Home | History | Annotate | Download | only in test 
      1 import audioop
      2 import unittest
      3 from test.test_support import run_unittest
      4 
      5 
      6 def gendata1():
      7     return '\0\1\2'
      8 
      9 def gendata2():
     10     if audioop.getsample('\0\1', 2, 0) == 1:
     11         return '\0\0\0\1\0\2'
     12     else:
     13         return '\0\0\1\0\2\0'
     14 
     15 def gendata4():
     16     if audioop.getsample('\0\0\0\1', 4, 0) == 1:
     17         return '\0\0\0\0\0\0\0\1\0\0\0\2'
     18     else:
     19         return '\0\0\0\0\1\0\0\0\2\0\0\0'
     20 
     21 data = [gendata1(), gendata2(), gendata4()]
     22 
     23 INVALID_DATA = [
     24     ('abc', 0),
     25     ('abc', 2),
     26     ('abc', 4),
     27 ]
     28 
     29 
     30 class TestAudioop(unittest.TestCase):
     31 
     32     def test_max(self):
     33         self.assertEqual(audioop.max(data[0], 1), 2)
     34         self.assertEqual(audioop.max(data[1], 2), 2)
     35         self.assertEqual(audioop.max(data[2], 4), 2)
     36 
     37     def test_minmax(self):
     38         self.assertEqual(audioop.minmax(data[0], 1), (0, 2))
     39         self.assertEqual(audioop.minmax(data[1], 2), (0, 2))
     40         self.assertEqual(audioop.minmax(data[2], 4), (0, 2))
     41 
     42     def test_maxpp(self):
     43         self.assertEqual(audioop.maxpp(data[0], 1), 0)
     44         self.assertEqual(audioop.maxpp(data[1], 2), 0)
     45         self.assertEqual(audioop.maxpp(data[2], 4), 0)
     46 
     47     def test_avg(self):
     48         self.assertEqual(audioop.avg(data[0], 1), 1)
     49         self.assertEqual(audioop.avg(data[1], 2), 1)
     50         self.assertEqual(audioop.avg(data[2], 4), 1)
     51 
     52     def test_avgpp(self):
     53         self.assertEqual(audioop.avgpp(data[0], 1), 0)
     54         self.assertEqual(audioop.avgpp(data[1], 2), 0)
     55         self.assertEqual(audioop.avgpp(data[2], 4), 0)
     56 
     57     def test_rms(self):
     58         self.assertEqual(audioop.rms(data[0], 1), 1)
     59         self.assertEqual(audioop.rms(data[1], 2), 1)
     60         self.assertEqual(audioop.rms(data[2], 4), 1)
     61 
     62     def test_cross(self):
     63         self.assertEqual(audioop.cross(data[0], 1), 0)
     64         self.assertEqual(audioop.cross(data[1], 2), 0)
     65         self.assertEqual(audioop.cross(data[2], 4), 0)
     66 
     67     def test_add(self):
     68         data2 = []
     69         for d in data:
     70             str = ''
     71             for s in d:
     72                 str = str + chr(ord(s)*2)
     73             data2.append(str)
     74         self.assertEqual(audioop.add(data[0], data[0], 1), data2[0])
     75         self.assertEqual(audioop.add(data[1], data[1], 2), data2[1])
     76         self.assertEqual(audioop.add(data[2], data[2], 4), data2[2])
     77 
     78     def test_bias(self):
     79         # Note: this test assumes that avg() works

     80         d1 = audioop.bias(data[0], 1, 100)
     81         d2 = audioop.bias(data[1], 2, 100)
     82         d4 = audioop.bias(data[2], 4, 100)
     83         self.assertEqual(audioop.avg(d1, 1), 101)
     84         self.assertEqual(audioop.avg(d2, 2), 101)
     85         self.assertEqual(audioop.avg(d4, 4), 101)
     86 
     87     def test_lin2lin(self):
     88         # too simple: we test only the size

     89         for d1 in data:
     90             for d2 in data:
     91                 got = len(d1)//3
     92                 wtd = len(d2)//3
     93                 self.assertEqual(len(audioop.lin2lin(d1, got, wtd)), len(d2))
     94 
     95     def test_adpcm2lin(self):
     96         # Very cursory test

     97         self.assertEqual(audioop.adpcm2lin('\0\0', 1, None), ('\0\0\0\0', (0,0)))
     98 
     99     def test_lin2adpcm(self):
    100         # Very cursory test

    101         self.assertEqual(audioop.lin2adpcm('\0\0\0\0', 1, None), ('\0\0', (0,0)))
    102 
    103     def test_lin2alaw(self):
    104         self.assertEqual(audioop.lin2alaw(data[0], 1), '\xd5\xc5\xf5')
    105         self.assertEqual(audioop.lin2alaw(data[1], 2), '\xd5\xd5\xd5')
    106         self.assertEqual(audioop.lin2alaw(data[2], 4), '\xd5\xd5\xd5')
    107 
    108     def test_alaw2lin(self):
    109         # Cursory

    110         d = audioop.lin2alaw(data[0], 1)
    111         self.assertEqual(audioop.alaw2lin(d, 1), data[0])
    112 
    113     def test_lin2ulaw(self):
    114         self.assertEqual(audioop.lin2ulaw(data[0], 1), '\xff\xe7\xdb')
    115         self.assertEqual(audioop.lin2ulaw(data[1], 2), '\xff\xff\xff')
    116         self.assertEqual(audioop.lin2ulaw(data[2], 4), '\xff\xff\xff')
    117 
    118     def test_ulaw2lin(self):
    119         # Cursory

    120         d = audioop.lin2ulaw(data[0], 1)
    121         self.assertEqual(audioop.ulaw2lin(d, 1), data[0])
    122 
    123     def test_mul(self):
    124         data2 = []
    125         for d in data:
    126             str = ''
    127             for s in d:
    128                 str = str + chr(ord(s)*2)
    129             data2.append(str)
    130         self.assertEqual(audioop.mul(data[0], 1, 2), data2[0])
    131         self.assertEqual(audioop.mul(data[1],2, 2), data2[1])
    132         self.assertEqual(audioop.mul(data[2], 4, 2), data2[2])
    133 
    134     def test_ratecv(self):
    135         state = None
    136         d1, state = audioop.ratecv(data[0], 1, 1, 8000, 16000, state)
    137         d2, state = audioop.ratecv(data[0], 1, 1, 8000, 16000, state)
    138         self.assertEqual(d1 + d2, '\000\000\001\001\002\001\000\000\001\001\002')
    139 
    140     def test_reverse(self):
    141         self.assertEqual(audioop.reverse(data[0], 1), '\2\1\0')
    142 
    143     def test_tomono(self):
    144         data2 = ''
    145         for d in data[0]:
    146             data2 = data2 + d + d
    147         self.assertEqual(audioop.tomono(data2, 1, 0.5, 0.5), data[0])
    148 
    149     def test_tostereo(self):
    150         data2 = ''
    151         for d in data[0]:
    152             data2 = data2 + d + d
    153         self.assertEqual(audioop.tostereo(data[0], 1, 1, 1), data2)
    154 
    155     def test_findfactor(self):
    156         self.assertEqual(audioop.findfactor(data[1], data[1]), 1.0)
    157 
    158     def test_findfit(self):
    159         self.assertEqual(audioop.findfit(data[1], data[1]), (0, 1.0))
    160 
    161     def test_findmax(self):
    162         self.assertEqual(audioop.findmax(data[1], 1), 2)
    163 
    164     def test_getsample(self):
    165         for i in range(3):
    166             self.assertEqual(audioop.getsample(data[0], 1, i), i)
    167             self.assertEqual(audioop.getsample(data[1], 2, i), i)
    168             self.assertEqual(audioop.getsample(data[2], 4, i), i)
    169 
    170     def test_negativelen(self):
    171         # from issue 3306, previously it segfaulted

    172         self.assertRaises(audioop.error,
    173             audioop.findmax, ''.join( chr(x) for x in xrange(256)), -2392392)
    174 
    175     def test_issue7673(self):
    176         state = None
    177         for data, size in INVALID_DATA:
    178             size2 = size
    179             self.assertRaises(audioop.error, audioop.getsample, data, size, 0)
    180             self.assertRaises(audioop.error, audioop.max, data, size)
    181             self.assertRaises(audioop.error, audioop.minmax, data, size)
    182             self.assertRaises(audioop.error, audioop.avg, data, size)
    183             self.assertRaises(audioop.error, audioop.rms, data, size)
    184             self.assertRaises(audioop.error, audioop.avgpp, data, size)
    185             self.assertRaises(audioop.error, audioop.maxpp, data, size)
    186             self.assertRaises(audioop.error, audioop.cross, data, size)
    187             self.assertRaises(audioop.error, audioop.mul, data, size, 1.0)
    188             self.assertRaises(audioop.error, audioop.tomono, data, size, 0.5, 0.5)
    189             self.assertRaises(audioop.error, audioop.tostereo, data, size, 0.5, 0.5)
    190             self.assertRaises(audioop.error, audioop.add, data, data, size)
    191             self.assertRaises(audioop.error, audioop.bias, data, size, 0)
    192             self.assertRaises(audioop.error, audioop.reverse, data, size)
    193             self.assertRaises(audioop.error, audioop.lin2lin, data, size, size2)
    194             self.assertRaises(audioop.error, audioop.ratecv, data, size, 1, 1, 1, state)
    195             self.assertRaises(audioop.error, audioop.lin2ulaw, data, size)
    196             self.assertRaises(audioop.error, audioop.ulaw2lin, data, size)
    197             self.assertRaises(audioop.error, audioop.lin2alaw, data, size)
    198             self.assertRaises(audioop.error, audioop.alaw2lin, data, size)
    199             self.assertRaises(audioop.error, audioop.lin2adpcm, data, size, state)
    200             self.assertRaises(audioop.error, audioop.adpcm2lin, data, size, state)
    201 
    202 def test_main():
    203     run_unittest(TestAudioop)
    204 
    205 if __name__ == '__main__':
    206     test_main()
    207