app_queue: Revert bad ringinuse=no patch.
[asterisk/asterisk.git] / tests / test_abstract_jb.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 Abstract Jitterbuffer Tests
22  *
23  * \author \verbatim Matt Jordan <mjordan@digium.com> \endverbatim
24  *
25  * Tests the abstract jitter buffer API.  This tests both adaptive and fixed
26  * jitter buffers.  Functions defined in abstract_jb that are not part of the
27  * abstract jitter buffer API are not tested by this unit test.
28  *
29  * \ingroup tests
30  */
31
32 /*** MODULEINFO
33         <depend>TEST_FRAMEWORK</depend>
34         <support_level>core</support_level>
35  ***/
36
37 #include "asterisk.h"
38
39 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
40
41 #include "asterisk/utils.h"
42 #include "asterisk/module.h"
43 #include "asterisk/test.h"
44 #include "asterisk/abstract_jb.h"
45 #include "asterisk/frame.h"
46
47 #define DEFAULT_FRAME_MS 160
48 #define DEFAULT_CONFIG_FLAGS 0
49 #define DEFAULT_CONFIG_SIZE (DEFAULT_FRAME_MS) * 10
50 #define DEFAULT_CONFIG_RESYNC_THRESHOLD (DEFAULT_FRAME_MS) * 2
51 #define DEFAULT_CONFIG_TARGET_EXTRA -1
52
53 /*! \internal \brief Destructor for a jitter buffer
54  * \param jb The jitter buffer to destroy
55  * \note This will destroy all frames still in the jitter buffer
56  */
57 static void dispose_jitterbuffer(struct ast_jb *jb)
58 {
59         if (!jb || !jb->impl || !jb->jbobj) {
60                 return;
61         }
62
63         jb->impl->empty_and_reset(jb->jbobj);
64
65         jb->impl->destroy(jb->jbobj);
66         jb->impl = NULL;
67         jb->jbobj = NULL;
68 }
69
70 /*! \internal \brief Destructor for frames
71  * \param f The frame to destroy
72  */
73 static void dispose_frame(struct ast_frame *f)
74 {
75         if (!f) {
76                 return;
77         }
78         ast_frfree(f);
79 }
80
81 /*! \internal \brief Create a test frame
82  * \param timestamp the time in ms of the frame
83  * \param seqno the frame's sequence number
84  * \returns a malloc'd frame
85  */
86 static struct ast_frame *create_test_frame(long timestamp,
87                 int seqno)
88 {
89         struct ast_frame f = {0};
90
91         f.subclass.format.id = AST_FORMAT_SLINEAR;
92         f.frametype = AST_FRAME_VOICE;
93         f.src = "TEST";
94         f.ts = timestamp;
95         f.len = DEFAULT_FRAME_MS;
96         f.seqno = seqno;
97
98         return ast_frisolate(&f);
99 }
100
101 /*! \internal
102  * \brief Test two numeric (long int) values.
103 */
104 #define LONG_INT_TEST(actual, expected) do { \
105         if ((actual) != (expected)) { \
106                 ast_test_status_update(test, #actual ": expected [%ld]; actual [%ld]\n", (long int)(expected), (long int)(actual)); \
107                 return AST_TEST_FAIL; \
108         } } while (0)
109
110 /*! \internal
111  * \brief Test two numeric (int) values.
112 */
113 #define INT_TEST(actual, expected) do { \
114         if ((actual) != (expected)) { \
115                 ast_test_status_update(test, #actual ": expected [%d]; actual [%d]\n", (expected), (actual)); \
116                 return AST_TEST_FAIL; \
117         } } while (0)
118
119 /*! \internal
120  * \brief Test two string values
121 */
122 #define STRING_TEST(actual, expected) do { \
123         if (strcmp((actual), (expected))) { \
124                 ast_test_status_update(test, #actual ": expected [%s]; actual [%s]\n", (expected), (actual)); \
125                 return AST_TEST_FAIL; \
126         } } while (0)
127
128 /*! \internal
129  * \brief Verify that two frames have the same properties
130  */
131 #define VERIFY_FRAME(actual, expected) do { \
132         INT_TEST((actual)->frametype, (expected)->frametype); \
133         INT_TEST((actual)->seqno, (expected)->seqno); \
134         LONG_INT_TEST((actual)->ts, (expected)->ts); \
135         LONG_INT_TEST((actual)->len, (expected)->len); \
136         STRING_TEST((actual)->src, (expected)->src); \
137 } while (0)
138
139 /*! \internal
140  * \brief Get the implementation for a jitter buffer
141  */
142 #define OBTAIN_JITTERBUFFER_IMPL(impl, ast_jb_type, literal_name) do { \
143         (impl) = ast_jb_get_impl((ast_jb_type)); \
144         if (!(impl)) { \
145                 ast_test_status_update(test, "Error: no %s jitterbuffer defined\n", (literal_name)); \
146                 return AST_TEST_FAIL; \
147         } \
148         if (strcmp((impl)->name, (literal_name))) { \
149                 ast_test_status_update(test, "Error: requested %s jitterbuffer and received %s\n", (literal_name), (impl)->name); \
150                 return AST_TEST_FAIL; \
151         } } while (0)
152
153 /*! \internal
154  * \brief Make a jitter buffer configuration object with default values
155  */
156 #define MAKE_DEFAULT_CONFIG(conf, impl) do { \
157         (conf)->flags = DEFAULT_CONFIG_FLAGS; \
158         strcpy((conf)->impl, (impl)->name); \
159         (conf)->max_size = DEFAULT_CONFIG_SIZE; \
160         (conf)->resync_threshold = DEFAULT_CONFIG_RESYNC_THRESHOLD; \
161         (conf)->target_extra = DEFAULT_CONFIG_TARGET_EXTRA; \
162         } while (0)
163
164 /*! \internal \brief A container object for the jitter buffers, used for all tests*/
165 static struct ast_jb default_jb = {
166         .impl = NULL,
167         .jbobj = NULL
168 };
169
170 /*! \internal \brief Construct a test name */
171 #define TEST_NAME(type_name, specifier) type_name ## _  ## specifier
172
173 #define TEST_NAME2(test_name) #test_name
174 #define STRINGIFY_TESTNAME(test_name) TEST_NAME2(test_name)
175
176 /*! \internal \brief Test nominal construction of a jitter buffer
177  * \param type_name The enum type of the jitter buffer to create
178  * \param literal_type_name The literal name of the type - "fixed" or "adaptive"
179  */
180 #define test_create_nominal(type_name, literal_type_name) AST_TEST_DEFINE(TEST_NAME(type_name, create)) {\
181         RAII_VAR(struct ast_jb *, jb, &default_jb, dispose_jitterbuffer); \
182         const struct ast_jb_impl *impl; \
183         struct ast_jb_conf conf; \
184 \
185         switch (cmd) { \
186         case TEST_INIT: \
187                 info->name = STRINGIFY_TESTNAME(TEST_NAME(type_name, create)); \
188                 info->category = "/main/abstract_jb/"; \
189                 info->summary = "Test nominal creation of a " literal_type_name " jitterbuffer"; \
190                 info->description = \
191                         "Tests nominal creation of a " literal_type_name " jitterbuffer using the " \
192                         " jitterbuffer API."; \
193                 return AST_TEST_NOT_RUN; \
194         case TEST_EXECUTE: \
195                 break; \
196         } \
197  \
198         ast_test_status_update(test, "Executing " STRINGIFY_TESTNAME(TEST_NAME(type_name,  create))"...\n"); \
199         OBTAIN_JITTERBUFFER_IMPL(impl, (type_name), (literal_type_name)); \
200         MAKE_DEFAULT_CONFIG(&conf, impl); \
201  \
202         jb->jbobj = impl->create(&conf); \
203         jb->impl = impl; \
204         if (!jb->jbobj) { \
205                 ast_test_status_update(test, "Error: Failed to adaptive jitterbuffer\n"); \
206                 return AST_TEST_FAIL; \
207         } \
208  \
209         return AST_TEST_PASS; \
210 }
211
212 /*! \internal \brief Test putting the initial frame into a jitter buffer
213  * \param type_name The enum type of the jitter buffer to create
214  * \param literal_type_name The literal name of the type - "fixed" or "adaptive"
215  */
216 #define test_put_first(type_name, literal_type_name) AST_TEST_DEFINE(TEST_NAME(type_name,  put_first)) {\
217         RAII_VAR(struct ast_jb *, jb, &default_jb, dispose_jitterbuffer); \
218         const struct ast_jb_impl *impl; \
219         struct ast_jb_conf conf; \
220         RAII_VAR(struct ast_frame *, expected_frame, NULL, dispose_frame); \
221         RAII_VAR(struct ast_frame *, actual_frame, NULL, dispose_frame); \
222         int res; \
223 \
224         switch (cmd) { \
225         case TEST_INIT: \
226                 info->name = STRINGIFY_TESTNAME(TEST_NAME(type_name,  put_first)); \
227                 info->category = "/main/abstract_jb/"; \
228                 info->summary = "Test putting a frame into a " literal_type_name " jitterbuffer"; \
229                 info->description = \
230                         "This tests putting a single frame into a " literal_type_name " jitterbuffer " \
231                         "when the jitterbuffer is empty and verifying that it is indeed " \
232                         "the first frame on the jitterbufffer"; \
233                 return AST_TEST_NOT_RUN; \
234         case TEST_EXECUTE: \
235                 break; \
236         } \
237 \
238         ast_test_status_update(test, "Executing " STRINGIFY_TESTNAME(TEST_NAME(type_name,  create))"...\n"); \
239         OBTAIN_JITTERBUFFER_IMPL(impl, (type_name), (literal_type_name)); \
240         MAKE_DEFAULT_CONFIG(&conf, impl); \
241         jb->jbobj = impl->create(&conf); \
242         jb->impl = impl; \
243         if (!jb->jbobj) { \
244                 ast_test_status_update(test, "Error: Failed to adaptive jitterbuffer\n"); \
245                 return AST_TEST_FAIL; \
246         } \
247 \
248         expected_frame = create_test_frame(1000, 0); \
249         res = jb->impl->put_first(jb->jbobj, \
250                 expected_frame, \
251                 1100); \
252         if (res != AST_JB_IMPL_OK) { \
253                 ast_test_status_update(test, "Error: Got %d back from put_first (expected %d)\n", \
254                         res, AST_JB_IMPL_OK); \
255                 return AST_TEST_FAIL; \
256         } \
257 \
258         res = jb->impl->remove(jb->jbobj, &actual_frame); \
259         if (!actual_frame || res != AST_JB_IMPL_OK) { \
260                 ast_test_status_update(test, "Error: failed to retrieve first frame\n"); \
261                 return AST_TEST_FAIL; \
262         } \
263         expected_frame = create_test_frame(1000, 0); \
264         VERIFY_FRAME(actual_frame, expected_frame); \
265         return AST_TEST_PASS; \
266 }
267
268 /*! \internal \brief Test putting a voice frames into a jitter buffer
269  * \param type_name The enum type of the jitter buffer to create
270  * \param literal_type_name The literal name of the type - "fixed" or "adaptive"
271  */
272 #define test_put(type_name, literal_type_name) AST_TEST_DEFINE(TEST_NAME(type_name, put)) {\
273         RAII_VAR(struct ast_jb *, jb, &default_jb, dispose_jitterbuffer); \
274         const struct ast_jb_impl *impl; \
275         struct ast_jb_conf conf; \
276         RAII_VAR(struct ast_frame *, expected_frame, NULL, dispose_frame); \
277         RAII_VAR(struct ast_frame *, actual_frame, NULL, dispose_frame); \
278         int res; \
279         long next; \
280         int i; \
281 \
282         switch (cmd) { \
283         case TEST_INIT: \
284                 info->name = STRINGIFY_TESTNAME(TEST_NAME(type_name, put)); \
285                 info->category = "/main/abstract_jb/"; \
286                 info->summary = "Test putting frames onto a " literal_type_name " jitterbuffer"; \
287                 info->description = \
288                         "This tests putting multiple frames into a " literal_type_name " jitterbuffer"; \
289                 return AST_TEST_NOT_RUN; \
290         case TEST_EXECUTE: \
291                 break; \
292         } \
293 \
294         ast_test_status_update(test, "Executing "STRINGIFY_TESTNAME(TEST_NAME(type_name, put))"...\n"); \
295         OBTAIN_JITTERBUFFER_IMPL(impl, (type_name), (literal_type_name)); \
296         MAKE_DEFAULT_CONFIG(&conf, impl); \
297         jb->jbobj = impl->create(&conf); \
298         jb->impl = impl; \
299 \
300         expected_frame = create_test_frame(1000, 0); \
301         jb->impl->put_first(jb->jbobj, expected_frame, 1100); \
302         for (i = 1; i < 10; i++) { \
303                 expected_frame = create_test_frame(1000 + i * DEFAULT_FRAME_MS, 0); \
304                 res = jb->impl->put(jb->jbobj, \
305                         expected_frame, \
306                         1100 + i * DEFAULT_FRAME_MS); \
307                 if (res != AST_JB_IMPL_OK) { \
308                         ast_test_status_update(test, "Error: On frame %d, got %d back from put (expected %d)\n", \
309                                 i, res, AST_JB_IMPL_OK); \
310                         return AST_TEST_FAIL; \
311                 } \
312         } \
313 \
314         for (i = 0; i < 10; i++) { \
315                 expected_frame = create_test_frame(1000 + i * DEFAULT_FRAME_MS, 0); \
316                 next = jb->impl->next(jb->jbobj); \
317                 res = jb->impl->get(jb->jbobj, &actual_frame, next, DEFAULT_FRAME_MS); \
318                 if (res != AST_JB_IMPL_OK) { \
319                         ast_test_status_update(test, "Error: failed to retrieve frame %i at time %ld\n", \
320                                 i, next); \
321                         return AST_TEST_FAIL; \
322                 } \
323                 VERIFY_FRAME(actual_frame, expected_frame); \
324                 ast_frfree(expected_frame); \
325                 expected_frame = NULL; \
326         } \
327         return AST_TEST_PASS; \
328 }
329
330 /*! \internal \brief Test overflowing the limits of a jitter buffer
331  * \param type_name The enum type of the jitter buffer to create
332  * \param literal_type_name The literal name of the type - "fixed" or "adaptive"
333  * \param overflow_limit The number of frames at which we expect the buffer to overflow
334  */
335 #define test_put_overflow(type_name, literal_type_name, overflow_limit) AST_TEST_DEFINE(TEST_NAME(type_name, put_overflow)) {\
336         RAII_VAR(struct ast_jb *, jb, &default_jb, dispose_jitterbuffer); \
337         const struct ast_jb_impl *impl; \
338         struct ast_jb_conf conf; \
339         RAII_VAR(struct ast_frame *, expected_frame, NULL, dispose_frame); \
340         int res; \
341         int i; \
342 \
343         switch (cmd) { \
344         case TEST_INIT: \
345                 info->name = STRINGIFY_TESTNAME(TEST_NAME(type_name,  put_overflow)); \
346                 info->category = "/main/abstract_jb/"; \
347                 info->summary = "Test putting frames onto a " literal_type_name " jitterbuffer " \
348                         "that ends up overflowing the maximum allowed slots in the buffer"; \
349                 info->description = \
350                         "This tests putting multiple frames into a " literal_type_name " jitterbuffer " \
351                         "until the jitterbuffer overflows"; \
352                 return AST_TEST_NOT_RUN; \
353         case TEST_EXECUTE: \
354                 break; \
355         } \
356 \
357         ast_test_status_update(test, "Executing "STRINGIFY_TESTNAME(TEST_NAME(type_name, put_overflow))"...\n"); \
358         OBTAIN_JITTERBUFFER_IMPL(impl, (type_name), (literal_type_name)); \
359         MAKE_DEFAULT_CONFIG(&conf, impl); \
360         jb->jbobj = impl->create(&conf); \
361         jb->impl = impl; \
362 \
363         expected_frame = create_test_frame(1000, 0); \
364         jb->impl->put_first(jb->jbobj, expected_frame, 1100); \
365         for (i = 1; i <= (overflow_limit); i++) { \
366                 expected_frame = create_test_frame(1000 + i * DEFAULT_FRAME_MS, 0); \
367                 res = jb->impl->put(jb->jbobj, \
368                         expected_frame, \
369                         1100 + i * DEFAULT_FRAME_MS); \
370                 if (res != AST_JB_IMPL_OK) { \
371                         ast_test_status_update(test, "Error: On frame %d, got %d back from put (expected %d)\n", \
372                                 i, res, AST_JB_IMPL_OK); \
373                         return AST_TEST_FAIL; \
374                 } \
375         } \
376 \
377         for (i = (overflow_limit)+1; i < (overflow_limit) + 5; i++) { \
378                 expected_frame = create_test_frame(1000 + i * DEFAULT_FRAME_MS, 0); \
379                 res = jb->impl->put(jb->jbobj, \
380                         expected_frame, \
381                         1100 + i * DEFAULT_FRAME_MS); \
382                 if (res != AST_JB_IMPL_DROP) { \
383                         expected_frame = NULL; \
384                         ast_test_status_update(test, "Error: On frame %d, got %d back from put (expected %d)\n", \
385                                 i, res, AST_JB_IMPL_DROP); \
386                         return AST_TEST_FAIL; \
387                 } \
388                 ast_frfree(expected_frame); \
389                 expected_frame = NULL;\
390         } \
391 \
392         return AST_TEST_PASS; \
393 }
394
395 /*! \internal \brief Test putting voice frames into a jitter buffer out of order
396  * \param type_name The enum type of the jitter buffer to create
397  * \param literal_type_name The literal name of the type - "fixed" or "adaptive"
398  * \param synch_limit The synchronization limit for this particular type of jitter buffer
399  */
400 #define test_put_out_of_order(type_name, literal_type_name, synch_limit) AST_TEST_DEFINE(TEST_NAME(type_name, put_out_of_order)) {\
401         RAII_VAR(struct ast_jb *, jb, &default_jb, dispose_jitterbuffer); \
402         const struct ast_jb_impl *impl; \
403         struct ast_jb_conf conf; \
404         RAII_VAR(struct ast_frame *, actual_frame, NULL, dispose_frame); \
405         RAII_VAR(struct ast_frame *, expected_frame, NULL, dispose_frame); \
406         int res; \
407         long next; \
408         int i; \
409 \
410         switch (cmd) { \
411         case TEST_INIT: \
412                 info->name = STRINGIFY_TESTNAME(TEST_NAME(type_name, put_out_of_order)); \
413                 info->category = "/main/abstract_jb/"; \
414                 info->summary = "Test putting out of order frames onto a " literal_type_name " jitterbuffer"; \
415                 info->description = \
416                         "This tests putting multiple frames into a " literal_type_name " jitterbuffer " \
417                         "that arrive out of order.  Every 3rd frame is put in out of order."; \
418                 return AST_TEST_NOT_RUN; \
419         case TEST_EXECUTE: \
420                 break; \
421         } \
422 \
423         ast_test_status_update(test, "Executing " STRINGIFY_TESTNAME(TEST_NAME(type_name, put_out_of_order)) "...\n"); \
424         OBTAIN_JITTERBUFFER_IMPL(impl, (type_name), (literal_type_name)); \
425         MAKE_DEFAULT_CONFIG(&conf, impl); \
426         conf.resync_threshold = (synch_limit); \
427         jb->jbobj = impl->create(&conf); \
428         jb->impl = impl; \
429 \
430         expected_frame = create_test_frame(1000, 0); \
431         jb->impl->put_first(jb->jbobj, expected_frame, 1100); \
432         for (i = 1; i <= 10; i++) { \
433                 if (i % 3 == 1 && i != 10) { \
434                         expected_frame = create_test_frame(1000 + ((i + 1) * DEFAULT_FRAME_MS), 0); \
435                 } else if (i % 3 == 2) { \
436                         expected_frame = create_test_frame(1000 + ((i - 1) * DEFAULT_FRAME_MS), 0); \
437                 } else { \
438                         expected_frame = create_test_frame(1000 + i * DEFAULT_FRAME_MS, 0); \
439                 } \
440                 res = jb->impl->put(jb->jbobj, \
441                         expected_frame, \
442                         1100 + i * DEFAULT_FRAME_MS); \
443                 if (res != AST_JB_IMPL_OK) { \
444                         ast_test_status_update(test, "Error: On frame %d, got %d back from put (expected %d)\n", \
445                                 i, res, AST_JB_IMPL_OK); \
446                         return AST_TEST_FAIL; \
447                 } \
448         } \
449 \
450         for (i = 0; i <= 10; i++) { \
451                 expected_frame = create_test_frame(1000 + i * DEFAULT_FRAME_MS, 0); \
452                 next = jb->impl->next(jb->jbobj); \
453                 res = jb->impl->get(jb->jbobj, &actual_frame, next, DEFAULT_FRAME_MS); \
454                 if (res != AST_JB_IMPL_OK) { \
455                         ast_test_status_update(test, "Error: failed to retrieve frame at %ld\n", \
456                                 next); \
457                         return AST_TEST_FAIL; \
458                 } \
459                 VERIFY_FRAME(actual_frame, expected_frame); \
460                 ast_frfree(expected_frame); \
461                 expected_frame = NULL; \
462         } \
463 \
464         return AST_TEST_PASS; \
465 }
466
467
468 test_create_nominal(AST_JB_ADAPTIVE, "adaptive")
469
470 test_put_first(AST_JB_ADAPTIVE, "adaptive")
471
472 test_put(AST_JB_ADAPTIVE, "adaptive")
473
474 test_put_overflow(AST_JB_ADAPTIVE, "adaptive", 10)
475
476 test_put_out_of_order(AST_JB_ADAPTIVE, "adaptive", DEFAULT_FRAME_MS * 2)
477
478 test_create_nominal(AST_JB_FIXED, "fixed")
479
480 test_put_first(AST_JB_FIXED, "fixed")
481
482 test_put(AST_JB_FIXED, "fixed")
483
484 test_put_overflow(AST_JB_FIXED, "fixed", 12)
485
486 test_put_out_of_order(AST_JB_FIXED, "fixed", DEFAULT_CONFIG_RESYNC_THRESHOLD)
487
488 static int unload_module(void)
489 {
490         AST_TEST_UNREGISTER(TEST_NAME(AST_JB_ADAPTIVE, create));
491         AST_TEST_UNREGISTER(TEST_NAME(AST_JB_ADAPTIVE, put_first));
492         AST_TEST_UNREGISTER(TEST_NAME(AST_JB_ADAPTIVE, put));
493         AST_TEST_UNREGISTER(TEST_NAME(AST_JB_ADAPTIVE, put_overflow));
494         AST_TEST_UNREGISTER(TEST_NAME(AST_JB_ADAPTIVE, put_out_of_order));
495
496         AST_TEST_UNREGISTER(TEST_NAME(AST_JB_FIXED, create));
497         AST_TEST_UNREGISTER(TEST_NAME(AST_JB_FIXED, put_first));
498         AST_TEST_UNREGISTER(TEST_NAME(AST_JB_FIXED, put));
499         AST_TEST_UNREGISTER(TEST_NAME(AST_JB_FIXED, put_overflow));
500         AST_TEST_UNREGISTER(TEST_NAME(AST_JB_FIXED, put_out_of_order));
501
502         return 0;
503 }
504
505 static int load_module(void)
506 {
507         AST_TEST_REGISTER(TEST_NAME(AST_JB_ADAPTIVE, create));
508         AST_TEST_REGISTER(TEST_NAME(AST_JB_ADAPTIVE, put_first));
509         AST_TEST_REGISTER(TEST_NAME(AST_JB_ADAPTIVE, put));
510         AST_TEST_REGISTER(TEST_NAME(AST_JB_ADAPTIVE, put_overflow));
511         AST_TEST_REGISTER(TEST_NAME(AST_JB_ADAPTIVE, put_out_of_order));
512
513         AST_TEST_REGISTER(TEST_NAME(AST_JB_FIXED, create));
514         AST_TEST_REGISTER(TEST_NAME(AST_JB_FIXED, put_first));
515         AST_TEST_REGISTER(TEST_NAME(AST_JB_FIXED, put));
516         AST_TEST_REGISTER(TEST_NAME(AST_JB_FIXED, put_overflow));
517         AST_TEST_REGISTER(TEST_NAME(AST_JB_FIXED, put_out_of_order));
518
519         return AST_MODULE_LOAD_SUCCESS;
520 }
521
522 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Abstract JitterBuffer API Tests");