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/ref.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/graph.h>
28 #include <babeltrace/graph/connection.h>
29 #include <babeltrace/graph/port.h>
30 #include <babeltrace/graph/private-component.h>
31 #include <babeltrace/graph/private-component-source.h>
32 #include <babeltrace/graph/private-component-sink.h>
33 #include <babeltrace/graph/private-port.h>
34 #include <babeltrace/graph/private-connection.h>
38 #include <babeltrace/assert-internal.h>
46 COMP_ACCEPT_PORT_CONNECTION
,
48 COMP_PORT_DISCONNECTED
,
51 GRAPH_PORTS_CONNECTED
,
52 GRAPH_PORTS_DISCONNECTED
,
58 TEST_SRC_PORT_CONNECTED_ERROR
,
59 TEST_SINK_PORT_CONNECTED_ERROR
,
60 TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED
,
61 TEST_SINK_REMOVES_PORT_IN_CONSUME
,
62 TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT
,
70 struct bt_component
*comp
;
71 struct bt_port
*self_port
;
72 struct bt_port
*other_port
;
73 } comp_accept_port_connection
;
76 struct bt_component
*comp
;
77 struct bt_port
*self_port
;
78 struct bt_port
*other_port
;
79 } comp_port_connected
;
82 struct bt_component
*comp
;
84 } comp_port_disconnected
;
87 struct bt_component
*comp
;
92 struct bt_component
*comp
;
97 struct bt_component
*upstream_comp
;
98 struct bt_component
*downstream_comp
;
99 struct bt_port
*upstream_port
;
100 struct bt_port
*downstream_port
;
101 struct bt_connection
*conn
;
102 } graph_ports_connected
;
105 struct bt_component
*upstream_comp
;
106 struct bt_component
*downstream_comp
;
107 struct bt_port
*upstream_port
;
108 struct bt_port
*downstream_port
;
109 } graph_ports_disconnected
;
113 static GArray
*events
;
114 static struct bt_component_class
*src_comp_class
;
115 static struct bt_component_class
*sink_comp_class
;
116 static enum test current_test
;
119 void clear_events(void)
121 g_array_set_size(events
, 0);
125 void append_event(struct event
*event
)
127 g_array_append_val(events
, *event
);
131 bool compare_events(struct event
*ev_a
, struct event
*ev_b
)
133 if (ev_a
->type
!= ev_b
->type
) {
137 switch (ev_a
->type
) {
138 case COMP_ACCEPT_PORT_CONNECTION
:
139 if (ev_a
->data
.comp_accept_port_connection
.comp
!=
140 ev_b
->data
.comp_accept_port_connection
.comp
) {
144 if (ev_a
->data
.comp_accept_port_connection
.self_port
!=
145 ev_b
->data
.comp_accept_port_connection
.self_port
) {
149 if (ev_a
->data
.comp_accept_port_connection
.other_port
!=
150 ev_b
->data
.comp_accept_port_connection
.other_port
) {
154 case COMP_PORT_CONNECTED
:
155 if (ev_a
->data
.comp_port_connected
.comp
!=
156 ev_b
->data
.comp_port_connected
.comp
) {
160 if (ev_a
->data
.comp_port_connected
.self_port
!=
161 ev_b
->data
.comp_port_connected
.self_port
) {
165 if (ev_a
->data
.comp_port_connected
.other_port
!=
166 ev_b
->data
.comp_port_connected
.other_port
) {
170 case COMP_PORT_DISCONNECTED
:
171 if (ev_a
->data
.comp_port_disconnected
.comp
!=
172 ev_b
->data
.comp_port_disconnected
.comp
) {
176 if (ev_a
->data
.comp_port_disconnected
.port
!=
177 ev_b
->data
.comp_port_disconnected
.port
) {
181 case GRAPH_PORT_ADDED
:
182 if (ev_a
->data
.graph_port_added
.comp
!=
183 ev_b
->data
.graph_port_added
.comp
) {
187 if (ev_a
->data
.graph_port_added
.port
!=
188 ev_b
->data
.graph_port_added
.port
) {
192 case GRAPH_PORT_REMOVED
:
193 if (ev_a
->data
.graph_port_removed
.comp
!=
194 ev_b
->data
.graph_port_removed
.comp
) {
198 if (ev_a
->data
.graph_port_removed
.port
!=
199 ev_b
->data
.graph_port_removed
.port
) {
203 case GRAPH_PORTS_CONNECTED
:
204 if (ev_a
->data
.graph_ports_connected
.upstream_comp
!=
205 ev_b
->data
.graph_ports_connected
.upstream_comp
) {
209 if (ev_a
->data
.graph_ports_connected
.downstream_comp
!=
210 ev_b
->data
.graph_ports_connected
.downstream_comp
) {
214 if (ev_a
->data
.graph_ports_connected
.upstream_port
!=
215 ev_b
->data
.graph_ports_connected
.upstream_port
) {
219 if (ev_a
->data
.graph_ports_connected
.downstream_port
!=
220 ev_b
->data
.graph_ports_connected
.downstream_port
) {
224 if (ev_a
->data
.graph_ports_connected
.conn
!=
225 ev_b
->data
.graph_ports_connected
.conn
) {
229 case GRAPH_PORTS_DISCONNECTED
:
230 if (ev_a
->data
.graph_ports_disconnected
.upstream_comp
!=
231 ev_b
->data
.graph_ports_disconnected
.upstream_comp
) {
235 if (ev_a
->data
.graph_ports_disconnected
.downstream_comp
!=
236 ev_b
->data
.graph_ports_disconnected
.downstream_comp
) {
240 if (ev_a
->data
.graph_ports_disconnected
.upstream_port
!=
241 ev_b
->data
.graph_ports_disconnected
.upstream_port
) {
245 if (ev_a
->data
.graph_ports_disconnected
.downstream_port
!=
246 ev_b
->data
.graph_ports_disconnected
.downstream_port
) {
258 bool has_event(struct event
*event
)
262 for (i
= 0; i
< events
->len
; i
++) {
263 struct event
*ev
= &g_array_index(events
, struct event
, i
);
265 if (compare_events(event
, ev
)) {
274 size_t event_pos(struct event
*event
)
278 for (i
= 0; i
< events
->len
; i
++) {
279 struct event
*ev
= &g_array_index(events
, struct event
, i
);
281 if (compare_events(event
, ev
)) {
290 enum bt_notification_iterator_status
src_iter_next(
291 struct bt_private_connection_private_notification_iterator
*priv_iterator
,
292 bt_notification_array notifs
, uint64_t capacity
,
295 return BT_NOTIFICATION_ITERATOR_STATUS_ERROR
;
299 enum bt_component_status
accept_port_connection(
300 struct bt_private_component
*private_component
,
301 struct bt_private_port
*self_private_port
,
302 struct bt_port
*other_port
)
304 struct event event
= {
305 .type
= COMP_ACCEPT_PORT_CONNECTION
,
306 .data
.comp_accept_port_connection
= {
307 .comp
= bt_component_borrow_from_private(private_component
),
308 .self_port
= bt_port_borrow_from_private(self_private_port
),
309 .other_port
= other_port
,
313 append_event(&event
);
314 return BT_COMPONENT_STATUS_OK
;
318 enum bt_component_status
src_port_connected(
319 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_borrow_from_private(private_component
),
329 .self_port
= bt_port_borrow_from_private(self_private_port
),
330 .other_port
= other_port
,
334 append_event(&event
);
336 switch (current_test
) {
337 case TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED
:
338 ret
= bt_private_component_source_add_output_private_port(
339 private_component
, "hello", NULL
, NULL
);
342 case TEST_SRC_PORT_CONNECTED_ERROR
:
343 return BT_COMPONENT_STATUS_ERROR
;
348 return BT_COMPONENT_STATUS_OK
;
352 void src_port_disconnected(struct bt_private_component
*private_component
,
353 struct bt_private_port
*private_port
)
356 struct event event
= {
357 .type
= COMP_PORT_DISCONNECTED
,
358 .data
.comp_port_disconnected
= {
359 .comp
= bt_component_borrow_from_private(private_component
),
360 .port
= bt_port_borrow_from_private(private_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 enum bt_component_status
sink_port_connected(
413 struct bt_private_component
*private_component
,
414 struct bt_private_port
*self_private_port
,
415 struct bt_port
*other_port
)
417 struct event event
= {
418 .type
= COMP_PORT_CONNECTED
,
419 .data
.comp_port_connected
= {
420 .comp
= bt_component_borrow_from_private(private_component
),
421 .self_port
= bt_port_borrow_from_private(self_private_port
),
422 .other_port
= other_port
,
426 append_event(&event
);
428 if (current_test
== TEST_SINK_PORT_CONNECTED_ERROR
) {
429 return BT_COMPONENT_STATUS_ERROR
;
431 return BT_COMPONENT_STATUS_OK
;
436 void sink_port_disconnected(struct bt_private_component
*private_component
,
437 struct bt_private_port
*private_port
)
439 struct event event
= {
440 .type
= COMP_PORT_DISCONNECTED
,
441 .data
.comp_port_disconnected
= {
442 .comp
= bt_component_borrow_from_private(private_component
),
443 .port
= bt_port_borrow_from_private(private_port
),
447 append_event(&event
);
451 enum bt_component_status
sink_init(struct bt_private_component
*priv_comp
,
452 struct bt_value
*params
, void *init_method_data
)
456 ret
= bt_private_component_sink_add_input_private_port(priv_comp
,
459 return BT_COMPONENT_STATUS_OK
;
463 void graph_port_added(struct bt_port
*port
,
466 struct bt_component
*comp
= bt_port_get_component(port
);
471 struct event event
= {
472 .type
= GRAPH_PORT_ADDED
,
473 .data
.graph_port_added
= {
479 append_event(&event
);
483 void graph_port_removed(struct bt_component
*component
,
484 struct bt_port
*port
, void *data
)
486 struct event event
= {
487 .type
= GRAPH_PORT_REMOVED
,
488 .data
.graph_port_removed
= {
494 append_event(&event
);
498 void graph_ports_connected(struct bt_port
*upstream_port
,
499 struct bt_port
*downstream_port
, void *data
)
501 struct bt_component
*upstream_comp
=
502 bt_port_get_component(upstream_port
);
503 struct bt_component
*downstream_comp
=
504 bt_port_get_component(downstream_port
);
505 struct bt_connection
*conn
= bt_port_get_connection(upstream_port
);
507 BT_ASSERT(upstream_comp
);
508 BT_ASSERT(downstream_comp
);
510 bt_put(upstream_comp
);
511 bt_put(downstream_comp
);
514 struct event event
= {
515 .type
= GRAPH_PORTS_CONNECTED
,
516 .data
.graph_ports_connected
= {
517 .upstream_comp
= upstream_comp
,
518 .downstream_comp
= downstream_comp
,
519 .upstream_port
= upstream_port
,
520 .downstream_port
= downstream_port
,
525 append_event(&event
);
529 void graph_ports_disconnected(
530 struct bt_component
*upstream_comp
,
531 struct bt_component
*downstream_comp
,
532 struct bt_port
*upstream_port
, struct bt_port
*downstream_port
,
535 struct event event
= {
536 .type
= GRAPH_PORTS_DISCONNECTED
,
537 .data
.graph_ports_disconnected
= {
538 .upstream_comp
= upstream_comp
,
539 .downstream_comp
= downstream_comp
,
540 .upstream_port
= upstream_port
,
541 .downstream_port
= downstream_port
,
545 append_event(&event
);
553 src_comp_class
= bt_component_class_source_create("src", src_iter_next
);
554 BT_ASSERT(src_comp_class
);
555 ret
= bt_component_class_set_init_method(src_comp_class
, src_init
);
557 ret
= bt_component_class_set_accept_port_connection_method(
558 src_comp_class
, accept_port_connection
);
560 ret
= bt_component_class_set_port_connected_method(src_comp_class
,
563 ret
= bt_component_class_set_port_disconnected_method(
564 src_comp_class
, src_port_disconnected
);
566 sink_comp_class
= bt_component_class_sink_create("sink", sink_consume
);
567 BT_ASSERT(sink_comp_class
);
568 ret
= bt_component_class_set_init_method(sink_comp_class
, sink_init
);
570 ret
= bt_component_class_set_accept_port_connection_method(
571 sink_comp_class
, accept_port_connection
);
573 ret
= bt_component_class_set_port_connected_method(sink_comp_class
,
574 sink_port_connected
);
576 ret
= bt_component_class_set_port_disconnected_method(sink_comp_class
,
577 sink_port_disconnected
);
579 bt_component_class_freeze(src_comp_class
);
580 bt_component_class_freeze(sink_comp_class
);
581 events
= g_array_new(FALSE
, TRUE
, sizeof(struct event
));
588 bt_put(src_comp_class
);
589 bt_put(sink_comp_class
);
590 g_array_free(events
, TRUE
);
594 struct bt_component
*create_src(struct bt_graph
*graph
)
596 struct bt_component
*comp
;
599 ret
= bt_graph_add_component(graph
, src_comp_class
, "src-comp", NULL
,
606 struct bt_component
*create_sink(struct bt_graph
*graph
)
608 struct bt_component
*comp
;
611 ret
= bt_graph_add_component(graph
, sink_comp_class
, "sink-comp",
618 struct bt_graph
*create_graph(void)
620 struct bt_graph
*graph
= bt_graph_create();
624 ret
= bt_graph_add_port_added_listener(graph
, graph_port_added
, NULL
,
627 ret
= bt_graph_add_port_removed_listener(graph
, graph_port_removed
,
630 ret
= bt_graph_add_ports_connected_listener(graph
,
631 graph_ports_connected
, NULL
, NULL
);
633 ret
= bt_graph_add_ports_disconnected_listener(graph
,
634 graph_ports_disconnected
, NULL
, NULL
);
640 void prepare_test(enum test test
, const char *name
)
644 diag("test: %s", name
);
648 void test_sink_removes_port_in_port_connected_then_src_removes_disconnected_port(void)
651 struct bt_component
*src
;
652 struct bt_component
*sink
;
653 struct bt_graph
*graph
;
654 struct bt_port
*src_def_port
;
655 struct bt_port
*sink_def_port
;
656 struct bt_connection
*conn
;
658 enum bt_graph_status status
;
659 size_t src_accept_port_connection_pos
;
660 size_t sink_accept_port_connection_pos
;
661 size_t src_port_connected_pos
;
662 size_t sink_port_connected_pos
;
663 size_t graph_ports_connected
;
664 size_t src_port_disconnected_pos
;
665 size_t sink_port_disconnected_pos
;
666 size_t graph_ports_disconnected_pos
;
667 size_t graph_port_removed_src_pos
;
668 size_t graph_port_removed_sink_pos
;
670 prepare_test(TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT
,
671 "sink removes port in consume, then source removes disconnected port");
672 graph
= create_graph();
674 src
= create_src(graph
);
675 sink
= create_sink(graph
);
676 src_def_port
= bt_component_source_get_output_port_by_name(src
, "out");
677 BT_ASSERT(src_def_port
);
678 sink_def_port
= bt_component_sink_get_input_port_by_name(sink
, "in");
679 BT_ASSERT(sink_def_port
);
680 status
= bt_graph_connect_ports(graph
, src_def_port
, sink_def_port
,
682 BT_ASSERT(status
== 0);
685 /* We're supposed to have 7 events so far */
686 ok(events
->len
== 7, "we have the expected number of events (before consume)");
688 /* Source's port added */
689 event
.type
= GRAPH_PORT_ADDED
;
690 event
.data
.graph_port_added
.comp
= src
;
691 event
.data
.graph_port_added
.port
= src_def_port
;
692 ok(has_event(&event
), "got the expected graph's port added event (for source, initial)");
694 /* Sink's port added */
695 event
.type
= GRAPH_PORT_ADDED
;
696 event
.data
.graph_port_added
.comp
= sink
;
697 event
.data
.graph_port_added
.port
= sink_def_port
;
698 ok(has_event(&event
), "got the expected graph's port added event (for sink, initial)");
700 /* Source's accept port connection */
701 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
702 event
.data
.comp_accept_port_connection
.comp
= src
;
703 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
704 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
705 ok(has_event(&event
), "got the expected source's accept port connection event");
706 src_accept_port_connection_pos
= event_pos(&event
);
708 /* Sink's accept port connection */
709 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
710 event
.data
.comp_accept_port_connection
.comp
= sink
;
711 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
712 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
713 ok(has_event(&event
), "got the expected sink's accept port connection event");
714 sink_accept_port_connection_pos
= event_pos(&event
);
716 /* Source's port connected */
717 event
.type
= COMP_PORT_CONNECTED
;
718 event
.data
.comp_port_connected
.comp
= src
;
719 event
.data
.comp_port_connected
.self_port
= src_def_port
;
720 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
721 ok(has_event(&event
), "got the expected source's port connected event");
722 src_port_connected_pos
= event_pos(&event
);
724 /* Sink's port connected */
725 event
.type
= COMP_PORT_CONNECTED
;
726 event
.data
.comp_port_connected
.comp
= sink
;
727 event
.data
.comp_port_connected
.self_port
= sink_def_port
;
728 event
.data
.comp_port_connected
.other_port
= src_def_port
;
729 ok(has_event(&event
), "got the expected sink's port connected event");
730 sink_port_connected_pos
= event_pos(&event
);
732 /* Graph's ports connected */
733 event
.type
= GRAPH_PORTS_CONNECTED
;
734 event
.data
.graph_ports_connected
.upstream_comp
= src
;
735 event
.data
.graph_ports_connected
.downstream_comp
= sink
;
736 event
.data
.graph_ports_connected
.upstream_port
= src_def_port
;
737 event
.data
.graph_ports_connected
.downstream_port
= sink_def_port
;
738 event
.data
.graph_ports_connected
.conn
= conn
;
739 ok(has_event(&event
), "got the expected graph's ports connected event");
740 graph_ports_connected
= event_pos(&event
);
742 /* Order of events */
743 ok(src_port_connected_pos
< graph_ports_connected
,
744 "event order is good (1)");
745 ok(sink_port_connected_pos
< graph_ports_connected
,
746 "event order is good (2)");
747 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
748 "event order is good (3)");
749 ok(sink_accept_port_connection_pos
< sink_port_connected_pos
,
750 "event order is good (4)");
752 /* Consume sink once */
754 ret
= bt_graph_consume(graph
);
757 /* We're supposed to have 5 new events */
758 ok(events
->len
== 5, "we have the expected number of events (after consume)");
760 /* Source's port disconnected */
761 event
.type
= COMP_PORT_DISCONNECTED
;
762 event
.data
.comp_port_disconnected
.comp
= src
;
763 event
.data
.comp_port_disconnected
.port
= src_def_port
;
764 ok(has_event(&event
), "got the expected source's port disconnected event");
765 src_port_disconnected_pos
= event_pos(&event
);
767 /* Sink's port disconnected */
768 event
.type
= COMP_PORT_DISCONNECTED
;
769 event
.data
.comp_port_disconnected
.comp
= sink
;
770 event
.data
.comp_port_disconnected
.port
= sink_def_port
;
771 ok(has_event(&event
), "got the expected sink's port disconnected event");
772 sink_port_disconnected_pos
= event_pos(&event
);
774 /* Graph's ports disconnected */
775 event
.type
= GRAPH_PORTS_DISCONNECTED
;
776 event
.data
.graph_ports_disconnected
.upstream_comp
= src
;
777 event
.data
.graph_ports_disconnected
.downstream_comp
= sink
;
778 event
.data
.graph_ports_disconnected
.upstream_port
= src_def_port
;
779 event
.data
.graph_ports_disconnected
.downstream_port
= sink_def_port
;
780 ok(has_event(&event
), "got the expected graph's ports disconnected event");
781 graph_ports_disconnected_pos
= event_pos(&event
);
783 /* Graph's port removed (sink) */
784 event
.type
= GRAPH_PORT_REMOVED
;
785 event
.data
.graph_port_removed
.comp
= sink
;
786 event
.data
.graph_port_removed
.port
= sink_def_port
;
787 ok(has_event(&event
), "got the expected graph's port removed event (for sink)");
788 graph_port_removed_sink_pos
= event_pos(&event
);
790 /* Graph's port removed (source) */
791 event
.type
= GRAPH_PORT_REMOVED
;
792 event
.data
.graph_port_removed
.comp
= src
;
793 event
.data
.graph_port_removed
.port
= src_def_port
;
794 ok(has_event(&event
), "got the expected graph's port removed event (for source)");
795 graph_port_removed_src_pos
= event_pos(&event
);
797 /* Order of events */
798 ok(src_port_disconnected_pos
< graph_ports_disconnected_pos
,
799 "event order is good (5)");
800 ok(src_port_disconnected_pos
< graph_port_removed_sink_pos
,
801 "event order is good (6)");
802 ok(src_port_disconnected_pos
< graph_port_removed_src_pos
,
803 "event order is good (7)");
804 ok(sink_port_disconnected_pos
< graph_ports_disconnected_pos
,
805 "event order is good (8)");
806 ok(sink_port_disconnected_pos
< graph_port_removed_sink_pos
,
807 "event order is good (9)");
808 ok(sink_port_disconnected_pos
< graph_port_removed_src_pos
,
809 "event order is good (10)");
810 ok(graph_ports_disconnected_pos
< graph_port_removed_sink_pos
,
811 "event order is good (11)");
812 ok(graph_port_removed_src_pos
< graph_ports_disconnected_pos
,
813 "event order is good (12)");
814 ok(graph_port_removed_src_pos
< graph_port_removed_sink_pos
,
815 "event order is good (13)");
821 bt_put(src_def_port
);
822 bt_put(sink_def_port
);
826 void test_sink_removes_port_in_port_connected(void)
829 struct bt_component
*src
;
830 struct bt_component
*sink
;
831 struct bt_graph
*graph
;
832 struct bt_port
*src_def_port
;
833 struct bt_port
*sink_def_port
;
834 struct bt_connection
*conn
;
836 enum bt_graph_status status
;
837 size_t src_accept_port_connection_pos
;
838 size_t sink_accept_port_connection_pos
;
839 size_t src_port_connected_pos
;
840 size_t sink_port_connected_pos
;
841 size_t graph_ports_connected_pos
;
842 size_t src_port_disconnected_pos
;
843 size_t sink_port_disconnected_pos
;
844 size_t graph_ports_disconnected_pos
;
845 size_t graph_port_removed_sink_pos
;
847 prepare_test(TEST_SINK_REMOVES_PORT_IN_CONSUME
,
848 "sink removes port in consume");
849 graph
= create_graph();
851 src
= create_src(graph
);
852 sink
= create_sink(graph
);
853 src_def_port
= bt_component_source_get_output_port_by_name(src
, "out");
854 BT_ASSERT(src_def_port
);
855 sink_def_port
= bt_component_sink_get_input_port_by_name(sink
, "in");
856 BT_ASSERT(sink_def_port
);
857 status
= bt_graph_connect_ports(graph
, src_def_port
, sink_def_port
,
859 BT_ASSERT(status
== 0);
861 /* We're supposed to have 7 events so far */
862 ok(events
->len
== 7, "we have the expected number of events (before consume)");
864 /* Source's port added */
865 event
.type
= GRAPH_PORT_ADDED
;
866 event
.data
.graph_port_added
.comp
= src
;
867 event
.data
.graph_port_added
.port
= src_def_port
;
868 ok(has_event(&event
), "got the expected graph's port added event (for source, initial)");
870 /* Sink's port added */
871 event
.type
= GRAPH_PORT_ADDED
;
872 event
.data
.graph_port_added
.comp
= sink
;
873 event
.data
.graph_port_added
.port
= sink_def_port
;
874 ok(has_event(&event
), "got the expected graph's port added event (for sink, initial)");
876 /* Source's accept port connection */
877 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
878 event
.data
.comp_accept_port_connection
.comp
= src
;
879 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
880 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
881 ok(has_event(&event
), "got the expected source's accept port connection event");
882 src_accept_port_connection_pos
= event_pos(&event
);
884 /* Sink's accept port connection */
885 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
886 event
.data
.comp_accept_port_connection
.comp
= sink
;
887 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
888 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
889 ok(has_event(&event
), "got the expected sink's accept port connection event");
890 sink_accept_port_connection_pos
= event_pos(&event
);
892 /* Source's port connected */
893 event
.type
= COMP_PORT_CONNECTED
;
894 event
.data
.comp_port_connected
.comp
= src
;
895 event
.data
.comp_port_connected
.self_port
= src_def_port
;
896 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
897 ok(has_event(&event
), "got the expected source's port connected event");
898 src_port_connected_pos
= event_pos(&event
);
900 /* Sink's port connected */
901 event
.type
= COMP_PORT_CONNECTED
;
902 event
.data
.comp_port_connected
.comp
= sink
;
903 event
.data
.comp_port_connected
.self_port
= sink_def_port
;
904 event
.data
.comp_port_connected
.other_port
= src_def_port
;
905 ok(has_event(&event
), "got the expected sink's port connected event");
906 sink_port_connected_pos
= event_pos(&event
);
908 /* Graph's ports connected */
909 event
.type
= GRAPH_PORTS_CONNECTED
;
910 event
.data
.graph_ports_connected
.upstream_comp
= src
;
911 event
.data
.graph_ports_connected
.downstream_comp
= sink
;
912 event
.data
.graph_ports_connected
.upstream_port
= src_def_port
;
913 event
.data
.graph_ports_connected
.downstream_port
= sink_def_port
;
914 event
.data
.graph_ports_connected
.conn
= conn
;
915 ok(has_event(&event
), "got the expected graph's ports connected event");
916 graph_ports_connected_pos
= event_pos(&event
);
918 /* Order of events */
919 ok(src_port_connected_pos
< graph_ports_connected_pos
,
920 "event order is good (1)");
921 ok(sink_port_connected_pos
< graph_ports_connected_pos
,
922 "event order is good (2)");
923 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
924 "event order is good (3)");
925 ok(sink_accept_port_connection_pos
< sink_port_connected_pos
,
926 "event order is good (4)");
928 /* Consume sink once */
930 ret
= bt_graph_consume(graph
);
933 /* We're supposed to have 4 new events */
934 ok(events
->len
== 4, "we have the expected number of events (after consume)");
936 /* Source's port disconnected */
937 event
.type
= COMP_PORT_DISCONNECTED
;
938 event
.data
.comp_port_disconnected
.comp
= src
;
939 event
.data
.comp_port_disconnected
.port
= src_def_port
;
940 ok(has_event(&event
), "got the expected source's port disconnected event");
941 src_port_disconnected_pos
= event_pos(&event
);
943 /* Sink's port disconnected */
944 event
.type
= COMP_PORT_DISCONNECTED
;
945 event
.data
.comp_port_disconnected
.comp
= sink
;
946 event
.data
.comp_port_disconnected
.port
= sink_def_port
;
947 ok(has_event(&event
), "got the expected sink's port disconnected event");
948 sink_port_disconnected_pos
= event_pos(&event
);
950 /* Graph's ports disconnected */
951 event
.type
= GRAPH_PORTS_DISCONNECTED
;
952 event
.data
.graph_ports_disconnected
.upstream_comp
= src
;
953 event
.data
.graph_ports_disconnected
.downstream_comp
= sink
;
954 event
.data
.graph_ports_disconnected
.upstream_port
= src_def_port
;
955 event
.data
.graph_ports_disconnected
.downstream_port
= sink_def_port
;
956 ok(has_event(&event
), "got the expected graph's ports disconnected event");
957 graph_ports_disconnected_pos
= event_pos(&event
);
959 /* Graph's port removed (sink) */
960 event
.type
= GRAPH_PORT_REMOVED
;
961 event
.data
.graph_port_removed
.comp
= sink
;
962 event
.data
.graph_port_removed
.port
= sink_def_port
;
963 ok(has_event(&event
), "got the expected graph's port removed event (for sink)");
964 graph_port_removed_sink_pos
= event_pos(&event
);
966 /* Order of events */
967 ok(src_port_disconnected_pos
< graph_ports_disconnected_pos
,
968 "event order is good (5)");
969 ok(src_port_disconnected_pos
< graph_port_removed_sink_pos
,
970 "event order is good (7)");
971 ok(sink_port_disconnected_pos
< graph_ports_disconnected_pos
,
972 "event order is good (8)");
973 ok(sink_port_disconnected_pos
< graph_port_removed_sink_pos
,
974 "event order is good (10)");
975 ok(graph_ports_disconnected_pos
< graph_port_removed_sink_pos
,
976 "event order is good (11)");
982 bt_put(src_def_port
);
983 bt_put(sink_def_port
);
987 void test_src_adds_port_in_port_connected(void)
989 struct bt_component
*src
;
990 struct bt_component
*sink
;
991 struct bt_graph
*graph
;
992 struct bt_port
*src_def_port
;
993 struct bt_port
*sink_def_port
;
994 struct bt_port
*src_hello_port
;
995 struct bt_connection
*conn
;
997 enum bt_graph_status status
;
998 size_t src_accept_port_connection_pos
;
999 size_t sink_accept_port_connection_pos
;
1000 size_t src_port_connected_pos
;
1001 size_t sink_port_connected_pos
;
1002 size_t graph_ports_connected_pos
;
1003 size_t graph_port_added_src_pos
;
1005 prepare_test(TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED
,
1006 "source adds port in port connected");
1007 graph
= create_graph();
1009 src
= create_src(graph
);
1010 sink
= create_sink(graph
);
1011 src_def_port
= bt_component_source_get_output_port_by_name(src
, "out");
1012 BT_ASSERT(src_def_port
);
1013 sink_def_port
= bt_component_sink_get_input_port_by_name(sink
, "in");
1014 BT_ASSERT(sink_def_port
);
1015 status
= bt_graph_connect_ports(graph
, src_def_port
, sink_def_port
,
1017 BT_ASSERT(status
== 0);
1018 src_hello_port
= bt_component_source_get_output_port_by_name(src
,
1020 BT_ASSERT(src_hello_port
);
1022 /* We're supposed to have 8 events */
1023 ok(events
->len
== 8, "we have the expected number of events");
1025 /* Source's port added */
1026 event
.type
= GRAPH_PORT_ADDED
;
1027 event
.data
.graph_port_added
.comp
= src
;
1028 event
.data
.graph_port_added
.port
= src_def_port
;
1029 ok(has_event(&event
), "got the expected graph's port added event (for source, initial)");
1031 /* Sink's port added */
1032 event
.type
= GRAPH_PORT_ADDED
;
1033 event
.data
.graph_port_added
.comp
= sink
;
1034 event
.data
.graph_port_added
.port
= sink_def_port
;
1035 ok(has_event(&event
), "got the expected graph's port added event (for sink, initial)");
1037 /* Source's accept port connection */
1038 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1039 event
.data
.comp_accept_port_connection
.comp
= src
;
1040 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
1041 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
1042 ok(has_event(&event
), "got the expected source's accept port connection event");
1043 src_accept_port_connection_pos
= event_pos(&event
);
1045 /* Sink's accept port connection */
1046 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1047 event
.data
.comp_accept_port_connection
.comp
= sink
;
1048 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
1049 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
1050 ok(has_event(&event
), "got the expected sink's accept port connection event");
1051 sink_accept_port_connection_pos
= event_pos(&event
);
1053 /* Source's port connected */
1054 event
.type
= COMP_PORT_CONNECTED
;
1055 event
.data
.comp_port_connected
.comp
= src
;
1056 event
.data
.comp_port_connected
.self_port
= src_def_port
;
1057 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
1058 ok(has_event(&event
), "got the expected source's port connected event");
1059 src_port_connected_pos
= event_pos(&event
);
1061 /* Graph's port added (source) */
1062 event
.type
= GRAPH_PORT_ADDED
;
1063 event
.data
.graph_port_added
.comp
= src
;
1064 event
.data
.graph_port_added
.port
= src_hello_port
;
1065 ok(has_event(&event
), "got the expected graph's port added event (for source)");
1066 graph_port_added_src_pos
= event_pos(&event
);
1068 /* Sink's port connected */
1069 event
.type
= COMP_PORT_CONNECTED
;
1070 event
.data
.comp_port_connected
.comp
= sink
;
1071 event
.data
.comp_port_connected
.self_port
= sink_def_port
;
1072 event
.data
.comp_port_connected
.other_port
= src_def_port
;
1073 ok(has_event(&event
), "got the expected sink's port connected event");
1074 sink_port_connected_pos
= event_pos(&event
);
1076 /* Graph's ports connected */
1077 event
.type
= GRAPH_PORTS_CONNECTED
;
1078 event
.data
.graph_ports_connected
.upstream_comp
= src
;
1079 event
.data
.graph_ports_connected
.downstream_comp
= sink
;
1080 event
.data
.graph_ports_connected
.upstream_port
= src_def_port
;
1081 event
.data
.graph_ports_connected
.downstream_port
= sink_def_port
;
1082 event
.data
.graph_ports_connected
.conn
= conn
;
1083 ok(has_event(&event
), "got the expected graph's port connected event (for source)");
1084 graph_ports_connected_pos
= event_pos(&event
);
1086 /* Order of events */
1087 ok(src_port_connected_pos
< graph_ports_connected_pos
,
1088 "event order is good (1)");
1089 ok(sink_port_connected_pos
< graph_ports_connected_pos
,
1090 "event order is good (2)");
1091 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
1092 "event order is good (3)");
1093 ok(sink_accept_port_connection_pos
< sink_port_connected_pos
,
1094 "event order is good (4)");
1095 ok(src_port_connected_pos
< graph_port_added_src_pos
,
1096 "event order is good (5)");
1097 ok(graph_port_added_src_pos
< graph_ports_connected_pos
,
1098 "event order is good (6)");
1104 bt_put(src_def_port
);
1105 bt_put(sink_def_port
);
1106 bt_put(src_hello_port
);
1110 void test_simple(void)
1112 struct bt_component
*src
;
1113 struct bt_component
*sink
;
1114 struct bt_graph
*graph
;
1115 struct bt_port
*src_def_port
;
1116 struct bt_port
*sink_def_port
;
1117 struct bt_connection
*conn
;
1119 enum bt_graph_status status
;
1120 size_t src_accept_port_connection_pos
;
1121 size_t sink_accept_port_connection_pos
;
1122 size_t src_port_connected_pos
;
1123 size_t sink_port_connected_pos
;
1124 size_t graph_ports_connected_pos
;
1126 prepare_test(TEST_SIMPLE
, "simple");
1127 graph
= create_graph();
1129 src
= create_src(graph
);
1130 sink
= create_sink(graph
);
1131 src_def_port
= bt_component_source_get_output_port_by_name(src
, "out");
1132 BT_ASSERT(src_def_port
);
1133 sink_def_port
= bt_component_sink_get_input_port_by_name(sink
, "in");
1134 BT_ASSERT(sink_def_port
);
1135 status
= bt_graph_connect_ports(graph
, src_def_port
, sink_def_port
,
1137 BT_ASSERT(status
== 0);
1139 /* We're supposed to have 7 events */
1140 ok(events
->len
== 7, "we have the expected number of events");
1142 /* Source's port added */
1143 event
.type
= GRAPH_PORT_ADDED
;
1144 event
.data
.graph_port_added
.comp
= src
;
1145 event
.data
.graph_port_added
.port
= src_def_port
;
1146 ok(has_event(&event
), "got the expected graph's port added event (for source, initial)");
1148 /* Sink's port added */
1149 event
.type
= GRAPH_PORT_ADDED
;
1150 event
.data
.graph_port_added
.comp
= sink
;
1151 event
.data
.graph_port_added
.port
= sink_def_port
;
1152 ok(has_event(&event
), "got the expected graph's port added event (for sink, initial)");
1154 /* Source's accept port connection */
1155 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1156 event
.data
.comp_accept_port_connection
.comp
= src
;
1157 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
1158 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
1159 ok(has_event(&event
), "got the expected source's accept port connection event");
1160 src_accept_port_connection_pos
= event_pos(&event
);
1162 /* Sink's accept port connection */
1163 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1164 event
.data
.comp_accept_port_connection
.comp
= sink
;
1165 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
1166 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
1167 ok(has_event(&event
), "got the expected sink's accept port connection event");
1168 sink_accept_port_connection_pos
= event_pos(&event
);
1170 /* Source's port connected */
1171 event
.type
= COMP_PORT_CONNECTED
;
1172 event
.data
.comp_port_connected
.comp
= src
;
1173 event
.data
.comp_port_connected
.self_port
= src_def_port
;
1174 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
1175 ok(has_event(&event
), "got the expected source's port connected event");
1176 src_port_connected_pos
= event_pos(&event
);
1178 /* Sink's port connected */
1179 event
.type
= COMP_PORT_CONNECTED
;
1180 event
.data
.comp_port_connected
.comp
= sink
;
1181 event
.data
.comp_port_connected
.self_port
= sink_def_port
;
1182 event
.data
.comp_port_connected
.other_port
= src_def_port
;
1183 ok(has_event(&event
), "got the expected sink's port connected event");
1184 sink_port_connected_pos
= event_pos(&event
);
1186 /* Graph's port connected */
1187 event
.type
= GRAPH_PORTS_CONNECTED
;
1188 event
.data
.graph_ports_connected
.upstream_comp
= src
;
1189 event
.data
.graph_ports_connected
.downstream_comp
= sink
;
1190 event
.data
.graph_ports_connected
.upstream_port
= src_def_port
;
1191 event
.data
.graph_ports_connected
.downstream_port
= sink_def_port
;
1192 event
.data
.graph_ports_connected
.conn
= conn
;
1193 ok(has_event(&event
), "got the expected graph's ports connected event");
1194 graph_ports_connected_pos
= event_pos(&event
);
1196 /* Order of events */
1197 ok(src_port_connected_pos
< graph_ports_connected_pos
,
1198 "event order is good (1)");
1199 ok(sink_port_connected_pos
< graph_ports_connected_pos
,
1200 "event order is good (2)");
1201 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
1202 "event order is good (3)");
1203 ok(sink_accept_port_connection_pos
< sink_port_connected_pos
,
1204 "event order is good (4)");
1210 bt_put(src_def_port
);
1211 bt_put(sink_def_port
);
1215 void test_src_port_connected_error(void)
1217 struct bt_component
*src
;
1218 struct bt_component
*sink
;
1219 struct bt_graph
*graph
;
1220 struct bt_port
*src_def_port
;
1221 struct bt_port
*sink_def_port
;
1222 struct bt_connection
*conn
= NULL
;
1224 enum bt_graph_status status
;
1225 size_t src_accept_port_connection_pos
;
1226 size_t src_port_connected_pos
;
1228 prepare_test(TEST_SRC_PORT_CONNECTED_ERROR
, "port connected error: source");
1229 graph
= create_graph();
1231 src
= create_src(graph
);
1232 sink
= create_sink(graph
);
1233 src_def_port
= bt_component_source_get_output_port_by_name(src
, "out");
1234 BT_ASSERT(src_def_port
);
1235 sink_def_port
= bt_component_sink_get_input_port_by_name(sink
, "in");
1236 BT_ASSERT(sink_def_port
);
1237 status
= bt_graph_connect_ports(graph
, src_def_port
, sink_def_port
,
1239 ok(status
!= BT_GRAPH_STATUS_OK
,
1240 "bt_graph_connect_ports() returns an error");
1241 ok(!conn
, "returned connection is NULL");
1243 /* We're supposed to have 5 events */
1244 ok(events
->len
== 5, "we have the expected number of events");
1246 /* Source's port added */
1247 event
.type
= GRAPH_PORT_ADDED
;
1248 event
.data
.graph_port_added
.comp
= src
;
1249 event
.data
.graph_port_added
.port
= src_def_port
;
1250 ok(has_event(&event
), "got the expected graph's port added event (for source, initial)");
1252 /* Sink's port added */
1253 event
.type
= GRAPH_PORT_ADDED
;
1254 event
.data
.graph_port_added
.comp
= sink
;
1255 event
.data
.graph_port_added
.port
= sink_def_port
;
1256 ok(has_event(&event
), "got the expected graph's port added event (for sink, initial)");
1258 /* Source's accept port connection */
1259 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1260 event
.data
.comp_accept_port_connection
.comp
= src
;
1261 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
1262 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
1263 ok(has_event(&event
), "got the expected source's accept port connection event");
1264 src_accept_port_connection_pos
= event_pos(&event
);
1266 /* Sink's accept port connection */
1267 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1268 event
.data
.comp_accept_port_connection
.comp
= sink
;
1269 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
1270 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
1271 ok(has_event(&event
), "got the expected sink's accept port connection event");
1273 /* Source's port connected */
1274 event
.type
= COMP_PORT_CONNECTED
;
1275 event
.data
.comp_port_connected
.comp
= src
;
1276 event
.data
.comp_port_connected
.self_port
= src_def_port
;
1277 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
1278 ok(has_event(&event
), "got the expected source's port connected event");
1279 src_port_connected_pos
= event_pos(&event
);
1281 /* Order of events */
1282 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
1283 "event order is good (1)");
1289 bt_put(src_def_port
);
1290 bt_put(sink_def_port
);
1294 void test_sink_port_connected_error(void)
1296 struct bt_component
*src
;
1297 struct bt_component
*sink
;
1298 struct bt_graph
*graph
;
1299 struct bt_port
*src_def_port
;
1300 struct bt_port
*sink_def_port
;
1301 struct bt_connection
*conn
= NULL
;
1303 enum bt_graph_status status
;
1304 size_t src_accept_port_connection_pos
;
1305 size_t sink_accept_port_connection_pos
;
1306 size_t src_port_connected_pos
;
1307 size_t src_port_disconnected_pos
;
1308 size_t sink_port_connected_pos
;
1310 prepare_test(TEST_SINK_PORT_CONNECTED_ERROR
, "port connected error: sink");
1311 graph
= create_graph();
1313 src
= create_src(graph
);
1314 sink
= create_sink(graph
);
1315 src_def_port
= bt_component_source_get_output_port_by_name(src
, "out");
1316 BT_ASSERT(src_def_port
);
1317 sink_def_port
= bt_component_sink_get_input_port_by_name(sink
, "in");
1318 BT_ASSERT(sink_def_port
);
1319 status
= bt_graph_connect_ports(graph
, src_def_port
, sink_def_port
,
1321 ok(status
!= BT_GRAPH_STATUS_OK
,
1322 "bt_graph_connect_ports() returns an error");
1323 ok(!conn
, "returned connection is NULL");
1325 /* We're supposed to have 5 events */
1326 ok(events
->len
== 7, "we have the expected number of events");
1328 /* Source's port added */
1329 event
.type
= GRAPH_PORT_ADDED
;
1330 event
.data
.graph_port_added
.comp
= src
;
1331 event
.data
.graph_port_added
.port
= src_def_port
;
1332 ok(has_event(&event
), "got the expected graph's port added event (for source, initial)");
1334 /* Sink's port added */
1335 event
.type
= GRAPH_PORT_ADDED
;
1336 event
.data
.graph_port_added
.comp
= sink
;
1337 event
.data
.graph_port_added
.port
= sink_def_port
;
1338 ok(has_event(&event
), "got the expected graph's port added event (for sink, initial)");
1340 /* Source's accept port connection */
1341 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1342 event
.data
.comp_accept_port_connection
.comp
= src
;
1343 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
1344 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
1345 ok(has_event(&event
), "got the expected source's accept port connection event");
1346 src_accept_port_connection_pos
= event_pos(&event
);
1348 /* Sink's accept port connection */
1349 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1350 event
.data
.comp_accept_port_connection
.comp
= sink
;
1351 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
1352 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
1353 ok(has_event(&event
), "got the expected sink's accept port connection event");
1354 sink_accept_port_connection_pos
= event_pos(&event
);
1356 /* Source's port connected */
1357 event
.type
= COMP_PORT_CONNECTED
;
1358 event
.data
.comp_port_connected
.comp
= src
;
1359 event
.data
.comp_port_connected
.self_port
= src_def_port
;
1360 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
1361 ok(has_event(&event
), "got the expected source's port connected event");
1362 src_port_connected_pos
= event_pos(&event
);
1364 /* Sink's port connected */
1365 event
.type
= COMP_PORT_CONNECTED
;
1366 event
.data
.comp_port_connected
.comp
= sink
;
1367 event
.data
.comp_port_connected
.self_port
= sink_def_port
;
1368 event
.data
.comp_port_connected
.other_port
= src_def_port
;
1369 ok(has_event(&event
), "got the expected sink's port connected event");
1370 sink_port_connected_pos
= event_pos(&event
);
1372 /* Source's port disconnected */
1373 event
.type
= COMP_PORT_DISCONNECTED
;
1374 event
.data
.comp_port_disconnected
.comp
= src
;
1375 event
.data
.comp_port_disconnected
.port
= src_def_port
;
1376 ok(has_event(&event
), "got the expected source's port disconnected event");
1377 src_port_disconnected_pos
= event_pos(&event
);
1379 /* Order of events */
1380 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
1381 "event order is good (1)");
1382 ok(sink_accept_port_connection_pos
< sink_port_connected_pos
,
1383 "event order is good (2)");
1384 ok(sink_port_connected_pos
< src_port_disconnected_pos
,
1385 "event order is good (3)");
1391 bt_put(src_def_port
);
1392 bt_put(sink_def_port
);
1396 void test_empty_graph(void)
1398 struct bt_graph
*graph
;
1400 prepare_test(TEST_EMPTY_GRAPH
, "empty graph");
1401 graph
= create_graph();
1402 ok(events
->len
== 0, "empty graph generates no events");
1406 int main(int argc
, char **argv
)
1408 plan_tests(NR_TESTS
);
1412 test_src_port_connected_error();
1413 test_sink_port_connected_error();
1414 test_src_adds_port_in_port_connected();
1415 test_sink_removes_port_in_port_connected();
1416 test_sink_removes_port_in_port_connected_then_src_removes_disconnected_port();
1418 return exit_status();