Lib/test/test_audioop.py

   1 import audioop
   2 import unittest
   3 from test.test_support import run_unittest
   4
   5 endian = 'big' if audioop.getsample('\0\1', 2, 0) == 1 else 'little'
   6
   7 def gendata1():
   8     return '\0\1\2'
   9
  10 def gendata2():
  11     if endian == 'big':
  12         return '\0\0\0\1\0\2'
  13     else:
  14         return '\0\0\1\0\2\0'
  15
  16 def gendata4():
  17     if endian == 'big':
  18         return '\0\0\0\0\0\0\0\1\0\0\0\2'
  19     else:
  20         return '\0\0\0\0\1\0\0\0\2\0\0\0'
  21
  22 data = [gendata1(), gendata2(), gendata4()]
  23
  24 INVALID_DATA = [
  25     (b'abc', 0),
  26     (b'abc', 2),
  27     (b'abc', 4),
  28 ]
  29
  30
  31 class TestAudioop(unittest.TestCase):
  32
  33     def test_max(self):
  34         self.assertEqual(audioop.max(data[0], 1), 2)
  35         self.assertEqual(audioop.max(data[1], 2), 2)
  36         self.assertEqual(audioop.max(data[2], 4), 2)
  37
  38     def test_minmax(self):
  39         self.assertEqual(audioop.minmax(data[0], 1), (0, 2))
  40         self.assertEqual(audioop.minmax(data[1], 2), (0, 2))
  41         self.assertEqual(audioop.minmax(data[2], 4), (0, 2))
  42
  43     def test_maxpp(self):
  44         self.assertEqual(audioop.maxpp(data[0], 1), 0)
  45         self.assertEqual(audioop.maxpp(data[1], 2), 0)
  46         self.assertEqual(audioop.maxpp(data[2], 4), 0)
  47
  48     def test_avg(self):
  49         self.assertEqual(audioop.avg(data[0], 1), 1)
  50         self.assertEqual(audioop.avg(data[1], 2), 1)
  51         self.assertEqual(audioop.avg(data[2], 4), 1)
  52
  53     def test_avgpp(self):
  54         self.assertEqual(audioop.avgpp(data[0], 1), 0)
  55         self.assertEqual(audioop.avgpp(data[1], 2), 0)
  56         self.assertEqual(audioop.avgpp(data[2], 4), 0)
  57
  58     def test_rms(self):
  59         self.assertEqual(audioop.rms(data[0], 1), 1)
  60         self.assertEqual(audioop.rms(data[1], 2), 1)
  61         self.assertEqual(audioop.rms(data[2], 4), 1)
  62
  63     def test_cross(self):
  64         self.assertEqual(audioop.cross(data[0], 1), 0)
  65         self.assertEqual(audioop.cross(data[1], 2), 0)
  66         self.assertEqual(audioop.cross(data[2], 4), 0)
  67
  68     def test_add(self):
  69         data2 = []
  70         for d in data:
  71             str = ''
  72             for s in d:
  73                 str = str + chr(ord(s)*2)
  74             data2.append(str)
  75         self.assertEqual(audioop.add(data[0], data[0], 1), data2[0])
  76         self.assertEqual(audioop.add(data[1], data[1], 2), data2[1])
  77         self.assertEqual(audioop.add(data[2], data[2], 4), data2[2])
  78
  79     def test_bias(self):
  80         # Note: this test assumes that avg() works
  81         d1 = audioop.bias(data[0], 1, 100)
  82         d2 = audioop.bias(data[1], 2, 100)
  83         d4 = audioop.bias(data[2], 4, 100)
  84         self.assertEqual(audioop.avg(d1, 1), 101)
  85         self.assertEqual(audioop.avg(d2, 2), 101)
  86         self.assertEqual(audioop.avg(d4, 4), 101)
  87
  88     def test_lin2lin(self):
  89         # too simple: we test only the size
  90         for d1 in data:
  91             for d2 in data:
  92                 got = len(d1)//3
  93                 wtd = len(d2)//3
  94                 self.assertEqual(len(audioop.lin2lin(d1, got, wtd)), len(d2))
  95
  96     def test_adpcm2lin(self):
  97         # Very cursory test
  98         self.assertEqual(audioop.adpcm2lin(b'\0\0', 1, None), (b'\0' * 4, (0,0)))
  99         self.assertEqual(audioop.adpcm2lin(b'\0\0', 2, None), (b'\0' * 8, (0,0)))
 100         self.assertEqual(audioop.adpcm2lin(b'\0\0', 4, None), (b'\0' * 16, (0,0)))
 101
 102     def test_lin2adpcm(self):
 103         # Very cursory test
 104         self.assertEqual(audioop.lin2adpcm('\0\0\0\0', 1, None), ('\0\0', (0,0)))
 105
 106     def test_lin2alaw(self):
 107         self.assertEqual(audioop.lin2alaw(data[0], 1), '\xd5\xc5\xf5')
 108         self.assertEqual(audioop.lin2alaw(data[1], 2), '\xd5\xd5\xd5')
 109         self.assertEqual(audioop.lin2alaw(data[2], 4), '\xd5\xd5\xd5')
 110
 111     def test_alaw2lin(self):
 112         # Cursory
 113         d = audioop.lin2alaw(data[0], 1)
 114         self.assertEqual(audioop.alaw2lin(d, 1), data[0])
 115         if endian == 'big':
 116             self.assertEqual(audioop.alaw2lin(d, 2),
 117                              b'\x00\x08\x01\x08\x02\x10')
 118             self.assertEqual(audioop.alaw2lin(d, 4),
 119                              b'\x00\x08\x00\x00\x01\x08\x00\x00\x02\x10\x00\x00')
 120         else:
 121             self.assertEqual(audioop.alaw2lin(d, 2),
 122                              b'\x08\x00\x08\x01\x10\x02')
 123             self.assertEqual(audioop.alaw2lin(d, 4),
 124                              b'\x00\x00\x08\x00\x00\x00\x08\x01\x00\x00\x10\x02')
 125
 126     def test_lin2ulaw(self):
 127         self.assertEqual(audioop.lin2ulaw(data[0], 1), '\xff\xe7\xdb')
 128         self.assertEqual(audioop.lin2ulaw(data[1], 2), '\xff\xff\xff')
 129         self.assertEqual(audioop.lin2ulaw(data[2], 4), '\xff\xff\xff')
 130
 131     def test_ulaw2lin(self):
 132         # Cursory
 133         d = audioop.lin2ulaw(data[0], 1)
 134         self.assertEqual(audioop.ulaw2lin(d, 1), data[0])
 135         if endian == 'big':
 136             self.assertEqual(audioop.ulaw2lin(d, 2),
 137                              b'\x00\x00\x01\x04\x02\x0c')
 138             self.assertEqual(audioop.ulaw2lin(d, 4),
 139                              b'\x00\x00\x00\x00\x01\x04\x00\x00\x02\x0c\x00\x00')
 140         else:
 141             self.assertEqual(audioop.ulaw2lin(d, 2),
 142                              b'\x00\x00\x04\x01\x0c\x02')
 143             self.assertEqual(audioop.ulaw2lin(d, 4),
 144                              b'\x00\x00\x00\x00\x00\x00\x04\x01\x00\x00\x0c\x02')
 145
 146     def test_mul(self):
 147         data2 = []
 148         for d in data:
 149             str = ''
 150             for s in d:
 151                 str = str + chr(ord(s)*2)
 152             data2.append(str)
 153         self.assertEqual(audioop.mul(data[0], 1, 2), data2[0])
 154         self.assertEqual(audioop.mul(data[1],2, 2), data2[1])
 155         self.assertEqual(audioop.mul(data[2], 4, 2), data2[2])
 156
 157     def test_ratecv(self):
 158         state = None
 159         d1, state = audioop.ratecv(data[0], 1, 1, 8000, 16000, state)
 160         d2, state = audioop.ratecv(data[0], 1, 1, 8000, 16000, state)
 161         self.assertEqual(d1 + d2, '\000\000\001\001\002\001\000\000\001\001\002')
 162
 163     def test_reverse(self):
 164         self.assertEqual(audioop.reverse(data[0], 1), '\2\1\0')
 165
 166     def test_tomono(self):
 167         data2 = ''
 168         for d in data[0]:
 169             data2 = data2 + d + d
 170         self.assertEqual(audioop.tomono(data2, 1, 0.5, 0.5), data[0])
 171
 172     def test_tostereo(self):
 173         data2 = ''
 174         for d in data[0]:
 175             data2 = data2 + d + d
 176         self.assertEqual(audioop.tostereo(data[0], 1, 1, 1), data2)
 177
 178     def test_findfactor(self):
 179         self.assertEqual(audioop.findfactor(data[1], data[1]), 1.0)
 180
 181     def test_findfit(self):
 182         self.assertEqual(audioop.findfit(data[1], data[1]), (0, 1.0))
 183
 184     def test_findmax(self):
 185         self.assertEqual(audioop.findmax(data[1], 1), 2)
 186
 187     def test_getsample(self):
 188         for i in range(3):
 189             self.assertEqual(audioop.getsample(data[0], 1, i), i)
 190             self.assertEqual(audioop.getsample(data[1], 2, i), i)
 191             self.assertEqual(audioop.getsample(data[2], 4, i), i)
 192
 193     def test_negativelen(self):
 194         # from issue 3306, previously it segfaulted
 195         self.assertRaises(audioop.error,
 196             audioop.findmax, ''.join( chr(x) for x in xrange(256)), -2392392)
 197
 198     def test_issue7673(self):
 199         state = None
 200         for data, size in INVALID_DATA:
 201             size2 = size
 202             self.assertRaises(audioop.error, audioop.getsample, data, size, 0)
 203             self.assertRaises(audioop.error, audioop.max, data, size)
 204             self.assertRaises(audioop.error, audioop.minmax, data, size)
 205             self.assertRaises(audioop.error, audioop.avg, data, size)
 206             self.assertRaises(audioop.error, audioop.rms, data, size)
 207             self.assertRaises(audioop.error, audioop.avgpp, data, size)
 208             self.assertRaises(audioop.error, audioop.maxpp, data, size)
 209             self.assertRaises(audioop.error, audioop.cross, data, size)
 210             self.assertRaises(audioop.error, audioop.mul, data, size, 1.0)
 211             self.assertRaises(audioop.error, audioop.tomono, data, size, 0.5, 0.5)
 212             self.assertRaises(audioop.error, audioop.tostereo, data, size, 0.5, 0.5)
 213             self.assertRaises(audioop.error, audioop.add, data, data, size)
 214             self.assertRaises(audioop.error, audioop.bias, data, size, 0)
 215             self.assertRaises(audioop.error, audioop.reverse, data, size)
 216             self.assertRaises(audioop.error, audioop.lin2lin, data, size, size2)
 217             self.assertRaises(audioop.error, audioop.ratecv, data, size, 1, 1, 1, state)
 218             self.assertRaises(audioop.error, audioop.lin2ulaw, data, size)
 219             self.assertRaises(audioop.error, audioop.lin2alaw, data, size)
 220             self.assertRaises(audioop.error, audioop.lin2adpcm, data, size, state)
 221
 222     def test_wrongsize(self):
 223         data = b'abc'
 224         state = None
 225         for size in (-1, 3, 5):
 226             self.assertRaises(audioop.error, audioop.ulaw2lin, data, size)
 227             self.assertRaises(audioop.error, audioop.alaw2lin, data, size)
 228             self.assertRaises(audioop.error, audioop.adpcm2lin, data, size, state)
 229
 230 def test_main():
 231     run_unittest(TestAudioop)
 232
 233 if __name__ == '__main__':
 234     test_main()