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/object.h>
21 #include <babeltrace/graph/component-class.h>
22 #include <babeltrace/graph/component-class-source.h>
23 #include <babeltrace/graph/component-class-sink.h>
24 #include <babeltrace/graph/component.h>
25 #include <babeltrace/graph/component-source.h>
26 #include <babeltrace/graph/component-sink.h>
27 #include <babeltrace/graph/private-graph.h>
28 #include <babeltrace/graph/graph.h>
29 #include <babeltrace/graph/connection.h>
30 #include <babeltrace/graph/port.h>
31 #include <babeltrace/graph/private-component.h>
32 #include <babeltrace/graph/private-component-source.h>
33 #include <babeltrace/graph/private-component-sink.h>
34 #include <babeltrace/graph/private-port.h>
35 #include <babeltrace/graph/private-connection.h>
39 #include <babeltrace/assert-internal.h>
47 COMP_ACCEPT_PORT_CONNECTION
,
49 COMP_PORT_DISCONNECTED
,
52 GRAPH_PORTS_CONNECTED
,
53 GRAPH_PORTS_DISCONNECTED
,
59 TEST_SRC_PORT_CONNECTED_ERROR
,
60 TEST_SINK_PORT_CONNECTED_ERROR
,
61 TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED
,
62 TEST_SINK_REMOVES_PORT_IN_CONSUME
,
63 TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT
,
71 struct bt_component
*comp
;
72 struct bt_port
*self_port
;
73 struct bt_port
*other_port
;
74 } comp_accept_port_connection
;
77 struct bt_component
*comp
;
78 struct bt_port
*self_port
;
79 struct bt_port
*other_port
;
80 } comp_port_connected
;
83 struct bt_component
*comp
;
85 } comp_port_disconnected
;
88 struct bt_component
*comp
;
93 struct bt_component
*comp
;
98 struct bt_component
*upstream_comp
;
99 struct bt_component
*downstream_comp
;
100 struct bt_port
*upstream_port
;
101 struct bt_port
*downstream_port
;
102 struct bt_connection
*conn
;
103 } graph_ports_connected
;
106 struct bt_component
*upstream_comp
;
107 struct bt_component
*downstream_comp
;
108 struct bt_port
*upstream_port
;
109 struct bt_port
*downstream_port
;
110 } graph_ports_disconnected
;
114 static GArray
*events
;
115 static struct bt_component_class
*src_comp_class
;
116 static struct bt_component_class
*sink_comp_class
;
117 static enum test current_test
;
120 void clear_events(void)
122 g_array_set_size(events
, 0);
126 void append_event(struct event
*event
)
128 g_array_append_val(events
, *event
);
132 bool compare_events(struct event
*ev_a
, struct event
*ev_b
)
134 if (ev_a
->type
!= ev_b
->type
) {
138 switch (ev_a
->type
) {
139 case COMP_ACCEPT_PORT_CONNECTION
:
140 if (ev_a
->data
.comp_accept_port_connection
.comp
!=
141 ev_b
->data
.comp_accept_port_connection
.comp
) {
145 if (ev_a
->data
.comp_accept_port_connection
.self_port
!=
146 ev_b
->data
.comp_accept_port_connection
.self_port
) {
150 if (ev_a
->data
.comp_accept_port_connection
.other_port
!=
151 ev_b
->data
.comp_accept_port_connection
.other_port
) {
155 case COMP_PORT_CONNECTED
:
156 if (ev_a
->data
.comp_port_connected
.comp
!=
157 ev_b
->data
.comp_port_connected
.comp
) {
161 if (ev_a
->data
.comp_port_connected
.self_port
!=
162 ev_b
->data
.comp_port_connected
.self_port
) {
166 if (ev_a
->data
.comp_port_connected
.other_port
!=
167 ev_b
->data
.comp_port_connected
.other_port
) {
171 case COMP_PORT_DISCONNECTED
:
172 if (ev_a
->data
.comp_port_disconnected
.comp
!=
173 ev_b
->data
.comp_port_disconnected
.comp
) {
177 if (ev_a
->data
.comp_port_disconnected
.port
!=
178 ev_b
->data
.comp_port_disconnected
.port
) {
182 case GRAPH_PORT_ADDED
:
183 if (ev_a
->data
.graph_port_added
.comp
!=
184 ev_b
->data
.graph_port_added
.comp
) {
188 if (ev_a
->data
.graph_port_added
.port
!=
189 ev_b
->data
.graph_port_added
.port
) {
193 case GRAPH_PORT_REMOVED
:
194 if (ev_a
->data
.graph_port_removed
.comp
!=
195 ev_b
->data
.graph_port_removed
.comp
) {
199 if (ev_a
->data
.graph_port_removed
.port
!=
200 ev_b
->data
.graph_port_removed
.port
) {
204 case GRAPH_PORTS_CONNECTED
:
205 if (ev_a
->data
.graph_ports_connected
.upstream_comp
!=
206 ev_b
->data
.graph_ports_connected
.upstream_comp
) {
210 if (ev_a
->data
.graph_ports_connected
.downstream_comp
!=
211 ev_b
->data
.graph_ports_connected
.downstream_comp
) {
215 if (ev_a
->data
.graph_ports_connected
.upstream_port
!=
216 ev_b
->data
.graph_ports_connected
.upstream_port
) {
220 if (ev_a
->data
.graph_ports_connected
.downstream_port
!=
221 ev_b
->data
.graph_ports_connected
.downstream_port
) {
225 if (ev_a
->data
.graph_ports_connected
.conn
!=
226 ev_b
->data
.graph_ports_connected
.conn
) {
230 case GRAPH_PORTS_DISCONNECTED
:
231 if (ev_a
->data
.graph_ports_disconnected
.upstream_comp
!=
232 ev_b
->data
.graph_ports_disconnected
.upstream_comp
) {
236 if (ev_a
->data
.graph_ports_disconnected
.downstream_comp
!=
237 ev_b
->data
.graph_ports_disconnected
.downstream_comp
) {
241 if (ev_a
->data
.graph_ports_disconnected
.upstream_port
!=
242 ev_b
->data
.graph_ports_disconnected
.upstream_port
) {
246 if (ev_a
->data
.graph_ports_disconnected
.downstream_port
!=
247 ev_b
->data
.graph_ports_disconnected
.downstream_port
) {
259 bool has_event(struct event
*event
)
263 for (i
= 0; i
< events
->len
; i
++) {
264 struct event
*ev
= &g_array_index(events
, struct event
, i
);
266 if (compare_events(event
, ev
)) {
275 size_t event_pos(struct event
*event
)
279 for (i
= 0; i
< events
->len
; i
++) {
280 struct event
*ev
= &g_array_index(events
, struct event
, i
);
282 if (compare_events(event
, ev
)) {
291 enum bt_notification_iterator_status
src_iter_next(
292 struct bt_private_connection_private_notification_iterator
*priv_iterator
,
293 bt_notification_array notifs
, uint64_t capacity
,
296 return BT_NOTIFICATION_ITERATOR_STATUS_ERROR
;
300 enum bt_component_status
accept_port_connection(
301 struct bt_private_component
*private_component
,
302 struct bt_private_port
*self_private_port
,
303 struct bt_port
*other_port
)
305 struct event event
= {
306 .type
= COMP_ACCEPT_PORT_CONNECTION
,
307 .data
.comp_accept_port_connection
= {
308 .comp
= bt_component_borrow_from_private(private_component
),
309 .self_port
= bt_port_borrow_from_private(self_private_port
),
310 .other_port
= other_port
,
314 append_event(&event
);
315 return BT_COMPONENT_STATUS_OK
;
319 enum bt_component_status
src_port_connected(
320 struct bt_private_component
*private_component
,
321 struct bt_private_port
*self_private_port
,
322 struct bt_port
*other_port
)
326 struct event event
= {
327 .type
= COMP_PORT_CONNECTED
,
328 .data
.comp_port_connected
= {
329 .comp
= bt_component_borrow_from_private(private_component
),
330 .self_port
= bt_port_borrow_from_private(self_private_port
),
331 .other_port
= other_port
,
335 append_event(&event
);
337 switch (current_test
) {
338 case TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED
:
339 ret
= bt_private_component_source_add_output_private_port(
340 private_component
, "hello", NULL
, NULL
);
343 case TEST_SRC_PORT_CONNECTED_ERROR
:
344 return BT_COMPONENT_STATUS_ERROR
;
349 return BT_COMPONENT_STATUS_OK
;
353 void src_port_disconnected(struct bt_private_component
*private_component
,
354 struct bt_private_port
*private_port
)
357 struct event event
= {
358 .type
= COMP_PORT_DISCONNECTED
,
359 .data
.comp_port_disconnected
= {
360 .comp
= bt_component_borrow_from_private(private_component
),
361 .port
= bt_port_borrow_from_private(private_port
),
365 append_event(&event
);
367 switch (current_test
) {
368 case TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT
:
369 ret
= bt_private_port_remove_from_component(private_port
);
377 enum bt_component_status
src_init(struct bt_private_component
*priv_comp
,
378 struct bt_value
*params
, void *init_method_data
)
382 ret
= bt_private_component_source_add_output_private_port(
383 priv_comp
, "out", NULL
, NULL
);
385 return BT_COMPONENT_STATUS_OK
;
389 enum bt_component_status
sink_consume(
390 struct bt_private_component
*priv_component
)
392 struct bt_private_port
*def_port
;
395 switch (current_test
) {
396 case TEST_SINK_REMOVES_PORT_IN_CONSUME
:
397 case TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT
:
398 def_port
= bt_private_component_sink_get_input_private_port_by_name(
399 priv_component
, "in");
401 ret
= bt_private_port_remove_from_component(def_port
);
403 bt_object_put_ref(def_port
);
409 return BT_COMPONENT_STATUS_OK
;
413 enum bt_component_status
sink_port_connected(
414 struct bt_private_component
*private_component
,
415 struct bt_private_port
*self_private_port
,
416 struct bt_port
*other_port
)
418 struct event event
= {
419 .type
= COMP_PORT_CONNECTED
,
420 .data
.comp_port_connected
= {
421 .comp
= bt_component_borrow_from_private(private_component
),
422 .self_port
= bt_port_borrow_from_private(self_private_port
),
423 .other_port
= other_port
,
427 append_event(&event
);
429 if (current_test
== TEST_SINK_PORT_CONNECTED_ERROR
) {
430 return BT_COMPONENT_STATUS_ERROR
;
432 return BT_COMPONENT_STATUS_OK
;
437 void sink_port_disconnected(struct bt_private_component
*private_component
,
438 struct bt_private_port
*private_port
)
440 struct event event
= {
441 .type
= COMP_PORT_DISCONNECTED
,
442 .data
.comp_port_disconnected
= {
443 .comp
= bt_component_borrow_from_private(private_component
),
444 .port
= bt_port_borrow_from_private(private_port
),
448 append_event(&event
);
452 enum bt_component_status
sink_init(struct bt_private_component
*priv_comp
,
453 struct bt_value
*params
, void *init_method_data
)
457 ret
= bt_private_component_sink_add_input_private_port(priv_comp
,
460 return BT_COMPONENT_STATUS_OK
;
464 void graph_port_added(struct bt_port
*port
,
467 struct bt_component
*comp
= bt_port_get_component(port
);
470 bt_object_put_ref(comp
);
472 struct event event
= {
473 .type
= GRAPH_PORT_ADDED
,
474 .data
.graph_port_added
= {
480 append_event(&event
);
484 void graph_port_removed(struct bt_component
*component
,
485 struct bt_port
*port
, void *data
)
487 struct event event
= {
488 .type
= GRAPH_PORT_REMOVED
,
489 .data
.graph_port_removed
= {
495 append_event(&event
);
499 void graph_ports_connected(struct bt_port
*upstream_port
,
500 struct bt_port
*downstream_port
, void *data
)
502 struct bt_component
*upstream_comp
=
503 bt_port_get_component(upstream_port
);
504 struct bt_component
*downstream_comp
=
505 bt_port_get_component(downstream_port
);
506 struct bt_connection
*conn
= bt_port_get_connection(upstream_port
);
508 BT_ASSERT(upstream_comp
);
509 BT_ASSERT(downstream_comp
);
511 bt_object_put_ref(upstream_comp
);
512 bt_object_put_ref(downstream_comp
);
513 bt_object_put_ref(conn
);
515 struct event event
= {
516 .type
= GRAPH_PORTS_CONNECTED
,
517 .data
.graph_ports_connected
= {
518 .upstream_comp
= upstream_comp
,
519 .downstream_comp
= downstream_comp
,
520 .upstream_port
= upstream_port
,
521 .downstream_port
= downstream_port
,
526 append_event(&event
);
530 void graph_ports_disconnected(
531 struct bt_component
*upstream_comp
,
532 struct bt_component
*downstream_comp
,
533 struct bt_port
*upstream_port
, struct bt_port
*downstream_port
,
536 struct event event
= {
537 .type
= GRAPH_PORTS_DISCONNECTED
,
538 .data
.graph_ports_disconnected
= {
539 .upstream_comp
= upstream_comp
,
540 .downstream_comp
= downstream_comp
,
541 .upstream_port
= upstream_port
,
542 .downstream_port
= downstream_port
,
546 append_event(&event
);
554 src_comp_class
= bt_component_class_source_create("src", src_iter_next
);
555 BT_ASSERT(src_comp_class
);
556 ret
= bt_component_class_set_init_method(src_comp_class
, src_init
);
558 ret
= bt_component_class_set_accept_port_connection_method(
559 src_comp_class
, accept_port_connection
);
561 ret
= bt_component_class_set_port_connected_method(src_comp_class
,
564 ret
= bt_component_class_set_port_disconnected_method(
565 src_comp_class
, src_port_disconnected
);
567 sink_comp_class
= bt_component_class_sink_create("sink", sink_consume
);
568 BT_ASSERT(sink_comp_class
);
569 ret
= bt_component_class_set_init_method(sink_comp_class
, sink_init
);
571 ret
= bt_component_class_set_accept_port_connection_method(
572 sink_comp_class
, accept_port_connection
);
574 ret
= bt_component_class_set_port_connected_method(sink_comp_class
,
575 sink_port_connected
);
577 ret
= bt_component_class_set_port_disconnected_method(sink_comp_class
,
578 sink_port_disconnected
);
580 bt_component_class_freeze(src_comp_class
);
581 bt_component_class_freeze(sink_comp_class
);
582 events
= g_array_new(FALSE
, TRUE
, sizeof(struct event
));
589 bt_object_put_ref(src_comp_class
);
590 bt_object_put_ref(sink_comp_class
);
591 g_array_free(events
, TRUE
);
595 struct bt_component
*create_src(struct bt_private_graph
*graph
)
597 struct bt_component
*comp
;
600 ret
= bt_private_graph_add_component(graph
, src_comp_class
, "src-comp", NULL
,
607 struct bt_component
*create_sink(struct bt_private_graph
*graph
)
609 struct bt_component
*comp
;
612 ret
= bt_private_graph_add_component(graph
, sink_comp_class
, "sink-comp",
619 struct bt_private_graph
*create_graph(void)
621 struct bt_private_graph
*graph
= bt_private_graph_create();
625 ret
= bt_private_graph_add_port_added_listener(graph
, graph_port_added
, NULL
,
628 ret
= bt_private_graph_add_port_removed_listener(graph
, graph_port_removed
,
631 ret
= bt_private_graph_add_ports_connected_listener(graph
,
632 graph_ports_connected
, NULL
, NULL
);
634 ret
= bt_private_graph_add_ports_disconnected_listener(graph
,
635 graph_ports_disconnected
, NULL
, NULL
);
641 void prepare_test(enum test test
, const char *name
)
645 diag("test: %s", name
);
649 void test_sink_removes_port_in_port_connected_then_src_removes_disconnected_port(void)
652 struct bt_component
*src
;
653 struct bt_component
*sink
;
654 struct bt_private_graph
*graph
;
655 struct bt_port
*src_def_port
;
656 struct bt_port
*sink_def_port
;
657 struct bt_connection
*conn
;
659 enum bt_graph_status status
;
660 size_t src_accept_port_connection_pos
;
661 size_t sink_accept_port_connection_pos
;
662 size_t src_port_connected_pos
;
663 size_t sink_port_connected_pos
;
664 size_t graph_ports_connected
;
665 size_t src_port_disconnected_pos
;
666 size_t sink_port_disconnected_pos
;
667 size_t graph_ports_disconnected_pos
;
668 size_t graph_port_removed_src_pos
;
669 size_t graph_port_removed_sink_pos
;
671 prepare_test(TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT
,
672 "sink removes port in consume, then source removes disconnected port");
673 graph
= create_graph();
675 src
= create_src(graph
);
676 sink
= create_sink(graph
);
677 src_def_port
= bt_component_source_get_output_port_by_name(src
, "out");
678 BT_ASSERT(src_def_port
);
679 sink_def_port
= bt_component_sink_get_input_port_by_name(sink
, "in");
680 BT_ASSERT(sink_def_port
);
681 status
= bt_private_graph_connect_ports(graph
, src_def_port
, sink_def_port
,
683 BT_ASSERT(status
== 0);
686 /* We're supposed to have 7 events so far */
687 ok(events
->len
== 7, "we have the expected number of events (before consume)");
689 /* Source's port added */
690 event
.type
= GRAPH_PORT_ADDED
;
691 event
.data
.graph_port_added
.comp
= src
;
692 event
.data
.graph_port_added
.port
= src_def_port
;
693 ok(has_event(&event
), "got the expected graph's port added event (for source, initial)");
695 /* Sink's port added */
696 event
.type
= GRAPH_PORT_ADDED
;
697 event
.data
.graph_port_added
.comp
= sink
;
698 event
.data
.graph_port_added
.port
= sink_def_port
;
699 ok(has_event(&event
), "got the expected graph's port added event (for sink, initial)");
701 /* Source's accept port connection */
702 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
703 event
.data
.comp_accept_port_connection
.comp
= src
;
704 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
705 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
706 ok(has_event(&event
), "got the expected source's accept port connection event");
707 src_accept_port_connection_pos
= event_pos(&event
);
709 /* Sink's accept port connection */
710 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
711 event
.data
.comp_accept_port_connection
.comp
= sink
;
712 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
713 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
714 ok(has_event(&event
), "got the expected sink's accept port connection event");
715 sink_accept_port_connection_pos
= event_pos(&event
);
717 /* Source's port connected */
718 event
.type
= COMP_PORT_CONNECTED
;
719 event
.data
.comp_port_connected
.comp
= src
;
720 event
.data
.comp_port_connected
.self_port
= src_def_port
;
721 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
722 ok(has_event(&event
), "got the expected source's port connected event");
723 src_port_connected_pos
= event_pos(&event
);
725 /* Sink's port connected */
726 event
.type
= COMP_PORT_CONNECTED
;
727 event
.data
.comp_port_connected
.comp
= sink
;
728 event
.data
.comp_port_connected
.self_port
= sink_def_port
;
729 event
.data
.comp_port_connected
.other_port
= src_def_port
;
730 ok(has_event(&event
), "got the expected sink's port connected event");
731 sink_port_connected_pos
= event_pos(&event
);
733 /* Graph's ports connected */
734 event
.type
= GRAPH_PORTS_CONNECTED
;
735 event
.data
.graph_ports_connected
.upstream_comp
= src
;
736 event
.data
.graph_ports_connected
.downstream_comp
= sink
;
737 event
.data
.graph_ports_connected
.upstream_port
= src_def_port
;
738 event
.data
.graph_ports_connected
.downstream_port
= sink_def_port
;
739 event
.data
.graph_ports_connected
.conn
= conn
;
740 ok(has_event(&event
), "got the expected graph's ports connected event");
741 graph_ports_connected
= event_pos(&event
);
743 /* Order of events */
744 ok(src_port_connected_pos
< graph_ports_connected
,
745 "event order is good (1)");
746 ok(sink_port_connected_pos
< graph_ports_connected
,
747 "event order is good (2)");
748 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
749 "event order is good (3)");
750 ok(sink_accept_port_connection_pos
< sink_port_connected_pos
,
751 "event order is good (4)");
753 /* Consume sink once */
755 ret
= bt_private_graph_consume(graph
);
758 /* We're supposed to have 5 new events */
759 ok(events
->len
== 5, "we have the expected number of events (after consume)");
761 /* Source's port disconnected */
762 event
.type
= COMP_PORT_DISCONNECTED
;
763 event
.data
.comp_port_disconnected
.comp
= src
;
764 event
.data
.comp_port_disconnected
.port
= src_def_port
;
765 ok(has_event(&event
), "got the expected source's port disconnected event");
766 src_port_disconnected_pos
= event_pos(&event
);
768 /* Sink's port disconnected */
769 event
.type
= COMP_PORT_DISCONNECTED
;
770 event
.data
.comp_port_disconnected
.comp
= sink
;
771 event
.data
.comp_port_disconnected
.port
= sink_def_port
;
772 ok(has_event(&event
), "got the expected sink's port disconnected event");
773 sink_port_disconnected_pos
= event_pos(&event
);
775 /* Graph's ports disconnected */
776 event
.type
= GRAPH_PORTS_DISCONNECTED
;
777 event
.data
.graph_ports_disconnected
.upstream_comp
= src
;
778 event
.data
.graph_ports_disconnected
.downstream_comp
= sink
;
779 event
.data
.graph_ports_disconnected
.upstream_port
= src_def_port
;
780 event
.data
.graph_ports_disconnected
.downstream_port
= sink_def_port
;
781 ok(has_event(&event
), "got the expected graph's ports disconnected event");
782 graph_ports_disconnected_pos
= event_pos(&event
);
784 /* Graph's port removed (sink) */
785 event
.type
= GRAPH_PORT_REMOVED
;
786 event
.data
.graph_port_removed
.comp
= sink
;
787 event
.data
.graph_port_removed
.port
= sink_def_port
;
788 ok(has_event(&event
), "got the expected graph's port removed event (for sink)");
789 graph_port_removed_sink_pos
= event_pos(&event
);
791 /* Graph's port removed (source) */
792 event
.type
= GRAPH_PORT_REMOVED
;
793 event
.data
.graph_port_removed
.comp
= src
;
794 event
.data
.graph_port_removed
.port
= src_def_port
;
795 ok(has_event(&event
), "got the expected graph's port removed event (for source)");
796 graph_port_removed_src_pos
= event_pos(&event
);
798 /* Order of events */
799 ok(src_port_disconnected_pos
< graph_ports_disconnected_pos
,
800 "event order is good (5)");
801 ok(src_port_disconnected_pos
< graph_port_removed_sink_pos
,
802 "event order is good (6)");
803 ok(src_port_disconnected_pos
< graph_port_removed_src_pos
,
804 "event order is good (7)");
805 ok(sink_port_disconnected_pos
< graph_ports_disconnected_pos
,
806 "event order is good (8)");
807 ok(sink_port_disconnected_pos
< graph_port_removed_sink_pos
,
808 "event order is good (9)");
809 ok(sink_port_disconnected_pos
< graph_port_removed_src_pos
,
810 "event order is good (10)");
811 ok(graph_ports_disconnected_pos
< graph_port_removed_sink_pos
,
812 "event order is good (11)");
813 ok(graph_port_removed_src_pos
< graph_ports_disconnected_pos
,
814 "event order is good (12)");
815 ok(graph_port_removed_src_pos
< graph_port_removed_sink_pos
,
816 "event order is good (13)");
818 bt_object_put_ref(graph
);
819 bt_object_put_ref(sink
);
820 bt_object_put_ref(src
);
821 bt_object_put_ref(conn
);
822 bt_object_put_ref(src_def_port
);
823 bt_object_put_ref(sink_def_port
);
827 void test_sink_removes_port_in_port_connected(void)
830 struct bt_component
*src
;
831 struct bt_component
*sink
;
832 struct bt_private_graph
*graph
;
833 struct bt_port
*src_def_port
;
834 struct bt_port
*sink_def_port
;
835 struct bt_connection
*conn
;
837 enum bt_graph_status status
;
838 size_t src_accept_port_connection_pos
;
839 size_t sink_accept_port_connection_pos
;
840 size_t src_port_connected_pos
;
841 size_t sink_port_connected_pos
;
842 size_t graph_ports_connected_pos
;
843 size_t src_port_disconnected_pos
;
844 size_t sink_port_disconnected_pos
;
845 size_t graph_ports_disconnected_pos
;
846 size_t graph_port_removed_sink_pos
;
848 prepare_test(TEST_SINK_REMOVES_PORT_IN_CONSUME
,
849 "sink removes port in consume");
850 graph
= create_graph();
852 src
= create_src(graph
);
853 sink
= create_sink(graph
);
854 src_def_port
= bt_component_source_get_output_port_by_name(src
, "out");
855 BT_ASSERT(src_def_port
);
856 sink_def_port
= bt_component_sink_get_input_port_by_name(sink
, "in");
857 BT_ASSERT(sink_def_port
);
858 status
= bt_private_graph_connect_ports(graph
, src_def_port
, sink_def_port
,
860 BT_ASSERT(status
== 0);
862 /* We're supposed to have 7 events so far */
863 ok(events
->len
== 7, "we have the expected number of events (before consume)");
865 /* Source's port added */
866 event
.type
= GRAPH_PORT_ADDED
;
867 event
.data
.graph_port_added
.comp
= src
;
868 event
.data
.graph_port_added
.port
= src_def_port
;
869 ok(has_event(&event
), "got the expected graph's port added event (for source, initial)");
871 /* Sink's port added */
872 event
.type
= GRAPH_PORT_ADDED
;
873 event
.data
.graph_port_added
.comp
= sink
;
874 event
.data
.graph_port_added
.port
= sink_def_port
;
875 ok(has_event(&event
), "got the expected graph's port added event (for sink, initial)");
877 /* Source's accept port connection */
878 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
879 event
.data
.comp_accept_port_connection
.comp
= src
;
880 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
881 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
882 ok(has_event(&event
), "got the expected source's accept port connection event");
883 src_accept_port_connection_pos
= event_pos(&event
);
885 /* Sink's accept port connection */
886 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
887 event
.data
.comp_accept_port_connection
.comp
= sink
;
888 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
889 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
890 ok(has_event(&event
), "got the expected sink's accept port connection event");
891 sink_accept_port_connection_pos
= event_pos(&event
);
893 /* Source's port connected */
894 event
.type
= COMP_PORT_CONNECTED
;
895 event
.data
.comp_port_connected
.comp
= src
;
896 event
.data
.comp_port_connected
.self_port
= src_def_port
;
897 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
898 ok(has_event(&event
), "got the expected source's port connected event");
899 src_port_connected_pos
= event_pos(&event
);
901 /* Sink's port connected */
902 event
.type
= COMP_PORT_CONNECTED
;
903 event
.data
.comp_port_connected
.comp
= sink
;
904 event
.data
.comp_port_connected
.self_port
= sink_def_port
;
905 event
.data
.comp_port_connected
.other_port
= src_def_port
;
906 ok(has_event(&event
), "got the expected sink's port connected event");
907 sink_port_connected_pos
= event_pos(&event
);
909 /* Graph's ports connected */
910 event
.type
= GRAPH_PORTS_CONNECTED
;
911 event
.data
.graph_ports_connected
.upstream_comp
= src
;
912 event
.data
.graph_ports_connected
.downstream_comp
= sink
;
913 event
.data
.graph_ports_connected
.upstream_port
= src_def_port
;
914 event
.data
.graph_ports_connected
.downstream_port
= sink_def_port
;
915 event
.data
.graph_ports_connected
.conn
= conn
;
916 ok(has_event(&event
), "got the expected graph's ports connected event");
917 graph_ports_connected_pos
= event_pos(&event
);
919 /* Order of events */
920 ok(src_port_connected_pos
< graph_ports_connected_pos
,
921 "event order is good (1)");
922 ok(sink_port_connected_pos
< graph_ports_connected_pos
,
923 "event order is good (2)");
924 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
925 "event order is good (3)");
926 ok(sink_accept_port_connection_pos
< sink_port_connected_pos
,
927 "event order is good (4)");
929 /* Consume sink once */
931 ret
= bt_private_graph_consume(graph
);
934 /* We're supposed to have 4 new events */
935 ok(events
->len
== 4, "we have the expected number of events (after consume)");
937 /* Source's port disconnected */
938 event
.type
= COMP_PORT_DISCONNECTED
;
939 event
.data
.comp_port_disconnected
.comp
= src
;
940 event
.data
.comp_port_disconnected
.port
= src_def_port
;
941 ok(has_event(&event
), "got the expected source's port disconnected event");
942 src_port_disconnected_pos
= event_pos(&event
);
944 /* Sink's port disconnected */
945 event
.type
= COMP_PORT_DISCONNECTED
;
946 event
.data
.comp_port_disconnected
.comp
= sink
;
947 event
.data
.comp_port_disconnected
.port
= sink_def_port
;
948 ok(has_event(&event
), "got the expected sink's port disconnected event");
949 sink_port_disconnected_pos
= event_pos(&event
);
951 /* Graph's ports disconnected */
952 event
.type
= GRAPH_PORTS_DISCONNECTED
;
953 event
.data
.graph_ports_disconnected
.upstream_comp
= src
;
954 event
.data
.graph_ports_disconnected
.downstream_comp
= sink
;
955 event
.data
.graph_ports_disconnected
.upstream_port
= src_def_port
;
956 event
.data
.graph_ports_disconnected
.downstream_port
= sink_def_port
;
957 ok(has_event(&event
), "got the expected graph's ports disconnected event");
958 graph_ports_disconnected_pos
= event_pos(&event
);
960 /* Graph's port removed (sink) */
961 event
.type
= GRAPH_PORT_REMOVED
;
962 event
.data
.graph_port_removed
.comp
= sink
;
963 event
.data
.graph_port_removed
.port
= sink_def_port
;
964 ok(has_event(&event
), "got the expected graph's port removed event (for sink)");
965 graph_port_removed_sink_pos
= event_pos(&event
);
967 /* Order of events */
968 ok(src_port_disconnected_pos
< graph_ports_disconnected_pos
,
969 "event order is good (5)");
970 ok(src_port_disconnected_pos
< graph_port_removed_sink_pos
,
971 "event order is good (7)");
972 ok(sink_port_disconnected_pos
< graph_ports_disconnected_pos
,
973 "event order is good (8)");
974 ok(sink_port_disconnected_pos
< graph_port_removed_sink_pos
,
975 "event order is good (10)");
976 ok(graph_ports_disconnected_pos
< graph_port_removed_sink_pos
,
977 "event order is good (11)");
979 bt_object_put_ref(graph
);
980 bt_object_put_ref(sink
);
981 bt_object_put_ref(src
);
982 bt_object_put_ref(conn
);
983 bt_object_put_ref(src_def_port
);
984 bt_object_put_ref(sink_def_port
);
988 void test_src_adds_port_in_port_connected(void)
990 struct bt_component
*src
;
991 struct bt_component
*sink
;
992 struct bt_private_graph
*graph
;
993 struct bt_port
*src_def_port
;
994 struct bt_port
*sink_def_port
;
995 struct bt_port
*src_hello_port
;
996 struct bt_connection
*conn
;
998 enum bt_graph_status status
;
999 size_t src_accept_port_connection_pos
;
1000 size_t sink_accept_port_connection_pos
;
1001 size_t src_port_connected_pos
;
1002 size_t sink_port_connected_pos
;
1003 size_t graph_ports_connected_pos
;
1004 size_t graph_port_added_src_pos
;
1006 prepare_test(TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED
,
1007 "source adds port in port connected");
1008 graph
= create_graph();
1010 src
= create_src(graph
);
1011 sink
= create_sink(graph
);
1012 src_def_port
= bt_component_source_get_output_port_by_name(src
, "out");
1013 BT_ASSERT(src_def_port
);
1014 sink_def_port
= bt_component_sink_get_input_port_by_name(sink
, "in");
1015 BT_ASSERT(sink_def_port
);
1016 status
= bt_private_graph_connect_ports(graph
, src_def_port
, sink_def_port
,
1018 BT_ASSERT(status
== 0);
1019 src_hello_port
= bt_component_source_get_output_port_by_name(src
,
1021 BT_ASSERT(src_hello_port
);
1023 /* We're supposed to have 8 events */
1024 ok(events
->len
== 8, "we have the expected number of events");
1026 /* Source's port added */
1027 event
.type
= GRAPH_PORT_ADDED
;
1028 event
.data
.graph_port_added
.comp
= src
;
1029 event
.data
.graph_port_added
.port
= src_def_port
;
1030 ok(has_event(&event
), "got the expected graph's port added event (for source, initial)");
1032 /* Sink's port added */
1033 event
.type
= GRAPH_PORT_ADDED
;
1034 event
.data
.graph_port_added
.comp
= sink
;
1035 event
.data
.graph_port_added
.port
= sink_def_port
;
1036 ok(has_event(&event
), "got the expected graph's port added event (for sink, initial)");
1038 /* Source's accept port connection */
1039 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1040 event
.data
.comp_accept_port_connection
.comp
= src
;
1041 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
1042 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
1043 ok(has_event(&event
), "got the expected source's accept port connection event");
1044 src_accept_port_connection_pos
= event_pos(&event
);
1046 /* Sink's accept port connection */
1047 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1048 event
.data
.comp_accept_port_connection
.comp
= sink
;
1049 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
1050 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
1051 ok(has_event(&event
), "got the expected sink's accept port connection event");
1052 sink_accept_port_connection_pos
= event_pos(&event
);
1054 /* Source's port connected */
1055 event
.type
= COMP_PORT_CONNECTED
;
1056 event
.data
.comp_port_connected
.comp
= src
;
1057 event
.data
.comp_port_connected
.self_port
= src_def_port
;
1058 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
1059 ok(has_event(&event
), "got the expected source's port connected event");
1060 src_port_connected_pos
= event_pos(&event
);
1062 /* Graph's port added (source) */
1063 event
.type
= GRAPH_PORT_ADDED
;
1064 event
.data
.graph_port_added
.comp
= src
;
1065 event
.data
.graph_port_added
.port
= src_hello_port
;
1066 ok(has_event(&event
), "got the expected graph's port added event (for source)");
1067 graph_port_added_src_pos
= event_pos(&event
);
1069 /* Sink's port connected */
1070 event
.type
= COMP_PORT_CONNECTED
;
1071 event
.data
.comp_port_connected
.comp
= sink
;
1072 event
.data
.comp_port_connected
.self_port
= sink_def_port
;
1073 event
.data
.comp_port_connected
.other_port
= src_def_port
;
1074 ok(has_event(&event
), "got the expected sink's port connected event");
1075 sink_port_connected_pos
= event_pos(&event
);
1077 /* Graph's ports connected */
1078 event
.type
= GRAPH_PORTS_CONNECTED
;
1079 event
.data
.graph_ports_connected
.upstream_comp
= src
;
1080 event
.data
.graph_ports_connected
.downstream_comp
= sink
;
1081 event
.data
.graph_ports_connected
.upstream_port
= src_def_port
;
1082 event
.data
.graph_ports_connected
.downstream_port
= sink_def_port
;
1083 event
.data
.graph_ports_connected
.conn
= conn
;
1084 ok(has_event(&event
), "got the expected graph's port connected event (for source)");
1085 graph_ports_connected_pos
= event_pos(&event
);
1087 /* Order of events */
1088 ok(src_port_connected_pos
< graph_ports_connected_pos
,
1089 "event order is good (1)");
1090 ok(sink_port_connected_pos
< graph_ports_connected_pos
,
1091 "event order is good (2)");
1092 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
1093 "event order is good (3)");
1094 ok(sink_accept_port_connection_pos
< sink_port_connected_pos
,
1095 "event order is good (4)");
1096 ok(src_port_connected_pos
< graph_port_added_src_pos
,
1097 "event order is good (5)");
1098 ok(graph_port_added_src_pos
< graph_ports_connected_pos
,
1099 "event order is good (6)");
1101 bt_object_put_ref(graph
);
1102 bt_object_put_ref(sink
);
1103 bt_object_put_ref(src
);
1104 bt_object_put_ref(conn
);
1105 bt_object_put_ref(src_def_port
);
1106 bt_object_put_ref(sink_def_port
);
1107 bt_object_put_ref(src_hello_port
);
1111 void test_simple(void)
1113 struct bt_component
*src
;
1114 struct bt_component
*sink
;
1115 struct bt_private_graph
*graph
;
1116 struct bt_port
*src_def_port
;
1117 struct bt_port
*sink_def_port
;
1118 struct bt_connection
*conn
;
1120 enum bt_graph_status status
;
1121 size_t src_accept_port_connection_pos
;
1122 size_t sink_accept_port_connection_pos
;
1123 size_t src_port_connected_pos
;
1124 size_t sink_port_connected_pos
;
1125 size_t graph_ports_connected_pos
;
1127 prepare_test(TEST_SIMPLE
, "simple");
1128 graph
= create_graph();
1130 src
= create_src(graph
);
1131 sink
= create_sink(graph
);
1132 src_def_port
= bt_component_source_get_output_port_by_name(src
, "out");
1133 BT_ASSERT(src_def_port
);
1134 sink_def_port
= bt_component_sink_get_input_port_by_name(sink
, "in");
1135 BT_ASSERT(sink_def_port
);
1136 status
= bt_private_graph_connect_ports(graph
, src_def_port
, sink_def_port
,
1138 BT_ASSERT(status
== 0);
1140 /* We're supposed to have 7 events */
1141 ok(events
->len
== 7, "we have the expected number of events");
1143 /* Source's port added */
1144 event
.type
= GRAPH_PORT_ADDED
;
1145 event
.data
.graph_port_added
.comp
= src
;
1146 event
.data
.graph_port_added
.port
= src_def_port
;
1147 ok(has_event(&event
), "got the expected graph's port added event (for source, initial)");
1149 /* Sink's port added */
1150 event
.type
= GRAPH_PORT_ADDED
;
1151 event
.data
.graph_port_added
.comp
= sink
;
1152 event
.data
.graph_port_added
.port
= sink_def_port
;
1153 ok(has_event(&event
), "got the expected graph's port added event (for sink, initial)");
1155 /* Source's accept port connection */
1156 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1157 event
.data
.comp_accept_port_connection
.comp
= src
;
1158 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
1159 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
1160 ok(has_event(&event
), "got the expected source's accept port connection event");
1161 src_accept_port_connection_pos
= event_pos(&event
);
1163 /* Sink's accept port connection */
1164 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1165 event
.data
.comp_accept_port_connection
.comp
= sink
;
1166 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
1167 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
1168 ok(has_event(&event
), "got the expected sink's accept port connection event");
1169 sink_accept_port_connection_pos
= event_pos(&event
);
1171 /* Source's port connected */
1172 event
.type
= COMP_PORT_CONNECTED
;
1173 event
.data
.comp_port_connected
.comp
= src
;
1174 event
.data
.comp_port_connected
.self_port
= src_def_port
;
1175 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
1176 ok(has_event(&event
), "got the expected source's port connected event");
1177 src_port_connected_pos
= event_pos(&event
);
1179 /* Sink's port connected */
1180 event
.type
= COMP_PORT_CONNECTED
;
1181 event
.data
.comp_port_connected
.comp
= sink
;
1182 event
.data
.comp_port_connected
.self_port
= sink_def_port
;
1183 event
.data
.comp_port_connected
.other_port
= src_def_port
;
1184 ok(has_event(&event
), "got the expected sink's port connected event");
1185 sink_port_connected_pos
= event_pos(&event
);
1187 /* Graph's port connected */
1188 event
.type
= GRAPH_PORTS_CONNECTED
;
1189 event
.data
.graph_ports_connected
.upstream_comp
= src
;
1190 event
.data
.graph_ports_connected
.downstream_comp
= sink
;
1191 event
.data
.graph_ports_connected
.upstream_port
= src_def_port
;
1192 event
.data
.graph_ports_connected
.downstream_port
= sink_def_port
;
1193 event
.data
.graph_ports_connected
.conn
= conn
;
1194 ok(has_event(&event
), "got the expected graph's ports connected event");
1195 graph_ports_connected_pos
= event_pos(&event
);
1197 /* Order of events */
1198 ok(src_port_connected_pos
< graph_ports_connected_pos
,
1199 "event order is good (1)");
1200 ok(sink_port_connected_pos
< graph_ports_connected_pos
,
1201 "event order is good (2)");
1202 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
1203 "event order is good (3)");
1204 ok(sink_accept_port_connection_pos
< sink_port_connected_pos
,
1205 "event order is good (4)");
1207 bt_object_put_ref(graph
);
1208 bt_object_put_ref(sink
);
1209 bt_object_put_ref(src
);
1210 bt_object_put_ref(conn
);
1211 bt_object_put_ref(src_def_port
);
1212 bt_object_put_ref(sink_def_port
);
1216 void test_src_port_connected_error(void)
1218 struct bt_component
*src
;
1219 struct bt_component
*sink
;
1220 struct bt_private_graph
*graph
;
1221 struct bt_port
*src_def_port
;
1222 struct bt_port
*sink_def_port
;
1223 struct bt_connection
*conn
= NULL
;
1225 enum bt_graph_status status
;
1226 size_t src_accept_port_connection_pos
;
1227 size_t src_port_connected_pos
;
1229 prepare_test(TEST_SRC_PORT_CONNECTED_ERROR
, "port connected error: source");
1230 graph
= create_graph();
1232 src
= create_src(graph
);
1233 sink
= create_sink(graph
);
1234 src_def_port
= bt_component_source_get_output_port_by_name(src
, "out");
1235 BT_ASSERT(src_def_port
);
1236 sink_def_port
= bt_component_sink_get_input_port_by_name(sink
, "in");
1237 BT_ASSERT(sink_def_port
);
1238 status
= bt_private_graph_connect_ports(graph
, src_def_port
, sink_def_port
,
1240 ok(status
!= BT_GRAPH_STATUS_OK
,
1241 "bt_private_graph_connect_ports() returns an error");
1242 ok(!conn
, "returned connection is NULL");
1244 /* We're supposed to have 5 events */
1245 ok(events
->len
== 5, "we have the expected number of events");
1247 /* Source's port added */
1248 event
.type
= GRAPH_PORT_ADDED
;
1249 event
.data
.graph_port_added
.comp
= src
;
1250 event
.data
.graph_port_added
.port
= src_def_port
;
1251 ok(has_event(&event
), "got the expected graph's port added event (for source, initial)");
1253 /* Sink's port added */
1254 event
.type
= GRAPH_PORT_ADDED
;
1255 event
.data
.graph_port_added
.comp
= sink
;
1256 event
.data
.graph_port_added
.port
= sink_def_port
;
1257 ok(has_event(&event
), "got the expected graph's port added event (for sink, initial)");
1259 /* Source's accept port connection */
1260 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1261 event
.data
.comp_accept_port_connection
.comp
= src
;
1262 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
1263 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
1264 ok(has_event(&event
), "got the expected source's accept port connection event");
1265 src_accept_port_connection_pos
= event_pos(&event
);
1267 /* Sink's accept port connection */
1268 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1269 event
.data
.comp_accept_port_connection
.comp
= sink
;
1270 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
1271 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
1272 ok(has_event(&event
), "got the expected sink's accept port connection event");
1274 /* Source's port connected */
1275 event
.type
= COMP_PORT_CONNECTED
;
1276 event
.data
.comp_port_connected
.comp
= src
;
1277 event
.data
.comp_port_connected
.self_port
= src_def_port
;
1278 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
1279 ok(has_event(&event
), "got the expected source's port connected event");
1280 src_port_connected_pos
= event_pos(&event
);
1282 /* Order of events */
1283 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
1284 "event order is good (1)");
1286 bt_object_put_ref(graph
);
1287 bt_object_put_ref(sink
);
1288 bt_object_put_ref(src
);
1289 bt_object_put_ref(conn
);
1290 bt_object_put_ref(src_def_port
);
1291 bt_object_put_ref(sink_def_port
);
1295 void test_sink_port_connected_error(void)
1297 struct bt_component
*src
;
1298 struct bt_component
*sink
;
1299 struct bt_private_graph
*graph
;
1300 struct bt_port
*src_def_port
;
1301 struct bt_port
*sink_def_port
;
1302 struct bt_connection
*conn
= NULL
;
1304 enum bt_graph_status status
;
1305 size_t src_accept_port_connection_pos
;
1306 size_t sink_accept_port_connection_pos
;
1307 size_t src_port_connected_pos
;
1308 size_t src_port_disconnected_pos
;
1309 size_t sink_port_connected_pos
;
1311 prepare_test(TEST_SINK_PORT_CONNECTED_ERROR
, "port connected error: sink");
1312 graph
= create_graph();
1314 src
= create_src(graph
);
1315 sink
= create_sink(graph
);
1316 src_def_port
= bt_component_source_get_output_port_by_name(src
, "out");
1317 BT_ASSERT(src_def_port
);
1318 sink_def_port
= bt_component_sink_get_input_port_by_name(sink
, "in");
1319 BT_ASSERT(sink_def_port
);
1320 status
= bt_private_graph_connect_ports(graph
, src_def_port
, sink_def_port
,
1322 ok(status
!= BT_GRAPH_STATUS_OK
,
1323 "bt_private_graph_connect_ports() returns an error");
1324 ok(!conn
, "returned connection is NULL");
1326 /* We're supposed to have 5 events */
1327 ok(events
->len
== 7, "we have the expected number of events");
1329 /* Source's port added */
1330 event
.type
= GRAPH_PORT_ADDED
;
1331 event
.data
.graph_port_added
.comp
= src
;
1332 event
.data
.graph_port_added
.port
= src_def_port
;
1333 ok(has_event(&event
), "got the expected graph's port added event (for source, initial)");
1335 /* Sink's port added */
1336 event
.type
= GRAPH_PORT_ADDED
;
1337 event
.data
.graph_port_added
.comp
= sink
;
1338 event
.data
.graph_port_added
.port
= sink_def_port
;
1339 ok(has_event(&event
), "got the expected graph's port added event (for sink, initial)");
1341 /* Source's accept port connection */
1342 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1343 event
.data
.comp_accept_port_connection
.comp
= src
;
1344 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
1345 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
1346 ok(has_event(&event
), "got the expected source's accept port connection event");
1347 src_accept_port_connection_pos
= event_pos(&event
);
1349 /* Sink's accept port connection */
1350 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1351 event
.data
.comp_accept_port_connection
.comp
= sink
;
1352 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
1353 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
1354 ok(has_event(&event
), "got the expected sink's accept port connection event");
1355 sink_accept_port_connection_pos
= event_pos(&event
);
1357 /* Source's port connected */
1358 event
.type
= COMP_PORT_CONNECTED
;
1359 event
.data
.comp_port_connected
.comp
= src
;
1360 event
.data
.comp_port_connected
.self_port
= src_def_port
;
1361 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
1362 ok(has_event(&event
), "got the expected source's port connected event");
1363 src_port_connected_pos
= event_pos(&event
);
1365 /* Sink's port connected */
1366 event
.type
= COMP_PORT_CONNECTED
;
1367 event
.data
.comp_port_connected
.comp
= sink
;
1368 event
.data
.comp_port_connected
.self_port
= sink_def_port
;
1369 event
.data
.comp_port_connected
.other_port
= src_def_port
;
1370 ok(has_event(&event
), "got the expected sink's port connected event");
1371 sink_port_connected_pos
= event_pos(&event
);
1373 /* Source's port disconnected */
1374 event
.type
= COMP_PORT_DISCONNECTED
;
1375 event
.data
.comp_port_disconnected
.comp
= src
;
1376 event
.data
.comp_port_disconnected
.port
= src_def_port
;
1377 ok(has_event(&event
), "got the expected source's port disconnected event");
1378 src_port_disconnected_pos
= event_pos(&event
);
1380 /* Order of events */
1381 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
1382 "event order is good (1)");
1383 ok(sink_accept_port_connection_pos
< sink_port_connected_pos
,
1384 "event order is good (2)");
1385 ok(sink_port_connected_pos
< src_port_disconnected_pos
,
1386 "event order is good (3)");
1388 bt_object_put_ref(graph
);
1389 bt_object_put_ref(sink
);
1390 bt_object_put_ref(src
);
1391 bt_object_put_ref(conn
);
1392 bt_object_put_ref(src_def_port
);
1393 bt_object_put_ref(sink_def_port
);
1397 void test_empty_graph(void)
1399 struct bt_private_graph
*graph
;
1401 prepare_test(TEST_EMPTY_GRAPH
, "empty graph");
1402 graph
= create_graph();
1403 ok(events
->len
== 0, "empty graph generates no events");
1404 bt_object_put_ref(graph
);
1407 int main(int argc
, char **argv
)
1409 plan_tests(NR_TESTS
);
1413 test_src_port_connected_error();
1414 test_sink_port_connected_error();
1415 test_src_adds_port_in_port_connected();
1416 test_sink_removes_port_in_port_connected();
1417 test_sink_removes_port_in_port_connected_then_src_removes_disconnected_port();
1419 return exit_status();