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
)
323 struct bt_private_port
*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 port
= bt_private_component_source_add_output_private_port(
341 private_component
, "hello", NULL
);
351 void src_port_disconnected(struct bt_private_component
*private_component
,
352 struct bt_private_port
*private_port
)
355 struct event event
= {
356 .type
= COMP_PORT_DISCONNECTED
,
357 .data
.comp_port_disconnected
= {
358 .comp
= bt_component_from_private_component(private_component
),
359 .port
= bt_port_from_private_port(private_port
),
363 bt_put(event
.data
.comp_port_disconnected
.comp
);
364 bt_put(event
.data
.comp_port_disconnected
.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
sink_consume(
378 struct bt_private_component
*priv_component
)
380 struct bt_private_port
*def_port
;
383 switch (current_test
) {
384 case TEST_SINK_REMOVES_PORT_IN_CONSUME
:
385 case TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT
:
386 def_port
= bt_private_component_sink_get_default_input_private_port(
389 ret
= bt_private_port_remove_from_component(def_port
);
397 return BT_COMPONENT_STATUS_OK
;
401 void sink_port_connected(struct bt_private_component
*private_component
,
402 struct bt_private_port
*self_private_port
,
403 struct bt_port
*other_port
)
405 struct event event
= {
406 .type
= COMP_PORT_CONNECTED
,
407 .data
.comp_port_connected
= {
408 .comp
= bt_component_from_private_component(private_component
),
409 .self_port
= bt_port_from_private_port(self_private_port
),
410 .other_port
= other_port
,
414 bt_put(event
.data
.comp_port_connected
.comp
);
415 bt_put(event
.data
.comp_port_connected
.self_port
);
416 append_event(&event
);
420 void sink_port_disconnected(struct bt_private_component
*private_component
,
421 struct bt_private_port
*private_port
)
423 struct event event
= {
424 .type
= COMP_PORT_DISCONNECTED
,
425 .data
.comp_port_disconnected
= {
426 .comp
= bt_component_from_private_component(private_component
),
427 .port
= bt_port_from_private_port(private_port
),
431 bt_put(event
.data
.comp_port_disconnected
.comp
);
432 bt_put(event
.data
.comp_port_disconnected
.port
);
433 append_event(&event
);
437 void graph_port_added(struct bt_port
*port
,
440 struct bt_component
*comp
= bt_port_get_component(port
);
445 struct event event
= {
446 .type
= GRAPH_PORT_ADDED
,
447 .data
.graph_port_added
= {
453 append_event(&event
);
457 void graph_port_removed(struct bt_component
*component
,
458 struct bt_port
*port
, void *data
)
460 struct event event
= {
461 .type
= GRAPH_PORT_REMOVED
,
462 .data
.graph_port_removed
= {
468 append_event(&event
);
472 void graph_ports_connected(struct bt_port
*upstream_port
,
473 struct bt_port
*downstream_port
, void *data
)
475 struct bt_component
*upstream_comp
=
476 bt_port_get_component(upstream_port
);
477 struct bt_component
*downstream_comp
=
478 bt_port_get_component(downstream_port
);
479 struct bt_connection
*conn
= bt_port_get_connection(upstream_port
);
481 assert(upstream_comp
);
482 assert(downstream_comp
);
484 bt_put(upstream_comp
);
485 bt_put(downstream_comp
);
488 struct event event
= {
489 .type
= GRAPH_PORTS_CONNECTED
,
490 .data
.graph_ports_connected
= {
491 .upstream_comp
= upstream_comp
,
492 .downstream_comp
= downstream_comp
,
493 .upstream_port
= upstream_port
,
494 .downstream_port
= downstream_port
,
499 append_event(&event
);
503 void graph_ports_disconnected(
504 struct bt_component
*upstream_comp
,
505 struct bt_component
*downstream_comp
,
506 struct bt_port
*upstream_port
, struct bt_port
*downstream_port
,
509 struct event event
= {
510 .type
= GRAPH_PORTS_DISCONNECTED
,
511 .data
.graph_ports_disconnected
= {
512 .upstream_comp
= upstream_comp
,
513 .downstream_comp
= downstream_comp
,
514 .upstream_port
= upstream_port
,
515 .downstream_port
= downstream_port
,
519 append_event(&event
);
527 src_comp_class
= bt_component_class_source_create("src", src_iter_next
);
528 assert(src_comp_class
);
529 ret
= bt_component_class_set_accept_port_connection_method(
530 src_comp_class
, accept_port_connection
);
532 ret
= bt_component_class_set_port_connected_method(src_comp_class
,
535 ret
= bt_component_class_set_port_disconnected_method(
536 src_comp_class
, src_port_disconnected
);
538 sink_comp_class
= bt_component_class_sink_create("sink", sink_consume
);
539 assert(sink_comp_class
);
540 ret
= bt_component_class_set_accept_port_connection_method(
541 sink_comp_class
, accept_port_connection
);
543 ret
= bt_component_class_set_port_connected_method(sink_comp_class
,
544 sink_port_connected
);
546 ret
= bt_component_class_set_port_disconnected_method(sink_comp_class
,
547 sink_port_disconnected
);
549 bt_component_class_freeze(src_comp_class
);
550 bt_component_class_freeze(sink_comp_class
);
551 events
= g_array_new(FALSE
, TRUE
, sizeof(struct event
));
558 bt_put(src_comp_class
);
559 bt_put(sink_comp_class
);
560 g_array_free(events
, TRUE
);
564 struct bt_component
*create_src(void)
566 struct bt_component
*comp
=
567 bt_component_create(src_comp_class
, "src-comp", NULL
);
574 struct bt_component
*create_sink(void)
576 struct bt_component
*comp
=
577 bt_component_create(sink_comp_class
, "sink-comp", NULL
);
584 struct bt_graph
*create_graph(void)
586 struct bt_graph
*graph
= bt_graph_create();
590 ret
= bt_graph_add_port_added_listener(graph
, graph_port_added
, NULL
);
592 ret
= bt_graph_add_port_removed_listener(graph
, graph_port_removed
,
595 ret
= bt_graph_add_ports_connected_listener(graph
, graph_ports_connected
,
598 ret
= bt_graph_add_ports_disconnected_listener(graph
,
599 graph_ports_disconnected
, NULL
);
605 void prepare_test(enum test test
, const char *name
)
609 diag("test: %s", name
);
613 void test_sink_removes_port_in_port_connected_then_src_removes_disconnected_port(void)
616 struct bt_component
*src
;
617 struct bt_component
*sink
;
618 struct bt_graph
*graph
;
619 struct bt_port
*src_def_port
;
620 struct bt_port
*sink_def_port
;
621 struct bt_connection
*conn
;
623 size_t src_accept_port_connection_pos
;
624 size_t sink_accept_port_connection_pos
;
625 size_t src_port_connected_pos
;
626 size_t sink_port_connected_pos
;
627 size_t graph_ports_connected
;
628 size_t src_port_disconnected_pos
;
629 size_t sink_port_disconnected_pos
;
630 size_t graph_ports_disconnected_pos
;
631 size_t graph_port_removed_src_pos
;
632 size_t graph_port_removed_sink_pos
;
634 prepare_test(TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT
,
635 "sink removes port in consume, then source removes disconnected port");
637 sink
= create_sink();
638 graph
= create_graph();
639 src_def_port
= bt_component_source_get_default_output_port(src
);
640 assert(src_def_port
);
641 sink_def_port
= bt_component_sink_get_default_input_port(sink
);
642 assert(sink_def_port
);
643 conn
= bt_graph_connect_ports(graph
, src_def_port
, sink_def_port
);
646 /* We're supposed to have 5 events so far */
647 ok(events
->len
== 5, "we have the expected number of events (before consume)");
649 /* Source's accept port connection */
650 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
651 event
.data
.comp_accept_port_connection
.comp
= src
;
652 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
653 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
654 ok(has_event(&event
), "got the expected source's accept port connection event");
655 src_accept_port_connection_pos
= event_pos(&event
);
657 /* Sink's accept port connection */
658 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
659 event
.data
.comp_accept_port_connection
.comp
= sink
;
660 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
661 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
662 ok(has_event(&event
), "got the expected sink's accept port connection event");
663 sink_accept_port_connection_pos
= event_pos(&event
);
665 /* Source's port connected */
666 event
.type
= COMP_PORT_CONNECTED
;
667 event
.data
.comp_port_connected
.comp
= src
;
668 event
.data
.comp_port_connected
.self_port
= src_def_port
;
669 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
670 ok(has_event(&event
), "got the expected source's port connected event");
671 src_port_connected_pos
= event_pos(&event
);
673 /* Sink's port connected */
674 event
.type
= COMP_PORT_CONNECTED
;
675 event
.data
.comp_port_connected
.comp
= sink
;
676 event
.data
.comp_port_connected
.self_port
= sink_def_port
;
677 event
.data
.comp_port_connected
.other_port
= src_def_port
;
678 ok(has_event(&event
), "got the expected sink's port connected event");
679 sink_port_connected_pos
= event_pos(&event
);
681 /* Graph's ports connected */
682 event
.type
= GRAPH_PORTS_CONNECTED
;
683 event
.data
.graph_ports_connected
.upstream_comp
= src
;
684 event
.data
.graph_ports_connected
.downstream_comp
= sink
;
685 event
.data
.graph_ports_connected
.upstream_port
= src_def_port
;
686 event
.data
.graph_ports_connected
.downstream_port
= sink_def_port
;
687 event
.data
.graph_ports_connected
.conn
= conn
;
688 ok(has_event(&event
), "got the expected graph's ports connected event");
689 graph_ports_connected
= event_pos(&event
);
691 /* Order of events */
692 ok(src_port_connected_pos
< graph_ports_connected
,
693 "event order is good (1)");
694 ok(sink_port_connected_pos
< graph_ports_connected
,
695 "event order is good (2)");
696 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
697 "event order is good (3)");
698 ok(sink_accept_port_connection_pos
< sink_port_connected_pos
,
699 "event order is good (4)");
701 /* Consume sink once */
703 ret
= bt_graph_consume(graph
);
706 /* We're supposed to have 5 new events */
707 ok(events
->len
== 5, "we have the expected number of events (after consume)");
709 /* Source's port disconnected */
710 event
.type
= COMP_PORT_DISCONNECTED
;
711 event
.data
.comp_port_disconnected
.comp
= src
;
712 event
.data
.comp_port_disconnected
.port
= src_def_port
;
713 ok(has_event(&event
), "got the expected source's port disconnected event");
714 src_port_disconnected_pos
= event_pos(&event
);
716 /* Sink's port disconnected */
717 event
.type
= COMP_PORT_DISCONNECTED
;
718 event
.data
.comp_port_disconnected
.comp
= sink
;
719 event
.data
.comp_port_disconnected
.port
= sink_def_port
;
720 ok(has_event(&event
), "got the expected sink's port disconnected event");
721 sink_port_disconnected_pos
= event_pos(&event
);
723 /* Graph's ports disconnected */
724 event
.type
= GRAPH_PORTS_DISCONNECTED
;
725 event
.data
.graph_ports_disconnected
.upstream_comp
= src
;
726 event
.data
.graph_ports_disconnected
.downstream_comp
= sink
;
727 event
.data
.graph_ports_disconnected
.upstream_port
= src_def_port
;
728 event
.data
.graph_ports_disconnected
.downstream_port
= sink_def_port
;
729 ok(has_event(&event
), "got the expected graph's ports disconnected event");
730 graph_ports_disconnected_pos
= event_pos(&event
);
732 /* Graph's port removed (sink) */
733 event
.type
= GRAPH_PORT_REMOVED
;
734 event
.data
.graph_port_removed
.comp
= sink
;
735 event
.data
.graph_port_removed
.port
= sink_def_port
;
736 ok(has_event(&event
), "got the expected graph's port removed event (for sink)");
737 graph_port_removed_sink_pos
= event_pos(&event
);
739 /* Graph's port removed (source) */
740 event
.type
= GRAPH_PORT_REMOVED
;
741 event
.data
.graph_port_removed
.comp
= src
;
742 event
.data
.graph_port_removed
.port
= src_def_port
;
743 ok(has_event(&event
), "got the expected graph's port removed event (for source)");
744 graph_port_removed_src_pos
= event_pos(&event
);
746 /* Order of events */
747 ok(src_port_disconnected_pos
< graph_ports_disconnected_pos
,
748 "event order is good (5)");
749 ok(src_port_disconnected_pos
< graph_port_removed_sink_pos
,
750 "event order is good (6)");
751 ok(src_port_disconnected_pos
< graph_port_removed_src_pos
,
752 "event order is good (7)");
753 ok(sink_port_disconnected_pos
< graph_ports_disconnected_pos
,
754 "event order is good (8)");
755 ok(sink_port_disconnected_pos
< graph_port_removed_sink_pos
,
756 "event order is good (9)");
757 ok(sink_port_disconnected_pos
< graph_port_removed_src_pos
,
758 "event order is good (10)");
759 ok(graph_ports_disconnected_pos
< graph_port_removed_sink_pos
,
760 "event order is good (11)");
761 ok(graph_port_removed_src_pos
< graph_ports_disconnected_pos
,
762 "event order is good (12)");
763 ok(graph_port_removed_src_pos
< graph_port_removed_sink_pos
,
764 "event order is good (13)");
770 bt_put(src_def_port
);
771 bt_put(sink_def_port
);
775 void test_sink_removes_port_in_port_connected(void)
778 struct bt_component
*src
;
779 struct bt_component
*sink
;
780 struct bt_graph
*graph
;
781 struct bt_port
*src_def_port
;
782 struct bt_port
*sink_def_port
;
783 struct bt_connection
*conn
;
785 size_t src_accept_port_connection_pos
;
786 size_t sink_accept_port_connection_pos
;
787 size_t src_port_connected_pos
;
788 size_t sink_port_connected_pos
;
789 size_t graph_ports_connected_pos
;
790 size_t src_port_disconnected_pos
;
791 size_t sink_port_disconnected_pos
;
792 size_t graph_ports_disconnected_pos
;
793 size_t graph_port_removed_sink_pos
;
795 prepare_test(TEST_SINK_REMOVES_PORT_IN_CONSUME
,
796 "sink removes port in consume");
798 sink
= create_sink();
799 graph
= create_graph();
800 src_def_port
= bt_component_source_get_default_output_port(src
);
801 assert(src_def_port
);
802 sink_def_port
= bt_component_sink_get_default_input_port(sink
);
803 assert(sink_def_port
);
804 conn
= bt_graph_connect_ports(graph
, src_def_port
, sink_def_port
);
807 /* We're supposed to have 5 events so far */
808 ok(events
->len
== 5, "we have the expected number of events (before consume)");
810 /* Source's accept port connection */
811 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
812 event
.data
.comp_accept_port_connection
.comp
= src
;
813 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
814 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
815 ok(has_event(&event
), "got the expected source's accept port connection event");
816 src_accept_port_connection_pos
= event_pos(&event
);
818 /* Sink's accept port connection */
819 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
820 event
.data
.comp_accept_port_connection
.comp
= sink
;
821 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
822 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
823 ok(has_event(&event
), "got the expected sink's accept port connection event");
824 sink_accept_port_connection_pos
= event_pos(&event
);
826 /* Source's port connected */
827 event
.type
= COMP_PORT_CONNECTED
;
828 event
.data
.comp_port_connected
.comp
= src
;
829 event
.data
.comp_port_connected
.self_port
= src_def_port
;
830 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
831 ok(has_event(&event
), "got the expected source's port connected event");
832 src_port_connected_pos
= event_pos(&event
);
834 /* Sink's port connected */
835 event
.type
= COMP_PORT_CONNECTED
;
836 event
.data
.comp_port_connected
.comp
= sink
;
837 event
.data
.comp_port_connected
.self_port
= sink_def_port
;
838 event
.data
.comp_port_connected
.other_port
= src_def_port
;
839 ok(has_event(&event
), "got the expected sink's port connected event");
840 sink_port_connected_pos
= event_pos(&event
);
842 /* Graph's ports connected */
843 event
.type
= GRAPH_PORTS_CONNECTED
;
844 event
.data
.graph_ports_connected
.upstream_comp
= src
;
845 event
.data
.graph_ports_connected
.downstream_comp
= sink
;
846 event
.data
.graph_ports_connected
.upstream_port
= src_def_port
;
847 event
.data
.graph_ports_connected
.downstream_port
= sink_def_port
;
848 event
.data
.graph_ports_connected
.conn
= conn
;
849 ok(has_event(&event
), "got the expected graph's ports connected event");
850 graph_ports_connected_pos
= event_pos(&event
);
852 /* Order of events */
853 ok(src_port_connected_pos
< graph_ports_connected_pos
,
854 "event order is good (1)");
855 ok(sink_port_connected_pos
< graph_ports_connected_pos
,
856 "event order is good (2)");
857 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
858 "event order is good (3)");
859 ok(sink_accept_port_connection_pos
< sink_port_connected_pos
,
860 "event order is good (4)");
862 /* Consume sink once */
864 ret
= bt_graph_consume(graph
);
867 /* We're supposed to have 4 new events */
868 ok(events
->len
== 4, "we have the expected number of events (after consume)");
870 /* Source's port disconnected */
871 event
.type
= COMP_PORT_DISCONNECTED
;
872 event
.data
.comp_port_disconnected
.comp
= src
;
873 event
.data
.comp_port_disconnected
.port
= src_def_port
;
874 ok(has_event(&event
), "got the expected source's port disconnected event");
875 src_port_disconnected_pos
= event_pos(&event
);
877 /* Sink's port disconnected */
878 event
.type
= COMP_PORT_DISCONNECTED
;
879 event
.data
.comp_port_disconnected
.comp
= sink
;
880 event
.data
.comp_port_disconnected
.port
= sink_def_port
;
881 ok(has_event(&event
), "got the expected sink's port disconnected event");
882 sink_port_disconnected_pos
= event_pos(&event
);
884 /* Graph's ports disconnected */
885 event
.type
= GRAPH_PORTS_DISCONNECTED
;
886 event
.data
.graph_ports_disconnected
.upstream_comp
= src
;
887 event
.data
.graph_ports_disconnected
.downstream_comp
= sink
;
888 event
.data
.graph_ports_disconnected
.upstream_port
= src_def_port
;
889 event
.data
.graph_ports_disconnected
.downstream_port
= sink_def_port
;
890 ok(has_event(&event
), "got the expected graph's ports disconnected event");
891 graph_ports_disconnected_pos
= event_pos(&event
);
893 /* Graph's port removed (sink) */
894 event
.type
= GRAPH_PORT_REMOVED
;
895 event
.data
.graph_port_removed
.comp
= sink
;
896 event
.data
.graph_port_removed
.port
= sink_def_port
;
897 ok(has_event(&event
), "got the expected graph's port removed event (for sink)");
898 graph_port_removed_sink_pos
= event_pos(&event
);
900 /* Order of events */
901 ok(src_port_disconnected_pos
< graph_ports_disconnected_pos
,
902 "event order is good (5)");
903 ok(src_port_disconnected_pos
< graph_port_removed_sink_pos
,
904 "event order is good (7)");
905 ok(sink_port_disconnected_pos
< graph_ports_disconnected_pos
,
906 "event order is good (8)");
907 ok(sink_port_disconnected_pos
< graph_port_removed_sink_pos
,
908 "event order is good (10)");
909 ok(graph_ports_disconnected_pos
< graph_port_removed_sink_pos
,
910 "event order is good (11)");
916 bt_put(src_def_port
);
917 bt_put(sink_def_port
);
921 void test_src_adds_port_in_port_connected(void)
923 struct bt_component
*src
;
924 struct bt_component
*sink
;
925 struct bt_graph
*graph
;
926 struct bt_port
*src_def_port
;
927 struct bt_port
*sink_def_port
;
928 struct bt_port
*src_hello_port
;
929 struct bt_connection
*conn
;
931 size_t src_accept_port_connection_pos
;
932 size_t sink_accept_port_connection_pos
;
933 size_t src_port_connected_pos
;
934 size_t sink_port_connected_pos
;
935 size_t graph_ports_connected_pos
;
936 size_t graph_port_added_src_pos
;
938 prepare_test(TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED
,
939 "source adds port in port connected");
941 sink
= create_sink();
942 graph
= create_graph();
943 src_def_port
= bt_component_source_get_default_output_port(src
);
944 assert(src_def_port
);
945 sink_def_port
= bt_component_sink_get_default_input_port(sink
);
946 assert(sink_def_port
);
947 conn
= bt_graph_connect_ports(graph
, src_def_port
, sink_def_port
);
949 src_hello_port
= bt_component_source_get_output_port_by_name(src
,
951 assert(src_hello_port
);
953 /* We're supposed to have 6 events */
954 ok(events
->len
== 6, "we have the expected number of events");
956 /* Source's accept port connection */
957 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
958 event
.data
.comp_accept_port_connection
.comp
= src
;
959 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
960 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
961 ok(has_event(&event
), "got the expected source's accept port connection event");
962 src_accept_port_connection_pos
= event_pos(&event
);
964 /* Sink's accept port connection */
965 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
966 event
.data
.comp_accept_port_connection
.comp
= sink
;
967 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
968 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
969 ok(has_event(&event
), "got the expected sink's accept port connection event");
970 sink_accept_port_connection_pos
= event_pos(&event
);
972 /* Source's port connected */
973 event
.type
= COMP_PORT_CONNECTED
;
974 event
.data
.comp_port_connected
.comp
= src
;
975 event
.data
.comp_port_connected
.self_port
= src_def_port
;
976 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
977 ok(has_event(&event
), "got the expected source's port connected event");
978 src_port_connected_pos
= event_pos(&event
);
980 /* Graph's port added (source) */
981 event
.type
= GRAPH_PORT_ADDED
;
982 event
.data
.graph_port_added
.comp
= src
;
983 event
.data
.graph_port_added
.port
= src_hello_port
;
984 ok(has_event(&event
), "got the expected graph's port added event (for source)");
985 graph_port_added_src_pos
= event_pos(&event
);
987 /* Sink's port connected */
988 event
.type
= COMP_PORT_CONNECTED
;
989 event
.data
.comp_port_connected
.comp
= sink
;
990 event
.data
.comp_port_connected
.self_port
= sink_def_port
;
991 event
.data
.comp_port_connected
.other_port
= src_def_port
;
992 ok(has_event(&event
), "got the expected sink's port connected event");
993 sink_port_connected_pos
= event_pos(&event
);
995 /* Graph's ports connected */
996 event
.type
= GRAPH_PORTS_CONNECTED
;
997 event
.data
.graph_ports_connected
.upstream_comp
= src
;
998 event
.data
.graph_ports_connected
.downstream_comp
= sink
;
999 event
.data
.graph_ports_connected
.upstream_port
= src_def_port
;
1000 event
.data
.graph_ports_connected
.downstream_port
= sink_def_port
;
1001 event
.data
.graph_ports_connected
.conn
= conn
;
1002 ok(has_event(&event
), "got the expected graph's port connected event (for source)");
1003 graph_ports_connected_pos
= event_pos(&event
);
1005 /* Order of events */
1006 ok(src_port_connected_pos
< graph_ports_connected_pos
,
1007 "event order is good (1)");
1008 ok(sink_port_connected_pos
< graph_ports_connected_pos
,
1009 "event order is good (2)");
1010 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
1011 "event order is good (3)");
1012 ok(sink_accept_port_connection_pos
< sink_port_connected_pos
,
1013 "event order is good (4)");
1014 ok(src_port_connected_pos
< graph_port_added_src_pos
,
1015 "event order is good (5)");
1016 ok(graph_port_added_src_pos
< graph_ports_connected_pos
,
1017 "event order is good (6)");
1023 bt_put(src_def_port
);
1024 bt_put(sink_def_port
);
1025 bt_put(src_hello_port
);
1029 void test_simple(void)
1031 struct bt_component
*src
;
1032 struct bt_component
*sink
;
1033 struct bt_graph
*graph
;
1034 struct bt_port
*src_def_port
;
1035 struct bt_port
*sink_def_port
;
1036 struct bt_connection
*conn
;
1038 size_t src_accept_port_connection_pos
;
1039 size_t sink_accept_port_connection_pos
;
1040 size_t src_port_connected_pos
;
1041 size_t sink_port_connected_pos
;
1042 size_t graph_ports_connected_pos
;
1044 prepare_test(TEST_SIMPLE
, "simple");
1046 sink
= create_sink();
1047 graph
= create_graph();
1048 src_def_port
= bt_component_source_get_default_output_port(src
);
1049 assert(src_def_port
);
1050 sink_def_port
= bt_component_sink_get_default_input_port(sink
);
1051 assert(sink_def_port
);
1052 conn
= bt_graph_connect_ports(graph
, src_def_port
, sink_def_port
);
1055 /* We're supposed to have 5 events */
1056 ok(events
->len
== 5, "we have the expected number of events");
1058 /* Source's accept port connection */
1059 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1060 event
.data
.comp_accept_port_connection
.comp
= src
;
1061 event
.data
.comp_accept_port_connection
.self_port
= src_def_port
;
1062 event
.data
.comp_accept_port_connection
.other_port
= sink_def_port
;
1063 ok(has_event(&event
), "got the expected source's accept port connection event");
1064 src_accept_port_connection_pos
= event_pos(&event
);
1066 /* Sink's accept port connection */
1067 event
.type
= COMP_ACCEPT_PORT_CONNECTION
;
1068 event
.data
.comp_accept_port_connection
.comp
= sink
;
1069 event
.data
.comp_accept_port_connection
.self_port
= sink_def_port
;
1070 event
.data
.comp_accept_port_connection
.other_port
= src_def_port
;
1071 ok(has_event(&event
), "got the expected sink's accept port connection event");
1072 sink_accept_port_connection_pos
= event_pos(&event
);
1074 /* Source's port connected */
1075 event
.type
= COMP_PORT_CONNECTED
;
1076 event
.data
.comp_port_connected
.comp
= src
;
1077 event
.data
.comp_port_connected
.self_port
= src_def_port
;
1078 event
.data
.comp_port_connected
.other_port
= sink_def_port
;
1079 ok(has_event(&event
), "got the expected source's port connected event");
1080 src_port_connected_pos
= event_pos(&event
);
1082 /* Sink's port connected */
1083 event
.type
= COMP_PORT_CONNECTED
;
1084 event
.data
.comp_port_connected
.comp
= sink
;
1085 event
.data
.comp_port_connected
.self_port
= sink_def_port
;
1086 event
.data
.comp_port_connected
.other_port
= src_def_port
;
1087 ok(has_event(&event
), "got the expected sink's port connected event");
1088 sink_port_connected_pos
= event_pos(&event
);
1090 /* Graph's port connected */
1091 event
.type
= GRAPH_PORTS_CONNECTED
;
1092 event
.data
.graph_ports_connected
.upstream_comp
= src
;
1093 event
.data
.graph_ports_connected
.downstream_comp
= sink
;
1094 event
.data
.graph_ports_connected
.upstream_port
= src_def_port
;
1095 event
.data
.graph_ports_connected
.downstream_port
= sink_def_port
;
1096 event
.data
.graph_ports_connected
.conn
= conn
;
1097 ok(has_event(&event
), "got the expected graph's ports connected event");
1098 graph_ports_connected_pos
= event_pos(&event
);
1100 /* Order of events */
1101 ok(src_port_connected_pos
< graph_ports_connected_pos
,
1102 "event order is good (1)");
1103 ok(sink_port_connected_pos
< graph_ports_connected_pos
,
1104 "event order is good (2)");
1105 ok(src_accept_port_connection_pos
< src_port_connected_pos
,
1106 "event order is good (3)");
1107 ok(sink_accept_port_connection_pos
< sink_port_connected_pos
,
1108 "event order is good (4)");
1114 bt_put(src_def_port
);
1115 bt_put(sink_def_port
);
1119 void test_empty_graph(void)
1121 struct bt_graph
*graph
;
1123 prepare_test(TEST_EMPTY_GRAPH
, "empty graph");
1124 graph
= create_graph();
1125 ok(events
->len
== 0, "empty graph generates no events");
1129 int main(int argc
, char **argv
)
1131 plan_tests(NR_TESTS
);
1135 test_src_adds_port_in_port_connected();
1136 test_sink_removes_port_in_port_connected();
1137 test_sink_removes_port_in_port_connected_then_src_removes_disconnected_port();
1139 return exit_status();