xref: /third_party/python/Lib/test/test_audioop.py

37     def test_max(self):
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)
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])
49     def test_minmax(self):
51             self.assertEqual(audioop.minmax(b'', w),
53             self.assertEqual(audioop.minmax(bytearray(), w),
55             self.assertEqual(audioop.minmax(memoryview(b''), 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),
62             self.assertEqual(audioop.minmax(p(minvalues[w]), w),
64             self.assertEqual(audioop.minmax(datas[w], w),
67     def test_maxpp(self):
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),
77     def test_avg(self):
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)
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),
88             self.assertEqual(audioop.avg(p(minvalues[w], minvalues[w]), w),
90         self.assertEqual(audioop.avg(packs[4](0x50000000, 0x70000000), 4),
92         self.assertEqual(audioop.avg(packs[4](-0x50000000, -0x70000000), 4),
95     def test_avgpp(self):
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)
107     def test_rms(self):
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)
113             self.assertEqual(audioop.rms(p(*range(100)), w), 57)
114             self.assertAlmostEqual(audioop.rms(p(maxvalues[w]) * 5, w),
116             self.assertAlmostEqual(audioop.rms(p(minvalues[w]) * 5, w),
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)
123     def test_cross(self):
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)
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)
135     def test_add(self):
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),
142         self.assertEqual(audioop.add(datas[1], datas[1], 1),
144         self.assertEqual(audioop.add(datas[2], datas[2], 2),
146         self.assertEqual(audioop.add(datas[3], datas[3], 3),
149         self.assertEqual(audioop.add(datas[4], datas[4], 4),
153     def test_bias(self):
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),
161         self.assertEqual(audioop.bias(datas[1], 1, -1),
163         self.assertEqual(audioop.bias(datas[1], 1, 0x7fffffff),
165         self.assertEqual(audioop.bias(datas[1], 1, -0x80000000),
167         self.assertEqual(audioop.bias(datas[2], 2, 1),
169         self.assertEqual(audioop.bias(datas[2], 2, -1),
171         self.assertEqual(audioop.bias(datas[2], 2, 0x7fffffff),
173         self.assertEqual(audioop.bias(datas[2], 2, -0x80000000),
175         self.assertEqual(audioop.bias(datas[3], 3, 1),
178         self.assertEqual(audioop.bias(datas[3], 3, -1),
181         self.assertEqual(audioop.bias(datas[3], 3, 0x7fffffff),
184         self.assertEqual(audioop.bias(datas[3], 3, -0x80000000),
186         self.assertEqual(audioop.bias(datas[4], 4, 1),
189         self.assertEqual(audioop.bias(datas[4], 4, -1),
192         self.assertEqual(audioop.bias(datas[4], 4, 0x7fffffff),
195         self.assertEqual(audioop.bias(datas[4], 4, -0x80000000),
199     def test_lin2lin(self):
201             self.assertEqual(audioop.lin2lin(datas[w], w, w), datas[w])
202             self.assertEqual(audioop.lin2lin(bytearray(datas[w]), w, w),
204             self.assertEqual(audioop.lin2lin(memoryview(datas[w]), w, w),
207         self.assertEqual(audioop.lin2lin(datas[1], 1, 2),
209         self.assertEqual(audioop.lin2lin(datas[1], 1, 3),
212         self.assertEqual(audioop.lin2lin(datas[1], 1, 4),
215         self.assertEqual(audioop.lin2lin(datas[2], 2, 1),
217         self.assertEqual(audioop.lin2lin(datas[2], 2, 3),
220         self.assertEqual(audioop.lin2lin(datas[2], 2, 4),
223         self.assertEqual(audioop.lin2lin(datas[3], 3, 1),
225         self.assertEqual(audioop.lin2lin(datas[3], 3, 2),
227         self.assertEqual(audioop.lin2lin(datas[3], 3, 4),
230         self.assertEqual(audioop.lin2lin(datas[4], 4, 1),
232         self.assertEqual(audioop.lin2lin(datas[4], 4, 2),
234         self.assertEqual(audioop.lin2lin(datas[4], 4, 3),
238     def test_adpcm2lin(self):
239         self.assertEqual(audioop.adpcm2lin(b'\x07\x7f\x7f', 1, None),
241         self.assertEqual(audioop.adpcm2lin(bytearray(b'\x07\x7f\x7f'), 1, None),
243         self.assertEqual(audioop.adpcm2lin(memoryview(b'\x07\x7f\x7f'), 1, None),
245         self.assertEqual(audioop.adpcm2lin(b'\x07\x7f\x7f', 2, None),
247         self.assertEqual(audioop.adpcm2lin(b'\x07\x7f\x7f', 3, None),
250         self.assertEqual(audioop.adpcm2lin(b'\x07\x7f\x7f', 4, None),
256             self.assertEqual(audioop.adpcm2lin(b'\0' * 5, w, None),
259     def test_lin2adpcm(self):
260         self.assertEqual(audioop.lin2adpcm(datas[1], 1, None),
262         self.assertEqual(audioop.lin2adpcm(bytearray(datas[1]), 1, None),
264         self.assertEqual(audioop.lin2adpcm(memoryview(datas[1]), 1, None),
267             self.assertEqual(audioop.lin2adpcm(datas[w], w, None),
272             self.assertEqual(audioop.lin2adpcm(b'\0' * w * 10, w, None),
275     def test_invalid_adpcm_state(self):
277         self.assertRaises(TypeError, audioop.adpcm2lin, b'\0', 1, 555)
278         self.assertRaises(TypeError, audioop.lin2adpcm, b'\0', 1, 555)
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))
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))
290     def test_lin2alaw(self):
291         self.assertEqual(audioop.lin2alaw(datas[1], 1),
293         self.assertEqual(audioop.lin2alaw(bytearray(datas[1]), 1),
295         self.assertEqual(audioop.lin2alaw(memoryview(datas[1]), 1),
298             self.assertEqual(audioop.lin2alaw(datas[w], w),
301     def test_alaw2lin(self):
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)
315             self.assertEqual(audioop.lin2alaw(decoded, w), encoded)
317     def test_lin2ulaw(self):
318         self.assertEqual(audioop.lin2ulaw(datas[1], 1),
320         self.assertEqual(audioop.lin2ulaw(bytearray(datas[1]), 1),
322         self.assertEqual(audioop.lin2ulaw(memoryview(datas[1]), 1),
325             self.assertEqual(audioop.lin2ulaw(datas[w], w),
328     def test_ulaw2lin(self):
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)
343             self.assertEqual(audioop.lin2ulaw(decoded, w), encoded)
345     def test_mul(self):
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),
352             self.assertEqual(audioop.mul(datas[w], w, 1),
354         self.assertEqual(audioop.mul(datas[1], 1, 2),
356         self.assertEqual(audioop.mul(datas[2], 2, 2),
358         self.assertEqual(audioop.mul(datas[3], 3, 2),
361         self.assertEqual(audioop.mul(datas[4], 4, 2),
365     def test_ratecv(self):
367             self.assertEqual(audioop.ratecv(b'', w, 1, 8000, 8000, None),
369             self.assertEqual(audioop.ratecv(bytearray(), w, 1, 8000, 8000, None),
371             self.assertEqual(audioop.ratecv(memoryview(b''), w, 1, 8000, 8000, None),
373             self.assertEqual(audioop.ratecv(b'', w, 5, 8000, 8000, None),
375             self.assertEqual(audioop.ratecv(b'', w, 1, 8000, 16000, None),
377             self.assertEqual(audioop.ratecv(datas[w], w, 1, 8000, 8000, None)[0],
379             self.assertEqual(audioop.ratecv(datas[w], w, 1, 8000, 8000, None, 1, 0)[0],
385         self.assertEqual(d1 + d2, b'\000\000\001\001\002\001\000\000\001\001\002')
394             self.assertEqual(d, d0)
395             self.assertEqual(state, state0)
406             self.assertEqual(audioop.ratecv(datas[w], w, 1, 8000, 8000, None, 3, 1)[0],
408             self.assertEqual(audioop.ratecv(datas[w], w, 1, 8000, 8000, None, 30, 10)[0],
411         self.assertRaises(TypeError, audioop.ratecv, b'', 1, 1, 8000, 8000, 42)
412         self.assertRaises(TypeError, audioop.ratecv,
415     def test_reverse(self):
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),
423     def test_tomono(self):
429             self.assertEqual(audioop.tomono(data2, w, 1, 0), data1)
430             self.assertEqual(audioop.tomono(data2, w, 0, 1), b'\0' * len(data1))
433             self.assertEqual(audioop.tomono(data2, w, 0.5, 0.5), data1)
434             self.assertEqual(audioop.tomono(bytearray(data2), w, 0.5, 0.5),
436             self.assertEqual(audioop.tomono(memoryview(data2), w, 0.5, 0.5),
439     def test_tostereo(self):
445             self.assertEqual(audioop.tostereo(data1, w, 1, 0), data2)
446             self.assertEqual(audioop.tostereo(data1, w, 0, 0), b'\0' * len(data2))
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),
454     def test_findfactor(self):
455         self.assertEqual(audioop.findfactor(datas[2], datas[2]), 1.0)
456         self.assertEqual(audioop.findfactor(bytearray(datas[2]),
458         self.assertEqual(audioop.findfactor(memoryview(datas[2]),
460         self.assertEqual(audioop.findfactor(b'\0' * len(datas[2]), datas[2]),
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]),
467         self.assertEqual(audioop.findfit(memoryview(datas[2]),
469         self.assertEqual(audioop.findfit(datas[2], packs[2](1, 2, 0)),
471         self.assertEqual(audioop.findfit(datas[2][:-2] * 5 + datas[2], datas[2]),
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)
479     def test_getsample(self):
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])
490     def test_byteswap(self):
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),
504             self.assertEqual(audioop.byteswap(memoryview(datas[w]), w),
507     def test_negativelen(self):
509         self.assertRaises(audioop.error,
512     def test_issue7673(self):
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)
536     def test_string(self):
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)
559     def test_wrongsize(self):
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)

Indexes created Thu Nov 07 10:32:03 CST 2024