X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=tests%2Flib%2Ftest_graph_topo.c;h=580648b24f053863bd4f26d21f66b6c4721ddf58;hb=9d408fcae74602e3591f66623ceb85f482d948ed;hp=8c88f82854caf74985bc18d770b4655e938a94f0;hpb=fb9935cce3db19748584c3e989eb5e6b83f04ed0;p=babeltrace.git diff --git a/tests/lib/test_graph_topo.c b/tests/lib/test_graph_topo.c index 8c88f828..580648b2 100644 --- a/tests/lib/test_graph_topo.c +++ b/tests/lib/test_graph_topo.c @@ -17,6 +17,7 @@ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ +#include #include #include #include @@ -39,10 +40,11 @@ #include "tap/tap.h" -#define NR_TESTS 53 +#define NR_TESTS 77 enum event_type { COMP_ACCEPT_PORT_CONNECTION, + COMP_PORT_CONNECTED, COMP_PORT_DISCONNECTED, GRAPH_PORT_ADDED, GRAPH_PORT_REMOVED, @@ -53,7 +55,7 @@ enum event_type { enum test { TEST_EMPTY_GRAPH, TEST_SIMPLE, - TEST_SRC_ADDS_PORT_IN_ACCEPT_PORT_CONNECTION, + TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED, TEST_SINK_REMOVES_PORT_IN_CONSUME, TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT, }; @@ -68,6 +70,12 @@ struct event { struct bt_port *other_port; } comp_accept_port_connection; + struct { + struct bt_component *comp; + struct bt_port *self_port; + struct bt_port *other_port; + } comp_port_connected; + struct { struct bt_component *comp; struct bt_port *port; @@ -141,6 +149,22 @@ bool compare_events(struct event *ev_a, struct event *ev_b) return false; } break; + case COMP_PORT_CONNECTED: + if (ev_a->data.comp_port_connected.comp != + ev_b->data.comp_port_connected.comp) { + return false; + } + + if (ev_a->data.comp_port_connected.self_port != + ev_b->data.comp_port_connected.self_port) { + return false; + } + + if (ev_a->data.comp_port_connected.other_port != + ev_b->data.comp_port_connected.other_port) { + return false; + } + break; case COMP_PORT_DISCONNECTED: if (ev_a->data.comp_port_disconnected.comp != ev_b->data.comp_port_disconnected.comp) { @@ -222,7 +246,7 @@ bool compare_events(struct event *ev_a, struct event *ev_b) } break; default: - assert(false); + abort(); } return true; @@ -257,14 +281,14 @@ size_t event_pos(struct event *event) } } - return -1ULL; + return SIZE_MAX; } static -struct bt_notification_iterator_next_return src_iter_next( - struct bt_private_notification_iterator *priv_iterator) +struct bt_notification_iterator_next_method_return src_iter_next( + struct bt_private_connection_private_notification_iterator *priv_iterator) { - struct bt_notification_iterator_next_return ret = { + struct bt_notification_iterator_next_method_return ret = { .status = BT_NOTIFICATION_ITERATOR_STATUS_ERROR, }; @@ -272,13 +296,11 @@ struct bt_notification_iterator_next_return src_iter_next( } static -enum bt_component_status src_accept_port_connection( +enum bt_component_status accept_port_connection( struct bt_private_component *private_component, struct bt_private_port *self_private_port, struct bt_port *other_port) { - struct bt_private_port *port; - struct event event = { .type = COMP_ACCEPT_PORT_CONNECTION, .data.comp_accept_port_connection = { @@ -291,19 +313,38 @@ enum bt_component_status src_accept_port_connection( bt_put(event.data.comp_accept_port_connection.comp); bt_put(event.data.comp_accept_port_connection.self_port); append_event(&event); + return BT_COMPONENT_STATUS_OK; +} + +static +void src_port_connected(struct bt_private_component *private_component, + struct bt_private_port *self_private_port, + struct bt_port *other_port) +{ + int ret; + + struct event event = { + .type = COMP_PORT_CONNECTED, + .data.comp_port_connected = { + .comp = bt_component_from_private_component(private_component), + .self_port = bt_port_from_private_port(self_private_port), + .other_port = other_port, + }, + }; + + bt_put(event.data.comp_port_connected.comp); + bt_put(event.data.comp_port_connected.self_port); + append_event(&event); switch (current_test) { - case TEST_SRC_ADDS_PORT_IN_ACCEPT_PORT_CONNECTION: - port = bt_private_component_source_add_output_private_port( - private_component, "hello"); - assert(port); - bt_put(port); + case TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED: + ret = bt_private_component_source_add_output_private_port( + private_component, "hello", NULL, NULL); + assert(ret == 0); break; default: break; } - - return BT_COMPONENT_STATUS_OK; } static @@ -332,6 +373,18 @@ void src_port_disconnected(struct bt_private_component *private_component, } } +static +enum bt_component_status src_init(struct bt_private_component *priv_comp, + struct bt_value *params, void *init_method_data) +{ + int ret; + + ret = bt_private_component_source_add_output_private_port( + priv_comp, "out", NULL, NULL); + assert(ret == 0); + return BT_COMPONENT_STATUS_OK; +} + static enum bt_component_status sink_consume( struct bt_private_component *priv_component) @@ -342,8 +395,8 @@ enum bt_component_status sink_consume( switch (current_test) { case TEST_SINK_REMOVES_PORT_IN_CONSUME: case TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT: - def_port = bt_private_component_sink_get_default_input_private_port( - priv_component); + def_port = bt_private_component_sink_get_input_private_port_by_name( + priv_component, "in"); assert(def_port); ret = bt_private_port_remove_from_component(def_port); assert(ret == 0); @@ -357,25 +410,22 @@ enum bt_component_status sink_consume( } static -enum bt_component_status sink_accept_port_connection( - struct bt_private_component *private_component, +void sink_port_connected(struct bt_private_component *private_component, struct bt_private_port *self_private_port, struct bt_port *other_port) { struct event event = { - .type = COMP_ACCEPT_PORT_CONNECTION, - .data.comp_accept_port_connection = { + .type = COMP_PORT_CONNECTED, + .data.comp_port_connected = { .comp = bt_component_from_private_component(private_component), .self_port = bt_port_from_private_port(self_private_port), .other_port = other_port, }, }; - bt_put(event.data.comp_accept_port_connection.comp); - bt_put(event.data.comp_accept_port_connection.self_port); + bt_put(event.data.comp_port_connected.comp); + bt_put(event.data.comp_port_connected.self_port); append_event(&event); - - return BT_COMPONENT_STATUS_OK; } static @@ -395,6 +445,18 @@ void sink_port_disconnected(struct bt_private_component *private_component, append_event(&event); } +static +enum bt_component_status sink_init(struct bt_private_component *priv_comp, + struct bt_value *params, void *init_method_data) +{ + int ret; + + ret = bt_private_component_sink_add_input_private_port(priv_comp, + "in", NULL, NULL); + assert(ret == 0); + return BT_COMPONENT_STATUS_OK; +} + static void graph_port_added(struct bt_port *port, void *data) @@ -488,19 +550,29 @@ void init_test(void) src_comp_class = bt_component_class_source_create("src", src_iter_next); assert(src_comp_class); + ret = bt_component_class_set_init_method(src_comp_class, src_init); + assert(ret == 0); ret = bt_component_class_set_accept_port_connection_method( - src_comp_class, src_accept_port_connection); + src_comp_class, accept_port_connection); + assert(ret == 0); + ret = bt_component_class_set_port_connected_method(src_comp_class, + src_port_connected); assert(ret == 0); ret = bt_component_class_set_port_disconnected_method( src_comp_class, src_port_disconnected); assert(ret == 0); sink_comp_class = bt_component_class_sink_create("sink", sink_consume); assert(sink_comp_class); + ret = bt_component_class_set_init_method(sink_comp_class, sink_init); + assert(ret == 0); ret = bt_component_class_set_accept_port_connection_method( - sink_comp_class, sink_accept_port_connection); + sink_comp_class, accept_port_connection); assert(ret == 0); - ret = bt_component_class_set_port_disconnected_method( - sink_comp_class, sink_port_disconnected); + ret = bt_component_class_set_port_connected_method(sink_comp_class, + sink_port_connected); + assert(ret == 0); + ret = bt_component_class_set_port_disconnected_method(sink_comp_class, + sink_port_disconnected); assert(ret == 0); bt_component_class_freeze(src_comp_class); bt_component_class_freeze(sink_comp_class); @@ -517,22 +589,26 @@ void fini_test(void) } static -struct bt_component *create_src(void) +struct bt_component *create_src(struct bt_graph *graph) { - struct bt_component *comp = - bt_component_create(src_comp_class, "src-comp", NULL); + struct bt_component *comp; + int ret; - assert(comp); + ret = bt_graph_add_component(graph, src_comp_class, "src-comp", NULL, + &comp); + assert(ret == 0); return comp; } static -struct bt_component *create_sink(void) +struct bt_component *create_sink(struct bt_graph *graph) { - struct bt_component *comp = - bt_component_create(sink_comp_class, "sink-comp", NULL); + struct bt_component *comp; + int ret; - assert(comp); + ret = bt_graph_add_component(graph, sink_comp_class, "sink-comp", + NULL, &comp); + assert(ret == 0); return comp; } @@ -543,17 +619,18 @@ struct bt_graph *create_graph(void) int ret; assert(graph); - ret = bt_graph_add_port_added_listener(graph, graph_port_added, NULL); - assert(ret == 0); - ret = bt_graph_add_port_removed_listener(graph, graph_port_removed, - NULL); - assert(ret == 0); - ret = bt_graph_add_ports_connected_listener(graph, graph_ports_connected, + ret = bt_graph_add_port_added_listener(graph, graph_port_added, NULL, NULL); - assert(ret == 0); + assert(ret >= 0); + ret = bt_graph_add_port_removed_listener(graph, graph_port_removed, + NULL, NULL); + assert(ret >= 0); + ret = bt_graph_add_ports_connected_listener(graph, + graph_ports_connected, NULL, NULL); + assert(ret >= 0); ret = bt_graph_add_ports_disconnected_listener(graph, - graph_ports_disconnected, NULL); - assert(ret == 0); + graph_ports_disconnected, NULL, NULL); + assert(ret >= 0); return graph; } @@ -566,7 +643,7 @@ void prepare_test(enum test test, const char *name) } static -void test_sink_removes_port_in_accept_port_connection_then_src_removes_disconnected_port(void) +void test_sink_removes_port_in_port_connected_then_src_removes_disconnected_port(void) { int ret; struct bt_component *src; @@ -576,8 +653,11 @@ void test_sink_removes_port_in_accept_port_connection_then_src_removes_disconnec struct bt_port *sink_def_port; struct bt_connection *conn; struct event event; - size_t src_accept_port_conn_pos; - size_t sink_accept_port_conn_pos; + enum bt_graph_status status; + size_t src_accept_port_connection_pos; + size_t sink_accept_port_connection_pos; + size_t src_port_connected_pos; + size_t sink_port_connected_pos; size_t graph_ports_connected; size_t src_port_disconnected_pos; size_t sink_port_disconnected_pos; @@ -587,18 +667,33 @@ void test_sink_removes_port_in_accept_port_connection_then_src_removes_disconnec prepare_test(TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT, "sink removes port in consume, then source removes disconnected port"); - src = create_src(); - sink = create_sink(); graph = create_graph(); - src_def_port = bt_component_source_get_default_output_port(src); + assert(graph); + src = create_src(graph); + sink = create_sink(graph); + src_def_port = bt_component_source_get_output_port_by_name(src, "out"); assert(src_def_port); - sink_def_port = bt_component_sink_get_default_input_port(sink); + sink_def_port = bt_component_sink_get_input_port_by_name(sink, "in"); assert(sink_def_port); - conn = bt_graph_connect_ports(graph, src_def_port, sink_def_port); + status = bt_graph_connect_ports(graph, src_def_port, sink_def_port, + &conn); + assert(status == 0); assert(conn); - /* We're supposed to have 3 events so far */ - ok(events->len == 3, "we have the expected number of events (before consume)"); + /* We're supposed to have 7 events so far */ + ok(events->len == 7, "we have the expected number of events (before consume)"); + + /* Source's port added */ + event.type = GRAPH_PORT_ADDED; + event.data.graph_port_added.comp = src; + event.data.graph_port_added.port = src_def_port; + ok(has_event(&event), "got the expected graph's port added event (for source, initial)"); + + /* Sink's port added */ + event.type = GRAPH_PORT_ADDED; + event.data.graph_port_added.comp = sink; + event.data.graph_port_added.port = sink_def_port; + ok(has_event(&event), "got the expected graph's port added event (for sink, initial)"); /* Source's accept port connection */ event.type = COMP_ACCEPT_PORT_CONNECTION; @@ -606,7 +701,7 @@ void test_sink_removes_port_in_accept_port_connection_then_src_removes_disconnec event.data.comp_accept_port_connection.self_port = src_def_port; event.data.comp_accept_port_connection.other_port = sink_def_port; ok(has_event(&event), "got the expected source's accept port connection event"); - src_accept_port_conn_pos = event_pos(&event); + src_accept_port_connection_pos = event_pos(&event); /* Sink's accept port connection */ event.type = COMP_ACCEPT_PORT_CONNECTION; @@ -614,7 +709,23 @@ void test_sink_removes_port_in_accept_port_connection_then_src_removes_disconnec event.data.comp_accept_port_connection.self_port = sink_def_port; event.data.comp_accept_port_connection.other_port = src_def_port; ok(has_event(&event), "got the expected sink's accept port connection event"); - sink_accept_port_conn_pos = event_pos(&event); + sink_accept_port_connection_pos = event_pos(&event); + + /* Source's port connected */ + event.type = COMP_PORT_CONNECTED; + event.data.comp_port_connected.comp = src; + event.data.comp_port_connected.self_port = src_def_port; + event.data.comp_port_connected.other_port = sink_def_port; + ok(has_event(&event), "got the expected source's port connected event"); + src_port_connected_pos = event_pos(&event); + + /* Sink's port connected */ + event.type = COMP_PORT_CONNECTED; + event.data.comp_port_connected.comp = sink; + event.data.comp_port_connected.self_port = sink_def_port; + event.data.comp_port_connected.other_port = src_def_port; + ok(has_event(&event), "got the expected sink's port connected event"); + sink_port_connected_pos = event_pos(&event); /* Graph's ports connected */ event.type = GRAPH_PORTS_CONNECTED; @@ -627,10 +738,14 @@ void test_sink_removes_port_in_accept_port_connection_then_src_removes_disconnec graph_ports_connected = event_pos(&event); /* Order of events */ - ok(src_accept_port_conn_pos < graph_ports_connected, + ok(src_port_connected_pos < graph_ports_connected, "event order is good (1)"); - ok(sink_accept_port_conn_pos < graph_ports_connected, + ok(sink_port_connected_pos < graph_ports_connected, "event order is good (2)"); + ok(src_accept_port_connection_pos < src_port_connected_pos, + "event order is good (3)"); + ok(sink_accept_port_connection_pos < sink_port_connected_pos, + "event order is good (4)"); /* Consume sink once */ clear_events(); @@ -706,7 +821,7 @@ void test_sink_removes_port_in_accept_port_connection_then_src_removes_disconnec } static -void test_sink_removes_port_in_accept_port_connection(void) +void test_sink_removes_port_in_port_connected(void) { int ret; struct bt_component *src; @@ -716,8 +831,11 @@ void test_sink_removes_port_in_accept_port_connection(void) struct bt_port *sink_def_port; struct bt_connection *conn; struct event event; - size_t src_accept_port_conn_pos; - size_t sink_accept_port_conn_pos; + enum bt_graph_status status; + size_t src_accept_port_connection_pos; + size_t sink_accept_port_connection_pos; + size_t src_port_connected_pos; + size_t sink_port_connected_pos; size_t graph_ports_connected_pos; size_t src_port_disconnected_pos; size_t sink_port_disconnected_pos; @@ -726,18 +844,32 @@ void test_sink_removes_port_in_accept_port_connection(void) prepare_test(TEST_SINK_REMOVES_PORT_IN_CONSUME, "sink removes port in consume"); - src = create_src(); - sink = create_sink(); graph = create_graph(); - src_def_port = bt_component_source_get_default_output_port(src); + assert(graph); + src = create_src(graph); + sink = create_sink(graph); + src_def_port = bt_component_source_get_output_port_by_name(src, "out"); assert(src_def_port); - sink_def_port = bt_component_sink_get_default_input_port(sink); + sink_def_port = bt_component_sink_get_input_port_by_name(sink, "in"); assert(sink_def_port); - conn = bt_graph_connect_ports(graph, src_def_port, sink_def_port); - assert(conn); + status = bt_graph_connect_ports(graph, src_def_port, sink_def_port, + &conn); + assert(status == 0); + + /* We're supposed to have 7 events so far */ + ok(events->len == 7, "we have the expected number of events (before consume)"); + + /* Source's port added */ + event.type = GRAPH_PORT_ADDED; + event.data.graph_port_added.comp = src; + event.data.graph_port_added.port = src_def_port; + ok(has_event(&event), "got the expected graph's port added event (for source, initial)"); - /* We're supposed to have 3 events so far */ - ok(events->len == 3, "we have the expected number of events (before consume)"); + /* Sink's port added */ + event.type = GRAPH_PORT_ADDED; + event.data.graph_port_added.comp = sink; + event.data.graph_port_added.port = sink_def_port; + ok(has_event(&event), "got the expected graph's port added event (for sink, initial)"); /* Source's accept port connection */ event.type = COMP_ACCEPT_PORT_CONNECTION; @@ -745,7 +877,7 @@ void test_sink_removes_port_in_accept_port_connection(void) event.data.comp_accept_port_connection.self_port = src_def_port; event.data.comp_accept_port_connection.other_port = sink_def_port; ok(has_event(&event), "got the expected source's accept port connection event"); - src_accept_port_conn_pos = event_pos(&event); + src_accept_port_connection_pos = event_pos(&event); /* Sink's accept port connection */ event.type = COMP_ACCEPT_PORT_CONNECTION; @@ -753,7 +885,23 @@ void test_sink_removes_port_in_accept_port_connection(void) event.data.comp_accept_port_connection.self_port = sink_def_port; event.data.comp_accept_port_connection.other_port = src_def_port; ok(has_event(&event), "got the expected sink's accept port connection event"); - sink_accept_port_conn_pos = event_pos(&event); + sink_accept_port_connection_pos = event_pos(&event); + + /* Source's port connected */ + event.type = COMP_PORT_CONNECTED; + event.data.comp_port_connected.comp = src; + event.data.comp_port_connected.self_port = src_def_port; + event.data.comp_port_connected.other_port = sink_def_port; + ok(has_event(&event), "got the expected source's port connected event"); + src_port_connected_pos = event_pos(&event); + + /* Sink's port connected */ + event.type = COMP_PORT_CONNECTED; + event.data.comp_port_connected.comp = sink; + event.data.comp_port_connected.self_port = sink_def_port; + event.data.comp_port_connected.other_port = src_def_port; + ok(has_event(&event), "got the expected sink's port connected event"); + sink_port_connected_pos = event_pos(&event); /* Graph's ports connected */ event.type = GRAPH_PORTS_CONNECTED; @@ -766,10 +914,14 @@ void test_sink_removes_port_in_accept_port_connection(void) graph_ports_connected_pos = event_pos(&event); /* Order of events */ - ok(src_accept_port_conn_pos < graph_ports_connected_pos, + ok(src_port_connected_pos < graph_ports_connected_pos, "event order is good (1)"); - ok(sink_accept_port_conn_pos < graph_ports_connected_pos, + ok(sink_port_connected_pos < graph_ports_connected_pos, "event order is good (2)"); + ok(src_accept_port_connection_pos < src_port_connected_pos, + "event order is good (3)"); + ok(sink_accept_port_connection_pos < sink_port_connected_pos, + "event order is good (4)"); /* Consume sink once */ clear_events(); @@ -830,7 +982,7 @@ void test_sink_removes_port_in_accept_port_connection(void) } static -void test_src_adds_port_in_accept_port_connection(void) +void test_src_adds_port_in_port_connected(void) { struct bt_component *src; struct bt_component *sink; @@ -840,27 +992,45 @@ void test_src_adds_port_in_accept_port_connection(void) struct bt_port *src_hello_port; struct bt_connection *conn; struct event event; - size_t src_accept_port_conn_pos; - size_t sink_accept_port_conn_pos; + enum bt_graph_status status; + size_t src_accept_port_connection_pos; + size_t sink_accept_port_connection_pos; + size_t src_port_connected_pos; + size_t sink_port_connected_pos; size_t graph_ports_connected_pos; size_t graph_port_added_src_pos; - prepare_test(TEST_SRC_ADDS_PORT_IN_ACCEPT_PORT_CONNECTION, - "source adds port in accept port connection"); - src = create_src(); - sink = create_sink(); + prepare_test(TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED, + "source adds port in port connected"); graph = create_graph(); - src_def_port = bt_component_source_get_default_output_port(src); + assert(graph); + src = create_src(graph); + sink = create_sink(graph); + src_def_port = bt_component_source_get_output_port_by_name(src, "out"); assert(src_def_port); - sink_def_port = bt_component_sink_get_default_input_port(sink); + sink_def_port = bt_component_sink_get_input_port_by_name(sink, "in"); assert(sink_def_port); - conn = bt_graph_connect_ports(graph, src_def_port, sink_def_port); - assert(conn); - src_hello_port = bt_component_source_get_output_port(src, "hello"); + status = bt_graph_connect_ports(graph, src_def_port, sink_def_port, + &conn); + assert(status == 0); + src_hello_port = bt_component_source_get_output_port_by_name(src, + "hello"); assert(src_hello_port); - /* We're supposed to have 4 events */ - ok(events->len == 4, "we have the expected number of events"); + /* We're supposed to have 8 events */ + ok(events->len == 8, "we have the expected number of events"); + + /* Source's port added */ + event.type = GRAPH_PORT_ADDED; + event.data.graph_port_added.comp = src; + event.data.graph_port_added.port = src_def_port; + ok(has_event(&event), "got the expected graph's port added event (for source, initial)"); + + /* Sink's port added */ + event.type = GRAPH_PORT_ADDED; + event.data.graph_port_added.comp = sink; + event.data.graph_port_added.port = sink_def_port; + ok(has_event(&event), "got the expected graph's port added event (for sink, initial)"); /* Source's accept port connection */ event.type = COMP_ACCEPT_PORT_CONNECTION; @@ -868,7 +1038,23 @@ void test_src_adds_port_in_accept_port_connection(void) event.data.comp_accept_port_connection.self_port = src_def_port; event.data.comp_accept_port_connection.other_port = sink_def_port; ok(has_event(&event), "got the expected source's accept port connection event"); - src_accept_port_conn_pos = event_pos(&event); + src_accept_port_connection_pos = event_pos(&event); + + /* Sink's accept port connection */ + event.type = COMP_ACCEPT_PORT_CONNECTION; + event.data.comp_accept_port_connection.comp = sink; + event.data.comp_accept_port_connection.self_port = sink_def_port; + event.data.comp_accept_port_connection.other_port = src_def_port; + ok(has_event(&event), "got the expected sink's accept port connection event"); + sink_accept_port_connection_pos = event_pos(&event); + + /* Source's port connected */ + event.type = COMP_PORT_CONNECTED; + event.data.comp_port_connected.comp = src; + event.data.comp_port_connected.self_port = src_def_port; + event.data.comp_port_connected.other_port = sink_def_port; + ok(has_event(&event), "got the expected source's port connected event"); + src_port_connected_pos = event_pos(&event); /* Graph's port added (source) */ event.type = GRAPH_PORT_ADDED; @@ -877,13 +1063,13 @@ void test_src_adds_port_in_accept_port_connection(void) ok(has_event(&event), "got the expected graph's port added event (for source)"); graph_port_added_src_pos = event_pos(&event); - /* Sink's accept port connection */ - event.type = COMP_ACCEPT_PORT_CONNECTION; - event.data.comp_accept_port_connection.comp = sink; - event.data.comp_accept_port_connection.self_port = sink_def_port; - event.data.comp_accept_port_connection.other_port = src_def_port; - ok(has_event(&event), "got the expected sink's accept port connection event"); - sink_accept_port_conn_pos = event_pos(&event); + /* Sink's port connected */ + event.type = COMP_PORT_CONNECTED; + event.data.comp_port_connected.comp = sink; + event.data.comp_port_connected.self_port = sink_def_port; + event.data.comp_port_connected.other_port = src_def_port; + ok(has_event(&event), "got the expected sink's port connected event"); + sink_port_connected_pos = event_pos(&event); /* Graph's ports connected */ event.type = GRAPH_PORTS_CONNECTED; @@ -896,14 +1082,18 @@ void test_src_adds_port_in_accept_port_connection(void) graph_ports_connected_pos = event_pos(&event); /* Order of events */ - ok(src_accept_port_conn_pos < graph_ports_connected_pos, + ok(src_port_connected_pos < graph_ports_connected_pos, "event order is good (1)"); - ok(sink_accept_port_conn_pos < graph_ports_connected_pos, + ok(sink_port_connected_pos < graph_ports_connected_pos, "event order is good (2)"); - ok(src_accept_port_conn_pos < graph_port_added_src_pos, + ok(src_accept_port_connection_pos < src_port_connected_pos, "event order is good (3)"); - ok(graph_port_added_src_pos < graph_ports_connected_pos, + ok(sink_accept_port_connection_pos < sink_port_connected_pos, "event order is good (4)"); + ok(src_port_connected_pos < graph_port_added_src_pos, + "event order is good (5)"); + ok(graph_port_added_src_pos < graph_ports_connected_pos, + "event order is good (6)"); bt_put(graph); bt_put(sink); @@ -924,23 +1114,40 @@ void test_simple(void) struct bt_port *sink_def_port; struct bt_connection *conn; struct event event; - size_t src_accept_port_conn_pos; - size_t sink_accept_port_conn_pos; + enum bt_graph_status status; + size_t src_accept_port_connection_pos; + size_t sink_accept_port_connection_pos; + size_t src_port_connected_pos; + size_t sink_port_connected_pos; size_t graph_ports_connected_pos; prepare_test(TEST_SIMPLE, "simple"); - src = create_src(); - sink = create_sink(); graph = create_graph(); - src_def_port = bt_component_source_get_default_output_port(src); + assert(graph); + src = create_src(graph); + sink = create_sink(graph); + src_def_port = bt_component_source_get_output_port_by_name(src, "out"); assert(src_def_port); - sink_def_port = bt_component_sink_get_default_input_port(sink); + sink_def_port = bt_component_sink_get_input_port_by_name(sink, "in"); assert(sink_def_port); - conn = bt_graph_connect_ports(graph, src_def_port, sink_def_port); - assert(conn); + status = bt_graph_connect_ports(graph, src_def_port, sink_def_port, + &conn); + assert(status == 0); - /* We're supposed to have 3 events */ - ok(events->len == 3, "we have the expected number of events"); + /* We're supposed to have 7 events */ + ok(events->len == 7, "we have the expected number of events"); + + /* Source's port added */ + event.type = GRAPH_PORT_ADDED; + event.data.graph_port_added.comp = src; + event.data.graph_port_added.port = src_def_port; + ok(has_event(&event), "got the expected graph's port added event (for source, initial)"); + + /* Sink's port added */ + event.type = GRAPH_PORT_ADDED; + event.data.graph_port_added.comp = sink; + event.data.graph_port_added.port = sink_def_port; + ok(has_event(&event), "got the expected graph's port added event (for sink, initial)"); /* Source's accept port connection */ event.type = COMP_ACCEPT_PORT_CONNECTION; @@ -948,7 +1155,7 @@ void test_simple(void) event.data.comp_accept_port_connection.self_port = src_def_port; event.data.comp_accept_port_connection.other_port = sink_def_port; ok(has_event(&event), "got the expected source's accept port connection event"); - src_accept_port_conn_pos = event_pos(&event); + src_accept_port_connection_pos = event_pos(&event); /* Sink's accept port connection */ event.type = COMP_ACCEPT_PORT_CONNECTION; @@ -956,7 +1163,23 @@ void test_simple(void) event.data.comp_accept_port_connection.self_port = sink_def_port; event.data.comp_accept_port_connection.other_port = src_def_port; ok(has_event(&event), "got the expected sink's accept port connection event"); - sink_accept_port_conn_pos = event_pos(&event); + sink_accept_port_connection_pos = event_pos(&event); + + /* Source's port connected */ + event.type = COMP_PORT_CONNECTED; + event.data.comp_port_connected.comp = src; + event.data.comp_port_connected.self_port = src_def_port; + event.data.comp_port_connected.other_port = sink_def_port; + ok(has_event(&event), "got the expected source's port connected event"); + src_port_connected_pos = event_pos(&event); + + /* Sink's port connected */ + event.type = COMP_PORT_CONNECTED; + event.data.comp_port_connected.comp = sink; + event.data.comp_port_connected.self_port = sink_def_port; + event.data.comp_port_connected.other_port = src_def_port; + ok(has_event(&event), "got the expected sink's port connected event"); + sink_port_connected_pos = event_pos(&event); /* Graph's port connected */ event.type = GRAPH_PORTS_CONNECTED; @@ -969,10 +1192,14 @@ void test_simple(void) graph_ports_connected_pos = event_pos(&event); /* Order of events */ - ok(src_accept_port_conn_pos < graph_ports_connected_pos, + ok(src_port_connected_pos < graph_ports_connected_pos, "event order is good (1)"); - ok(sink_accept_port_conn_pos < graph_ports_connected_pos, + ok(sink_port_connected_pos < graph_ports_connected_pos, "event order is good (2)"); + ok(src_accept_port_connection_pos < src_port_connected_pos, + "event order is good (3)"); + ok(sink_accept_port_connection_pos < sink_port_connected_pos, + "event order is good (4)"); bt_put(graph); bt_put(sink); @@ -999,9 +1226,9 @@ int main(int argc, char **argv) init_test(); test_empty_graph(); test_simple(); - test_src_adds_port_in_accept_port_connection(); - test_sink_removes_port_in_accept_port_connection(); - test_sink_removes_port_in_accept_port_connection_then_src_removes_disconnected_port(); + test_src_adds_port_in_port_connected(); + test_sink_removes_port_in_port_connected(); + test_sink_removes_port_in_port_connected_then_src_removes_disconnected_port(); fini_test(); return exit_status(); }