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 <babeltrace2/babeltrace.h>
21 #include "common/assert.h"
32 SRC_COMP_OUTPUT_PORT_CONNECTED
,
33 SINK_COMP_INPUT_PORT_CONNECTED
,
34 GRAPH_SRC_OUTPUT_PORT_ADDED
,
35 GRAPH_SINK_INPUT_PORT_ADDED
,
41 TEST_SRC_PORT_CONNECTED_ERROR
,
42 TEST_SINK_PORT_CONNECTED_ERROR
,
43 TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED
,
51 const bt_component
*comp
;
52 const bt_port
*self_port
;
53 const bt_port
*other_port
;
54 } src_comp_output_port_connected
;
57 const bt_component
*comp
;
58 const bt_port
*self_port
;
59 const bt_port
*other_port
;
60 } sink_comp_input_port_connected
;
63 const bt_component
*comp
;
65 } graph_src_output_port_added
;
68 const bt_component
*comp
;
70 } graph_sink_input_port_added
;
74 static GArray
*events
;
75 static bt_component_class_source
*src_comp_class
;
76 static bt_component_class_sink
*sink_comp_class
;
77 static enum test current_test
;
80 void clear_events(void)
82 g_array_set_size(events
, 0);
86 void append_event(struct event
*event
)
88 g_array_append_val(events
, *event
);
92 bool compare_events(struct event
*ev_a
, struct event
*ev_b
)
94 if (ev_a
->type
!= ev_b
->type
) {
99 case SRC_COMP_OUTPUT_PORT_CONNECTED
:
100 if (ev_a
->data
.src_comp_output_port_connected
.comp
!=
101 ev_b
->data
.src_comp_output_port_connected
.comp
) {
105 if (ev_a
->data
.src_comp_output_port_connected
.self_port
!=
106 ev_b
->data
.src_comp_output_port_connected
.self_port
) {
110 if (ev_a
->data
.src_comp_output_port_connected
.other_port
!=
111 ev_b
->data
.src_comp_output_port_connected
.other_port
) {
115 case SINK_COMP_INPUT_PORT_CONNECTED
:
116 if (ev_a
->data
.sink_comp_input_port_connected
.comp
!=
117 ev_b
->data
.sink_comp_input_port_connected
.comp
) {
121 if (ev_a
->data
.sink_comp_input_port_connected
.self_port
!=
122 ev_b
->data
.sink_comp_input_port_connected
.self_port
) {
126 if (ev_a
->data
.sink_comp_input_port_connected
.other_port
!=
127 ev_b
->data
.sink_comp_input_port_connected
.other_port
) {
131 case GRAPH_SRC_OUTPUT_PORT_ADDED
:
132 if (ev_a
->data
.graph_src_output_port_added
.comp
!=
133 ev_b
->data
.graph_src_output_port_added
.comp
) {
137 if (ev_a
->data
.graph_src_output_port_added
.port
!=
138 ev_b
->data
.graph_src_output_port_added
.port
) {
142 case GRAPH_SINK_INPUT_PORT_ADDED
:
143 if (ev_a
->data
.graph_sink_input_port_added
.comp
!=
144 ev_b
->data
.graph_sink_input_port_added
.comp
) {
148 if (ev_a
->data
.graph_sink_input_port_added
.port
!=
149 ev_b
->data
.graph_sink_input_port_added
.port
) {
161 bool has_event(struct event
*event
)
165 for (i
= 0; i
< events
->len
; i
++) {
166 struct event
*ev
= &g_array_index(events
, struct event
, i
);
168 if (compare_events(event
, ev
)) {
177 size_t event_pos(struct event
*event
)
181 for (i
= 0; i
< events
->len
; i
++) {
182 struct event
*ev
= &g_array_index(events
, struct event
, i
);
184 if (compare_events(event
, ev
)) {
193 bt_component_class_message_iterator_next_method_status
src_iter_next(
194 bt_self_message_iterator
*self_iterator
,
195 bt_message_array_const msgs
, uint64_t capacity
,
198 return BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_ERROR
;
202 bt_component_class_port_connected_method_status
src_output_port_connected(
203 bt_self_component_source
*self_comp
,
204 bt_self_component_port_output
*self_comp_port
,
205 const bt_port_input
*other_port
)
208 struct event event
= {
209 .type
= SRC_COMP_OUTPUT_PORT_CONNECTED
,
210 .data
.src_comp_output_port_connected
= {
211 .comp
= bt_self_component_as_component(
212 bt_self_component_source_as_self_component(
214 .self_port
= bt_self_component_port_as_port(
215 bt_self_component_port_output_as_self_component_port(
217 .other_port
= bt_port_input_as_port_const(other_port
),
221 append_event(&event
);
223 switch (current_test
) {
224 case TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED
:
225 ret
= bt_self_component_source_add_output_port(
226 self_comp
, "hello", NULL
, NULL
);
229 case TEST_SRC_PORT_CONNECTED_ERROR
:
230 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_ERROR
;
235 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_OK
;
239 bt_component_class_port_connected_method_status
sink_input_port_connected(
240 bt_self_component_sink
*self_comp
,
241 bt_self_component_port_input
*self_comp_port
,
242 const bt_port_output
*other_port
)
244 struct event event
= {
245 .type
= SINK_COMP_INPUT_PORT_CONNECTED
,
246 .data
.sink_comp_input_port_connected
= {
247 .comp
= bt_self_component_as_component(
248 bt_self_component_sink_as_self_component(
250 .self_port
= bt_self_component_port_as_port(
251 bt_self_component_port_input_as_self_component_port(
253 .other_port
= bt_port_output_as_port_const(other_port
),
257 append_event(&event
);
259 if (current_test
== TEST_SINK_PORT_CONNECTED_ERROR
) {
260 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_ERROR
;
262 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_OK
;
267 bt_component_class_initialize_method_status
src_init(
268 bt_self_component_source
*self_comp
,
269 bt_self_component_source_configuration
*config
,
270 const bt_value
*params
, void *init_method_data
)
274 ret
= bt_self_component_source_add_output_port(
275 self_comp
, "out", NULL
, NULL
);
277 return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK
;
281 bt_component_class_initialize_method_status
sink_init(
282 bt_self_component_sink
*self_comp
,
283 bt_self_component_sink_configuration
*config
,
284 const bt_value
*params
, void *init_method_data
)
288 ret
= bt_self_component_sink_add_input_port(self_comp
,
291 return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK
;
295 bt_component_class_sink_consume_method_status
sink_consume(
296 bt_self_component_sink
*self_comp
)
298 return BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK
;
302 bt_graph_listener_func_status
graph_src_output_port_added(
303 const bt_component_source
*comp
, const bt_port_output
*port
,
306 struct event event
= {
307 .type
= GRAPH_SRC_OUTPUT_PORT_ADDED
,
308 .data
.graph_src_output_port_added
= {
309 .comp
= bt_component_source_as_component_const(comp
),
310 .port
= bt_port_output_as_port_const(port
),
314 append_event(&event
);
316 return BT_GRAPH_LISTENER_FUNC_STATUS_OK
;
320 bt_graph_listener_func_status
graph_sink_input_port_added(
321 const bt_component_sink
*comp
, const bt_port_input
*port
,
324 struct event event
= {
325 .type
= GRAPH_SINK_INPUT_PORT_ADDED
,
326 .data
.graph_sink_input_port_added
= {
327 .comp
= bt_component_sink_as_component_const(comp
),
328 .port
= bt_port_input_as_port_const(port
),
332 append_event(&event
);
334 return BT_GRAPH_LISTENER_FUNC_STATUS_OK
;
342 src_comp_class
= bt_component_class_source_create(
343 "src", src_iter_next
);
344 BT_ASSERT(src_comp_class
);
345 ret
= bt_component_class_source_set_initialize_method(
346 src_comp_class
, src_init
);
348 ret
= bt_component_class_source_set_output_port_connected_method(
349 src_comp_class
, src_output_port_connected
);
351 sink_comp_class
= bt_component_class_sink_create("sink",
353 BT_ASSERT(sink_comp_class
);
354 ret
= bt_component_class_sink_set_initialize_method(sink_comp_class
,
357 ret
= bt_component_class_sink_set_input_port_connected_method(
358 sink_comp_class
, sink_input_port_connected
);
360 events
= g_array_new(FALSE
, TRUE
, sizeof(struct event
));
367 bt_component_class_source_put_ref(src_comp_class
);
368 bt_component_class_sink_put_ref(sink_comp_class
);
369 g_array_free(events
, TRUE
);
373 const bt_component_source
*create_src(bt_graph
*graph
)
375 const bt_component_source
*comp
;
378 ret
= bt_graph_add_source_component(graph
, src_comp_class
,
379 "src-comp", NULL
, BT_LOGGING_LEVEL_NONE
, &comp
);
385 const bt_component_sink
*create_sink(bt_graph
*graph
)
387 const bt_component_sink
*comp
;
390 ret
= bt_graph_add_sink_component(graph
, sink_comp_class
,
391 "sink-comp", NULL
, BT_LOGGING_LEVEL_NONE
, &comp
);
397 bt_graph
*create_graph(void)
399 bt_graph
*graph
= bt_graph_create(0);
403 ret
= bt_graph_add_source_component_output_port_added_listener(
404 graph
, graph_src_output_port_added
, NULL
, NULL
);
406 ret
= bt_graph_add_sink_component_input_port_added_listener(
407 graph
, graph_sink_input_port_added
, NULL
, NULL
);
413 void prepare_test(enum test test
, const char *name
)
417 diag("test: %s", name
);
421 void test_src_adds_port_in_port_connected(void)
423 const bt_component_source
*src
;
424 const bt_component_sink
*sink
;
425 const bt_component
*gsrc
;
426 const bt_component
*gsink
;
428 const bt_port_output
*src_def_port
;
429 const bt_port_output
*src_hello_port
;
430 const bt_port_input
*sink_def_port
;
431 const bt_port
*gsrc_def_port
;
432 const bt_port
*gsrc_hello_port
;
433 const bt_port
*gsink_def_port
;
435 bt_graph_connect_ports_status status
;
436 size_t src_port_connected_pos
;
437 size_t graph_port_added_src_pos
;
439 prepare_test(TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED
,
440 "source adds port in port connected");
441 graph
= create_graph();
443 src
= create_src(graph
);
444 sink
= create_sink(graph
);
445 src_def_port
= bt_component_source_borrow_output_port_by_name_const(src
,
447 BT_ASSERT(src_def_port
);
448 sink_def_port
= bt_component_sink_borrow_input_port_by_name_const(sink
,
450 BT_ASSERT(sink_def_port
);
451 status
= bt_graph_connect_ports(graph
, src_def_port
,
452 sink_def_port
, NULL
);
453 BT_ASSERT(status
== 0);
454 src_hello_port
= bt_component_source_borrow_output_port_by_name_const(src
,
456 BT_ASSERT(src_hello_port
);
457 gsrc
= bt_component_source_as_component_const(src
);
458 gsink
= bt_component_sink_as_component_const(sink
);
459 gsrc_def_port
= bt_port_output_as_port_const(src_def_port
);
460 gsrc_hello_port
= bt_port_output_as_port_const(src_hello_port
);
461 gsink_def_port
= bt_port_input_as_port_const(sink_def_port
);
463 /* We're supposed to have 5 events */
464 ok(events
->len
== 5, "we have the expected number of events");
466 /* Source's port added */
467 event
.type
= GRAPH_SRC_OUTPUT_PORT_ADDED
;
468 event
.data
.graph_src_output_port_added
.comp
= gsrc
;
469 event
.data
.graph_src_output_port_added
.port
= gsrc_def_port
;
470 ok(has_event(&event
), "got the expected graph's port added event (for source, initial)");
472 /* Sink's port added */
473 event
.type
= GRAPH_SINK_INPUT_PORT_ADDED
;
474 event
.data
.graph_sink_input_port_added
.comp
= gsink
;
475 event
.data
.graph_sink_input_port_added
.port
= gsink_def_port
;
476 ok(has_event(&event
), "got the expected graph's port added event (for sink, initial)");
478 /* Source's port connected */
479 event
.type
= SRC_COMP_OUTPUT_PORT_CONNECTED
;
480 event
.data
.src_comp_output_port_connected
.comp
= gsrc
;
481 event
.data
.src_comp_output_port_connected
.self_port
= gsrc_def_port
;
482 event
.data
.src_comp_output_port_connected
.other_port
= gsink_def_port
;
483 ok(has_event(&event
), "got the expected source's port connected event");
484 src_port_connected_pos
= event_pos(&event
);
486 /* Graph's port added (source) */
487 event
.type
= GRAPH_SRC_OUTPUT_PORT_ADDED
;
488 event
.data
.graph_src_output_port_added
.comp
= gsrc
;
489 event
.data
.graph_src_output_port_added
.port
= gsrc_hello_port
;
490 ok(has_event(&event
), "got the expected graph's port added event (for source)");
491 graph_port_added_src_pos
= event_pos(&event
);
493 /* Sink's port connected */
494 event
.type
= SINK_COMP_INPUT_PORT_CONNECTED
;
495 event
.data
.sink_comp_input_port_connected
.comp
= gsink
;
496 event
.data
.sink_comp_input_port_connected
.self_port
= gsink_def_port
;
497 event
.data
.sink_comp_input_port_connected
.other_port
= gsrc_def_port
;
498 ok(has_event(&event
), "got the expected sink's port connected event");
500 /* Order of events */
501 ok(src_port_connected_pos
< graph_port_added_src_pos
,
502 "event order is good");
504 bt_component_source_put_ref(src
);
505 bt_component_sink_put_ref(sink
);
506 bt_graph_put_ref(graph
);
510 void test_simple(void)
512 const bt_component_source
*src
;
513 const bt_component_sink
*sink
;
514 const bt_component
*gsrc
;
515 const bt_component
*gsink
;
517 const bt_port_output
*src_def_port
;
518 const bt_port_input
*sink_def_port
;
519 const bt_port
*gsrc_def_port
;
520 const bt_port
*gsink_def_port
;
522 bt_graph_connect_ports_status status
;
524 prepare_test(TEST_SIMPLE
, "simple");
525 graph
= create_graph();
527 src
= create_src(graph
);
528 sink
= create_sink(graph
);
529 src_def_port
= bt_component_source_borrow_output_port_by_name_const(src
,
531 BT_ASSERT(src_def_port
);
532 sink_def_port
= bt_component_sink_borrow_input_port_by_name_const(sink
,
534 BT_ASSERT(sink_def_port
);
535 status
= bt_graph_connect_ports(graph
, src_def_port
,
536 sink_def_port
, NULL
);
537 BT_ASSERT(status
== 0);
538 gsrc
= bt_component_source_as_component_const(src
);
539 gsink
= bt_component_sink_as_component_const(sink
);
540 gsrc_def_port
= bt_port_output_as_port_const(src_def_port
);
541 gsink_def_port
= bt_port_input_as_port_const(sink_def_port
);
543 /* We're supposed to have 4 events */
544 ok(events
->len
== 4, "we have the expected number of events");
546 /* Source's port added */
547 event
.type
= GRAPH_SRC_OUTPUT_PORT_ADDED
;
548 event
.data
.graph_src_output_port_added
.comp
= gsrc
;
549 event
.data
.graph_src_output_port_added
.port
= gsrc_def_port
;
550 ok(has_event(&event
), "got the expected graph's port added event (for source, initial)");
552 /* Sink's port added */
553 event
.type
= GRAPH_SINK_INPUT_PORT_ADDED
;
554 event
.data
.graph_sink_input_port_added
.comp
= gsink
;
555 event
.data
.graph_sink_input_port_added
.port
= gsink_def_port
;
556 ok(has_event(&event
), "got the expected graph's port added event (for sink, initial)");
558 /* Source's port connected */
559 event
.type
= SRC_COMP_OUTPUT_PORT_CONNECTED
;
560 event
.data
.src_comp_output_port_connected
.comp
= gsrc
;
561 event
.data
.src_comp_output_port_connected
.self_port
= gsrc_def_port
;
562 event
.data
.src_comp_output_port_connected
.other_port
= gsink_def_port
;
563 ok(has_event(&event
), "got the expected source's port connected event");
565 /* Sink's port connected */
566 event
.type
= SINK_COMP_INPUT_PORT_CONNECTED
;
567 event
.data
.sink_comp_input_port_connected
.comp
= gsink
;
568 event
.data
.sink_comp_input_port_connected
.self_port
= gsink_def_port
;
569 event
.data
.sink_comp_input_port_connected
.other_port
= gsrc_def_port
;
570 ok(has_event(&event
), "got the expected sink's port connected event");
572 bt_component_sink_put_ref(sink
);
573 bt_graph_put_ref(graph
);
574 bt_component_source_put_ref(src
);
578 void test_src_port_connected_error(void)
580 const bt_component_source
*src
;
581 const bt_component_sink
*sink
;
582 const bt_component
*gsrc
;
583 const bt_component
*gsink
;
585 const bt_port_output
*src_def_port
;
586 const bt_port_input
*sink_def_port
;
587 const bt_port
*gsrc_def_port
;
588 const bt_port
*gsink_def_port
;
589 const bt_connection
*conn
= NULL
;
591 bt_graph_connect_ports_status status
;
593 prepare_test(TEST_SRC_PORT_CONNECTED_ERROR
, "port connected error: source");
594 graph
= create_graph();
596 src
= create_src(graph
);
597 sink
= create_sink(graph
);
598 src_def_port
= bt_component_source_borrow_output_port_by_name_const(src
,
600 BT_ASSERT(src_def_port
);
601 sink_def_port
= bt_component_sink_borrow_input_port_by_name_const(sink
,
603 BT_ASSERT(sink_def_port
);
604 status
= bt_graph_connect_ports(graph
, src_def_port
,
605 sink_def_port
, &conn
);
606 ok(status
!= BT_GRAPH_CONNECT_PORTS_STATUS_OK
,
607 "bt_graph_connect_ports() returns an error");
608 bt_current_thread_clear_error();
609 ok(!conn
, "returned connection is still NULL");
610 gsrc
= bt_component_source_as_component_const(src
);
611 gsink
= bt_component_sink_as_component_const(sink
);
612 gsrc_def_port
= bt_port_output_as_port_const(src_def_port
);
613 gsink_def_port
= bt_port_input_as_port_const(sink_def_port
);
615 /* We're supposed to have 3 events */
616 ok(events
->len
== 3, "we have the expected number of events");
618 /* Source's port added */
619 event
.type
= GRAPH_SRC_OUTPUT_PORT_ADDED
;
620 event
.data
.graph_src_output_port_added
.comp
= gsrc
;
621 event
.data
.graph_src_output_port_added
.port
= gsrc_def_port
;
622 ok(has_event(&event
), "got the expected graph's port added event (for source, initial)");
624 /* Sink's port added */
625 event
.type
= GRAPH_SINK_INPUT_PORT_ADDED
;
626 event
.data
.graph_sink_input_port_added
.comp
= gsink
;
627 event
.data
.graph_sink_input_port_added
.port
= gsink_def_port
;
628 ok(has_event(&event
), "got the expected graph's port added event (for sink, initial)");
630 /* Source's port connected */
631 event
.type
= SRC_COMP_OUTPUT_PORT_CONNECTED
;
632 event
.data
.src_comp_output_port_connected
.comp
= gsrc
;
633 event
.data
.src_comp_output_port_connected
.self_port
= gsrc_def_port
;
634 event
.data
.src_comp_output_port_connected
.other_port
= gsink_def_port
;
635 ok(has_event(&event
), "got the expected source's port connected event");
637 bt_graph_put_ref(graph
);
638 bt_component_sink_put_ref(sink
);
639 bt_component_source_put_ref(src
);
640 bt_connection_put_ref(conn
);
644 void test_sink_port_connected_error(void)
646 const bt_component_source
*src
;
647 const bt_component_sink
*sink
;
648 const bt_component
*gsrc
;
649 const bt_component
*gsink
;
651 const bt_port_output
*src_def_port
;
652 const bt_port_input
*sink_def_port
;
653 const bt_port
*gsrc_def_port
;
654 const bt_port
*gsink_def_port
;
655 const bt_connection
*conn
= NULL
;
657 bt_graph_connect_ports_status status
;
659 prepare_test(TEST_SINK_PORT_CONNECTED_ERROR
, "port connected error: sink");
660 graph
= create_graph();
662 src
= create_src(graph
);
663 sink
= create_sink(graph
);
664 src_def_port
= bt_component_source_borrow_output_port_by_name_const(src
,
666 BT_ASSERT(src_def_port
);
667 sink_def_port
= bt_component_sink_borrow_input_port_by_name_const(sink
,
669 BT_ASSERT(sink_def_port
);
670 status
= bt_graph_connect_ports(graph
, src_def_port
,
671 sink_def_port
, &conn
);
672 ok(status
!= BT_GRAPH_CONNECT_PORTS_STATUS_OK
,
673 "bt_graph_connect_ports() returns an error");
674 bt_current_thread_clear_error();
675 ok(!conn
, "returned connection is still NULL");
676 gsrc
= bt_component_source_as_component_const(src
);
677 gsink
= bt_component_sink_as_component_const(sink
);
678 gsrc_def_port
= bt_port_output_as_port_const(src_def_port
);
679 gsink_def_port
= bt_port_input_as_port_const(sink_def_port
);
681 /* We're supposed to have 4 events */
682 ok(events
->len
== 4, "we have the expected number of events");
684 /* Source's port added */
685 event
.type
= GRAPH_SRC_OUTPUT_PORT_ADDED
;
686 event
.data
.graph_src_output_port_added
.comp
= gsrc
;
687 event
.data
.graph_src_output_port_added
.port
= gsrc_def_port
;
688 ok(has_event(&event
), "got the expected graph's port added event (for source, initial)");
690 /* Sink's port added */
691 event
.type
= GRAPH_SINK_INPUT_PORT_ADDED
;
692 event
.data
.graph_sink_input_port_added
.comp
= gsink
;
693 event
.data
.graph_sink_input_port_added
.port
= gsink_def_port
;
694 ok(has_event(&event
), "got the expected graph's port added event (for sink, initial)");
696 /* Source's port connected */
697 event
.type
= SRC_COMP_OUTPUT_PORT_CONNECTED
;
698 event
.data
.src_comp_output_port_connected
.comp
= gsrc
;
699 event
.data
.src_comp_output_port_connected
.self_port
= gsrc_def_port
;
700 event
.data
.src_comp_output_port_connected
.other_port
= gsink_def_port
;
701 ok(has_event(&event
), "got the expected source's port connected event");
703 /* Sink's port connected */
704 event
.type
= SINK_COMP_INPUT_PORT_CONNECTED
;
705 event
.data
.sink_comp_input_port_connected
.comp
= gsink
;
706 event
.data
.sink_comp_input_port_connected
.self_port
= gsink_def_port
;
707 event
.data
.sink_comp_input_port_connected
.other_port
= gsrc_def_port
;
708 ok(has_event(&event
), "got the expected sink's port connected event");
710 bt_connection_put_ref(conn
);
711 bt_graph_put_ref(graph
);
712 bt_component_sink_put_ref(sink
);
713 bt_component_source_put_ref(src
);
717 void test_empty_graph(void)
721 prepare_test(TEST_EMPTY_GRAPH
, "empty graph");
722 graph
= create_graph();
723 ok(events
->len
== 0, "empty graph generates no events");
724 bt_graph_put_ref(graph
);
727 int main(int argc
, char **argv
)
729 plan_tests(NR_TESTS
);
733 test_src_port_connected_error();
734 test_sink_port_connected_error();
735 test_src_adds_port_in_port_connected();
737 return exit_status();