Commit | Line | Data |
---|---|---|
920dae64 AT |
1 | # Test audioop. |
2 | import audioop | |
3 | from test.test_support import verbose | |
4 | ||
5 | def gendata1(): | |
6 | return '\0\1\2' | |
7 | ||
8 | def gendata2(): | |
9 | if verbose: | |
10 | print 'getsample' | |
11 | if audioop.getsample('\0\1', 2, 0) == 1: | |
12 | return '\0\0\0\1\0\2' | |
13 | else: | |
14 | return '\0\0\1\0\2\0' | |
15 | ||
16 | def gendata4(): | |
17 | if verbose: | |
18 | print 'getsample' | |
19 | if audioop.getsample('\0\0\0\1', 4, 0) == 1: | |
20 | return '\0\0\0\0\0\0\0\1\0\0\0\2' | |
21 | else: | |
22 | return '\0\0\0\0\1\0\0\0\2\0\0\0' | |
23 | ||
24 | def testmax(data): | |
25 | if verbose: | |
26 | print 'max' | |
27 | if audioop.max(data[0], 1) != 2 or \ | |
28 | audioop.max(data[1], 2) != 2 or \ | |
29 | audioop.max(data[2], 4) != 2: | |
30 | return 0 | |
31 | return 1 | |
32 | ||
33 | def testminmax(data): | |
34 | if verbose: | |
35 | print 'minmax' | |
36 | if audioop.minmax(data[0], 1) != (0, 2) or \ | |
37 | audioop.minmax(data[1], 2) != (0, 2) or \ | |
38 | audioop.minmax(data[2], 4) != (0, 2): | |
39 | return 0 | |
40 | return 1 | |
41 | ||
42 | def testmaxpp(data): | |
43 | if verbose: | |
44 | print 'maxpp' | |
45 | if audioop.maxpp(data[0], 1) != 0 or \ | |
46 | audioop.maxpp(data[1], 2) != 0 or \ | |
47 | audioop.maxpp(data[2], 4) != 0: | |
48 | return 0 | |
49 | return 1 | |
50 | ||
51 | def testavg(data): | |
52 | if verbose: | |
53 | print 'avg' | |
54 | if audioop.avg(data[0], 1) != 1 or \ | |
55 | audioop.avg(data[1], 2) != 1 or \ | |
56 | audioop.avg(data[2], 4) != 1: | |
57 | return 0 | |
58 | return 1 | |
59 | ||
60 | def testavgpp(data): | |
61 | if verbose: | |
62 | print 'avgpp' | |
63 | if audioop.avgpp(data[0], 1) != 0 or \ | |
64 | audioop.avgpp(data[1], 2) != 0 or \ | |
65 | audioop.avgpp(data[2], 4) != 0: | |
66 | return 0 | |
67 | return 1 | |
68 | ||
69 | def testrms(data): | |
70 | if audioop.rms(data[0], 1) != 1 or \ | |
71 | audioop.rms(data[1], 2) != 1 or \ | |
72 | audioop.rms(data[2], 4) != 1: | |
73 | return 0 | |
74 | return 1 | |
75 | ||
76 | def testcross(data): | |
77 | if verbose: | |
78 | print 'cross' | |
79 | if audioop.cross(data[0], 1) != 0 or \ | |
80 | audioop.cross(data[1], 2) != 0 or \ | |
81 | audioop.cross(data[2], 4) != 0: | |
82 | return 0 | |
83 | return 1 | |
84 | ||
85 | def testadd(data): | |
86 | if verbose: | |
87 | print 'add' | |
88 | data2 = [] | |
89 | for d in data: | |
90 | str = '' | |
91 | for s in d: | |
92 | str = str + chr(ord(s)*2) | |
93 | data2.append(str) | |
94 | if audioop.add(data[0], data[0], 1) != data2[0] or \ | |
95 | audioop.add(data[1], data[1], 2) != data2[1] or \ | |
96 | audioop.add(data[2], data[2], 4) != data2[2]: | |
97 | return 0 | |
98 | return 1 | |
99 | ||
100 | def testbias(data): | |
101 | if verbose: | |
102 | print 'bias' | |
103 | # Note: this test assumes that avg() works | |
104 | d1 = audioop.bias(data[0], 1, 100) | |
105 | d2 = audioop.bias(data[1], 2, 100) | |
106 | d4 = audioop.bias(data[2], 4, 100) | |
107 | if audioop.avg(d1, 1) != 101 or \ | |
108 | audioop.avg(d2, 2) != 101 or \ | |
109 | audioop.avg(d4, 4) != 101: | |
110 | return 0 | |
111 | return 1 | |
112 | ||
113 | def testlin2lin(data): | |
114 | if verbose: | |
115 | print 'lin2lin' | |
116 | # too simple: we test only the size | |
117 | for d1 in data: | |
118 | for d2 in data: | |
119 | got = len(d1)//3 | |
120 | wtd = len(d2)//3 | |
121 | if len(audioop.lin2lin(d1, got, wtd)) != len(d2): | |
122 | return 0 | |
123 | return 1 | |
124 | ||
125 | def testadpcm2lin(data): | |
126 | # Very cursory test | |
127 | if audioop.adpcm2lin('\0\0', 1, None) != ('\0\0\0\0', (0,0)): | |
128 | return 0 | |
129 | return 1 | |
130 | ||
131 | def testlin2adpcm(data): | |
132 | if verbose: | |
133 | print 'lin2adpcm' | |
134 | # Very cursory test | |
135 | if audioop.lin2adpcm('\0\0\0\0', 1, None) != ('\0\0', (0,0)): | |
136 | return 0 | |
137 | return 1 | |
138 | ||
139 | def testlin2ulaw(data): | |
140 | if verbose: | |
141 | print 'lin2ulaw' | |
142 | if audioop.lin2ulaw(data[0], 1) != '\377\347\333' or \ | |
143 | audioop.lin2ulaw(data[1], 2) != '\377\377\377' or \ | |
144 | audioop.lin2ulaw(data[2], 4) != '\377\377\377': | |
145 | return 0 | |
146 | return 1 | |
147 | ||
148 | def testulaw2lin(data): | |
149 | if verbose: | |
150 | print 'ulaw2lin' | |
151 | # Cursory | |
152 | d = audioop.lin2ulaw(data[0], 1) | |
153 | if audioop.ulaw2lin(d, 1) != data[0]: | |
154 | return 0 | |
155 | return 1 | |
156 | ||
157 | def testmul(data): | |
158 | if verbose: | |
159 | print 'mul' | |
160 | data2 = [] | |
161 | for d in data: | |
162 | str = '' | |
163 | for s in d: | |
164 | str = str + chr(ord(s)*2) | |
165 | data2.append(str) | |
166 | if audioop.mul(data[0], 1, 2) != data2[0] or \ | |
167 | audioop.mul(data[1],2, 2) != data2[1] or \ | |
168 | audioop.mul(data[2], 4, 2) != data2[2]: | |
169 | return 0 | |
170 | return 1 | |
171 | ||
172 | def testratecv(data): | |
173 | if verbose: | |
174 | print 'ratecv' | |
175 | state = None | |
176 | d1, state = audioop.ratecv(data[0], 1, 1, 8000, 16000, state) | |
177 | d2, state = audioop.ratecv(data[0], 1, 1, 8000, 16000, state) | |
178 | if d1 + d2 != '\000\000\001\001\002\001\000\000\001\001\002': | |
179 | return 0 | |
180 | return 1 | |
181 | ||
182 | def testreverse(data): | |
183 | if verbose: | |
184 | print 'reverse' | |
185 | if audioop.reverse(data[0], 1) != '\2\1\0': | |
186 | return 0 | |
187 | return 1 | |
188 | ||
189 | def testtomono(data): | |
190 | if verbose: | |
191 | print 'tomono' | |
192 | data2 = '' | |
193 | for d in data[0]: | |
194 | data2 = data2 + d + d | |
195 | if audioop.tomono(data2, 1, 0.5, 0.5) != data[0]: | |
196 | return 0 | |
197 | return 1 | |
198 | ||
199 | def testtostereo(data): | |
200 | if verbose: | |
201 | print 'tostereo' | |
202 | data2 = '' | |
203 | for d in data[0]: | |
204 | data2 = data2 + d + d | |
205 | if audioop.tostereo(data[0], 1, 1, 1) != data2: | |
206 | return 0 | |
207 | return 1 | |
208 | ||
209 | def testfindfactor(data): | |
210 | if verbose: | |
211 | print 'findfactor' | |
212 | if audioop.findfactor(data[1], data[1]) != 1.0: | |
213 | return 0 | |
214 | return 1 | |
215 | ||
216 | def testfindfit(data): | |
217 | if verbose: | |
218 | print 'findfit' | |
219 | if audioop.findfit(data[1], data[1]) != (0, 1.0): | |
220 | return 0 | |
221 | return 1 | |
222 | ||
223 | def testfindmax(data): | |
224 | if verbose: | |
225 | print 'findmax' | |
226 | if audioop.findmax(data[1], 1) != 2: | |
227 | return 0 | |
228 | return 1 | |
229 | ||
230 | def testgetsample(data): | |
231 | if verbose: | |
232 | print 'getsample' | |
233 | for i in range(3): | |
234 | if audioop.getsample(data[0], 1, i) != i or \ | |
235 | audioop.getsample(data[1], 2, i) != i or \ | |
236 | audioop.getsample(data[2], 4, i) != i: | |
237 | return 0 | |
238 | return 1 | |
239 | ||
240 | def testone(name, data): | |
241 | try: | |
242 | func = eval('test'+name) | |
243 | except NameError: | |
244 | print 'No test found for audioop.'+name+'()' | |
245 | return | |
246 | try: | |
247 | rv = func(data) | |
248 | except 'xx': | |
249 | print 'Test FAILED for audioop.'+name+'() (with an exception)' | |
250 | return | |
251 | if not rv: | |
252 | print 'Test FAILED for audioop.'+name+'()' | |
253 | ||
254 | def testall(): | |
255 | data = [gendata1(), gendata2(), gendata4()] | |
256 | names = dir(audioop) | |
257 | # We know there is a routine 'add' | |
258 | routines = [] | |
259 | for n in names: | |
260 | if type(eval('audioop.'+n)) == type(audioop.add): | |
261 | routines.append(n) | |
262 | for n in routines: | |
263 | testone(n, data) | |
264 | testall() |