1import sys
2from test.support import warnings_helper
3import unittest
4
5audioop = warnings_helper.import_deprecated("audioop")
6
7
8def pack(width, data):
9    return b''.join(v.to_bytes(width, sys.byteorder, signed=True) for v in data)
10
11def 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
15packs = {w: (lambda *data, width=w: pack(width, data)) for w in (1, 2, 3, 4)}
16maxvalues = {w: (1 << (8 * w - 1)) - 1 for w in (1, 2, 3, 4)}
17minvalues = {w: -1 << (8 * w - 1) for w in (1, 2, 3, 4)}
18
19datas = {
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
27INVALID_DATA = [
28    (b'abc', 0),
29    (b'abc', 2),
30    (b'ab', 3),
31    (b'abc', 4),
32]
33
34
35class TestAudioop(unittest.TestCase):
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
567if __name__ == '__main__':
568    unittest.main()
569