2 * Copyright 2017 - Philippe Proulx <pproulx@efficios.com>
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; under version 2 of the License.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
25 #include <babeltrace/ctf-ir/event-class.h>
26 #include <babeltrace/ctf-ir/event.h>
27 #include <babeltrace/ctf-ir/field-types.h>
28 #include <babeltrace/ctf-ir/fields.h>
29 #include <babeltrace/ctf-ir/packet.h>
30 #include <babeltrace/ctf-ir/stream-class.h>
31 #include <babeltrace/ctf-ir/stream.h>
32 #include <babeltrace/ctf-ir/trace.h>
33 #include <babeltrace/graph/clock-class-priority-map.h>
34 #include <babeltrace/graph/component-class-filter.h>
35 #include <babeltrace/graph/component-class-sink.h>
36 #include <babeltrace/graph/component-class-source.h>
37 #include <babeltrace/graph/component-class.h>
38 #include <babeltrace/graph/component-filter.h>
39 #include <babeltrace/graph/component-sink.h>
40 #include <babeltrace/graph/component-source.h>
41 #include <babeltrace/graph/component.h>
42 #include <babeltrace/graph/graph.h>
43 #include <babeltrace/graph/notification-event.h>
44 #include <babeltrace/graph/notification-inactivity.h>
45 #include <babeltrace/graph/notification-iterator.h>
46 #include <babeltrace/graph/notification-packet.h>
47 #include <babeltrace/graph/port.h>
48 #include <babeltrace/graph/private-component-source.h>
49 #include <babeltrace/graph/private-component-sink.h>
50 #include <babeltrace/graph/private-component.h>
51 #include <babeltrace/graph/private-connection.h>
52 #include <babeltrace/graph/private-notification-iterator.h>
53 #include <babeltrace/graph/private-port.h>
54 #include <babeltrace/plugin/plugin.h>
55 #include <babeltrace/ref.h>
64 TEST_NO_UPSTREAM_CONNECTION
,
66 TEST_4_PORTS_WITH_RETRIES
,
67 TEST_SINGLE_END_THEN_MULTIPLE_FULL
,
68 TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
,
71 enum test_event_type
{
72 TEST_EV_TYPE_NOTIF_UNEXPECTED
,
73 TEST_EV_TYPE_NOTIF_EVENT
,
74 TEST_EV_TYPE_NOTIF_INACTIVITY
,
75 TEST_EV_TYPE_NOTIF_PACKET_BEGIN
,
76 TEST_EV_TYPE_NOTIF_PACKET_END
,
77 TEST_EV_TYPE_NOTIF_STREAM_BEGIN
,
78 TEST_EV_TYPE_NOTIF_STREAM_END
,
81 TEST_EV_TYPE_SENTINEL
,
85 enum test_event_type type
;
89 struct source_muxer_sink
{
90 struct bt_component
*source
;
91 struct bt_component
*muxer
;
92 struct bt_component
*sink
;
95 struct graph_listener_data
{
96 struct bt_graph
*graph
;
97 struct bt_component
*source
;
98 struct bt_component
*muxer
;
99 struct bt_component
*sink
;
102 static bool debug
= false;
103 static enum test current_test
;
104 static GArray
*test_events
;
105 static struct bt_clock_class_priority_map
*src_cc_prio_map
;
106 static struct bt_clock_class_priority_map
*src_empty_cc_prio_map
;
107 static struct bt_ctf_clock_class
*src_clock_class
;
108 static struct bt_ctf_stream_class
*src_stream_class
;
109 static struct bt_ctf_event_class
*src_event_class
;
110 static struct bt_ctf_packet
*src_packet0
;
111 static struct bt_ctf_packet
*src_packet1
;
112 static struct bt_ctf_packet
*src_packet2
;
113 static struct bt_ctf_packet
*src_packet3
;
118 SEQ_PACKET_BEGIN
= -3,
122 struct src_iter_user_data
{
126 struct bt_ctf_packet
*packet
;
129 struct sink_user_data
{
130 struct bt_notification_iterator
*notif_iter
;
133 static int64_t seq1
[] = {
134 24, 53, 97, 105, 119, 210, 222, 240, 292, 317, 353, 407, 433,
135 473, 487, 504, 572, 615, 708, 766, 850, 852, 931, 951, 956, 996,
139 static int64_t seq2
[] = {
140 51, 59, 68, 77, 91, 121, 139, 170, 179, 266, 352, 454, 478, 631,
141 644, 668, 714, 744, 750, 778, 790, 836, SEQ_END
,
144 static int64_t seq3
[] = {
145 8, 71, 209, 254, 298, 320, 350, 393, 419, 624, 651, 678, 717,
146 731, 733, 788, 819, 820, 857, 892, 903, 944, 998, SEQ_END
,
149 static int64_t seq4
[] = {
150 41, 56, 120, 138, 154, 228, 471, 479, 481, 525, 591, 605, 612,
151 618, 632, 670, 696, 825, 863, 867, 871, 884, 953, 985, 999,
155 static int64_t seq1_with_again
[] = {
156 24, 53, 97, 105, 119, 210, SEQ_AGAIN
, 222, 240, 292, 317, 353,
157 407, 433, 473, 487, 504, 572, 615, 708, 766, 850, 852, 931, 951,
161 static int64_t seq2_with_again
[] = {
162 51, 59, 68, 77, 91, 121, 139, 170, 179, 266, 352, 454, 478, 631,
163 644, 668, 714, 744, 750, 778, 790, 836, SEQ_AGAIN
, SEQ_END
,
166 static int64_t seq3_with_again
[] = {
167 8, 71, 209, 254, 298, 320, 350, 393, 419, 624, 651, SEQ_AGAIN
,
168 678, 717, 731, 733, 788, 819, 820, 857, 892, 903, 944, 998,
172 static int64_t seq4_with_again
[] = {
173 SEQ_AGAIN
, 41, 56, 120, 138, 154, 228, 471, 479, 481, 525, 591,
174 605, 612, 618, 632, 670, 696, 825, 863, 867, 871, 884, 953, 985,
178 static int64_t seq5
[] = {
179 1, 4, 189, 1001, SEQ_END
,
183 void clear_test_events(void)
185 g_array_set_size(test_events
, 0);
189 void print_test_event(FILE *fp
, const struct test_event
*event
)
191 fprintf(fp
, "{ type = ");
193 switch (event
->type
) {
194 case TEST_EV_TYPE_NOTIF_UNEXPECTED
:
195 fprintf(fp
, "TEST_EV_TYPE_NOTIF_UNEXPECTED");
197 case TEST_EV_TYPE_NOTIF_EVENT
:
198 fprintf(fp
, "TEST_EV_TYPE_NOTIF_EVENT");
200 case TEST_EV_TYPE_NOTIF_INACTIVITY
:
201 fprintf(fp
, "TEST_EV_TYPE_NOTIF_INACTIVITY");
203 case TEST_EV_TYPE_NOTIF_PACKET_BEGIN
:
204 fprintf(fp
, "TEST_EV_TYPE_NOTIF_PACKET_BEGIN");
206 case TEST_EV_TYPE_NOTIF_PACKET_END
:
207 fprintf(fp
, "TEST_EV_TYPE_NOTIF_PACKET_END");
209 case TEST_EV_TYPE_NOTIF_STREAM_BEGIN
:
210 fprintf(fp
, "TEST_EV_TYPE_NOTIF_STREAM_BEGIN");
212 case TEST_EV_TYPE_NOTIF_STREAM_END
:
213 fprintf(fp
, "TEST_EV_TYPE_NOTIF_STREAM_END");
215 case TEST_EV_TYPE_AGAIN
:
216 fprintf(fp
, "TEST_EV_TYPE_AGAIN");
218 case TEST_EV_TYPE_END
:
219 fprintf(fp
, "TEST_EV_TYPE_END");
221 case TEST_EV_TYPE_SENTINEL
:
222 fprintf(fp
, "TEST_EV_TYPE_SENTINEL");
225 fprintf(fp
, "(UNKNOWN)");
229 switch (event
->type
) {
230 case TEST_EV_TYPE_NOTIF_EVENT
:
231 case TEST_EV_TYPE_NOTIF_INACTIVITY
:
232 fprintf(fp
, ", ts-ns = %" PRId64
, event
->ts_ns
);
241 void append_test_event(struct test_event
*event
)
243 g_array_append_val(test_events
, *event
);
247 bool compare_single_test_events(const struct test_event
*ev_a
,
248 const struct test_event
*ev_b
)
251 fprintf(stderr
, ":: Comparing test events: ");
252 print_test_event(stderr
, ev_a
);
253 fprintf(stderr
, " vs. ");
254 print_test_event(stderr
, ev_b
);
255 fprintf(stderr
, "\n");
258 if (ev_a
->type
!= ev_b
->type
) {
262 switch (ev_a
->type
) {
263 case TEST_EV_TYPE_NOTIF_EVENT
:
264 case TEST_EV_TYPE_NOTIF_INACTIVITY
:
265 if (ev_a
->ts_ns
!= ev_b
->ts_ns
) {
277 bool compare_test_events(const struct test_event
*expected_events
)
279 const struct test_event
*expected_event
= expected_events
;
282 assert(expected_events
);
285 const struct test_event
*event
;
287 if (expected_event
->type
== TEST_EV_TYPE_SENTINEL
) {
291 if (i
>= test_events
->len
) {
295 event
= &g_array_index(test_events
, struct test_event
, i
);
297 if (!compare_single_test_events(event
, expected_event
)) {
305 if (i
!= test_events
->len
) {
307 fprintf(stderr
, ":: Length mismatch\n");
317 void init_static_data(void)
320 struct bt_ctf_trace
*trace
;
321 struct bt_ctf_stream
*stream
;
322 struct bt_ctf_field_type
*empty_struct_ft
;
325 test_events
= g_array_new(FALSE
, TRUE
, sizeof(struct test_event
));
329 empty_struct_ft
= bt_ctf_field_type_structure_create();
330 assert(empty_struct_ft
);
331 trace
= bt_ctf_trace_create();
333 ret
= bt_ctf_trace_set_native_byte_order(trace
,
334 BT_CTF_BYTE_ORDER_LITTLE_ENDIAN
);
336 ret
= bt_ctf_trace_set_packet_header_type(trace
, empty_struct_ft
);
338 src_clock_class
= bt_ctf_clock_class_create("my-clock");
339 assert(src_clock_class
);
340 ret
= bt_ctf_clock_class_set_is_absolute(src_clock_class
, 1);
342 ret
= bt_ctf_trace_add_clock_class(trace
, src_clock_class
);
344 src_empty_cc_prio_map
= bt_clock_class_priority_map_create();
345 assert(src_empty_cc_prio_map
);
346 src_cc_prio_map
= bt_clock_class_priority_map_create();
347 assert(src_cc_prio_map
);
348 ret
= bt_clock_class_priority_map_add_clock_class(src_cc_prio_map
,
351 src_stream_class
= bt_ctf_stream_class_create("my-stream-class");
352 assert(src_stream_class
);
353 ret
= bt_ctf_stream_class_set_packet_context_type(src_stream_class
,
356 ret
= bt_ctf_stream_class_set_event_header_type(src_stream_class
,
359 ret
= bt_ctf_stream_class_set_event_context_type(src_stream_class
,
362 src_event_class
= bt_ctf_event_class_create("my-event-class");
363 ret
= bt_ctf_event_class_set_context_type(src_event_class
,
366 ret
= bt_ctf_event_class_set_context_type(src_event_class
,
369 ret
= bt_ctf_stream_class_add_event_class(src_stream_class
,
372 ret
= bt_ctf_trace_add_stream_class(trace
, src_stream_class
);
374 stream
= bt_ctf_stream_create(src_stream_class
, "stream0");
376 src_packet0
= bt_ctf_packet_create(stream
);
379 stream
= bt_ctf_stream_create(src_stream_class
, "stream1");
381 src_packet1
= bt_ctf_packet_create(stream
);
384 stream
= bt_ctf_stream_create(src_stream_class
, "stream2");
386 src_packet2
= bt_ctf_packet_create(stream
);
389 stream
= bt_ctf_stream_create(src_stream_class
, "stream3");
391 src_packet3
= bt_ctf_packet_create(stream
);
396 bt_put(empty_struct_ft
);
400 void fini_static_data(void)
403 g_array_free(test_events
, TRUE
);
406 bt_put(src_empty_cc_prio_map
);
407 bt_put(src_cc_prio_map
);
408 bt_put(src_clock_class
);
409 bt_put(src_stream_class
);
410 bt_put(src_event_class
);
418 void src_iter_finalize(
419 struct bt_private_notification_iterator
*private_notification_iterator
)
421 struct src_iter_user_data
*user_data
=
422 bt_private_notification_iterator_get_user_data(
423 private_notification_iterator
);
431 enum bt_notification_iterator_status
src_iter_init(
432 struct bt_private_notification_iterator
*priv_notif_iter
,
433 struct bt_private_port
*private_port
)
435 struct src_iter_user_data
*user_data
=
436 g_new0(struct src_iter_user_data
, 1);
437 struct bt_port
*port
= bt_port_from_private_port(private_port
);
438 const char *port_name
;
443 ret
= bt_private_notification_iterator_set_user_data(priv_notif_iter
,
446 port_name
= bt_port_get_name(port
);
448 user_data
->iter_index
= port_name
[3] - '0';
451 switch (user_data
->iter_index
) {
453 user_data
->packet
= src_packet0
;
456 user_data
->packet
= src_packet1
;
459 user_data
->packet
= src_packet2
;
462 user_data
->packet
= src_packet3
;
468 switch (current_test
) {
470 if (user_data
->iter_index
== 1) {
471 user_data
->seq
= seq5
;
474 case TEST_SIMPLE_4_PORTS
:
475 if (user_data
->iter_index
== 0) {
476 user_data
->seq
= seq1
;
477 } else if (user_data
->iter_index
== 1) {
478 user_data
->seq
= seq2
;
479 } else if (user_data
->iter_index
== 2) {
480 user_data
->seq
= seq3
;
482 user_data
->seq
= seq4
;
485 case TEST_4_PORTS_WITH_RETRIES
:
486 if (user_data
->iter_index
== 0) {
487 user_data
->seq
= seq1_with_again
;
488 } else if (user_data
->iter_index
== 1) {
489 user_data
->seq
= seq2_with_again
;
490 } else if (user_data
->iter_index
== 2) {
491 user_data
->seq
= seq3_with_again
;
493 user_data
->seq
= seq4_with_again
;
496 case TEST_SINGLE_END_THEN_MULTIPLE_FULL
:
497 case TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
:
498 if (user_data
->iter_index
== 0) {
499 /* Ignore: this iterator only returns END */
500 } else if (user_data
->iter_index
== 1) {
501 user_data
->seq
= seq2
;
503 user_data
->seq
= seq3
;
510 return BT_NOTIFICATION_ITERATOR_STATUS_OK
;
514 struct bt_ctf_event
*src_create_event(struct bt_ctf_packet
*packet
,
517 struct bt_ctf_event
*event
= bt_ctf_event_create(src_event_class
);
521 ret
= bt_ctf_event_set_packet(event
, packet
);
525 struct bt_ctf_clock_value
*clock_value
;
527 clock_value
= bt_ctf_clock_value_create(src_clock_class
,
530 ret
= bt_ctf_event_set_clock_value(event
, clock_value
);
539 struct bt_notification_iterator_next_return
src_iter_next_seq(
540 struct src_iter_user_data
*user_data
)
542 struct bt_notification_iterator_next_return next_return
= {
543 .status
= BT_NOTIFICATION_ITERATOR_STATUS_OK
,
547 assert(user_data
->seq
);
548 cur_ts_ns
= user_data
->seq
[user_data
->at
];
553 BT_NOTIFICATION_ITERATOR_STATUS_END
;
557 BT_NOTIFICATION_ITERATOR_STATUS_AGAIN
;
559 case SEQ_PACKET_BEGIN
:
560 next_return
.notification
=
561 bt_notification_packet_begin_create(user_data
->packet
);
562 assert(next_return
.notification
);
565 next_return
.notification
=
566 bt_notification_packet_end_create(user_data
->packet
);
567 assert(next_return
.notification
);
571 struct bt_ctf_event
*event
= src_create_event(
572 user_data
->packet
, cur_ts_ns
);
575 next_return
.notification
= bt_notification_event_create(event
,
578 assert(next_return
.notification
);
583 if (next_return
.status
!= BT_NOTIFICATION_ITERATOR_STATUS_END
) {
591 struct bt_notification_iterator_next_return
src_iter_next(
592 struct bt_private_notification_iterator
*priv_iterator
)
594 struct bt_notification_iterator_next_return next_return
;
595 struct src_iter_user_data
*user_data
=
596 bt_private_notification_iterator_get_user_data(priv_iterator
);
597 struct bt_private_component
*private_component
=
598 bt_private_notification_iterator_get_private_component(priv_iterator
);
601 assert(private_component
);
603 switch (current_test
) {
605 if (user_data
->iter_index
== 0) {
606 if (user_data
->at
== 0) {
607 next_return
.notification
=
608 bt_notification_packet_begin_create(
610 assert(next_return
.notification
);
611 } else if (user_data
->at
< 6) {
612 struct bt_ctf_event
*event
= src_create_event(
613 user_data
->packet
, -1);
616 next_return
.notification
=
617 bt_notification_event_create(event
,
618 src_empty_cc_prio_map
);
619 assert(next_return
.notification
);
623 BT_NOTIFICATION_ITERATOR_STATUS_END
;
628 next_return
= src_iter_next_seq(user_data
);
631 case TEST_SIMPLE_4_PORTS
:
632 case TEST_4_PORTS_WITH_RETRIES
:
633 next_return
= src_iter_next_seq(user_data
);
635 case TEST_SINGLE_END_THEN_MULTIPLE_FULL
:
636 if (user_data
->iter_index
== 0) {
637 struct bt_private_port
*priv_port
;
639 priv_port
= bt_private_component_source_add_output_private_port(
640 private_component
, "out1", NULL
);
643 priv_port
= bt_private_component_source_add_output_private_port(
644 private_component
, "out2", 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 struct bt_private_port
*priv_port
;
660 priv_port
= bt_private_component_source_add_output_private_port(
661 private_component
, "out1", NULL
);
664 priv_port
= bt_private_component_source_add_output_private_port(
665 private_component
, "out2", NULL
);
668 next_return
.status
= BT_NOTIFICATION_ITERATOR_STATUS_END
;
671 next_return
= src_iter_next_seq(user_data
);
678 bt_put(private_component
);
683 enum bt_component_status
src_init(
684 struct bt_private_component
*private_component
,
685 struct bt_value
*params
, void *init_method_data
)
687 struct bt_private_port
*priv_port
;
690 switch (current_test
) {
694 case TEST_SINGLE_END_THEN_MULTIPLE_FULL
:
695 case TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
:
704 priv_port
= bt_private_component_source_add_output_private_port(
705 private_component
, "out0", NULL
);
711 priv_port
= bt_private_component_source_add_output_private_port(
712 private_component
, "out1", NULL
);
718 priv_port
= bt_private_component_source_add_output_private_port(
719 private_component
, "out2", NULL
);
725 priv_port
= bt_private_component_source_add_output_private_port(
726 private_component
, "out3", NULL
);
731 return BT_COMPONENT_STATUS_OK
;
735 void src_finalize(struct bt_private_component
*private_component
)
740 enum bt_component_status
sink_consume(
741 struct bt_private_component
*priv_component
)
743 enum bt_component_status ret
= BT_COMPONENT_STATUS_OK
;
744 struct bt_notification
*notification
= NULL
;
745 struct sink_user_data
*user_data
=
746 bt_private_component_get_user_data(priv_component
);
747 enum bt_notification_iterator_status it_ret
;
748 struct test_event test_event
;
749 bool do_append_test_event
= true;
751 assert(user_data
&& user_data
->notif_iter
);
752 it_ret
= bt_notification_iterator_next(user_data
->notif_iter
);
755 ret
= BT_COMPONENT_STATUS_ERROR
;
756 do_append_test_event
= false;
761 case BT_NOTIFICATION_ITERATOR_STATUS_END
:
762 test_event
.type
= TEST_EV_TYPE_END
;
763 ret
= BT_COMPONENT_STATUS_END
;
764 BT_PUT(user_data
->notif_iter
);
766 case BT_NOTIFICATION_ITERATOR_STATUS_AGAIN
:
767 test_event
.type
= TEST_EV_TYPE_AGAIN
;
768 ret
= BT_COMPONENT_STATUS_AGAIN
;
774 notification
= bt_notification_iterator_get_notification(
775 user_data
->notif_iter
);
776 assert(notification
);
778 switch (bt_notification_get_type(notification
)) {
779 case BT_NOTIFICATION_TYPE_EVENT
:
781 struct bt_ctf_event
*event
;
782 struct bt_clock_class_priority_map
*cc_prio_map
;
784 test_event
.type
= TEST_EV_TYPE_NOTIF_EVENT
;
786 bt_notification_event_get_clock_class_priority_map(
789 event
= bt_notification_event_get_event(notification
);
792 if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map
) > 0) {
793 struct bt_ctf_clock_value
*clock_value
;
794 struct bt_ctf_clock_class
*clock_class
=
795 bt_clock_class_priority_map_get_highest_priority_clock_class(
799 clock_value
= bt_ctf_event_get_clock_value(event
,
802 ret
= bt_ctf_clock_value_get_value_ns_from_epoch(
803 clock_value
, &test_event
.ts_ns
);
808 test_event
.ts_ns
= -1;
815 case BT_NOTIFICATION_TYPE_INACTIVITY
:
817 struct bt_clock_class_priority_map
*cc_prio_map
;
819 test_event
.type
= TEST_EV_TYPE_NOTIF_INACTIVITY
;
820 cc_prio_map
= bt_notification_event_get_clock_class_priority_map(
824 if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map
) > 0) {
825 struct bt_ctf_clock_value
*clock_value
;
826 struct bt_ctf_clock_class
*clock_class
=
827 bt_clock_class_priority_map_get_highest_priority_clock_class(
832 bt_notification_inactivity_get_clock_value(
833 notification
, clock_class
);
835 ret
= bt_ctf_clock_value_get_value_ns_from_epoch(
836 clock_value
, &test_event
.ts_ns
);
841 test_event
.ts_ns
= -1;
847 case BT_NOTIFICATION_TYPE_PACKET_BEGIN
:
848 test_event
.type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
;
850 case BT_NOTIFICATION_TYPE_PACKET_END
:
851 test_event
.type
= TEST_EV_TYPE_NOTIF_PACKET_END
;
853 case BT_NOTIFICATION_TYPE_STREAM_BEGIN
:
854 test_event
.type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
;
856 case BT_NOTIFICATION_TYPE_STREAM_END
:
857 test_event
.type
= TEST_EV_TYPE_NOTIF_STREAM_END
;
860 test_event
.type
= TEST_EV_TYPE_NOTIF_UNEXPECTED
;
865 if (do_append_test_event
) {
866 append_test_event(&test_event
);
869 bt_put(notification
);
874 void sink_port_connected(struct bt_private_component
*private_component
,
875 struct bt_private_port
*self_private_port
,
876 struct bt_port
*other_port
)
878 struct bt_private_connection
*priv_conn
=
879 bt_private_port_get_private_connection(self_private_port
);
880 struct sink_user_data
*user_data
= bt_private_component_get_user_data(
885 user_data
->notif_iter
=
886 bt_private_connection_create_notification_iterator(priv_conn
,
888 assert(user_data
->notif_iter
);
893 enum bt_component_status
sink_init(
894 struct bt_private_component
*private_component
,
895 struct bt_value
*params
, void *init_method_data
)
897 struct sink_user_data
*user_data
= g_new0(struct sink_user_data
, 1);
902 ret
= bt_private_component_set_user_data(private_component
,
905 priv_port
= bt_private_component_sink_add_input_private_port(
906 private_component
, "in", NULL
);
909 return BT_COMPONENT_STATUS_OK
;
913 void sink_finalize(struct bt_private_component
*private_component
)
915 struct sink_user_data
*user_data
= bt_private_component_get_user_data(
919 bt_put(user_data
->notif_iter
);
925 void create_source_muxer_sink(struct bt_component
**source
,
926 struct bt_component
**muxer
,
927 struct bt_component
**sink
)
929 struct bt_component_class
*src_comp_class
;
930 struct bt_component_class
*muxer_comp_class
;
931 struct bt_component_class
*sink_comp_class
;
934 /* Create source component */
935 src_comp_class
= bt_component_class_source_create("src", src_iter_next
);
936 assert(src_comp_class
);
937 ret
= bt_component_class_set_init_method(src_comp_class
, src_init
);
939 ret
= bt_component_class_set_finalize_method(src_comp_class
,
942 ret
= bt_component_class_source_set_notification_iterator_init_method(
943 src_comp_class
, src_iter_init
);
945 ret
= bt_component_class_source_set_notification_iterator_finalize_method(
946 src_comp_class
, src_iter_finalize
);
948 *source
= bt_component_create(src_comp_class
, "source", NULL
);
951 /* Create muxer component */
952 muxer_comp_class
= bt_plugin_find_component_class("utils", "muxer",
953 BT_COMPONENT_CLASS_TYPE_FILTER
);
954 assert(muxer_comp_class
);
955 *muxer
= bt_component_create(muxer_comp_class
, "muxer", NULL
);
958 /* Create sink component */
959 sink_comp_class
= bt_component_class_sink_create("sink", sink_consume
);
960 assert(sink_comp_class
);
961 ret
= bt_component_class_set_init_method(sink_comp_class
, sink_init
);
963 ret
= bt_component_class_set_finalize_method(sink_comp_class
,
965 ret
= bt_component_class_set_port_connected_method(sink_comp_class
,
966 sink_port_connected
);
968 *sink
= bt_component_create(sink_comp_class
, "sink", NULL
);
970 bt_put(src_comp_class
);
971 bt_put(muxer_comp_class
);
972 bt_put(sink_comp_class
);
976 void do_std_test(enum test test
, const char *name
,
977 const struct test_event
*expected_test_events
,
980 struct bt_component
*src_comp
;
981 struct bt_component
*muxer_comp
;
982 struct bt_component
*sink_comp
;
983 struct bt_port
*upstream_port
;
984 struct bt_port
*downstream_port
;
985 struct bt_graph
*graph
;
989 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
993 diag("test: %s", name
);
994 create_source_muxer_sink(&src_comp
, &muxer_comp
, &sink_comp
);
995 graph
= bt_graph_create();
998 /* Connect source output ports to muxer input ports */
1000 count
= bt_component_source_get_output_port_count(src_comp
);
1003 for (i
= 0; i
< count
; i
++) {
1004 upstream_port
= bt_component_source_get_output_port_by_index(
1006 assert(upstream_port
);
1007 downstream_port
= bt_component_filter_get_input_port_by_index(
1009 assert(downstream_port
);
1010 conn
= bt_graph_connect_ports(graph
,
1011 upstream_port
, downstream_port
);
1014 bt_put(upstream_port
);
1015 bt_put(downstream_port
);
1019 /* Connect muxer output port to sink input port */
1020 upstream_port
= bt_component_filter_get_output_port_by_name(muxer_comp
,
1022 assert(upstream_port
);
1023 downstream_port
= bt_component_sink_get_input_port_by_name(sink_comp
, "in");
1024 assert(downstream_port
);
1025 conn
= bt_graph_connect_ports(graph
, upstream_port
, downstream_port
);
1028 bt_put(upstream_port
);
1029 bt_put(downstream_port
);
1031 while (graph_status
== BT_GRAPH_STATUS_OK
||
1032 graph_status
== BT_GRAPH_STATUS_AGAIN
) {
1033 graph_status
= bt_graph_run(graph
);
1036 ok(graph_status
== BT_GRAPH_STATUS_END
, "graph finishes without any error");
1037 ok(compare_test_events(expected_test_events
),
1038 "the produced sequence of test events is the expected one");
1047 void test_no_ts(void)
1049 const struct test_event expected_test_events
[] = {
1050 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1051 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1052 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1053 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
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_EVENT
, .ts_ns
= -1, },
1059 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1060 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1061 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 1, },
1062 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 4, },
1063 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 189, },
1064 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 1001, },
1065 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1066 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1067 { .type
= TEST_EV_TYPE_END
, },
1068 { .type
= TEST_EV_TYPE_SENTINEL
, },
1071 do_std_test(TEST_NO_TS
, "event notifications with no time",
1072 expected_test_events
, true);
1076 void test_no_upstream_connection(void)
1078 const struct test_event expected_test_events
[] = {
1079 { .type
= TEST_EV_TYPE_END
, },
1080 { .type
= TEST_EV_TYPE_SENTINEL
, },
1083 do_std_test(TEST_NO_UPSTREAM_CONNECTION
, "no upstream connection",
1084 expected_test_events
, false);
1088 void test_simple_4_ports(void)
1090 const struct test_event expected_test_events
[] = {
1091 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1092 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1093 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1094 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1095 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1096 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1097 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1098 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1099 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1100 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 24 },
1101 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 41 },
1102 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1103 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 53 },
1104 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 56 },
1105 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1106 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1107 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1108 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1109 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1110 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 97 },
1111 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 105 },
1112 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 119 },
1113 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 120 },
1114 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1115 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 138 },
1116 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1117 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 154 },
1118 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1119 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1120 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1121 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 210 },
1122 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 222 },
1123 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 228 },
1124 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 240 },
1125 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1126 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1127 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 292 },
1128 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1129 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 317 },
1130 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1131 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1132 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1133 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 353 },
1134 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1135 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 407 },
1136 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1137 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 433 },
1138 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1139 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 471 },
1140 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 473 },
1141 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1142 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 479 },
1143 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 481 },
1144 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 487 },
1145 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 504 },
1146 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 525 },
1147 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 572 },
1148 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 591 },
1149 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 605 },
1150 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 612 },
1151 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 615 },
1152 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 618 },
1153 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1154 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1155 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 632 },
1156 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1157 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1158 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1159 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 670 },
1160 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1161 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 696 },
1162 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 708 },
1163 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1164 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1165 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1166 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1167 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1168 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1169 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 766 },
1170 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1171 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1172 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1173 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1174 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1175 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 825 },
1176 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1177 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1178 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1179 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 850 },
1180 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 852 },
1181 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1182 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 863 },
1183 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 867 },
1184 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 871 },
1185 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 884 },
1186 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1187 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1188 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 931 },
1189 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1190 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 951 },
1191 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 953 },
1192 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 956 },
1193 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 985 },
1194 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 996 },
1195 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1196 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1197 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1198 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1199 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1200 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 999 },
1201 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1202 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1203 { .type
= TEST_EV_TYPE_END
, },
1204 { .type
= TEST_EV_TYPE_SENTINEL
, },
1207 do_std_test(TEST_SIMPLE_4_PORTS
, "simple: 4 ports without retries",
1208 expected_test_events
, true);
1212 void test_4_ports_with_retries(void)
1214 const struct test_event expected_test_events
[] = {
1215 { .type
= TEST_EV_TYPE_AGAIN
, },
1216 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1217 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1218 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1219 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1220 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1221 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1222 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1223 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1224 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1225 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 24 },
1226 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 41 },
1227 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1228 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 53 },
1229 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 56 },
1230 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1231 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1232 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1233 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1234 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1235 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 97 },
1236 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 105 },
1237 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 119 },
1238 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 120 },
1239 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1240 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 138 },
1241 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1242 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 154 },
1243 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1244 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1245 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1246 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 210 },
1247 { .type
= TEST_EV_TYPE_AGAIN
, },
1248 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 222 },
1249 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 228 },
1250 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 240 },
1251 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1252 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1253 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 292 },
1254 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1255 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 317 },
1256 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1257 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1258 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1259 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 353 },
1260 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1261 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 407 },
1262 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1263 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 433 },
1264 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1265 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 471 },
1266 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 473 },
1267 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1268 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 479 },
1269 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 481 },
1270 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 487 },
1271 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 504 },
1272 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 525 },
1273 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 572 },
1274 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 591 },
1275 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 605 },
1276 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 612 },
1277 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 615 },
1278 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 618 },
1279 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1280 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1281 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 632 },
1282 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1283 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1284 { .type
= TEST_EV_TYPE_AGAIN
, },
1285 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1286 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 670 },
1287 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1288 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 696 },
1289 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 708 },
1290 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1291 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1292 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1293 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1294 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1295 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1296 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 766 },
1297 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1298 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1299 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1300 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1301 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1302 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 825 },
1303 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1304 { .type
= TEST_EV_TYPE_AGAIN
, },
1305 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1306 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1307 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 850 },
1308 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 852 },
1309 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1310 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 863 },
1311 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 867 },
1312 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 871 },
1313 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 884 },
1314 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1315 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1316 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 931 },
1317 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1318 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 951 },
1319 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 953 },
1320 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 956 },
1321 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 985 },
1322 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 996 },
1323 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1324 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1325 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1326 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1327 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1328 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 999 },
1329 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1330 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1331 { .type
= TEST_EV_TYPE_END
, },
1332 { .type
= TEST_EV_TYPE_SENTINEL
, },
1335 do_std_test(TEST_4_PORTS_WITH_RETRIES
, "4 ports with retries",
1336 expected_test_events
, true);
1340 void connect_port_to_first_avail_muxer_port(struct bt_graph
*graph
,
1341 struct bt_port
*source_port
,
1342 struct bt_component
*muxer_comp
)
1344 struct bt_port
*avail_muxer_port
= NULL
;
1349 count
= bt_component_filter_get_input_port_count(muxer_comp
);
1352 for (i
= 0; i
< count
; i
++) {
1353 struct bt_port
*muxer_port
=
1354 bt_component_filter_get_input_port_by_index(
1359 if (!bt_port_is_connected(muxer_port
)) {
1360 BT_MOVE(avail_muxer_port
, muxer_port
);
1367 conn
= bt_graph_connect_ports(graph
, source_port
, avail_muxer_port
);
1370 bt_put(avail_muxer_port
);
1374 void graph_port_added_listener_connect_to_avail_muxer_port(struct bt_port
*port
,
1377 struct graph_listener_data
*graph_listener_data
= data
;
1378 struct bt_component
*comp
;
1380 comp
= bt_port_get_component(port
);
1383 if (comp
!= graph_listener_data
->source
) {
1387 connect_port_to_first_avail_muxer_port(graph_listener_data
->graph
,
1388 port
, graph_listener_data
->muxer
);
1395 void test_single_end_then_multiple_full(void)
1397 struct bt_component
*src_comp
;
1398 struct bt_component
*muxer_comp
;
1399 struct bt_component
*sink_comp
;
1400 struct bt_port
*upstream_port
;
1401 struct bt_port
*downstream_port
;
1402 struct bt_graph
*graph
;
1407 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
1408 struct graph_listener_data graph_listener_data
;
1409 const struct test_event expected_test_events
[] = {
1410 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1411 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1412 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1413 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1414 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1415 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1416 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1417 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1418 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1419 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1420 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1421 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1422 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1423 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1424 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1425 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1426 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1427 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1428 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1429 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1430 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1431 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1432 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1433 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1434 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1435 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1436 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1437 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1438 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1439 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1440 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1441 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1442 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1443 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1444 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1445 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1446 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1447 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1448 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1449 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1450 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1451 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1452 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1453 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1454 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1455 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1456 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1457 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1458 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1459 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1460 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1461 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1462 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1463 { .type
= TEST_EV_TYPE_END
, },
1464 { .type
= TEST_EV_TYPE_SENTINEL
, },
1467 clear_test_events();
1468 current_test
= TEST_SINGLE_END_THEN_MULTIPLE_FULL
;
1469 diag("test: single end then multiple full");
1470 create_source_muxer_sink(&src_comp
, &muxer_comp
, &sink_comp
);
1471 graph
= bt_graph_create();
1473 graph_listener_data
.graph
= graph
;
1474 graph_listener_data
.source
= src_comp
;
1475 graph_listener_data
.muxer
= muxer_comp
;
1476 graph_listener_data
.sink
= sink_comp
;
1477 ret
= bt_graph_add_port_added_listener(graph
,
1478 graph_port_added_listener_connect_to_avail_muxer_port
,
1479 &graph_listener_data
);
1482 /* Connect source output ports to muxer input ports */
1483 count
= bt_component_source_get_output_port_count(src_comp
);
1486 for (i
= 0; i
< count
; i
++) {
1487 upstream_port
= bt_component_source_get_output_port_by_index(
1489 assert(upstream_port
);
1490 connect_port_to_first_avail_muxer_port(graph
,
1491 upstream_port
, muxer_comp
);
1492 bt_put(upstream_port
);
1495 /* Connect muxer output port to sink input port */
1496 upstream_port
= bt_component_filter_get_output_port_by_name(muxer_comp
,
1498 assert(upstream_port
);
1499 downstream_port
= bt_component_sink_get_input_port_by_name(sink_comp
, "in");
1500 assert(downstream_port
);
1501 conn
= bt_graph_connect_ports(graph
, upstream_port
, downstream_port
);
1504 bt_put(upstream_port
);
1505 bt_put(downstream_port
);
1507 while (graph_status
== BT_GRAPH_STATUS_OK
||
1508 graph_status
== BT_GRAPH_STATUS_AGAIN
) {
1509 graph_status
= bt_graph_run(graph
);
1512 ok(graph_status
== BT_GRAPH_STATUS_END
, "graph finishes without any error");
1513 ok(compare_test_events(expected_test_events
),
1514 "the produced sequence of test events is the expected one");
1523 void test_single_again_end_then_multiple_full(void)
1525 struct bt_component
*src_comp
;
1526 struct bt_component
*muxer_comp
;
1527 struct bt_component
*sink_comp
;
1528 struct bt_port
*upstream_port
;
1529 struct bt_port
*downstream_port
;
1530 struct bt_graph
*graph
;
1535 enum bt_graph_status graph_status
= BT_GRAPH_STATUS_OK
;
1536 struct graph_listener_data graph_listener_data
;
1537 const struct test_event expected_test_events
[] = {
1538 { .type
= TEST_EV_TYPE_AGAIN
, },
1539 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1540 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1541 { .type
= TEST_EV_TYPE_NOTIF_STREAM_BEGIN
, },
1542 { .type
= TEST_EV_TYPE_NOTIF_PACKET_BEGIN
, },
1543 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 8 },
1544 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 51 },
1545 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 59 },
1546 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 68 },
1547 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 71 },
1548 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 77 },
1549 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 91 },
1550 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 121 },
1551 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 139 },
1552 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 170 },
1553 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 179 },
1554 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 209 },
1555 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 254 },
1556 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 266 },
1557 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 298 },
1558 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 320 },
1559 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 350 },
1560 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 352 },
1561 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 393 },
1562 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 419 },
1563 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 454 },
1564 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 478 },
1565 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 624 },
1566 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 631 },
1567 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 644 },
1568 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 651 },
1569 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 668 },
1570 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 678 },
1571 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 714 },
1572 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 717 },
1573 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 731 },
1574 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 733 },
1575 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 744 },
1576 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 750 },
1577 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 778 },
1578 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 788 },
1579 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 790 },
1580 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 819 },
1581 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 820 },
1582 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 836 },
1583 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1584 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1585 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 857 },
1586 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 892 },
1587 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 903 },
1588 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 944 },
1589 { .type
= TEST_EV_TYPE_NOTIF_EVENT
, .ts_ns
= 998 },
1590 { .type
= TEST_EV_TYPE_NOTIF_PACKET_END
, },
1591 { .type
= TEST_EV_TYPE_NOTIF_STREAM_END
, },
1592 { .type
= TEST_EV_TYPE_END
, },
1593 { .type
= TEST_EV_TYPE_SENTINEL
, },
1596 clear_test_events();
1597 current_test
= TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL
;
1598 diag("test: single again then end then multiple full");
1599 create_source_muxer_sink(&src_comp
, &muxer_comp
, &sink_comp
);
1600 graph
= bt_graph_create();
1602 graph_listener_data
.graph
= graph
;
1603 graph_listener_data
.source
= src_comp
;
1604 graph_listener_data
.muxer
= muxer_comp
;
1605 graph_listener_data
.sink
= sink_comp
;
1606 ret
= bt_graph_add_port_added_listener(graph
,
1607 graph_port_added_listener_connect_to_avail_muxer_port
,
1608 &graph_listener_data
);
1611 /* Connect source output ports to muxer input ports */
1612 count
= bt_component_source_get_output_port_count(src_comp
);
1615 for (i
= 0; i
< count
; i
++) {
1616 upstream_port
= bt_component_source_get_output_port_by_index(
1618 assert(upstream_port
);
1619 connect_port_to_first_avail_muxer_port(graph
,
1620 upstream_port
, muxer_comp
);
1621 bt_put(upstream_port
);
1624 /* Connect muxer output port to sink input port */
1625 upstream_port
= bt_component_filter_get_output_port_by_name(muxer_comp
,
1627 assert(upstream_port
);
1628 downstream_port
= bt_component_sink_get_input_port_by_name(sink_comp
, "in");
1629 assert(downstream_port
);
1630 conn
= bt_graph_connect_ports(graph
, upstream_port
, downstream_port
);
1633 bt_put(upstream_port
);
1634 bt_put(downstream_port
);
1636 while (graph_status
== BT_GRAPH_STATUS_OK
||
1637 graph_status
== BT_GRAPH_STATUS_AGAIN
) {
1638 graph_status
= bt_graph_run(graph
);
1641 ok(graph_status
== BT_GRAPH_STATUS_END
, "graph finishes without any error");
1642 ok(compare_test_events(expected_test_events
),
1643 "the produced sequence of test events is the expected one");
1651 #define DEBUG_ENV_VAR "TEST_UTILS_MUXER_DEBUG"
1653 int main(int argc
, char **argv
)
1655 if (getenv(DEBUG_ENV_VAR
) && strcmp(getenv(DEBUG_ENV_VAR
), "1") == 0) {
1659 plan_tests(NR_TESTS
);
1662 test_no_upstream_connection();
1663 test_simple_4_ports();
1664 test_4_ports_with_retries();
1665 test_single_end_then_multiple_full();
1666 test_single_again_end_then_multiple_full();
1668 return exit_status();