4 * Copyright 2017 - Philippe Proulx <pproulx@efficios.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; under version 2 of the License.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 #include <babeltrace/graph/component-class.h>
21 #include <babeltrace/graph/component-class-source.h>
22 #include <babeltrace/graph/component-class-sink.h>
23 #include <babeltrace/graph/component.h>
24 #include <babeltrace/graph/component-source.h>
25 #include <babeltrace/graph/component-sink.h>
26 #include <babeltrace/graph/graph.h>
27 #include <babeltrace/graph/connection.h>
28 #include <babeltrace/graph/port.h>
29 #include <babeltrace/graph/private-component.h>
30 #include <babeltrace/graph/private-component-source.h>
31 #include <babeltrace/graph/private-component-sink.h>
32 #include <babeltrace/graph/private-port.h>
33 #include <babeltrace/graph/private-connection.h>
45 COMP_ACCEPT_PORT_CONNECTION
,
47 COMP_PORT_DISCONNECTED
,
50 GRAPH_PORTS_CONNECTED
,
51 GRAPH_PORTS_DISCONNECTED
,
57 TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED
,
58 TEST_SINK_REMOVES_PORT_IN_CONSUME
,
59 TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT
,
67 struct bt_component
*comp
;
68 struct bt_port
*self_port
;
69 struct bt_port
*other_port
;
70 } comp_accept_port_connection
;
73 struct bt_component
*comp
;
74 struct bt_port
*self_port
;
75 struct bt_port
*other_port
;
76 } comp_port_connected
;
79 struct bt_component
*comp
;
81 } comp_port_disconnected
;
84 struct bt_component
*comp
;
89 struct bt_component
*comp
;
94 struct bt_component
*upstream_comp
;
95 struct bt_component
*downstream_comp
;
96 struct bt_port
*upstream_port
;
97 struct bt_port
*downstream_port
;
98 struct bt_connection
*conn
;
99 } graph_ports_connected
;
102 struct bt_component
*upstream_comp
;
103 struct bt_component
*downstream_comp
;
104 struct bt_port
*upstream_port
;
105 struct bt_port
*downstream_port
;
106 } graph_ports_disconnected
;
110 static GArray
*events
;
111 static struct bt_component_class
*src_comp_class
;
112 static struct bt_component_class
*sink_comp_class
;
113 static enum test current_test
;
116 void clear_events(void)
118 g_array_set_size(events
, 0);
122 void append_event(struct event
*event
)
124 g_array_append_val(events
, *event
);
128 bool compare_events(struct event
*ev_a
, struct event
*ev_b
)
130 if (ev_a
->type
!= ev_b
->type
) {
134 switch (ev_a
->type
) {
135 case COMP_ACCEPT_PORT_CONNECTION
:
136 if (ev_a
->data
.comp_accept_port_connection
.comp
!=
137 ev_b
->data
.comp_accept_port_connection
.comp
) {
141 if (ev_a
->data
.comp_accept_port_connection
.self_port
!=
142 ev_b
->data
.comp_accept_port_connection
.self_port
) {
146 if (ev_a
->data
.comp_accept_port_connection
.other_port
!=
147 ev_b
->data
.comp_accept_port_connection
.other_port
) {
151 case COMP_PORT_CONNECTED
:
152 if (ev_a
->data
.comp_port_connected
.comp
!=
153 ev_b
->data
.comp_port_connected
.comp
) {
157 if (ev_a
->data
.comp_port_connected
.self_port
!=
158 ev_b
->data
.comp_port_connected
.self_port
) {
162 if (ev_a
->data
.comp_port_connected
.other_port
!=
163 ev_b
->data
.comp_port_connected
.other_port
) {
167 case COMP_PORT_DISCONNECTED
:
168 if (ev_a
->data
.comp_port_disconnected
.comp
!=
169 ev_b
->data
.comp_port_disconnected
.comp
) {
173 if (ev_a
->data
.comp_port_disconnected
.port
!=
174 ev_b
->data
.comp_port_disconnected
.port
) {
178 case GRAPH_PORT_ADDED
:
179 if (ev_a
->data
.graph_port_added
.comp
!=
180 ev_b
->data
.graph_port_added
.comp
) {
184 if (ev_a
->data
.graph_port_added
.port
!=
185 ev_b
->data
.graph_port_added
.port
) {
189 case GRAPH_PORT_REMOVED
:
190 if (ev_a
->data
.graph_port_removed
.comp
!=
191 ev_b
->data
.graph_port_removed
.comp
) {
195 if (ev_a
->data
.graph_port_removed
.port
!=
196 ev_b
->data
.graph_port_removed
.port
) {
200 case GRAPH_PORTS_CONNECTED
:
201 if (ev_a
->data
.graph_ports_connected
.upstream_comp
!=
202 ev_b
->data
.graph_ports_connected
.upstream_comp
) {
206 if (ev_a
->data
.graph_ports_connected
.downstream_comp
!=
207 ev_b
->data
.graph_ports_connected
.downstream_comp
) {
211 if (ev_a
->data
.graph_ports_connected
.upstream_port
!=
212 ev_b
->data
.graph_ports_connected
.upstream_port
) {
216 if (ev_a
->data
.graph_ports_connected
.downstream_port
!=
217 ev_b
->data
.graph_ports_connected
.downstream_port
) {
221 if (ev_a
->data
.graph_ports_connected
.conn
!=
222 ev_b
->data
.graph_ports_connected
.conn
) {
226 case GRAPH_PORTS_DISCONNECTED
:
227 if (ev_a
->data
.graph_ports_disconnected
.upstream_comp
!=
228 ev_b
->data
.graph_ports_disconnected
.upstream_comp
) {
232 if (ev_a
->data
.graph_ports_disconnected
.downstream_comp
!=
233 ev_b
->data
.graph_ports_disconnected
.downstream_comp
) {
237 if (ev_a
->data
.graph_ports_disconnected
.upstream_port
!=
238 ev_b
->data
.graph_ports_disconnected
.upstream_port
) {
242 if (ev_a
->data
.graph_ports_disconnected
.downstream_port
!=
243 ev_b
->data
.graph_ports_disconnected
.downstream_port
) {
255 bool has_event(struct event
*event
)
259 for (i
= 0; i
< events
->len
; i
++) {
260 struct event
*ev
= &g_array_index(events
, struct event
, i
);
262 if (compare_events(event
, ev
)) {
271 size_t event_pos(struct event
*event
)
275 for (i
= 0; i
< events
->len
; i
++) {
276 struct event
*ev
= &g_array_index(events
, struct event
, i
);
278 if (compare_events(event
, ev
)) {
287 struct bt_notification_iterator_next_return
src_iter_next(
288 struct bt_private_notification_iterator
*priv_iterator
)
290 struct bt_notification_iterator_next_return ret
= {
291 .status
= BT_NOTIFICATION_ITERATOR_STATUS_ERROR
,
298 enum bt_component_status
accept_port_connection(
299 struct bt_private_component
*private_component
,
300 struct bt_private_port
*self_private_port
,
301 struct bt_port
*other_port
)
303 struct event event
= {
304 .type
= COMP_ACCEPT_PORT_CONNECTION
,
305 .data
.comp_accept_port_connection
= {
306 .comp
= bt_component_from_private_component(private_component
),
307 .self_port
= bt_port_from_private_port(self_private_port
),
308 .other_port
= other_port
,
312 bt_put(event
.data
.comp_accept_port_connection
.comp
);
313 bt_put(event
.data
.comp_accept_port_connection
.self_port
);
314 append_event(&event
);
315 return BT_COMPONENT_STATUS_OK
;
319 void src_port_connected(struct bt_private_component
*private_component
,
320 struct bt_private_port
*self_private_port
,
321 struct bt_port
*other_port
)
325 struct event event
= {
326 .type
= COMP_PORT_CONNECTED
,
327 .data
.comp_port_connected
= {
328 .comp
= bt_component_from_private_component(private_component
),
329 .self_port
= bt_port_from_private_port(self_private_port
),
330 .other_port
= other_port
,
334 bt_put(event
.data
.comp_port_connected
.comp
);
335 bt_put(event
.data
.comp_port_connected
.self_port
);
336 append_event(&event
);
338 switch (current_test
) {
339 case TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED
:
340 ret
= bt_private_component_source_add_output_private_port(
341 private_component
, "hello", NULL
, NULL
);
350 void src_port_disconnected(struct bt_private_component
*private_component
,
351 struct bt_private_port
*private_port
)
354 struct event event
= {
355 .type
= COMP_PORT_DISCONNECTED
,
356 .data
.comp_port_disconnected
= {
357 .comp
= bt_component_from_private_component(private_component
),
358 .port
= bt_port_from_private_port(private_port
),
362 bt_put(event
.data
.comp_port_disconnected
.comp
);
363 bt_put(event
.data
.comp_port_disconnected
.port
);
364 append_event(&event
);
366 switch (current_test
) {
367 case TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT
:
368 ret
= bt_private_port_remove_from_component(private_port
);
376 enum bt_component_status
src_init(struct bt_private_component
*priv_comp
,
377 struct bt_value
*params
, void *init_method_data
)
381 ret
= bt_private_component_source_add_output_private_port(
382 priv_comp
, "out", NULL
, NULL
);
384 return BT_COMPONENT_STATUS_OK
;
388 enum bt_component_status
sink_consume(
389 struct bt_private_component
*priv_component
)
391 struct bt_private_port
*def_port
;
394 switch (current_test
) {
395 case TEST_SINK_REMOVES_PORT_IN_CONSUME
:
396 case TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT
:
397 def_port
= bt_private_component_sink_get_input_private_port_by_name(
398 priv_component
, "in");
400 ret
= bt_private_port_remove_from_component(def_port
);
408 return BT_COMPONENT_STATUS_OK
;
412 void sink_port_connected(struct bt_private_component
*private_component
,
413 struct bt_private_port
*self_private_port
,
414 struct bt_port
*other_port
)
416 struct event event
= {
417 .type
= COMP_PORT_CONNECTED
,
418 .data
.comp_port_connected
= {
419 .comp
= bt_component_from_private_component(private_component
),
420 .self_port
= bt_port_from_private_port(self_private_port
),
421 .other_port
= other_port
,
425 bt_put(event
.data
.comp_port_connected
.comp
);
426 bt_put(event
.data
.comp_port_connected
.self_port
);
427 append_event(&event
);
431 void sink_port_disconnected(struct bt_private_component
*private_component
,
432 struct bt_private_port
*private_port
)
434 struct event event
= {
435 .type
= COMP_PORT_DISCONNECTED
,
436 .data
.comp_port_disconnected
= {
437 .comp
= bt_component_from_private_component(private_component
),
438 .port
= bt_port_from_private_port(private_port
),
442 bt_put(event
.data
.comp_port_disconnected
.comp
);
443 bt_put(event
.data
.comp_port_disconnected
.port
);
444 append_event(&event
);
448 enum bt_component_status
sink_init(struct bt_private_component
*priv_comp
,
449 struct bt_value
*params
, void *init_method_data
)
453 ret
= bt_private_component_sink_add_input_private_port(priv_comp
,
456 return BT_COMPONENT_STATUS_OK
;
460 void graph_port_added(struct bt_port
*port
,
463 struct bt_component
*comp
= bt_port_get_component(port
);
468 struct event event
= {
469 .type
= GRAPH_PORT_ADDED
,
470 .data
.graph_port_added
= {
476 append_event(&event
);
480 void graph_port_removed(struct bt_component
*component
,
481 struct bt_port
*port
, void *data
)
483 struct event event
= {
484 .type
= GRAPH_PORT_REMOVED
,
485 .data
.graph_port_removed
= {
491 append_event(&event
);
495 void graph_ports_connected(struct bt_port
*upstream_port
,
496 struct bt_port
*downstream_port
, void *data
)
498 struct bt_component
*upstream_comp
=
499 bt_port_get_component(upstream_port
);
500 struct bt_component
*downstream_comp
=
501 bt_port_get_component(downstream_port
);
502 struct bt_connection
*conn
= bt_port_get_connection(upstream_port
);
504 assert(upstream_comp
);
505 assert(downstream_comp
);
507 bt_put(upstream_comp
);
508 bt_put(downstream_comp
);
511 struct event event
= {
512 .type
= GRAPH_PORTS_CONNECTED
,
513 .data
.graph_ports_connected
= {
514 .upstream_comp
= upstream_comp
,
515 .downstream_comp
= downstream_comp
,
516 .upstream_port
= upstream_port
,
517 .downstream_port
= downstream_port
,
522 append_event(&event
);
526 void graph_ports_disconnected(
527 struct bt_component
*upstream_comp
,
528 struct bt_component
*downstream_comp
,
529 struct bt_port
*upstream_port
, struct bt_port
*downstream_port
,
532 struct event event
= {
533 .type
= GRAPH_PORTS_DISCONNECTED
,
534 .data
.graph_ports_disconnected
= {
535 .upstream_comp
= upstream_comp
,
536 .downstream_comp
= downstream_comp
,
537 .upstream_port
= upstream_port
,
538 .downstream_port
= downstream_port
,
542 append_event(&event
);
550 src_comp_class
= bt_component_class_source_create("src", src_iter_next
);
551 assert(src_comp_class
);
552 ret
= bt_component_class_set_init_method(src_comp_class
, src_init
);
554 ret
= bt_component_class_set_accept_port_connection_method(
555 src_comp_class
, accept_port_connection
);
557 ret
= bt_component_class_set_port_connected_method(src_comp_class
,
560 ret
= bt_component_class_set_port_disconnected_method(
561 src_comp_class
, src_port_disconnected
);
563 sink_comp_class
= bt_component_class_sink_create("sink", sink_consume
);
564 assert(sink_comp_class
);
565 ret
= bt_component_class_set_init_method(sink_comp_class
, sink_init
);
567 ret
= bt_component_class_set_accept_port_connection_method(
568 sink_comp_class
, accept_port_connection
);
570 ret
= bt_component_class_set_port_connected_method(sink_comp_class
,
571 sink_port_connected
);
573 ret
= bt_component_class_set_port_disconnected_method(sink_comp_class
,
574 sink_port_disconnected
);
576 bt_component_class_freeze(src_comp_class
);
577 bt_component_class_freeze(sink_comp_class
);
578 events
= g_array_new(FALSE
, TRUE
, sizeof(struct event
));
585 bt_put(src_comp_class
);
586 bt_put(sink_comp_class
);
587 g_array_free(events
, TRUE
);
591 struct bt_component
*create_src(void)
593 struct bt_component
*comp
=
594 bt_component_create(src_comp_class
, "src-comp", NULL
);
601 struct bt_component
*create_sink(void)
603 struct bt_component
*comp
=
604 bt_component_create(sink_comp_class
, "sink-comp", NULL
);
611 struct bt_graph
*create_graph(void)
613 struct bt_graph
*graph
= bt_graph_create();
617 ret
= bt_graph_add_port_added_listener(graph
, graph_port_added
, NULL
);
619 ret
= bt_graph_add_port_removed_listener(graph
, graph_port_removed
,
622 ret
= bt_graph_add_ports_connected_listener(graph
, graph_ports_connected
,
625 ret
= bt_graph_add_ports_disconnected_listener(graph
,
626 graph_ports_disconnected
, NULL
);
632 void prepare_test(enum test test
, const char *name
)
636 diag("test: %s", name
);
640 void test_sink_removes_port_in_port_connected_then_src_removes_disconnected_port(void)
643 struct bt_component
*src
;
644 struct bt_component
*sink
;
645 struct bt_graph
*graph
;
646 struct bt_port
*src_def_port
;
647 struct bt_port
*sink_def_port
;
648 struct bt_connection
*conn
;
650 enum bt_graph_status status
;
651 size_t src_accept_port_connection_pos
;
652 size_t sink_accept_port_connection_pos
;
653 size_t src_port_connected_pos
;
654 size_t sink_port_connected_pos
;
655 size_t graph_ports_connected
;
656 size_t src_port_disconnected_pos
;
657 size_t sink_port_disconnected_pos
;
658 size_t graph_ports_disconnected_pos
;
659 size_t graph_port_removed_src_pos
;
660 size_t graph_port_removed_sink_pos
;
662 prepare_test(TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT
,
663 "sink removes port in consume, then source removes disconnected port");
665 sink
= create_sink();
666 graph
= create_graph();
667 src_def_port
= bt_component_source_get_output_port_by_name(src
, "out");
668 assert(src_def_port
);
669 sink_def_port
= bt_component_sink_get_input_port_by_name(sink
, "in");
670 assert(sink_def_port
);
671 status
= bt_graph_connect_ports(graph
, src_def_port
, sink_def_port
,
676 /* We're supposed to have 5 events so far */
677 ok(events
->len
== 5, "we have the expected number of events (before consume)");
679 /* Source's accept port connection */
680 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
681 event
.data
.comp_accept_port_connection
.comp
= src
;
682 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
683 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
684 ok(has_event(&event
), "got the expected source's accept port connection event");
685 src_accept_port_connection_pos
= event_pos(&event
);
687 /* Sink's accept port connection */
688 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
689 event
.data
.comp_accept_port_connection
.comp
= sink
;
690 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
691 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
692 ok(has_event(&event
), "got the expected sink's accept port connection event");
693 sink_accept_port_connection_pos
= event_pos(&event
);
695 /* Source's port connected */
696 event
.type
= COMP_PORT_CONNECTED
;
697 event
.data
.comp_port_connected
.comp
= src
;
698 event
.data
.comp_port_connected
.self_port
= src_def_port
;
699 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
700 ok(has_event(&event
), "got the expected source's port connected event");
701 src_port_connected_pos
= event_pos(&event
);
703 /* Sink's port connected */
704 event
.type
= COMP_PORT_CONNECTED
;
705 event
.data
.comp_port_connected
.comp
= sink
;
706 event
.data
.comp_port_connected
.self_port
= sink_def_port
;
707 event
.data
.comp_port_connected
.other_port
= src_def_port
;
708 ok(has_event(&event
), "got the expected sink's port connected event");
709 sink_port_connected_pos
= event_pos(&event
);
711 /* Graph's ports connected */
712 event
.type
= GRAPH_PORTS_CONNECTED
;
713 event
.data
.graph_ports_connected
.upstream_comp
= src
;
714 event
.data
.graph_ports_connected
.downstream_comp
= sink
;
715 event
.data
.graph_ports_connected
.upstream_port
= src_def_port
;
716 event
.data
.graph_ports_connected
.downstream_port
= sink_def_port
;
717 event
.data
.graph_ports_connected
.conn
= conn
;
718 ok(has_event(&event
), "got the expected graph's ports connected event");
719 graph_ports_connected
= event_pos(&event
);
721 /* Order of events */
722 ok(src_port_connected_pos
< graph_ports_connected
,
723 "event order is good (1)");
724 ok(sink_port_connected_pos
< graph_ports_connected
,
725 "event order is good (2)");
726 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
727 "event order is good (3)");
728 ok(sink_accept_port_connection_pos
< sink_port_connected_pos
,
729 "event order is good (4)");
731 /* Consume sink once */
733 ret
= bt_graph_consume(graph
);
736 /* We're supposed to have 5 new events */
737 ok(events
->len
== 5, "we have the expected number of events (after consume)");
739 /* Source's port disconnected */
740 event
.type
= COMP_PORT_DISCONNECTED
;
741 event
.data
.comp_port_disconnected
.comp
= src
;
742 event
.data
.comp_port_disconnected
.port
= src_def_port
;
743 ok(has_event(&event
), "got the expected source's port disconnected event");
744 src_port_disconnected_pos
= event_pos(&event
);
746 /* Sink's port disconnected */
747 event
.type
= COMP_PORT_DISCONNECTED
;
748 event
.data
.comp_port_disconnected
.comp
= sink
;
749 event
.data
.comp_port_disconnected
.port
= sink_def_port
;
750 ok(has_event(&event
), "got the expected sink's port disconnected event");
751 sink_port_disconnected_pos
= event_pos(&event
);
753 /* Graph's ports disconnected */
754 event
.type
= GRAPH_PORTS_DISCONNECTED
;
755 event
.data
.graph_ports_disconnected
.upstream_comp
= src
;
756 event
.data
.graph_ports_disconnected
.downstream_comp
= sink
;
757 event
.data
.graph_ports_disconnected
.upstream_port
= src_def_port
;
758 event
.data
.graph_ports_disconnected
.downstream_port
= sink_def_port
;
759 ok(has_event(&event
), "got the expected graph's ports disconnected event");
760 graph_ports_disconnected_pos
= event_pos(&event
);
762 /* Graph's port removed (sink) */
763 event
.type
= GRAPH_PORT_REMOVED
;
764 event
.data
.graph_port_removed
.comp
= sink
;
765 event
.data
.graph_port_removed
.port
= sink_def_port
;
766 ok(has_event(&event
), "got the expected graph's port removed event (for sink)");
767 graph_port_removed_sink_pos
= event_pos(&event
);
769 /* Graph's port removed (source) */
770 event
.type
= GRAPH_PORT_REMOVED
;
771 event
.data
.graph_port_removed
.comp
= src
;
772 event
.data
.graph_port_removed
.port
= src_def_port
;
773 ok(has_event(&event
), "got the expected graph's port removed event (for source)");
774 graph_port_removed_src_pos
= event_pos(&event
);
776 /* Order of events */
777 ok(src_port_disconnected_pos
< graph_ports_disconnected_pos
,
778 "event order is good (5)");
779 ok(src_port_disconnected_pos
< graph_port_removed_sink_pos
,
780 "event order is good (6)");
781 ok(src_port_disconnected_pos
< graph_port_removed_src_pos
,
782 "event order is good (7)");
783 ok(sink_port_disconnected_pos
< graph_ports_disconnected_pos
,
784 "event order is good (8)");
785 ok(sink_port_disconnected_pos
< graph_port_removed_sink_pos
,
786 "event order is good (9)");
787 ok(sink_port_disconnected_pos
< graph_port_removed_src_pos
,
788 "event order is good (10)");
789 ok(graph_ports_disconnected_pos
< graph_port_removed_sink_pos
,
790 "event order is good (11)");
791 ok(graph_port_removed_src_pos
< graph_ports_disconnected_pos
,
792 "event order is good (12)");
793 ok(graph_port_removed_src_pos
< graph_port_removed_sink_pos
,
794 "event order is good (13)");
800 bt_put(src_def_port
);
801 bt_put(sink_def_port
);
805 void test_sink_removes_port_in_port_connected(void)
808 struct bt_component
*src
;
809 struct bt_component
*sink
;
810 struct bt_graph
*graph
;
811 struct bt_port
*src_def_port
;
812 struct bt_port
*sink_def_port
;
813 struct bt_connection
*conn
;
815 enum bt_graph_status status
;
816 size_t src_accept_port_connection_pos
;
817 size_t sink_accept_port_connection_pos
;
818 size_t src_port_connected_pos
;
819 size_t sink_port_connected_pos
;
820 size_t graph_ports_connected_pos
;
821 size_t src_port_disconnected_pos
;
822 size_t sink_port_disconnected_pos
;
823 size_t graph_ports_disconnected_pos
;
824 size_t graph_port_removed_sink_pos
;
826 prepare_test(TEST_SINK_REMOVES_PORT_IN_CONSUME
,
827 "sink removes port in consume");
829 sink
= create_sink();
830 graph
= create_graph();
831 src_def_port
= bt_component_source_get_output_port_by_name(src
, "out");
832 assert(src_def_port
);
833 sink_def_port
= bt_component_sink_get_input_port_by_name(sink
, "in");
834 assert(sink_def_port
);
835 status
= bt_graph_connect_ports(graph
, src_def_port
, sink_def_port
,
839 /* We're supposed to have 5 events so far */
840 ok(events
->len
== 5, "we have the expected number of events (before consume)");
842 /* Source's accept port connection */
843 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
844 event
.data
.comp_accept_port_connection
.comp
= src
;
845 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
846 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
847 ok(has_event(&event
), "got the expected source's accept port connection event");
848 src_accept_port_connection_pos
= event_pos(&event
);
850 /* Sink's accept port connection */
851 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
852 event
.data
.comp_accept_port_connection
.comp
= sink
;
853 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
854 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
855 ok(has_event(&event
), "got the expected sink's accept port connection event");
856 sink_accept_port_connection_pos
= event_pos(&event
);
858 /* Source's port connected */
859 event
.type
= COMP_PORT_CONNECTED
;
860 event
.data
.comp_port_connected
.comp
= src
;
861 event
.data
.comp_port_connected
.self_port
= src_def_port
;
862 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
863 ok(has_event(&event
), "got the expected source's port connected event");
864 src_port_connected_pos
= event_pos(&event
);
866 /* Sink's port connected */
867 event
.type
= COMP_PORT_CONNECTED
;
868 event
.data
.comp_port_connected
.comp
= sink
;
869 event
.data
.comp_port_connected
.self_port
= sink_def_port
;
870 event
.data
.comp_port_connected
.other_port
= src_def_port
;
871 ok(has_event(&event
), "got the expected sink's port connected event");
872 sink_port_connected_pos
= event_pos(&event
);
874 /* Graph's ports connected */
875 event
.type
= GRAPH_PORTS_CONNECTED
;
876 event
.data
.graph_ports_connected
.upstream_comp
= src
;
877 event
.data
.graph_ports_connected
.downstream_comp
= sink
;
878 event
.data
.graph_ports_connected
.upstream_port
= src_def_port
;
879 event
.data
.graph_ports_connected
.downstream_port
= sink_def_port
;
880 event
.data
.graph_ports_connected
.conn
= conn
;
881 ok(has_event(&event
), "got the expected graph's ports connected event");
882 graph_ports_connected_pos
= event_pos(&event
);
884 /* Order of events */
885 ok(src_port_connected_pos
< graph_ports_connected_pos
,
886 "event order is good (1)");
887 ok(sink_port_connected_pos
< graph_ports_connected_pos
,
888 "event order is good (2)");
889 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
890 "event order is good (3)");
891 ok(sink_accept_port_connection_pos
< sink_port_connected_pos
,
892 "event order is good (4)");
894 /* Consume sink once */
896 ret
= bt_graph_consume(graph
);
899 /* We're supposed to have 4 new events */
900 ok(events
->len
== 4, "we have the expected number of events (after consume)");
902 /* Source's port disconnected */
903 event
.type
= COMP_PORT_DISCONNECTED
;
904 event
.data
.comp_port_disconnected
.comp
= src
;
905 event
.data
.comp_port_disconnected
.port
= src_def_port
;
906 ok(has_event(&event
), "got the expected source's port disconnected event");
907 src_port_disconnected_pos
= event_pos(&event
);
909 /* Sink's port disconnected */
910 event
.type
= COMP_PORT_DISCONNECTED
;
911 event
.data
.comp_port_disconnected
.comp
= sink
;
912 event
.data
.comp_port_disconnected
.port
= sink_def_port
;
913 ok(has_event(&event
), "got the expected sink's port disconnected event");
914 sink_port_disconnected_pos
= event_pos(&event
);
916 /* Graph's ports disconnected */
917 event
.type
= GRAPH_PORTS_DISCONNECTED
;
918 event
.data
.graph_ports_disconnected
.upstream_comp
= src
;
919 event
.data
.graph_ports_disconnected
.downstream_comp
= sink
;
920 event
.data
.graph_ports_disconnected
.upstream_port
= src_def_port
;
921 event
.data
.graph_ports_disconnected
.downstream_port
= sink_def_port
;
922 ok(has_event(&event
), "got the expected graph's ports disconnected event");
923 graph_ports_disconnected_pos
= event_pos(&event
);
925 /* Graph's port removed (sink) */
926 event
.type
= GRAPH_PORT_REMOVED
;
927 event
.data
.graph_port_removed
.comp
= sink
;
928 event
.data
.graph_port_removed
.port
= sink_def_port
;
929 ok(has_event(&event
), "got the expected graph's port removed event (for sink)");
930 graph_port_removed_sink_pos
= event_pos(&event
);
932 /* Order of events */
933 ok(src_port_disconnected_pos
< graph_ports_disconnected_pos
,
934 "event order is good (5)");
935 ok(src_port_disconnected_pos
< graph_port_removed_sink_pos
,
936 "event order is good (7)");
937 ok(sink_port_disconnected_pos
< graph_ports_disconnected_pos
,
938 "event order is good (8)");
939 ok(sink_port_disconnected_pos
< graph_port_removed_sink_pos
,
940 "event order is good (10)");
941 ok(graph_ports_disconnected_pos
< graph_port_removed_sink_pos
,
942 "event order is good (11)");
948 bt_put(src_def_port
);
949 bt_put(sink_def_port
);
953 void test_src_adds_port_in_port_connected(void)
955 struct bt_component
*src
;
956 struct bt_component
*sink
;
957 struct bt_graph
*graph
;
958 struct bt_port
*src_def_port
;
959 struct bt_port
*sink_def_port
;
960 struct bt_port
*src_hello_port
;
961 struct bt_connection
*conn
;
963 enum bt_graph_status status
;
964 size_t src_accept_port_connection_pos
;
965 size_t sink_accept_port_connection_pos
;
966 size_t src_port_connected_pos
;
967 size_t sink_port_connected_pos
;
968 size_t graph_ports_connected_pos
;
969 size_t graph_port_added_src_pos
;
971 prepare_test(TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED
,
972 "source adds port in port connected");
974 sink
= create_sink();
975 graph
= create_graph();
976 src_def_port
= bt_component_source_get_output_port_by_name(src
, "out");
977 assert(src_def_port
);
978 sink_def_port
= bt_component_sink_get_input_port_by_name(sink
, "in");
979 assert(sink_def_port
);
980 status
= bt_graph_connect_ports(graph
, src_def_port
, sink_def_port
,
983 src_hello_port
= bt_component_source_get_output_port_by_name(src
,
985 assert(src_hello_port
);
987 /* We're supposed to have 6 events */
988 ok(events
->len
== 6, "we have the expected number of events");
990 /* Source's accept port connection */
991 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
992 event
.data
.comp_accept_port_connection
.comp
= src
;
993 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
994 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
995 ok(has_event(&event
), "got the expected source's accept port connection event");
996 src_accept_port_connection_pos
= event_pos(&event
);
998 /* Sink's accept port connection */
999 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1000 event
.data
.comp_accept_port_connection
.comp
= sink
;
1001 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
1002 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
1003 ok(has_event(&event
), "got the expected sink's accept port connection event");
1004 sink_accept_port_connection_pos
= event_pos(&event
);
1006 /* Source's port connected */
1007 event
.type
= COMP_PORT_CONNECTED
;
1008 event
.data
.comp_port_connected
.comp
= src
;
1009 event
.data
.comp_port_connected
.self_port
= src_def_port
;
1010 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
1011 ok(has_event(&event
), "got the expected source's port connected event");
1012 src_port_connected_pos
= event_pos(&event
);
1014 /* Graph's port added (source) */
1015 event
.type
= GRAPH_PORT_ADDED
;
1016 event
.data
.graph_port_added
.comp
= src
;
1017 event
.data
.graph_port_added
.port
= src_hello_port
;
1018 ok(has_event(&event
), "got the expected graph's port added event (for source)");
1019 graph_port_added_src_pos
= event_pos(&event
);
1021 /* Sink's port connected */
1022 event
.type
= COMP_PORT_CONNECTED
;
1023 event
.data
.comp_port_connected
.comp
= sink
;
1024 event
.data
.comp_port_connected
.self_port
= sink_def_port
;
1025 event
.data
.comp_port_connected
.other_port
= src_def_port
;
1026 ok(has_event(&event
), "got the expected sink's port connected event");
1027 sink_port_connected_pos
= event_pos(&event
);
1029 /* Graph's ports connected */
1030 event
.type
= GRAPH_PORTS_CONNECTED
;
1031 event
.data
.graph_ports_connected
.upstream_comp
= src
;
1032 event
.data
.graph_ports_connected
.downstream_comp
= sink
;
1033 event
.data
.graph_ports_connected
.upstream_port
= src_def_port
;
1034 event
.data
.graph_ports_connected
.downstream_port
= sink_def_port
;
1035 event
.data
.graph_ports_connected
.conn
= conn
;
1036 ok(has_event(&event
), "got the expected graph's port connected event (for source)");
1037 graph_ports_connected_pos
= event_pos(&event
);
1039 /* Order of events */
1040 ok(src_port_connected_pos
< graph_ports_connected_pos
,
1041 "event order is good (1)");
1042 ok(sink_port_connected_pos
< graph_ports_connected_pos
,
1043 "event order is good (2)");
1044 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
1045 "event order is good (3)");
1046 ok(sink_accept_port_connection_pos
< sink_port_connected_pos
,
1047 "event order is good (4)");
1048 ok(src_port_connected_pos
< graph_port_added_src_pos
,
1049 "event order is good (5)");
1050 ok(graph_port_added_src_pos
< graph_ports_connected_pos
,
1051 "event order is good (6)");
1057 bt_put(src_def_port
);
1058 bt_put(sink_def_port
);
1059 bt_put(src_hello_port
);
1063 void test_simple(void)
1065 struct bt_component
*src
;
1066 struct bt_component
*sink
;
1067 struct bt_graph
*graph
;
1068 struct bt_port
*src_def_port
;
1069 struct bt_port
*sink_def_port
;
1070 struct bt_connection
*conn
;
1072 enum bt_graph_status status
;
1073 size_t src_accept_port_connection_pos
;
1074 size_t sink_accept_port_connection_pos
;
1075 size_t src_port_connected_pos
;
1076 size_t sink_port_connected_pos
;
1077 size_t graph_ports_connected_pos
;
1079 prepare_test(TEST_SIMPLE
, "simple");
1081 sink
= create_sink();
1082 graph
= create_graph();
1083 src_def_port
= bt_component_source_get_output_port_by_name(src
, "out");
1084 assert(src_def_port
);
1085 sink_def_port
= bt_component_sink_get_input_port_by_name(sink
, "in");
1086 assert(sink_def_port
);
1087 status
= bt_graph_connect_ports(graph
, src_def_port
, sink_def_port
,
1089 assert(status
== 0);
1091 /* We're supposed to have 5 events */
1092 ok(events
->len
== 5, "we have the expected number of events");
1094 /* Source's accept port connection */
1095 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1096 event
.data
.comp_accept_port_connection
.comp
= src
;
1097 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
1098 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
1099 ok(has_event(&event
), "got the expected source's accept port connection event");
1100 src_accept_port_connection_pos
= event_pos(&event
);
1102 /* Sink's accept port connection */
1103 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1104 event
.data
.comp_accept_port_connection
.comp
= sink
;
1105 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
1106 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
1107 ok(has_event(&event
), "got the expected sink's accept port connection event");
1108 sink_accept_port_connection_pos
= event_pos(&event
);
1110 /* Source's port connected */
1111 event
.type
= COMP_PORT_CONNECTED
;
1112 event
.data
.comp_port_connected
.comp
= src
;
1113 event
.data
.comp_port_connected
.self_port
= src_def_port
;
1114 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
1115 ok(has_event(&event
), "got the expected source's port connected event");
1116 src_port_connected_pos
= event_pos(&event
);
1118 /* Sink's port connected */
1119 event
.type
= COMP_PORT_CONNECTED
;
1120 event
.data
.comp_port_connected
.comp
= sink
;
1121 event
.data
.comp_port_connected
.self_port
= sink_def_port
;
1122 event
.data
.comp_port_connected
.other_port
= src_def_port
;
1123 ok(has_event(&event
), "got the expected sink's port connected event");
1124 sink_port_connected_pos
= event_pos(&event
);
1126 /* Graph's port connected */
1127 event
.type
= GRAPH_PORTS_CONNECTED
;
1128 event
.data
.graph_ports_connected
.upstream_comp
= src
;
1129 event
.data
.graph_ports_connected
.downstream_comp
= sink
;
1130 event
.data
.graph_ports_connected
.upstream_port
= src_def_port
;
1131 event
.data
.graph_ports_connected
.downstream_port
= sink_def_port
;
1132 event
.data
.graph_ports_connected
.conn
= conn
;
1133 ok(has_event(&event
), "got the expected graph's ports connected event");
1134 graph_ports_connected_pos
= event_pos(&event
);
1136 /* Order of events */
1137 ok(src_port_connected_pos
< graph_ports_connected_pos
,
1138 "event order is good (1)");
1139 ok(sink_port_connected_pos
< graph_ports_connected_pos
,
1140 "event order is good (2)");
1141 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
1142 "event order is good (3)");
1143 ok(sink_accept_port_connection_pos
< sink_port_connected_pos
,
1144 "event order is good (4)");
1150 bt_put(src_def_port
);
1151 bt_put(sink_def_port
);
1155 void test_empty_graph(void)
1157 struct bt_graph
*graph
;
1159 prepare_test(TEST_EMPTY_GRAPH
, "empty graph");
1160 graph
= create_graph();
1161 ok(events
->len
== 0, "empty graph generates no events");
1165 int main(int argc
, char **argv
)
1167 plan_tests(NR_TESTS
);
1171 test_src_adds_port_in_port_connected();
1172 test_sink_removes_port_in_port_connected();
1173 test_sink_removes_port_in_port_connected_then_src_removes_disconnected_port();
1175 return exit_status();