Mercurial > hg > audiostuff

comparison spandsp-0.0.6pre17/tests/bert_tests.c @ 4:26cd8f1ef0b1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
import spandsp-0.0.6pre17
author Peter Meerwald <pmeerw@cosy.sbg.ac.at>
date Fri, 25 Jun 2010 15:50:58 +0200
parents
children
comparison
equal deleted inserted replaced
3:c6c5a16ce2f2 4:26cd8f1ef0b1
1 /*
2 * SpanDSP - a series of DSP components for telephony
3 *
4 * bert_tests.c - Tests for the BER tester.
5 *
6 * Written by Steve Underwood <steveu@coppice.org>
7 *
8 * Copyright (C) 2004 Steve Underwood
9 *
10 * All rights reserved.
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2, as
14 * published by the Free Software Foundation.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 *
25 * $Id: bert_tests.c,v 1.28 2009/05/30 15:23:13 steveu Exp $
26 */
27
28 /*! \file */
29
30 /*! \page bert_tests_page BERT tests
31 \section bert_tests_page_sec_1 What does it do?
32 These tests exercise each of the BERT standards supported by the BERT module.
33 */
34
35 #if defined(HAVE_CONFIG_H)
36 #include "config.h"
37 #endif
38
39 #include <stdlib.h>
40 #include <stdio.h>
41 #include <string.h>
42 #include <assert.h>
43 #include <sndfile.h>
44
45 //#if defined(WITH_SPANDSP_INTERNALS)
46 #define SPANDSP_EXPOSE_INTERNAL_STRUCTURES
47 //#endif
48
49 #include "spandsp.h"
50
51 /* Use a local random generator, so the results are consistent across platforms */
52 static int my_rand(void)
53 {
54 static int rndnum = 1234567;
55
56 return (rndnum = 1664525U*rndnum + 1013904223U);
57 }
58 /*- End of function --------------------------------------------------------*/
59
60 static void reporter(void *user_data, int reason, bert_results_t *results)
61 {
62 int channel;
63
64 channel = (int) (intptr_t) user_data;
65 printf("BERT report '%s' ", bert_event_to_str(reason));
66 switch (reason)
67 {
68 case BERT_REPORT_REGULAR:
69 printf("%d bits, %d bad bits, %d resyncs", results->total_bits, results->bad_bits, results->resyncs);
70 break;
71 }
72 printf("\r");
73 }
74 /*- End of function --------------------------------------------------------*/
75
76 int8_t test[0x800000];
77
78 int main(int argc, char *argv[])
79 {
80 bert_state_t tx_bert;
81 bert_state_t rx_bert;
82 bert_state_t bert;
83 bert_results_t bert_results;
84 int i;
85 int bit;
86 int zeros;
87 int max_zeros;
88 int failed;
89
90 bert_init(&tx_bert, 0, BERT_PATTERN_ZEROS, 300, 20);
91 bert_init(&rx_bert, 0, BERT_PATTERN_ZEROS, 300, 20);
92 for (i = 0; i < 511*2; i++)
93 {
94 bit = bert_get_bit(&tx_bert);
95 bert_put_bit(&rx_bert, bit);
96 }
97 bert_result(&rx_bert, &bert_results);
98 printf("Zeros: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
99 if (bert_results.bad_bits || bert_results.total_bits != 950)
100 {
101 printf("Test failed.\n");
102 exit(2);
103 }
104
105 bert_init(&tx_bert, 0, BERT_PATTERN_ONES, 300, 20);
106 bert_init(&rx_bert, 0, BERT_PATTERN_ONES, 300, 20);
107 for (i = 0; i < 511*2; i++)
108 {
109 bit = bert_get_bit(&tx_bert);
110 bert_put_bit(&rx_bert, bit);
111 }
112 bert_result(&rx_bert, &bert_results);
113 printf("Ones: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
114 if (bert_results.bad_bits || bert_results.total_bits != 950)
115 {
116 printf("Test failed.\n");
117 exit(2);
118 }
119
120 bert_init(&tx_bert, 0, BERT_PATTERN_1_TO_7, 300, 20);
121 bert_init(&rx_bert, 0, BERT_PATTERN_1_TO_7, 300, 20);
122 for (i = 0; i < 511*2; i++)
123 {
124 bit = bert_get_bit(&tx_bert);
125 bert_put_bit(&rx_bert, bit);
126 }
127 bert_result(&rx_bert, &bert_results);
128 printf("1 to 7: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
129 if (bert_results.bad_bits || bert_results.total_bits != 950)
130 {
131 printf("Test failed.\n");
132 exit(2);
133 }
134
135 bert_init(&tx_bert, 0, BERT_PATTERN_1_TO_3, 300, 20);
136 bert_init(&rx_bert, 0, BERT_PATTERN_1_TO_3, 300, 20);
137 for (i = 0; i < 511*2; i++)
138 {
139 bit = bert_get_bit(&tx_bert);
140 bert_put_bit(&rx_bert, bit);
141 }
142 bert_result(&rx_bert, &bert_results);
143 printf("1 to 3: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
144 if (bert_results.bad_bits || bert_results.total_bits != 950)
145 {
146 printf("Test failed.\n");
147 exit(2);
148 }
149
150 bert_init(&tx_bert, 0, BERT_PATTERN_1_TO_1, 300, 20);
151 bert_init(&rx_bert, 0, BERT_PATTERN_1_TO_1, 300, 20);
152 for (i = 0; i < 511*2; i++)
153 {
154 bit = bert_get_bit(&tx_bert);
155 bert_put_bit(&rx_bert, bit);
156 }
157 bert_result(&rx_bert, &bert_results);
158 printf("1 to 1: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
159 if (bert_results.bad_bits || bert_results.total_bits != 950)
160 {
161 printf("Test failed.\n");
162 exit(2);
163 }
164
165 bert_init(&tx_bert, 0, BERT_PATTERN_3_TO_1, 300, 20);
166 bert_init(&rx_bert, 0, BERT_PATTERN_3_TO_1, 300, 20);
167 for (i = 0; i < 511*2; i++)
168 {
169 bit = bert_get_bit(&tx_bert);
170 bert_put_bit(&rx_bert, bit);
171 }
172 bert_result(&rx_bert, &bert_results);
173 printf("3 to 1: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
174 if (bert_results.bad_bits || bert_results.total_bits != 950)
175 {
176 printf("Test failed.\n");
177 exit(2);
178 }
179
180 bert_init(&tx_bert, 0, BERT_PATTERN_7_TO_1, 300, 20);
181 bert_init(&rx_bert, 0, BERT_PATTERN_7_TO_1, 300, 20);
182 for (i = 0; i < 511*2; i++)
183 {
184 bit = bert_get_bit(&tx_bert);
185 bert_put_bit(&rx_bert, bit);
186 }
187 bert_result(&rx_bert, &bert_results);
188 printf("7 to 1: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
189 if (bert_results.bad_bits || bert_results.total_bits != 950)
190 {
191 printf("Test failed.\n");
192 exit(2);
193 }
194
195 bert_init(&tx_bert, 0, BERT_PATTERN_ITU_O153_9, 300, 20);
196 bert_init(&rx_bert, 0, BERT_PATTERN_ITU_O153_9, 300, 20);
197 for (i = 0; i < 0x200; i++)
198 test[i] = 0;
199 max_zeros = 0;
200 zeros = 0;
201 for (i = 0; i < 511*2; i++)
202 {
203 bit = bert_get_bit(&tx_bert);
204 if (bit)
205 {
206 if (zeros > max_zeros)
207 max_zeros = zeros;
208 zeros = 0;
209 }
210 else
211 {
212 zeros++;
213 }
214 bert_put_bit(&rx_bert, bit);
215 test[tx_bert.tx.reg]++;
216 }
217 failed = FALSE;
218 if (test[0] != 0)
219 {
220 printf("XXX %d %d\n", 0, test[0]);
221 failed = TRUE;
222 }
223 for (i = 1; i < 0x200; i++)
224 {
225 if (test[i] != 2)
226 {
227 printf("XXX %d %d\n", i, test[i]);
228 failed = TRUE;
229 }
230 }
231 bert_result(&rx_bert, &bert_results);
232 printf("O.153(9): Bad bits %d/%d, max zeros %d\n", bert_results.bad_bits, bert_results.total_bits, max_zeros);
233 if (bert_results.bad_bits || bert_results.total_bits != 986 || failed)
234 {
235 printf("Test failed.\n");
236 exit(2);
237 }
238
239 bert_init(&tx_bert, 0, BERT_PATTERN_ITU_O152_11, 300, 20);
240 bert_init(&rx_bert, 0, BERT_PATTERN_ITU_O152_11, 300, 20);
241 for (i = 0; i < 0x800; i++)
242 test[i] = 0;
243 max_zeros = 0;
244 zeros = 0;
245 for (i = 0; i < 2047*2; i++)
246 {
247 bit = bert_get_bit(&tx_bert);
248 if (bit)
249 {
250 if (zeros > max_zeros)
251 max_zeros = zeros;
252 zeros = 0;
253 }
254 else
255 {
256 zeros++;
257 }
258 bert_put_bit(&rx_bert, bit);
259 test[tx_bert.tx.reg]++;
260 }
261 failed = FALSE;
262 if (test[0] != 0)
263 {
264 printf("XXX %d %d\n", 0, test[0]);
265 failed = TRUE;
266 }
267 for (i = 1; i < 0x800; i++)
268 {
269 if (test[i] != 2)
270 {
271 printf("XXX %d %d\n", i, test[i]);
272 failed = TRUE;
273 }
274 }
275 bert_result(&rx_bert, &bert_results);
276 printf("O.152(11): Bad bits %d/%d, max zeros %d\n", bert_results.bad_bits, bert_results.total_bits, max_zeros);
277 if (bert_results.bad_bits || bert_results.total_bits != 4052 || failed)
278 {
279 printf("Test failed.\n");
280 exit(2);
281 }
282
283 bert_init(&tx_bert, 0, BERT_PATTERN_ITU_O151_15, 300, 20);
284 bert_init(&rx_bert, 0, BERT_PATTERN_ITU_O151_15, 300, 20);
285 for (i = 0; i < 0x8000; i++)
286 test[i] = 0;
287 max_zeros = 0;
288 zeros = 0;
289 for (i = 0; i < 32767*2; i++)
290 {
291 bit = bert_get_bit(&tx_bert);
292 if (bit)
293 {
294 if (zeros > max_zeros)
295 max_zeros = zeros;
296 zeros = 0;
297 }
298 else
299 {
300 zeros++;
301 }
302 bert_put_bit(&rx_bert, bit);
303 test[tx_bert.tx.reg]++;
304 }
305 failed = FALSE;
306 if (test[0] != 0)
307 {
308 printf("XXX %d %d\n", 0, test[0]);
309 failed = TRUE;
310 }
311 for (i = 1; i < 0x8000; i++)
312 {
313 if (test[i] != 2)
314 {
315 printf("XXX %d %d\n", i, test[i]);
316 failed = TRUE;
317 }
318 }
319 bert_result(&rx_bert, &bert_results);
320 printf("O.151(15): Bad bits %d/%d, max zeros %d\n", bert_results.bad_bits, bert_results.total_bits, max_zeros);
321 if (bert_results.bad_bits || bert_results.total_bits != 65480 || failed)
322 {
323 printf("Test failed.\n");
324 exit(2);
325 }
326
327 bert_init(&tx_bert, 0, BERT_PATTERN_ITU_O151_20, 300, 20);
328 bert_init(&rx_bert, 0, BERT_PATTERN_ITU_O151_20, 300, 20);
329 for (i = 0; i < 0x100000; i++)
330 test[i] = 0;
331 max_zeros = 0;
332 zeros = 0;
333 for (i = 0; i < 1048575*2; i++)
334 {
335 bit = bert_get_bit(&tx_bert);
336 if (bit)
337 {
338 if (zeros > max_zeros)
339 max_zeros = zeros;
340 zeros = 0;
341 }
342 else
343 {
344 zeros++;
345 }
346 bert_put_bit(&rx_bert, bit);
347 test[tx_bert.tx.reg]++;
348 }
349 failed = FALSE;
350 if (test[0] != 0)
351 {
352 printf("XXX %d %d\n", 0, test[0]);
353 failed = TRUE;
354 }
355 for (i = 1; i < 0x100000; i++)
356 {
357 if (test[i] != 2)
358 printf("XXX %d %d\n", i, test[i]);
359 }
360 bert_result(&rx_bert, &bert_results);
361 printf("O.151(20): Bad bits %d/%d, max zeros %d\n", bert_results.bad_bits, bert_results.total_bits, max_zeros);
362 if (bert_results.bad_bits || bert_results.total_bits != 2097066 || failed)
363 {
364 printf("Test failed.\n");
365 exit(2);
366 }
367
368 bert_init(&tx_bert, 0, BERT_PATTERN_ITU_O151_23, 300, 20);
369 bert_init(&rx_bert, 0, BERT_PATTERN_ITU_O151_23, 300, 20);
370 for (i = 0; i < 0x800000; i++)
371 test[i] = 0;
372 max_zeros = 0;
373 zeros = 0;
374 for (i = 0; i < 8388607*2; i++)
375 {
376 bit = bert_get_bit(&tx_bert);
377 if (bit)
378 {
379 if (zeros > max_zeros)
380 max_zeros = zeros;
381 zeros = 0;
382 }
383 else
384 {
385 zeros++;
386 }
387 bert_put_bit(&rx_bert, bit);
388 test[tx_bert.tx.reg]++;
389 }
390 failed = FALSE;
391 if (test[0] != 0)
392 {
393 printf("XXX %d %d\n", 0, test[0]);
394 failed = TRUE;
395 }
396 for (i = 1; i < 0x800000; i++)
397 {
398 if (test[i] != 2)
399 printf("XXX %d %d\n", i, test[i]);
400 }
401 bert_result(&rx_bert, &bert_results);
402 printf("O.151(23): Bad bits %d/%d, max zeros %d\n", bert_results.bad_bits, bert_results.total_bits, max_zeros);
403 if (bert_results.bad_bits || bert_results.total_bits != 16777136 || failed)
404 {
405 printf("Test failed.\n");
406 exit(2);
407 }
408
409 bert_init(&tx_bert, 0, BERT_PATTERN_QBF, 300, 20);
410 bert_init(&rx_bert, 0, BERT_PATTERN_QBF, 300, 20);
411 for (i = 0; i < 100000; i++)
412 {
413 bit = bert_get_bit(&tx_bert);
414 bert_put_bit(&rx_bert, bit);
415 }
416 bert_result(&rx_bert, &bert_results);
417 printf("QBF: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
418 if (bert_results.bad_bits || bert_results.total_bits != 100000)
419 {
420 printf("Test failed.\n");
421 exit(2);
422 }
423
424 /* Test the mechanism for categorising the error rate into <10^x bands */
425 /* TODO: The result of this test is not checked automatically */
426 bert_init(&bert, 15000000, BERT_PATTERN_ITU_O152_11, 300, 20);
427 bert_set_report(&bert, 100000, reporter, (intptr_t) 0);
428 for (;;)
429 {
430 if ((bit = bert_get_bit(&bert)) == SIG_STATUS_END_OF_DATA)
431 {
432 bert_result(&bert, &bert_results);
433 printf("Rate test: %d bits, %d bad bits, %d resyncs\n", bert_results.total_bits, bert_results.bad_bits, bert_results.resyncs);
434 if (bert_results.total_bits != 15000000 - 42
435 ||
436 bert_results.bad_bits != 58
437 ||
438 bert_results.resyncs != 0)
439 {
440 printf("Tests failed\n");
441 exit(2);
442 }
443 break;
444 //bert_init(&bert, 15000000, BERT_PATTERN_ITU_O152_11, 300, 20);
445 //bert_set_report(&bert, 100000, reporter, (intptr_t) 0);
446 //continue;
447 }
448 if ((my_rand() & 0x3FFFF) == 0)
449 bit ^= 1;
450 //if ((my_rand() & 0xFFF) == 0)
451 // bert_put_bit(&bert, bit);
452 bert_put_bit(&bert, bit);
453 }
454
455 printf("Tests passed.\n");
456 return 0;
457 }
458 /*- End of function --------------------------------------------------------*/
459 /*- End of file ------------------------------------------------------------*/

Repositories maintained by Peter Meerwald, pmeerw@pmeerw.net.