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
);
538 struct bt_notification_iterator_next_return
src_iter_next_seq(
539 struct src_iter_user_data
*user_data
)
541 struct bt_notification_iterator_next_return next_return
= {
542 .status
= BT_NOTIFICATION_ITERATOR_STATUS_OK
,
546 assert(user_data
->seq
);
547 cur_ts_ns
= user_data
->seq
[user_data
->at
];
552 BT_NOTIFICATION_ITERATOR_STATUS_END
;
556 BT_NOTIFICATION_ITERATOR_STATUS_AGAIN
;
558 case SEQ_PACKET_BEGIN
:
559 next_return
.notification
=
560 bt_notification_packet_begin_create(user_data
->packet
);
561 assert(next_return
.notification
);
564 next_return
.notification
=
565 bt_notification_packet_end_create(user_data
->packet
);
566 assert(next_return
.notification
);
570 struct bt_ctf_event
*event
= src_create_event(
571 user_data
->packet
, cur_ts_ns
);
574 next_return
.notification
= bt_notification_event_create(event
,
577 assert(next_return
.notification
);
582 if (next_return
.status
!= BT_NOTIFICATION_ITERATOR_STATUS_END
) {
590 struct bt_notification_iterator_next_return
src_iter_next(
591 struct bt_private_notification_iterator
*priv_iterator
)
593 struct bt_notification_iterator_next_return next_return
;
594 struct src_iter_user_data
*user_data
=
595 bt_private_notification_iterator_get_user_data(priv_iterator
);
596 struct bt_private_component
*private_component
=
597 bt_private_notification_iterator_get_private_component(priv_iterator
);
600 assert(private_component
);
602 switch (current_test
) {
604 if (user_data
->iter_index
== 0) {
605 if (user_data
->at
== 0) {
606 next_return
.notification
=
607 bt_notification_packet_begin_create(
609 assert(next_return
.notification
);
610 } else if (user_data
->at
< 6) {
611 struct bt_ctf_event
*event
= src_create_event(
612 user_data
->packet
, -1);
615 next_return
.notification
=
616 bt_notification_event_create(event
,
617 src_empty_cc_prio_map
);
618 assert(next_return
.notification
);
622 BT_NOTIFICATION_ITERATOR_STATUS_END
;
627 next_return
= src_iter_next_seq(user_data
);
630 case TEST_SIMPLE_4_PORTS
:
631 case TEST_4_PORTS_WITH_RETRIES
:
632 next_return
= src_iter_next_seq(user_data
);
634 case TEST_SINGLE_END_THEN_MULTIPLE_FULL
:
635 if (user_data
->iter_index
== 0) {
636 struct bt_private_port
*priv_port
;
638 priv_port
= bt_private_component_source_add_output_private_port(
639 private_component
, "out1", NULL
);
642 priv_port
= bt_private_component_source_add_output_private_port(
643 private_component
, "out2", NULL
);
646 next_return
.status
= BT_NOTIFICATION_ITERATOR_STATUS_END
;
648 next_return
= src_iter_next_seq(user_data
);
651 case TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
:
652 if (user_data
->iter_index
== 0) {
653 if (user_data
->at
== 0) {
654 next_return
.status
= BT_NOTIFICATION_ITERATOR_STATUS_AGAIN
;
657 struct bt_private_port
*priv_port
;
659 priv_port
= bt_private_component_source_add_output_private_port(
660 private_component
, "out1", NULL
);
663 priv_port
= bt_private_component_source_add_output_private_port(
664 private_component
, "out2", NULL
);
667 next_return
.status
= BT_NOTIFICATION_ITERATOR_STATUS_END
;
670 next_return
= src_iter_next_seq(user_data
);
677 bt_put(private_component
);
682 enum bt_component_status
src_init(
683 struct bt_private_component
*private_component
,
684 struct bt_value
*params
, void *init_method_data
)
686 struct bt_private_port
*priv_port
;
689 switch (current_test
) {
693 case TEST_SINGLE_END_THEN_MULTIPLE_FULL
:
694 case TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
:
703 priv_port
= bt_private_component_source_add_output_private_port(
704 private_component
, "out0", NULL
);
710 priv_port
= bt_private_component_source_add_output_private_port(
711 private_component
, "out1", NULL
);
717 priv_port
= bt_private_component_source_add_output_private_port(
718 private_component
, "out2", NULL
);
724 priv_port
= bt_private_component_source_add_output_private_port(
725 private_component
, "out3", NULL
);
730 return BT_COMPONENT_STATUS_OK
;
734 void src_finalize(struct bt_private_component
*private_component
)
739 enum bt_component_status
sink_consume(
740 struct bt_private_component
*priv_component
)
742 enum bt_component_status ret
= BT_COMPONENT_STATUS_OK
;
743 struct bt_notification
*notification
= NULL
;
744 struct sink_user_data
*user_data
=
745 bt_private_component_get_user_data(priv_component
);
746 enum bt_notification_iterator_status it_ret
;
747 struct test_event test_event
;
748 bool do_append_test_event
= true;
750 assert(user_data
&& user_data
->notif_iter
);
751 it_ret
= bt_notification_iterator_next(user_data
->notif_iter
);
754 ret
= BT_COMPONENT_STATUS_ERROR
;
755 do_append_test_event
= false;
760 case BT_NOTIFICATION_ITERATOR_STATUS_END
:
761 test_event
.type
= TEST_EV_TYPE_END
;
762 ret
= BT_COMPONENT_STATUS_END
;
763 BT_PUT(user_data
->notif_iter
);
765 case BT_NOTIFICATION_ITERATOR_STATUS_AGAIN
:
766 test_event
.type
= TEST_EV_TYPE_AGAIN
;
767 ret
= BT_COMPONENT_STATUS_AGAIN
;
773 notification
= bt_notification_iterator_get_notification(
774 user_data
->notif_iter
);
775 assert(notification
);
777 switch (bt_notification_get_type(notification
)) {
778 case BT_NOTIFICATION_TYPE_EVENT
:
780 struct bt_ctf_event
*event
;
781 struct bt_clock_class_priority_map
*cc_prio_map
;
783 test_event
.type
= TEST_EV_TYPE_NOTIF_EVENT
;
785 bt_notification_event_get_clock_class_priority_map(
788 event
= bt_notification_event_get_event(notification
);
791 if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map
) > 0) {
792 struct bt_ctf_clock_value
*clock_value
;
793 struct bt_ctf_clock_class
*clock_class
=
794 bt_clock_class_priority_map_get_highest_priority_clock_class(
798 clock_value
= bt_ctf_event_get_clock_value(event
,
801 ret
= bt_ctf_clock_value_get_value_ns_from_epoch(
802 clock_value
, &test_event
.ts_ns
);
807 test_event
.ts_ns
= -1;
814 case BT_NOTIFICATION_TYPE_INACTIVITY
:
816 struct bt_clock_class_priority_map
*cc_prio_map
;
818 test_event
.type
= TEST_EV_TYPE_NOTIF_INACTIVITY
;
819 cc_prio_map
= bt_notification_event_get_clock_class_priority_map(
823 if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map
) > 0) {
824 struct bt_ctf_clock_value
*clock_value
;
825 struct bt_ctf_clock_class
*clock_class
=
826 bt_clock_class_priority_map_get_highest_priority_clock_class(
831 bt_notification_inactivity_get_clock_value(
832 notification
, clock_class
);
834 ret
= bt_ctf_clock_value_get_value_ns_from_epoch(
835 clock_value
, &test_event
.ts_ns
);
840 test_event
.ts_ns
= -1;
846 case BT_NOTIFICATION_TYPE_PACKET_BEGIN
:
847 test_event
.type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
;
849 case BT_NOTIFICATION_TYPE_PACKET_END
:
850 test_event
.type
= TEST_EV_TYPE_NOTIF_PACKET_END
;
852 case BT_NOTIFICATION_TYPE_STREAM_BEGIN
:
853 test_event
.type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
;
855 case BT_NOTIFICATION_TYPE_STREAM_END
:
856 test_event
.type
= TEST_EV_TYPE_NOTIF_STREAM_END
;
859 test_event
.type
= TEST_EV_TYPE_NOTIF_UNEXPECTED
;
864 if (do_append_test_event
) {
865 append_test_event(&test_event
);
868 bt_put(notification
);
873 void sink_port_connected(struct bt_private_component
*private_component
,
874 struct bt_private_port
*self_private_port
,
875 struct bt_port
*other_port
)
877 struct bt_private_connection
*priv_conn
=
878 bt_private_port_get_private_connection(self_private_port
);
879 struct sink_user_data
*user_data
= bt_private_component_get_user_data(
884 user_data
->notif_iter
=
885 bt_private_connection_create_notification_iterator(priv_conn
,
887 assert(user_data
->notif_iter
);
892 enum bt_component_status
sink_init(
893 struct bt_private_component
*private_component
,
894 struct bt_value
*params
, void *init_method_data
)
896 struct sink_user_data
*user_data
= g_new0(struct sink_user_data
, 1);
901 ret
= bt_private_component_set_user_data(private_component
,
904 priv_port
= bt_private_component_sink_add_input_private_port(
905 private_component
, "in", NULL
);
908 return BT_COMPONENT_STATUS_OK
;
912 void sink_finalize(struct bt_private_component
*private_component
)
914 struct sink_user_data
*user_data
= bt_private_component_get_user_data(
918 bt_put(user_data
->notif_iter
);
924 void create_source_muxer_sink(struct bt_component
**source
,
925 struct bt_component
**muxer
,
926 struct bt_component
**sink
)
928 struct bt_component_class
*src_comp_class
;
929 struct bt_component_class
*muxer_comp_class
;
930 struct bt_component_class
*sink_comp_class
;
933 /* Create source component */
934 src_comp_class
= bt_component_class_source_create("src", src_iter_next
);
935 assert(src_comp_class
);
936 ret
= bt_component_class_set_init_method(src_comp_class
, src_init
);
938 ret
= bt_component_class_set_finalize_method(src_comp_class
,
941 ret
= bt_component_class_source_set_notification_iterator_init_method(
942 src_comp_class
, src_iter_init
);
944 ret
= bt_component_class_source_set_notification_iterator_finalize_method(
945 src_comp_class
, src_iter_finalize
);
947 *source
= bt_component_create(src_comp_class
, "source", NULL
);
950 /* Create muxer component */
951 muxer_comp_class
= bt_plugin_find_component_class("utils", "muxer",
952 BT_COMPONENT_CLASS_TYPE_FILTER
);
953 assert(muxer_comp_class
);
954 *muxer
= bt_component_create(muxer_comp_class
, "muxer", NULL
);
957 /* Create sink component */
958 sink_comp_class
= bt_component_class_sink_create("sink", sink_consume
);
959 assert(sink_comp_class
);
960 ret
= bt_component_class_set_init_method(sink_comp_class
, sink_init
);
962 ret
= bt_component_class_set_finalize_method(sink_comp_class
,
964 ret
= bt_component_class_set_port_connected_method(sink_comp_class
,
965 sink_port_connected
);
967 *sink
= bt_component_create(sink_comp_class
, "sink", NULL
);
969 bt_put(src_comp_class
);
970 bt_put(muxer_comp_class
);
971 bt_put(sink_comp_class
);
975 void do_std_test(enum test test
, const char *name
,
976 const struct test_event
*expected_test_events
,
979 struct bt_component
*src_comp
;
980 struct bt_component
*muxer_comp
;
981 struct bt_component
*sink_comp
;
982 struct bt_port
*upstream_port
;
983 struct bt_port
*downstream_port
;
984 struct bt_graph
*graph
;
988 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
992 diag("test: %s", name
);
993 create_source_muxer_sink(&src_comp
, &muxer_comp
, &sink_comp
);
994 graph
= bt_graph_create();
997 /* Connect source output ports to muxer input ports */
999 count
= bt_component_source_get_output_port_count(src_comp
);
1002 for (i
= 0; i
< count
; i
++) {
1003 upstream_port
= bt_component_source_get_output_port_by_index(
1005 assert(upstream_port
);
1006 downstream_port
= bt_component_filter_get_input_port_by_index(
1008 assert(downstream_port
);
1009 conn
= bt_graph_connect_ports(graph
,
1010 upstream_port
, downstream_port
);
1013 bt_put(upstream_port
);
1014 bt_put(downstream_port
);
1018 /* Connect muxer output port to sink input port */
1019 upstream_port
= bt_component_filter_get_output_port_by_name(muxer_comp
,
1021 assert(upstream_port
);
1022 downstream_port
= bt_component_sink_get_input_port_by_name(sink_comp
, "in");
1023 assert(downstream_port
);
1024 conn
= bt_graph_connect_ports(graph
, upstream_port
, downstream_port
);
1027 bt_put(upstream_port
);
1028 bt_put(downstream_port
);
1030 while (graph_status
== BT_GRAPH_STATUS_OK
||
1031 graph_status
== BT_GRAPH_STATUS_AGAIN
) {
1032 graph_status
= bt_graph_run(graph
);
1035 ok(graph_status
== BT_GRAPH_STATUS_END
, "graph finishes without any error");
1036 ok(compare_test_events(expected_test_events
),
1037 "the produced sequence of test events is the expected one");
1046 void test_no_ts(void)
1048 const struct test_event expected_test_events
[] = {
1049 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1050 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1051 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1052 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1053 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1054 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1055 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1056 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1057 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= -1, },
1058 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1059 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1060 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 1, },
1061 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 4, },
1062 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 189, },
1063 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 1001, },
1064 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1065 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1066 { .type
= TEST_EV_TYPE_END
, },
1067 { .type
= TEST_EV_TYPE_SENTINEL
, },
1070 do_std_test(TEST_NO_TS
, "event notifications with no time",
1071 expected_test_events
, true);
1075 void test_no_upstream_connection(void)
1077 const struct test_event expected_test_events
[] = {
1078 { .type
= TEST_EV_TYPE_END
, },
1079 { .type
= TEST_EV_TYPE_SENTINEL
, },
1082 do_std_test(TEST_NO_UPSTREAM_CONNECTION
, "no upstream connection",
1083 expected_test_events
, false);
1087 void test_simple_4_ports(void)
1089 const struct test_event expected_test_events
[] = {
1090 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1091 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1092 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1093 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1094 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1095 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1096 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1097 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1098 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1099 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 24 },
1100 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 41 },
1101 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1102 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 53 },
1103 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 56 },
1104 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1105 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1106 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1107 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1108 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1109 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 97 },
1110 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 105 },
1111 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 119 },
1112 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 120 },
1113 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1114 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 138 },
1115 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1116 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 154 },
1117 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1118 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1119 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1120 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 210 },
1121 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 222 },
1122 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 228 },
1123 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 240 },
1124 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1125 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1126 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 292 },
1127 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1128 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 317 },
1129 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1130 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1131 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1132 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 353 },
1133 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1134 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 407 },
1135 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1136 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 433 },
1137 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1138 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 471 },
1139 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 473 },
1140 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1141 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 479 },
1142 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 481 },
1143 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 487 },
1144 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 504 },
1145 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 525 },
1146 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 572 },
1147 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 591 },
1148 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 605 },
1149 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 612 },
1150 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 615 },
1151 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 618 },
1152 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1153 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1154 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 632 },
1155 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1156 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1157 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1158 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 670 },
1159 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1160 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 696 },
1161 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 708 },
1162 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1163 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1164 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1165 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1166 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1167 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1168 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 766 },
1169 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1170 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1171 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1172 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1173 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1174 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 825 },
1175 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1176 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1177 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1178 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 850 },
1179 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 852 },
1180 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1181 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 863 },
1182 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 867 },
1183 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 871 },
1184 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 884 },
1185 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1186 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1187 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 931 },
1188 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1189 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 951 },
1190 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 953 },
1191 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 956 },
1192 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 985 },
1193 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 996 },
1194 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1195 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1196 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1197 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1198 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1199 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 999 },
1200 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1201 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1202 { .type
= TEST_EV_TYPE_END
, },
1203 { .type
= TEST_EV_TYPE_SENTINEL
, },
1206 do_std_test(TEST_SIMPLE_4_PORTS
, "simple: 4 ports without retries",
1207 expected_test_events
, true);
1211 void test_4_ports_with_retries(void)
1213 const struct test_event expected_test_events
[] = {
1214 { .type
= TEST_EV_TYPE_AGAIN
, },
1215 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1216 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1217 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1218 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1219 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1220 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1221 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1222 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1223 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1224 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 24 },
1225 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 41 },
1226 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1227 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 53 },
1228 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 56 },
1229 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1230 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1231 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1232 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1233 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1234 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 97 },
1235 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 105 },
1236 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 119 },
1237 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 120 },
1238 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1239 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 138 },
1240 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1241 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 154 },
1242 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1243 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1244 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1245 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 210 },
1246 { .type
= TEST_EV_TYPE_AGAIN
, },
1247 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 222 },
1248 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 228 },
1249 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 240 },
1250 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1251 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1252 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 292 },
1253 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1254 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 317 },
1255 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1256 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1257 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1258 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 353 },
1259 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1260 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 407 },
1261 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1262 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 433 },
1263 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1264 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 471 },
1265 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 473 },
1266 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1267 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 479 },
1268 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 481 },
1269 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 487 },
1270 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 504 },
1271 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 525 },
1272 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 572 },
1273 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 591 },
1274 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 605 },
1275 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 612 },
1276 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 615 },
1277 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 618 },
1278 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1279 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1280 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 632 },
1281 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1282 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1283 { .type
= TEST_EV_TYPE_AGAIN
, },
1284 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1285 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 670 },
1286 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1287 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 696 },
1288 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 708 },
1289 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1290 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1291 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1292 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1293 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1294 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1295 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 766 },
1296 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1297 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1298 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1299 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1300 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1301 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 825 },
1302 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1303 { .type
= TEST_EV_TYPE_AGAIN
, },
1304 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1305 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1306 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 850 },
1307 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 852 },
1308 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1309 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 863 },
1310 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 867 },
1311 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 871 },
1312 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 884 },
1313 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1314 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1315 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 931 },
1316 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1317 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 951 },
1318 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 953 },
1319 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 956 },
1320 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 985 },
1321 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 996 },
1322 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1323 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1324 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1325 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1326 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1327 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 999 },
1328 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1329 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1330 { .type
= TEST_EV_TYPE_END
, },
1331 { .type
= TEST_EV_TYPE_SENTINEL
, },
1334 do_std_test(TEST_4_PORTS_WITH_RETRIES
, "4 ports with retries",
1335 expected_test_events
, true);
1339 void connect_port_to_first_avail_muxer_port(struct bt_graph
*graph
,
1340 struct bt_port
*source_port
,
1341 struct bt_component
*muxer_comp
)
1343 struct bt_port
*avail_muxer_port
= NULL
;
1348 count
= bt_component_filter_get_input_port_count(muxer_comp
);
1351 for (i
= 0; i
< count
; i
++) {
1352 struct bt_port
*muxer_port
=
1353 bt_component_filter_get_input_port_by_index(
1358 if (!bt_port_is_connected(muxer_port
)) {
1359 BT_MOVE(avail_muxer_port
, muxer_port
);
1366 conn
= bt_graph_connect_ports(graph
, source_port
, avail_muxer_port
);
1369 bt_put(avail_muxer_port
);
1373 void graph_port_added_listener_connect_to_avail_muxer_port(struct bt_port
*port
,
1376 struct graph_listener_data
*graph_listener_data
= data
;
1377 struct bt_component
*comp
;
1379 comp
= bt_port_get_component(port
);
1382 if (comp
!= graph_listener_data
->source
) {
1386 connect_port_to_first_avail_muxer_port(graph_listener_data
->graph
,
1387 port
, graph_listener_data
->muxer
);
1394 void test_single_end_then_multiple_full(void)
1396 struct bt_component
*src_comp
;
1397 struct bt_component
*muxer_comp
;
1398 struct bt_component
*sink_comp
;
1399 struct bt_port
*upstream_port
;
1400 struct bt_port
*downstream_port
;
1401 struct bt_graph
*graph
;
1406 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
1407 struct graph_listener_data graph_listener_data
;
1408 const struct test_event expected_test_events
[] = {
1409 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1410 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1411 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1412 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1413 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1414 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1415 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1416 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1417 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1418 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1419 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1420 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1421 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1422 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1423 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1424 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1425 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1426 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1427 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1428 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1429 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1430 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1431 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1432 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1433 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1434 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1435 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1436 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1437 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1438 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1439 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1440 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1441 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1442 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1443 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1444 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1445 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1446 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1447 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1448 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1449 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1450 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1451 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1452 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1453 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1454 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1455 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1456 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1457 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1458 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1459 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1460 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1461 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1462 { .type
= TEST_EV_TYPE_END
, },
1463 { .type
= TEST_EV_TYPE_SENTINEL
, },
1466 clear_test_events();
1467 current_test
= TEST_SINGLE_END_THEN_MULTIPLE_FULL
;
1468 diag("test: single end then multiple full");
1469 create_source_muxer_sink(&src_comp
, &muxer_comp
, &sink_comp
);
1470 graph
= bt_graph_create();
1472 graph_listener_data
.graph
= graph
;
1473 graph_listener_data
.source
= src_comp
;
1474 graph_listener_data
.muxer
= muxer_comp
;
1475 graph_listener_data
.sink
= sink_comp
;
1476 ret
= bt_graph_add_port_added_listener(graph
,
1477 graph_port_added_listener_connect_to_avail_muxer_port
,
1478 &graph_listener_data
);
1481 /* Connect source output ports to muxer input ports */
1482 count
= bt_component_source_get_output_port_count(src_comp
);
1485 for (i
= 0; i
< count
; i
++) {
1486 upstream_port
= bt_component_source_get_output_port_by_index(
1488 assert(upstream_port
);
1489 connect_port_to_first_avail_muxer_port(graph
,
1490 upstream_port
, muxer_comp
);
1491 bt_put(upstream_port
);
1494 /* Connect muxer output port to sink input port */
1495 upstream_port
= bt_component_filter_get_output_port_by_name(muxer_comp
,
1497 assert(upstream_port
);
1498 downstream_port
= bt_component_sink_get_input_port_by_name(sink_comp
, "in");
1499 assert(downstream_port
);
1500 conn
= bt_graph_connect_ports(graph
, upstream_port
, downstream_port
);
1503 bt_put(upstream_port
);
1504 bt_put(downstream_port
);
1506 while (graph_status
== BT_GRAPH_STATUS_OK
||
1507 graph_status
== BT_GRAPH_STATUS_AGAIN
) {
1508 graph_status
= bt_graph_run(graph
);
1511 ok(graph_status
== BT_GRAPH_STATUS_END
, "graph finishes without any error");
1512 ok(compare_test_events(expected_test_events
),
1513 "the produced sequence of test events is the expected one");
1522 void test_single_again_end_then_multiple_full(void)
1524 struct bt_component
*src_comp
;
1525 struct bt_component
*muxer_comp
;
1526 struct bt_component
*sink_comp
;
1527 struct bt_port
*upstream_port
;
1528 struct bt_port
*downstream_port
;
1529 struct bt_graph
*graph
;
1534 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
1535 struct graph_listener_data graph_listener_data
;
1536 const struct test_event expected_test_events
[] = {
1537 { .type
= TEST_EV_TYPE_AGAIN
, },
1538 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1539 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1540 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1541 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1542 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1543 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1544 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1545 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1546 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1547 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1548 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1549 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1550 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1551 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1552 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1553 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1554 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1555 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1556 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1557 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1558 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1559 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1560 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1561 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1562 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1563 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1564 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1565 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1566 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1567 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1568 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1569 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1570 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1571 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1572 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1573 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1574 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1575 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1576 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1577 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1578 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1579 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1580 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1581 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1582 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1583 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1584 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1585 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1586 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1587 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1588 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1589 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1590 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1591 { .type
= TEST_EV_TYPE_END
, },
1592 { .type
= TEST_EV_TYPE_SENTINEL
, },
1595 clear_test_events();
1596 current_test
= TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
;
1597 diag("test: single again then end then multiple full");
1598 create_source_muxer_sink(&src_comp
, &muxer_comp
, &sink_comp
);
1599 graph
= bt_graph_create();
1601 graph_listener_data
.graph
= graph
;
1602 graph_listener_data
.source
= src_comp
;
1603 graph_listener_data
.muxer
= muxer_comp
;
1604 graph_listener_data
.sink
= sink_comp
;
1605 ret
= bt_graph_add_port_added_listener(graph
,
1606 graph_port_added_listener_connect_to_avail_muxer_port
,
1607 &graph_listener_data
);
1610 /* Connect source output ports to muxer input ports */
1611 count
= bt_component_source_get_output_port_count(src_comp
);
1614 for (i
= 0; i
< count
; i
++) {
1615 upstream_port
= bt_component_source_get_output_port_by_index(
1617 assert(upstream_port
);
1618 connect_port_to_first_avail_muxer_port(graph
,
1619 upstream_port
, muxer_comp
);
1620 bt_put(upstream_port
);
1623 /* Connect muxer output port to sink input port */
1624 upstream_port
= bt_component_filter_get_output_port_by_name(muxer_comp
,
1626 assert(upstream_port
);
1627 downstream_port
= bt_component_sink_get_input_port_by_name(sink_comp
, "in");
1628 assert(downstream_port
);
1629 conn
= bt_graph_connect_ports(graph
, upstream_port
, downstream_port
);
1632 bt_put(upstream_port
);
1633 bt_put(downstream_port
);
1635 while (graph_status
== BT_GRAPH_STATUS_OK
||
1636 graph_status
== BT_GRAPH_STATUS_AGAIN
) {
1637 graph_status
= bt_graph_run(graph
);
1640 ok(graph_status
== BT_GRAPH_STATUS_END
, "graph finishes without any error");
1641 ok(compare_test_events(expected_test_events
),
1642 "the produced sequence of test events is the expected one");
1650 #define DEBUG_ENV_VAR "TEST_UTILS_MUXER_DEBUG"
1652 int main(int argc
, char **argv
)
1654 if (getenv(DEBUG_ENV_VAR
) && strcmp(getenv(DEBUG_ENV_VAR
), "1") == 0) {
1658 plan_tests(NR_TESTS
);
1661 test_no_upstream_connection();
1662 test_simple_4_ports();
1663 test_4_ports_with_retries();
1664 test_single_end_then_multiple_full();
1665 test_single_again_end_then_multiple_full();
1667 return exit_status();