2 * Copyright 2017 - Philippe Proulx <pproulx@efficios.com>
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; under version 2 of the License.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 #include <babeltrace/assert-internal.h>
25 #include <babeltrace/babeltrace.h>
34 TEST_NO_UPSTREAM_CONNECTION
,
36 TEST_4_PORTS_WITH_RETRIES
,
37 TEST_SINGLE_END_THEN_MULTIPLE_FULL
,
38 TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
,
41 enum test_event_type
{
42 TEST_EV_TYPE_NOTIF_UNEXPECTED
,
43 TEST_EV_TYPE_NOTIF_EVENT
,
44 TEST_EV_TYPE_NOTIF_INACTIVITY
,
45 TEST_EV_TYPE_NOTIF_PACKET_BEGIN
,
46 TEST_EV_TYPE_NOTIF_PACKET_END
,
47 TEST_EV_TYPE_NOTIF_STREAM_BEGIN
,
48 TEST_EV_TYPE_NOTIF_STREAM_END
,
51 TEST_EV_TYPE_SENTINEL
,
55 enum test_event_type type
;
59 struct source_muxer_sink
{
60 struct bt_component
*source
;
61 struct bt_component
*muxer
;
62 struct bt_component
*sink
;
65 struct graph_listener_data
{
66 struct bt_graph
*graph
;
67 struct bt_component
*source
;
68 struct bt_component
*muxer
;
69 struct bt_component
*sink
;
72 static bool debug
= false;
73 static enum test current_test
;
74 static GArray
*test_events
;
75 static struct bt_graph
*graph
;
76 static struct bt_clock_class_priority_map
*src_cc_prio_map
;
77 static struct bt_clock_class_priority_map
*src_empty_cc_prio_map
;
78 static struct bt_clock_class
*src_clock_class
;
79 static struct bt_stream_class
*src_stream_class
;
80 static struct bt_event_class
*src_event_class
;
81 static struct bt_packet
*src_packet0
;
82 static struct bt_packet
*src_packet1
;
83 static struct bt_packet
*src_packet2
;
84 static struct bt_packet
*src_packet3
;
89 SEQ_PACKET_BEGIN
= -3,
91 SEQ_STREAM_BEGIN
= -5,
95 struct src_iter_user_data
{
99 struct bt_packet
*packet
;
102 struct sink_user_data
{
103 struct bt_notification_iterator
*notif_iter
;
106 static int64_t seq1
[] = {
107 SEQ_STREAM_BEGIN
, SEQ_PACKET_BEGIN
, 24, 53, 97, 105, 119, 210,
108 222, 240, 292, 317, 353, 407, 433, 473, 487, 504, 572, 615, 708,
109 766, 850, 852, 931, 951, 956, 996, SEQ_PACKET_END
,
110 SEQ_STREAM_END
, SEQ_END
,
113 static int64_t seq2
[] = {
114 SEQ_STREAM_BEGIN
, SEQ_PACKET_BEGIN
, 51, 59, 68, 77, 91, 121,
115 139, 170, 179, 266, 352, 454, 478, 631, 644, 668, 714, 744, 750,
116 778, 790, 836, SEQ_PACKET_END
, SEQ_STREAM_END
, SEQ_END
,
119 static int64_t seq3
[] = {
120 SEQ_STREAM_BEGIN
, SEQ_PACKET_BEGIN
, 8, 71, 209, 254, 298, 320,
121 350, 393, 419, 624, 651, 678, 717, 731, 733, 788, 819, 820, 857,
122 892, 903, 944, 998, SEQ_PACKET_END
, SEQ_STREAM_END
, SEQ_END
,
125 static int64_t seq4
[] = {
126 SEQ_STREAM_BEGIN
, SEQ_PACKET_BEGIN
, 41, 56, 120, 138, 154, 228,
127 471, 479, 481, 525, 591, 605, 612, 618, 632, 670, 696, 825, 863,
128 867, 871, 884, 953, 985, 999, SEQ_PACKET_END
, SEQ_STREAM_END
,
132 static int64_t seq1_with_again
[] = {
133 SEQ_STREAM_BEGIN
, SEQ_PACKET_BEGIN
, 24, 53, 97, 105, 119, 210,
134 SEQ_AGAIN
, SEQ_AGAIN
, 222, 240, 292, 317, 353, 407, 433, 473,
135 487, 504, 572, 615, 708, 766, 850, 852, 931, 951, 956, 996,
136 SEQ_PACKET_END
, SEQ_STREAM_END
, SEQ_END
,
139 static int64_t seq2_with_again
[] = {
140 SEQ_STREAM_BEGIN
, SEQ_PACKET_BEGIN
, 51, 59, 68, 77, 91, 121,
141 139, 170, 179, 266, 352, 454, 478, 631, 644, 668, 714, 744, 750,
142 778, 790, 836, SEQ_AGAIN
, SEQ_AGAIN
, SEQ_PACKET_END
,
143 SEQ_STREAM_END
, SEQ_END
,
146 static int64_t seq3_with_again
[] = {
147 SEQ_STREAM_BEGIN
, SEQ_PACKET_BEGIN
, 8, 71, 209, 254, 298, 320,
148 350, 393, 419, 624, 651, SEQ_AGAIN
, SEQ_AGAIN
, 678, 717, 731,
149 733, 788, 819, 820, 857, 892, 903, 944, 998, SEQ_PACKET_END
,
150 SEQ_STREAM_END
, SEQ_END
,
153 static int64_t seq4_with_again
[] = {
154 SEQ_AGAIN
, SEQ_STREAM_BEGIN
, SEQ_PACKET_BEGIN
, 41, 56, 120, 138,
155 154, 228, 471, 479, 481, 525, 591, 605, 612, 618, 632, 670, 696,
156 825, 863, 867, 871, 884, 953, 985, 999, SEQ_PACKET_END
,
157 SEQ_STREAM_END
, SEQ_END
,
160 static int64_t seq5
[] = {
161 SEQ_STREAM_BEGIN
, SEQ_PACKET_BEGIN
, 1, 4, 189, 1001,
162 SEQ_PACKET_END
, SEQ_STREAM_END
, SEQ_END
,
166 void clear_test_events(void)
168 g_array_set_size(test_events
, 0);
172 void print_test_event(FILE *fp
, const struct test_event
*event
)
174 fprintf(fp
, "{ type = ");
176 switch (event
->type
) {
177 case TEST_EV_TYPE_NOTIF_UNEXPECTED
:
178 fprintf(fp
, "TEST_EV_TYPE_NOTIF_UNEXPECTED");
180 case TEST_EV_TYPE_NOTIF_EVENT
:
181 fprintf(fp
, "TEST_EV_TYPE_NOTIF_EVENT");
183 case TEST_EV_TYPE_NOTIF_INACTIVITY
:
184 fprintf(fp
, "TEST_EV_TYPE_NOTIF_INACTIVITY");
186 case TEST_EV_TYPE_NOTIF_PACKET_BEGIN
:
187 fprintf(fp
, "TEST_EV_TYPE_NOTIF_PACKET_BEGIN");
189 case TEST_EV_TYPE_NOTIF_PACKET_END
:
190 fprintf(fp
, "TEST_EV_TYPE_NOTIF_PACKET_END");
192 case TEST_EV_TYPE_NOTIF_STREAM_BEGIN
:
193 fprintf(fp
, "TEST_EV_TYPE_NOTIF_STREAM_BEGIN");
195 case TEST_EV_TYPE_NOTIF_STREAM_END
:
196 fprintf(fp
, "TEST_EV_TYPE_NOTIF_STREAM_END");
198 case TEST_EV_TYPE_AGAIN
:
199 fprintf(fp
, "TEST_EV_TYPE_AGAIN");
201 case TEST_EV_TYPE_END
:
202 fprintf(fp
, "TEST_EV_TYPE_END");
204 case TEST_EV_TYPE_SENTINEL
:
205 fprintf(fp
, "TEST_EV_TYPE_SENTINEL");
208 fprintf(fp
, "(UNKNOWN)");
212 switch (event
->type
) {
213 case TEST_EV_TYPE_NOTIF_EVENT
:
214 case TEST_EV_TYPE_NOTIF_INACTIVITY
:
215 fprintf(fp
, ", ts-ns = %" PRId64
, event
->ts_ns
);
224 void append_test_event(struct test_event
*event
)
226 g_array_append_val(test_events
, *event
);
230 bool compare_single_test_events(const struct test_event
*ev_a
,
231 const struct test_event
*ev_b
)
234 fprintf(stderr
, ":: Comparing test events: ");
235 print_test_event(stderr
, ev_a
);
236 fprintf(stderr
, " vs. ");
237 print_test_event(stderr
, ev_b
);
238 fprintf(stderr
, "\n");
241 if (ev_a
->type
!= ev_b
->type
) {
245 switch (ev_a
->type
) {
246 case TEST_EV_TYPE_NOTIF_EVENT
:
247 case TEST_EV_TYPE_NOTIF_INACTIVITY
:
248 if (ev_a
->ts_ns
!= ev_b
->ts_ns
) {
260 bool compare_test_events(const struct test_event
*expected_events
)
262 const struct test_event
*expected_event
= expected_events
;
265 BT_ASSERT(expected_events
);
268 const struct test_event
*event
;
270 if (expected_event
->type
== TEST_EV_TYPE_SENTINEL
) {
274 if (i
>= test_events
->len
) {
278 event
= &g_array_index(test_events
, struct test_event
, i
);
280 if (!compare_single_test_events(event
, expected_event
)) {
288 if (i
!= test_events
->len
) {
290 fprintf(stderr
, ":: Length mismatch\n");
300 void init_static_data(void)
303 struct bt_trace
*trace
;
304 struct bt_stream
*stream
;
305 struct bt_field_type
*empty_struct_ft
;
306 struct bt_field_type
*eh_ft
;
307 struct bt_field_type
*eh_ts_ft
;
310 test_events
= g_array_new(FALSE
, TRUE
, sizeof(struct test_event
));
311 BT_ASSERT(test_events
);
314 empty_struct_ft
= bt_field_type_structure_create();
315 BT_ASSERT(empty_struct_ft
);
316 src_clock_class
= bt_clock_class_create("my-clock", 1000000000);
317 BT_ASSERT(src_clock_class
);
318 trace
= bt_trace_create();
320 ret
= bt_trace_set_native_byte_order(trace
,
321 BT_BYTE_ORDER_LITTLE_ENDIAN
);
323 ret
= bt_trace_set_packet_header_field_type(trace
, empty_struct_ft
);
325 ret
= bt_clock_class_set_is_absolute(src_clock_class
, 1);
327 ret
= bt_trace_add_clock_class(trace
, src_clock_class
);
329 src_empty_cc_prio_map
= bt_clock_class_priority_map_create();
330 BT_ASSERT(src_empty_cc_prio_map
);
331 src_cc_prio_map
= bt_clock_class_priority_map_create();
332 BT_ASSERT(src_cc_prio_map
);
333 ret
= bt_clock_class_priority_map_add_clock_class(src_cc_prio_map
,
336 src_stream_class
= bt_stream_class_create("my-stream-class");
337 BT_ASSERT(src_stream_class
);
338 ret
= bt_stream_class_set_packet_context_field_type(src_stream_class
,
341 eh_ft
= bt_field_type_structure_create();
343 eh_ts_ft
= bt_field_type_integer_create(64);
345 ret
= bt_field_type_structure_add_field(eh_ft
, eh_ts_ft
, "ts");
347 ret
= bt_field_type_integer_set_mapped_clock_class(eh_ts_ft
,
350 ret
= bt_stream_class_set_event_header_field_type(src_stream_class
,
353 ret
= bt_stream_class_set_event_context_field_type(src_stream_class
,
356 src_event_class
= bt_event_class_create("my-event-class");
357 ret
= bt_event_class_set_context_field_type(src_event_class
,
360 ret
= bt_event_class_set_context_field_type(src_event_class
,
363 ret
= bt_stream_class_add_event_class(src_stream_class
,
366 ret
= bt_trace_add_stream_class(trace
, src_stream_class
);
368 stream
= bt_stream_create(src_stream_class
, "stream0", 0);
370 src_packet0
= bt_packet_create(stream
);
371 BT_ASSERT(src_packet0
);
373 stream
= bt_stream_create(src_stream_class
, "stream1", 1);
375 src_packet1
= bt_packet_create(stream
);
376 BT_ASSERT(src_packet0
);
378 stream
= bt_stream_create(src_stream_class
, "stream2", 2);
380 src_packet2
= bt_packet_create(stream
);
381 BT_ASSERT(src_packet0
);
383 stream
= bt_stream_create(src_stream_class
, "stream3", 3);
385 src_packet3
= bt_packet_create(stream
);
386 BT_ASSERT(src_packet0
);
390 bt_put(empty_struct_ft
);
396 void fini_static_data(void)
399 g_array_free(test_events
, TRUE
);
402 bt_put(src_empty_cc_prio_map
);
403 bt_put(src_cc_prio_map
);
404 bt_put(src_clock_class
);
405 bt_put(src_stream_class
);
406 bt_put(src_event_class
);
414 void src_iter_finalize(
415 struct bt_private_connection_private_notification_iterator
*private_notification_iterator
)
417 struct src_iter_user_data
*user_data
=
418 bt_private_connection_private_notification_iterator_get_user_data(
419 private_notification_iterator
);
427 enum bt_notification_iterator_status
src_iter_init(
428 struct bt_private_connection_private_notification_iterator
*priv_notif_iter
,
429 struct bt_private_port
*private_port
)
431 struct src_iter_user_data
*user_data
=
432 g_new0(struct src_iter_user_data
, 1);
433 struct bt_port
*port
= bt_port_borrow_from_private(private_port
);
434 const char *port_name
;
437 BT_ASSERT(user_data
);
439 ret
= bt_private_connection_private_notification_iterator_set_user_data(priv_notif_iter
,
442 port_name
= bt_port_get_name(port
);
443 BT_ASSERT(port_name
);
444 user_data
->iter_index
= port_name
[3] - '0';
446 switch (user_data
->iter_index
) {
448 user_data
->packet
= src_packet0
;
451 user_data
->packet
= src_packet1
;
454 user_data
->packet
= src_packet2
;
457 user_data
->packet
= src_packet3
;
463 switch (current_test
) {
465 if (user_data
->iter_index
== 1) {
466 user_data
->seq
= seq5
;
469 case TEST_SIMPLE_4_PORTS
:
470 if (user_data
->iter_index
== 0) {
471 user_data
->seq
= seq1
;
472 } else if (user_data
->iter_index
== 1) {
473 user_data
->seq
= seq2
;
474 } else if (user_data
->iter_index
== 2) {
475 user_data
->seq
= seq3
;
477 user_data
->seq
= seq4
;
480 case TEST_4_PORTS_WITH_RETRIES
:
481 if (user_data
->iter_index
== 0) {
482 user_data
->seq
= seq1_with_again
;
483 } else if (user_data
->iter_index
== 1) {
484 user_data
->seq
= seq2_with_again
;
485 } else if (user_data
->iter_index
== 2) {
486 user_data
->seq
= seq3_with_again
;
488 user_data
->seq
= seq4_with_again
;
491 case TEST_SINGLE_END_THEN_MULTIPLE_FULL
:
492 case TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
:
493 if (user_data
->iter_index
== 0) {
494 /* Ignore: this iterator only returns END */
495 } else if (user_data
->iter_index
== 1) {
496 user_data
->seq
= seq2
;
498 user_data
->seq
= seq3
;
505 return BT_NOTIFICATION_ITERATOR_STATUS_OK
;
509 struct bt_notification
*src_create_event_notif(struct bt_packet
*packet
,
510 struct bt_clock_class_priority_map
*cc_prio_map
, int64_t ts_ns
)
513 struct bt_event
*event
;
514 struct bt_notification
*notif
;
515 struct bt_clock_value
*clock_value
;
516 struct bt_field
*field
;
518 notif
= bt_notification_event_create(graph
, src_event_class
,
519 packet
, cc_prio_map
);
521 event
= bt_notification_event_borrow_event(notif
);
523 field
= bt_event_borrow_header(event
);
525 field
= bt_field_structure_borrow_field_by_name(field
, "ts");
527 ret
= bt_field_integer_unsigned_set_value(field
, (uint64_t) ts_ns
);
529 clock_value
= bt_event_borrow_clock_value(event
, src_clock_class
);
530 BT_ASSERT(clock_value
);
531 ret
= bt_clock_value_set_value(clock_value
, (uint64_t) ts_ns
);
537 enum bt_notification_iterator_status
src_iter_next_seq(
538 struct src_iter_user_data
*user_data
,
539 bt_notification_array notifs
)
541 enum bt_notification_iterator_status status
=
542 BT_NOTIFICATION_ITERATOR_STATUS_OK
;
544 struct bt_stream
*stream
;
546 BT_ASSERT(user_data
->seq
);
547 cur_ts_ns
= user_data
->seq
[user_data
->at
];
551 status
= BT_NOTIFICATION_ITERATOR_STATUS_END
;
554 status
= BT_NOTIFICATION_ITERATOR_STATUS_AGAIN
;
556 case SEQ_PACKET_BEGIN
:
557 notifs
[0] = bt_notification_packet_begin_create(graph
,
559 BT_ASSERT(notifs
[0]);
562 notifs
[0] = bt_notification_packet_end_create(graph
,
564 BT_ASSERT(notifs
[0]);
566 case SEQ_STREAM_BEGIN
:
567 stream
= bt_packet_get_stream(user_data
->packet
);
568 notifs
[0] = bt_notification_stream_begin_create(graph
, stream
);
569 BT_ASSERT(notifs
[0]);
573 stream
= bt_packet_get_stream(user_data
->packet
);
574 notifs
[0] = bt_notification_stream_end_create(graph
, stream
);
575 BT_ASSERT(notifs
[0]);
580 notifs
[0] = src_create_event_notif(user_data
->packet
,
581 src_cc_prio_map
, cur_ts_ns
);
582 BT_ASSERT(notifs
[0]);
587 if (status
!= BT_NOTIFICATION_ITERATOR_STATUS_END
) {
595 enum bt_notification_iterator_status
src_iter_next(
596 struct bt_private_connection_private_notification_iterator
*priv_iterator
,
597 bt_notification_array notifs
, uint64_t capacity
,
600 enum bt_notification_iterator_status status
=
601 BT_NOTIFICATION_ITERATOR_STATUS_OK
;
602 struct src_iter_user_data
*user_data
=
603 bt_private_connection_private_notification_iterator_get_user_data(priv_iterator
);
604 struct bt_private_component
*private_component
=
605 bt_private_connection_private_notification_iterator_get_private_component(priv_iterator
);
606 struct bt_stream
*stream
;
609 BT_ASSERT(user_data
);
610 BT_ASSERT(private_component
);
613 * We can always set it to 1: it's not going to be considered
614 * anyway if the status is not
615 * BT_NOTIFICATION_ITERATOR_STATUS_OK.
619 switch (current_test
) {
621 if (user_data
->iter_index
== 0) {
622 if (user_data
->at
== 0) {
623 stream
= bt_packet_get_stream(user_data
->packet
);
625 bt_notification_stream_begin_create(
628 BT_ASSERT(notifs
[0]);
629 } else if (user_data
->at
== 1) {
631 bt_notification_packet_begin_create(
632 graph
, user_data
->packet
);
633 BT_ASSERT(notifs
[0]);
634 } else if (user_data
->at
< 7) {
636 src_create_event_notif(
638 src_empty_cc_prio_map
, 0);
639 BT_ASSERT(notifs
[0]);
640 } else if (user_data
->at
== 7) {
642 bt_notification_packet_end_create(
643 graph
, user_data
->packet
);
644 BT_ASSERT(notifs
[0]);
645 } else if (user_data
->at
== 8) {
646 stream
= bt_packet_get_stream(user_data
->packet
);
648 bt_notification_stream_end_create(
651 BT_ASSERT(notifs
[0]);
654 BT_NOTIFICATION_ITERATOR_STATUS_END
;
659 status
= src_iter_next_seq(user_data
, notifs
);
662 case TEST_SIMPLE_4_PORTS
:
663 case TEST_4_PORTS_WITH_RETRIES
:
664 status
= src_iter_next_seq(user_data
, notifs
);
666 case TEST_SINGLE_END_THEN_MULTIPLE_FULL
:
667 if (user_data
->iter_index
== 0) {
668 ret
= bt_private_component_source_add_output_private_port(
669 private_component
, "out1", NULL
, NULL
);
671 ret
= bt_private_component_source_add_output_private_port(
672 private_component
, "out2", NULL
, NULL
);
674 status
= BT_NOTIFICATION_ITERATOR_STATUS_END
;
676 status
= src_iter_next_seq(user_data
, notifs
);
679 case TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
:
680 if (user_data
->iter_index
== 0) {
681 if (user_data
->at
== 0) {
682 status
= BT_NOTIFICATION_ITERATOR_STATUS_AGAIN
;
685 ret
= bt_private_component_source_add_output_private_port(
686 private_component
, "out1", NULL
, NULL
);
688 ret
= bt_private_component_source_add_output_private_port(
689 private_component
, "out2", NULL
, NULL
);
691 status
= BT_NOTIFICATION_ITERATOR_STATUS_END
;
694 status
= src_iter_next_seq(user_data
, notifs
);
701 bt_put(private_component
);
706 enum bt_component_status
src_init(
707 struct bt_private_component
*private_component
,
708 struct bt_value
*params
, void *init_method_data
)
713 switch (current_test
) {
717 case TEST_SINGLE_END_THEN_MULTIPLE_FULL
:
718 case TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
:
727 ret
= bt_private_component_source_add_output_private_port(
728 private_component
, "out0", NULL
, NULL
);
733 ret
= bt_private_component_source_add_output_private_port(
734 private_component
, "out1", NULL
, NULL
);
739 ret
= bt_private_component_source_add_output_private_port(
740 private_component
, "out2", NULL
, NULL
);
745 ret
= bt_private_component_source_add_output_private_port(
746 private_component
, "out3", NULL
, NULL
);
750 return BT_COMPONENT_STATUS_OK
;
754 void src_finalize(struct bt_private_component
*private_component
)
759 void append_test_event_from_notification(struct bt_notification
*notification
)
762 struct test_event test_event
;
764 switch (bt_notification_get_type(notification
)) {
765 case BT_NOTIFICATION_TYPE_EVENT
:
767 struct bt_event
*event
;
768 struct bt_clock_class_priority_map
*cc_prio_map
;
770 test_event
.type
= TEST_EV_TYPE_NOTIF_EVENT
;
772 bt_notification_event_borrow_clock_class_priority_map(
774 BT_ASSERT(cc_prio_map
);
775 event
= bt_notification_event_borrow_event(notification
);
778 if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map
) > 0) {
779 struct bt_clock_value
*clock_value
;
780 struct bt_clock_class
*clock_class
=
781 bt_clock_class_priority_map_borrow_highest_priority_clock_class(
784 BT_ASSERT(clock_class
);
785 clock_value
= bt_event_borrow_clock_value(event
,
787 BT_ASSERT(clock_value
);
788 ret
= bt_clock_value_get_value_ns_from_epoch(
789 clock_value
, &test_event
.ts_ns
);
792 test_event
.ts_ns
= -1;
797 case BT_NOTIFICATION_TYPE_INACTIVITY
:
799 struct bt_clock_class_priority_map
*cc_prio_map
;
801 test_event
.type
= TEST_EV_TYPE_NOTIF_INACTIVITY
;
802 cc_prio_map
= bt_notification_inactivity_borrow_clock_class_priority_map(
804 BT_ASSERT(cc_prio_map
);
806 if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map
) > 0) {
807 struct bt_clock_value
*clock_value
;
808 struct bt_clock_class
*clock_class
=
809 bt_clock_class_priority_map_borrow_highest_priority_clock_class(
812 BT_ASSERT(clock_class
);
814 bt_notification_inactivity_borrow_clock_value(
815 notification
, clock_class
);
816 BT_ASSERT(clock_value
);
817 ret
= bt_clock_value_get_value_ns_from_epoch(
818 clock_value
, &test_event
.ts_ns
);
821 test_event
.ts_ns
= -1;
826 case BT_NOTIFICATION_TYPE_PACKET_BEGIN
:
827 test_event
.type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
;
829 case BT_NOTIFICATION_TYPE_PACKET_END
:
830 test_event
.type
= TEST_EV_TYPE_NOTIF_PACKET_END
;
832 case BT_NOTIFICATION_TYPE_STREAM_BEGIN
:
833 test_event
.type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
;
835 case BT_NOTIFICATION_TYPE_STREAM_END
:
836 test_event
.type
= TEST_EV_TYPE_NOTIF_STREAM_END
;
839 test_event
.type
= TEST_EV_TYPE_NOTIF_UNEXPECTED
;
843 append_test_event(&test_event
);
847 enum bt_component_status
sink_consume(
848 struct bt_private_component
*priv_component
)
850 enum bt_component_status ret
= BT_COMPONENT_STATUS_OK
;
851 bt_notification_array notifications
= NULL
;
853 struct sink_user_data
*user_data
=
854 bt_private_component_get_user_data(priv_component
);
855 enum bt_notification_iterator_status it_ret
;
856 struct test_event test_event
;
857 bool do_append_test_event
= true;
860 BT_ASSERT(user_data
&& user_data
->notif_iter
);
861 it_ret
= bt_private_connection_notification_iterator_next(
862 user_data
->notif_iter
, ¬ifications
, &count
);
864 ret
= BT_COMPONENT_STATUS_ERROR
;
865 do_append_test_event
= false;
870 case BT_NOTIFICATION_ITERATOR_STATUS_END
:
871 test_event
.type
= TEST_EV_TYPE_END
;
872 ret
= BT_COMPONENT_STATUS_END
;
873 BT_PUT(user_data
->notif_iter
);
875 case BT_NOTIFICATION_ITERATOR_STATUS_AGAIN
:
876 test_event
.type
= TEST_EV_TYPE_AGAIN
;
877 ret
= BT_COMPONENT_STATUS_AGAIN
;
883 BT_ASSERT(notifications
);
885 for (i
= 0; i
< count
; i
++) {
886 append_test_event_from_notification(notifications
[i
]);
887 bt_put(notifications
[i
]);
890 do_append_test_event
= false;
893 if (do_append_test_event
) {
894 append_test_event(&test_event
);
901 void sink_port_connected(struct bt_private_component
*private_component
,
902 struct bt_private_port
*self_private_port
,
903 struct bt_port
*other_port
)
905 struct bt_private_connection
*priv_conn
=
906 bt_private_port_get_private_connection(self_private_port
);
907 struct sink_user_data
*user_data
= bt_private_component_get_user_data(
909 enum bt_connection_status conn_status
;
911 BT_ASSERT(user_data
);
912 BT_ASSERT(priv_conn
);
913 conn_status
= bt_private_connection_create_notification_iterator(
914 priv_conn
, &user_data
->notif_iter
);
915 BT_ASSERT(conn_status
== 0);
920 enum bt_component_status
sink_init(
921 struct bt_private_component
*private_component
,
922 struct bt_value
*params
, void *init_method_data
)
924 struct sink_user_data
*user_data
= g_new0(struct sink_user_data
, 1);
927 BT_ASSERT(user_data
);
928 ret
= bt_private_component_set_user_data(private_component
,
931 ret
= bt_private_component_sink_add_input_private_port(
932 private_component
, "in", NULL
, NULL
);
934 return BT_COMPONENT_STATUS_OK
;
938 void sink_finalize(struct bt_private_component
*private_component
)
940 struct sink_user_data
*user_data
= bt_private_component_get_user_data(
944 bt_put(user_data
->notif_iter
);
950 void create_source_muxer_sink(struct bt_graph
*graph
,
951 struct bt_component
**source
,
952 struct bt_component
**muxer
,
953 struct bt_component
**sink
)
955 struct bt_component_class
*src_comp_class
;
956 struct bt_component_class
*muxer_comp_class
;
957 struct bt_component_class
*sink_comp_class
;
960 /* Create source component */
961 src_comp_class
= bt_component_class_source_create("src", src_iter_next
);
962 BT_ASSERT(src_comp_class
);
963 ret
= bt_component_class_set_init_method(src_comp_class
, src_init
);
965 ret
= bt_component_class_set_finalize_method(src_comp_class
,
968 ret
= bt_component_class_source_set_notification_iterator_init_method(
969 src_comp_class
, src_iter_init
);
971 ret
= bt_component_class_source_set_notification_iterator_finalize_method(
972 src_comp_class
, src_iter_finalize
);
974 ret
= bt_graph_add_component(graph
, src_comp_class
, "source", NULL
, source
);
977 /* Create muxer component */
978 muxer_comp_class
= bt_plugin_find_component_class("utils", "muxer",
979 BT_COMPONENT_CLASS_TYPE_FILTER
);
980 BT_ASSERT(muxer_comp_class
);
981 ret
= bt_graph_add_component(graph
, muxer_comp_class
, "muxer", NULL
, muxer
);
984 /* Create sink component */
985 sink_comp_class
= bt_component_class_sink_create("sink", sink_consume
);
986 BT_ASSERT(sink_comp_class
);
987 ret
= bt_component_class_set_init_method(sink_comp_class
, sink_init
);
989 ret
= bt_component_class_set_finalize_method(sink_comp_class
,
991 ret
= bt_component_class_set_port_connected_method(sink_comp_class
,
992 sink_port_connected
);
994 ret
= bt_graph_add_component(graph
, sink_comp_class
, "sink", NULL
, sink
);
997 bt_put(src_comp_class
);
998 bt_put(muxer_comp_class
);
999 bt_put(sink_comp_class
);
1003 void do_std_test(enum test test
, const char *name
,
1004 const struct test_event
*expected_test_events
,
1007 struct bt_component
*src_comp
;
1008 struct bt_component
*muxer_comp
;
1009 struct bt_component
*sink_comp
;
1010 struct bt_port
*upstream_port
;
1011 struct bt_port
*downstream_port
;
1014 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
1016 clear_test_events();
1017 current_test
= test
;
1018 diag("test: %s", name
);
1020 graph
= bt_graph_create();
1022 create_source_muxer_sink(graph
, &src_comp
, &muxer_comp
, &sink_comp
);
1024 /* Connect source output ports to muxer input ports */
1025 if (with_upstream
) {
1026 count
= bt_component_source_get_output_port_count(src_comp
);
1027 BT_ASSERT(count
>= 0);
1029 for (i
= 0; i
< count
; i
++) {
1030 upstream_port
= bt_component_source_get_output_port_by_index(
1032 BT_ASSERT(upstream_port
);
1033 downstream_port
= bt_component_filter_get_input_port_by_index(
1035 BT_ASSERT(downstream_port
);
1036 graph_status
= bt_graph_connect_ports(graph
,
1037 upstream_port
, downstream_port
, NULL
);
1038 BT_ASSERT(graph_status
== 0);
1039 bt_put(upstream_port
);
1040 bt_put(downstream_port
);
1044 /* Connect muxer output port to sink input port */
1045 upstream_port
= bt_component_filter_get_output_port_by_name(muxer_comp
,
1047 BT_ASSERT(upstream_port
);
1048 downstream_port
= bt_component_sink_get_input_port_by_name(sink_comp
, "in");
1049 BT_ASSERT(downstream_port
);
1050 graph_status
= bt_graph_connect_ports(graph
, upstream_port
,
1051 downstream_port
, NULL
);
1052 BT_ASSERT(graph_status
== 0);
1053 bt_put(upstream_port
);
1054 bt_put(downstream_port
);
1056 while (graph_status
== BT_GRAPH_STATUS_OK
||
1057 graph_status
== BT_GRAPH_STATUS_AGAIN
) {
1058 graph_status
= bt_graph_run(graph
);
1061 ok(graph_status
== BT_GRAPH_STATUS_END
, "graph finishes without any error");
1062 ok(compare_test_events(expected_test_events
),
1063 "the produced sequence of test events is the expected one");
1072 void test_no_ts(void)
1074 const struct test_event expected_test_events
[] = {
1075 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1076 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1077 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1078 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1079 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1080 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1081 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1082 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1083 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1084 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1085 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1086 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 1, },
1087 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 4, },
1088 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 189, },
1089 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 1001, },
1090 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1091 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1092 { .type
= TEST_EV_TYPE_END
, },
1093 { .type
= TEST_EV_TYPE_SENTINEL
, },
1096 do_std_test(TEST_NO_TS
, "event notifications with no time",
1097 expected_test_events
, true);
1101 void test_no_upstream_connection(void)
1103 const struct test_event expected_test_events
[] = {
1104 { .type
= TEST_EV_TYPE_END
, },
1105 { .type
= TEST_EV_TYPE_SENTINEL
, },
1108 do_std_test(TEST_NO_UPSTREAM_CONNECTION
, "no upstream connection",
1109 expected_test_events
, false);
1113 void test_simple_4_ports(void)
1115 const struct test_event expected_test_events
[] = {
1116 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1117 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1118 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1119 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1120 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1121 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1122 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1123 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1124 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1125 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 24 },
1126 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 41 },
1127 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1128 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 53 },
1129 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 56 },
1130 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1131 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1132 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1133 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1134 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1135 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 97 },
1136 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 105 },
1137 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 119 },
1138 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 120 },
1139 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1140 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 138 },
1141 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1142 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 154 },
1143 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1144 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1145 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1146 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 210 },
1147 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 222 },
1148 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 228 },
1149 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 240 },
1150 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1151 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1152 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 292 },
1153 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1154 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 317 },
1155 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1156 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1157 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1158 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 353 },
1159 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1160 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 407 },
1161 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1162 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 433 },
1163 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1164 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 471 },
1165 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 473 },
1166 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1167 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 479 },
1168 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 481 },
1169 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 487 },
1170 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 504 },
1171 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 525 },
1172 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 572 },
1173 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 591 },
1174 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 605 },
1175 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 612 },
1176 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 615 },
1177 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 618 },
1178 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1179 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1180 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 632 },
1181 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1182 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1183 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1184 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 670 },
1185 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1186 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 696 },
1187 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 708 },
1188 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1189 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1190 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1191 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1192 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1193 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1194 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 766 },
1195 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1196 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1197 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1198 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1199 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1200 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 825 },
1201 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1202 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1203 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1204 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 850 },
1205 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 852 },
1206 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1207 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 863 },
1208 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 867 },
1209 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 871 },
1210 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 884 },
1211 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1212 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1213 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 931 },
1214 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1215 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 951 },
1216 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 953 },
1217 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 956 },
1218 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 985 },
1219 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 996 },
1220 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1221 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1222 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1223 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1224 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1225 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 999 },
1226 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1227 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1228 { .type
= TEST_EV_TYPE_END
, },
1229 { .type
= TEST_EV_TYPE_SENTINEL
, },
1232 do_std_test(TEST_SIMPLE_4_PORTS
, "simple: 4 ports without retries",
1233 expected_test_events
, true);
1237 void test_4_ports_with_retries(void)
1239 const struct test_event expected_test_events
[] = {
1240 { .type
= TEST_EV_TYPE_AGAIN
, },
1241 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1242 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1243 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1244 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1245 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1246 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1247 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1248 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1249 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1250 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 24 },
1251 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 41 },
1252 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1253 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 53 },
1254 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 56 },
1255 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1256 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1257 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1258 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1259 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1260 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 97 },
1261 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 105 },
1262 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 119 },
1263 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 120 },
1264 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1265 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 138 },
1266 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1267 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 154 },
1268 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1269 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1270 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1271 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 210 },
1272 { .type
= TEST_EV_TYPE_AGAIN
, },
1273 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 222 },
1274 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 228 },
1275 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 240 },
1276 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1277 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1278 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 292 },
1279 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1280 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 317 },
1281 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1282 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1283 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1284 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 353 },
1285 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1286 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 407 },
1287 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1288 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 433 },
1289 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1290 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 471 },
1291 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 473 },
1292 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1293 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 479 },
1294 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 481 },
1295 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 487 },
1296 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 504 },
1297 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 525 },
1298 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 572 },
1299 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 591 },
1300 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 605 },
1301 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 612 },
1302 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 615 },
1303 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 618 },
1304 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1305 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1306 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 632 },
1307 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1308 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1309 { .type
= TEST_EV_TYPE_AGAIN
, },
1310 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1311 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 670 },
1312 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1313 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 696 },
1314 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 708 },
1315 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1316 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1317 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1318 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1319 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1320 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1321 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 766 },
1322 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1323 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1324 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1325 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1326 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1327 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 825 },
1328 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1329 { .type
= TEST_EV_TYPE_AGAIN
, },
1330 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1331 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1332 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 850 },
1333 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 852 },
1334 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1335 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 863 },
1336 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 867 },
1337 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 871 },
1338 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 884 },
1339 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1340 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1341 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 931 },
1342 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1343 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 951 },
1344 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 953 },
1345 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 956 },
1346 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 985 },
1347 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 996 },
1348 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1349 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1350 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1351 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1352 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1353 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 999 },
1354 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1355 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1356 { .type
= TEST_EV_TYPE_END
, },
1357 { .type
= TEST_EV_TYPE_SENTINEL
, },
1360 do_std_test(TEST_4_PORTS_WITH_RETRIES
, "4 ports with retries",
1361 expected_test_events
, true);
1365 void connect_port_to_first_avail_muxer_port(struct bt_graph
*graph
,
1366 struct bt_port
*source_port
,
1367 struct bt_component
*muxer_comp
)
1369 struct bt_port
*avail_muxer_port
= NULL
;
1372 enum bt_graph_status graph_status
;
1374 count
= bt_component_filter_get_input_port_count(muxer_comp
);
1375 BT_ASSERT(count
>= 0);
1377 for (i
= 0; i
< count
; i
++) {
1378 struct bt_port
*muxer_port
=
1379 bt_component_filter_get_input_port_by_index(
1382 BT_ASSERT(muxer_port
);
1384 if (!bt_port_is_connected(muxer_port
)) {
1385 BT_MOVE(avail_muxer_port
, muxer_port
);
1392 graph_status
= bt_graph_connect_ports(graph
, source_port
,
1393 avail_muxer_port
, NULL
);
1394 BT_ASSERT(graph_status
== 0);
1395 bt_put(avail_muxer_port
);
1399 void graph_port_added_listener_connect_to_avail_muxer_port(struct bt_port
*port
,
1402 struct graph_listener_data
*graph_listener_data
= data
;
1403 struct bt_component
*comp
;
1405 comp
= bt_port_get_component(port
);
1408 if (comp
!= graph_listener_data
->source
) {
1412 connect_port_to_first_avail_muxer_port(graph_listener_data
->graph
,
1413 port
, graph_listener_data
->muxer
);
1420 void test_single_end_then_multiple_full(void)
1422 struct bt_component
*src_comp
;
1423 struct bt_component
*muxer_comp
;
1424 struct bt_component
*sink_comp
;
1425 struct bt_port
*upstream_port
;
1426 struct bt_port
*downstream_port
;
1430 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
1431 struct graph_listener_data graph_listener_data
;
1432 const struct test_event expected_test_events
[] = {
1433 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1434 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1435 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1436 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1437 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1438 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1439 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1440 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1441 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1442 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1443 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1444 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1445 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1446 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1447 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1448 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1449 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1450 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1451 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1452 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1453 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1454 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1455 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1456 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1457 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1458 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1459 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1460 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1461 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1462 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1463 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1464 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1465 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1466 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1467 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1468 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1469 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1470 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1471 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1472 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1473 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1474 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1475 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1476 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1477 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1478 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1479 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1480 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1481 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1482 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1483 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1484 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1485 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1486 { .type
= TEST_EV_TYPE_END
, },
1487 { .type
= TEST_EV_TYPE_SENTINEL
, },
1490 clear_test_events();
1491 current_test
= TEST_SINGLE_END_THEN_MULTIPLE_FULL
;
1492 diag("test: single end then multiple full");
1494 graph
= bt_graph_create();
1496 create_source_muxer_sink(graph
, &src_comp
, &muxer_comp
, &sink_comp
);
1497 graph_listener_data
.graph
= graph
;
1498 graph_listener_data
.source
= src_comp
;
1499 graph_listener_data
.muxer
= muxer_comp
;
1500 graph_listener_data
.sink
= sink_comp
;
1501 ret
= bt_graph_add_port_added_listener(graph
,
1502 graph_port_added_listener_connect_to_avail_muxer_port
, NULL
,
1503 &graph_listener_data
);
1504 BT_ASSERT(ret
>= 0);
1506 /* Connect source output ports to muxer input ports */
1507 count
= bt_component_source_get_output_port_count(src_comp
);
1508 BT_ASSERT(ret
== 0);
1510 for (i
= 0; i
< count
; i
++) {
1511 upstream_port
= bt_component_source_get_output_port_by_index(
1513 BT_ASSERT(upstream_port
);
1514 connect_port_to_first_avail_muxer_port(graph
,
1515 upstream_port
, muxer_comp
);
1516 bt_put(upstream_port
);
1519 /* Connect muxer output port to sink input port */
1520 upstream_port
= bt_component_filter_get_output_port_by_name(muxer_comp
,
1522 BT_ASSERT(upstream_port
);
1523 downstream_port
= bt_component_sink_get_input_port_by_name(sink_comp
, "in");
1524 BT_ASSERT(downstream_port
);
1525 graph_status
= bt_graph_connect_ports(graph
, upstream_port
,
1526 downstream_port
, NULL
);
1527 BT_ASSERT(graph_status
== 0);
1528 bt_put(upstream_port
);
1529 bt_put(downstream_port
);
1531 while (graph_status
== BT_GRAPH_STATUS_OK
||
1532 graph_status
== BT_GRAPH_STATUS_AGAIN
) {
1533 graph_status
= bt_graph_run(graph
);
1536 ok(graph_status
== BT_GRAPH_STATUS_END
, "graph finishes without any error");
1537 ok(compare_test_events(expected_test_events
),
1538 "the produced sequence of test events is the expected one");
1547 void test_single_again_end_then_multiple_full(void)
1549 struct bt_component
*src_comp
;
1550 struct bt_component
*muxer_comp
;
1551 struct bt_component
*sink_comp
;
1552 struct bt_port
*upstream_port
;
1553 struct bt_port
*downstream_port
;
1557 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
1558 struct graph_listener_data graph_listener_data
;
1559 const struct test_event expected_test_events
[] = {
1560 { .type
= TEST_EV_TYPE_AGAIN
, },
1561 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1562 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1563 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1564 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1565 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1566 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1567 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1568 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1569 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1570 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1571 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1572 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1573 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1574 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1575 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1576 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1577 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1578 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1579 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1580 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1581 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1582 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1583 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1584 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1585 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1586 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1587 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1588 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1589 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1590 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1591 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1592 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1593 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1594 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1595 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1596 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1597 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1598 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1599 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1600 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1601 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1602 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1603 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1604 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1605 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1606 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1607 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1608 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1609 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1610 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1611 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1612 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1613 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1614 { .type
= TEST_EV_TYPE_END
, },
1615 { .type
= TEST_EV_TYPE_SENTINEL
, },
1618 clear_test_events();
1619 current_test
= TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
;
1620 diag("test: single again then end then multiple full");
1622 graph
= bt_graph_create();
1624 create_source_muxer_sink(graph
, &src_comp
, &muxer_comp
, &sink_comp
);
1625 graph_listener_data
.graph
= graph
;
1626 graph_listener_data
.source
= src_comp
;
1627 graph_listener_data
.muxer
= muxer_comp
;
1628 graph_listener_data
.sink
= sink_comp
;
1629 ret
= bt_graph_add_port_added_listener(graph
,
1630 graph_port_added_listener_connect_to_avail_muxer_port
, NULL
,
1631 &graph_listener_data
);
1632 BT_ASSERT(ret
>= 0);
1634 /* Connect source output ports to muxer input ports */
1635 count
= bt_component_source_get_output_port_count(src_comp
);
1636 BT_ASSERT(ret
== 0);
1638 for (i
= 0; i
< count
; i
++) {
1639 upstream_port
= bt_component_source_get_output_port_by_index(
1641 BT_ASSERT(upstream_port
);
1642 connect_port_to_first_avail_muxer_port(graph
,
1643 upstream_port
, muxer_comp
);
1644 bt_put(upstream_port
);
1647 /* Connect muxer output port to sink input port */
1648 upstream_port
= bt_component_filter_get_output_port_by_name(muxer_comp
,
1650 BT_ASSERT(upstream_port
);
1651 downstream_port
= bt_component_sink_get_input_port_by_name(sink_comp
, "in");
1652 BT_ASSERT(downstream_port
);
1653 graph_status
= bt_graph_connect_ports(graph
, upstream_port
,
1654 downstream_port
, NULL
);
1655 BT_ASSERT(graph_status
== 0);
1656 bt_put(upstream_port
);
1657 bt_put(downstream_port
);
1659 while (graph_status
== BT_GRAPH_STATUS_OK
||
1660 graph_status
== BT_GRAPH_STATUS_AGAIN
) {
1661 graph_status
= bt_graph_run(graph
);
1664 ok(graph_status
== BT_GRAPH_STATUS_END
, "graph finishes without any error");
1665 ok(compare_test_events(expected_test_events
),
1666 "the produced sequence of test events is the expected one");
1674 #define DEBUG_ENV_VAR "TEST_UTILS_MUXER_DEBUG"
1676 int main(int argc
, char **argv
)
1678 if (getenv(DEBUG_ENV_VAR
) && strcmp(getenv(DEBUG_ENV_VAR
), "1") == 0) {
1682 plan_tests(NR_TESTS
);
1685 test_no_upstream_connection();
1686 test_simple_4_ports();
1687 test_4_ports_with_retries();
1688 test_single_end_then_multiple_full();
1689 test_single_again_end_then_multiple_full();
1691 return exit_status();