tests/lib/test_graph_topo.c

   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
  20 #include <babeltrace2/babeltrace.h>
  21 #include "common/assert.h"
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <stdbool.h>
  25 #include <glib.h>
  26
  27 #include "tap/tap.h"
  28
  29 #define NR_TESTS        26
  30
  31 enum event_type {
  32         SRC_COMP_OUTPUT_PORT_CONNECTED,
  33         SINK_COMP_INPUT_PORT_CONNECTED,
  34         GRAPH_SRC_OUTPUT_PORT_ADDED,
  35         GRAPH_SINK_INPUT_PORT_ADDED,
  36 };
  37
  38 enum test {
  39         TEST_EMPTY_GRAPH,
  40         TEST_SIMPLE,
  41         TEST_SRC_PORT_CONNECTED_ERROR,
  42         TEST_SINK_PORT_CONNECTED_ERROR,
  43         TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED,
  44 };
  45
  46 struct event {
  47         enum event_type type;
  48
  49         union {
  50                 struct {
  51                         const bt_component *comp;
  52                         const bt_port *self_port;
  53                         const bt_port *other_port;
  54                 } src_comp_output_port_connected;
  55
  56                 struct {
  57                         const bt_component *comp;
  58                         const bt_port *self_port;
  59                         const bt_port *other_port;
  60                 } sink_comp_input_port_connected;
  61
  62                 struct {
  63                         const bt_component *comp;
  64                         const bt_port *port;
  65                 } graph_src_output_port_added;
  66
  67                 struct {
  68                         const bt_component *comp;
  69                         const bt_port *port;
  70                 } graph_sink_input_port_added;
  71         } data;
  72 };
  73
  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;
  78
  79 static
  80 void clear_events(void)
  81 {
  82         g_array_set_size(events, 0);
  83 }
  84
  85 static
  86 void append_event(struct event *event)
  87 {
  88         g_array_append_val(events, *event);
  89 }
  90
  91 static
  92 bool compare_events(struct event *ev_a, struct event *ev_b)
  93 {
  94         if (ev_a->type != ev_b->type) {
  95                 return false;
  96         }
  97
  98         switch (ev_a->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) {
 102                                 return false;
 103                         }
 104
 105                         if (ev_a->data.src_comp_output_port_connected.self_port !=
 106                                         ev_b->data.src_comp_output_port_connected.self_port) {
 107                                 return false;
 108                         }
 109
 110                         if (ev_a->data.src_comp_output_port_connected.other_port !=
 111                                         ev_b->data.src_comp_output_port_connected.other_port) {
 112                                 return false;
 113                         }
 114                         break;
 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) {
 118                                 return false;
 119                         }
 120
 121                         if (ev_a->data.sink_comp_input_port_connected.self_port !=
 122                                         ev_b->data.sink_comp_input_port_connected.self_port) {
 123                                 return false;
 124                         }
 125
 126                         if (ev_a->data.sink_comp_input_port_connected.other_port !=
 127                                         ev_b->data.sink_comp_input_port_connected.other_port) {
 128                                 return false;
 129                         }
 130                         break;
 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) {
 134                                 return false;
 135                         }
 136
 137                         if (ev_a->data.graph_src_output_port_added.port !=
 138                                         ev_b->data.graph_src_output_port_added.port) {
 139                                 return false;
 140                         }
 141                         break;
 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) {
 145                                 return false;
 146                         }
 147
 148                         if (ev_a->data.graph_sink_input_port_added.port !=
 149                                         ev_b->data.graph_sink_input_port_added.port) {
 150                                 return false;
 151                         }
 152                         break;
 153                 default:
 154                         abort();
 155         }
 156
 157         return true;
 158 }
 159
 160 static
 161 bool has_event(struct event *event)
 162 {
 163         size_t i;
 164
 165         for (i = 0; i < events->len; i++) {
 166                 struct event *ev = &g_array_index(events, struct event, i);
 167
 168                 if (compare_events(event, ev)) {
 169                         return true;
 170                 }
 171         }
 172
 173         return false;
 174 }
 175
 176 static
 177 size_t event_pos(struct event *event)
 178 {
 179         size_t i;
 180
 181         for (i = 0; i < events->len; i++) {
 182                 struct event *ev = &g_array_index(events, struct event, i);
 183
 184                 if (compare_events(event, ev)) {
 185                         return i;
 186                 }
 187         }
 188
 189         return SIZE_MAX;
 190 }
 191
 192 static
 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,
 196                 uint64_t *count)
 197 {
 198         return BT_COMPONENT_CLASS_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_ERROR;
 199 }
 200
 201 static
 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)
 206 {
 207         int ret;
 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(
 213                                         self_comp)),
 214                         .self_port = bt_self_component_port_as_port(
 215                                 bt_self_component_port_output_as_self_component_port(
 216                                         self_comp_port)),
 217                         .other_port = bt_port_input_as_port_const(other_port),
 218                 },
 219         };
 220
 221         append_event(&event);
 222
 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);
 227                 BT_ASSERT(ret == 0);
 228                 break;
 229         case TEST_SRC_PORT_CONNECTED_ERROR:
 230                 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_ERROR;
 231         default:
 232                 break;
 233         }
 234
 235         return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_OK;
 236 }
 237
 238 static
 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)
 243 {
 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(
 249                                         self_comp)),
 250                         .self_port = bt_self_component_port_as_port(
 251                                 bt_self_component_port_input_as_self_component_port(
 252                                         self_comp_port)),
 253                         .other_port = bt_port_output_as_port_const(other_port),
 254                 },
 255         };
 256
 257         append_event(&event);
 258
 259         if (current_test == TEST_SINK_PORT_CONNECTED_ERROR) {
 260                 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_ERROR;
 261         } else {
 262                 return BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_OK;
 263         }
 264 }
 265
 266 static
 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)
 271 {
 272         int ret;
 273
 274         ret = bt_self_component_source_add_output_port(
 275                 self_comp, "out", NULL, NULL);
 276         BT_ASSERT(ret == 0);
 277         return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
 278 }
 279
 280 static
 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)
 285 {
 286         int ret;
 287
 288         ret = bt_self_component_sink_add_input_port(self_comp,
 289                 "in", NULL, NULL);
 290         BT_ASSERT(ret == 0);
 291         return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
 292 }
 293
 294 static
 295 bt_component_class_sink_consume_method_status sink_consume(
 296                 bt_self_component_sink *self_comp)
 297 {
 298         return BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;
 299 }
 300
 301 static
 302 bt_graph_listener_func_status graph_src_output_port_added(
 303                 const bt_component_source *comp, const bt_port_output *port,
 304                 void *data)
 305 {
 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),
 311                 },
 312         };
 313
 314         append_event(&event);
 315
 316         return BT_GRAPH_LISTENER_FUNC_STATUS_OK;
 317 }
 318
 319 static
 320 bt_graph_listener_func_status graph_sink_input_port_added(
 321                 const bt_component_sink *comp, const bt_port_input *port,
 322                 void *data)
 323 {
 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),
 329                 },
 330         };
 331
 332         append_event(&event);
 333
 334         return BT_GRAPH_LISTENER_FUNC_STATUS_OK;
 335 }
 336
 337 static
 338 void init_test(void)
 339 {
 340         int ret;
 341
 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);
 347         BT_ASSERT(ret == 0);
 348         ret = bt_component_class_source_set_output_port_connected_method(
 349                 src_comp_class, src_output_port_connected);
 350         BT_ASSERT(ret == 0);
 351         sink_comp_class = bt_component_class_sink_create("sink",
 352                 sink_consume);
 353         BT_ASSERT(sink_comp_class);
 354         ret = bt_component_class_sink_set_initialize_method(sink_comp_class,
 355                 sink_init);
 356         BT_ASSERT(ret == 0);
 357         ret = bt_component_class_sink_set_input_port_connected_method(
 358                 sink_comp_class, sink_input_port_connected);
 359         BT_ASSERT(ret == 0);
 360         events = g_array_new(FALSE, TRUE, sizeof(struct event));
 361         BT_ASSERT(events);
 362 }
 363
 364 static
 365 void fini_test(void)
 366 {
 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);
 370 }
 371
 372 static
 373 const bt_component_source *create_src(bt_graph *graph)
 374 {
 375         const bt_component_source *comp;
 376         int ret;
 377
 378         ret = bt_graph_add_source_component(graph, src_comp_class,
 379                 "src-comp", NULL, BT_LOGGING_LEVEL_NONE, &comp);
 380         BT_ASSERT(ret == 0);
 381         return comp;
 382 }
 383
 384 static
 385 const bt_component_sink *create_sink(bt_graph *graph)
 386 {
 387         const bt_component_sink *comp;
 388         int ret;
 389
 390         ret = bt_graph_add_sink_component(graph, sink_comp_class,
 391                 "sink-comp", NULL, BT_LOGGING_LEVEL_NONE, &comp);
 392         BT_ASSERT(ret == 0);
 393         return comp;
 394 }
 395
 396 static
 397 bt_graph *create_graph(void)
 398 {
 399         bt_graph *graph = bt_graph_create(0);
 400         int ret;
 401
 402         BT_ASSERT(graph);
 403         ret = bt_graph_add_source_component_output_port_added_listener(
 404                 graph, graph_src_output_port_added, NULL, NULL);
 405         BT_ASSERT(ret >= 0);
 406         ret = bt_graph_add_sink_component_input_port_added_listener(
 407                 graph, graph_sink_input_port_added, NULL, NULL);
 408         BT_ASSERT(ret >= 0);
 409         return graph;
 410 }
 411
 412 static
 413 void prepare_test(enum test test, const char *name)
 414 {
 415         clear_events();
 416         current_test = test;
 417         diag("test: %s", name);
 418 }
 419
 420 static
 421 void test_src_adds_port_in_port_connected(void)
 422 {
 423         const bt_component_source *src;
 424         const bt_component_sink *sink;
 425         const bt_component *gsrc;
 426         const bt_component *gsink;
 427         bt_graph *graph;
 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;
 434         struct event event;
 435         bt_graph_connect_ports_status status;
 436         size_t src_port_connected_pos;
 437         size_t graph_port_added_src_pos;
 438
 439         prepare_test(TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED,
 440                 "source adds port in port connected");
 441         graph = create_graph();
 442         BT_ASSERT(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,
 446                                                                             "out");
 447         BT_ASSERT(src_def_port);
 448         sink_def_port = bt_component_sink_borrow_input_port_by_name_const(sink,
 449                                                                           "in");
 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,
 455                                                                               "hello");
 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);
 462
 463         /* We're supposed to have 5 events */
 464         ok(events->len == 5, "we have the expected number of events");
 465
 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)");
 471
 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)");
 477
 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);
 485
 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);
 492
 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");
 499
 500         /* Order of events */
 501         ok(src_port_connected_pos < graph_port_added_src_pos,
 502                 "event order is good");
 503
 504         bt_component_source_put_ref(src);
 505         bt_component_sink_put_ref(sink);
 506         bt_graph_put_ref(graph);
 507 }
 508
 509 static
 510 void test_simple(void)
 511 {
 512         const bt_component_source *src;
 513         const bt_component_sink *sink;
 514         const bt_component *gsrc;
 515         const bt_component *gsink;
 516         bt_graph *graph;
 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;
 521         struct event event;
 522         bt_graph_connect_ports_status status;
 523
 524         prepare_test(TEST_SIMPLE, "simple");
 525         graph = create_graph();
 526         BT_ASSERT(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,
 530                                                                             "out");
 531         BT_ASSERT(src_def_port);
 532         sink_def_port = bt_component_sink_borrow_input_port_by_name_const(sink,
 533                                                                           "in");
 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);
 542
 543         /* We're supposed to have 4 events */
 544         ok(events->len == 4, "we have the expected number of events");
 545
 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)");
 551
 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)");
 557
 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");
 564
 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");
 571
 572         bt_component_sink_put_ref(sink);
 573         bt_graph_put_ref(graph);
 574         bt_component_source_put_ref(src);
 575 }
 576
 577 static
 578 void test_src_port_connected_error(void)
 579 {
 580         const bt_component_source *src;
 581         const bt_component_sink *sink;
 582         const bt_component *gsrc;
 583         const bt_component *gsink;
 584         bt_graph *graph;
 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;
 590         struct event event;
 591         bt_graph_connect_ports_status status;
 592
 593         prepare_test(TEST_SRC_PORT_CONNECTED_ERROR, "port connected error: source");
 594         graph = create_graph();
 595         BT_ASSERT(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,
 599                                                                             "out");
 600         BT_ASSERT(src_def_port);
 601         sink_def_port = bt_component_sink_borrow_input_port_by_name_const(sink,
 602                                                                           "in");
 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);
 614
 615         /* We're supposed to have 3 events */
 616         ok(events->len == 3, "we have the expected number of events");
 617
 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)");
 623
 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)");
 629
 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");
 636
 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);
 641 }
 642
 643 static
 644 void test_sink_port_connected_error(void)
 645 {
 646         const bt_component_source *src;
 647         const bt_component_sink *sink;
 648         const bt_component *gsrc;
 649         const bt_component *gsink;
 650         bt_graph *graph;
 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;
 656         struct event event;
 657         bt_graph_connect_ports_status status;
 658
 659         prepare_test(TEST_SINK_PORT_CONNECTED_ERROR, "port connected error: sink");
 660         graph = create_graph();
 661         BT_ASSERT(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,
 665                                                                             "out");
 666         BT_ASSERT(src_def_port);
 667         sink_def_port = bt_component_sink_borrow_input_port_by_name_const(sink,
 668                                                                           "in");
 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);
 680
 681         /* We're supposed to have 4 events */
 682         ok(events->len == 4, "we have the expected number of events");
 683
 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)");
 689
 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)");
 695
 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");
 702
 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");
 709
 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);
 714 }
 715
 716 static
 717 void test_empty_graph(void)
 718 {
 719         bt_graph *graph;
 720
 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);
 725 }
 726
 727 int main(int argc, char **argv)
 728 {
 729         plan_tests(NR_TESTS);
 730         init_test();
 731         test_empty_graph();
 732         test_simple();
 733         test_src_port_connected_error();
 734         test_sink_port_connected_error();
 735         test_src_adds_port_in_port_connected();
 736         fini_test();
 737         return exit_status();
 738 }