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/ctf-ir/event-class.h>
25 #include <babeltrace/ctf-ir/event.h>
26 #include <babeltrace/ctf-ir/field-types.h>
27 #include <babeltrace/ctf-ir/fields.h>
28 #include <babeltrace/ctf-ir/packet.h>
29 #include <babeltrace/ctf-ir/stream-class.h>
30 #include <babeltrace/ctf-ir/stream.h>
31 #include <babeltrace/ctf-ir/trace.h>
32 #include <babeltrace/graph/clock-class-priority-map.h>
33 #include <babeltrace/graph/component-class-filter.h>
34 #include <babeltrace/graph/component-class-sink.h>
35 #include <babeltrace/graph/component-class-source.h>
36 #include <babeltrace/graph/component-class.h>
37 #include <babeltrace/graph/component-filter.h>
38 #include <babeltrace/graph/component-sink.h>
39 #include <babeltrace/graph/component-source.h>
40 #include <babeltrace/graph/component.h>
41 #include <babeltrace/graph/graph.h>
42 #include <babeltrace/graph/notification-event.h>
43 #include <babeltrace/graph/notification-inactivity.h>
44 #include <babeltrace/graph/notification-iterator.h>
45 #include <babeltrace/graph/notification-packet.h>
46 #include <babeltrace/graph/port.h>
47 #include <babeltrace/graph/private-component-source.h>
48 #include <babeltrace/graph/private-component-sink.h>
49 #include <babeltrace/graph/private-component.h>
50 #include <babeltrace/graph/private-connection.h>
51 #include <babeltrace/graph/private-notification-iterator.h>
52 #include <babeltrace/graph/private-port.h>
53 #include <babeltrace/plugin/plugin.h>
54 #include <babeltrace/ref.h>
63 TEST_NO_UPSTREAM_CONNECTION
,
65 TEST_4_PORTS_WITH_RETRIES
,
66 TEST_SINGLE_END_THEN_MULTIPLE_FULL
,
67 TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
,
70 enum test_event_type
{
71 TEST_EV_TYPE_NOTIF_UNEXPECTED
,
72 TEST_EV_TYPE_NOTIF_EVENT
,
73 TEST_EV_TYPE_NOTIF_INACTIVITY
,
74 TEST_EV_TYPE_NOTIF_PACKET_BEGIN
,
75 TEST_EV_TYPE_NOTIF_PACKET_END
,
76 TEST_EV_TYPE_NOTIF_STREAM_BEGIN
,
77 TEST_EV_TYPE_NOTIF_STREAM_END
,
80 TEST_EV_TYPE_SENTINEL
,
84 enum test_event_type type
;
88 struct source_muxer_sink
{
89 struct bt_component
*source
;
90 struct bt_component
*muxer
;
91 struct bt_component
*sink
;
94 struct graph_listener_data
{
95 struct bt_graph
*graph
;
96 struct bt_component
*source
;
97 struct bt_component
*muxer
;
98 struct bt_component
*sink
;
101 static bool debug
= false;
102 static enum test current_test
;
103 static GArray
*test_events
;
104 static struct bt_clock_class_priority_map
*src_cc_prio_map
;
105 static struct bt_clock_class_priority_map
*src_empty_cc_prio_map
;
106 static struct bt_ctf_clock_class
*src_clock_class
;
107 static struct bt_ctf_stream_class
*src_stream_class
;
108 static struct bt_ctf_event_class
*src_event_class
;
109 static struct bt_ctf_packet
*src_packet0
;
110 static struct bt_ctf_packet
*src_packet1
;
111 static struct bt_ctf_packet
*src_packet2
;
112 static struct bt_ctf_packet
*src_packet3
;
117 SEQ_PACKET_BEGIN
= -3,
121 struct src_iter_user_data
{
125 struct bt_ctf_packet
*packet
;
128 struct sink_user_data
{
129 struct bt_notification_iterator
*notif_iter
;
132 static int64_t seq1
[] = {
133 24, 53, 97, 105, 119, 210, 222, 240, 292, 317, 353, 407, 433,
134 473, 487, 504, 572, 615, 708, 766, 850, 852, 931, 951, 956, 996,
138 static int64_t seq2
[] = {
139 51, 59, 68, 77, 91, 121, 139, 170, 179, 266, 352, 454, 478, 631,
140 644, 668, 714, 744, 750, 778, 790, 836, SEQ_END
,
143 static int64_t seq3
[] = {
144 8, 71, 209, 254, 298, 320, 350, 393, 419, 624, 651, 678, 717,
145 731, 733, 788, 819, 820, 857, 892, 903, 944, 998, SEQ_END
,
148 static int64_t seq4
[] = {
149 41, 56, 120, 138, 154, 228, 471, 479, 481, 525, 591, 605, 612,
150 618, 632, 670, 696, 825, 863, 867, 871, 884, 953, 985, 999,
154 static int64_t seq1_with_again
[] = {
155 24, 53, 97, 105, 119, 210, SEQ_AGAIN
, 222, 240, 292, 317, 353,
156 407, 433, 473, 487, 504, 572, 615, 708, 766, 850, 852, 931, 951,
160 static int64_t seq2_with_again
[] = {
161 51, 59, 68, 77, 91, 121, 139, 170, 179, 266, 352, 454, 478, 631,
162 644, 668, 714, 744, 750, 778, 790, 836, SEQ_AGAIN
, SEQ_END
,
165 static int64_t seq3_with_again
[] = {
166 8, 71, 209, 254, 298, 320, 350, 393, 419, 624, 651, SEQ_AGAIN
,
167 678, 717, 731, 733, 788, 819, 820, 857, 892, 903, 944, 998,
171 static int64_t seq4_with_again
[] = {
172 SEQ_AGAIN
, 41, 56, 120, 138, 154, 228, 471, 479, 481, 525, 591,
173 605, 612, 618, 632, 670, 696, 825, 863, 867, 871, 884, 953, 985,
177 static int64_t seq5
[] = {
178 1, 4, 189, 1001, SEQ_END
,
182 void clear_test_events(void)
184 g_array_set_size(test_events
, 0);
188 void print_test_event(FILE *fp
, const struct test_event
*event
)
190 fprintf(fp
, "{ type = ");
192 switch (event
->type
) {
193 case TEST_EV_TYPE_NOTIF_UNEXPECTED
:
194 fprintf(fp
, "TEST_EV_TYPE_NOTIF_UNEXPECTED");
196 case TEST_EV_TYPE_NOTIF_EVENT
:
197 fprintf(fp
, "TEST_EV_TYPE_NOTIF_EVENT");
199 case TEST_EV_TYPE_NOTIF_INACTIVITY
:
200 fprintf(fp
, "TEST_EV_TYPE_NOTIF_INACTIVITY");
202 case TEST_EV_TYPE_NOTIF_PACKET_BEGIN
:
203 fprintf(fp
, "TEST_EV_TYPE_NOTIF_PACKET_BEGIN");
205 case TEST_EV_TYPE_NOTIF_PACKET_END
:
206 fprintf(fp
, "TEST_EV_TYPE_NOTIF_PACKET_END");
208 case TEST_EV_TYPE_NOTIF_STREAM_BEGIN
:
209 fprintf(fp
, "TEST_EV_TYPE_NOTIF_STREAM_BEGIN");
211 case TEST_EV_TYPE_NOTIF_STREAM_END
:
212 fprintf(fp
, "TEST_EV_TYPE_NOTIF_STREAM_END");
214 case TEST_EV_TYPE_AGAIN
:
215 fprintf(fp
, "TEST_EV_TYPE_AGAIN");
217 case TEST_EV_TYPE_END
:
218 fprintf(fp
, "TEST_EV_TYPE_END");
220 case TEST_EV_TYPE_SENTINEL
:
221 fprintf(fp
, "TEST_EV_TYPE_SENTINEL");
224 fprintf(fp
, "(UNKNOWN)");
228 switch (event
->type
) {
229 case TEST_EV_TYPE_NOTIF_EVENT
:
230 case TEST_EV_TYPE_NOTIF_INACTIVITY
:
231 fprintf(fp
, ", ts-ns = %" PRId64
, event
->ts_ns
);
240 void append_test_event(struct test_event
*event
)
242 g_array_append_val(test_events
, *event
);
246 bool compare_single_test_events(const struct test_event
*ev_a
,
247 const struct test_event
*ev_b
)
250 fprintf(stderr
, ":: Comparing test events: ");
251 print_test_event(stderr
, ev_a
);
252 fprintf(stderr
, " vs. ");
253 print_test_event(stderr
, ev_b
);
254 fprintf(stderr
, "\n");
257 if (ev_a
->type
!= ev_b
->type
) {
261 switch (ev_a
->type
) {
262 case TEST_EV_TYPE_NOTIF_EVENT
:
263 case TEST_EV_TYPE_NOTIF_INACTIVITY
:
264 if (ev_a
->ts_ns
!= ev_b
->ts_ns
) {
276 bool compare_test_events(const struct test_event
*expected_events
)
278 const struct test_event
*expected_event
= expected_events
;
281 assert(expected_events
);
284 const struct test_event
*event
;
286 if (expected_event
->type
== TEST_EV_TYPE_SENTINEL
) {
290 if (i
>= test_events
->len
) {
294 event
= &g_array_index(test_events
, struct test_event
, i
);
296 if (!compare_single_test_events(event
, expected_event
)) {
304 if (i
!= test_events
->len
) {
306 fprintf(stderr
, ":: Length mismatch\n");
316 void init_static_data(void)
319 struct bt_ctf_trace
*trace
;
320 struct bt_ctf_stream
*stream
;
321 struct bt_ctf_field_type
*empty_struct_ft
;
324 test_events
= g_array_new(FALSE
, TRUE
, sizeof(struct test_event
));
328 empty_struct_ft
= bt_ctf_field_type_structure_create();
329 assert(empty_struct_ft
);
330 trace
= bt_ctf_trace_create();
332 ret
= bt_ctf_trace_set_native_byte_order(trace
,
333 BT_CTF_BYTE_ORDER_LITTLE_ENDIAN
);
335 ret
= bt_ctf_trace_set_packet_header_type(trace
, empty_struct_ft
);
337 src_clock_class
= bt_ctf_clock_class_create("my-clock");
338 assert(src_clock_class
);
339 ret
= bt_ctf_clock_class_set_is_absolute(src_clock_class
, 1);
341 ret
= bt_ctf_trace_add_clock_class(trace
, src_clock_class
);
343 src_empty_cc_prio_map
= bt_clock_class_priority_map_create();
344 assert(src_empty_cc_prio_map
);
345 src_cc_prio_map
= bt_clock_class_priority_map_create();
346 assert(src_cc_prio_map
);
347 ret
= bt_clock_class_priority_map_add_clock_class(src_cc_prio_map
,
350 src_stream_class
= bt_ctf_stream_class_create("my-stream-class");
351 assert(src_stream_class
);
352 ret
= bt_ctf_stream_class_set_packet_context_type(src_stream_class
,
355 ret
= bt_ctf_stream_class_set_event_header_type(src_stream_class
,
358 ret
= bt_ctf_stream_class_set_event_context_type(src_stream_class
,
361 src_event_class
= bt_ctf_event_class_create("my-event-class");
362 ret
= bt_ctf_event_class_set_context_type(src_event_class
,
365 ret
= bt_ctf_event_class_set_context_type(src_event_class
,
368 ret
= bt_ctf_stream_class_add_event_class(src_stream_class
,
371 ret
= bt_ctf_trace_add_stream_class(trace
, src_stream_class
);
373 stream
= bt_ctf_stream_create(src_stream_class
, "stream0");
375 src_packet0
= bt_ctf_packet_create(stream
);
378 stream
= bt_ctf_stream_create(src_stream_class
, "stream1");
380 src_packet1
= bt_ctf_packet_create(stream
);
383 stream
= bt_ctf_stream_create(src_stream_class
, "stream2");
385 src_packet2
= bt_ctf_packet_create(stream
);
388 stream
= bt_ctf_stream_create(src_stream_class
, "stream3");
390 src_packet3
= bt_ctf_packet_create(stream
);
395 bt_put(empty_struct_ft
);
399 void fini_static_data(void)
402 g_array_free(test_events
, TRUE
);
405 bt_put(src_empty_cc_prio_map
);
406 bt_put(src_cc_prio_map
);
407 bt_put(src_clock_class
);
408 bt_put(src_stream_class
);
409 bt_put(src_event_class
);
417 void src_iter_finalize(
418 struct bt_private_notification_iterator
*private_notification_iterator
)
420 struct src_iter_user_data
*user_data
=
421 bt_private_notification_iterator_get_user_data(
422 private_notification_iterator
);
430 enum bt_notification_iterator_status
src_iter_init(
431 struct bt_private_notification_iterator
*priv_notif_iter
,
432 struct bt_private_port
*private_port
)
434 struct src_iter_user_data
*user_data
=
435 g_new0(struct src_iter_user_data
, 1);
436 struct bt_port
*port
= bt_port_from_private_port(private_port
);
437 const char *port_name
;
442 ret
= bt_private_notification_iterator_set_user_data(priv_notif_iter
,
445 port_name
= bt_port_get_name(port
);
447 user_data
->iter_index
= port_name
[3] - '0';
450 switch (user_data
->iter_index
) {
452 user_data
->packet
= src_packet0
;
455 user_data
->packet
= src_packet1
;
458 user_data
->packet
= src_packet2
;
461 user_data
->packet
= src_packet3
;
467 switch (current_test
) {
469 if (user_data
->iter_index
== 1) {
470 user_data
->seq
= seq5
;
473 case TEST_SIMPLE_4_PORTS
:
474 if (user_data
->iter_index
== 0) {
475 user_data
->seq
= seq1
;
476 } else if (user_data
->iter_index
== 1) {
477 user_data
->seq
= seq2
;
478 } else if (user_data
->iter_index
== 2) {
479 user_data
->seq
= seq3
;
481 user_data
->seq
= seq4
;
484 case TEST_4_PORTS_WITH_RETRIES
:
485 if (user_data
->iter_index
== 0) {
486 user_data
->seq
= seq1_with_again
;
487 } else if (user_data
->iter_index
== 1) {
488 user_data
->seq
= seq2_with_again
;
489 } else if (user_data
->iter_index
== 2) {
490 user_data
->seq
= seq3_with_again
;
492 user_data
->seq
= seq4_with_again
;
495 case TEST_SINGLE_END_THEN_MULTIPLE_FULL
:
496 case TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
:
497 if (user_data
->iter_index
== 0) {
498 /* Ignore: this iterator only returns END */
499 } else if (user_data
->iter_index
== 1) {
500 user_data
->seq
= seq2
;
502 user_data
->seq
= seq3
;
509 return BT_NOTIFICATION_ITERATOR_STATUS_OK
;
513 struct bt_ctf_event
*src_create_event(struct bt_ctf_packet
*packet
,
516 struct bt_ctf_event
*event
= bt_ctf_event_create(src_event_class
);
520 ret
= bt_ctf_event_set_packet(event
, packet
);
524 struct bt_ctf_clock_value
*clock_value
;
526 clock_value
= bt_ctf_clock_value_create(src_clock_class
,
529 ret
= bt_ctf_event_set_clock_value(event
, clock_value
);
537 struct bt_notification_iterator_next_return
src_iter_next_seq(
538 struct src_iter_user_data
*user_data
)
540 struct bt_notification_iterator_next_return next_return
= {
541 .status
= BT_NOTIFICATION_ITERATOR_STATUS_OK
,
545 assert(user_data
->seq
);
546 cur_ts_ns
= user_data
->seq
[user_data
->at
];
551 BT_NOTIFICATION_ITERATOR_STATUS_END
;
555 BT_NOTIFICATION_ITERATOR_STATUS_AGAIN
;
557 case SEQ_PACKET_BEGIN
:
558 next_return
.notification
=
559 bt_notification_packet_begin_create(user_data
->packet
);
560 assert(next_return
.notification
);
563 next_return
.notification
=
564 bt_notification_packet_end_create(user_data
->packet
);
565 assert(next_return
.notification
);
569 struct bt_ctf_event
*event
= src_create_event(
570 user_data
->packet
, cur_ts_ns
);
573 next_return
.notification
= bt_notification_event_create(event
,
576 assert(next_return
.notification
);
581 if (next_return
.status
!= BT_NOTIFICATION_ITERATOR_STATUS_END
) {
589 struct bt_notification_iterator_next_return
src_iter_next(
590 struct bt_private_notification_iterator
*priv_iterator
)
592 struct bt_notification_iterator_next_return next_return
= {
593 .status
= BT_NOTIFICATION_ITERATOR_STATUS_OK
,
594 .notification
= NULL
,
596 struct src_iter_user_data
*user_data
=
597 bt_private_notification_iterator_get_user_data(priv_iterator
);
598 struct bt_private_component
*private_component
=
599 bt_private_notification_iterator_get_private_component(priv_iterator
);
602 assert(private_component
);
604 switch (current_test
) {
606 if (user_data
->iter_index
== 0) {
607 if (user_data
->at
== 0) {
608 next_return
.notification
=
609 bt_notification_packet_begin_create(
611 assert(next_return
.notification
);
612 } else if (user_data
->at
< 6) {
613 struct bt_ctf_event
*event
= src_create_event(
614 user_data
->packet
, -1);
617 next_return
.notification
=
618 bt_notification_event_create(event
,
619 src_empty_cc_prio_map
);
620 assert(next_return
.notification
);
624 BT_NOTIFICATION_ITERATOR_STATUS_END
;
629 next_return
= src_iter_next_seq(user_data
);
632 case TEST_SIMPLE_4_PORTS
:
633 case TEST_4_PORTS_WITH_RETRIES
:
634 next_return
= src_iter_next_seq(user_data
);
636 case TEST_SINGLE_END_THEN_MULTIPLE_FULL
:
637 if (user_data
->iter_index
== 0) {
638 struct bt_private_port
*priv_port
;
640 priv_port
= bt_private_component_source_add_output_private_port(
641 private_component
, "out1", NULL
);
644 priv_port
= bt_private_component_source_add_output_private_port(
645 private_component
, "out2", NULL
);
648 next_return
.status
= BT_NOTIFICATION_ITERATOR_STATUS_END
;
650 next_return
= src_iter_next_seq(user_data
);
653 case TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
:
654 if (user_data
->iter_index
== 0) {
655 if (user_data
->at
== 0) {
656 next_return
.status
= BT_NOTIFICATION_ITERATOR_STATUS_AGAIN
;
659 struct bt_private_port
*priv_port
;
661 priv_port
= bt_private_component_source_add_output_private_port(
662 private_component
, "out1", NULL
);
665 priv_port
= bt_private_component_source_add_output_private_port(
666 private_component
, "out2", NULL
);
669 next_return
.status
= BT_NOTIFICATION_ITERATOR_STATUS_END
;
672 next_return
= src_iter_next_seq(user_data
);
679 bt_put(private_component
);
684 enum bt_component_status
src_init(
685 struct bt_private_component
*private_component
,
686 struct bt_value
*params
, void *init_method_data
)
688 struct bt_private_port
*priv_port
;
691 switch (current_test
) {
695 case TEST_SINGLE_END_THEN_MULTIPLE_FULL
:
696 case TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
:
705 priv_port
= bt_private_component_source_add_output_private_port(
706 private_component
, "out0", NULL
);
712 priv_port
= bt_private_component_source_add_output_private_port(
713 private_component
, "out1", NULL
);
719 priv_port
= bt_private_component_source_add_output_private_port(
720 private_component
, "out2", NULL
);
726 priv_port
= bt_private_component_source_add_output_private_port(
727 private_component
, "out3", NULL
);
732 return BT_COMPONENT_STATUS_OK
;
736 void src_finalize(struct bt_private_component
*private_component
)
741 enum bt_component_status
sink_consume(
742 struct bt_private_component
*priv_component
)
744 enum bt_component_status ret
= BT_COMPONENT_STATUS_OK
;
745 struct bt_notification
*notification
= NULL
;
746 struct sink_user_data
*user_data
=
747 bt_private_component_get_user_data(priv_component
);
748 enum bt_notification_iterator_status it_ret
;
749 struct test_event test_event
;
750 bool do_append_test_event
= true;
752 assert(user_data
&& user_data
->notif_iter
);
753 it_ret
= bt_notification_iterator_next(user_data
->notif_iter
);
756 ret
= BT_COMPONENT_STATUS_ERROR
;
757 do_append_test_event
= false;
762 case BT_NOTIFICATION_ITERATOR_STATUS_END
:
763 test_event
.type
= TEST_EV_TYPE_END
;
764 ret
= BT_COMPONENT_STATUS_END
;
765 BT_PUT(user_data
->notif_iter
);
767 case BT_NOTIFICATION_ITERATOR_STATUS_AGAIN
:
768 test_event
.type
= TEST_EV_TYPE_AGAIN
;
769 ret
= BT_COMPONENT_STATUS_AGAIN
;
775 notification
= bt_notification_iterator_get_notification(
776 user_data
->notif_iter
);
777 assert(notification
);
779 switch (bt_notification_get_type(notification
)) {
780 case BT_NOTIFICATION_TYPE_EVENT
:
782 struct bt_ctf_event
*event
;
783 struct bt_clock_class_priority_map
*cc_prio_map
;
785 test_event
.type
= TEST_EV_TYPE_NOTIF_EVENT
;
787 bt_notification_event_get_clock_class_priority_map(
790 event
= bt_notification_event_get_event(notification
);
793 if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map
) > 0) {
794 struct bt_ctf_clock_value
*clock_value
;
795 struct bt_ctf_clock_class
*clock_class
=
796 bt_clock_class_priority_map_get_highest_priority_clock_class(
800 clock_value
= bt_ctf_event_get_clock_value(event
,
803 ret
= bt_ctf_clock_value_get_value_ns_from_epoch(
804 clock_value
, &test_event
.ts_ns
);
809 test_event
.ts_ns
= -1;
816 case BT_NOTIFICATION_TYPE_INACTIVITY
:
818 struct bt_clock_class_priority_map
*cc_prio_map
;
820 test_event
.type
= TEST_EV_TYPE_NOTIF_INACTIVITY
;
821 cc_prio_map
= bt_notification_event_get_clock_class_priority_map(
825 if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map
) > 0) {
826 struct bt_ctf_clock_value
*clock_value
;
827 struct bt_ctf_clock_class
*clock_class
=
828 bt_clock_class_priority_map_get_highest_priority_clock_class(
833 bt_notification_inactivity_get_clock_value(
834 notification
, clock_class
);
836 ret
= bt_ctf_clock_value_get_value_ns_from_epoch(
837 clock_value
, &test_event
.ts_ns
);
842 test_event
.ts_ns
= -1;
848 case BT_NOTIFICATION_TYPE_PACKET_BEGIN
:
849 test_event
.type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
;
851 case BT_NOTIFICATION_TYPE_PACKET_END
:
852 test_event
.type
= TEST_EV_TYPE_NOTIF_PACKET_END
;
854 case BT_NOTIFICATION_TYPE_STREAM_BEGIN
:
855 test_event
.type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
;
857 case BT_NOTIFICATION_TYPE_STREAM_END
:
858 test_event
.type
= TEST_EV_TYPE_NOTIF_STREAM_END
;
861 test_event
.type
= TEST_EV_TYPE_NOTIF_UNEXPECTED
;
866 if (do_append_test_event
) {
867 append_test_event(&test_event
);
870 bt_put(notification
);
875 void sink_port_connected(struct bt_private_component
*private_component
,
876 struct bt_private_port
*self_private_port
,
877 struct bt_port
*other_port
)
879 struct bt_private_connection
*priv_conn
=
880 bt_private_port_get_private_connection(self_private_port
);
881 struct sink_user_data
*user_data
= bt_private_component_get_user_data(
886 user_data
->notif_iter
=
887 bt_private_connection_create_notification_iterator(priv_conn
,
889 assert(user_data
->notif_iter
);
894 enum bt_component_status
sink_init(
895 struct bt_private_component
*private_component
,
896 struct bt_value
*params
, void *init_method_data
)
898 struct sink_user_data
*user_data
= g_new0(struct sink_user_data
, 1);
903 ret
= bt_private_component_set_user_data(private_component
,
906 priv_port
= bt_private_component_sink_add_input_private_port(
907 private_component
, "in", NULL
);
910 return BT_COMPONENT_STATUS_OK
;
914 void sink_finalize(struct bt_private_component
*private_component
)
916 struct sink_user_data
*user_data
= bt_private_component_get_user_data(
920 bt_put(user_data
->notif_iter
);
926 void create_source_muxer_sink(struct bt_component
**source
,
927 struct bt_component
**muxer
,
928 struct bt_component
**sink
)
930 struct bt_component_class
*src_comp_class
;
931 struct bt_component_class
*muxer_comp_class
;
932 struct bt_component_class
*sink_comp_class
;
935 /* Create source component */
936 src_comp_class
= bt_component_class_source_create("src", src_iter_next
);
937 assert(src_comp_class
);
938 ret
= bt_component_class_set_init_method(src_comp_class
, src_init
);
940 ret
= bt_component_class_set_finalize_method(src_comp_class
,
943 ret
= bt_component_class_source_set_notification_iterator_init_method(
944 src_comp_class
, src_iter_init
);
946 ret
= bt_component_class_source_set_notification_iterator_finalize_method(
947 src_comp_class
, src_iter_finalize
);
949 *source
= bt_component_create(src_comp_class
, "source", NULL
);
952 /* Create muxer component */
953 muxer_comp_class
= bt_plugin_find_component_class("utils", "muxer",
954 BT_COMPONENT_CLASS_TYPE_FILTER
);
955 assert(muxer_comp_class
);
956 *muxer
= bt_component_create(muxer_comp_class
, "muxer", NULL
);
959 /* Create sink component */
960 sink_comp_class
= bt_component_class_sink_create("sink", sink_consume
);
961 assert(sink_comp_class
);
962 ret
= bt_component_class_set_init_method(sink_comp_class
, sink_init
);
964 ret
= bt_component_class_set_finalize_method(sink_comp_class
,
966 ret
= bt_component_class_set_port_connected_method(sink_comp_class
,
967 sink_port_connected
);
969 *sink
= bt_component_create(sink_comp_class
, "sink", NULL
);
971 bt_put(src_comp_class
);
972 bt_put(muxer_comp_class
);
973 bt_put(sink_comp_class
);
977 void do_std_test(enum test test
, const char *name
,
978 const struct test_event
*expected_test_events
,
981 struct bt_component
*src_comp
;
982 struct bt_component
*muxer_comp
;
983 struct bt_component
*sink_comp
;
984 struct bt_port
*upstream_port
;
985 struct bt_port
*downstream_port
;
986 struct bt_graph
*graph
;
990 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
994 diag("test: %s", name
);
995 create_source_muxer_sink(&src_comp
, &muxer_comp
, &sink_comp
);
996 graph
= bt_graph_create();
999 /* Connect source output ports to muxer input ports */
1000 if (with_upstream
) {
1001 count
= bt_component_source_get_output_port_count(src_comp
);
1004 for (i
= 0; i
< count
; i
++) {
1005 upstream_port
= bt_component_source_get_output_port_by_index(
1007 assert(upstream_port
);
1008 downstream_port
= bt_component_filter_get_input_port_by_index(
1010 assert(downstream_port
);
1011 conn
= bt_graph_connect_ports(graph
,
1012 upstream_port
, downstream_port
);
1015 bt_put(upstream_port
);
1016 bt_put(downstream_port
);
1020 /* Connect muxer output port to sink input port */
1021 upstream_port
= bt_component_filter_get_output_port_by_name(muxer_comp
,
1023 assert(upstream_port
);
1024 downstream_port
= bt_component_sink_get_input_port_by_name(sink_comp
, "in");
1025 assert(downstream_port
);
1026 conn
= bt_graph_connect_ports(graph
, upstream_port
, downstream_port
);
1029 bt_put(upstream_port
);
1030 bt_put(downstream_port
);
1032 while (graph_status
== BT_GRAPH_STATUS_OK
||
1033 graph_status
== BT_GRAPH_STATUS_AGAIN
) {
1034 graph_status
= bt_graph_run(graph
);
1037 ok(graph_status
== BT_GRAPH_STATUS_END
, "graph finishes without any error");
1038 ok(compare_test_events(expected_test_events
),
1039 "the produced sequence of test events is the expected one");
1048 void test_no_ts(void)
1050 const struct test_event expected_test_events
[] = {
1051 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1052 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1053 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1054 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1055 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1056 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1057 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1058 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1059 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1060 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1061 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1062 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 1, },
1063 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 4, },
1064 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 189, },
1065 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 1001, },
1066 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1067 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1068 { .type
= TEST_EV_TYPE_END
, },
1069 { .type
= TEST_EV_TYPE_SENTINEL
, },
1072 do_std_test(TEST_NO_TS
, "event notifications with no time",
1073 expected_test_events
, true);
1077 void test_no_upstream_connection(void)
1079 const struct test_event expected_test_events
[] = {
1080 { .type
= TEST_EV_TYPE_END
, },
1081 { .type
= TEST_EV_TYPE_SENTINEL
, },
1084 do_std_test(TEST_NO_UPSTREAM_CONNECTION
, "no upstream connection",
1085 expected_test_events
, false);
1089 void test_simple_4_ports(void)
1091 const struct test_event expected_test_events
[] = {
1092 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1093 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1094 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1095 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1096 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1097 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1098 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1099 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1100 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1101 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 24 },
1102 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 41 },
1103 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1104 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 53 },
1105 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 56 },
1106 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1107 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1108 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1109 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1110 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1111 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 97 },
1112 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 105 },
1113 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 119 },
1114 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 120 },
1115 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1116 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 138 },
1117 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1118 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 154 },
1119 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1120 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1121 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1122 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 210 },
1123 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 222 },
1124 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 228 },
1125 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 240 },
1126 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1127 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1128 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 292 },
1129 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1130 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 317 },
1131 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1132 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1133 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1134 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 353 },
1135 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1136 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 407 },
1137 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1138 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 433 },
1139 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1140 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 471 },
1141 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 473 },
1142 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1143 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 479 },
1144 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 481 },
1145 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 487 },
1146 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 504 },
1147 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 525 },
1148 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 572 },
1149 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 591 },
1150 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 605 },
1151 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 612 },
1152 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 615 },
1153 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 618 },
1154 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1155 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1156 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 632 },
1157 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1158 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1159 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1160 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 670 },
1161 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1162 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 696 },
1163 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 708 },
1164 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1165 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1166 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1167 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1168 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1169 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1170 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 766 },
1171 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1172 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1173 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1174 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1175 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1176 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 825 },
1177 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1178 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1179 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1180 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 850 },
1181 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 852 },
1182 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1183 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 863 },
1184 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 867 },
1185 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 871 },
1186 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 884 },
1187 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1188 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1189 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 931 },
1190 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1191 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 951 },
1192 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 953 },
1193 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 956 },
1194 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 985 },
1195 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 996 },
1196 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1197 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1198 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1199 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1200 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1201 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 999 },
1202 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1203 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1204 { .type
= TEST_EV_TYPE_END
, },
1205 { .type
= TEST_EV_TYPE_SENTINEL
, },
1208 do_std_test(TEST_SIMPLE_4_PORTS
, "simple: 4 ports without retries",
1209 expected_test_events
, true);
1213 void test_4_ports_with_retries(void)
1215 const struct test_event expected_test_events
[] = {
1216 { .type
= TEST_EV_TYPE_AGAIN
, },
1217 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1218 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1219 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1220 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1221 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1222 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1223 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1224 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1225 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1226 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 24 },
1227 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 41 },
1228 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1229 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 53 },
1230 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 56 },
1231 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1232 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1233 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1234 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1235 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1236 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 97 },
1237 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 105 },
1238 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 119 },
1239 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 120 },
1240 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1241 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 138 },
1242 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1243 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 154 },
1244 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1245 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1246 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1247 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 210 },
1248 { .type
= TEST_EV_TYPE_AGAIN
, },
1249 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 222 },
1250 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 228 },
1251 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 240 },
1252 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1253 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1254 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 292 },
1255 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1256 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 317 },
1257 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1258 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1259 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1260 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 353 },
1261 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1262 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 407 },
1263 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1264 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 433 },
1265 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1266 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 471 },
1267 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 473 },
1268 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1269 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 479 },
1270 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 481 },
1271 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 487 },
1272 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 504 },
1273 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 525 },
1274 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 572 },
1275 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 591 },
1276 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 605 },
1277 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 612 },
1278 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 615 },
1279 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 618 },
1280 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1281 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1282 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 632 },
1283 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1284 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1285 { .type
= TEST_EV_TYPE_AGAIN
, },
1286 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1287 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 670 },
1288 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1289 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 696 },
1290 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 708 },
1291 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1292 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1293 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1294 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1295 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1296 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1297 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 766 },
1298 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1299 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1300 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1301 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1302 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1303 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 825 },
1304 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1305 { .type
= TEST_EV_TYPE_AGAIN
, },
1306 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1307 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1308 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 850 },
1309 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 852 },
1310 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1311 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 863 },
1312 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 867 },
1313 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 871 },
1314 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 884 },
1315 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1316 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1317 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 931 },
1318 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1319 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 951 },
1320 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 953 },
1321 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 956 },
1322 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 985 },
1323 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 996 },
1324 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1325 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1326 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1327 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1328 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1329 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 999 },
1330 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1331 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1332 { .type
= TEST_EV_TYPE_END
, },
1333 { .type
= TEST_EV_TYPE_SENTINEL
, },
1336 do_std_test(TEST_4_PORTS_WITH_RETRIES
, "4 ports with retries",
1337 expected_test_events
, true);
1341 void connect_port_to_first_avail_muxer_port(struct bt_graph
*graph
,
1342 struct bt_port
*source_port
,
1343 struct bt_component
*muxer_comp
)
1345 struct bt_port
*avail_muxer_port
= NULL
;
1350 count
= bt_component_filter_get_input_port_count(muxer_comp
);
1353 for (i
= 0; i
< count
; i
++) {
1354 struct bt_port
*muxer_port
=
1355 bt_component_filter_get_input_port_by_index(
1360 if (!bt_port_is_connected(muxer_port
)) {
1361 BT_MOVE(avail_muxer_port
, muxer_port
);
1368 conn
= bt_graph_connect_ports(graph
, source_port
, avail_muxer_port
);
1371 bt_put(avail_muxer_port
);
1375 void graph_port_added_listener_connect_to_avail_muxer_port(struct bt_port
*port
,
1378 struct graph_listener_data
*graph_listener_data
= data
;
1379 struct bt_component
*comp
;
1381 comp
= bt_port_get_component(port
);
1384 if (comp
!= graph_listener_data
->source
) {
1388 connect_port_to_first_avail_muxer_port(graph_listener_data
->graph
,
1389 port
, graph_listener_data
->muxer
);
1396 void test_single_end_then_multiple_full(void)
1398 struct bt_component
*src_comp
;
1399 struct bt_component
*muxer_comp
;
1400 struct bt_component
*sink_comp
;
1401 struct bt_port
*upstream_port
;
1402 struct bt_port
*downstream_port
;
1403 struct bt_graph
*graph
;
1408 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
1409 struct graph_listener_data graph_listener_data
;
1410 const struct test_event expected_test_events
[] = {
1411 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1412 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1413 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1414 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1415 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1416 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1417 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1418 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1419 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1420 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1421 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1422 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1423 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1424 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1425 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1426 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1427 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1428 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1429 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1430 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1431 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1432 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1433 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1434 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1435 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1436 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1437 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1438 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1439 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1440 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1441 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1442 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1443 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1444 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1445 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1446 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1447 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1448 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1449 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1450 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1451 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1452 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1453 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1454 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1455 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1456 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1457 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1458 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1459 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1460 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1461 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1462 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1463 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1464 { .type
= TEST_EV_TYPE_END
, },
1465 { .type
= TEST_EV_TYPE_SENTINEL
, },
1468 clear_test_events();
1469 current_test
= TEST_SINGLE_END_THEN_MULTIPLE_FULL
;
1470 diag("test: single end then multiple full");
1471 create_source_muxer_sink(&src_comp
, &muxer_comp
, &sink_comp
);
1472 graph
= bt_graph_create();
1474 graph_listener_data
.graph
= graph
;
1475 graph_listener_data
.source
= src_comp
;
1476 graph_listener_data
.muxer
= muxer_comp
;
1477 graph_listener_data
.sink
= sink_comp
;
1478 ret
= bt_graph_add_port_added_listener(graph
,
1479 graph_port_added_listener_connect_to_avail_muxer_port
,
1480 &graph_listener_data
);
1483 /* Connect source output ports to muxer input ports */
1484 count
= bt_component_source_get_output_port_count(src_comp
);
1487 for (i
= 0; i
< count
; i
++) {
1488 upstream_port
= bt_component_source_get_output_port_by_index(
1490 assert(upstream_port
);
1491 connect_port_to_first_avail_muxer_port(graph
,
1492 upstream_port
, muxer_comp
);
1493 bt_put(upstream_port
);
1496 /* Connect muxer output port to sink input port */
1497 upstream_port
= bt_component_filter_get_output_port_by_name(muxer_comp
,
1499 assert(upstream_port
);
1500 downstream_port
= bt_component_sink_get_input_port_by_name(sink_comp
, "in");
1501 assert(downstream_port
);
1502 conn
= bt_graph_connect_ports(graph
, upstream_port
, downstream_port
);
1505 bt_put(upstream_port
);
1506 bt_put(downstream_port
);
1508 while (graph_status
== BT_GRAPH_STATUS_OK
||
1509 graph_status
== BT_GRAPH_STATUS_AGAIN
) {
1510 graph_status
= bt_graph_run(graph
);
1513 ok(graph_status
== BT_GRAPH_STATUS_END
, "graph finishes without any error");
1514 ok(compare_test_events(expected_test_events
),
1515 "the produced sequence of test events is the expected one");
1524 void test_single_again_end_then_multiple_full(void)
1526 struct bt_component
*src_comp
;
1527 struct bt_component
*muxer_comp
;
1528 struct bt_component
*sink_comp
;
1529 struct bt_port
*upstream_port
;
1530 struct bt_port
*downstream_port
;
1531 struct bt_graph
*graph
;
1536 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
1537 struct graph_listener_data graph_listener_data
;
1538 const struct test_event expected_test_events
[] = {
1539 { .type
= TEST_EV_TYPE_AGAIN
, },
1540 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1541 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1542 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1543 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1544 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1545 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1546 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1547 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1548 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1549 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1550 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1551 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1552 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1553 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1554 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1555 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1556 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1557 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1558 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1559 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1560 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1561 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1562 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1563 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1564 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1565 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1566 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1567 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1568 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1569 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1570 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1571 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1572 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1573 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1574 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1575 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1576 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1577 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1578 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1579 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1580 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1581 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1582 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1583 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1584 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1585 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1586 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1587 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1588 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1589 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1590 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1591 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1592 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1593 { .type
= TEST_EV_TYPE_END
, },
1594 { .type
= TEST_EV_TYPE_SENTINEL
, },
1597 clear_test_events();
1598 current_test
= TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
;
1599 diag("test: single again then end then multiple full");
1600 create_source_muxer_sink(&src_comp
, &muxer_comp
, &sink_comp
);
1601 graph
= bt_graph_create();
1603 graph_listener_data
.graph
= graph
;
1604 graph_listener_data
.source
= src_comp
;
1605 graph_listener_data
.muxer
= muxer_comp
;
1606 graph_listener_data
.sink
= sink_comp
;
1607 ret
= bt_graph_add_port_added_listener(graph
,
1608 graph_port_added_listener_connect_to_avail_muxer_port
,
1609 &graph_listener_data
);
1612 /* Connect source output ports to muxer input ports */
1613 count
= bt_component_source_get_output_port_count(src_comp
);
1616 for (i
= 0; i
< count
; i
++) {
1617 upstream_port
= bt_component_source_get_output_port_by_index(
1619 assert(upstream_port
);
1620 connect_port_to_first_avail_muxer_port(graph
,
1621 upstream_port
, muxer_comp
);
1622 bt_put(upstream_port
);
1625 /* Connect muxer output port to sink input port */
1626 upstream_port
= bt_component_filter_get_output_port_by_name(muxer_comp
,
1628 assert(upstream_port
);
1629 downstream_port
= bt_component_sink_get_input_port_by_name(sink_comp
, "in");
1630 assert(downstream_port
);
1631 conn
= bt_graph_connect_ports(graph
, upstream_port
, downstream_port
);
1634 bt_put(upstream_port
);
1635 bt_put(downstream_port
);
1637 while (graph_status
== BT_GRAPH_STATUS_OK
||
1638 graph_status
== BT_GRAPH_STATUS_AGAIN
) {
1639 graph_status
= bt_graph_run(graph
);
1642 ok(graph_status
== BT_GRAPH_STATUS_END
, "graph finishes without any error");
1643 ok(compare_test_events(expected_test_events
),
1644 "the produced sequence of test events is the expected one");
1652 #define DEBUG_ENV_VAR "TEST_UTILS_MUXER_DEBUG"
1654 int main(int argc
, char **argv
)
1656 if (getenv(DEBUG_ENV_VAR
) && strcmp(getenv(DEBUG_ENV_VAR
), "1") == 0) {
1660 plan_tests(NR_TESTS
);
1663 test_no_upstream_connection();
1664 test_simple_4_ports();
1665 test_4_ports_with_retries();
1666 test_single_end_then_multiple_full();
1667 test_single_again_end_then_multiple_full();
1669 return exit_status();