projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix: tests: free message iterator class in test_graph_topo.c
[babeltrace.git] / tests / lib / test_graph_topo.c
CommitLineData
21d04293 1/*
0235b0db 2 * SPDX-License-Identifier: GPL-2.0-only
21d04293 3 *
0235b0db 4 * Copyright (C) 2017 Philippe Proulx <pproulx@efficios.com>
21d04293
PP		 5 */
6
7#include <babeltrace2/babeltrace.h>
8#include "common/assert.h"
9#include <stdlib.h>
10#include <string.h>
11#include <stdbool.h>
12#include <glib.h>
13
14#include "tap/tap.h"
15
2945edfe 16#define NR_TESTS 26
21d04293
PP		 17
18enum event_type {
19 SRC_COMP_OUTPUT_PORT_CONNECTED,
20 SINK_COMP_INPUT_PORT_CONNECTED,
21 GRAPH_SRC_OUTPUT_PORT_ADDED,
22 GRAPH_SINK_INPUT_PORT_ADDED,
21d04293
PP		 23};
24
25enum test {
26 TEST_EMPTY_GRAPH,
27 TEST_SIMPLE,
28 TEST_SRC_PORT_CONNECTED_ERROR,
29 TEST_SINK_PORT_CONNECTED_ERROR,
30 TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED,
31};
32
33struct event {
34 enum event_type type;
35
36 union {
37 struct {
38 const bt_component *comp;
39 const bt_port *self_port;
40 const bt_port *other_port;
41 } src_comp_output_port_connected;
42
43 struct {
44 const bt_component *comp;
45 const bt_port *self_port;
46 const bt_port *other_port;
47 } sink_comp_input_port_connected;
48
49 struct {
50 const bt_component *comp;
51 const bt_port *port;
52 } graph_src_output_port_added;
53
54 struct {
55 const bt_component *comp;
56 const bt_port *port;
57 } graph_sink_input_port_added;
21d04293
PP		 58 } data;
59};
60
61static GArray *events;
a3f0c7db 62static bt_message_iterator_class *msg_iter_class;
21d04293
PP		 63static bt_component_class_source *src_comp_class;
64static bt_component_class_sink *sink_comp_class;
65static enum test current_test;
66
67static
68void clear_events(void)
69{
70 g_array_set_size(events, 0);
71}
72
73static
74void append_event(struct event *event)
75{
76 g_array_append_val(events, *event);
77}
78
79static
80bool compare_events(struct event *ev_a, struct event *ev_b)
81{
82 if (ev_a->type != ev_b->type) {
83 return false;
84 }
85
86 switch (ev_a->type) {
87 case SRC_COMP_OUTPUT_PORT_CONNECTED:
88 if (ev_a->data.src_comp_output_port_connected.comp !=
89 ev_b->data.src_comp_output_port_connected.comp) {
90 return false;
91 }
92
93 if (ev_a->data.src_comp_output_port_connected.self_port !=
94 ev_b->data.src_comp_output_port_connected.self_port) {
95 return false;
96 }
97
98 if (ev_a->data.src_comp_output_port_connected.other_port !=
99 ev_b->data.src_comp_output_port_connected.other_port) {
100 return false;
101 }
102 break;
103 case SINK_COMP_INPUT_PORT_CONNECTED:
104 if (ev_a->data.sink_comp_input_port_connected.comp !=
105 ev_b->data.sink_comp_input_port_connected.comp) {
106 return false;
107 }
108
109 if (ev_a->data.sink_comp_input_port_connected.self_port !=
110 ev_b->data.sink_comp_input_port_connected.self_port) {
111 return false;
112 }
113
114 if (ev_a->data.sink_comp_input_port_connected.other_port !=
115 ev_b->data.sink_comp_input_port_connected.other_port) {
116 return false;
117 }
118 break;
119 case GRAPH_SRC_OUTPUT_PORT_ADDED:
120 if (ev_a->data.graph_src_output_port_added.comp !=
121 ev_b->data.graph_src_output_port_added.comp) {
122 return false;
123 }
124
125 if (ev_a->data.graph_src_output_port_added.port !=
126 ev_b->data.graph_src_output_port_added.port) {
127 return false;
128 }
129 break;
130 case GRAPH_SINK_INPUT_PORT_ADDED:
131 if (ev_a->data.graph_sink_input_port_added.comp !=
132 ev_b->data.graph_sink_input_port_added.comp) {
133 return false;
134 }
135
136 if (ev_a->data.graph_sink_input_port_added.port !=
137 ev_b->data.graph_sink_input_port_added.port) {
138 return false;
139 }
140 break;
21d04293
PP		 141 default:
142 abort();
143 }
144
145 return true;
146}
147
148static
149bool has_event(struct event *event)
150{
151 size_t i;
152
153 for (i = 0; i < events->len; i++) {
154 struct event *ev = &g_array_index(events, struct event, i);
155
156 if (compare_events(event, ev)) {
157 return true;
158 }
159 }
160
161 return false;
162}
163
164static
165size_t event_pos(struct event *event)
166{
167 size_t i;
168
169 for (i = 0; i < events->len; i++) {
170 struct event *ev = &g_array_index(events, struct event, i);
171
172 if (compare_events(event, ev)) {
173 return i;
174 }
175 }
176
177 return SIZE_MAX;
178}
179
180static
a3f0c7db 181bt_message_iterator_class_next_method_status src_iter_next(
21d04293
PP		 182 bt_self_message_iterator *self_iterator,
183 bt_message_array_const msgs, uint64_t capacity,
184 uint64_t *count)
185{
a3f0c7db 186 return BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
21d04293
PP		 187}
188
189static
190bt_component_class_port_connected_method_status src_output_port_connected(
191 bt_self_component_source *self_comp,
192 bt_self_component_port_output *self_comp_port,
193 const bt_port_input *other_port)
194{
195 int ret;
196 struct event event = {
197 .type = SRC_COMP_OUTPUT_PORT_CONNECTED,
198 .data.src_comp_output_port_connected = {
199 .comp = bt_self_component_as_component(
200 bt_self_component_source_as_self_component(
201 self_comp)),
202 .self_port = bt_self_component_port_as_port(
203 bt_self_component_port_output_as_self_component_port(
204 self_comp_port)),
205 .other_port = bt_port_input_as_port_const(other_port),
206 },
207 };
208
209 append_event(&event);
210
211 switch (current_test) {
212 case TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED:
213 ret = bt_self_component_source_add_output_port(
214 self_comp, "hello", NULL, NULL);
215 BT_ASSERT(ret == 0);
216 break;
217 case TEST_SRC_PORT_CONNECTED_ERROR:
218 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_ERROR;
219 default:
220 break;
221 }
222
223 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_OK;
224}
225
226static
227bt_component_class_port_connected_method_status sink_input_port_connected(
228 bt_self_component_sink *self_comp,
229 bt_self_component_port_input *self_comp_port,
230 const bt_port_output *other_port)
231{
232 struct event event = {
233 .type = SINK_COMP_INPUT_PORT_CONNECTED,
234 .data.sink_comp_input_port_connected = {
235 .comp = bt_self_component_as_component(
236 bt_self_component_sink_as_self_component(
237 self_comp)),
238 .self_port = bt_self_component_port_as_port(
239 bt_self_component_port_input_as_self_component_port(
240 self_comp_port)),
241 .other_port = bt_port_output_as_port_const(other_port),
242 },
243 };
244
245 append_event(&event);
246
247 if (current_test == TEST_SINK_PORT_CONNECTED_ERROR) {
248 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_ERROR;
249 } else {
250 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_OK;
251 }
252}
253
254static
21a9f056 255bt_component_class_initialize_method_status src_init(
21d04293 256 bt_self_component_source *self_comp,
59225a3e 257 bt_self_component_source_configuration *config,
21d04293
PP		 258 const bt_value *params, void *init_method_data)
259{
260 int ret;
261
262 ret = bt_self_component_source_add_output_port(
263 self_comp, "out", NULL, NULL);
264 BT_ASSERT(ret == 0);
21a9f056 265 return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
21d04293
PP		 266}
267
268static
21a9f056 269bt_component_class_initialize_method_status sink_init(
21d04293 270 bt_self_component_sink *self_comp,
59225a3e 271 bt_self_component_sink_configuration *config,
21d04293
PP		 272 const bt_value *params, void *init_method_data)
273{
274 int ret;
275
276 ret = bt_self_component_sink_add_input_port(self_comp,
277 "in", NULL, NULL);
278 BT_ASSERT(ret == 0);
21a9f056 279 return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
21d04293
PP		 280}
281
282static
283bt_component_class_sink_consume_method_status sink_consume(
284 bt_self_component_sink *self_comp)
285{
286 return BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;
287}
288
289static
290bt_graph_listener_func_status graph_src_output_port_added(
291 const bt_component_source *comp, const bt_port_output *port,
292 void *data)
293{
294 struct event event = {
295 .type = GRAPH_SRC_OUTPUT_PORT_ADDED,
296 .data.graph_src_output_port_added = {
297 .comp = bt_component_source_as_component_const(comp),
298 .port = bt_port_output_as_port_const(port),
299 },
300 };
301
302 append_event(&event);
303
304 return BT_GRAPH_LISTENER_FUNC_STATUS_OK;
305}
306
307static
308bt_graph_listener_func_status graph_sink_input_port_added(
309 const bt_component_sink *comp, const bt_port_input *port,
310 void *data)
311{
312 struct event event = {
313 .type = GRAPH_SINK_INPUT_PORT_ADDED,
314 .data.graph_sink_input_port_added = {
315 .comp = bt_component_sink_as_component_const(comp),
316 .port = bt_port_input_as_port_const(port),
317 },
318 };
319
320 append_event(&event);
321
322 return BT_GRAPH_LISTENER_FUNC_STATUS_OK;
323}
324
21d04293
PP		 325static
326void init_test(void)
327{
328 int ret;
329
a3f0c7db
SM		 330 msg_iter_class = bt_message_iterator_class_create(src_iter_next);
331 BT_ASSERT(msg_iter_class);
332
21d04293 333 src_comp_class = bt_component_class_source_create(
a3f0c7db 334 "src", msg_iter_class);
21d04293 335 BT_ASSERT(src_comp_class);
21a9f056 336 ret = bt_component_class_source_set_initialize_method(
21d04293
PP		 337 src_comp_class, src_init);
338 BT_ASSERT(ret == 0);
339 ret = bt_component_class_source_set_output_port_connected_method(
340 src_comp_class, src_output_port_connected);
341 BT_ASSERT(ret == 0);
342 sink_comp_class = bt_component_class_sink_create("sink",
343 sink_consume);
344 BT_ASSERT(sink_comp_class);
21a9f056 345 ret = bt_component_class_sink_set_initialize_method(sink_comp_class,
21d04293
PP		 346 sink_init);
347 BT_ASSERT(ret == 0);
348 ret = bt_component_class_sink_set_input_port_connected_method(
349 sink_comp_class, sink_input_port_connected);
350 BT_ASSERT(ret == 0);
351 events = g_array_new(FALSE, TRUE, sizeof(struct event));
352 BT_ASSERT(events);
353}
354
355static
356void fini_test(void)
357{
358 bt_component_class_source_put_ref(src_comp_class);
359 bt_component_class_sink_put_ref(sink_comp_class);
360 g_array_free(events, TRUE);
44b263a8 361 BT_MESSAGE_ITERATOR_CLASS_PUT_REF_AND_RESET(msg_iter_class);
21d04293
PP		 362}
363
364static
365const bt_component_source *create_src(bt_graph *graph)
366{
367 const bt_component_source *comp;
368 int ret;
369
370 ret = bt_graph_add_source_component(graph, src_comp_class,
371 "src-comp", NULL, BT_LOGGING_LEVEL_NONE, &comp);
372 BT_ASSERT(ret == 0);
373 return comp;
374}
375
376static
377const bt_component_sink *create_sink(bt_graph *graph)
378{
379 const bt_component_sink *comp;
380 int ret;
381
382 ret = bt_graph_add_sink_component(graph, sink_comp_class,
383 "sink-comp", NULL, BT_LOGGING_LEVEL_NONE, &comp);
384 BT_ASSERT(ret == 0);
385 return comp;
386}
387
388static
389bt_graph *create_graph(void)
390{
056deb59 391 bt_graph *graph = bt_graph_create(0);
21d04293
PP		 392 int ret;
393
394 BT_ASSERT(graph);
395 ret = bt_graph_add_source_component_output_port_added_listener(
f3d6b4c2 396 graph, graph_src_output_port_added, NULL, NULL);
21d04293
PP		 397 BT_ASSERT(ret >= 0);
398 ret = bt_graph_add_sink_component_input_port_added_listener(
f3d6b4c2 399 graph, graph_sink_input_port_added, NULL, NULL);
21d04293 400 BT_ASSERT(ret >= 0);
21d04293
PP		 401 return graph;
402}
403
404static
405void prepare_test(enum test test, const char *name)
406{
407 clear_events();
408 current_test = test;
409 diag("test: %s", name);
410}
411
412static
413void test_src_adds_port_in_port_connected(void)
414{
415 const bt_component_source *src;
416 const bt_component_sink *sink;
417 const bt_component *gsrc;
418 const bt_component *gsink;
419 bt_graph *graph;
420 const bt_port_output *src_def_port;
421 const bt_port_output *src_hello_port;
422 const bt_port_input *sink_def_port;
423 const bt_port *gsrc_def_port;
424 const bt_port *gsrc_hello_port;
425 const bt_port *gsink_def_port;
426 struct event event;
427 bt_graph_connect_ports_status status;
428 size_t src_port_connected_pos;
21d04293
PP		 429 size_t graph_port_added_src_pos;
430
431 prepare_test(TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED,
432 "source adds port in port connected");
433 graph = create_graph();
434 BT_ASSERT(graph);
435 src = create_src(graph);
436 sink = create_sink(graph);
437 src_def_port = bt_component_source_borrow_output_port_by_name_const(src,
438 "out");
439 BT_ASSERT(src_def_port);
440 sink_def_port = bt_component_sink_borrow_input_port_by_name_const(sink,
441 "in");
442 BT_ASSERT(sink_def_port);
443 status = bt_graph_connect_ports(graph, src_def_port,
444 sink_def_port, NULL);
445 BT_ASSERT(status == 0);
446 src_hello_port = bt_component_source_borrow_output_port_by_name_const(src,
447 "hello");
448 BT_ASSERT(src_hello_port);
449 gsrc = bt_component_source_as_component_const(src);
450 gsink = bt_component_sink_as_component_const(sink);
451 gsrc_def_port = bt_port_output_as_port_const(src_def_port);
452 gsrc_hello_port = bt_port_output_as_port_const(src_hello_port);
453 gsink_def_port = bt_port_input_as_port_const(sink_def_port);
454
2945edfe
PP		 455 /* We're supposed to have 5 events */
456 ok(events->len == 5, "we have the expected number of events");
21d04293
PP		 457
458 /* Source's port added */
459 event.type = GRAPH_SRC_OUTPUT_PORT_ADDED;
460 event.data.graph_src_output_port_added.comp = gsrc;
461 event.data.graph_src_output_port_added.port = gsrc_def_port;
462 ok(has_event(&event), "got the expected graph's port added event (for source, initial)");
463
464 /* Sink's port added */
465 event.type = GRAPH_SINK_INPUT_PORT_ADDED;
466 event.data.graph_sink_input_port_added.comp = gsink;
467 event.data.graph_sink_input_port_added.port = gsink_def_port;
468 ok(has_event(&event), "got the expected graph's port added event (for sink, initial)");
469
470 /* Source's port connected */
471 event.type = SRC_COMP_OUTPUT_PORT_CONNECTED;
472 event.data.src_comp_output_port_connected.comp = gsrc;
473 event.data.src_comp_output_port_connected.self_port = gsrc_def_port;
474 event.data.src_comp_output_port_connected.other_port = gsink_def_port;
475 ok(has_event(&event), "got the expected source's port connected event");
476 src_port_connected_pos = event_pos(&event);
477
478 /* Graph's port added (source) */
479 event.type = GRAPH_SRC_OUTPUT_PORT_ADDED;
480 event.data.graph_src_output_port_added.comp = gsrc;
481 event.data.graph_src_output_port_added.port = gsrc_hello_port;
482 ok(has_event(&event), "got the expected graph's port added event (for source)");
483 graph_port_added_src_pos = event_pos(&event);
484
485 /* Sink's port connected */
486 event.type = SINK_COMP_INPUT_PORT_CONNECTED;
487 event.data.sink_comp_input_port_connected.comp = gsink;
488 event.data.sink_comp_input_port_connected.self_port = gsink_def_port;
489 event.data.sink_comp_input_port_connected.other_port = gsrc_def_port;
490 ok(has_event(&event), "got the expected sink's port connected event");
21d04293
PP		 491
492 /* Order of events */
21d04293 493 ok(src_port_connected_pos < graph_port_added_src_pos,
2945edfe 494 "event order is good");
21d04293 495
21d04293
PP		 496 bt_graph_put_ref(graph);
497}
498
499static
500void test_simple(void)
501{
502 const bt_component_source *src;
503 const bt_component_sink *sink;
504 const bt_component *gsrc;
505 const bt_component *gsink;
506 bt_graph *graph;
507 const bt_port_output *src_def_port;
508 const bt_port_input *sink_def_port;
509 const bt_port *gsrc_def_port;
510 const bt_port *gsink_def_port;
511 struct event event;
512 bt_graph_connect_ports_status status;
21d04293
PP		 513
514 prepare_test(TEST_SIMPLE, "simple");
515 graph = create_graph();
516 BT_ASSERT(graph);
517 src = create_src(graph);
518 sink = create_sink(graph);
519 src_def_port = bt_component_source_borrow_output_port_by_name_const(src,
520 "out");
521 BT_ASSERT(src_def_port);
522 sink_def_port = bt_component_sink_borrow_input_port_by_name_const(sink,
523 "in");
524 BT_ASSERT(sink_def_port);
525 status = bt_graph_connect_ports(graph, src_def_port,
526 sink_def_port, NULL);
527 BT_ASSERT(status == 0);
528 gsrc = bt_component_source_as_component_const(src);
529 gsink = bt_component_sink_as_component_const(sink);
530 gsrc_def_port = bt_port_output_as_port_const(src_def_port);
531 gsink_def_port = bt_port_input_as_port_const(sink_def_port);
532
2945edfe
PP		 533 /* We're supposed to have 4 events */
534 ok(events->len == 4, "we have the expected number of events");
21d04293
PP		 535
536 /* Source's port added */
537 event.type = GRAPH_SRC_OUTPUT_PORT_ADDED;
538 event.data.graph_src_output_port_added.comp = gsrc;
539 event.data.graph_src_output_port_added.port = gsrc_def_port;
540 ok(has_event(&event), "got the expected graph's port added event (for source, initial)");
541
542 /* Sink's port added */
543 event.type = GRAPH_SINK_INPUT_PORT_ADDED;
544 event.data.graph_sink_input_port_added.comp = gsink;
545 event.data.graph_sink_input_port_added.port = gsink_def_port;
546 ok(has_event(&event), "got the expected graph's port added event (for sink, initial)");
547
548 /* Source's port connected */
549 event.type = SRC_COMP_OUTPUT_PORT_CONNECTED;
550 event.data.src_comp_output_port_connected.comp = gsrc;
551 event.data.src_comp_output_port_connected.self_port = gsrc_def_port;
552 event.data.src_comp_output_port_connected.other_port = gsink_def_port;
553 ok(has_event(&event), "got the expected source's port connected event");
21d04293
PP		 554
555 /* Sink's port connected */
556 event.type = SINK_COMP_INPUT_PORT_CONNECTED;
557 event.data.sink_comp_input_port_connected.comp = gsink;
558 event.data.sink_comp_input_port_connected.self_port = gsink_def_port;
559 event.data.sink_comp_input_port_connected.other_port = gsrc_def_port;
560 ok(has_event(&event), "got the expected sink's port connected event");
21d04293 561
21d04293 562 bt_graph_put_ref(graph);
21d04293
PP		 563}
564
565static
566void test_src_port_connected_error(void)
567{
568 const bt_component_source *src;
569 const bt_component_sink *sink;
570 const bt_component *gsrc;
571 const bt_component *gsink;
572 bt_graph *graph;
573 const bt_port_output *src_def_port;
574 const bt_port_input *sink_def_port;
575 const bt_port *gsrc_def_port;
576 const bt_port *gsink_def_port;
577 const bt_connection *conn = NULL;
578 struct event event;
579 bt_graph_connect_ports_status status;
580
581 prepare_test(TEST_SRC_PORT_CONNECTED_ERROR, "port connected error: source");
582 graph = create_graph();
583 BT_ASSERT(graph);
584 src = create_src(graph);
585 sink = create_sink(graph);
586 src_def_port = bt_component_source_borrow_output_port_by_name_const(src,
587 "out");
588 BT_ASSERT(src_def_port);
589 sink_def_port = bt_component_sink_borrow_input_port_by_name_const(sink,
590 "in");
591 BT_ASSERT(sink_def_port);
592 status = bt_graph_connect_ports(graph, src_def_port,
593 sink_def_port, &conn);
594 ok(status != BT_GRAPH_CONNECT_PORTS_STATUS_OK,
595 "bt_graph_connect_ports() returns an error");
758932ce 596 bt_current_thread_clear_error();
21d04293
PP		 597 ok(!conn, "returned connection is still NULL");
598 gsrc = bt_component_source_as_component_const(src);
599 gsink = bt_component_sink_as_component_const(sink);
600 gsrc_def_port = bt_port_output_as_port_const(src_def_port);
601 gsink_def_port = bt_port_input_as_port_const(sink_def_port);
602
603 /* We're supposed to have 3 events */
604 ok(events->len == 3, "we have the expected number of events");
605
606 /* Source's port added */
607 event.type = GRAPH_SRC_OUTPUT_PORT_ADDED;
608 event.data.graph_src_output_port_added.comp = gsrc;
609 event.data.graph_src_output_port_added.port = gsrc_def_port;
610 ok(has_event(&event), "got the expected graph's port added event (for source, initial)");
611
612 /* Sink's port added */
613 event.type = GRAPH_SINK_INPUT_PORT_ADDED;
614 event.data.graph_sink_input_port_added.comp = gsink;
615 event.data.graph_sink_input_port_added.port = gsink_def_port;
616 ok(has_event(&event), "got the expected graph's port added event (for sink, initial)");
617
618 /* Source's port connected */
619 event.type = SRC_COMP_OUTPUT_PORT_CONNECTED;
620 event.data.src_comp_output_port_connected.comp = gsrc;
621 event.data.src_comp_output_port_connected.self_port = gsrc_def_port;
622 event.data.src_comp_output_port_connected.other_port = gsink_def_port;
623 ok(has_event(&event), "got the expected source's port connected event");
624
625 bt_graph_put_ref(graph);
21d04293
PP		 626}
627
628static
629void test_sink_port_connected_error(void)
630{
631 const bt_component_source *src;
632 const bt_component_sink *sink;
633 const bt_component *gsrc;
634 const bt_component *gsink;
635 bt_graph *graph;
636 const bt_port_output *src_def_port;
637 const bt_port_input *sink_def_port;
638 const bt_port *gsrc_def_port;
639 const bt_port *gsink_def_port;
640 const bt_connection *conn = NULL;
641 struct event event;
642 bt_graph_connect_ports_status status;
643
644 prepare_test(TEST_SINK_PORT_CONNECTED_ERROR, "port connected error: sink");
645 graph = create_graph();
646 BT_ASSERT(graph);
647 src = create_src(graph);
648 sink = create_sink(graph);
649 src_def_port = bt_component_source_borrow_output_port_by_name_const(src,
650 "out");
651 BT_ASSERT(src_def_port);
652 sink_def_port = bt_component_sink_borrow_input_port_by_name_const(sink,
653 "in");
654 BT_ASSERT(sink_def_port);
655 status = bt_graph_connect_ports(graph, src_def_port,
656 sink_def_port, &conn);
657 ok(status != BT_GRAPH_CONNECT_PORTS_STATUS_OK,
658 "bt_graph_connect_ports() returns an error");
758932ce 659 bt_current_thread_clear_error();
21d04293
PP		 660 ok(!conn, "returned connection is still NULL");
661 gsrc = bt_component_source_as_component_const(src);
662 gsink = bt_component_sink_as_component_const(sink);
663 gsrc_def_port = bt_port_output_as_port_const(src_def_port);
664 gsink_def_port = bt_port_input_as_port_const(sink_def_port);
665
666 /* We're supposed to have 4 events */
667 ok(events->len == 4, "we have the expected number of events");
668
669 /* Source's port added */
670 event.type = GRAPH_SRC_OUTPUT_PORT_ADDED;
671 event.data.graph_src_output_port_added.comp = gsrc;
672 event.data.graph_src_output_port_added.port = gsrc_def_port;
673 ok(has_event(&event), "got the expected graph's port added event (for source, initial)");
674
675 /* Sink's port added */
676 event.type = GRAPH_SINK_INPUT_PORT_ADDED;
677 event.data.graph_sink_input_port_added.comp = gsink;
678 event.data.graph_sink_input_port_added.port = gsink_def_port;
679 ok(has_event(&event), "got the expected graph's port added event (for sink, initial)");
680
681 /* Source's port connected */
682 event.type = SRC_COMP_OUTPUT_PORT_CONNECTED;
683 event.data.src_comp_output_port_connected.comp = gsrc;
684 event.data.src_comp_output_port_connected.self_port = gsrc_def_port;
685 event.data.src_comp_output_port_connected.other_port = gsink_def_port;
686 ok(has_event(&event), "got the expected source's port connected event");
687
688 /* Sink's port connected */
689 event.type = SINK_COMP_INPUT_PORT_CONNECTED;
690 event.data.sink_comp_input_port_connected.comp = gsink;
691 event.data.sink_comp_input_port_connected.self_port = gsink_def_port;
692 event.data.sink_comp_input_port_connected.other_port = gsrc_def_port;
693 ok(has_event(&event), "got the expected sink's port connected event");
694
21d04293 695 bt_graph_put_ref(graph);
21d04293
PP		 696}
697
698static
699void test_empty_graph(void)
700{
701 bt_graph *graph;
702
703 prepare_test(TEST_EMPTY_GRAPH, "empty graph");
704 graph = create_graph();
705 ok(events->len == 0, "empty graph generates no events");
706 bt_graph_put_ref(graph);
707}
708
709int main(int argc, char **argv)
710{
711 plan_tests(NR_TESTS);
712 init_test();
713 test_empty_graph();
714 test_simple();
715 test_src_port_connected_error();
716 test_sink_port_connected_error();
717 test_src_adds_port_in_port_connected();
718 fini_test();
719 return exit_status();
720}
BabelTrace - Trace Format Babel Tower
This page took 0.07528 seconds and 4 git commands to generate.