1 import sys
2 from test.support import warnings_helper
3 import unittest
4
5 audioop = warnings_helper.import_deprecated("audioop")
6
7
8 def pack(width, data):
9 return b''.join(v.to_bytes(width, sys.byteorder, signed=True) for v in data)
10
11 def unpack(width, data):
12 return [int.from_bytes(data[i: i + width], sys.byteorder, signed=True)
13 for i in range(0, len(data), width)]
14
15 packs = {w: (lambda *data, width=w: pack(width, data)) for w in (1, 2, 3, 4)}
16 maxvalues = {w: (1 << (8 * w - 1)) - 1 for w in (1, 2, 3, 4)}
17 minvalues = {w: -1 << (8 * w - 1) for w in (1, 2, 3, 4)}
18
19 datas = {
20 1: b'\x00\x12\x45\xbb\x7f\x80\xff',
21 2: packs[2](0, 0x1234, 0x4567, -0x4567, 0x7fff, -0x8000, -1),
22 3: packs[3](0, 0x123456, 0x456789, -0x456789, 0x7fffff, -0x800000, -1),
23 4: packs[4](0, 0x12345678, 0x456789ab, -0x456789ab,
24 0x7fffffff, -0x80000000, -1),
25 }
26
27 INVALID_DATA = [
28 (b'abc', 0),
29 (b'abc', 2),
30 (b'ab', 3),
31 (b'abc', 4),
32 ]
33
34
35 class ESC[4;38;5;81mTestAudioop(ESC[4;38;5;149munittestESC[4;38;5;149m.ESC[4;38;5;149mTestCase):
36
37 def test_max(self):
38 for w in 1, 2, 3, 4:
39 self.assertEqual(audioop.max(b'', w), 0)
40 self.assertEqual(audioop.max(bytearray(), w), 0)
41 self.assertEqual(audioop.max(memoryview(b''), w), 0)
42 p = packs[w]
43 self.assertEqual(audioop.max(p(5), w), 5)
44 self.assertEqual(audioop.max(p(5, -8, -1), w), 8)
45 self.assertEqual(audioop.max(p(maxvalues[w]), w), maxvalues[w])
46 self.assertEqual(audioop.max(p(minvalues[w]), w), -minvalues[w])
47 self.assertEqual(audioop.max(datas[w], w), -minvalues[w])
48
49 def test_minmax(self):
50 for w in 1, 2, 3, 4:
51 self.assertEqual(audioop.minmax(b'', w),
52 (0x7fffffff, -0x80000000))
53 self.assertEqual(audioop.minmax(bytearray(), w),
54 (0x7fffffff, -0x80000000))
55 self.assertEqual(audioop.minmax(memoryview(b''), w),
56 (0x7fffffff, -0x80000000))
57 p = packs[w]
58 self.assertEqual(audioop.minmax(p(5), w), (5, 5))
59 self.assertEqual(audioop.minmax(p(5, -8, -1), w), (-8, 5))
60 self.assertEqual(audioop.minmax(p(maxvalues[w]), w),
61 (maxvalues[w], maxvalues[w]))
62 self.assertEqual(audioop.minmax(p(minvalues[w]), w),
63 (minvalues[w], minvalues[w]))
64 self.assertEqual(audioop.minmax(datas[w], w),
65 (minvalues[w], maxvalues[w]))
66
67 def test_maxpp(self):
68 for w in 1, 2, 3, 4:
69 self.assertEqual(audioop.maxpp(b'', w), 0)
70 self.assertEqual(audioop.maxpp(bytearray(), w), 0)
71 self.assertEqual(audioop.maxpp(memoryview(b''), w), 0)
72 self.assertEqual(audioop.maxpp(packs[w](*range(100)), w), 0)
73 self.assertEqual(audioop.maxpp(packs[w](9, 10, 5, 5, 0, 1), w), 10)
74 self.assertEqual(audioop.maxpp(datas[w], w),
75 maxvalues[w] - minvalues[w])
76
77 def test_avg(self):
78 for w in 1, 2, 3, 4:
79 self.assertEqual(audioop.avg(b'', w), 0)
80 self.assertEqual(audioop.avg(bytearray(), w), 0)
81 self.assertEqual(audioop.avg(memoryview(b''), w), 0)
82 p = packs[w]
83 self.assertEqual(audioop.avg(p(5), w), 5)
84 self .assertEqual(audioop.avg(p(5, 8), w), 6)
85 self.assertEqual(audioop.avg(p(5, -8), w), -2)
86 self.assertEqual(audioop.avg(p(maxvalues[w], maxvalues[w]), w),
87 maxvalues[w])
88 self.assertEqual(audioop.avg(p(minvalues[w], minvalues[w]), w),
89 minvalues[w])
90 self.assertEqual(audioop.avg(packs[4](0x50000000, 0x70000000), 4),
91 0x60000000)
92 self.assertEqual(audioop.avg(packs[4](-0x50000000, -0x70000000), 4),
93 -0x60000000)
94
95 def test_avgpp(self):
96 for w in 1, 2, 3, 4:
97 self.assertEqual(audioop.avgpp(b'', w), 0)
98 self.assertEqual(audioop.avgpp(bytearray(), w), 0)
99 self.assertEqual(audioop.avgpp(memoryview(b''), w), 0)
100 self.assertEqual(audioop.avgpp(packs[w](*range(100)), w), 0)
101 self.assertEqual(audioop.avgpp(packs[w](9, 10, 5, 5, 0, 1), w), 10)
102 self.assertEqual(audioop.avgpp(datas[1], 1), 196)
103 self.assertEqual(audioop.avgpp(datas[2], 2), 50534)
104 self.assertEqual(audioop.avgpp(datas[3], 3), 12937096)
105 self.assertEqual(audioop.avgpp(datas[4], 4), 3311897002)
106
107 def test_rms(self):
108 for w in 1, 2, 3, 4:
109 self.assertEqual(audioop.rms(b'', w), 0)
110 self.assertEqual(audioop.rms(bytearray(), w), 0)
111 self.assertEqual(audioop.rms(memoryview(b''), w), 0)
112 p = packs[w]
113 self.assertEqual(audioop.rms(p(*range(100)), w), 57)
114 self.assertAlmostEqual(audioop.rms(p(maxvalues[w]) * 5, w),
115 maxvalues[w], delta=1)
116 self.assertAlmostEqual(audioop.rms(p(minvalues[w]) * 5, w),
117 -minvalues[w], delta=1)
118 self.assertEqual(audioop.rms(datas[1], 1), 77)
119 self.assertEqual(audioop.rms(datas[2], 2), 20001)
120 self.assertEqual(audioop.rms(datas[3], 3), 5120523)
121 self.assertEqual(audioop.rms(datas[4], 4), 1310854152)
122
123 def test_cross(self):
124 for w in 1, 2, 3, 4:
125 self.assertEqual(audioop.cross(b'', w), -1)
126 self.assertEqual(audioop.cross(bytearray(), w), -1)
127 self.assertEqual(audioop.cross(memoryview(b''), w), -1)
128 p = packs[w]
129 self.assertEqual(audioop.cross(p(0, 1, 2), w), 0)
130 self.assertEqual(audioop.cross(p(1, 2, -3, -4), w), 1)
131 self.assertEqual(audioop.cross(p(-1, -2, 3, 4), w), 1)
132 self.assertEqual(audioop.cross(p(0, minvalues[w]), w), 1)
133 self.assertEqual(audioop.cross(p(minvalues[w], maxvalues[w]), w), 1)
134
135 def test_add(self):
136 for w in 1, 2, 3, 4:
137 self.assertEqual(audioop.add(b'', b'', w), b'')
138 self.assertEqual(audioop.add(bytearray(), bytearray(), w), b'')
139 self.assertEqual(audioop.add(memoryview(b''), memoryview(b''), w), b'')
140 self.assertEqual(audioop.add(datas[w], b'\0' * len(datas[w]), w),
141 datas[w])
142 self.assertEqual(audioop.add(datas[1], datas[1], 1),
143 b'\x00\x24\x7f\x80\x7f\x80\xfe')
144 self.assertEqual(audioop.add(datas[2], datas[2], 2),
145 packs[2](0, 0x2468, 0x7fff, -0x8000, 0x7fff, -0x8000, -2))
146 self.assertEqual(audioop.add(datas[3], datas[3], 3),
147 packs[3](0, 0x2468ac, 0x7fffff, -0x800000,
148 0x7fffff, -0x800000, -2))
149 self.assertEqual(audioop.add(datas[4], datas[4], 4),
150 packs[4](0, 0x2468acf0, 0x7fffffff, -0x80000000,
151 0x7fffffff, -0x80000000, -2))
152
153 def test_bias(self):
154 for w in 1, 2, 3, 4:
155 for bias in 0, 1, -1, 127, -128, 0x7fffffff, -0x80000000:
156 self.assertEqual(audioop.bias(b'', w, bias), b'')
157 self.assertEqual(audioop.bias(bytearray(), w, bias), b'')
158 self.assertEqual(audioop.bias(memoryview(b''), w, bias), b'')
159 self.assertEqual(audioop.bias(datas[1], 1, 1),
160 b'\x01\x13\x46\xbc\x80\x81\x00')
161 self.assertEqual(audioop.bias(datas[1], 1, -1),
162 b'\xff\x11\x44\xba\x7e\x7f\xfe')
163 self.assertEqual(audioop.bias(datas[1], 1, 0x7fffffff),
164 b'\xff\x11\x44\xba\x7e\x7f\xfe')
165 self.assertEqual(audioop.bias(datas[1], 1, -0x80000000),
166 datas[1])
167 self.assertEqual(audioop.bias(datas[2], 2, 1),
168 packs[2](1, 0x1235, 0x4568, -0x4566, -0x8000, -0x7fff, 0))
169 self.assertEqual(audioop.bias(datas[2], 2, -1),
170 packs[2](-1, 0x1233, 0x4566, -0x4568, 0x7ffe, 0x7fff, -2))
171 self.assertEqual(audioop.bias(datas[2], 2, 0x7fffffff),
172 packs[2](-1, 0x1233, 0x4566, -0x4568, 0x7ffe, 0x7fff, -2))
173 self.assertEqual(audioop.bias(datas[2], 2, -0x80000000),
174 datas[2])
175 self.assertEqual(audioop.bias(datas[3], 3, 1),
176 packs[3](1, 0x123457, 0x45678a, -0x456788,
177 -0x800000, -0x7fffff, 0))
178 self.assertEqual(audioop.bias(datas[3], 3, -1),
179 packs[3](-1, 0x123455, 0x456788, -0x45678a,
180 0x7ffffe, 0x7fffff, -2))
181 self.assertEqual(audioop.bias(datas[3], 3, 0x7fffffff),
182 packs[3](-1, 0x123455, 0x456788, -0x45678a,
183 0x7ffffe, 0x7fffff, -2))
184 self.assertEqual(audioop.bias(datas[3], 3, -0x80000000),
185 datas[3])
186 self.assertEqual(audioop.bias(datas[4], 4, 1),
187 packs[4](1, 0x12345679, 0x456789ac, -0x456789aa,
188 -0x80000000, -0x7fffffff, 0))
189 self.assertEqual(audioop.bias(datas[4], 4, -1),
190 packs[4](-1, 0x12345677, 0x456789aa, -0x456789ac,
191 0x7ffffffe, 0x7fffffff, -2))
192 self.assertEqual(audioop.bias(datas[4], 4, 0x7fffffff),
193 packs[4](0x7fffffff, -0x6dcba989, -0x3a987656, 0x3a987654,
194 -2, -1, 0x7ffffffe))
195 self.assertEqual(audioop.bias(datas[4], 4, -0x80000000),
196 packs[4](-0x80000000, -0x6dcba988, -0x3a987655, 0x3a987655,
197 -1, 0, 0x7fffffff))
198
199 def test_lin2lin(self):
200 for w in 1, 2, 3, 4:
201 self.assertEqual(audioop.lin2lin(datas[w], w, w), datas[w])
202 self.assertEqual(audioop.lin2lin(bytearray(datas[w]), w, w),
203 datas[w])
204 self.assertEqual(audioop.lin2lin(memoryview(datas[w]), w, w),
205 datas[w])
206
207 self.assertEqual(audioop.lin2lin(datas[1], 1, 2),
208 packs[2](0, 0x1200, 0x4500, -0x4500, 0x7f00, -0x8000, -0x100))
209 self.assertEqual(audioop.lin2lin(datas[1], 1, 3),
210 packs[3](0, 0x120000, 0x450000, -0x450000,
211 0x7f0000, -0x800000, -0x10000))
212 self.assertEqual(audioop.lin2lin(datas[1], 1, 4),
213 packs[4](0, 0x12000000, 0x45000000, -0x45000000,
214 0x7f000000, -0x80000000, -0x1000000))
215 self.assertEqual(audioop.lin2lin(datas[2], 2, 1),
216 b'\x00\x12\x45\xba\x7f\x80\xff')
217 self.assertEqual(audioop.lin2lin(datas[2], 2, 3),
218 packs[3](0, 0x123400, 0x456700, -0x456700,
219 0x7fff00, -0x800000, -0x100))
220 self.assertEqual(audioop.lin2lin(datas[2], 2, 4),
221 packs[4](0, 0x12340000, 0x45670000, -0x45670000,
222 0x7fff0000, -0x80000000, -0x10000))
223 self.assertEqual(audioop.lin2lin(datas[3], 3, 1),
224 b'\x00\x12\x45\xba\x7f\x80\xff')
225 self.assertEqual(audioop.lin2lin(datas[3], 3, 2),
226 packs[2](0, 0x1234, 0x4567, -0x4568, 0x7fff, -0x8000, -1))
227 self.assertEqual(audioop.lin2lin(datas[3], 3, 4),
228 packs[4](0, 0x12345600, 0x45678900, -0x45678900,
229 0x7fffff00, -0x80000000, -0x100))
230 self.assertEqual(audioop.lin2lin(datas[4], 4, 1),
231 b'\x00\x12\x45\xba\x7f\x80\xff')
232 self.assertEqual(audioop.lin2lin(datas[4], 4, 2),
233 packs[2](0, 0x1234, 0x4567, -0x4568, 0x7fff, -0x8000, -1))
234 self.assertEqual(audioop.lin2lin(datas[4], 4, 3),
235 packs[3](0, 0x123456, 0x456789, -0x45678a,
236 0x7fffff, -0x800000, -1))
237
238 def test_adpcm2lin(self):
239 self.assertEqual(audioop.adpcm2lin(b'\x07\x7f\x7f', 1, None),
240 (b'\x00\x00\x00\xff\x00\xff', (-179, 40)))
241 self.assertEqual(audioop.adpcm2lin(bytearray(b'\x07\x7f\x7f'), 1, None),
242 (b'\x00\x00\x00\xff\x00\xff', (-179, 40)))
243 self.assertEqual(audioop.adpcm2lin(memoryview(b'\x07\x7f\x7f'), 1, None),
244 (b'\x00\x00\x00\xff\x00\xff', (-179, 40)))
245 self.assertEqual(audioop.adpcm2lin(b'\x07\x7f\x7f', 2, None),
246 (packs[2](0, 0xb, 0x29, -0x16, 0x72, -0xb3), (-179, 40)))
247 self.assertEqual(audioop.adpcm2lin(b'\x07\x7f\x7f', 3, None),
248 (packs[3](0, 0xb00, 0x2900, -0x1600, 0x7200,
249 -0xb300), (-179, 40)))
250 self.assertEqual(audioop.adpcm2lin(b'\x07\x7f\x7f', 4, None),
251 (packs[4](0, 0xb0000, 0x290000, -0x160000, 0x720000,
252 -0xb30000), (-179, 40)))
253
254 # Very cursory test
255 for w in 1, 2, 3, 4:
256 self.assertEqual(audioop.adpcm2lin(b'\0' * 5, w, None),
257 (b'\0' * w * 10, (0, 0)))
258
259 def test_lin2adpcm(self):
260 self.assertEqual(audioop.lin2adpcm(datas[1], 1, None),
261 (b'\x07\x7f\x7f', (-221, 39)))
262 self.assertEqual(audioop.lin2adpcm(bytearray(datas[1]), 1, None),
263 (b'\x07\x7f\x7f', (-221, 39)))
264 self.assertEqual(audioop.lin2adpcm(memoryview(datas[1]), 1, None),
265 (b'\x07\x7f\x7f', (-221, 39)))
266 for w in 2, 3, 4:
267 self.assertEqual(audioop.lin2adpcm(datas[w], w, None),
268 (b'\x07\x7f\x7f', (31, 39)))
269
270 # Very cursory test
271 for w in 1, 2, 3, 4:
272 self.assertEqual(audioop.lin2adpcm(b'\0' * w * 10, w, None),
273 (b'\0' * 5, (0, 0)))
274
275 def test_invalid_adpcm_state(self):
276 # state must be a tuple or None, not an integer
277 self.assertRaises(TypeError, audioop.adpcm2lin, b'\0', 1, 555)
278 self.assertRaises(TypeError, audioop.lin2adpcm, b'\0', 1, 555)
279 # Issues #24456, #24457: index out of range
280 self.assertRaises(ValueError, audioop.adpcm2lin, b'\0', 1, (0, -1))
281 self.assertRaises(ValueError, audioop.adpcm2lin, b'\0', 1, (0, 89))
282 self.assertRaises(ValueError, audioop.lin2adpcm, b'\0', 1, (0, -1))
283 self.assertRaises(ValueError, audioop.lin2adpcm, b'\0', 1, (0, 89))
284 # value out of range
285 self.assertRaises(ValueError, audioop.adpcm2lin, b'\0', 1, (-0x8001, 0))
286 self.assertRaises(ValueError, audioop.adpcm2lin, b'\0', 1, (0x8000, 0))
287 self.assertRaises(ValueError, audioop.lin2adpcm, b'\0', 1, (-0x8001, 0))
288 self.assertRaises(ValueError, audioop.lin2adpcm, b'\0', 1, (0x8000, 0))
289
290 def test_lin2alaw(self):
291 self.assertEqual(audioop.lin2alaw(datas[1], 1),
292 b'\xd5\x87\xa4\x24\xaa\x2a\x5a')
293 self.assertEqual(audioop.lin2alaw(bytearray(datas[1]), 1),
294 b'\xd5\x87\xa4\x24\xaa\x2a\x5a')
295 self.assertEqual(audioop.lin2alaw(memoryview(datas[1]), 1),
296 b'\xd5\x87\xa4\x24\xaa\x2a\x5a')
297 for w in 2, 3, 4:
298 self.assertEqual(audioop.lin2alaw(datas[w], w),
299 b'\xd5\x87\xa4\x24\xaa\x2a\x55')
300
301 def test_alaw2lin(self):
302 encoded = b'\x00\x03\x24\x2a\x51\x54\x55\x58\x6b\x71\x7f'\
303 b'\x80\x83\xa4\xaa\xd1\xd4\xd5\xd8\xeb\xf1\xff'
304 src = [-688, -720, -2240, -4032, -9, -3, -1, -27, -244, -82, -106,
305 688, 720, 2240, 4032, 9, 3, 1, 27, 244, 82, 106]
306 for w in 1, 2, 3, 4:
307 decoded = packs[w](*(x << (w * 8) >> 13 for x in src))
308 self.assertEqual(audioop.alaw2lin(encoded, w), decoded)
309 self.assertEqual(audioop.alaw2lin(bytearray(encoded), w), decoded)
310 self.assertEqual(audioop.alaw2lin(memoryview(encoded), w), decoded)
311
312 encoded = bytes(range(256))
313 for w in 2, 3, 4:
314 decoded = audioop.alaw2lin(encoded, w)
315 self.assertEqual(audioop.lin2alaw(decoded, w), encoded)
316
317 def test_lin2ulaw(self):
318 self.assertEqual(audioop.lin2ulaw(datas[1], 1),
319 b'\xff\xad\x8e\x0e\x80\x00\x67')
320 self.assertEqual(audioop.lin2ulaw(bytearray(datas[1]), 1),
321 b'\xff\xad\x8e\x0e\x80\x00\x67')
322 self.assertEqual(audioop.lin2ulaw(memoryview(datas[1]), 1),
323 b'\xff\xad\x8e\x0e\x80\x00\x67')
324 for w in 2, 3, 4:
325 self.assertEqual(audioop.lin2ulaw(datas[w], w),
326 b'\xff\xad\x8e\x0e\x80\x00\x7e')
327
328 def test_ulaw2lin(self):
329 encoded = b'\x00\x0e\x28\x3f\x57\x6a\x76\x7c\x7e\x7f'\
330 b'\x80\x8e\xa8\xbf\xd7\xea\xf6\xfc\xfe\xff'
331 src = [-8031, -4447, -1471, -495, -163, -53, -18, -6, -2, 0,
332 8031, 4447, 1471, 495, 163, 53, 18, 6, 2, 0]
333 for w in 1, 2, 3, 4:
334 decoded = packs[w](*(x << (w * 8) >> 14 for x in src))
335 self.assertEqual(audioop.ulaw2lin(encoded, w), decoded)
336 self.assertEqual(audioop.ulaw2lin(bytearray(encoded), w), decoded)
337 self.assertEqual(audioop.ulaw2lin(memoryview(encoded), w), decoded)
338
339 # Current u-law implementation has two codes fo 0: 0x7f and 0xff.
340 encoded = bytes(range(127)) + bytes(range(128, 256))
341 for w in 2, 3, 4:
342 decoded = audioop.ulaw2lin(encoded, w)
343 self.assertEqual(audioop.lin2ulaw(decoded, w), encoded)
344
345 def test_mul(self):
346 for w in 1, 2, 3, 4:
347 self.assertEqual(audioop.mul(b'', w, 2), b'')
348 self.assertEqual(audioop.mul(bytearray(), w, 2), b'')
349 self.assertEqual(audioop.mul(memoryview(b''), w, 2), b'')
350 self.assertEqual(audioop.mul(datas[w], w, 0),
351 b'\0' * len(datas[w]))
352 self.assertEqual(audioop.mul(datas[w], w, 1),
353 datas[w])
354 self.assertEqual(audioop.mul(datas[1], 1, 2),
355 b'\x00\x24\x7f\x80\x7f\x80\xfe')
356 self.assertEqual(audioop.mul(datas[2], 2, 2),
357 packs[2](0, 0x2468, 0x7fff, -0x8000, 0x7fff, -0x8000, -2))
358 self.assertEqual(audioop.mul(datas[3], 3, 2),
359 packs[3](0, 0x2468ac, 0x7fffff, -0x800000,
360 0x7fffff, -0x800000, -2))
361 self.assertEqual(audioop.mul(datas[4], 4, 2),
362 packs[4](0, 0x2468acf0, 0x7fffffff, -0x80000000,
363 0x7fffffff, -0x80000000, -2))
364
365 def test_ratecv(self):
366 for w in 1, 2, 3, 4:
367 self.assertEqual(audioop.ratecv(b'', w, 1, 8000, 8000, None),
368 (b'', (-1, ((0, 0),))))
369 self.assertEqual(audioop.ratecv(bytearray(), w, 1, 8000, 8000, None),
370 (b'', (-1, ((0, 0),))))
371 self.assertEqual(audioop.ratecv(memoryview(b''), w, 1, 8000, 8000, None),
372 (b'', (-1, ((0, 0),))))
373 self.assertEqual(audioop.ratecv(b'', w, 5, 8000, 8000, None),
374 (b'', (-1, ((0, 0),) * 5)))
375 self.assertEqual(audioop.ratecv(b'', w, 1, 8000, 16000, None),
376 (b'', (-2, ((0, 0),))))
377 self.assertEqual(audioop.ratecv(datas[w], w, 1, 8000, 8000, None)[0],
378 datas[w])
379 self.assertEqual(audioop.ratecv(datas[w], w, 1, 8000, 8000, None, 1, 0)[0],
380 datas[w])
381
382 state = None
383 d1, state = audioop.ratecv(b'\x00\x01\x02', 1, 1, 8000, 16000, state)
384 d2, state = audioop.ratecv(b'\x00\x01\x02', 1, 1, 8000, 16000, state)
385 self.assertEqual(d1 + d2, b'\000\000\001\001\002\001\000\000\001\001\002')
386
387 for w in 1, 2, 3, 4:
388 d0, state0 = audioop.ratecv(datas[w], w, 1, 8000, 16000, None)
389 d, state = b'', None
390 for i in range(0, len(datas[w]), w):
391 d1, state = audioop.ratecv(datas[w][i:i + w], w, 1,
392 8000, 16000, state)
393 d += d1
394 self.assertEqual(d, d0)
395 self.assertEqual(state, state0)
396
397 expected = {
398 1: packs[1](0, 0x0d, 0x37, -0x26, 0x55, -0x4b, -0x14),
399 2: packs[2](0, 0x0da7, 0x3777, -0x2630, 0x5673, -0x4a64, -0x129a),
400 3: packs[3](0, 0x0da740, 0x377776, -0x262fca,
401 0x56740c, -0x4a62fd, -0x1298c0),
402 4: packs[4](0, 0x0da740da, 0x37777776, -0x262fc962,
403 0x56740da6, -0x4a62fc96, -0x1298bf26),
404 }
405 for w in 1, 2, 3, 4:
406 self.assertEqual(audioop.ratecv(datas[w], w, 1, 8000, 8000, None, 3, 1)[0],
407 expected[w])
408 self.assertEqual(audioop.ratecv(datas[w], w, 1, 8000, 8000, None, 30, 10)[0],
409 expected[w])
410
411 self.assertRaises(TypeError, audioop.ratecv, b'', 1, 1, 8000, 8000, 42)
412 self.assertRaises(TypeError, audioop.ratecv,
413 b'', 1, 1, 8000, 8000, (1, (42,)))
414
415 def test_reverse(self):
416 for w in 1, 2, 3, 4:
417 self.assertEqual(audioop.reverse(b'', w), b'')
418 self.assertEqual(audioop.reverse(bytearray(), w), b'')
419 self.assertEqual(audioop.reverse(memoryview(b''), w), b'')
420 self.assertEqual(audioop.reverse(packs[w](0, 1, 2), w),
421 packs[w](2, 1, 0))
422
423 def test_tomono(self):
424 for w in 1, 2, 3, 4:
425 data1 = datas[w]
426 data2 = bytearray(2 * len(data1))
427 for k in range(w):
428 data2[k::2*w] = data1[k::w]
429 self.assertEqual(audioop.tomono(data2, w, 1, 0), data1)
430 self.assertEqual(audioop.tomono(data2, w, 0, 1), b'\0' * len(data1))
431 for k in range(w):
432 data2[k+w::2*w] = data1[k::w]
433 self.assertEqual(audioop.tomono(data2, w, 0.5, 0.5), data1)
434 self.assertEqual(audioop.tomono(bytearray(data2), w, 0.5, 0.5),
435 data1)
436 self.assertEqual(audioop.tomono(memoryview(data2), w, 0.5, 0.5),
437 data1)
438
439 def test_tostereo(self):
440 for w in 1, 2, 3, 4:
441 data1 = datas[w]
442 data2 = bytearray(2 * len(data1))
443 for k in range(w):
444 data2[k::2*w] = data1[k::w]
445 self.assertEqual(audioop.tostereo(data1, w, 1, 0), data2)
446 self.assertEqual(audioop.tostereo(data1, w, 0, 0), b'\0' * len(data2))
447 for k in range(w):
448 data2[k+w::2*w] = data1[k::w]
449 self.assertEqual(audioop.tostereo(data1, w, 1, 1), data2)
450 self.assertEqual(audioop.tostereo(bytearray(data1), w, 1, 1), data2)
451 self.assertEqual(audioop.tostereo(memoryview(data1), w, 1, 1),
452 data2)
453
454 def test_findfactor(self):
455 self.assertEqual(audioop.findfactor(datas[2], datas[2]), 1.0)
456 self.assertEqual(audioop.findfactor(bytearray(datas[2]),
457 bytearray(datas[2])), 1.0)
458 self.assertEqual(audioop.findfactor(memoryview(datas[2]),
459 memoryview(datas[2])), 1.0)
460 self.assertEqual(audioop.findfactor(b'\0' * len(datas[2]), datas[2]),
461 0.0)
462
463 def test_findfit(self):
464 self.assertEqual(audioop.findfit(datas[2], datas[2]), (0, 1.0))
465 self.assertEqual(audioop.findfit(bytearray(datas[2]),
466 bytearray(datas[2])), (0, 1.0))
467 self.assertEqual(audioop.findfit(memoryview(datas[2]),
468 memoryview(datas[2])), (0, 1.0))
469 self.assertEqual(audioop.findfit(datas[2], packs[2](1, 2, 0)),
470 (1, 8038.8))
471 self.assertEqual(audioop.findfit(datas[2][:-2] * 5 + datas[2], datas[2]),
472 (30, 1.0))
473
474 def test_findmax(self):
475 self.assertEqual(audioop.findmax(datas[2], 1), 5)
476 self.assertEqual(audioop.findmax(bytearray(datas[2]), 1), 5)
477 self.assertEqual(audioop.findmax(memoryview(datas[2]), 1), 5)
478
479 def test_getsample(self):
480 for w in 1, 2, 3, 4:
481 data = packs[w](0, 1, -1, maxvalues[w], minvalues[w])
482 self.assertEqual(audioop.getsample(data, w, 0), 0)
483 self.assertEqual(audioop.getsample(bytearray(data), w, 0), 0)
484 self.assertEqual(audioop.getsample(memoryview(data), w, 0), 0)
485 self.assertEqual(audioop.getsample(data, w, 1), 1)
486 self.assertEqual(audioop.getsample(data, w, 2), -1)
487 self.assertEqual(audioop.getsample(data, w, 3), maxvalues[w])
488 self.assertEqual(audioop.getsample(data, w, 4), minvalues[w])
489
490 def test_byteswap(self):
491 swapped_datas = {
492 1: datas[1],
493 2: packs[2](0, 0x3412, 0x6745, -0x6646, -0x81, 0x80, -1),
494 3: packs[3](0, 0x563412, -0x7698bb, 0x7798ba, -0x81, 0x80, -1),
495 4: packs[4](0, 0x78563412, -0x547698bb, 0x557698ba,
496 -0x81, 0x80, -1),
497 }
498 for w in 1, 2, 3, 4:
499 self.assertEqual(audioop.byteswap(b'', w), b'')
500 self.assertEqual(audioop.byteswap(datas[w], w), swapped_datas[w])
501 self.assertEqual(audioop.byteswap(swapped_datas[w], w), datas[w])
502 self.assertEqual(audioop.byteswap(bytearray(datas[w]), w),
503 swapped_datas[w])
504 self.assertEqual(audioop.byteswap(memoryview(datas[w]), w),
505 swapped_datas[w])
506
507 def test_negativelen(self):
508 # from issue 3306, previously it segfaulted
509 self.assertRaises(audioop.error,
510 audioop.findmax, bytes(range(256)), -2392392)
511
512 def test_issue7673(self):
513 state = None
514 for data, size in INVALID_DATA:
515 size2 = size
516 self.assertRaises(audioop.error, audioop.getsample, data, size, 0)
517 self.assertRaises(audioop.error, audioop.max, data, size)
518 self.assertRaises(audioop.error, audioop.minmax, data, size)
519 self.assertRaises(audioop.error, audioop.avg, data, size)
520 self.assertRaises(audioop.error, audioop.rms, data, size)
521 self.assertRaises(audioop.error, audioop.avgpp, data, size)
522 self.assertRaises(audioop.error, audioop.maxpp, data, size)
523 self.assertRaises(audioop.error, audioop.cross, data, size)
524 self.assertRaises(audioop.error, audioop.mul, data, size, 1.0)
525 self.assertRaises(audioop.error, audioop.tomono, data, size, 0.5, 0.5)
526 self.assertRaises(audioop.error, audioop.tostereo, data, size, 0.5, 0.5)
527 self.assertRaises(audioop.error, audioop.add, data, data, size)
528 self.assertRaises(audioop.error, audioop.bias, data, size, 0)
529 self.assertRaises(audioop.error, audioop.reverse, data, size)
530 self.assertRaises(audioop.error, audioop.lin2lin, data, size, size2)
531 self.assertRaises(audioop.error, audioop.ratecv, data, size, 1, 1, 1, state)
532 self.assertRaises(audioop.error, audioop.lin2ulaw, data, size)
533 self.assertRaises(audioop.error, audioop.lin2alaw, data, size)
534 self.assertRaises(audioop.error, audioop.lin2adpcm, data, size, state)
535
536 def test_string(self):
537 data = 'abcd'
538 size = 2
539 self.assertRaises(TypeError, audioop.getsample, data, size, 0)
540 self.assertRaises(TypeError, audioop.max, data, size)
541 self.assertRaises(TypeError, audioop.minmax, data, size)
542 self.assertRaises(TypeError, audioop.avg, data, size)
543 self.assertRaises(TypeError, audioop.rms, data, size)
544 self.assertRaises(TypeError, audioop.avgpp, data, size)
545 self.assertRaises(TypeError, audioop.maxpp, data, size)
546 self.assertRaises(TypeError, audioop.cross, data, size)
547 self.assertRaises(TypeError, audioop.mul, data, size, 1.0)
548 self.assertRaises(TypeError, audioop.tomono, data, size, 0.5, 0.5)
549 self.assertRaises(TypeError, audioop.tostereo, data, size, 0.5, 0.5)
550 self.assertRaises(TypeError, audioop.add, data, data, size)
551 self.assertRaises(TypeError, audioop.bias, data, size, 0)
552 self.assertRaises(TypeError, audioop.reverse, data, size)
553 self.assertRaises(TypeError, audioop.lin2lin, data, size, size)
554 self.assertRaises(TypeError, audioop.ratecv, data, size, 1, 1, 1, None)
555 self.assertRaises(TypeError, audioop.lin2ulaw, data, size)
556 self.assertRaises(TypeError, audioop.lin2alaw, data, size)
557 self.assertRaises(TypeError, audioop.lin2adpcm, data, size, None)
558
559 def test_wrongsize(self):
560 data = b'abcdefgh'
561 state = None
562 for size in (-1, 0, 5, 1024):
563 self.assertRaises(audioop.error, audioop.ulaw2lin, data, size)
564 self.assertRaises(audioop.error, audioop.alaw2lin, data, size)
565 self.assertRaises(audioop.error, audioop.adpcm2lin, data, size, state)
566
567 if __name__ == '__main__':
568 unittest.main()