app_queue: Revert bad ringinuse=no patch.
[asterisk/asterisk.git] / tests / test_jitterbuf.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2012, Matt Jordan
5  *
6  * Matt Jordan <mjordan@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*!
20  * \file
21  * \brief Unit tests for jitterbuf.c
22  *
23  * \author\verbatim Matt Jordan <mjordan@digium.com> \endverbatim
24  *
25  * \ingroup tests
26  */
27
28 /*** MODULEINFO
29         <depend>TEST_FRAMEWORK</depend>
30         <support_level>core</support_level>
31  ***/
32
33 #include "asterisk.h"
34
35 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
36
37 #include "asterisk/utils.h"
38 #include "asterisk/module.h"
39 #include "asterisk/test.h"
40 #include "jitterbuf.h"
41
42 #define DEFAULT_MAX_JITTERBUFFER 1000
43 #define DEFAULT_RESYNCH_THRESHOLD 1000
44 #define DEFAULT_MAX_CONTIG_INTERP 10
45 #define DEFAULT_TARGET_EXTRA -1
46 #define DEFAULT_CODEC_INTERP_LEN 20
47
48 /*! \internal
49  * Test two numeric (long int) values.  Failure automatically attempts
50  * to jump to a cleanup tag
51  */
52 #define JB_NUMERIC_TEST(attribute, expected) do { \
53         if ((attribute) != (expected)) { \
54                 ast_test_status_update(test, #attribute ": expected [%ld]; actual [%ld]\n", (long int)(expected), (attribute)); \
55                 goto cleanup; \
56         } \
57 } while (0)
58
59 /*! \internal
60  * Print out as debug the frame related contents of a jb_info object
61  */
62 #define JB_INFO_PRINT_FRAME_DEBUG(jbinfo) do { \
63         ast_debug(1, "JitterBuffer Frame Info:\n" \
64                 "\tFrames In: %ld\n\tFrames Out: %ld\n" \
65                 "\tDropped Frames: %ld\n\tLate Frames: %ld\n" \
66                 "\tLost Frames: %ld\n\tOut of Order Frames: %ld\n" \
67                 "\tCurrent Frame: %ld\n", jbinfo.frames_in, jbinfo.frames_out, \
68                 jbinfo.frames_dropped, jbinfo.frames_late, jbinfo.frames_lost, \
69                 jbinfo.frames_ooo, jbinfo.frames_cur); \
70 } while (0)
71
72 /*! \internal
73  * This macro installs the error, warning, and debug functions for a test.  It is
74  * expected that at the end of a test, the functions are removed.
75  * Note that the debug statement is in here merely to aid in tracing in a log where
76  * the jitter buffer debug output begins.
77  */
78 #define JB_TEST_BEGIN(test_name) do { \
79         jb_setoutput(test_jb_error_output, test_jb_warn_output, test_jb_debug_output); \
80         ast_debug(1, "Starting %s\n", test_name); \
81 } while (0)
82
83 /*! \internal
84  * Uninstall the error, warning, and debug functions from a test
85  */
86 #define JB_TEST_END do { \
87         jb_setoutput(NULL, NULL, NULL); \
88 } while (0)
89
90 static const char *jitter_buffer_return_codes[] = {
91         "JB_OK",            /* 0 */
92         "JB_EMPTY",         /* 1 */
93         "JB_NOFRAME",       /* 2 */
94         "JB_INTERP",        /* 3 */
95         "JB_DROP",          /* 4 */
96         "JB_SCHED"          /* 5 */
97 };
98
99 /*! \internal \brief Make a default jitter buffer configuration */
100 static void test_jb_populate_config(struct jb_conf *jbconf)
101 {
102         if (!jbconf) {
103                 return;
104         }
105
106         jbconf->max_jitterbuf = DEFAULT_MAX_JITTERBUFFER;
107         jbconf->resync_threshold = DEFAULT_RESYNCH_THRESHOLD;
108         jbconf->max_contig_interp = DEFAULT_MAX_CONTIG_INTERP;
109         jbconf->target_extra = 0;
110 }
111
112 /*! \internal \brief Debug callback function for the jitter buffer's jb_dbg function */
113 static void __attribute__((format(printf, 1, 2))) test_jb_debug_output(const char *fmt, ...)
114 {
115         va_list args;
116         char buf[1024];
117
118         va_start(args, fmt);
119         vsnprintf(buf, sizeof(buf), fmt, args);
120         va_end(args);
121
122         ast_debug(1, "%s", buf);
123 }
124
125 /*! \internal \brief Warning callback function for the jitter buffer's jb_warn function */
126 static void __attribute__((format(printf, 1, 2))) test_jb_warn_output(const char *fmt, ...)
127 {
128         va_list args;
129         char buf[1024];
130
131         va_start(args, fmt);
132         vsnprintf(buf, sizeof(buf), fmt, args);
133         va_end(args);
134
135         ast_log(AST_LOG_WARNING, "%s", buf);
136 }
137
138 /*! \internal \brief Error callback function for the jitter buffer's jb_err function */
139 static void __attribute__((format(printf, 1, 2))) test_jb_error_output(const char *fmt, ...)
140 {
141         va_list args;
142         char buf[1024];
143
144         va_start(args, fmt);
145         vsnprintf(buf, sizeof(buf), fmt, args);
146         va_end(args);
147
148         ast_log(AST_LOG_ERROR, "%s", buf);
149 }
150
151 /*! \internal \brief Insert frames into the jitter buffer for the nominal tests */
152 static int test_jb_nominal_frame_insertion(struct ast_test *test, struct jitterbuf *jb, enum jb_frame_type frame_type)
153 {
154         int i = 0, ret = 0;
155
156         for (i = 0; i < 40; i++) {
157                 if (jb_put(jb, NULL, frame_type, 20, i * 20, i * 20 + 5) == JB_DROP) {
158                         ast_test_status_update(test, "Jitter buffer dropped packet %d\n", i);
159                         ret = 1;
160                         break;
161                 }
162         }
163
164         return ret;
165 }
166
167 AST_TEST_DEFINE(jitterbuffer_nominal_voice_frames)
168 {
169         enum ast_test_result_state result = AST_TEST_FAIL;
170         struct jitterbuf *jb = NULL;
171         struct jb_frame frame;
172         struct jb_conf jbconf;
173         struct jb_info jbinfo;
174         int i = 0;
175
176         switch (cmd) {
177         case TEST_INIT:
178                 info->name = "jitterbuffer_nominal_voice_frames";
179                 info->category = "/main/jitterbuf/";
180                 info->summary = "Nominal operation of jitter buffer with audio data";
181                 info->description =
182                         "Tests the nominal case of putting audio data into a jitter buffer, "
183                         "retrieving the frames, and querying for the next frame";
184                 return AST_TEST_NOT_RUN;
185         case TEST_EXECUTE:
186                 break;
187         }
188
189         JB_TEST_BEGIN("jitterbuffer_nominal_voice_frames");
190
191         if (!(jb = jb_new())) {
192                 ast_test_status_update(test, "Failed to allocate memory for jitterbuffer\n");
193                 goto cleanup;
194         }
195
196         test_jb_populate_config(&jbconf);
197         if (jb_setconf(jb, &jbconf) != JB_OK) {
198                 ast_test_status_update(test, "Failed to set jitterbuffer configuration\n");
199                 goto cleanup;
200         }
201
202         if (test_jb_nominal_frame_insertion(test, jb, JB_TYPE_VOICE)) {
203                 goto cleanup;
204         }
205
206         for (i = 0; i < 40; i++) {
207                 enum jb_return_code ret;
208                 /* We should have a frame for each point in time */
209                 if ((ret = jb_get(jb, &frame, i * 20 + 5, DEFAULT_CODEC_INTERP_LEN)) != JB_OK) {
210                         ast_test_status_update(test,
211                                 "Unexpected jitter buffer return code [%s] when retrieving frame %d\n",
212                                 jitter_buffer_return_codes[ret], i);
213                         goto cleanup;
214                 }
215                 JB_NUMERIC_TEST(frame.ms, 20);
216                 JB_NUMERIC_TEST(frame.ts, i * 20 - jb->info.resync_offset);
217                 JB_NUMERIC_TEST(jb_next(jb), (i + 1) * 20 + 5);
218         }
219
220         result = AST_TEST_PASS;
221
222         if (jb_getinfo(jb, &jbinfo) != JB_OK) {
223                 ast_test_status_update(test, "Failed to get jitterbuffer information\n");
224                 goto cleanup;
225         }
226         JB_INFO_PRINT_FRAME_DEBUG(jbinfo);
227         JB_NUMERIC_TEST(jbinfo.frames_dropped, 0);
228         JB_NUMERIC_TEST(jbinfo.frames_in, 40);
229         JB_NUMERIC_TEST(jbinfo.frames_out, 40);
230         JB_NUMERIC_TEST(jbinfo.frames_late, 0);
231         JB_NUMERIC_TEST(jbinfo.frames_lost, 0);
232         JB_NUMERIC_TEST(jbinfo.frames_ooo, 0);
233
234 cleanup:
235         if (jb) {
236                 /* No need to do anything - this will put all frames on the 'free' list,
237                  * so jb_destroy will dispose of them */
238                 while (jb_getall(jb, &frame) == JB_OK) { }
239                 jb_destroy(jb);
240         }
241
242         JB_TEST_END;
243
244         return result;
245 }
246
247 AST_TEST_DEFINE(jitterbuffer_nominal_control_frames)
248 {
249         enum ast_test_result_state result = AST_TEST_FAIL;
250         struct jitterbuf *jb = NULL;
251         struct jb_frame frame;
252         struct jb_conf jbconf;
253         struct jb_info jbinfo;
254         int i = 0;
255
256         switch (cmd) {
257         case TEST_INIT:
258                 info->name = "jitterbuffer_nominal_control_frames";
259                 info->category = "/main/jitterbuf/";
260                 info->summary = "Nominal operation of jitter buffer with control frames";
261                 info->description =
262                         "Tests the nominal case of putting control frames into a jitter buffer, "
263                         "retrieving the frames, and querying for the next frame";
264                 return AST_TEST_NOT_RUN;
265         case TEST_EXECUTE:
266                 break;
267         }
268
269         JB_TEST_BEGIN("jitterbuffer_nominal_control_frames");
270
271         if (!(jb = jb_new())) {
272                 ast_test_status_update(test, "Failed to allocate memory for jitterbuffer\n");
273                 goto cleanup;
274         }
275
276         test_jb_populate_config(&jbconf);
277         if (jb_setconf(jb, &jbconf) != JB_OK) {
278                 ast_test_status_update(test, "Failed to set jitterbuffer configuration\n");
279                 goto cleanup;
280         }
281
282         if (test_jb_nominal_frame_insertion(test, jb, JB_TYPE_CONTROL)) {
283                 goto cleanup;
284         }
285
286         for (i = 0; i < 40; i++) {
287                 enum jb_return_code ret;
288                 /* We should have a frame for each point in time */
289                 if ((ret = jb_get(jb, &frame, i * 20 + 5, DEFAULT_CODEC_INTERP_LEN)) != JB_OK) {
290                         ast_test_status_update(test,
291                                 "Unexpected jitter buffer return code [%s] when retrieving frame %d\n",
292                                 jitter_buffer_return_codes[ret], i);
293                         goto cleanup;
294                 }
295                 JB_NUMERIC_TEST(frame.ms, 20);
296                 JB_NUMERIC_TEST(frame.ts, i * 20 - jb->info.resync_offset);
297         }
298
299         if (jb_getinfo(jb, &jbinfo) != JB_OK) {
300                 ast_test_status_update(test, "Failed to get jitterbuffer information\n");
301                 goto cleanup;
302         }
303         JB_INFO_PRINT_FRAME_DEBUG(jbinfo);
304         JB_NUMERIC_TEST(jbinfo.frames_dropped, 0);
305         JB_NUMERIC_TEST(jbinfo.frames_in, 40);
306         JB_NUMERIC_TEST(jbinfo.frames_out, 40);
307         JB_NUMERIC_TEST(jbinfo.frames_late, 0);
308         JB_NUMERIC_TEST(jbinfo.frames_lost, 0);
309         JB_NUMERIC_TEST(jbinfo.frames_ooo, 0);
310
311         result = AST_TEST_PASS;
312
313 cleanup:
314         if (jb) {
315                 /* No need to do anything - this will put all frames on the 'free' list,
316                  * so jb_destroy will dispose of them */
317                 while (jb_getall(jb, &frame) == JB_OK) { }
318                 jb_destroy(jb);
319         }
320
321         JB_TEST_END;
322
323         return result;
324 }
325
326 /*! \internal \brief Insert frames into the jitter buffer for the out of order tests */
327 static int test_jb_out_of_order_frame_insertion(struct ast_test *test, struct jitterbuf *jb, enum jb_frame_type frame_type)
328 {
329         int i = 0, ret = 0;
330
331         for (i = 0; i < 40; i++) {
332                 if (i % 4 == 0) {
333                         /* Add the next frame */
334                         if (jb_put(jb, NULL, frame_type, 20, (i + 1) * 20, (i + 1) * 20 + 5) == JB_DROP) {
335                                 ast_test_status_update(test, "Jitter buffer dropped packet %d\n", (i+1));
336                                 ret = 1;
337                                 break;
338                         }
339                         /* Add the current frame */
340                         if (jb_put(jb, NULL, frame_type, 20, i * 20, i * 20 + 5) == JB_DROP) {
341                                 ast_test_status_update(test, "Jitter buffer dropped packet %d\n", i);
342                                 ret = 1;
343                                 break;
344                         }
345                         i++;
346                 } else {
347                         if (jb_put(jb, NULL, frame_type, 20, i * 20, i * 20 + 5) == JB_DROP) {
348                                 ast_test_status_update(test, "Jitter buffer dropped packet %d\n", i);
349                                 ret = 1;
350                                 break;
351                         }
352                 }
353         }
354
355         return ret;
356 }
357
358 AST_TEST_DEFINE(jitterbuffer_out_of_order_voice)
359 {
360         enum ast_test_result_state result = AST_TEST_FAIL;
361         struct jitterbuf *jb = NULL;
362         struct jb_frame frame;
363         struct jb_info jbinfo;
364         struct jb_conf jbconf;
365         int i;
366
367         switch (cmd) {
368         case TEST_INIT:
369                 info->name = "jitterbuffer_out_of_order_voice";
370                 info->category = "/main/jitterbuf/";
371                 info->summary = "Tests sending out of order audio frames to a jitter buffer";
372                 info->description =
373                         "Every 5th frame sent to a jitter buffer is reversed with the previous "
374                         "frame.  The expected result is to have a jitter buffer with the frames "
375                         "in order, while a total of 10 frames should be recorded as having been "
376                         "received out of order.";
377                 return AST_TEST_NOT_RUN;
378         case TEST_EXECUTE:
379                 break;
380         }
381
382         JB_TEST_BEGIN("jitterbuffer_out_of_order_voice");
383
384         if (!(jb = jb_new())) {
385                 ast_test_status_update(test, "Failed to allocate memory for jitterbuffer\n");
386                 goto cleanup;
387         }
388
389         test_jb_populate_config(&jbconf);
390         if (jb_setconf(jb, &jbconf) != JB_OK) {
391                 ast_test_status_update(test, "Failed to set jitterbuffer configuration\n");
392                 goto cleanup;
393         }
394
395         if (test_jb_out_of_order_frame_insertion(test, jb, JB_TYPE_VOICE)) {
396                 goto cleanup;
397         }
398
399         for (i = 0; i < 40; i++) {
400                 enum jb_return_code ret;
401                 /* We should have a frame for each point in time */
402                 if ((ret = jb_get(jb, &frame, i * 20 + 5, DEFAULT_CODEC_INTERP_LEN)) != JB_OK) {
403                         ast_test_status_update(test,
404                                 "Unexpected jitter buffer return code [%s] when retrieving frame %d\n",
405                                 jitter_buffer_return_codes[ret], i);
406                         goto cleanup;
407                 }
408                 JB_NUMERIC_TEST(frame.ms, 20);
409                 JB_NUMERIC_TEST(frame.ts, i * 20 - jb->info.resync_offset);
410         }
411
412         if (jb_getinfo(jb, &jbinfo) != JB_OK) {
413                 ast_test_status_update(test, "Failed to get jitterbuffer information\n");
414                 goto cleanup;
415         }
416         JB_INFO_PRINT_FRAME_DEBUG(jbinfo);
417         JB_NUMERIC_TEST(jbinfo.frames_dropped, 0);
418         JB_NUMERIC_TEST(jbinfo.frames_in, 40);
419         JB_NUMERIC_TEST(jbinfo.frames_out, 40);
420         JB_NUMERIC_TEST(jbinfo.frames_late, 0);
421         JB_NUMERIC_TEST(jbinfo.frames_lost, 0);
422         JB_NUMERIC_TEST(jbinfo.frames_ooo, 10);
423
424         result = AST_TEST_PASS;
425
426 cleanup:
427         if (jb) {
428                 /* No need to do anything - this will put all frames on the 'free' list,
429                  * so jb_destroy will dispose of them */
430                 while (jb_getall(jb, &frame) == JB_OK) { }
431                 jb_destroy(jb);
432         }
433
434         JB_TEST_END;
435
436         return result;
437 }
438
439 AST_TEST_DEFINE(jitterbuffer_out_of_order_control)
440 {
441         enum ast_test_result_state result = AST_TEST_FAIL;
442         struct jitterbuf *jb = NULL;
443         struct jb_frame frame;
444         struct jb_info jbinfo;
445         struct jb_conf jbconf;
446         int i;
447
448         switch (cmd) {
449         case TEST_INIT:
450                 info->name = "jitterbuffer_out_of_order_voice";
451                 info->category = "/main/jitterbuf/";
452                 info->summary = "Tests sending out of order audio frames to a jitter buffer";
453                 info->description =
454                         "Every 5th frame sent to a jitter buffer is reversed with the previous "
455                         "frame.  The expected result is to have a jitter buffer with the frames "
456                         "in order, while a total of 10 frames should be recorded as having been "
457                         "received out of order.";
458                 return AST_TEST_NOT_RUN;
459         case TEST_EXECUTE:
460                 break;
461         }
462
463         JB_TEST_BEGIN("jitterbuffer_out_of_order_control");
464
465         if (!(jb = jb_new())) {
466                 ast_test_status_update(test, "Failed to allocate memory for jitterbuffer\n");
467                 goto cleanup;
468         }
469
470         test_jb_populate_config(&jbconf);
471         if (jb_setconf(jb, &jbconf) != JB_OK) {
472                 ast_test_status_update(test, "Failed to set jitterbuffer configuration\n");
473                 goto cleanup;
474         }
475
476         if (test_jb_out_of_order_frame_insertion(test, jb, JB_TYPE_CONTROL)) {
477                 goto cleanup;
478         }
479
480         for (i = 0; i < 40; i++) {
481                 enum jb_return_code ret;
482                 /* We should have a frame for each point in time */
483                 if ((ret = jb_get(jb, &frame, i * 20 + 5, DEFAULT_CODEC_INTERP_LEN)) != JB_OK) {
484                         ast_test_status_update(test,
485                                 "Unexpected jitter buffer return code [%s] when retrieving frame %d\n",
486                                 jitter_buffer_return_codes[ret], i);
487                         goto cleanup;
488                 }
489                 JB_NUMERIC_TEST(frame.ms, 20);
490                 JB_NUMERIC_TEST(frame.ts, i * 20 - jb->info.resync_offset);
491         }
492
493         if (jb_getinfo(jb, &jbinfo) != JB_OK) {
494                 ast_test_status_update(test, "Failed to get jitterbuffer information\n");
495                 goto cleanup;
496         }
497         JB_INFO_PRINT_FRAME_DEBUG(jbinfo);
498         JB_NUMERIC_TEST(jbinfo.frames_dropped, 0);
499         JB_NUMERIC_TEST(jbinfo.frames_in, 40);
500         JB_NUMERIC_TEST(jbinfo.frames_out, 40);
501         JB_NUMERIC_TEST(jbinfo.frames_late, 0);
502         JB_NUMERIC_TEST(jbinfo.frames_lost, 0);
503         JB_NUMERIC_TEST(jbinfo.frames_ooo, 10);
504
505         result = AST_TEST_PASS;
506
507 cleanup:
508         if (jb) {
509                 /* No need to do anything - this will put all frames on the 'free' list,
510                  * so jb_destroy will dispose of them */
511                 while (jb_getall(jb, &frame) == JB_OK) { }
512                 jb_destroy(jb);
513         }
514
515         JB_TEST_END;
516
517         return result;
518 }
519
520 /*! \internal \brief Insert frames into the jitter buffer for the lost frame tests */
521 static int test_jb_lost_frame_insertion(struct ast_test *test, struct jitterbuf *jb, enum jb_frame_type frame_type)
522 {
523         int i = 0, ret = 0;
524
525         for (i = 0; i < 40; i++) {
526                 if (i % 5 == 0) {
527                         i++;
528                 }
529                 if (jb_put(jb, NULL, frame_type, 20, i * 20, i * 20 + 5) == JB_DROP) {
530                         ast_test_status_update(test, "Jitter buffer dropped packet %d\n", i);
531                         ret = 1;
532                         break;
533                 }
534         }
535
536         return ret;
537 }
538
539 AST_TEST_DEFINE(jitterbuffer_lost_voice)
540 {
541         enum ast_test_result_state result = AST_TEST_FAIL;
542         struct jitterbuf *jb = NULL;
543         struct jb_frame frame;
544         struct jb_conf jbconf;
545         struct jb_info jbinfo;
546         int i;
547
548         switch (cmd) {
549         case TEST_INIT:
550                 info->name = "jitterbuffer_lost_voice";
551                 info->category = "/main/jitterbuf/";
552                 info->summary = "Tests missing frames in the jitterbuffer";
553                 info->description =
554                         "Every 5th frame that would be sent to a jitter buffer is instead"
555                         "dropped.  When reading data from the jitter buffer, the jitter buffer"
556                         "should interpolate the voice frame.";
557                 return AST_TEST_NOT_RUN;
558         case TEST_EXECUTE:
559                 break;
560         }
561
562         JB_TEST_BEGIN("jitterbuffer_lost_voice");
563
564         if (!(jb = jb_new())) {
565                 ast_test_status_update(test, "Failed to allocate memory for jitterbuffer\n");
566                 goto cleanup;
567         }
568
569         test_jb_populate_config(&jbconf);
570         if (jb_setconf(jb, &jbconf) != JB_OK) {
571                 ast_test_status_update(test, "Failed to set jitterbuffer configuration\n");
572                 goto cleanup;
573         }
574
575         if (test_jb_lost_frame_insertion(test, jb, JB_TYPE_VOICE)) {
576                 goto cleanup;
577         }
578
579         for (i = 0; i < 40; i++) {
580                 enum jb_return_code ret;
581                 if ((ret = jb_get(jb, &frame, i * 20 + 5, DEFAULT_CODEC_INTERP_LEN)) != JB_OK) {
582                         /* If we didn't get an OK, make sure that it was an expected lost frame */
583                         if (!((ret == JB_INTERP && i % 5 == 0) || (ret == JB_NOFRAME && i == 0))) {
584                                 ast_test_status_update(test,
585                                         "Unexpected jitter buffer return code [%s] when retrieving frame %d\n",
586                                         jitter_buffer_return_codes[ret], i);
587                                 goto cleanup;
588                         }
589                 } else {
590                         JB_NUMERIC_TEST(frame.ms, 20);
591                         JB_NUMERIC_TEST(frame.ts, i * 20 - jb->info.resync_offset);
592                 }
593         }
594
595         if (jb_getinfo(jb, &jbinfo) != JB_OK) {
596                 ast_test_status_update(test, "Failed to get jitterbuffer information\n");
597                 goto cleanup;
598         }
599         JB_INFO_PRINT_FRAME_DEBUG(jbinfo);
600         /* Note: The first frame (at i = 0) never got added, so nothing existed at that point.
601          * Its neither dropped nor lost.
602          */
603         JB_NUMERIC_TEST(jbinfo.frames_ooo, 0);
604         JB_NUMERIC_TEST(jbinfo.frames_late, 0);
605         JB_NUMERIC_TEST(jbinfo.frames_lost, 7);
606         JB_NUMERIC_TEST(jbinfo.frames_in, 32);
607         JB_NUMERIC_TEST(jbinfo.frames_out, 32);
608         JB_NUMERIC_TEST(jbinfo.frames_dropped, 0);
609
610         result = AST_TEST_PASS;
611
612 cleanup:
613         if (jb) {
614                 /* No need to do anything - this will put all frames on the 'free' list,
615                  * so jb_destroy will dispose of them */
616                 while (jb_getall(jb, &frame) == JB_OK) { }
617                 jb_destroy(jb);
618         }
619
620         JB_TEST_END;
621
622         return result;
623 }
624
625 AST_TEST_DEFINE(jitterbuffer_lost_control)
626 {
627         enum ast_test_result_state result = AST_TEST_FAIL;
628         struct jitterbuf *jb = NULL;
629         struct jb_frame frame;
630         struct jb_conf jbconf;
631         struct jb_info jbinfo;
632         int i;
633
634         switch (cmd) {
635         case TEST_INIT:
636                 info->name = "jitterbuffer_lost_control";
637                 info->category = "/main/jitterbuf/";
638                 info->summary = "Tests missing frames in the jitterbuffer";
639                 info->description =
640                         "Every 5th frame that would be sent to a jitter buffer is instead"
641                         "dropped.  When reading data from the jitter buffer, the jitter buffer"
642                         "simply reports that no frame exists for that time slot";
643                 return AST_TEST_NOT_RUN;
644         case TEST_EXECUTE:
645                 break;
646         }
647
648         JB_TEST_BEGIN("jitterbuffer_lost_control");
649
650         if (!(jb = jb_new())) {
651                 ast_test_status_update(test, "Failed to allocate memory for jitterbuffer\n");
652                 goto cleanup;
653         }
654
655         test_jb_populate_config(&jbconf);
656         if (jb_setconf(jb, &jbconf) != JB_OK) {
657                 ast_test_status_update(test, "Failed to set jitterbuffer configuration\n");
658                 goto cleanup;
659         }
660
661         if (test_jb_lost_frame_insertion(test, jb, JB_TYPE_CONTROL)) {
662                 goto cleanup;
663         }
664
665         for (i = 0; i < 40; i++) {
666                 enum jb_return_code ret;
667                 if ((ret = jb_get(jb, &frame, i * 20 + 5, DEFAULT_CODEC_INTERP_LEN)) != JB_OK) {
668                         /* If we didn't get an OK, make sure that it was an expected lost frame */
669                         if (!(ret == JB_NOFRAME && i % 5 == 0)) {
670                                 ast_test_status_update(test,
671                                         "Unexpected jitter buffer return code [%s] when retrieving frame %d\n",
672                                         jitter_buffer_return_codes[ret], i);
673                                 goto cleanup;
674                         }
675                 } else {
676                         JB_NUMERIC_TEST(frame.ms, 20);
677                         JB_NUMERIC_TEST(frame.ts, i * 20 - jb->info.resync_offset);
678                 }
679         }
680
681         if (jb_getinfo(jb, &jbinfo) != JB_OK) {
682                 ast_test_status_update(test, "Failed to get jitterbuffer information\n");
683                 goto cleanup;
684         }
685         JB_INFO_PRINT_FRAME_DEBUG(jbinfo);
686         /* Note: The first frame (at i = 0) never got added, so nothing existed at that point.
687          * Its neither dropped nor lost.
688          */
689         JB_NUMERIC_TEST(jbinfo.frames_ooo, 0);
690         JB_NUMERIC_TEST(jbinfo.frames_late, 0);
691         JB_NUMERIC_TEST(jbinfo.frames_lost, 0);
692         JB_NUMERIC_TEST(jbinfo.frames_in, 32);
693         JB_NUMERIC_TEST(jbinfo.frames_out, 32);
694         JB_NUMERIC_TEST(jbinfo.frames_dropped, 0);
695
696         result = AST_TEST_PASS;
697
698 cleanup:
699         if (jb) {
700                 /* No need to do anything - this will put all frames on the 'free' list,
701                  * so jb_destroy will dispose of them */
702                 while (jb_getall(jb, &frame) == JB_OK) { }
703                 jb_destroy(jb);
704         }
705
706         JB_TEST_END;
707
708         return result;
709 }
710
711 /*! \internal \brief Insert frames into the jitter buffer for the late frame tests */
712 static int test_jb_late_frame_insertion(struct ast_test *test, struct jitterbuf *jb, enum jb_frame_type frame_type)
713 {
714         int i = 0, ret = 0;
715
716         for (i = 0; i < 40; i++) {
717                 if (i % 5 == 0) {
718                         /* Add 5th frame */
719                         if (jb_put(jb, NULL, frame_type, 20, i * 20, i * 20 + 20) == JB_DROP) {
720                                 ast_test_status_update(test, "Jitter buffer dropped packet %d\n", (i+1));
721                                 ret = 1;
722                                 break;
723                         }
724                 } else {
725                         if (jb_put(jb, NULL, frame_type, 20, i * 20, i * 20 + 5) == JB_DROP) {
726                                 ast_test_status_update(test, "Jitter buffer dropped packet %d\n", i);
727                                 ret = 1;
728                                 break;
729                         }
730                 }
731         }
732
733         return ret;
734 }
735
736 AST_TEST_DEFINE(jitterbuffer_late_voice)
737 {
738         enum ast_test_result_state result = AST_TEST_FAIL;
739         struct jitterbuf *jb = NULL;
740         struct jb_frame frame;
741         struct jb_info jbinfo;
742         struct jb_conf jbconf;
743         int i;
744
745         switch (cmd) {
746         case TEST_INIT:
747                 info->name = "jitterbuffer_late_voice";
748                 info->category = "/main/jitterbuf/";
749                 info->summary = "Tests sending frames to a jitter buffer that arrive late";
750                 info->description =
751                         "Every 5th frame sent to a jitter buffer arrives late, but still in "
752                         "order with respect to the previous and next packet";
753                 return AST_TEST_NOT_RUN;
754         case TEST_EXECUTE:
755                 break;
756         }
757
758         JB_TEST_BEGIN("jitterbuffer_late_voice");
759
760         if (!(jb = jb_new())) {
761                 ast_test_status_update(test, "Failed to allocate memory for jitterbuffer\n");
762                 goto cleanup;
763         }
764
765         test_jb_populate_config(&jbconf);
766         if (jb_setconf(jb, &jbconf) != JB_OK) {
767                 ast_test_status_update(test, "Failed to set jitterbuffer configuration\n");
768                 goto cleanup;
769         }
770
771         if (test_jb_late_frame_insertion(test, jb, JB_TYPE_VOICE)) {
772                 goto cleanup;
773         }
774
775         for (i = 0; i < 40; i++) {
776                 enum jb_return_code ret;
777                 /* We should have a frame for each point in time */
778                 if ((ret = jb_get(jb, &frame, i * 20 + 5, DEFAULT_CODEC_INTERP_LEN)) != JB_OK) {
779                         ast_test_status_update(test,
780                                 "Unexpected jitter buffer return code [%s] when retrieving frame %d\n",
781                                 jitter_buffer_return_codes[ret], i);
782                         goto cleanup;
783                 }
784                 JB_NUMERIC_TEST(frame.ms, 20);
785                 JB_NUMERIC_TEST(frame.ts, i * 20 - jb->info.resync_offset);
786         }
787
788         if (jb_getinfo(jb, &jbinfo) != JB_OK) {
789                 ast_test_status_update(test, "Failed to get jitterbuffer information\n");
790                 goto cleanup;
791         }
792         JB_INFO_PRINT_FRAME_DEBUG(jbinfo);
793         JB_NUMERIC_TEST(jbinfo.frames_ooo, 0);
794         JB_NUMERIC_TEST(jbinfo.frames_late, 0);
795         JB_NUMERIC_TEST(jbinfo.frames_lost, 0);
796         JB_NUMERIC_TEST(jbinfo.frames_in, 40);
797         JB_NUMERIC_TEST(jbinfo.frames_out, 40);
798         JB_NUMERIC_TEST(jbinfo.frames_dropped, 0);
799
800         result = AST_TEST_PASS;
801
802 cleanup:
803         if (jb) {
804                 /* No need to do anything - this will put all frames on the 'free' list,
805                  * so jb_destroy will dispose of them */
806                 while (jb_getall(jb, &frame) == JB_OK) { }
807                 jb_destroy(jb);
808         }
809
810         JB_TEST_END;
811
812         return result;
813 }
814
815 AST_TEST_DEFINE(jitterbuffer_late_control)
816 {
817         enum ast_test_result_state result = AST_TEST_FAIL;
818         struct jitterbuf *jb = NULL;
819         struct jb_frame frame;
820         struct jb_info jbinfo;
821         struct jb_conf jbconf;
822         int i;
823
824         switch (cmd) {
825         case TEST_INIT:
826                 info->name = "jitterbuffer_late_control";
827                 info->category = "/main/jitterbuf/";
828                 info->summary = "Tests sending frames to a jitter buffer that arrive late";
829                 info->description =
830                         "Every 5th frame sent to a jitter buffer arrives late, but still in "
831                         "order with respect to the previous and next packet";
832                 return AST_TEST_NOT_RUN;
833         case TEST_EXECUTE:
834                 break;
835         }
836
837         JB_TEST_BEGIN("jitterbuffer_late_voice");
838
839         if (!(jb = jb_new())) {
840                 ast_test_status_update(test, "Failed to allocate memory for jitterbuffer\n");
841                 goto cleanup;
842         }
843
844         test_jb_populate_config(&jbconf);
845         if (jb_setconf(jb, &jbconf) != JB_OK) {
846                 ast_test_status_update(test, "Failed to set jitterbuffer configuration\n");
847                 goto cleanup;
848         }
849
850         if (test_jb_late_frame_insertion(test, jb, JB_TYPE_CONTROL)) {
851                 goto cleanup;
852         }
853
854         for (i = 0; i < 40; i++) {
855                 enum jb_return_code ret;
856                 /* We should have a frame for each point in time */
857                 if ((ret = jb_get(jb, &frame, i * 20 + 5, DEFAULT_CODEC_INTERP_LEN)) != JB_OK) {
858                         ast_test_status_update(test,
859                                 "Unexpected jitter buffer return code [%s] when retrieving frame %d\n",
860                                 jitter_buffer_return_codes[ret], i);
861                         goto cleanup;
862                 }
863                 JB_NUMERIC_TEST(frame.ms, 20);
864                 JB_NUMERIC_TEST(frame.ts, i * 20 - jb->info.resync_offset);
865         }
866
867         if (jb_getinfo(jb, &jbinfo) != JB_OK) {
868                 ast_test_status_update(test, "Failed to get jitterbuffer information\n");
869                 goto cleanup;
870         }
871         JB_INFO_PRINT_FRAME_DEBUG(jbinfo);
872         JB_NUMERIC_TEST(jbinfo.frames_ooo, 0);
873         JB_NUMERIC_TEST(jbinfo.frames_late, 0);
874         JB_NUMERIC_TEST(jbinfo.frames_lost, 0);
875         JB_NUMERIC_TEST(jbinfo.frames_in, 40);
876         JB_NUMERIC_TEST(jbinfo.frames_out, 40);
877         JB_NUMERIC_TEST(jbinfo.frames_dropped, 0);
878
879         result = AST_TEST_PASS;
880
881 cleanup:
882         if (jb) {
883                 /* No need to do anything - this will put all frames on the 'free' list,
884                  * so jb_destroy will dispose of them */
885                 while (jb_getall(jb, &frame) == JB_OK) { }
886                 jb_destroy(jb);
887         }
888
889         JB_TEST_END;
890
891         return result;
892 }
893
894 /*! \internal \brief Insert frames into the jitter buffer for the overflow tests */
895 static void test_jb_overflow_frame_insertion(struct jitterbuf *jb, enum jb_frame_type frame_type)
896 {
897         int i = 0;
898
899         for (i = 0; i < 100; i++) {
900                 jb_put(jb, NULL, frame_type, 20, i * 20, i * 20 + 5);
901         }
902 }
903
904 AST_TEST_DEFINE(jitterbuffer_overflow_voice)
905 {
906         enum ast_test_result_state result = AST_TEST_FAIL;
907         struct jitterbuf *jb = NULL;
908         struct jb_frame frame;
909         struct jb_info jbinfo;
910         struct jb_conf jbconf;
911         int i = 0;
912
913         switch (cmd) {
914         case TEST_INIT:
915                 info->name = "jitterbuffer_overflow_voice";
916                 info->category = "/main/jitterbuf/";
917                 info->summary = "Tests overfilling a jitter buffer with voice frames";
918                 info->description = "Tests overfilling a jitter buffer with voice frames";
919                 return AST_TEST_NOT_RUN;
920         case TEST_EXECUTE:
921                 break;
922         }
923
924         JB_TEST_BEGIN("jitterbuffer_overflow_voice");
925
926         if (!(jb = jb_new())) {
927                 ast_test_status_update(test, "Failed to allocate memory for jitterbuffer\n");
928                 goto cleanup;
929         }
930
931         test_jb_populate_config(&jbconf);
932         if (jb_setconf(jb, &jbconf) != JB_OK) {
933                 ast_test_status_update(test, "Failed to set jitterbuffer configuration\n");
934                 goto cleanup;
935         }
936
937         test_jb_overflow_frame_insertion(jb, JB_TYPE_VOICE);
938
939         while (jb_get(jb, &frame, i * 20 + 5, DEFAULT_CODEC_INTERP_LEN) == JB_OK) {
940                 JB_NUMERIC_TEST(frame.ms, 20);
941                 JB_NUMERIC_TEST(frame.ts, i * 20 - jb->info.resync_offset);
942                 ++i;
943         }
944
945         if (jb_getinfo(jb, &jbinfo) != JB_OK) {
946                 ast_test_status_update(test, "Failed to get jitterbuffer information\n");
947                 goto cleanup;
948         }
949
950         JB_INFO_PRINT_FRAME_DEBUG(jbinfo);
951         JB_NUMERIC_TEST(jbinfo.frames_dropped, 49);
952         JB_NUMERIC_TEST(jbinfo.frames_out, 51);
953         JB_NUMERIC_TEST(jbinfo.frames_in, 51);
954         JB_NUMERIC_TEST(jbinfo.frames_late, 0);
955         /* Note that the last frame will be interpolated */
956         JB_NUMERIC_TEST(jbinfo.frames_lost, 1);
957         JB_NUMERIC_TEST(jbinfo.frames_ooo, 0);
958
959         result = AST_TEST_PASS;
960
961 cleanup:
962         if (jb) {
963                 /* No need to do anything - this will put all frames on the 'free' list,
964                  * so jb_destroy will dispose of them */
965                 while (jb_getall(jb, &frame) == JB_OK) { }
966                 jb_destroy(jb);
967         }
968
969         JB_TEST_END;
970
971         return result;
972 }
973
974 AST_TEST_DEFINE(jitterbuffer_overflow_control)
975 {
976         enum ast_test_result_state result = AST_TEST_FAIL;
977         struct jitterbuf *jb = NULL;
978         struct jb_frame frame;
979         struct jb_info jbinfo;
980         struct jb_conf jbconf;
981         int i = 0;
982
983         switch (cmd) {
984         case TEST_INIT:
985                 info->name = "jitterbuffer_overflow_control";
986                 info->category = "/main/jitterbuf/";
987                 info->summary = "Tests overfilling a jitter buffer with control frames";
988                 info->description = "Tests overfilling a jitter buffer with control frames";
989                 return AST_TEST_NOT_RUN;
990         case TEST_EXECUTE:
991                 break;
992         }
993
994         JB_TEST_BEGIN("jitterbuffer_overflow_control");
995
996         if (!(jb = jb_new())) {
997                 ast_test_status_update(test, "Failed to allocate memory for jitterbuffer\n");
998                 goto cleanup;
999         }
1000
1001         test_jb_populate_config(&jbconf);
1002         if (jb_setconf(jb, &jbconf) != JB_OK) {
1003                 ast_test_status_update(test, "Failed to set jitterbuffer configuration\n");
1004                 goto cleanup;
1005         }
1006
1007         test_jb_overflow_frame_insertion(jb, JB_TYPE_CONTROL);
1008
1009         while (jb_get(jb, &frame, i * 20 + 5, DEFAULT_CODEC_INTERP_LEN) == JB_OK) {
1010                 JB_NUMERIC_TEST(frame.ms, 20);
1011                 JB_NUMERIC_TEST(frame.ts, i * 20 - jb->info.resync_offset);
1012                 ++i;
1013         }
1014
1015         if (jb_getinfo(jb, &jbinfo) != JB_OK) {
1016                 ast_test_status_update(test, "Failed to get jitterbuffer information\n");
1017                 goto cleanup;
1018         }
1019
1020         JB_INFO_PRINT_FRAME_DEBUG(jbinfo);
1021         JB_NUMERIC_TEST(jbinfo.frames_dropped, 49);
1022         JB_NUMERIC_TEST(jbinfo.frames_out, 51);
1023         JB_NUMERIC_TEST(jbinfo.frames_in, 51);
1024         JB_NUMERIC_TEST(jbinfo.frames_late, 0);
1025         JB_NUMERIC_TEST(jbinfo.frames_lost, 0);
1026         JB_NUMERIC_TEST(jbinfo.frames_ooo, 0);
1027
1028         result = AST_TEST_PASS;
1029
1030 cleanup:
1031         if (jb) {
1032                 /* No need to do anything - this will put all frames on the 'free' list,
1033                  * so jb_destroy will dispose of them */
1034                 while (jb_getall(jb, &frame) == JB_OK) { }
1035                 jb_destroy(jb);
1036         }
1037
1038         JB_TEST_END;
1039
1040         return result;
1041 }
1042
1043 /*! \internal \brief Insert frames into the jitter buffer for the resynch tests */
1044 static void test_jb_resynch_frame_insertion(struct jitterbuf *jb, enum jb_frame_type frame_type)
1045 {
1046         int i = 0;
1047
1048         for (i = 0; i < 20; i++) {
1049                 jb_put(jb, NULL, frame_type, 20, i * 20, i * 20 + 5);
1050         }
1051
1052         for (i = 20; i < 40; i++) {
1053                 jb_put(jb, NULL, frame_type, 20, i * 20 + 500, i * 20 + 5);
1054         }
1055 }
1056
1057 AST_TEST_DEFINE(jitterbuffer_resynch_control)
1058 {
1059         enum ast_test_result_state result = AST_TEST_FAIL;
1060         struct jitterbuf *jb = NULL;
1061         struct jb_frame frame;
1062         struct jb_info jbinfo;
1063         struct jb_conf jbconf;
1064         int interpolated_frames = 0;
1065         int i;
1066
1067         switch (cmd) {
1068         case TEST_INIT:
1069                 info->name = "jitterbuffer_resynch_control";
1070                 info->category = "/main/jitterbuf/";
1071                 info->summary = "Tests sending control frames that force a resynch";
1072                 info->description = "Control frames are sent to a jitter buffer.  After some "
1073                         "number of frames, the source timestamps jump, forcing a resync of "
1074                         "the jitter buffer.  Since the frames are control, the resync happens "
1075                         "immediately.";
1076                 return AST_TEST_NOT_RUN;
1077         case TEST_EXECUTE:
1078                 break;
1079         }
1080
1081         JB_TEST_BEGIN("jitterbuffer_resynch_control");
1082
1083         if (!(jb = jb_new())) {
1084                 ast_test_status_update(test, "Failed to allocate memory for jitterbuffer\n");
1085                 goto cleanup;
1086         }
1087
1088         test_jb_populate_config(&jbconf);
1089         jbconf.resync_threshold = 200;
1090         if (jb_setconf(jb, &jbconf) != JB_OK) {
1091                 ast_test_status_update(test, "Failed to set jitterbuffer configuration\n");
1092                 goto cleanup;
1093         }
1094
1095         test_jb_resynch_frame_insertion(jb, JB_TYPE_CONTROL);
1096
1097         for (i = 0; i <= 40; i++) {
1098                 if (jb_get(jb, &frame, i * 20 + 5, DEFAULT_CODEC_INTERP_LEN) == JB_INTERP) {
1099                         ++interpolated_frames;
1100                 }
1101         }
1102
1103         if (jb_getinfo(jb, &jbinfo) != JB_OK) {
1104                 ast_test_status_update(test, "Failed to get jitterbuffer information\n");
1105                 goto cleanup;
1106         }
1107         /* With control frames, a resync happens automatically */
1108         JB_INFO_PRINT_FRAME_DEBUG(jbinfo);
1109         JB_NUMERIC_TEST(jbinfo.frames_dropped, 0);
1110         JB_NUMERIC_TEST(jbinfo.frames_out, 40);
1111         JB_NUMERIC_TEST(jbinfo.frames_in, 40);
1112         /* Verify that each of the interpolated frames is counted */
1113         JB_NUMERIC_TEST(jbinfo.frames_lost, interpolated_frames);
1114         JB_NUMERIC_TEST(jbinfo.frames_late, 0);
1115         JB_NUMERIC_TEST(jbinfo.frames_ooo, 0);
1116
1117         result = AST_TEST_PASS;
1118
1119 cleanup:
1120         if (jb) {
1121                 /* No need to do anything - this will put all frames on the 'free' list,
1122                  * so jb_destroy will dispose of them */
1123                 while (jb_getall(jb, &frame) == JB_OK) { }
1124                 jb_destroy(jb);
1125         }
1126
1127         JB_TEST_END;
1128
1129         return result;
1130 }
1131
1132 AST_TEST_DEFINE(jitterbuffer_resynch_voice)
1133 {
1134         enum ast_test_result_state result = AST_TEST_FAIL;
1135         struct jitterbuf *jb = NULL;
1136         struct jb_frame frame;
1137         struct jb_info jbinfo;
1138         struct jb_conf jbconf;
1139         int interpolated_frames = 0;
1140         int i;
1141
1142         switch (cmd) {
1143         case TEST_INIT:
1144                 info->name = "jitterbuffer_resynch_voice";
1145                 info->category = "/main/jitterbuf/";
1146                 info->summary = "Tests sending voice frames that force a resynch";
1147                 info->description = "Voice frames are sent to a jitter buffer.  After some "
1148                         "number of frames, the source timestamps jump, forcing a resync of "
1149                         "the jitter buffer.  Since the frames are voice, the resync happens "
1150                         "after observing three packets that break the resync threshold.";
1151                 return AST_TEST_NOT_RUN;
1152         case TEST_EXECUTE:
1153                 break;
1154         }
1155
1156         JB_TEST_BEGIN("jitterbuffer_resynch_voice");
1157
1158         if (!(jb = jb_new())) {
1159                 ast_test_status_update(test, "Failed to allocate memory for jitterbuffer\n");
1160                 goto cleanup;
1161         }
1162
1163         test_jb_populate_config(&jbconf);
1164         jbconf.resync_threshold = 200;
1165         if (jb_setconf(jb, &jbconf) != JB_OK) {
1166                 ast_test_status_update(test, "Failed to set jitterbuffer configuration\n");
1167                 goto cleanup;
1168         }
1169
1170         test_jb_resynch_frame_insertion(jb, JB_TYPE_VOICE);
1171
1172         for (i = 0; i <= 40; i++) {
1173                 if (jb_get(jb, &frame, i * 20 + 5, DEFAULT_CODEC_INTERP_LEN) == JB_INTERP) {
1174                         ++interpolated_frames;
1175                 }
1176         }
1177
1178         if (jb_getinfo(jb, &jbinfo) != JB_OK) {
1179                 ast_test_status_update(test, "Failed to get jitterbuffer information\n");
1180                 goto cleanup;
1181         }
1182         /* The first three packets before the resync should be dropped */
1183         JB_INFO_PRINT_FRAME_DEBUG(jbinfo);
1184         JB_NUMERIC_TEST(jbinfo.frames_dropped, 3);
1185         JB_NUMERIC_TEST(jbinfo.frames_out, 37);
1186         JB_NUMERIC_TEST(jbinfo.frames_in, 37);
1187         /* Verify that each of the interpolated frames is counted */
1188         JB_NUMERIC_TEST(jbinfo.frames_lost, interpolated_frames);
1189         JB_NUMERIC_TEST(jbinfo.frames_late, 0);
1190         JB_NUMERIC_TEST(jbinfo.frames_ooo, 0);
1191
1192
1193         result = AST_TEST_PASS;
1194
1195 cleanup:
1196         if (jb) {
1197                 /* No need to do anything - this will put all frames on the 'free' list,
1198                  * so jb_destroy will dispose of them */
1199                 while (jb_getall(jb, &frame) == JB_OK) { }
1200                 jb_destroy(jb);
1201         }
1202
1203         JB_TEST_END;
1204
1205         return result;
1206 }
1207
1208 static int unload_module(void)
1209 {
1210         AST_TEST_UNREGISTER(jitterbuffer_nominal_voice_frames);
1211         AST_TEST_UNREGISTER(jitterbuffer_nominal_control_frames);
1212         AST_TEST_UNREGISTER(jitterbuffer_out_of_order_voice);
1213         AST_TEST_UNREGISTER(jitterbuffer_out_of_order_control);
1214         AST_TEST_UNREGISTER(jitterbuffer_lost_voice);
1215         AST_TEST_UNREGISTER(jitterbuffer_lost_control);
1216         AST_TEST_UNREGISTER(jitterbuffer_late_voice);
1217         AST_TEST_UNREGISTER(jitterbuffer_late_control);
1218         AST_TEST_UNREGISTER(jitterbuffer_overflow_voice);
1219         AST_TEST_UNREGISTER(jitterbuffer_overflow_control);
1220         AST_TEST_UNREGISTER(jitterbuffer_resynch_voice);
1221         AST_TEST_UNREGISTER(jitterbuffer_resynch_control);
1222         return 0;
1223 }
1224
1225 static int load_module(void)
1226 {
1227         /* Nominal - put / get frames */
1228         AST_TEST_REGISTER(jitterbuffer_nominal_voice_frames);
1229         AST_TEST_REGISTER(jitterbuffer_nominal_control_frames);
1230
1231         /* Out of order frame arrival */
1232         AST_TEST_REGISTER(jitterbuffer_out_of_order_voice);
1233         AST_TEST_REGISTER(jitterbuffer_out_of_order_control);
1234
1235         /* Lost frame arrival */
1236         AST_TEST_REGISTER(jitterbuffer_lost_voice);
1237         AST_TEST_REGISTER(jitterbuffer_lost_control);
1238
1239         /* Late frame arrival */
1240         AST_TEST_REGISTER(jitterbuffer_late_voice);
1241         AST_TEST_REGISTER(jitterbuffer_late_control);
1242
1243         /* Buffer overflow */
1244         AST_TEST_REGISTER(jitterbuffer_overflow_voice);
1245         AST_TEST_REGISTER(jitterbuffer_overflow_control);
1246
1247         /* Buffer resynch */
1248         AST_TEST_REGISTER(jitterbuffer_resynch_voice);
1249         AST_TEST_REGISTER(jitterbuffer_resynch_control);
1250
1251         return AST_MODULE_LOAD_SUCCESS;
1252 }
1253
1254 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Jitter Buffer Tests");