Serhiy Storchaka | 1b80e63 | 2013-10-13 17:55:07 +0300 | [diff] [blame] | 1 | from test.support import findfile, TESTFN, unlink |
R. David Murray | b507d2e | 2009-04-29 15:34:32 +0000 | [diff] [blame] | 2 | import unittest |
Serhiy Storchaka | 1b80e63 | 2013-10-13 17:55:07 +0300 | [diff] [blame] | 3 | from test import audiotests |
Serhiy Storchaka | 3062c9a | 2013-11-23 22:26:01 +0200 | [diff] [blame] | 4 | from audioop import byteswap |
R. David Murray | eb01a6c | 2009-04-29 20:40:42 +0000 | [diff] [blame] | 5 | import os |
Sandro Tosi | bdd5354 | 2012-01-01 18:04:37 +0100 | [diff] [blame] | 6 | import io |
Serhiy Storchaka | 1b80e63 | 2013-10-13 17:55:07 +0300 | [diff] [blame] | 7 | import sys |
Ezio Melotti | 8576953 | 2012-03-12 23:52:40 +0200 | [diff] [blame] | 8 | import struct |
R. David Murray | b507d2e | 2009-04-29 15:34:32 +0000 | [diff] [blame] | 9 | import aifc |
| 10 | |
| 11 | |
Serhiy Storchaka | 7714ebb | 2013-11-16 13:04:00 +0200 | [diff] [blame] | 12 | class AifcTest(audiotests.AudioWriteTests, |
| 13 | audiotests.AudioTestsWithSourceFile): |
Serhiy Storchaka | 1b80e63 | 2013-10-13 17:55:07 +0300 | [diff] [blame] | 14 | module = aifc |
Serhiy Storchaka | 7714ebb | 2013-11-16 13:04:00 +0200 | [diff] [blame] | 15 | close_fd = True |
| 16 | test_unseekable_read = None |
Serhiy Storchaka | 7714ebb | 2013-11-16 13:04:00 +0200 | [diff] [blame] | 17 | |
| 18 | |
| 19 | class AifcPCM8Test(AifcTest, unittest.TestCase): |
Serhiy Storchaka | 1b80e63 | 2013-10-13 17:55:07 +0300 | [diff] [blame] | 20 | sndfilename = 'pluck-pcm8.aiff' |
| 21 | sndfilenframes = 3307 |
| 22 | nchannels = 2 |
| 23 | sampwidth = 1 |
| 24 | framerate = 11025 |
| 25 | nframes = 48 |
| 26 | comptype = b'NONE' |
| 27 | compname = b'not compressed' |
| 28 | frames = bytes.fromhex("""\ |
| 29 | 02FF 4B00 3104 8008 CB06 4803 BF01 03FE B8FA B4F3 29EB 1AE6 \ |
| 30 | EDE4 C6E2 0EE0 EFE0 57E2 FBE8 13EF D8F7 97FB F5FC 08FB DFFB \ |
| 31 | 11FA 3EFB BCFC 66FF CF04 4309 C10E 5112 EE17 8216 7F14 8012 \ |
| 32 | 490E 520D EF0F CE0F E40C 630A 080A 2B0B 510E 8B11 B60E 440A \ |
| 33 | """) |
R. David Murray | b507d2e | 2009-04-29 15:34:32 +0000 | [diff] [blame] | 34 | |
R. David Murray | b507d2e | 2009-04-29 15:34:32 +0000 | [diff] [blame] | 35 | |
Serhiy Storchaka | 7714ebb | 2013-11-16 13:04:00 +0200 | [diff] [blame] | 36 | class AifcPCM16Test(AifcTest, unittest.TestCase): |
Serhiy Storchaka | 1b80e63 | 2013-10-13 17:55:07 +0300 | [diff] [blame] | 37 | sndfilename = 'pluck-pcm16.aiff' |
| 38 | sndfilenframes = 3307 |
| 39 | nchannels = 2 |
| 40 | sampwidth = 2 |
| 41 | framerate = 11025 |
| 42 | nframes = 48 |
| 43 | comptype = b'NONE' |
| 44 | compname = b'not compressed' |
| 45 | frames = bytes.fromhex("""\ |
| 46 | 022EFFEA 4B5D00F6 311804EA 80E10840 CBE106B1 48A903F5 BFE601B2 036CFE7B \ |
| 47 | B858FA3E B4B1F34F 299AEBCA 1A5DE6DA EDFAE491 C628E275 0E09E0B5 EF2AE029 \ |
| 48 | 5758E271 FB35E83F 1376EF86 D82BF727 9790FB76 F5FAFC0F 0867FB9C DF30FB43 \ |
| 49 | 117EFA36 3EE5FB5B BC79FCB1 66D9FF5D CF150412 431D097C C1BA0EC8 512112A1 \ |
| 50 | EEE21753 82071665 7FFF1443 8004128F 49A20EAF 52BB0DBA EFB40F60 CE3C0FBF \ |
| 51 | E4B30CEC 63430A5C 08C80A20 2BBB0B08 514A0E43 8BCF1139 B6F60EEB 44120A5E \ |
| 52 | """) |
R. David Murray | eb01a6c | 2009-04-29 20:40:42 +0000 | [diff] [blame] | 53 | |
Serhiy Storchaka | 1b80e63 | 2013-10-13 17:55:07 +0300 | [diff] [blame] | 54 | |
Serhiy Storchaka | 7714ebb | 2013-11-16 13:04:00 +0200 | [diff] [blame] | 55 | class AifcPCM24Test(AifcTest, unittest.TestCase): |
Serhiy Storchaka | 1b80e63 | 2013-10-13 17:55:07 +0300 | [diff] [blame] | 56 | sndfilename = 'pluck-pcm24.aiff' |
| 57 | sndfilenframes = 3307 |
| 58 | nchannels = 2 |
| 59 | sampwidth = 3 |
| 60 | framerate = 11025 |
| 61 | nframes = 48 |
| 62 | comptype = b'NONE' |
| 63 | compname = b'not compressed' |
| 64 | frames = bytes.fromhex("""\ |
| 65 | 022D65FFEB9D 4B5A0F00FA54 3113C304EE2B 80DCD6084303 \ |
| 66 | CBDEC006B261 48A99803F2F8 BFE82401B07D 036BFBFE7B5D \ |
| 67 | B85756FA3EC9 B4B055F3502B 299830EBCB62 1A5CA7E6D99A \ |
| 68 | EDFA3EE491BD C625EBE27884 0E05A9E0B6CF EF2929E02922 \ |
| 69 | 5758D8E27067 FB3557E83E16 1377BFEF8402 D82C5BF7272A \ |
| 70 | 978F16FB7745 F5F865FC1013 086635FB9C4E DF30FCFB40EE \ |
| 71 | 117FE0FA3438 3EE6B8FB5AC3 BC77A3FCB2F4 66D6DAFF5F32 \ |
| 72 | CF13B9041275 431D69097A8C C1BB600EC74E 5120B912A2BA \ |
| 73 | EEDF641754C0 8207001664B7 7FFFFF14453F 8000001294E6 \ |
| 74 | 499C1B0EB3B2 52B73E0DBCA0 EFB2B20F5FD8 CE3CDB0FBE12 \ |
| 75 | E4B49C0CEA2D 6344A80A5A7C 08C8FE0A1FFE 2BB9860B0A0E \ |
| 76 | 51486F0E44E1 8BCC64113B05 B6F4EC0EEB36 4413170A5B48 \ |
| 77 | """) |
Serhiy Storchaka | 1b80e63 | 2013-10-13 17:55:07 +0300 | [diff] [blame] | 78 | |
| 79 | |
Serhiy Storchaka | 7714ebb | 2013-11-16 13:04:00 +0200 | [diff] [blame] | 80 | class AifcPCM32Test(AifcTest, unittest.TestCase): |
Serhiy Storchaka | 1b80e63 | 2013-10-13 17:55:07 +0300 | [diff] [blame] | 81 | sndfilename = 'pluck-pcm32.aiff' |
| 82 | sndfilenframes = 3307 |
| 83 | nchannels = 2 |
| 84 | sampwidth = 4 |
| 85 | framerate = 11025 |
| 86 | nframes = 48 |
| 87 | comptype = b'NONE' |
| 88 | compname = b'not compressed' |
| 89 | frames = bytes.fromhex("""\ |
| 90 | 022D65BCFFEB9D92 4B5A0F8000FA549C 3113C34004EE2BC0 80DCD680084303E0 \ |
| 91 | CBDEC0C006B26140 48A9980003F2F8FC BFE8248001B07D92 036BFB60FE7B5D34 \ |
| 92 | B8575600FA3EC920 B4B05500F3502BC0 29983000EBCB6240 1A5CA7A0E6D99A60 \ |
| 93 | EDFA3E80E491BD40 C625EB80E27884A0 0E05A9A0E0B6CFE0 EF292940E0292280 \ |
| 94 | 5758D800E2706700 FB3557D8E83E1640 1377BF00EF840280 D82C5B80F7272A80 \ |
| 95 | 978F1600FB774560 F5F86510FC101364 086635A0FB9C4E20 DF30FC40FB40EE28 \ |
| 96 | 117FE0A0FA3438B0 3EE6B840FB5AC3F0 BC77A380FCB2F454 66D6DA80FF5F32B4 \ |
| 97 | CF13B980041275B0 431D6980097A8C00 C1BB60000EC74E00 5120B98012A2BAA0 \ |
| 98 | EEDF64C01754C060 820700001664B780 7FFFFFFF14453F40 800000001294E6E0 \ |
| 99 | 499C1B000EB3B270 52B73E000DBCA020 EFB2B2E00F5FD880 CE3CDB400FBE1270 \ |
| 100 | E4B49CC00CEA2D90 6344A8800A5A7CA0 08C8FE800A1FFEE0 2BB986C00B0A0E00 \ |
| 101 | 51486F800E44E190 8BCC6480113B0580 B6F4EC000EEB3630 441317800A5B48A0 \ |
| 102 | """) |
Serhiy Storchaka | 1b80e63 | 2013-10-13 17:55:07 +0300 | [diff] [blame] | 103 | |
| 104 | |
Serhiy Storchaka | 7714ebb | 2013-11-16 13:04:00 +0200 | [diff] [blame] | 105 | class AifcULAWTest(AifcTest, unittest.TestCase): |
Serhiy Storchaka | 1b80e63 | 2013-10-13 17:55:07 +0300 | [diff] [blame] | 106 | sndfilename = 'pluck-ulaw.aifc' |
| 107 | sndfilenframes = 3307 |
| 108 | nchannels = 2 |
| 109 | sampwidth = 2 |
| 110 | framerate = 11025 |
| 111 | nframes = 48 |
| 112 | comptype = b'ulaw' |
| 113 | compname = b'' |
| 114 | frames = bytes.fromhex("""\ |
| 115 | 022CFFE8 497C0104 307C04DC 8284083C CB84069C 497C03DC BE8401AC 036CFE74 \ |
| 116 | B684FA24 B684F344 2A7CEC04 19FCE704 EE04E504 C584E204 0E3CE104 EF04DF84 \ |
| 117 | 557CE204 FB24E804 12FCEF04 D784F744 9684FB64 F5C4FC24 083CFBA4 DF84FB24 \ |
| 118 | 11FCFA24 3E7CFB64 BA84FCB4 657CFF5C CF84041C 417C093C C1840EBC 517C12FC \ |
| 119 | EF0416FC 828415FC 7D7C13FC 828412FC 497C0EBC 517C0DBC F0040F3C CD840FFC \ |
| 120 | E5040CBC 617C0A3C 08BC0A3C 2C7C0B3C 517C0E3C 8A8410FC B6840EBC 457C0A3C \ |
| 121 | """) |
| 122 | if sys.byteorder != 'big': |
Serhiy Storchaka | 3062c9a | 2013-11-23 22:26:01 +0200 | [diff] [blame] | 123 | frames = byteswap(frames, 2) |
Serhiy Storchaka | 1b80e63 | 2013-10-13 17:55:07 +0300 | [diff] [blame] | 124 | |
| 125 | |
Serhiy Storchaka | 7714ebb | 2013-11-16 13:04:00 +0200 | [diff] [blame] | 126 | class AifcALAWTest(AifcTest, unittest.TestCase): |
Serhiy Storchaka | 1b80e63 | 2013-10-13 17:55:07 +0300 | [diff] [blame] | 127 | sndfilename = 'pluck-alaw.aifc' |
| 128 | sndfilenframes = 3307 |
| 129 | nchannels = 2 |
| 130 | sampwidth = 2 |
| 131 | framerate = 11025 |
| 132 | nframes = 48 |
| 133 | comptype = b'alaw' |
| 134 | compname = b'' |
| 135 | frames = bytes.fromhex("""\ |
| 136 | 0230FFE8 4A0000F8 310004E0 82000840 CB0006A0 4A0003F0 BE0001A8 0370FE78 \ |
| 137 | BA00FA20 B600F340 2900EB80 1A80E680 ED80E480 C700E280 0E40E080 EF80E080 \ |
| 138 | 5600E280 FB20E880 1380EF80 D900F740 9600FB60 F5C0FC10 0840FBA0 DF00FB20 \ |
| 139 | 1180FA20 3F00FB60 BE00FCB0 6600FF58 CF000420 42000940 C1000EC0 52001280 \ |
| 140 | EE801780 82001680 7E001480 82001280 4A000EC0 52000DC0 EF800F40 CF000FC0 \ |
| 141 | E4800CC0 62000A40 08C00A40 2B000B40 52000E40 8A001180 B6000EC0 46000A40 \ |
| 142 | """) |
| 143 | if sys.byteorder != 'big': |
Serhiy Storchaka | 3062c9a | 2013-11-23 22:26:01 +0200 | [diff] [blame] | 144 | frames = byteswap(frames, 2) |
Serhiy Storchaka | 1b80e63 | 2013-10-13 17:55:07 +0300 | [diff] [blame] | 145 | |
| 146 | |
| 147 | class AifcMiscTest(audiotests.AudioTests, unittest.TestCase): |
R. David Murray | b507d2e | 2009-04-29 15:34:32 +0000 | [diff] [blame] | 148 | def test_skipunknown(self): |
| 149 | #Issue 2245 |
| 150 | #This file contains chunk types aifc doesn't recognize. |
Serhiy Storchaka | 1b80e63 | 2013-10-13 17:55:07 +0300 | [diff] [blame] | 151 | self.f = aifc.open(findfile('Sine-1000Hz-300ms.aif')) |
R David Murray | 4d35e75 | 2013-07-25 16:12:01 -0400 | [diff] [blame] | 152 | |
| 153 | def test_params_added(self): |
| 154 | f = self.f = aifc.open(TESTFN, 'wb') |
| 155 | f.aiff() |
| 156 | f.setparams((1, 1, 1, 1, b'NONE', b'')) |
| 157 | f.close() |
| 158 | |
| 159 | f = self.f = aifc.open(TESTFN, 'rb') |
| 160 | params = f.getparams() |
| 161 | self.assertEqual(params.nchannels, f.getnchannels()) |
| 162 | self.assertEqual(params.sampwidth, f.getsampwidth()) |
| 163 | self.assertEqual(params.framerate, f.getframerate()) |
| 164 | self.assertEqual(params.nframes, f.getnframes()) |
| 165 | self.assertEqual(params.comptype, f.getcomptype()) |
| 166 | self.assertEqual(params.compname, f.getcompname()) |
| 167 | |
Sandro Tosi | bdd5354 | 2012-01-01 18:04:37 +0100 | [diff] [blame] | 168 | def test_write_header_comptype_sampwidth(self): |
| 169 | for comptype in (b'ULAW', b'ulaw', b'ALAW', b'alaw', b'G722'): |
Ezio Melotti | 8576953 | 2012-03-12 23:52:40 +0200 | [diff] [blame] | 170 | fout = aifc.open(io.BytesIO(), 'wb') |
Sandro Tosi | bdd5354 | 2012-01-01 18:04:37 +0100 | [diff] [blame] | 171 | fout.setnchannels(1) |
| 172 | fout.setframerate(1) |
| 173 | fout.setcomptype(comptype, b'') |
| 174 | fout.close() |
| 175 | self.assertEqual(fout.getsampwidth(), 2) |
| 176 | fout.initfp(None) |
| 177 | |
Sandro Tosi | 70efbef | 2012-01-01 22:53:08 +0100 | [diff] [blame] | 178 | def test_write_markers_values(self): |
Ezio Melotti | 8576953 | 2012-03-12 23:52:40 +0200 | [diff] [blame] | 179 | fout = aifc.open(io.BytesIO(), 'wb') |
Sandro Tosi | 70efbef | 2012-01-01 22:53:08 +0100 | [diff] [blame] | 180 | self.assertEqual(fout.getmarkers(), None) |
| 181 | fout.setmark(1, 0, b'foo1') |
| 182 | fout.setmark(1, 1, b'foo2') |
| 183 | self.assertEqual(fout.getmark(1), (1, 1, b'foo2')) |
| 184 | self.assertEqual(fout.getmarkers(), [(1, 1, b'foo2')]) |
| 185 | fout.initfp(None) |
| 186 | |
| 187 | def test_read_markers(self): |
| 188 | fout = self.fout = aifc.open(TESTFN, 'wb') |
| 189 | fout.aiff() |
| 190 | fout.setparams((1, 1, 1, 1, b'NONE', b'')) |
| 191 | fout.setmark(1, 0, b'odd') |
| 192 | fout.setmark(2, 0, b'even') |
| 193 | fout.writeframes(b'\x00') |
| 194 | fout.close() |
| 195 | f = self.f = aifc.open(TESTFN, 'rb') |
| 196 | self.assertEqual(f.getmarkers(), [(1, 0, b'odd'), (2, 0, b'even')]) |
| 197 | self.assertEqual(f.getmark(1), (1, 0, b'odd')) |
| 198 | self.assertEqual(f.getmark(2), (2, 0, b'even')) |
| 199 | self.assertRaises(aifc.Error, f.getmark, 3) |
| 200 | |
R. David Murray | b507d2e | 2009-04-29 15:34:32 +0000 | [diff] [blame] | 201 | |
Antoine Pitrou | 03757ec | 2012-01-17 17:13:04 +0100 | [diff] [blame] | 202 | class AIFCLowLevelTest(unittest.TestCase): |
| 203 | |
| 204 | def test_read_written(self): |
| 205 | def read_written(self, what): |
| 206 | f = io.BytesIO() |
| 207 | getattr(aifc, '_write_' + what)(f, x) |
| 208 | f.seek(0) |
| 209 | return getattr(aifc, '_read_' + what)(f) |
| 210 | for x in (-1, 0, 0.1, 1): |
| 211 | self.assertEqual(read_written(x, 'float'), x) |
| 212 | for x in (float('NaN'), float('Inf')): |
| 213 | self.assertEqual(read_written(x, 'float'), aifc._HUGE_VAL) |
| 214 | for x in (b'', b'foo', b'a' * 255): |
| 215 | self.assertEqual(read_written(x, 'string'), x) |
| 216 | for x in (-0x7FFFFFFF, -1, 0, 1, 0x7FFFFFFF): |
| 217 | self.assertEqual(read_written(x, 'long'), x) |
| 218 | for x in (0, 1, 0xFFFFFFFF): |
| 219 | self.assertEqual(read_written(x, 'ulong'), x) |
| 220 | for x in (-0x7FFF, -1, 0, 1, 0x7FFF): |
| 221 | self.assertEqual(read_written(x, 'short'), x) |
| 222 | for x in (0, 1, 0xFFFF): |
| 223 | self.assertEqual(read_written(x, 'ushort'), x) |
| 224 | |
| 225 | def test_read_raises(self): |
| 226 | f = io.BytesIO(b'\x00') |
| 227 | self.assertRaises(EOFError, aifc._read_ulong, f) |
| 228 | self.assertRaises(EOFError, aifc._read_long, f) |
| 229 | self.assertRaises(EOFError, aifc._read_ushort, f) |
| 230 | self.assertRaises(EOFError, aifc._read_short, f) |
| 231 | |
| 232 | def test_write_long_string_raises(self): |
| 233 | f = io.BytesIO() |
| 234 | with self.assertRaises(ValueError): |
| 235 | aifc._write_string(f, b'too long' * 255) |
| 236 | |
Ezio Melotti | 8576953 | 2012-03-12 23:52:40 +0200 | [diff] [blame] | 237 | def test_wrong_open_mode(self): |
| 238 | with self.assertRaises(aifc.Error): |
| 239 | aifc.open(TESTFN, 'wrong_mode') |
| 240 | |
| 241 | def test_read_wrong_form(self): |
| 242 | b1 = io.BytesIO(b'WRNG' + struct.pack('>L', 0)) |
| 243 | b2 = io.BytesIO(b'FORM' + struct.pack('>L', 4) + b'WRNG') |
| 244 | self.assertRaises(aifc.Error, aifc.open, b1) |
| 245 | self.assertRaises(aifc.Error, aifc.open, b2) |
| 246 | |
| 247 | def test_read_no_comm_chunk(self): |
| 248 | b = io.BytesIO(b'FORM' + struct.pack('>L', 4) + b'AIFF') |
| 249 | self.assertRaises(aifc.Error, aifc.open, b) |
| 250 | |
| 251 | def test_read_wrong_compression_type(self): |
| 252 | b = b'FORM' + struct.pack('>L', 4) + b'AIFC' |
| 253 | b += b'COMM' + struct.pack('>LhlhhLL', 23, 0, 0, 0, 0, 0, 0) |
| 254 | b += b'WRNG' + struct.pack('B', 0) |
| 255 | self.assertRaises(aifc.Error, aifc.open, io.BytesIO(b)) |
| 256 | |
| 257 | def test_read_wrong_marks(self): |
| 258 | b = b'FORM' + struct.pack('>L', 4) + b'AIFF' |
| 259 | b += b'COMM' + struct.pack('>LhlhhLL', 18, 0, 0, 0, 0, 0, 0) |
| 260 | b += b'SSND' + struct.pack('>L', 8) + b'\x00' * 8 |
| 261 | b += b'MARK' + struct.pack('>LhB', 3, 1, 1) |
Serhiy Storchaka | 4606d36 | 2013-10-14 20:05:33 +0300 | [diff] [blame] | 262 | with self.assertWarns(UserWarning) as cm: |
Ezio Melotti | 8576953 | 2012-03-12 23:52:40 +0200 | [diff] [blame] | 263 | f = aifc.open(io.BytesIO(b)) |
Serhiy Storchaka | 4606d36 | 2013-10-14 20:05:33 +0300 | [diff] [blame] | 264 | self.assertEqual(str(cm.warning), 'Warning: MARK chunk contains ' |
| 265 | 'only 0 markers instead of 1') |
Ezio Melotti | 8576953 | 2012-03-12 23:52:40 +0200 | [diff] [blame] | 266 | self.assertEqual(f.getmarkers(), None) |
| 267 | |
| 268 | def test_read_comm_kludge_compname_even(self): |
| 269 | b = b'FORM' + struct.pack('>L', 4) + b'AIFC' |
| 270 | b += b'COMM' + struct.pack('>LhlhhLL', 18, 0, 0, 0, 0, 0, 0) |
| 271 | b += b'NONE' + struct.pack('B', 4) + b'even' + b'\x00' |
| 272 | b += b'SSND' + struct.pack('>L', 8) + b'\x00' * 8 |
Serhiy Storchaka | 4606d36 | 2013-10-14 20:05:33 +0300 | [diff] [blame] | 273 | with self.assertWarns(UserWarning) as cm: |
Ezio Melotti | 8576953 | 2012-03-12 23:52:40 +0200 | [diff] [blame] | 274 | f = aifc.open(io.BytesIO(b)) |
Serhiy Storchaka | 4606d36 | 2013-10-14 20:05:33 +0300 | [diff] [blame] | 275 | self.assertEqual(str(cm.warning), 'Warning: bad COMM chunk size') |
Ezio Melotti | 8576953 | 2012-03-12 23:52:40 +0200 | [diff] [blame] | 276 | self.assertEqual(f.getcompname(), b'even') |
| 277 | |
| 278 | def test_read_comm_kludge_compname_odd(self): |
| 279 | b = b'FORM' + struct.pack('>L', 4) + b'AIFC' |
| 280 | b += b'COMM' + struct.pack('>LhlhhLL', 18, 0, 0, 0, 0, 0, 0) |
| 281 | b += b'NONE' + struct.pack('B', 3) + b'odd' |
| 282 | b += b'SSND' + struct.pack('>L', 8) + b'\x00' * 8 |
Serhiy Storchaka | 4606d36 | 2013-10-14 20:05:33 +0300 | [diff] [blame] | 283 | with self.assertWarns(UserWarning) as cm: |
Ezio Melotti | 8576953 | 2012-03-12 23:52:40 +0200 | [diff] [blame] | 284 | f = aifc.open(io.BytesIO(b)) |
Serhiy Storchaka | 4606d36 | 2013-10-14 20:05:33 +0300 | [diff] [blame] | 285 | self.assertEqual(str(cm.warning), 'Warning: bad COMM chunk size') |
Ezio Melotti | 8576953 | 2012-03-12 23:52:40 +0200 | [diff] [blame] | 286 | self.assertEqual(f.getcompname(), b'odd') |
| 287 | |
| 288 | def test_write_params_raises(self): |
| 289 | fout = aifc.open(io.BytesIO(), 'wb') |
| 290 | wrong_params = (0, 0, 0, 0, b'WRNG', '') |
| 291 | self.assertRaises(aifc.Error, fout.setparams, wrong_params) |
| 292 | self.assertRaises(aifc.Error, fout.getparams) |
| 293 | self.assertRaises(aifc.Error, fout.setnchannels, 0) |
| 294 | self.assertRaises(aifc.Error, fout.getnchannels) |
| 295 | self.assertRaises(aifc.Error, fout.setsampwidth, 0) |
| 296 | self.assertRaises(aifc.Error, fout.getsampwidth) |
| 297 | self.assertRaises(aifc.Error, fout.setframerate, 0) |
| 298 | self.assertRaises(aifc.Error, fout.getframerate) |
| 299 | self.assertRaises(aifc.Error, fout.setcomptype, b'WRNG', '') |
| 300 | fout.aiff() |
| 301 | fout.setnchannels(1) |
| 302 | fout.setsampwidth(1) |
| 303 | fout.setframerate(1) |
| 304 | fout.setnframes(1) |
| 305 | fout.writeframes(b'\x00') |
| 306 | self.assertRaises(aifc.Error, fout.setparams, (1, 1, 1, 1, 1, 1)) |
| 307 | self.assertRaises(aifc.Error, fout.setnchannels, 1) |
| 308 | self.assertRaises(aifc.Error, fout.setsampwidth, 1) |
| 309 | self.assertRaises(aifc.Error, fout.setframerate, 1) |
| 310 | self.assertRaises(aifc.Error, fout.setnframes, 1) |
| 311 | self.assertRaises(aifc.Error, fout.setcomptype, b'NONE', '') |
| 312 | self.assertRaises(aifc.Error, fout.aiff) |
| 313 | self.assertRaises(aifc.Error, fout.aifc) |
| 314 | |
| 315 | def test_write_params_singles(self): |
| 316 | fout = aifc.open(io.BytesIO(), 'wb') |
| 317 | fout.aifc() |
| 318 | fout.setnchannels(1) |
| 319 | fout.setsampwidth(2) |
| 320 | fout.setframerate(3) |
| 321 | fout.setnframes(4) |
| 322 | fout.setcomptype(b'NONE', b'name') |
| 323 | self.assertEqual(fout.getnchannels(), 1) |
| 324 | self.assertEqual(fout.getsampwidth(), 2) |
| 325 | self.assertEqual(fout.getframerate(), 3) |
| 326 | self.assertEqual(fout.getnframes(), 0) |
| 327 | self.assertEqual(fout.tell(), 0) |
| 328 | self.assertEqual(fout.getcomptype(), b'NONE') |
| 329 | self.assertEqual(fout.getcompname(), b'name') |
| 330 | fout.writeframes(b'\x00' * 4 * fout.getsampwidth() * fout.getnchannels()) |
| 331 | self.assertEqual(fout.getnframes(), 4) |
| 332 | self.assertEqual(fout.tell(), 4) |
| 333 | |
| 334 | def test_write_params_bunch(self): |
| 335 | fout = aifc.open(io.BytesIO(), 'wb') |
| 336 | fout.aifc() |
| 337 | p = (1, 2, 3, 4, b'NONE', b'name') |
| 338 | fout.setparams(p) |
| 339 | self.assertEqual(fout.getparams(), p) |
| 340 | fout.initfp(None) |
| 341 | |
| 342 | def test_write_header_raises(self): |
| 343 | fout = aifc.open(io.BytesIO(), 'wb') |
| 344 | self.assertRaises(aifc.Error, fout.close) |
Serhiy Storchaka | 051722d | 2012-12-29 22:30:56 +0200 | [diff] [blame] | 345 | fout = aifc.open(io.BytesIO(), 'wb') |
Ezio Melotti | 8576953 | 2012-03-12 23:52:40 +0200 | [diff] [blame] | 346 | fout.setnchannels(1) |
| 347 | self.assertRaises(aifc.Error, fout.close) |
Serhiy Storchaka | 051722d | 2012-12-29 22:30:56 +0200 | [diff] [blame] | 348 | fout = aifc.open(io.BytesIO(), 'wb') |
| 349 | fout.setnchannels(1) |
Ezio Melotti | 8576953 | 2012-03-12 23:52:40 +0200 | [diff] [blame] | 350 | fout.setsampwidth(1) |
| 351 | self.assertRaises(aifc.Error, fout.close) |
Ezio Melotti | 8576953 | 2012-03-12 23:52:40 +0200 | [diff] [blame] | 352 | |
| 353 | def test_write_header_comptype_raises(self): |
| 354 | for comptype in (b'ULAW', b'ulaw', b'ALAW', b'alaw', b'G722'): |
| 355 | fout = aifc.open(io.BytesIO(), 'wb') |
| 356 | fout.setsampwidth(1) |
| 357 | fout.setcomptype(comptype, b'') |
| 358 | self.assertRaises(aifc.Error, fout.close) |
| 359 | fout.initfp(None) |
| 360 | |
| 361 | def test_write_markers_raises(self): |
| 362 | fout = aifc.open(io.BytesIO(), 'wb') |
| 363 | self.assertRaises(aifc.Error, fout.setmark, 0, 0, b'') |
| 364 | self.assertRaises(aifc.Error, fout.setmark, 1, -1, b'') |
| 365 | self.assertRaises(aifc.Error, fout.setmark, 1, 0, None) |
| 366 | self.assertRaises(aifc.Error, fout.getmark, 1) |
| 367 | fout.initfp(None) |
| 368 | |
| 369 | def test_write_aiff_by_extension(self): |
| 370 | sampwidth = 2 |
Ezio Melotti | 4b843a7 | 2013-03-01 21:10:26 +0200 | [diff] [blame] | 371 | filename = TESTFN + '.aiff' |
| 372 | fout = self.fout = aifc.open(filename, 'wb') |
| 373 | self.addCleanup(unlink, filename) |
Ezio Melotti | 8576953 | 2012-03-12 23:52:40 +0200 | [diff] [blame] | 374 | fout.setparams((1, sampwidth, 1, 1, b'ULAW', b'')) |
| 375 | frames = b'\x00' * fout.getnchannels() * sampwidth |
| 376 | fout.writeframes(frames) |
| 377 | fout.close() |
Ezio Melotti | 4b843a7 | 2013-03-01 21:10:26 +0200 | [diff] [blame] | 378 | f = self.f = aifc.open(filename, 'rb') |
Ezio Melotti | 8576953 | 2012-03-12 23:52:40 +0200 | [diff] [blame] | 379 | self.assertEqual(f.getcomptype(), b'NONE') |
| 380 | f.close() |
| 381 | |
Antoine Pitrou | 03757ec | 2012-01-17 17:13:04 +0100 | [diff] [blame] | 382 | |
R. David Murray | b507d2e | 2009-04-29 15:34:32 +0000 | [diff] [blame] | 383 | if __name__ == "__main__": |
| 384 | unittest.main() |