Commit | Line | Data |
---|---|---|
fb9935cc PP |
1 | /* |
2 | * test_graph_topo.c | |
3 | * | |
4 | * Copyright 2017 - Philippe Proulx <pproulx@efficios.com> | |
5 | * | |
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. | |
9 | * | |
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. | |
14 | * | |
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. | |
18 | */ | |
19 | ||
3fadfbc0 | 20 | #include <babeltrace2/babeltrace.h> |
578e048b | 21 | #include "common/assert.h" |
fb9935cc PP |
22 | #include <stdlib.h> |
23 | #include <string.h> | |
24 | #include <stdbool.h> | |
fb9935cc PP |
25 | #include <glib.h> |
26 | ||
27 | #include "tap/tap.h" | |
28 | ||
c594ab03 | 29 | #define NR_TESTS 33 |
fb9935cc PP |
30 | |
31 | enum event_type { | |
d94d92ac PP |
32 | SRC_COMP_OUTPUT_PORT_CONNECTED, |
33 | SINK_COMP_INPUT_PORT_CONNECTED, | |
d94d92ac PP |
34 | GRAPH_SRC_OUTPUT_PORT_ADDED, |
35 | GRAPH_SINK_INPUT_PORT_ADDED, | |
d94d92ac | 36 | GRAPH_SRC_SINK_PORTS_CONNECTED, |
fb9935cc PP |
37 | }; |
38 | ||
39 | enum test { | |
40 | TEST_EMPTY_GRAPH, | |
41 | TEST_SIMPLE, | |
bf55043c PP |
42 | TEST_SRC_PORT_CONNECTED_ERROR, |
43 | TEST_SINK_PORT_CONNECTED_ERROR, | |
c14181ff | 44 | TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED, |
fb9935cc PP |
45 | }; |
46 | ||
47 | struct event { | |
48 | enum event_type type; | |
49 | ||
50 | union { | |
d94d92ac | 51 | struct { |
b19ff26f PP |
52 | const bt_component *comp; |
53 | const bt_port *self_port; | |
54 | const bt_port *other_port; | |
d94d92ac | 55 | } src_comp_output_port_connected; |
fb9935cc | 56 | |
c14181ff | 57 | struct { |
b19ff26f PP |
58 | const bt_component *comp; |
59 | const bt_port *self_port; | |
60 | const bt_port *other_port; | |
d94d92ac PP |
61 | } sink_comp_input_port_connected; |
62 | ||
fb9935cc | 63 | struct { |
b19ff26f PP |
64 | const bt_component *comp; |
65 | const bt_port *port; | |
d94d92ac | 66 | } graph_src_output_port_added; |
fb9935cc PP |
67 | |
68 | struct { | |
b19ff26f PP |
69 | const bt_component *comp; |
70 | const bt_port *port; | |
d94d92ac | 71 | } graph_sink_input_port_added; |
fb9935cc | 72 | |
fb9935cc | 73 | struct { |
b19ff26f PP |
74 | const bt_component *upstream_comp; |
75 | const bt_component *downstream_comp; | |
76 | const bt_port *upstream_port; | |
77 | const bt_port *downstream_port; | |
d94d92ac | 78 | } graph_src_sink_ports_connected; |
fb9935cc PP |
79 | } data; |
80 | }; | |
81 | ||
82 | static GArray *events; | |
b19ff26f PP |
83 | static bt_component_class_source *src_comp_class; |
84 | static bt_component_class_sink *sink_comp_class; | |
fb9935cc PP |
85 | static enum test current_test; |
86 | ||
87 | static | |
88 | void clear_events(void) | |
89 | { | |
90 | g_array_set_size(events, 0); | |
91 | } | |
92 | ||
93 | static | |
94 | void append_event(struct event *event) | |
95 | { | |
96 | g_array_append_val(events, *event); | |
97 | } | |
98 | ||
99 | static | |
100 | bool compare_events(struct event *ev_a, struct event *ev_b) | |
101 | { | |
102 | if (ev_a->type != ev_b->type) { | |
103 | return false; | |
104 | } | |
105 | ||
106 | switch (ev_a->type) { | |
d94d92ac PP |
107 | case SRC_COMP_OUTPUT_PORT_CONNECTED: |
108 | if (ev_a->data.src_comp_output_port_connected.comp != | |
109 | ev_b->data.src_comp_output_port_connected.comp) { | |
110 | return false; | |
111 | } | |
112 | ||
113 | if (ev_a->data.src_comp_output_port_connected.self_port != | |
114 | ev_b->data.src_comp_output_port_connected.self_port) { | |
fb9935cc PP |
115 | return false; |
116 | } | |
117 | ||
d94d92ac PP |
118 | if (ev_a->data.src_comp_output_port_connected.other_port != |
119 | ev_b->data.src_comp_output_port_connected.other_port) { | |
fb9935cc PP |
120 | return false; |
121 | } | |
122 | break; | |
d94d92ac PP |
123 | case SINK_COMP_INPUT_PORT_CONNECTED: |
124 | if (ev_a->data.sink_comp_input_port_connected.comp != | |
125 | ev_b->data.sink_comp_input_port_connected.comp) { | |
fb9935cc PP |
126 | return false; |
127 | } | |
128 | ||
d94d92ac PP |
129 | if (ev_a->data.sink_comp_input_port_connected.self_port != |
130 | ev_b->data.sink_comp_input_port_connected.self_port) { | |
131 | return false; | |
132 | } | |
133 | ||
134 | if (ev_a->data.sink_comp_input_port_connected.other_port != | |
135 | ev_b->data.sink_comp_input_port_connected.other_port) { | |
fb9935cc PP |
136 | return false; |
137 | } | |
138 | break; | |
d94d92ac PP |
139 | case GRAPH_SRC_OUTPUT_PORT_ADDED: |
140 | if (ev_a->data.graph_src_output_port_added.comp != | |
141 | ev_b->data.graph_src_output_port_added.comp) { | |
fb9935cc PP |
142 | return false; |
143 | } | |
144 | ||
d94d92ac PP |
145 | if (ev_a->data.graph_src_output_port_added.port != |
146 | ev_b->data.graph_src_output_port_added.port) { | |
147 | return false; | |
148 | } | |
149 | break; | |
150 | case GRAPH_SINK_INPUT_PORT_ADDED: | |
151 | if (ev_a->data.graph_sink_input_port_added.comp != | |
152 | ev_b->data.graph_sink_input_port_added.comp) { | |
153 | return false; | |
154 | } | |
155 | ||
156 | if (ev_a->data.graph_sink_input_port_added.port != | |
157 | ev_b->data.graph_sink_input_port_added.port) { | |
158 | return false; | |
159 | } | |
160 | break; | |
d94d92ac PP |
161 | case GRAPH_SRC_SINK_PORTS_CONNECTED: |
162 | if (ev_a->data.graph_src_sink_ports_connected.upstream_comp != | |
163 | ev_b->data.graph_src_sink_ports_connected.upstream_comp) { | |
164 | return false; | |
165 | } | |
166 | ||
167 | if (ev_a->data.graph_src_sink_ports_connected.downstream_comp != | |
168 | ev_b->data.graph_src_sink_ports_connected.downstream_comp) { | |
fb9935cc PP |
169 | return false; |
170 | } | |
171 | ||
d94d92ac PP |
172 | if (ev_a->data.graph_src_sink_ports_connected.upstream_port != |
173 | ev_b->data.graph_src_sink_ports_connected.upstream_port) { | |
fb9935cc PP |
174 | return false; |
175 | } | |
176 | ||
d94d92ac PP |
177 | if (ev_a->data.graph_src_sink_ports_connected.downstream_port != |
178 | ev_b->data.graph_src_sink_ports_connected.downstream_port) { | |
fb9935cc PP |
179 | return false; |
180 | } | |
181 | break; | |
fb9935cc | 182 | default: |
0fbb9a9f | 183 | abort(); |
fb9935cc PP |
184 | } |
185 | ||
186 | return true; | |
187 | } | |
188 | ||
189 | static | |
190 | bool has_event(struct event *event) | |
191 | { | |
192 | size_t i; | |
193 | ||
194 | for (i = 0; i < events->len; i++) { | |
195 | struct event *ev = &g_array_index(events, struct event, i); | |
196 | ||
197 | if (compare_events(event, ev)) { | |
198 | return true; | |
199 | } | |
200 | } | |
201 | ||
202 | return false; | |
203 | } | |
204 | ||
205 | static | |
206 | size_t event_pos(struct event *event) | |
207 | { | |
208 | size_t i; | |
209 | ||
210 | for (i = 0; i < events->len; i++) { | |
211 | struct event *ev = &g_array_index(events, struct event, i); | |
212 | ||
213 | if (compare_events(event, ev)) { | |
214 | return i; | |
215 | } | |
216 | } | |
217 | ||
1974687e | 218 | return SIZE_MAX; |
fb9935cc PP |
219 | } |
220 | ||
221 | static | |
4cdfc5e8 | 222 | bt_self_message_iterator_status src_iter_next( |
d6e69534 PP |
223 | bt_self_message_iterator *self_iterator, |
224 | bt_message_array_const msgs, uint64_t capacity, | |
d4393e08 | 225 | uint64_t *count) |
fb9935cc | 226 | { |
d6e69534 | 227 | return BT_SELF_MESSAGE_ITERATOR_STATUS_ERROR; |
fb9935cc PP |
228 | } |
229 | ||
d94d92ac | 230 | static |
4cdfc5e8 | 231 | bt_self_component_status src_output_port_connected( |
b19ff26f PP |
232 | bt_self_component_source *self_comp, |
233 | bt_self_component_port_output *self_comp_port, | |
234 | const bt_port_input *other_port) | |
d94d92ac PP |
235 | { |
236 | int ret; | |
c14181ff | 237 | struct event event = { |
d94d92ac PP |
238 | .type = SRC_COMP_OUTPUT_PORT_CONNECTED, |
239 | .data.src_comp_output_port_connected = { | |
707b7d35 PP |
240 | .comp = bt_self_component_as_component( |
241 | bt_self_component_source_as_self_component( | |
d94d92ac | 242 | self_comp)), |
707b7d35 PP |
243 | .self_port = bt_self_component_port_as_port( |
244 | bt_self_component_port_output_as_self_component_port( | |
d94d92ac | 245 | self_comp_port)), |
0d72b8c3 | 246 | .other_port = bt_port_input_as_port_const(other_port), |
c14181ff PP |
247 | }, |
248 | }; | |
249 | ||
c14181ff | 250 | append_event(&event); |
fb9935cc PP |
251 | |
252 | switch (current_test) { | |
c14181ff | 253 | case TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED: |
d94d92ac PP |
254 | ret = bt_self_component_source_add_output_port( |
255 | self_comp, "hello", NULL, NULL); | |
25583cd0 | 256 | BT_ASSERT(ret == 0); |
fb9935cc | 257 | break; |
bf55043c | 258 | case TEST_SRC_PORT_CONNECTED_ERROR: |
d94d92ac | 259 | return BT_SELF_COMPONENT_STATUS_ERROR; |
fb9935cc PP |
260 | default: |
261 | break; | |
262 | } | |
bf55043c | 263 | |
d94d92ac | 264 | return BT_SELF_COMPONENT_STATUS_OK; |
fb9935cc PP |
265 | } |
266 | ||
267 | static | |
4cdfc5e8 | 268 | bt_self_component_status sink_input_port_connected( |
b19ff26f PP |
269 | bt_self_component_sink *self_comp, |
270 | bt_self_component_port_input *self_comp_port, | |
271 | const bt_port_output *other_port) | |
d94d92ac PP |
272 | { |
273 | struct event event = { | |
274 | .type = SINK_COMP_INPUT_PORT_CONNECTED, | |
275 | .data.sink_comp_input_port_connected = { | |
707b7d35 PP |
276 | .comp = bt_self_component_as_component( |
277 | bt_self_component_sink_as_self_component( | |
d94d92ac | 278 | self_comp)), |
707b7d35 PP |
279 | .self_port = bt_self_component_port_as_port( |
280 | bt_self_component_port_input_as_self_component_port( | |
d94d92ac | 281 | self_comp_port)), |
0d72b8c3 | 282 | .other_port = bt_port_output_as_port_const(other_port), |
d94d92ac PP |
283 | }, |
284 | }; | |
285 | ||
286 | append_event(&event); | |
287 | ||
288 | if (current_test == TEST_SINK_PORT_CONNECTED_ERROR) { | |
289 | return BT_SELF_COMPONENT_STATUS_ERROR; | |
290 | } else { | |
291 | return BT_SELF_COMPONENT_STATUS_OK; | |
292 | } | |
293 | } | |
294 | ||
d94d92ac | 295 | static |
4cdfc5e8 | 296 | bt_self_component_status src_init( |
b19ff26f PP |
297 | bt_self_component_source *self_comp, |
298 | const bt_value *params, void *init_method_data) | |
b9d103be | 299 | { |
147337a3 | 300 | int ret; |
b9d103be | 301 | |
d94d92ac PP |
302 | ret = bt_self_component_source_add_output_port( |
303 | self_comp, "out", NULL, NULL); | |
25583cd0 | 304 | BT_ASSERT(ret == 0); |
d94d92ac | 305 | return BT_SELF_COMPONENT_STATUS_OK; |
b9d103be PP |
306 | } |
307 | ||
fb9935cc | 308 | static |
4cdfc5e8 | 309 | bt_self_component_status sink_init( |
b19ff26f PP |
310 | bt_self_component_sink *self_comp, |
311 | const bt_value *params, void *init_method_data) | |
fb9935cc | 312 | { |
d94d92ac PP |
313 | int ret; |
314 | ||
315 | ret = bt_self_component_sink_add_input_port(self_comp, | |
316 | "in", NULL, NULL); | |
317 | BT_ASSERT(ret == 0); | |
318 | return BT_SELF_COMPONENT_STATUS_OK; | |
319 | } | |
320 | ||
321 | static | |
4cdfc5e8 | 322 | bt_self_component_status sink_consume( |
b19ff26f | 323 | bt_self_component_sink *self_comp) |
d94d92ac | 324 | { |
d94d92ac | 325 | return BT_SELF_COMPONENT_STATUS_OK; |
fb9935cc PP |
326 | } |
327 | ||
328 | static | |
8cc56726 SM |
329 | bt_graph_listener_status graph_src_output_port_added( |
330 | const bt_component_source *comp, const bt_port_output *port, | |
331 | void *data) | |
fb9935cc PP |
332 | { |
333 | struct event event = { | |
d94d92ac PP |
334 | .type = GRAPH_SRC_OUTPUT_PORT_ADDED, |
335 | .data.graph_src_output_port_added = { | |
0d72b8c3 PP |
336 | .comp = bt_component_source_as_component_const(comp), |
337 | .port = bt_port_output_as_port_const(port), | |
fb9935cc PP |
338 | }, |
339 | }; | |
340 | ||
fb9935cc | 341 | append_event(&event); |
8cc56726 SM |
342 | |
343 | return BT_GRAPH_LISTENER_STATUS_OK; | |
fb9935cc PP |
344 | } |
345 | ||
346 | static | |
8cc56726 SM |
347 | bt_graph_listener_status graph_sink_input_port_added( |
348 | const bt_component_sink *comp, const bt_port_input *port, | |
349 | void *data) | |
fb9935cc PP |
350 | { |
351 | struct event event = { | |
d94d92ac PP |
352 | .type = GRAPH_SINK_INPUT_PORT_ADDED, |
353 | .data.graph_sink_input_port_added = { | |
0d72b8c3 PP |
354 | .comp = bt_component_sink_as_component_const(comp), |
355 | .port = bt_port_input_as_port_const(port), | |
fb9935cc PP |
356 | }, |
357 | }; | |
358 | ||
fb9935cc | 359 | append_event(&event); |
8cc56726 SM |
360 | |
361 | return BT_GRAPH_LISTENER_STATUS_OK; | |
fb9935cc PP |
362 | } |
363 | ||
fb9935cc | 364 | static |
8cc56726 SM |
365 | bt_graph_listener_status graph_src_sink_ports_connected( |
366 | const bt_component_source *upstream_comp, | |
b19ff26f PP |
367 | const bt_component_sink *downstream_comp, |
368 | const bt_port_output *upstream_port, | |
369 | const bt_port_input *downstream_port, void *data) | |
fb9935cc | 370 | { |
fb9935cc | 371 | struct event event = { |
d94d92ac PP |
372 | .type = GRAPH_SRC_SINK_PORTS_CONNECTED, |
373 | .data.graph_src_sink_ports_connected = { | |
374 | .upstream_comp = | |
0d72b8c3 PP |
375 | bt_component_source_as_component_const(upstream_comp), |
376 | .downstream_comp = | |
377 | bt_component_sink_as_component_const(downstream_comp), | |
378 | .upstream_port = | |
379 | bt_port_output_as_port_const(upstream_port), | |
380 | .downstream_port = | |
381 | bt_port_input_as_port_const(downstream_port), | |
fb9935cc PP |
382 | }, |
383 | }; | |
384 | ||
385 | append_event(&event); | |
8cc56726 SM |
386 | |
387 | return BT_GRAPH_LISTENER_STATUS_OK; | |
fb9935cc PP |
388 | } |
389 | ||
fb9935cc PP |
390 | static |
391 | void init_test(void) | |
392 | { | |
393 | int ret; | |
394 | ||
0d72b8c3 | 395 | src_comp_class = bt_component_class_source_create( |
d94d92ac | 396 | "src", src_iter_next); |
25583cd0 | 397 | BT_ASSERT(src_comp_class); |
0d72b8c3 | 398 | ret = bt_component_class_source_set_init_method( |
d94d92ac | 399 | src_comp_class, src_init); |
25583cd0 | 400 | BT_ASSERT(ret == 0); |
0d72b8c3 | 401 | ret = bt_component_class_source_set_output_port_connected_method( |
d94d92ac | 402 | src_comp_class, src_output_port_connected); |
25583cd0 | 403 | BT_ASSERT(ret == 0); |
0d72b8c3 | 404 | sink_comp_class = bt_component_class_sink_create("sink", |
d94d92ac | 405 | sink_consume); |
25583cd0 | 406 | BT_ASSERT(sink_comp_class); |
0d72b8c3 | 407 | ret = bt_component_class_sink_set_init_method(sink_comp_class, |
d94d92ac | 408 | sink_init); |
25583cd0 | 409 | BT_ASSERT(ret == 0); |
0d72b8c3 | 410 | ret = bt_component_class_sink_set_input_port_connected_method( |
d94d92ac | 411 | sink_comp_class, sink_input_port_connected); |
25583cd0 | 412 | BT_ASSERT(ret == 0); |
fb9935cc | 413 | events = g_array_new(FALSE, TRUE, sizeof(struct event)); |
25583cd0 | 414 | BT_ASSERT(events); |
fb9935cc PP |
415 | } |
416 | ||
417 | static | |
418 | void fini_test(void) | |
419 | { | |
c5b9b441 PP |
420 | bt_component_class_source_put_ref(src_comp_class); |
421 | bt_component_class_sink_put_ref(sink_comp_class); | |
fb9935cc PP |
422 | g_array_free(events, TRUE); |
423 | } | |
424 | ||
425 | static | |
b19ff26f | 426 | const bt_component_source *create_src(bt_graph *graph) |
fb9935cc | 427 | { |
b19ff26f | 428 | const bt_component_source *comp; |
36712f1d | 429 | int ret; |
fb9935cc | 430 | |
0d72b8c3 | 431 | ret = bt_graph_add_source_component(graph, src_comp_class, |
e874da19 | 432 | "src-comp", NULL, BT_LOGGING_LEVEL_NONE, &comp); |
25583cd0 | 433 | BT_ASSERT(ret == 0); |
fb9935cc PP |
434 | return comp; |
435 | } | |
436 | ||
437 | static | |
b19ff26f | 438 | const bt_component_sink *create_sink(bt_graph *graph) |
fb9935cc | 439 | { |
b19ff26f | 440 | const bt_component_sink *comp; |
36712f1d | 441 | int ret; |
fb9935cc | 442 | |
0d72b8c3 | 443 | ret = bt_graph_add_sink_component(graph, sink_comp_class, |
e874da19 | 444 | "sink-comp", NULL, BT_LOGGING_LEVEL_NONE, &comp); |
25583cd0 | 445 | BT_ASSERT(ret == 0); |
fb9935cc PP |
446 | return comp; |
447 | } | |
448 | ||
449 | static | |
b19ff26f | 450 | bt_graph *create_graph(void) |
fb9935cc | 451 | { |
b19ff26f | 452 | bt_graph *graph = bt_graph_create(); |
fb9935cc PP |
453 | int ret; |
454 | ||
25583cd0 | 455 | BT_ASSERT(graph); |
0d72b8c3 | 456 | ret = bt_graph_add_source_component_output_port_added_listener( |
d94d92ac PP |
457 | graph, graph_src_output_port_added, NULL, NULL, NULL); |
458 | BT_ASSERT(ret >= 0); | |
0d72b8c3 | 459 | ret = bt_graph_add_sink_component_input_port_added_listener( |
d94d92ac | 460 | graph, graph_sink_input_port_added, NULL, NULL, NULL); |
25583cd0 | 461 | BT_ASSERT(ret >= 0); |
0d72b8c3 | 462 | ret = bt_graph_add_source_sink_component_ports_connected_listener( |
d94d92ac PP |
463 | graph, graph_src_sink_ports_connected, NULL, NULL, NULL); |
464 | BT_ASSERT(ret >= 0); | |
fb9935cc PP |
465 | return graph; |
466 | } | |
467 | ||
468 | static | |
469 | void prepare_test(enum test test, const char *name) | |
470 | { | |
471 | clear_events(); | |
472 | current_test = test; | |
473 | diag("test: %s", name); | |
474 | } | |
475 | ||
fb9935cc | 476 | static |
c14181ff | 477 | void test_src_adds_port_in_port_connected(void) |
fb9935cc | 478 | { |
b19ff26f PP |
479 | const bt_component_source *src; |
480 | const bt_component_sink *sink; | |
481 | const bt_component *gsrc; | |
482 | const bt_component *gsink; | |
483 | bt_graph *graph; | |
484 | const bt_port_output *src_def_port; | |
485 | const bt_port_output *src_hello_port; | |
486 | const bt_port_input *sink_def_port; | |
487 | const bt_port *gsrc_def_port; | |
488 | const bt_port *gsrc_hello_port; | |
489 | const bt_port *gsink_def_port; | |
fb9935cc | 490 | struct event event; |
4cdfc5e8 | 491 | bt_graph_status status; |
c14181ff PP |
492 | size_t src_port_connected_pos; |
493 | size_t sink_port_connected_pos; | |
fb9935cc PP |
494 | size_t graph_ports_connected_pos; |
495 | size_t graph_port_added_src_pos; | |
496 | ||
c14181ff PP |
497 | prepare_test(TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED, |
498 | "source adds port in port connected"); | |
fb9935cc | 499 | graph = create_graph(); |
25583cd0 | 500 | BT_ASSERT(graph); |
36712f1d PP |
501 | src = create_src(graph); |
502 | sink = create_sink(graph); | |
0d72b8c3 PP |
503 | src_def_port = bt_component_source_borrow_output_port_by_name_const(src, |
504 | "out"); | |
25583cd0 | 505 | BT_ASSERT(src_def_port); |
0d72b8c3 PP |
506 | sink_def_port = bt_component_sink_borrow_input_port_by_name_const(sink, |
507 | "in"); | |
25583cd0 | 508 | BT_ASSERT(sink_def_port); |
0d72b8c3 | 509 | status = bt_graph_connect_ports(graph, src_def_port, |
d94d92ac | 510 | sink_def_port, NULL); |
25583cd0 | 511 | BT_ASSERT(status == 0); |
0d72b8c3 PP |
512 | src_hello_port = bt_component_source_borrow_output_port_by_name_const(src, |
513 | "hello"); | |
25583cd0 | 514 | BT_ASSERT(src_hello_port); |
0d72b8c3 PP |
515 | gsrc = bt_component_source_as_component_const(src); |
516 | gsink = bt_component_sink_as_component_const(sink); | |
517 | gsrc_def_port = bt_port_output_as_port_const(src_def_port); | |
518 | gsrc_hello_port = bt_port_output_as_port_const(src_hello_port); | |
519 | gsink_def_port = bt_port_input_as_port_const(sink_def_port); | |
fb9935cc | 520 | |
c594ab03 SM |
521 | /* We're supposed to have 6 events */ |
522 | ok(events->len == 6, "we have the expected number of events"); | |
36712f1d PP |
523 | |
524 | /* Source's port added */ | |
d94d92ac PP |
525 | event.type = GRAPH_SRC_OUTPUT_PORT_ADDED; |
526 | event.data.graph_src_output_port_added.comp = gsrc; | |
527 | event.data.graph_src_output_port_added.port = gsrc_def_port; | |
36712f1d PP |
528 | ok(has_event(&event), "got the expected graph's port added event (for source, initial)"); |
529 | ||
530 | /* Sink's port added */ | |
d94d92ac PP |
531 | event.type = GRAPH_SINK_INPUT_PORT_ADDED; |
532 | event.data.graph_sink_input_port_added.comp = gsink; | |
533 | event.data.graph_sink_input_port_added.port = gsink_def_port; | |
36712f1d | 534 | ok(has_event(&event), "got the expected graph's port added event (for sink, initial)"); |
fb9935cc | 535 | |
c14181ff | 536 | /* Source's port connected */ |
d94d92ac PP |
537 | event.type = SRC_COMP_OUTPUT_PORT_CONNECTED; |
538 | event.data.src_comp_output_port_connected.comp = gsrc; | |
539 | event.data.src_comp_output_port_connected.self_port = gsrc_def_port; | |
540 | event.data.src_comp_output_port_connected.other_port = gsink_def_port; | |
c14181ff PP |
541 | ok(has_event(&event), "got the expected source's port connected event"); |
542 | src_port_connected_pos = event_pos(&event); | |
fb9935cc PP |
543 | |
544 | /* Graph's port added (source) */ | |
d94d92ac PP |
545 | event.type = GRAPH_SRC_OUTPUT_PORT_ADDED; |
546 | event.data.graph_src_output_port_added.comp = gsrc; | |
547 | event.data.graph_src_output_port_added.port = gsrc_hello_port; | |
fb9935cc PP |
548 | ok(has_event(&event), "got the expected graph's port added event (for source)"); |
549 | graph_port_added_src_pos = event_pos(&event); | |
550 | ||
c14181ff | 551 | /* Sink's port connected */ |
d94d92ac PP |
552 | event.type = SINK_COMP_INPUT_PORT_CONNECTED; |
553 | event.data.sink_comp_input_port_connected.comp = gsink; | |
554 | event.data.sink_comp_input_port_connected.self_port = gsink_def_port; | |
555 | event.data.sink_comp_input_port_connected.other_port = gsrc_def_port; | |
c14181ff PP |
556 | ok(has_event(&event), "got the expected sink's port connected event"); |
557 | sink_port_connected_pos = event_pos(&event); | |
fb9935cc PP |
558 | |
559 | /* Graph's ports connected */ | |
d94d92ac PP |
560 | event.type = GRAPH_SRC_SINK_PORTS_CONNECTED; |
561 | event.data.graph_src_sink_ports_connected.upstream_comp = gsrc; | |
562 | event.data.graph_src_sink_ports_connected.downstream_comp = gsink; | |
563 | event.data.graph_src_sink_ports_connected.upstream_port = gsrc_def_port; | |
564 | event.data.graph_src_sink_ports_connected.downstream_port = gsink_def_port; | |
565 | ok(has_event(&event), "got the expected graph's ports connected event"); | |
fb9935cc PP |
566 | graph_ports_connected_pos = event_pos(&event); |
567 | ||
568 | /* Order of events */ | |
c14181ff | 569 | ok(src_port_connected_pos < graph_ports_connected_pos, |
fb9935cc | 570 | "event order is good (1)"); |
c14181ff | 571 | ok(sink_port_connected_pos < graph_ports_connected_pos, |
fb9935cc | 572 | "event order is good (2)"); |
c14181ff | 573 | ok(src_port_connected_pos < graph_port_added_src_pos, |
c594ab03 | 574 | "event order is good (3)"); |
c14181ff | 575 | ok(graph_port_added_src_pos < graph_ports_connected_pos, |
c594ab03 | 576 | "event order is good (4)"); |
fb9935cc | 577 | |
c5b9b441 PP |
578 | bt_component_source_put_ref(src); |
579 | bt_component_sink_put_ref(sink); | |
580 | bt_graph_put_ref(graph); | |
fb9935cc PP |
581 | } |
582 | ||
583 | static | |
584 | void test_simple(void) | |
585 | { | |
b19ff26f PP |
586 | const bt_component_source *src; |
587 | const bt_component_sink *sink; | |
588 | const bt_component *gsrc; | |
589 | const bt_component *gsink; | |
590 | bt_graph *graph; | |
591 | const bt_port_output *src_def_port; | |
592 | const bt_port_input *sink_def_port; | |
593 | const bt_port *gsrc_def_port; | |
594 | const bt_port *gsink_def_port; | |
fb9935cc | 595 | struct event event; |
4cdfc5e8 | 596 | bt_graph_status status; |
c14181ff PP |
597 | size_t src_port_connected_pos; |
598 | size_t sink_port_connected_pos; | |
fb9935cc PP |
599 | size_t graph_ports_connected_pos; |
600 | ||
601 | prepare_test(TEST_SIMPLE, "simple"); | |
fb9935cc | 602 | graph = create_graph(); |
25583cd0 | 603 | BT_ASSERT(graph); |
36712f1d PP |
604 | src = create_src(graph); |
605 | sink = create_sink(graph); | |
0d72b8c3 PP |
606 | src_def_port = bt_component_source_borrow_output_port_by_name_const(src, |
607 | "out"); | |
25583cd0 | 608 | BT_ASSERT(src_def_port); |
0d72b8c3 PP |
609 | sink_def_port = bt_component_sink_borrow_input_port_by_name_const(sink, |
610 | "in"); | |
25583cd0 | 611 | BT_ASSERT(sink_def_port); |
0d72b8c3 | 612 | status = bt_graph_connect_ports(graph, src_def_port, |
d94d92ac | 613 | sink_def_port, NULL); |
25583cd0 | 614 | BT_ASSERT(status == 0); |
0d72b8c3 PP |
615 | gsrc = bt_component_source_as_component_const(src); |
616 | gsink = bt_component_sink_as_component_const(sink); | |
617 | gsrc_def_port = bt_port_output_as_port_const(src_def_port); | |
618 | gsink_def_port = bt_port_input_as_port_const(sink_def_port); | |
fb9935cc | 619 | |
c594ab03 SM |
620 | /* We're supposed to have 5 events */ |
621 | ok(events->len == 5, "we have the expected number of events"); | |
36712f1d PP |
622 | |
623 | /* Source's port added */ | |
d94d92ac PP |
624 | event.type = GRAPH_SRC_OUTPUT_PORT_ADDED; |
625 | event.data.graph_src_output_port_added.comp = gsrc; | |
626 | event.data.graph_src_output_port_added.port = gsrc_def_port; | |
36712f1d PP |
627 | ok(has_event(&event), "got the expected graph's port added event (for source, initial)"); |
628 | ||
629 | /* Sink's port added */ | |
d94d92ac PP |
630 | event.type = GRAPH_SINK_INPUT_PORT_ADDED; |
631 | event.data.graph_sink_input_port_added.comp = gsink; | |
632 | event.data.graph_sink_input_port_added.port = gsink_def_port; | |
36712f1d | 633 | ok(has_event(&event), "got the expected graph's port added event (for sink, initial)"); |
fb9935cc | 634 | |
c14181ff | 635 | /* Source's port connected */ |
d94d92ac PP |
636 | event.type = SRC_COMP_OUTPUT_PORT_CONNECTED; |
637 | event.data.src_comp_output_port_connected.comp = gsrc; | |
638 | event.data.src_comp_output_port_connected.self_port = gsrc_def_port; | |
639 | event.data.src_comp_output_port_connected.other_port = gsink_def_port; | |
c14181ff PP |
640 | ok(has_event(&event), "got the expected source's port connected event"); |
641 | src_port_connected_pos = event_pos(&event); | |
642 | ||
643 | /* Sink's port connected */ | |
d94d92ac PP |
644 | event.type = SINK_COMP_INPUT_PORT_CONNECTED; |
645 | event.data.sink_comp_input_port_connected.comp = gsink; | |
646 | event.data.sink_comp_input_port_connected.self_port = gsink_def_port; | |
647 | event.data.sink_comp_input_port_connected.other_port = gsrc_def_port; | |
c14181ff PP |
648 | ok(has_event(&event), "got the expected sink's port connected event"); |
649 | sink_port_connected_pos = event_pos(&event); | |
fb9935cc | 650 | |
d94d92ac PP |
651 | /* Graph's ports connected */ |
652 | event.type = GRAPH_SRC_SINK_PORTS_CONNECTED; | |
653 | event.data.graph_src_sink_ports_connected.upstream_comp = gsrc; | |
654 | event.data.graph_src_sink_ports_connected.downstream_comp = gsink; | |
655 | event.data.graph_src_sink_ports_connected.upstream_port = gsrc_def_port; | |
656 | event.data.graph_src_sink_ports_connected.downstream_port = gsink_def_port; | |
fb9935cc PP |
657 | ok(has_event(&event), "got the expected graph's ports connected event"); |
658 | graph_ports_connected_pos = event_pos(&event); | |
659 | ||
660 | /* Order of events */ | |
c14181ff | 661 | ok(src_port_connected_pos < graph_ports_connected_pos, |
fb9935cc | 662 | "event order is good (1)"); |
c14181ff | 663 | ok(sink_port_connected_pos < graph_ports_connected_pos, |
fb9935cc PP |
664 | "event order is good (2)"); |
665 | ||
c5b9b441 PP |
666 | bt_component_sink_put_ref(sink); |
667 | bt_graph_put_ref(graph); | |
668 | bt_component_source_put_ref(src); | |
fb9935cc PP |
669 | } |
670 | ||
bf55043c PP |
671 | static |
672 | void test_src_port_connected_error(void) | |
673 | { | |
b19ff26f PP |
674 | const bt_component_source *src; |
675 | const bt_component_sink *sink; | |
676 | const bt_component *gsrc; | |
677 | const bt_component *gsink; | |
678 | bt_graph *graph; | |
679 | const bt_port_output *src_def_port; | |
680 | const bt_port_input *sink_def_port; | |
681 | const bt_port *gsrc_def_port; | |
682 | const bt_port *gsink_def_port; | |
683 | const bt_connection *conn = NULL; | |
bf55043c | 684 | struct event event; |
4cdfc5e8 | 685 | bt_graph_status status; |
bf55043c PP |
686 | |
687 | prepare_test(TEST_SRC_PORT_CONNECTED_ERROR, "port connected error: source"); | |
688 | graph = create_graph(); | |
689 | BT_ASSERT(graph); | |
690 | src = create_src(graph); | |
691 | sink = create_sink(graph); | |
0d72b8c3 PP |
692 | src_def_port = bt_component_source_borrow_output_port_by_name_const(src, |
693 | "out"); | |
bf55043c | 694 | BT_ASSERT(src_def_port); |
0d72b8c3 PP |
695 | sink_def_port = bt_component_sink_borrow_input_port_by_name_const(sink, |
696 | "in"); | |
bf55043c | 697 | BT_ASSERT(sink_def_port); |
0d72b8c3 | 698 | status = bt_graph_connect_ports(graph, src_def_port, |
d94d92ac | 699 | sink_def_port, &conn); |
bf55043c | 700 | ok(status != BT_GRAPH_STATUS_OK, |
0d72b8c3 | 701 | "bt_graph_connect_ports() returns an error"); |
d94d92ac | 702 | ok(!conn, "returned connection is still NULL"); |
0d72b8c3 PP |
703 | gsrc = bt_component_source_as_component_const(src); |
704 | gsink = bt_component_sink_as_component_const(sink); | |
705 | gsrc_def_port = bt_port_output_as_port_const(src_def_port); | |
706 | gsink_def_port = bt_port_input_as_port_const(sink_def_port); | |
bf55043c | 707 | |
c594ab03 SM |
708 | /* We're supposed to have 3 events */ |
709 | ok(events->len == 3, "we have the expected number of events"); | |
bf55043c PP |
710 | |
711 | /* Source's port added */ | |
d94d92ac PP |
712 | event.type = GRAPH_SRC_OUTPUT_PORT_ADDED; |
713 | event.data.graph_src_output_port_added.comp = gsrc; | |
714 | event.data.graph_src_output_port_added.port = gsrc_def_port; | |
bf55043c PP |
715 | ok(has_event(&event), "got the expected graph's port added event (for source, initial)"); |
716 | ||
717 | /* Sink's port added */ | |
d94d92ac PP |
718 | event.type = GRAPH_SINK_INPUT_PORT_ADDED; |
719 | event.data.graph_sink_input_port_added.comp = gsink; | |
720 | event.data.graph_sink_input_port_added.port = gsink_def_port; | |
bf55043c PP |
721 | ok(has_event(&event), "got the expected graph's port added event (for sink, initial)"); |
722 | ||
bf55043c | 723 | /* Source's port connected */ |
d94d92ac PP |
724 | event.type = SRC_COMP_OUTPUT_PORT_CONNECTED; |
725 | event.data.src_comp_output_port_connected.comp = gsrc; | |
726 | event.data.src_comp_output_port_connected.self_port = gsrc_def_port; | |
727 | event.data.src_comp_output_port_connected.other_port = gsink_def_port; | |
bf55043c | 728 | ok(has_event(&event), "got the expected source's port connected event"); |
bf55043c | 729 | |
c5b9b441 PP |
730 | bt_graph_put_ref(graph); |
731 | bt_component_sink_put_ref(sink); | |
732 | bt_component_source_put_ref(src); | |
733 | bt_connection_put_ref(conn); | |
bf55043c PP |
734 | } |
735 | ||
736 | static | |
737 | void test_sink_port_connected_error(void) | |
738 | { | |
b19ff26f PP |
739 | const bt_component_source *src; |
740 | const bt_component_sink *sink; | |
741 | const bt_component *gsrc; | |
742 | const bt_component *gsink; | |
743 | bt_graph *graph; | |
744 | const bt_port_output *src_def_port; | |
745 | const bt_port_input *sink_def_port; | |
746 | const bt_port *gsrc_def_port; | |
747 | const bt_port *gsink_def_port; | |
748 | const bt_connection *conn = NULL; | |
bf55043c | 749 | struct event event; |
4cdfc5e8 | 750 | bt_graph_status status; |
bf55043c PP |
751 | |
752 | prepare_test(TEST_SINK_PORT_CONNECTED_ERROR, "port connected error: sink"); | |
753 | graph = create_graph(); | |
754 | BT_ASSERT(graph); | |
755 | src = create_src(graph); | |
756 | sink = create_sink(graph); | |
0d72b8c3 PP |
757 | src_def_port = bt_component_source_borrow_output_port_by_name_const(src, |
758 | "out"); | |
bf55043c | 759 | BT_ASSERT(src_def_port); |
0d72b8c3 PP |
760 | sink_def_port = bt_component_sink_borrow_input_port_by_name_const(sink, |
761 | "in"); | |
bf55043c | 762 | BT_ASSERT(sink_def_port); |
0d72b8c3 | 763 | status = bt_graph_connect_ports(graph, src_def_port, |
d94d92ac | 764 | sink_def_port, &conn); |
bf55043c | 765 | ok(status != BT_GRAPH_STATUS_OK, |
0d72b8c3 | 766 | "bt_graph_connect_ports() returns an error"); |
d94d92ac | 767 | ok(!conn, "returned connection is still NULL"); |
0d72b8c3 PP |
768 | gsrc = bt_component_source_as_component_const(src); |
769 | gsink = bt_component_sink_as_component_const(sink); | |
770 | gsrc_def_port = bt_port_output_as_port_const(src_def_port); | |
771 | gsink_def_port = bt_port_input_as_port_const(sink_def_port); | |
bf55043c | 772 | |
c594ab03 SM |
773 | /* We're supposed to have 4 events */ |
774 | ok(events->len == 4, "we have the expected number of events"); | |
bf55043c PP |
775 | |
776 | /* Source's port added */ | |
d94d92ac PP |
777 | event.type = GRAPH_SRC_OUTPUT_PORT_ADDED; |
778 | event.data.graph_src_output_port_added.comp = gsrc; | |
779 | event.data.graph_src_output_port_added.port = gsrc_def_port; | |
bf55043c PP |
780 | ok(has_event(&event), "got the expected graph's port added event (for source, initial)"); |
781 | ||
782 | /* Sink's port added */ | |
d94d92ac PP |
783 | event.type = GRAPH_SINK_INPUT_PORT_ADDED; |
784 | event.data.graph_sink_input_port_added.comp = gsink; | |
785 | event.data.graph_sink_input_port_added.port = gsink_def_port; | |
bf55043c PP |
786 | ok(has_event(&event), "got the expected graph's port added event (for sink, initial)"); |
787 | ||
bf55043c | 788 | /* Source's port connected */ |
d94d92ac PP |
789 | event.type = SRC_COMP_OUTPUT_PORT_CONNECTED; |
790 | event.data.src_comp_output_port_connected.comp = gsrc; | |
791 | event.data.src_comp_output_port_connected.self_port = gsrc_def_port; | |
792 | event.data.src_comp_output_port_connected.other_port = gsink_def_port; | |
bf55043c | 793 | ok(has_event(&event), "got the expected source's port connected event"); |
bf55043c PP |
794 | |
795 | /* Sink's port connected */ | |
d94d92ac PP |
796 | event.type = SINK_COMP_INPUT_PORT_CONNECTED; |
797 | event.data.sink_comp_input_port_connected.comp = gsink; | |
798 | event.data.sink_comp_input_port_connected.self_port = gsink_def_port; | |
799 | event.data.sink_comp_input_port_connected.other_port = gsrc_def_port; | |
bf55043c | 800 | ok(has_event(&event), "got the expected sink's port connected event"); |
bf55043c | 801 | |
c5b9b441 PP |
802 | bt_connection_put_ref(conn); |
803 | bt_graph_put_ref(graph); | |
804 | bt_component_sink_put_ref(sink); | |
805 | bt_component_source_put_ref(src); | |
bf55043c PP |
806 | } |
807 | ||
fb9935cc PP |
808 | static |
809 | void test_empty_graph(void) | |
810 | { | |
b19ff26f | 811 | bt_graph *graph; |
fb9935cc PP |
812 | |
813 | prepare_test(TEST_EMPTY_GRAPH, "empty graph"); | |
814 | graph = create_graph(); | |
815 | ok(events->len == 0, "empty graph generates no events"); | |
c5b9b441 | 816 | bt_graph_put_ref(graph); |
fb9935cc PP |
817 | } |
818 | ||
819 | int main(int argc, char **argv) | |
820 | { | |
821 | plan_tests(NR_TESTS); | |
822 | init_test(); | |
823 | test_empty_graph(); | |
824 | test_simple(); | |
bf55043c PP |
825 | test_src_port_connected_error(); |
826 | test_sink_port_connected_error(); | |
c14181ff | 827 | test_src_adds_port_in_port_connected(); |
fb9935cc PP |
828 | fini_test(); |
829 | return exit_status(); | |
830 | } |