1 /* GSequencer - Advanced GTK Sequencer
2 * Copyright (C) 2018 Joël Krähemann
3 *
4 * This file is part of GSequencer.
5 *
6 * GSequencer is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * GSequencer is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with GSequencer. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include <glib.h>
21 #include <glib-object.h>
22
23 #include <ags/libags.h>
24 #include <ags/libags-audio.h>
25
26 #include <CUnit/CUnit.h>
27 #include <CUnit/Automated.h>
28 #include <CUnit/Basic.h>
29
30 #include <stdlib.h>
31
32 int ags_recycling_context_test_init_suite();
33 int ags_recycling_context_test_clean_suite();
34
35 void ags_recycling_context_test_find_scope();
36 void ags_recycling_context_test_replace();
37 void ags_recycling_context_test_add();
38 void ags_recycling_context_test_remove();
39 void ags_recycling_context_test_insert();
40 void ags_recycling_context_test_get_toplevel();
41 void ags_recycling_context_test_find();
42 void ags_recycling_context_test_find_child();
43 void ags_recycling_context_test_find_parent();
44 void ags_recycling_context_test_add_child();
45 void ags_recycling_context_test_remove_child();
46 void ags_recycling_context_test_get_child_recall_id();
47 void ags_recycling_context_test_reset_recycling();
48
49 #define AGS_RECYCLING_CONTEXT_TEST_REPLACE_RECYCLING_COUNT (9)
50
51 #define AGS_RECYCLING_CONTEXT_TEST_ADD_RECYCLING_COUNT (7)
52
53 #define AGS_RECYCLING_CONTEXT_TEST_REMOVE_RECYCLING_COUNT (7)
54
55 #define AGS_RECYCLING_CONTEXT_TEST_INSERT_RECYCLING_COUNT (88)
56
57 #define AGS_RECYCLING_CONTEXT_TEST_GET_TOPLEVEL_NESTING_LEVEL (5)
58
59 #define AGS_RECYCLING_CONTEXT_TEST_FIND_RECYCLING_COUNT (88)
60
61 #define AGS_RECYCLING_CONTEXT_TEST_FIND_CHILD_CHILD_COUNT (5)
62 #define AGS_RECYCLING_CONTEXT_TEST_FIND_CHILD_RECYCLING_COUNT (4)
63
64 #define AGS_RECYCLING_CONTEXT_TEST_FIND_PARENT_CHILD_COUNT (5)
65 #define AGS_RECYCLING_CONTEXT_TEST_FIND_PARENT_RECYCLING_COUNT (4)
66
67 #define AGS_RECYCLING_CONTEXT_TEST_GET_CHILD_RECALL_ID_CHILD_COUNT (5)
68 #define AGS_RECYCLING_CONTEXT_TEST_GET_CHILD_RECALL_ID_RECYCLING_COUNT (4)
69
70 #define AGS_RECYCLING_CONTEXT_TEST_RESET_RECYCLING_RECYCLING_COUNT (4)
71
72 /* The suite initialization function.
73 * Opens the temporary file used by the tests.
74 * Returns zero on success, non-zero otherwise.
75 */
76 int
ags_recycling_context_test_init_suite()77 ags_recycling_context_test_init_suite()
78 {
79 return(0);
80 }
81
82 /* The suite cleanup function.
83 * Closes the temporary file used by the tests.
84 * Returns zero on success, non-zero otherwise.
85 */
86 int
ags_recycling_context_test_clean_suite()87 ags_recycling_context_test_clean_suite()
88 {
89 return(0);
90 }
91
92 void
ags_recycling_context_test_find_scope()93 ags_recycling_context_test_find_scope()
94 {
95 AgsRecyclingContext **recycling_context;
96
97 GList *list;
98 GList *current;
99
100 recycling_context = (AgsRecyclingContext **) malloc(AGS_SOUND_SCOPE_LAST * sizeof(AgsRecyclingContext *));
101
102 list = NULL;
103
104 recycling_context[AGS_SOUND_SCOPE_PLAYBACK] = ags_recycling_context_new(0);
105 recycling_context[AGS_SOUND_SCOPE_PLAYBACK]->sound_scope = AGS_SOUND_SCOPE_PLAYBACK;
106 list = g_list_prepend(list,
107 recycling_context[AGS_SOUND_SCOPE_PLAYBACK]);
108
109 recycling_context[AGS_SOUND_SCOPE_SEQUENCER] = ags_recycling_context_new(0);
110 recycling_context[AGS_SOUND_SCOPE_SEQUENCER]->sound_scope = AGS_SOUND_SCOPE_SEQUENCER;
111 list = g_list_prepend(list,
112 recycling_context[AGS_SOUND_SCOPE_SEQUENCER]);
113
114 recycling_context[AGS_SOUND_SCOPE_NOTATION] = ags_recycling_context_new(0);
115 recycling_context[AGS_SOUND_SCOPE_NOTATION]->sound_scope = AGS_SOUND_SCOPE_NOTATION;
116 list = g_list_prepend(list,
117 recycling_context[AGS_SOUND_SCOPE_NOTATION]);
118
119 recycling_context[AGS_SOUND_SCOPE_WAVE] = ags_recycling_context_new(0);
120 recycling_context[AGS_SOUND_SCOPE_WAVE]->sound_scope = AGS_SOUND_SCOPE_WAVE;
121 list = g_list_prepend(list,
122 recycling_context[AGS_SOUND_SCOPE_WAVE]);
123
124 recycling_context[AGS_SOUND_SCOPE_MIDI] = ags_recycling_context_new(0);
125 recycling_context[AGS_SOUND_SCOPE_MIDI]->sound_scope = AGS_SOUND_SCOPE_MIDI;
126 list = g_list_prepend(list,
127 recycling_context[AGS_SOUND_SCOPE_MIDI]);
128
129 list = g_list_reverse(list);
130
131 /* test */
132 current = ags_recycling_context_find_scope(list,
133 AGS_SOUND_SCOPE_PLAYBACK);
134 CU_ASSERT(current->data == recycling_context[AGS_SOUND_SCOPE_PLAYBACK]);
135
136 current = ags_recycling_context_find_scope(list,
137 AGS_SOUND_SCOPE_SEQUENCER);
138 CU_ASSERT(current->data == recycling_context[AGS_SOUND_SCOPE_SEQUENCER]);
139
140 current = ags_recycling_context_find_scope(list,
141 AGS_SOUND_SCOPE_NOTATION);
142 CU_ASSERT(current->data == recycling_context[AGS_SOUND_SCOPE_NOTATION]);
143
144 current = ags_recycling_context_find_scope(list,
145 AGS_SOUND_SCOPE_WAVE);
146 CU_ASSERT(current->data == recycling_context[AGS_SOUND_SCOPE_WAVE]);
147
148 current = ags_recycling_context_find_scope(list,
149 AGS_SOUND_SCOPE_MIDI);
150 CU_ASSERT(current->data == recycling_context[AGS_SOUND_SCOPE_MIDI]);
151 }
152
153 void
ags_recycling_context_test_replace()154 ags_recycling_context_test_replace()
155 {
156 AgsRecycling **recycling;
157 AgsRecyclingContext *recycling_context;
158
159 guint i;
160 gboolean success;
161
162 recycling = (AgsRecycling **) malloc(AGS_RECYCLING_CONTEXT_TEST_REPLACE_RECYCLING_COUNT * sizeof(AgsRecycling *));
163
164 recycling_context = ags_recycling_context_new((guint64) AGS_RECYCLING_CONTEXT_TEST_REPLACE_RECYCLING_COUNT);
165
166 success = TRUE;
167
168 for(i = 0; i < AGS_RECYCLING_CONTEXT_TEST_REPLACE_RECYCLING_COUNT; i++){
169 recycling[i] = ags_recycling_new(NULL);
170 ags_recycling_context_replace(recycling_context,
171 recycling[i],
172 i);
173
174 if(recycling_context->recycling[i] != recycling[i]){
175 success = FALSE;
176
177 break;
178 }
179 }
180
181 CU_ASSERT(success);
182 }
183
184 void
ags_recycling_context_test_add()185 ags_recycling_context_test_add()
186 {
187 AgsRecycling **recycling;
188 AgsRecyclingContext *recycling_context;
189
190 guint i;
191 gboolean success;
192
193 recycling = (AgsRecycling **) malloc(AGS_RECYCLING_CONTEXT_TEST_ADD_RECYCLING_COUNT * sizeof(AgsRecycling *));
194
195 recycling_context = ags_recycling_context_new(0);
196
197 success = TRUE;
198
199 for(i = 0; i < AGS_RECYCLING_CONTEXT_TEST_ADD_RECYCLING_COUNT; i++){
200 recycling[i] = ags_recycling_new(NULL);
201 ags_recycling_context_add(recycling_context,
202 recycling[i]);
203
204 if(recycling_context->recycling[i] != recycling[i] ||
205 recycling_context->length != i + 1){
206 success = FALSE;
207
208 break;
209 }
210 }
211
212 CU_ASSERT(success);
213 }
214
215 void
ags_recycling_context_test_remove()216 ags_recycling_context_test_remove()
217 {
218 AgsRecycling **recycling;
219 AgsRecyclingContext *recycling_context;
220
221 guint i, j;
222 gboolean success;
223
224 recycling = (AgsRecycling **) malloc(AGS_RECYCLING_CONTEXT_TEST_REMOVE_RECYCLING_COUNT * sizeof(AgsRecycling *));
225
226 recycling_context = ags_recycling_context_new((guint64) AGS_RECYCLING_CONTEXT_TEST_REMOVE_RECYCLING_COUNT);
227
228 for(i = 0; i < AGS_RECYCLING_CONTEXT_TEST_REMOVE_RECYCLING_COUNT; i++){
229 recycling[i] = ags_recycling_new(NULL);
230 ags_recycling_context_replace(recycling_context,
231 recycling[i],
232 i);
233 }
234
235 /* test */
236 success = TRUE;
237
238 for(i = 0; i < AGS_RECYCLING_CONTEXT_TEST_REMOVE_RECYCLING_COUNT && success; i++){
239 ags_recycling_context_remove(recycling_context,
240 recycling[i]);
241
242 if(recycling_context->length != 0){
243 for(j = 0; AGS_RECYCLING_CONTEXT_TEST_REMOVE_RECYCLING_COUNT - (j + i + 1) > 1; j++){
244 if(recycling_context->recycling[j] != recycling[i + j + 1]){
245 success = FALSE;
246
247 break;
248 }
249 }
250 }
251
252 if(recycling_context->length == 0){
253 if(recycling_context->recycling != NULL){
254 success = FALSE;
255
256 break;
257 }
258 }
259 }
260
261 CU_ASSERT(success);
262 }
263
264 void
ags_recycling_context_test_insert()265 ags_recycling_context_test_insert()
266 {
267 AgsRecycling **recycling;
268 AgsRecyclingContext *recycling_context;
269
270 gint position;
271 guint i, j;
272 gboolean success;
273
274 recycling = (AgsRecycling **) malloc(AGS_RECYCLING_CONTEXT_TEST_INSERT_RECYCLING_COUNT * sizeof(AgsRecycling *));
275
276 recycling_context = ags_recycling_context_new(0);
277
278 success = TRUE;
279
280 for(i = 0; i < AGS_RECYCLING_CONTEXT_TEST_INSERT_RECYCLING_COUNT; i++){
281 recycling[i] = ags_recycling_new(NULL);
282 }
283
284 /* test */
285 for(i = 0; i < AGS_RECYCLING_CONTEXT_TEST_INSERT_RECYCLING_COUNT; i++){
286 if(i > 0){
287 position = rand() % i;
288 }else{
289 position = 0;
290 }
291
292 ags_recycling_context_insert(recycling_context,
293 recycling[i],
294 position);
295
296
297 if(recycling_context->recycling[position] != recycling[i]){
298 success = FALSE;
299
300 break;
301 }
302 }
303
304 CU_ASSERT(success);
305 }
306
307 void
ags_recycling_context_test_get_toplevel()308 ags_recycling_context_test_get_toplevel()
309 {
310 AgsRecyclingContext *toplevel;
311 AgsRecyclingContext *recycling_context, *current;
312
313 guint i;
314
315 toplevel = ags_recycling_context_new(0);
316
317 current = toplevel;
318
319 for(i = 0; i < AGS_RECYCLING_CONTEXT_TEST_GET_TOPLEVEL_NESTING_LEVEL; i++){
320 recycling_context = ags_recycling_context_new(0);
321 ags_recycling_context_add_child(current,
322 recycling_context);
323
324 current = recycling_context;
325 }
326
327 CU_ASSERT(ags_recycling_context_get_toplevel(toplevel) == toplevel);
328 CU_ASSERT(ags_recycling_context_get_toplevel(current) == toplevel);
329 }
330
331 void
ags_recycling_context_test_find()332 ags_recycling_context_test_find()
333 {
334 AgsRecycling **recycling;
335 AgsRecyclingContext *recycling_context;
336
337 gint position;
338 guint i;
339 gboolean success;
340
341 recycling = (AgsRecycling **) malloc(AGS_RECYCLING_CONTEXT_TEST_FIND_RECYCLING_COUNT * sizeof(AgsRecycling *));
342
343 recycling_context = ags_recycling_context_new((guint64) AGS_RECYCLING_CONTEXT_TEST_FIND_RECYCLING_COUNT);
344
345 for(i = 0; i < AGS_RECYCLING_CONTEXT_TEST_FIND_RECYCLING_COUNT; i++){
346 recycling[i] = ags_recycling_new(NULL);
347 ags_recycling_context_replace(recycling_context,
348 recycling[i],
349 i);
350 }
351
352 /* test */
353 success = TRUE;
354
355 for(i = 0; i < AGS_RECYCLING_CONTEXT_TEST_FIND_RECYCLING_COUNT; i++){
356 position = ags_recycling_context_find(recycling_context,
357 recycling[i]);
358
359 if(position != i){
360 success = FALSE;
361
362 break;
363 }
364 }
365
366 CU_ASSERT(success);
367
368 CU_ASSERT(ags_recycling_context_find(recycling_context, NULL) == -1);
369 }
370
371 void
ags_recycling_context_test_find_child()372 ags_recycling_context_test_find_child()
373 {
374 AgsRecycling ***recycling;
375 AgsRecyclingContext *recycling_context;
376 AgsRecyclingContext **child;
377
378 gint position;
379 guint i, j;
380 gboolean success;
381
382 recycling_context = ags_recycling_context_new(0);
383 child = (AgsRecyclingContext **) malloc(AGS_RECYCLING_CONTEXT_TEST_FIND_CHILD_CHILD_COUNT * sizeof(AgsRecyclingContext *));
384
385 recycling = (AgsRecycling ***) malloc(AGS_RECYCLING_CONTEXT_TEST_FIND_CHILD_CHILD_COUNT * sizeof(AgsRecycling **));
386
387 for(i = 0; i < AGS_RECYCLING_CONTEXT_TEST_FIND_CHILD_CHILD_COUNT; i++){
388 child[i] = ags_recycling_context_new((guint64) AGS_RECYCLING_CONTEXT_TEST_FIND_CHILD_RECYCLING_COUNT);
389 ags_recycling_context_add_child(recycling_context,
390 child[i]);
391
392 recycling[i] = (AgsRecycling **) malloc(AGS_RECYCLING_CONTEXT_TEST_FIND_CHILD_RECYCLING_COUNT * sizeof(AgsRecycling *));
393
394 for(j = 0; j < AGS_RECYCLING_CONTEXT_TEST_FIND_CHILD_RECYCLING_COUNT; j++){
395 recycling[i][j] = ags_recycling_new(NULL);
396 ags_recycling_context_replace(child[i],
397 recycling[i][j],
398 j);
399 }
400 }
401
402 /* test */
403 success = TRUE;
404
405 for(i = 0; i < AGS_RECYCLING_CONTEXT_TEST_FIND_CHILD_CHILD_COUNT; i++){
406 for(j = 0; j < AGS_RECYCLING_CONTEXT_TEST_FIND_CHILD_RECYCLING_COUNT; j++){
407 position = ags_recycling_context_find_child(recycling_context,
408 recycling[i][j]);
409
410 if(position == -1){
411 success = FALSE;
412
413 break;
414 }
415 }
416 }
417
418 CU_ASSERT(success == TRUE);
419 }
420
421 void
ags_recycling_context_test_find_parent()422 ags_recycling_context_test_find_parent()
423 {
424 AgsRecycling **recycling;
425 AgsRecyclingContext *recycling_context;
426 AgsRecyclingContext **child;
427
428 gint position;
429 guint i;
430 gboolean success;
431
432 recycling_context = ags_recycling_context_new((guint64) AGS_RECYCLING_CONTEXT_TEST_FIND_PARENT_RECYCLING_COUNT);
433 child = (AgsRecyclingContext **) malloc(AGS_RECYCLING_CONTEXT_TEST_FIND_PARENT_CHILD_COUNT * sizeof(AgsRecyclingContext *));
434
435 recycling = (AgsRecycling **) malloc(AGS_RECYCLING_CONTEXT_TEST_FIND_PARENT_RECYCLING_COUNT * sizeof(AgsRecycling *));
436
437 for(i = 0; i < AGS_RECYCLING_CONTEXT_TEST_FIND_PARENT_RECYCLING_COUNT; i++){
438 recycling[i] = ags_recycling_new(NULL);
439 ags_recycling_context_replace(recycling_context,
440 recycling[i],
441 i);
442 }
443
444 for(i = 0; i < AGS_RECYCLING_CONTEXT_TEST_FIND_PARENT_CHILD_COUNT; i++){
445 child[i] = ags_recycling_context_new(0);
446 ags_recycling_context_add_child(recycling_context,
447 child[i]);
448
449 }
450
451 /* test */
452 success = TRUE;
453
454 for(i = 0; i < AGS_RECYCLING_CONTEXT_TEST_FIND_PARENT_RECYCLING_COUNT; i++){
455 position = ags_recycling_context_find_parent(child[rand() % AGS_RECYCLING_CONTEXT_TEST_FIND_PARENT_CHILD_COUNT],
456 recycling[i]);
457
458 if(position == -1){
459 success = FALSE;
460
461 break;
462 }
463 }
464
465 CU_ASSERT(success == TRUE);
466 }
467
468 void
ags_recycling_context_test_add_child()469 ags_recycling_context_test_add_child()
470 {
471 AgsRecyclingContext *recycling_context;
472 AgsRecyclingContext *child;
473
474 recycling_context = ags_recycling_context_new(0);
475
476 child = ags_recycling_context_new(0);
477 ags_recycling_context_add_child(recycling_context,
478 child);
479
480 CU_ASSERT(child->parent == recycling_context);
481 CU_ASSERT(g_list_find(recycling_context->children, child) != NULL);
482 }
483
484 void
ags_recycling_context_test_remove_child()485 ags_recycling_context_test_remove_child()
486 {
487 AgsRecyclingContext *recycling_context;
488 AgsRecyclingContext *child;
489
490 recycling_context = ags_recycling_context_new(0);
491
492 child = ags_recycling_context_new(0);
493 ags_recycling_context_add_child(recycling_context,
494 child);
495
496 /* test */
497 ags_recycling_context_remove_child(recycling_context,
498 child);
499
500 CU_ASSERT(child->parent == NULL);
501 CU_ASSERT(g_list_find(recycling_context->children, child) == NULL);
502 }
503
504 void
ags_recycling_context_test_get_child_recall_id()505 ags_recycling_context_test_get_child_recall_id()
506 {
507 AgsRecallID *recall_id;
508 AgsRecallID **child_recall_id;
509 AgsRecyclingContext *recycling_context;
510 AgsRecyclingContext **child;
511
512 GList *list;
513
514 gint position;
515 guint i, j;
516 gboolean success;
517
518 recall_id = ags_recall_id_new();
519
520 recycling_context = ags_recycling_context_new(0);
521 g_object_set(recycling_context,
522 "recall-id", recall_id,
523 NULL);
524
525 g_object_set(recall_id,
526 "recycling-context", recycling_context,
527 NULL);
528
529 child_recall_id = (AgsRecallID **) malloc(AGS_RECYCLING_CONTEXT_TEST_GET_CHILD_RECALL_ID_CHILD_COUNT * sizeof(AgsRecallID *));
530
531 child = (AgsRecyclingContext **) malloc(AGS_RECYCLING_CONTEXT_TEST_GET_CHILD_RECALL_ID_CHILD_COUNT * sizeof(AgsRecyclingContext *));
532
533 for(i = 0; i < AGS_RECYCLING_CONTEXT_TEST_GET_CHILD_RECALL_ID_CHILD_COUNT; i++){
534 child_recall_id[i] = ags_recall_id_new();
535
536 child[i] = ags_recycling_context_new(0);
537 ags_recycling_context_add_child(recycling_context,
538 child[i]);
539
540 g_object_set(child[i],
541 "recall-id", child_recall_id[i],
542 NULL);
543
544 g_object_set(child_recall_id[i],
545 "recycling-context", child[i],
546 NULL);
547 }
548
549 /* test */
550 success = TRUE;
551
552 list = ags_recycling_context_get_child_recall_id(recycling_context);
553
554 CU_ASSERT(list != NULL);
555
556 for(i = 0; i < AGS_RECYCLING_CONTEXT_TEST_GET_CHILD_RECALL_ID_CHILD_COUNT; i++){
557 if(g_list_find(list, child_recall_id[i]) == NULL){
558 success = FALSE;
559
560 break;
561 }
562 }
563
564 CU_ASSERT(success == TRUE);
565 }
566
567 void
ags_recycling_context_test_reset_recycling()568 ags_recycling_context_test_reset_recycling()
569 {
570 AgsRecycling *first_recycling, *last_recycling;
571 AgsRecycling *recycling;
572 AgsRecyclingContext *new_recycling_context, *recycling_context;
573
574 guint i;
575 gboolean success;
576
577 recycling_context = ags_recycling_context_new(0);
578
579 first_recycling =
580 recycling = ags_recycling_new(NULL);
581
582 for(i = 1; i < AGS_RECYCLING_CONTEXT_TEST_RESET_RECYCLING_RECYCLING_COUNT; i++){
583 g_object_set(recycling,
584 "next", ags_recycling_new(NULL),
585 NULL);
586
587 g_object_set(recycling->next,
588 "prev", recycling,
589 NULL);
590
591 recycling = recycling->next;
592 }
593
594 last_recycling = recycling;
595
596 /* test */
597 success = TRUE;
598
599 new_recycling_context = ags_recycling_context_reset_recycling(recycling_context,
600 NULL, NULL,
601 first_recycling, last_recycling);
602
603 CU_ASSERT(new_recycling_context != NULL);
604 CU_ASSERT(new_recycling_context != recycling_context);
605 CU_ASSERT(AGS_IS_RECYCLING_CONTEXT(new_recycling_context));
606
607 recycling = first_recycling;
608
609 for(i = 0; i < AGS_RECYCLING_CONTEXT_TEST_RESET_RECYCLING_RECYCLING_COUNT; i++){
610 if(new_recycling_context->recycling[i] != recycling){
611 success = FALSE;
612
613 break;
614 }
615
616 recycling = recycling->next;
617 }
618
619 CU_ASSERT(success == TRUE);
620 }
621
622 int
main(int argc,char ** argv)623 main(int argc, char **argv)
624 {
625 CU_pSuite pSuite = NULL;
626
627 /* initialize the CUnit test registry */
628 if(CUE_SUCCESS != CU_initialize_registry()){
629 return CU_get_error();
630 }
631
632 /* add a suite to the registry */
633 pSuite = CU_add_suite("AgsRecyclingContextTest", ags_recycling_context_test_init_suite, ags_recycling_context_test_clean_suite);
634
635 if(pSuite == NULL){
636 CU_cleanup_registry();
637
638 return CU_get_error();
639 }
640
641 /* add the tests to the suite */
642 if((CU_add_test(pSuite, "test of AgsRecyclingContext find scope", ags_recycling_context_test_find_scope) == NULL) ||
643 (CU_add_test(pSuite, "test of AgsRecyclingContext replace", ags_recycling_context_test_replace) == NULL) ||
644 (CU_add_test(pSuite, "test of AgsRecyclingContext add", ags_recycling_context_test_add) == NULL) ||
645 (CU_add_test(pSuite, "test of AgsRecyclingContext remove", ags_recycling_context_test_remove) == NULL) ||
646 (CU_add_test(pSuite, "test of AgsRecyclingContext insert", ags_recycling_context_test_insert) == NULL) ||
647 (CU_add_test(pSuite, "test of AgsRecyclingContext get toplevel", ags_recycling_context_test_get_toplevel) == NULL) ||
648 (CU_add_test(pSuite, "test of AgsRecyclingContext find", ags_recycling_context_test_find) == NULL) ||
649 (CU_add_test(pSuite, "test of AgsRecyclingContext find child", ags_recycling_context_test_find_child) == NULL) ||
650 (CU_add_test(pSuite, "test of AgsRecyclingContext find parent", ags_recycling_context_test_find_parent) == NULL) ||
651 (CU_add_test(pSuite, "test of AgsRecyclingContext add child", ags_recycling_context_test_add_child) == NULL) ||
652 (CU_add_test(pSuite, "test of AgsRecyclingContext remove child", ags_recycling_context_test_remove_child) == NULL) ||
653 (CU_add_test(pSuite, "test of AgsRecyclingContext get child recall id", ags_recycling_context_test_get_child_recall_id) == NULL) ||
654 (CU_add_test(pSuite, "test of AgsRecyclingContext reset recycling", ags_recycling_context_test_reset_recycling) == NULL)){
655 CU_cleanup_registry();
656
657 return CU_get_error();
658 }
659
660 /* Run all tests using the CUnit Basic interface */
661 CU_basic_set_mode(CU_BRM_VERBOSE);
662 CU_basic_run_tests();
663
664 CU_cleanup_registry();
665
666 return(CU_get_error());
667 }
668