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.
25 #include <babeltrace/ctf-ir/event-class.h>
26 #include <babeltrace/ctf-ir/event.h>
27 #include <babeltrace/ctf-ir/field-types.h>
28 #include <babeltrace/ctf-ir/fields.h>
29 #include <babeltrace/ctf-ir/packet.h>
30 #include <babeltrace/ctf-ir/stream-class.h>
31 #include <babeltrace/ctf-ir/stream.h>
32 #include <babeltrace/ctf-ir/trace.h>
33 #include <babeltrace/graph/clock-class-priority-map.h>
34 #include <babeltrace/graph/component-class-filter.h>
35 #include <babeltrace/graph/component-class-sink.h>
36 #include <babeltrace/graph/component-class-source.h>
37 #include <babeltrace/graph/component-class.h>
38 #include <babeltrace/graph/component-filter.h>
39 #include <babeltrace/graph/component-sink.h>
40 #include <babeltrace/graph/component-source.h>
41 #include <babeltrace/graph/component.h>
42 #include <babeltrace/graph/graph.h>
43 #include <babeltrace/graph/notification-event.h>
44 #include <babeltrace/graph/notification-inactivity.h>
45 #include <babeltrace/graph/notification-iterator.h>
46 #include <babeltrace/graph/notification-packet.h>
47 #include <babeltrace/graph/port.h>
48 #include <babeltrace/graph/private-component-source.h>
49 #include <babeltrace/graph/private-component-sink.h>
50 #include <babeltrace/graph/private-component.h>
51 #include <babeltrace/graph/private-connection.h>
52 #include <babeltrace/graph/private-notification-iterator.h>
53 #include <babeltrace/graph/private-port.h>
54 #include <babeltrace/plugin/plugin.h>
55 #include <babeltrace/ref.h>
64 TEST_NO_UPSTREAM_CONNECTION
,
66 TEST_4_PORTS_WITH_RETRIES
,
67 TEST_SINGLE_END_THEN_MULTIPLE_FULL
,
68 TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
,
71 enum test_event_type
{
72 TEST_EV_TYPE_NOTIF_UNEXPECTED
,
73 TEST_EV_TYPE_NOTIF_EVENT
,
74 TEST_EV_TYPE_NOTIF_INACTIVITY
,
75 TEST_EV_TYPE_NOTIF_PACKET_BEGIN
,
76 TEST_EV_TYPE_NOTIF_PACKET_END
,
77 TEST_EV_TYPE_NOTIF_STREAM_BEGIN
,
78 TEST_EV_TYPE_NOTIF_STREAM_END
,
81 TEST_EV_TYPE_SENTINEL
,
85 enum test_event_type type
;
89 struct source_muxer_sink
{
90 struct bt_component
*source
;
91 struct bt_component
*muxer
;
92 struct bt_component
*sink
;
95 struct graph_listener_data
{
96 struct bt_graph
*graph
;
97 struct bt_component
*source
;
98 struct bt_component
*muxer
;
99 struct bt_component
*sink
;
102 static bool debug
= false;
103 static enum test current_test
;
104 static GArray
*test_events
;
105 static struct bt_clock_class_priority_map
*src_cc_prio_map
;
106 static struct bt_clock_class_priority_map
*src_empty_cc_prio_map
;
107 static struct bt_ctf_clock_class
*src_clock_class
;
108 static struct bt_ctf_stream_class
*src_stream_class
;
109 static struct bt_ctf_event_class
*src_event_class
;
110 static struct bt_ctf_packet
*src_packet0
;
111 static struct bt_ctf_packet
*src_packet1
;
112 static struct bt_ctf_packet
*src_packet2
;
113 static struct bt_ctf_packet
*src_packet3
;
118 SEQ_PACKET_BEGIN
= -3,
122 struct src_iter_user_data
{
126 struct bt_ctf_packet
*packet
;
129 struct sink_user_data
{
130 struct bt_notification_iterator
*notif_iter
;
133 static int64_t seq1
[] = {
134 24, 53, 97, 105, 119, 210, 222, 240, 292, 317, 353, 407, 433,
135 473, 487, 504, 572, 615, 708, 766, 850, 852, 931, 951, 956, 996,
139 static int64_t seq2
[] = {
140 51, 59, 68, 77, 91, 121, 139, 170, 179, 266, 352, 454, 478, 631,
141 644, 668, 714, 744, 750, 778, 790, 836, SEQ_END
,
144 static int64_t seq3
[] = {
145 8, 71, 209, 254, 298, 320, 350, 393, 419, 624, 651, 678, 717,
146 731, 733, 788, 819, 820, 857, 892, 903, 944, 998, SEQ_END
,
149 static int64_t seq4
[] = {
150 41, 56, 120, 138, 154, 228, 471, 479, 481, 525, 591, 605, 612,
151 618, 632, 670, 696, 825, 863, 867, 871, 884, 953, 985, 999,
155 static int64_t seq1_with_again
[] = {
156 24, 53, 97, 105, 119, 210, SEQ_AGAIN
, 222, 240, 292, 317, 353,
157 407, 433, 473, 487, 504, 572, 615, 708, 766, 850, 852, 931, 951,
161 static int64_t seq2_with_again
[] = {
162 51, 59, 68, 77, 91, 121, 139, 170, 179, 266, 352, 454, 478, 631,
163 644, 668, 714, 744, 750, 778, 790, 836, SEQ_AGAIN
, SEQ_END
,
166 static int64_t seq3_with_again
[] = {
167 8, 71, 209, 254, 298, 320, 350, 393, 419, 624, 651, SEQ_AGAIN
,
168 678, 717, 731, 733, 788, 819, 820, 857, 892, 903, 944, 998,
172 static int64_t seq4_with_again
[] = {
173 SEQ_AGAIN
, 41, 56, 120, 138, 154, 228, 471, 479, 481, 525, 591,
174 605, 612, 618, 632, 670, 696, 825, 863, 867, 871, 884, 953, 985,
178 static int64_t seq5
[] = {
179 1, 4, 189, 1001, SEQ_END
,
183 void clear_test_events(void)
185 g_array_set_size(test_events
, 0);
189 void print_test_event(FILE *fp
, const struct test_event
*event
)
191 fprintf(fp
, "{ type = ");
193 switch (event
->type
) {
194 case TEST_EV_TYPE_NOTIF_UNEXPECTED
:
195 fprintf(fp
, "TEST_EV_TYPE_NOTIF_UNEXPECTED");
197 case TEST_EV_TYPE_NOTIF_EVENT
:
198 fprintf(fp
, "TEST_EV_TYPE_NOTIF_EVENT");
200 case TEST_EV_TYPE_NOTIF_INACTIVITY
:
201 fprintf(fp
, "TEST_EV_TYPE_NOTIF_INACTIVITY");
203 case TEST_EV_TYPE_NOTIF_PACKET_BEGIN
:
204 fprintf(fp
, "TEST_EV_TYPE_NOTIF_PACKET_BEGIN");
206 case TEST_EV_TYPE_NOTIF_PACKET_END
:
207 fprintf(fp
, "TEST_EV_TYPE_NOTIF_PACKET_END");
209 case TEST_EV_TYPE_NOTIF_STREAM_BEGIN
:
210 fprintf(fp
, "TEST_EV_TYPE_NOTIF_STREAM_BEGIN");
212 case TEST_EV_TYPE_NOTIF_STREAM_END
:
213 fprintf(fp
, "TEST_EV_TYPE_NOTIF_STREAM_END");
215 case TEST_EV_TYPE_AGAIN
:
216 fprintf(fp
, "TEST_EV_TYPE_AGAIN");
218 case TEST_EV_TYPE_END
:
219 fprintf(fp
, "TEST_EV_TYPE_END");
221 case TEST_EV_TYPE_SENTINEL
:
222 fprintf(fp
, "TEST_EV_TYPE_SENTINEL");
225 fprintf(fp
, "(UNKNOWN)");
229 switch (event
->type
) {
230 case TEST_EV_TYPE_NOTIF_EVENT
:
231 case TEST_EV_TYPE_NOTIF_INACTIVITY
:
232 fprintf(fp
, ", ts-ns = %" PRId64
, event
->ts_ns
);
241 void append_test_event(struct test_event
*event
)
243 g_array_append_val(test_events
, *event
);
247 bool compare_single_test_events(const struct test_event
*ev_a
,
248 const struct test_event
*ev_b
)
251 fprintf(stderr
, ":: Comparing test events: ");
252 print_test_event(stderr
, ev_a
);
253 fprintf(stderr
, " vs. ");
254 print_test_event(stderr
, ev_b
);
255 fprintf(stderr
, "\n");
258 if (ev_a
->type
!= ev_b
->type
) {
262 switch (ev_a
->type
) {
263 case TEST_EV_TYPE_NOTIF_EVENT
:
264 case TEST_EV_TYPE_NOTIF_INACTIVITY
:
265 if (ev_a
->ts_ns
!= ev_b
->ts_ns
) {
277 bool compare_test_events(const struct test_event
*expected_events
)
279 const struct test_event
*expected_event
= expected_events
;
282 assert(expected_events
);
285 const struct test_event
*event
;
287 if (expected_event
->type
== TEST_EV_TYPE_SENTINEL
) {
291 if (i
>= test_events
->len
) {
295 event
= &g_array_index(test_events
, struct test_event
, i
);
297 if (!compare_single_test_events(event
, expected_event
)) {
305 if (i
!= test_events
->len
) {
307 fprintf(stderr
, ":: Length mismatch\n");
317 void init_static_data(void)
320 struct bt_ctf_trace
*trace
;
321 struct bt_ctf_stream
*stream
;
322 struct bt_ctf_field_type
*empty_struct_ft
;
325 test_events
= g_array_new(FALSE
, TRUE
, sizeof(struct test_event
));
329 empty_struct_ft
= bt_ctf_field_type_structure_create();
330 assert(empty_struct_ft
);
331 trace
= bt_ctf_trace_create();
333 ret
= bt_ctf_trace_set_native_byte_order(trace
,
334 BT_CTF_BYTE_ORDER_LITTLE_ENDIAN
);
336 ret
= bt_ctf_trace_set_packet_header_type(trace
, empty_struct_ft
);
338 src_clock_class
= bt_ctf_clock_class_create("my-clock");
339 assert(src_clock_class
);
340 ret
= bt_ctf_clock_class_set_is_absolute(src_clock_class
, 1);
342 ret
= bt_ctf_trace_add_clock_class(trace
, src_clock_class
);
344 src_empty_cc_prio_map
= bt_clock_class_priority_map_create();
345 assert(src_empty_cc_prio_map
);
346 src_cc_prio_map
= bt_clock_class_priority_map_create();
347 assert(src_cc_prio_map
);
348 ret
= bt_clock_class_priority_map_add_clock_class(src_cc_prio_map
,
351 src_stream_class
= bt_ctf_stream_class_create("my-stream-class");
352 assert(src_stream_class
);
353 ret
= bt_ctf_stream_class_set_packet_context_type(src_stream_class
,
356 ret
= bt_ctf_stream_class_set_event_header_type(src_stream_class
,
359 ret
= bt_ctf_stream_class_set_event_context_type(src_stream_class
,
362 src_event_class
= bt_ctf_event_class_create("my-event-class");
363 ret
= bt_ctf_event_class_set_context_type(src_event_class
,
366 ret
= bt_ctf_event_class_set_context_type(src_event_class
,
369 ret
= bt_ctf_stream_class_add_event_class(src_stream_class
,
372 ret
= bt_ctf_trace_add_stream_class(trace
, src_stream_class
);
374 stream
= bt_ctf_stream_create(src_stream_class
, "stream0");
376 src_packet0
= bt_ctf_packet_create(stream
);
379 stream
= bt_ctf_stream_create(src_stream_class
, "stream1");
381 src_packet1
= bt_ctf_packet_create(stream
);
384 stream
= bt_ctf_stream_create(src_stream_class
, "stream2");
386 src_packet2
= bt_ctf_packet_create(stream
);
389 stream
= bt_ctf_stream_create(src_stream_class
, "stream3");
391 src_packet3
= bt_ctf_packet_create(stream
);
396 bt_put(empty_struct_ft
);
400 void fini_static_data(void)
403 g_array_free(test_events
, TRUE
);
406 bt_put(src_empty_cc_prio_map
);
407 bt_put(src_cc_prio_map
);
408 bt_put(src_clock_class
);
409 bt_put(src_stream_class
);
410 bt_put(src_event_class
);
418 void src_iter_finalize(
419 struct bt_private_notification_iterator
*private_notification_iterator
)
421 struct src_iter_user_data
*user_data
=
422 bt_private_notification_iterator_get_user_data(
423 private_notification_iterator
);
431 enum bt_notification_iterator_status
src_iter_init(
432 struct bt_private_notification_iterator
*priv_notif_iter
,
433 struct bt_private_port
*private_port
)
435 struct src_iter_user_data
*user_data
=
436 g_new0(struct src_iter_user_data
, 1);
437 struct bt_port
*port
= bt_port_from_private_port(private_port
);
438 const char *port_name
;
443 ret
= bt_private_notification_iterator_set_user_data(priv_notif_iter
,
446 port_name
= bt_port_get_name(port
);
448 user_data
->iter_index
= port_name
[3] - '0';
451 switch (user_data
->iter_index
) {
453 user_data
->packet
= src_packet0
;
456 user_data
->packet
= src_packet1
;
459 user_data
->packet
= src_packet2
;
462 user_data
->packet
= src_packet3
;
468 switch (current_test
) {
470 if (user_data
->iter_index
== 1) {
471 user_data
->seq
= seq5
;
474 case TEST_SIMPLE_4_PORTS
:
475 if (user_data
->iter_index
== 0) {
476 user_data
->seq
= seq1
;
477 } else if (user_data
->iter_index
== 1) {
478 user_data
->seq
= seq2
;
479 } else if (user_data
->iter_index
== 2) {
480 user_data
->seq
= seq3
;
482 user_data
->seq
= seq4
;
485 case TEST_4_PORTS_WITH_RETRIES
:
486 if (user_data
->iter_index
== 0) {
487 user_data
->seq
= seq1_with_again
;
488 } else if (user_data
->iter_index
== 1) {
489 user_data
->seq
= seq2_with_again
;
490 } else if (user_data
->iter_index
== 2) {
491 user_data
->seq
= seq3_with_again
;
493 user_data
->seq
= seq4_with_again
;
496 case TEST_SINGLE_END_THEN_MULTIPLE_FULL
:
497 case TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
:
498 if (user_data
->iter_index
== 0) {
499 /* Ignore: this iterator only returns END */
500 } else if (user_data
->iter_index
== 1) {
501 user_data
->seq
= seq2
;
503 user_data
->seq
= seq3
;
510 return BT_NOTIFICATION_ITERATOR_STATUS_OK
;
514 struct bt_ctf_event
*src_create_event(struct bt_ctf_packet
*packet
,
517 struct bt_ctf_event
*event
= bt_ctf_event_create(src_event_class
);
521 ret
= bt_ctf_event_set_packet(event
, packet
);
525 struct bt_ctf_clock_value
*clock_value
;
527 clock_value
= bt_ctf_clock_value_create(src_clock_class
,
530 ret
= bt_ctf_event_set_clock_value(event
, clock_value
);
539 struct bt_notification_iterator_next_return
src_iter_next_seq(
540 struct src_iter_user_data
*user_data
)
542 struct bt_notification_iterator_next_return next_return
= {
543 .status
= BT_NOTIFICATION_ITERATOR_STATUS_OK
,
547 assert(user_data
->seq
);
548 cur_ts_ns
= user_data
->seq
[user_data
->at
];
553 BT_NOTIFICATION_ITERATOR_STATUS_END
;
557 BT_NOTIFICATION_ITERATOR_STATUS_AGAIN
;
559 case SEQ_PACKET_BEGIN
:
560 next_return
.notification
=
561 bt_notification_packet_begin_create(user_data
->packet
);
562 assert(next_return
.notification
);
565 next_return
.notification
=
566 bt_notification_packet_end_create(user_data
->packet
);
567 assert(next_return
.notification
);
571 struct bt_ctf_event
*event
= src_create_event(
572 user_data
->packet
, cur_ts_ns
);
575 next_return
.notification
= bt_notification_event_create(event
,
578 assert(next_return
.notification
);
583 if (next_return
.status
!= BT_NOTIFICATION_ITERATOR_STATUS_END
) {
591 struct bt_notification_iterator_next_return
src_iter_next(
592 struct bt_private_notification_iterator
*priv_iterator
)
594 struct bt_notification_iterator_next_return next_return
= {
595 .notification
= NULL
,
596 .status
= BT_NOTIFICATION_ITERATOR_STATUS_OK
,
598 struct src_iter_user_data
*user_data
=
599 bt_private_notification_iterator_get_user_data(priv_iterator
);
600 struct bt_private_component
*private_component
=
601 bt_private_notification_iterator_get_private_component(priv_iterator
);
605 assert(private_component
);
607 switch (current_test
) {
609 if (user_data
->iter_index
== 0) {
610 if (user_data
->at
== 0) {
611 next_return
.notification
=
612 bt_notification_packet_begin_create(
614 assert(next_return
.notification
);
615 } else if (user_data
->at
< 6) {
616 struct bt_ctf_event
*event
= src_create_event(
617 user_data
->packet
, -1);
620 next_return
.notification
=
621 bt_notification_event_create(event
,
622 src_empty_cc_prio_map
);
623 assert(next_return
.notification
);
627 BT_NOTIFICATION_ITERATOR_STATUS_END
;
632 next_return
= src_iter_next_seq(user_data
);
635 case TEST_SIMPLE_4_PORTS
:
636 case TEST_4_PORTS_WITH_RETRIES
:
637 next_return
= src_iter_next_seq(user_data
);
639 case TEST_SINGLE_END_THEN_MULTIPLE_FULL
:
640 if (user_data
->iter_index
== 0) {
641 ret
= bt_private_component_source_add_output_private_port(
642 private_component
, "out1", NULL
, NULL
);
644 ret
= bt_private_component_source_add_output_private_port(
645 private_component
, "out2", NULL
, NULL
);
647 next_return
.status
= BT_NOTIFICATION_ITERATOR_STATUS_END
;
649 next_return
= src_iter_next_seq(user_data
);
652 case TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
:
653 if (user_data
->iter_index
== 0) {
654 if (user_data
->at
== 0) {
655 next_return
.status
= BT_NOTIFICATION_ITERATOR_STATUS_AGAIN
;
658 ret
= bt_private_component_source_add_output_private_port(
659 private_component
, "out1", NULL
, NULL
);
661 ret
= bt_private_component_source_add_output_private_port(
662 private_component
, "out2", NULL
, NULL
);
664 next_return
.status
= BT_NOTIFICATION_ITERATOR_STATUS_END
;
667 next_return
= src_iter_next_seq(user_data
);
674 bt_put(private_component
);
679 enum bt_component_status
src_init(
680 struct bt_private_component
*private_component
,
681 struct bt_value
*params
, void *init_method_data
)
686 switch (current_test
) {
690 case TEST_SINGLE_END_THEN_MULTIPLE_FULL
:
691 case TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
:
700 ret
= bt_private_component_source_add_output_private_port(
701 private_component
, "out0", NULL
, NULL
);
706 ret
= bt_private_component_source_add_output_private_port(
707 private_component
, "out1", NULL
, NULL
);
712 ret
= bt_private_component_source_add_output_private_port(
713 private_component
, "out2", NULL
, NULL
);
718 ret
= bt_private_component_source_add_output_private_port(
719 private_component
, "out3", NULL
, NULL
);
723 return BT_COMPONENT_STATUS_OK
;
727 void src_finalize(struct bt_private_component
*private_component
)
732 enum bt_component_status
sink_consume(
733 struct bt_private_component
*priv_component
)
735 enum bt_component_status ret
= BT_COMPONENT_STATUS_OK
;
736 struct bt_notification
*notification
= NULL
;
737 struct sink_user_data
*user_data
=
738 bt_private_component_get_user_data(priv_component
);
739 enum bt_notification_iterator_status it_ret
;
740 struct test_event test_event
;
741 bool do_append_test_event
= true;
743 assert(user_data
&& user_data
->notif_iter
);
744 it_ret
= bt_notification_iterator_next(user_data
->notif_iter
);
747 ret
= BT_COMPONENT_STATUS_ERROR
;
748 do_append_test_event
= false;
753 case BT_NOTIFICATION_ITERATOR_STATUS_END
:
754 test_event
.type
= TEST_EV_TYPE_END
;
755 ret
= BT_COMPONENT_STATUS_END
;
756 BT_PUT(user_data
->notif_iter
);
758 case BT_NOTIFICATION_ITERATOR_STATUS_AGAIN
:
759 test_event
.type
= TEST_EV_TYPE_AGAIN
;
760 ret
= BT_COMPONENT_STATUS_AGAIN
;
766 notification
= bt_notification_iterator_get_notification(
767 user_data
->notif_iter
);
768 assert(notification
);
770 switch (bt_notification_get_type(notification
)) {
771 case BT_NOTIFICATION_TYPE_EVENT
:
773 struct bt_ctf_event
*event
;
774 struct bt_clock_class_priority_map
*cc_prio_map
;
776 test_event
.type
= TEST_EV_TYPE_NOTIF_EVENT
;
778 bt_notification_event_get_clock_class_priority_map(
781 event
= bt_notification_event_get_event(notification
);
784 if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map
) > 0) {
785 struct bt_ctf_clock_value
*clock_value
;
786 struct bt_ctf_clock_class
*clock_class
=
787 bt_clock_class_priority_map_get_highest_priority_clock_class(
791 clock_value
= bt_ctf_event_get_clock_value(event
,
794 ret
= bt_ctf_clock_value_get_value_ns_from_epoch(
795 clock_value
, &test_event
.ts_ns
);
800 test_event
.ts_ns
= -1;
807 case BT_NOTIFICATION_TYPE_INACTIVITY
:
809 struct bt_clock_class_priority_map
*cc_prio_map
;
811 test_event
.type
= TEST_EV_TYPE_NOTIF_INACTIVITY
;
812 cc_prio_map
= bt_notification_event_get_clock_class_priority_map(
816 if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map
) > 0) {
817 struct bt_ctf_clock_value
*clock_value
;
818 struct bt_ctf_clock_class
*clock_class
=
819 bt_clock_class_priority_map_get_highest_priority_clock_class(
824 bt_notification_inactivity_get_clock_value(
825 notification
, clock_class
);
827 ret
= bt_ctf_clock_value_get_value_ns_from_epoch(
828 clock_value
, &test_event
.ts_ns
);
833 test_event
.ts_ns
= -1;
839 case BT_NOTIFICATION_TYPE_PACKET_BEGIN
:
840 test_event
.type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
;
842 case BT_NOTIFICATION_TYPE_PACKET_END
:
843 test_event
.type
= TEST_EV_TYPE_NOTIF_PACKET_END
;
845 case BT_NOTIFICATION_TYPE_STREAM_BEGIN
:
846 test_event
.type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
;
848 case BT_NOTIFICATION_TYPE_STREAM_END
:
849 test_event
.type
= TEST_EV_TYPE_NOTIF_STREAM_END
;
852 test_event
.type
= TEST_EV_TYPE_NOTIF_UNEXPECTED
;
857 if (do_append_test_event
) {
858 append_test_event(&test_event
);
861 bt_put(notification
);
866 void sink_port_connected(struct bt_private_component
*private_component
,
867 struct bt_private_port
*self_private_port
,
868 struct bt_port
*other_port
)
870 struct bt_private_connection
*priv_conn
=
871 bt_private_port_get_private_connection(self_private_port
);
872 struct sink_user_data
*user_data
= bt_private_component_get_user_data(
877 user_data
->notif_iter
=
878 bt_private_connection_create_notification_iterator(priv_conn
,
880 assert(user_data
->notif_iter
);
885 enum bt_component_status
sink_init(
886 struct bt_private_component
*private_component
,
887 struct bt_value
*params
, void *init_method_data
)
889 struct sink_user_data
*user_data
= g_new0(struct sink_user_data
, 1);
893 ret
= bt_private_component_set_user_data(private_component
,
896 ret
= bt_private_component_sink_add_input_private_port(
897 private_component
, "in", NULL
, NULL
);
899 return BT_COMPONENT_STATUS_OK
;
903 void sink_finalize(struct bt_private_component
*private_component
)
905 struct sink_user_data
*user_data
= bt_private_component_get_user_data(
909 bt_put(user_data
->notif_iter
);
915 void create_source_muxer_sink(struct bt_component
**source
,
916 struct bt_component
**muxer
,
917 struct bt_component
**sink
)
919 struct bt_component_class
*src_comp_class
;
920 struct bt_component_class
*muxer_comp_class
;
921 struct bt_component_class
*sink_comp_class
;
924 /* Create source component */
925 src_comp_class
= bt_component_class_source_create("src", src_iter_next
);
926 assert(src_comp_class
);
927 ret
= bt_component_class_set_init_method(src_comp_class
, src_init
);
929 ret
= bt_component_class_set_finalize_method(src_comp_class
,
932 ret
= bt_component_class_source_set_notification_iterator_init_method(
933 src_comp_class
, src_iter_init
);
935 ret
= bt_component_class_source_set_notification_iterator_finalize_method(
936 src_comp_class
, src_iter_finalize
);
938 *source
= bt_component_create(src_comp_class
, "source", NULL
);
941 /* Create muxer component */
942 muxer_comp_class
= bt_plugin_find_component_class("utils", "muxer",
943 BT_COMPONENT_CLASS_TYPE_FILTER
);
944 assert(muxer_comp_class
);
945 *muxer
= bt_component_create(muxer_comp_class
, "muxer", NULL
);
948 /* Create sink component */
949 sink_comp_class
= bt_component_class_sink_create("sink", sink_consume
);
950 assert(sink_comp_class
);
951 ret
= bt_component_class_set_init_method(sink_comp_class
, sink_init
);
953 ret
= bt_component_class_set_finalize_method(sink_comp_class
,
955 ret
= bt_component_class_set_port_connected_method(sink_comp_class
,
956 sink_port_connected
);
958 *sink
= bt_component_create(sink_comp_class
, "sink", NULL
);
960 bt_put(src_comp_class
);
961 bt_put(muxer_comp_class
);
962 bt_put(sink_comp_class
);
966 void do_std_test(enum test test
, const char *name
,
967 const struct test_event
*expected_test_events
,
970 struct bt_component
*src_comp
;
971 struct bt_component
*muxer_comp
;
972 struct bt_component
*sink_comp
;
973 struct bt_port
*upstream_port
;
974 struct bt_port
*downstream_port
;
975 struct bt_graph
*graph
;
978 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
982 diag("test: %s", name
);
983 create_source_muxer_sink(&src_comp
, &muxer_comp
, &sink_comp
);
984 graph
= bt_graph_create();
987 /* Connect source output ports to muxer input ports */
989 count
= bt_component_source_get_output_port_count(src_comp
);
992 for (i
= 0; i
< count
; i
++) {
993 upstream_port
= bt_component_source_get_output_port_by_index(
995 assert(upstream_port
);
996 downstream_port
= bt_component_filter_get_input_port_by_index(
998 assert(downstream_port
);
999 graph_status
= bt_graph_connect_ports(graph
,
1000 upstream_port
, downstream_port
, NULL
);
1001 assert(graph_status
== 0);
1002 bt_put(upstream_port
);
1003 bt_put(downstream_port
);
1007 /* Connect muxer output port to sink input port */
1008 upstream_port
= bt_component_filter_get_output_port_by_name(muxer_comp
,
1010 assert(upstream_port
);
1011 downstream_port
= bt_component_sink_get_input_port_by_name(sink_comp
, "in");
1012 assert(downstream_port
);
1013 graph_status
= bt_graph_connect_ports(graph
, upstream_port
,
1014 downstream_port
, NULL
);
1015 assert(graph_status
== 0);
1016 bt_put(upstream_port
);
1017 bt_put(downstream_port
);
1019 while (graph_status
== BT_GRAPH_STATUS_OK
||
1020 graph_status
== BT_GRAPH_STATUS_AGAIN
) {
1021 graph_status
= bt_graph_run(graph
);
1024 ok(graph_status
== BT_GRAPH_STATUS_END
, "graph finishes without any error");
1025 ok(compare_test_events(expected_test_events
),
1026 "the produced sequence of test events is the expected one");
1035 void test_no_ts(void)
1037 const struct test_event expected_test_events
[] = {
1038 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1039 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1040 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1041 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1042 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1043 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1044 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1045 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1046 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1047 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1048 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1049 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 1, },
1050 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 4, },
1051 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 189, },
1052 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 1001, },
1053 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1054 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1055 { .type
= TEST_EV_TYPE_END
, },
1056 { .type
= TEST_EV_TYPE_SENTINEL
, },
1059 do_std_test(TEST_NO_TS
, "event notifications with no time",
1060 expected_test_events
, true);
1064 void test_no_upstream_connection(void)
1066 const struct test_event expected_test_events
[] = {
1067 { .type
= TEST_EV_TYPE_END
, },
1068 { .type
= TEST_EV_TYPE_SENTINEL
, },
1071 do_std_test(TEST_NO_UPSTREAM_CONNECTION
, "no upstream connection",
1072 expected_test_events
, false);
1076 void test_simple_4_ports(void)
1078 const struct test_event expected_test_events
[] = {
1079 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1080 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1081 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1082 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1083 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1084 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1085 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1086 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1087 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1088 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 24 },
1089 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 41 },
1090 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1091 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 53 },
1092 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 56 },
1093 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1094 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1095 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1096 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1097 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1098 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 97 },
1099 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 105 },
1100 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 119 },
1101 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 120 },
1102 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1103 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 138 },
1104 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1105 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 154 },
1106 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1107 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1108 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1109 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 210 },
1110 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 222 },
1111 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 228 },
1112 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 240 },
1113 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1114 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1115 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 292 },
1116 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1117 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 317 },
1118 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1119 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1120 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1121 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 353 },
1122 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1123 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 407 },
1124 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1125 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 433 },
1126 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1127 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 471 },
1128 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 473 },
1129 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1130 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 479 },
1131 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 481 },
1132 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 487 },
1133 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 504 },
1134 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 525 },
1135 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 572 },
1136 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 591 },
1137 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 605 },
1138 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 612 },
1139 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 615 },
1140 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 618 },
1141 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1142 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1143 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 632 },
1144 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1145 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1146 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1147 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 670 },
1148 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1149 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 696 },
1150 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 708 },
1151 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1152 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1153 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1154 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1155 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1156 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1157 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 766 },
1158 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1159 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1160 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1161 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1162 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1163 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 825 },
1164 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1165 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1166 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1167 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 850 },
1168 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 852 },
1169 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1170 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 863 },
1171 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 867 },
1172 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 871 },
1173 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 884 },
1174 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1175 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1176 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 931 },
1177 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1178 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 951 },
1179 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 953 },
1180 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 956 },
1181 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 985 },
1182 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 996 },
1183 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1184 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1185 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1186 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1187 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1188 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 999 },
1189 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1190 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1191 { .type
= TEST_EV_TYPE_END
, },
1192 { .type
= TEST_EV_TYPE_SENTINEL
, },
1195 do_std_test(TEST_SIMPLE_4_PORTS
, "simple: 4 ports without retries",
1196 expected_test_events
, true);
1200 void test_4_ports_with_retries(void)
1202 const struct test_event expected_test_events
[] = {
1203 { .type
= TEST_EV_TYPE_AGAIN
, },
1204 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1205 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1206 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1207 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1208 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1209 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1210 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1211 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1212 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1213 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 24 },
1214 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 41 },
1215 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1216 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 53 },
1217 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 56 },
1218 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1219 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1220 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1221 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1222 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1223 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 97 },
1224 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 105 },
1225 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 119 },
1226 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 120 },
1227 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1228 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 138 },
1229 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1230 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 154 },
1231 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1232 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1233 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1234 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 210 },
1235 { .type
= TEST_EV_TYPE_AGAIN
, },
1236 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 222 },
1237 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 228 },
1238 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 240 },
1239 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1240 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1241 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 292 },
1242 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1243 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 317 },
1244 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1245 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1246 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1247 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 353 },
1248 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1249 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 407 },
1250 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1251 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 433 },
1252 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1253 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 471 },
1254 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 473 },
1255 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1256 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 479 },
1257 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 481 },
1258 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 487 },
1259 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 504 },
1260 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 525 },
1261 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 572 },
1262 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 591 },
1263 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 605 },
1264 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 612 },
1265 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 615 },
1266 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 618 },
1267 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1268 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1269 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 632 },
1270 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1271 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1272 { .type
= TEST_EV_TYPE_AGAIN
, },
1273 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1274 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 670 },
1275 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1276 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 696 },
1277 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 708 },
1278 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1279 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1280 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1281 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1282 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1283 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1284 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 766 },
1285 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1286 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1287 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1288 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1289 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1290 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 825 },
1291 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1292 { .type
= TEST_EV_TYPE_AGAIN
, },
1293 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1294 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1295 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 850 },
1296 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 852 },
1297 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1298 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 863 },
1299 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 867 },
1300 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 871 },
1301 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 884 },
1302 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1303 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1304 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 931 },
1305 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1306 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 951 },
1307 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 953 },
1308 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 956 },
1309 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 985 },
1310 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 996 },
1311 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1312 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1313 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1314 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1315 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1316 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 999 },
1317 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1318 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1319 { .type
= TEST_EV_TYPE_END
, },
1320 { .type
= TEST_EV_TYPE_SENTINEL
, },
1323 do_std_test(TEST_4_PORTS_WITH_RETRIES
, "4 ports with retries",
1324 expected_test_events
, true);
1328 void connect_port_to_first_avail_muxer_port(struct bt_graph
*graph
,
1329 struct bt_port
*source_port
,
1330 struct bt_component
*muxer_comp
)
1332 struct bt_port
*avail_muxer_port
= NULL
;
1335 enum bt_graph_status graph_status
;
1337 count
= bt_component_filter_get_input_port_count(muxer_comp
);
1340 for (i
= 0; i
< count
; i
++) {
1341 struct bt_port
*muxer_port
=
1342 bt_component_filter_get_input_port_by_index(
1347 if (!bt_port_is_connected(muxer_port
)) {
1348 BT_MOVE(avail_muxer_port
, muxer_port
);
1355 graph_status
= bt_graph_connect_ports(graph
, source_port
,
1356 avail_muxer_port
, NULL
);
1357 assert(graph_status
== 0);
1358 bt_put(avail_muxer_port
);
1362 void graph_port_added_listener_connect_to_avail_muxer_port(struct bt_port
*port
,
1365 struct graph_listener_data
*graph_listener_data
= data
;
1366 struct bt_component
*comp
;
1368 comp
= bt_port_get_component(port
);
1371 if (comp
!= graph_listener_data
->source
) {
1375 connect_port_to_first_avail_muxer_port(graph_listener_data
->graph
,
1376 port
, graph_listener_data
->muxer
);
1383 void test_single_end_then_multiple_full(void)
1385 struct bt_component
*src_comp
;
1386 struct bt_component
*muxer_comp
;
1387 struct bt_component
*sink_comp
;
1388 struct bt_port
*upstream_port
;
1389 struct bt_port
*downstream_port
;
1390 struct bt_graph
*graph
;
1394 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
1395 struct graph_listener_data graph_listener_data
;
1396 const struct test_event expected_test_events
[] = {
1397 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1398 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1399 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1400 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1401 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1402 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1403 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1404 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1405 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1406 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1407 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1408 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1409 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1410 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1411 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1412 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1413 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1414 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1415 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1416 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1417 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1418 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1419 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1420 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1421 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1422 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1423 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1424 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1425 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1426 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1427 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1428 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1429 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1430 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1431 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1432 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1433 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1434 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1435 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1436 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1437 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1438 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1439 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1440 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1441 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1442 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1443 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1444 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1445 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1446 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1447 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1448 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1449 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1450 { .type
= TEST_EV_TYPE_END
, },
1451 { .type
= TEST_EV_TYPE_SENTINEL
, },
1454 clear_test_events();
1455 current_test
= TEST_SINGLE_END_THEN_MULTIPLE_FULL
;
1456 diag("test: single end then multiple full");
1457 create_source_muxer_sink(&src_comp
, &muxer_comp
, &sink_comp
);
1458 graph
= bt_graph_create();
1460 graph_listener_data
.graph
= graph
;
1461 graph_listener_data
.source
= src_comp
;
1462 graph_listener_data
.muxer
= muxer_comp
;
1463 graph_listener_data
.sink
= sink_comp
;
1464 ret
= bt_graph_add_port_added_listener(graph
,
1465 graph_port_added_listener_connect_to_avail_muxer_port
,
1466 &graph_listener_data
);
1469 /* Connect source output ports to muxer input ports */
1470 count
= bt_component_source_get_output_port_count(src_comp
);
1473 for (i
= 0; i
< count
; i
++) {
1474 upstream_port
= bt_component_source_get_output_port_by_index(
1476 assert(upstream_port
);
1477 connect_port_to_first_avail_muxer_port(graph
,
1478 upstream_port
, muxer_comp
);
1479 bt_put(upstream_port
);
1482 /* Connect muxer output port to sink input port */
1483 upstream_port
= bt_component_filter_get_output_port_by_name(muxer_comp
,
1485 assert(upstream_port
);
1486 downstream_port
= bt_component_sink_get_input_port_by_name(sink_comp
, "in");
1487 assert(downstream_port
);
1488 graph_status
= bt_graph_connect_ports(graph
, upstream_port
,
1489 downstream_port
, NULL
);
1490 assert(graph_status
== 0);
1491 bt_put(upstream_port
);
1492 bt_put(downstream_port
);
1494 while (graph_status
== BT_GRAPH_STATUS_OK
||
1495 graph_status
== BT_GRAPH_STATUS_AGAIN
) {
1496 graph_status
= bt_graph_run(graph
);
1499 ok(graph_status
== BT_GRAPH_STATUS_END
, "graph finishes without any error");
1500 ok(compare_test_events(expected_test_events
),
1501 "the produced sequence of test events is the expected one");
1510 void test_single_again_end_then_multiple_full(void)
1512 struct bt_component
*src_comp
;
1513 struct bt_component
*muxer_comp
;
1514 struct bt_component
*sink_comp
;
1515 struct bt_port
*upstream_port
;
1516 struct bt_port
*downstream_port
;
1517 struct bt_graph
*graph
;
1521 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
1522 struct graph_listener_data graph_listener_data
;
1523 const struct test_event expected_test_events
[] = {
1524 { .type
= TEST_EV_TYPE_AGAIN
, },
1525 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1526 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1527 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1528 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1529 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1530 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1531 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1532 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1533 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1534 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1535 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1536 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1537 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1538 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1539 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1540 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1541 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1542 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1543 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1544 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1545 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1546 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1547 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1548 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1549 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1550 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1551 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1552 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1553 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1554 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1555 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1556 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1557 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1558 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1559 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1560 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1561 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1562 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1563 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1564 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1565 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1566 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1567 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1568 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1569 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1570 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1571 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1572 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1573 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1574 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1575 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1576 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1577 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1578 { .type
= TEST_EV_TYPE_END
, },
1579 { .type
= TEST_EV_TYPE_SENTINEL
, },
1582 clear_test_events();
1583 current_test
= TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
;
1584 diag("test: single again then end then multiple full");
1585 create_source_muxer_sink(&src_comp
, &muxer_comp
, &sink_comp
);
1586 graph
= bt_graph_create();
1588 graph_listener_data
.graph
= graph
;
1589 graph_listener_data
.source
= src_comp
;
1590 graph_listener_data
.muxer
= muxer_comp
;
1591 graph_listener_data
.sink
= sink_comp
;
1592 ret
= bt_graph_add_port_added_listener(graph
,
1593 graph_port_added_listener_connect_to_avail_muxer_port
,
1594 &graph_listener_data
);
1597 /* Connect source output ports to muxer input ports */
1598 count
= bt_component_source_get_output_port_count(src_comp
);
1601 for (i
= 0; i
< count
; i
++) {
1602 upstream_port
= bt_component_source_get_output_port_by_index(
1604 assert(upstream_port
);
1605 connect_port_to_first_avail_muxer_port(graph
,
1606 upstream_port
, muxer_comp
);
1607 bt_put(upstream_port
);
1610 /* Connect muxer output port to sink input port */
1611 upstream_port
= bt_component_filter_get_output_port_by_name(muxer_comp
,
1613 assert(upstream_port
);
1614 downstream_port
= bt_component_sink_get_input_port_by_name(sink_comp
, "in");
1615 assert(downstream_port
);
1616 graph_status
= bt_graph_connect_ports(graph
, upstream_port
,
1617 downstream_port
, NULL
);
1618 assert(graph_status
== 0);
1619 bt_put(upstream_port
);
1620 bt_put(downstream_port
);
1622 while (graph_status
== BT_GRAPH_STATUS_OK
||
1623 graph_status
== BT_GRAPH_STATUS_AGAIN
) {
1624 graph_status
= bt_graph_run(graph
);
1627 ok(graph_status
== BT_GRAPH_STATUS_END
, "graph finishes without any error");
1628 ok(compare_test_events(expected_test_events
),
1629 "the produced sequence of test events is the expected one");
1637 #define DEBUG_ENV_VAR "TEST_UTILS_MUXER_DEBUG"
1639 int main(int argc
, char **argv
)
1641 if (getenv(DEBUG_ENV_VAR
) && strcmp(getenv(DEBUG_ENV_VAR
), "1") == 0) {
1645 plan_tests(NR_TESTS
);
1648 test_no_upstream_connection();
1649 test_simple_4_ports();
1650 test_4_ports_with_retries();
1651 test_single_end_then_multiple_full();
1652 test_single_again_end_then_multiple_full();
1654 return exit_status();