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", 1000000000);
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(
874 enum bt_connection_status conn_status
;
878 conn_status
= bt_private_connection_create_notification_iterator(
879 priv_conn
, NULL
, &user_data
->notif_iter
);
880 assert(conn_status
== 0);
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_graph
*graph
,
916 struct bt_component
**source
,
917 struct bt_component
**muxer
,
918 struct bt_component
**sink
)
920 struct bt_component_class
*src_comp_class
;
921 struct bt_component_class
*muxer_comp_class
;
922 struct bt_component_class
*sink_comp_class
;
925 /* Create source component */
926 src_comp_class
= bt_component_class_source_create("src", src_iter_next
);
927 assert(src_comp_class
);
928 ret
= bt_component_class_set_init_method(src_comp_class
, src_init
);
930 ret
= bt_component_class_set_finalize_method(src_comp_class
,
933 ret
= bt_component_class_source_set_notification_iterator_init_method(
934 src_comp_class
, src_iter_init
);
936 ret
= bt_component_class_source_set_notification_iterator_finalize_method(
937 src_comp_class
, src_iter_finalize
);
939 ret
= bt_graph_add_component(graph
, src_comp_class
, "source", NULL
, source
);
942 /* Create muxer component */
943 muxer_comp_class
= bt_plugin_find_component_class("utils", "muxer",
944 BT_COMPONENT_CLASS_TYPE_FILTER
);
945 assert(muxer_comp_class
);
946 ret
= bt_graph_add_component(graph
, muxer_comp_class
, "muxer", NULL
, muxer
);
949 /* Create sink component */
950 sink_comp_class
= bt_component_class_sink_create("sink", sink_consume
);
951 assert(sink_comp_class
);
952 ret
= bt_component_class_set_init_method(sink_comp_class
, sink_init
);
954 ret
= bt_component_class_set_finalize_method(sink_comp_class
,
956 ret
= bt_component_class_set_port_connected_method(sink_comp_class
,
957 sink_port_connected
);
959 ret
= bt_graph_add_component(graph
, sink_comp_class
, "sink", NULL
, sink
);
962 bt_put(src_comp_class
);
963 bt_put(muxer_comp_class
);
964 bt_put(sink_comp_class
);
968 void do_std_test(enum test test
, const char *name
,
969 const struct test_event
*expected_test_events
,
972 struct bt_component
*src_comp
;
973 struct bt_component
*muxer_comp
;
974 struct bt_component
*sink_comp
;
975 struct bt_port
*upstream_port
;
976 struct bt_port
*downstream_port
;
977 struct bt_graph
*graph
;
980 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
984 diag("test: %s", name
);
985 graph
= bt_graph_create();
987 create_source_muxer_sink(graph
, &src_comp
, &muxer_comp
, &sink_comp
);
989 /* Connect source output ports to muxer input ports */
991 count
= bt_component_source_get_output_port_count(src_comp
);
994 for (i
= 0; i
< count
; i
++) {
995 upstream_port
= bt_component_source_get_output_port_by_index(
997 assert(upstream_port
);
998 downstream_port
= bt_component_filter_get_input_port_by_index(
1000 assert(downstream_port
);
1001 graph_status
= bt_graph_connect_ports(graph
,
1002 upstream_port
, downstream_port
, NULL
);
1003 assert(graph_status
== 0);
1004 bt_put(upstream_port
);
1005 bt_put(downstream_port
);
1009 /* Connect muxer output port to sink input port */
1010 upstream_port
= bt_component_filter_get_output_port_by_name(muxer_comp
,
1012 assert(upstream_port
);
1013 downstream_port
= bt_component_sink_get_input_port_by_name(sink_comp
, "in");
1014 assert(downstream_port
);
1015 graph_status
= bt_graph_connect_ports(graph
, upstream_port
,
1016 downstream_port
, NULL
);
1017 assert(graph_status
== 0);
1018 bt_put(upstream_port
);
1019 bt_put(downstream_port
);
1021 while (graph_status
== BT_GRAPH_STATUS_OK
||
1022 graph_status
== BT_GRAPH_STATUS_AGAIN
) {
1023 graph_status
= bt_graph_run(graph
);
1026 ok(graph_status
== BT_GRAPH_STATUS_END
, "graph finishes without any error");
1027 ok(compare_test_events(expected_test_events
),
1028 "the produced sequence of test events is the expected one");
1037 void test_no_ts(void)
1039 const struct test_event expected_test_events
[] = {
1040 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1041 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1042 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1043 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
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_EVENT
, .ts_ns
= -1, },
1048 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1049 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1050 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1051 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 1, },
1052 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 4, },
1053 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 189, },
1054 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 1001, },
1055 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1056 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1057 { .type
= TEST_EV_TYPE_END
, },
1058 { .type
= TEST_EV_TYPE_SENTINEL
, },
1061 do_std_test(TEST_NO_TS
, "event notifications with no time",
1062 expected_test_events
, true);
1066 void test_no_upstream_connection(void)
1068 const struct test_event expected_test_events
[] = {
1069 { .type
= TEST_EV_TYPE_END
, },
1070 { .type
= TEST_EV_TYPE_SENTINEL
, },
1073 do_std_test(TEST_NO_UPSTREAM_CONNECTION
, "no upstream connection",
1074 expected_test_events
, false);
1078 void test_simple_4_ports(void)
1080 const struct test_event expected_test_events
[] = {
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_STREAM_BEGIN
, },
1088 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1089 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1090 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 24 },
1091 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 41 },
1092 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1093 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 53 },
1094 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 56 },
1095 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1096 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1097 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1098 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1099 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1100 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 97 },
1101 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 105 },
1102 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 119 },
1103 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 120 },
1104 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1105 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 138 },
1106 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1107 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 154 },
1108 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1109 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1110 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1111 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 210 },
1112 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 222 },
1113 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 228 },
1114 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 240 },
1115 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1116 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1117 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 292 },
1118 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1119 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 317 },
1120 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1121 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1122 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1123 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 353 },
1124 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1125 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 407 },
1126 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1127 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 433 },
1128 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1129 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 471 },
1130 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 473 },
1131 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1132 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 479 },
1133 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 481 },
1134 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 487 },
1135 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 504 },
1136 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 525 },
1137 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 572 },
1138 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 591 },
1139 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 605 },
1140 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 612 },
1141 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 615 },
1142 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 618 },
1143 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1144 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1145 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 632 },
1146 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1147 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1148 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1149 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 670 },
1150 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1151 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 696 },
1152 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 708 },
1153 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1154 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1155 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1156 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1157 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1158 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1159 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 766 },
1160 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1161 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1162 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1163 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1164 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1165 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 825 },
1166 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1167 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1168 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1169 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 850 },
1170 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 852 },
1171 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1172 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 863 },
1173 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 867 },
1174 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 871 },
1175 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 884 },
1176 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1177 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1178 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 931 },
1179 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1180 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 951 },
1181 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 953 },
1182 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 956 },
1183 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 985 },
1184 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 996 },
1185 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1186 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1187 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1188 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1189 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1190 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 999 },
1191 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1192 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1193 { .type
= TEST_EV_TYPE_END
, },
1194 { .type
= TEST_EV_TYPE_SENTINEL
, },
1197 do_std_test(TEST_SIMPLE_4_PORTS
, "simple: 4 ports without retries",
1198 expected_test_events
, true);
1202 void test_4_ports_with_retries(void)
1204 const struct test_event expected_test_events
[] = {
1205 { .type
= TEST_EV_TYPE_AGAIN
, },
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_STREAM_BEGIN
, },
1213 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1214 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1215 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 24 },
1216 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 41 },
1217 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1218 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 53 },
1219 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 56 },
1220 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1221 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1222 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1223 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1224 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1225 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 97 },
1226 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 105 },
1227 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 119 },
1228 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 120 },
1229 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1230 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 138 },
1231 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1232 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 154 },
1233 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1234 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1235 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1236 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 210 },
1237 { .type
= TEST_EV_TYPE_AGAIN
, },
1238 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 222 },
1239 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 228 },
1240 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 240 },
1241 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1242 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1243 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 292 },
1244 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1245 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 317 },
1246 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1247 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1248 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1249 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 353 },
1250 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1251 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 407 },
1252 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1253 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 433 },
1254 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1255 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 471 },
1256 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 473 },
1257 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1258 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 479 },
1259 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 481 },
1260 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 487 },
1261 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 504 },
1262 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 525 },
1263 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 572 },
1264 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 591 },
1265 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 605 },
1266 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 612 },
1267 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 615 },
1268 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 618 },
1269 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1270 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1271 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 632 },
1272 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1273 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1274 { .type
= TEST_EV_TYPE_AGAIN
, },
1275 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1276 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 670 },
1277 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1278 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 696 },
1279 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 708 },
1280 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1281 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1282 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1283 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1284 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1285 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1286 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 766 },
1287 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1288 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1289 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1290 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1291 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1292 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 825 },
1293 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1294 { .type
= TEST_EV_TYPE_AGAIN
, },
1295 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1296 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1297 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 850 },
1298 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 852 },
1299 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1300 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 863 },
1301 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 867 },
1302 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 871 },
1303 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 884 },
1304 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1305 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1306 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 931 },
1307 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1308 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 951 },
1309 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 953 },
1310 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 956 },
1311 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 985 },
1312 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 996 },
1313 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1314 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1315 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1316 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1317 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1318 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 999 },
1319 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1320 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1321 { .type
= TEST_EV_TYPE_END
, },
1322 { .type
= TEST_EV_TYPE_SENTINEL
, },
1325 do_std_test(TEST_4_PORTS_WITH_RETRIES
, "4 ports with retries",
1326 expected_test_events
, true);
1330 void connect_port_to_first_avail_muxer_port(struct bt_graph
*graph
,
1331 struct bt_port
*source_port
,
1332 struct bt_component
*muxer_comp
)
1334 struct bt_port
*avail_muxer_port
= NULL
;
1337 enum bt_graph_status graph_status
;
1339 count
= bt_component_filter_get_input_port_count(muxer_comp
);
1342 for (i
= 0; i
< count
; i
++) {
1343 struct bt_port
*muxer_port
=
1344 bt_component_filter_get_input_port_by_index(
1349 if (!bt_port_is_connected(muxer_port
)) {
1350 BT_MOVE(avail_muxer_port
, muxer_port
);
1357 graph_status
= bt_graph_connect_ports(graph
, source_port
,
1358 avail_muxer_port
, NULL
);
1359 assert(graph_status
== 0);
1360 bt_put(avail_muxer_port
);
1364 void graph_port_added_listener_connect_to_avail_muxer_port(struct bt_port
*port
,
1367 struct graph_listener_data
*graph_listener_data
= data
;
1368 struct bt_component
*comp
;
1370 comp
= bt_port_get_component(port
);
1373 if (comp
!= graph_listener_data
->source
) {
1377 connect_port_to_first_avail_muxer_port(graph_listener_data
->graph
,
1378 port
, graph_listener_data
->muxer
);
1385 void test_single_end_then_multiple_full(void)
1387 struct bt_component
*src_comp
;
1388 struct bt_component
*muxer_comp
;
1389 struct bt_component
*sink_comp
;
1390 struct bt_port
*upstream_port
;
1391 struct bt_port
*downstream_port
;
1392 struct bt_graph
*graph
;
1396 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
1397 struct graph_listener_data graph_listener_data
;
1398 const struct test_event expected_test_events
[] = {
1399 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1400 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1401 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1402 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1403 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1404 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1405 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1406 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1407 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1408 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1409 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1410 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1411 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1412 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1413 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1414 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1415 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1416 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1417 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1418 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1419 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1420 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1421 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1422 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1423 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1424 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1425 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1426 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1427 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1428 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1429 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1430 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1431 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1432 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1433 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1434 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1435 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1436 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1437 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1438 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1439 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1440 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1441 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1442 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1443 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1444 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1445 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1446 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1447 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1448 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1449 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1450 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1451 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1452 { .type
= TEST_EV_TYPE_END
, },
1453 { .type
= TEST_EV_TYPE_SENTINEL
, },
1456 clear_test_events();
1457 current_test
= TEST_SINGLE_END_THEN_MULTIPLE_FULL
;
1458 diag("test: single end then multiple full");
1459 graph
= bt_graph_create();
1461 create_source_muxer_sink(graph
, &src_comp
, &muxer_comp
, &sink_comp
);
1462 graph_listener_data
.graph
= graph
;
1463 graph_listener_data
.source
= src_comp
;
1464 graph_listener_data
.muxer
= muxer_comp
;
1465 graph_listener_data
.sink
= sink_comp
;
1466 ret
= bt_graph_add_port_added_listener(graph
,
1467 graph_port_added_listener_connect_to_avail_muxer_port
, NULL
,
1468 &graph_listener_data
);
1471 /* Connect source output ports to muxer input ports */
1472 count
= bt_component_source_get_output_port_count(src_comp
);
1475 for (i
= 0; i
< count
; i
++) {
1476 upstream_port
= bt_component_source_get_output_port_by_index(
1478 assert(upstream_port
);
1479 connect_port_to_first_avail_muxer_port(graph
,
1480 upstream_port
, muxer_comp
);
1481 bt_put(upstream_port
);
1484 /* Connect muxer output port to sink input port */
1485 upstream_port
= bt_component_filter_get_output_port_by_name(muxer_comp
,
1487 assert(upstream_port
);
1488 downstream_port
= bt_component_sink_get_input_port_by_name(sink_comp
, "in");
1489 assert(downstream_port
);
1490 graph_status
= bt_graph_connect_ports(graph
, upstream_port
,
1491 downstream_port
, NULL
);
1492 assert(graph_status
== 0);
1493 bt_put(upstream_port
);
1494 bt_put(downstream_port
);
1496 while (graph_status
== BT_GRAPH_STATUS_OK
||
1497 graph_status
== BT_GRAPH_STATUS_AGAIN
) {
1498 graph_status
= bt_graph_run(graph
);
1501 ok(graph_status
== BT_GRAPH_STATUS_END
, "graph finishes without any error");
1502 ok(compare_test_events(expected_test_events
),
1503 "the produced sequence of test events is the expected one");
1512 void test_single_again_end_then_multiple_full(void)
1514 struct bt_component
*src_comp
;
1515 struct bt_component
*muxer_comp
;
1516 struct bt_component
*sink_comp
;
1517 struct bt_port
*upstream_port
;
1518 struct bt_port
*downstream_port
;
1519 struct bt_graph
*graph
;
1523 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
1524 struct graph_listener_data graph_listener_data
;
1525 const struct test_event expected_test_events
[] = {
1526 { .type
= TEST_EV_TYPE_AGAIN
, },
1527 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1528 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1529 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1530 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1531 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1532 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1533 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1534 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1535 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1536 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1537 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1538 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1539 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1540 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1541 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1542 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1543 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1544 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1545 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1546 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1547 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1548 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1549 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1550 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1551 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1552 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1553 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1554 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1555 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1556 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1557 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1558 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1559 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1560 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1561 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1562 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1563 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1564 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1565 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1566 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1567 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1568 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1569 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1570 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1571 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1572 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1573 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1574 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1575 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1576 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1577 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1578 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1579 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1580 { .type
= TEST_EV_TYPE_END
, },
1581 { .type
= TEST_EV_TYPE_SENTINEL
, },
1584 clear_test_events();
1585 current_test
= TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
;
1586 diag("test: single again then end then multiple full");
1587 graph
= bt_graph_create();
1589 create_source_muxer_sink(graph
, &src_comp
, &muxer_comp
, &sink_comp
);
1590 graph_listener_data
.graph
= graph
;
1591 graph_listener_data
.source
= src_comp
;
1592 graph_listener_data
.muxer
= muxer_comp
;
1593 graph_listener_data
.sink
= sink_comp
;
1594 ret
= bt_graph_add_port_added_listener(graph
,
1595 graph_port_added_listener_connect_to_avail_muxer_port
, NULL
,
1596 &graph_listener_data
);
1599 /* Connect source output ports to muxer input ports */
1600 count
= bt_component_source_get_output_port_count(src_comp
);
1603 for (i
= 0; i
< count
; i
++) {
1604 upstream_port
= bt_component_source_get_output_port_by_index(
1606 assert(upstream_port
);
1607 connect_port_to_first_avail_muxer_port(graph
,
1608 upstream_port
, muxer_comp
);
1609 bt_put(upstream_port
);
1612 /* Connect muxer output port to sink input port */
1613 upstream_port
= bt_component_filter_get_output_port_by_name(muxer_comp
,
1615 assert(upstream_port
);
1616 downstream_port
= bt_component_sink_get_input_port_by_name(sink_comp
, "in");
1617 assert(downstream_port
);
1618 graph_status
= bt_graph_connect_ports(graph
, upstream_port
,
1619 downstream_port
, NULL
);
1620 assert(graph_status
== 0);
1621 bt_put(upstream_port
);
1622 bt_put(downstream_port
);
1624 while (graph_status
== BT_GRAPH_STATUS_OK
||
1625 graph_status
== BT_GRAPH_STATUS_AGAIN
) {
1626 graph_status
= bt_graph_run(graph
);
1629 ok(graph_status
== BT_GRAPH_STATUS_END
, "graph finishes without any error");
1630 ok(compare_test_events(expected_test_events
),
1631 "the produced sequence of test events is the expected one");
1639 #define DEBUG_ENV_VAR "TEST_UTILS_MUXER_DEBUG"
1641 int main(int argc
, char **argv
)
1643 if (getenv(DEBUG_ENV_VAR
) && strcmp(getenv(DEBUG_ENV_VAR
), "1") == 0) {
1647 plan_tests(NR_TESTS
);
1650 test_no_upstream_connection();
1651 test_simple_4_ports();
1652 test_4_ports_with_retries();
1653 test_single_end_then_multiple_full();
1654 test_single_again_end_then_multiple_full();
1656 return exit_status();