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 <babeltrace/object.h>
  21 #include <babeltrace/graph/component-class.h>
  22 #include <babeltrace/graph/component-class-source.h>
  23 #include <babeltrace/graph/component-class-sink.h>
  24 #include <babeltrace/graph/component.h>
  25 #include <babeltrace/graph/component-source.h>
  26 #include <babeltrace/graph/component-sink.h>
  27 #include <babeltrace/graph/private-graph.h>
  28 #include <babeltrace/graph/graph.h>
  29 #include <babeltrace/graph/connection.h>
  30 #include <babeltrace/graph/port.h>
  31 #include <babeltrace/graph/private-component.h>
  32 #include <babeltrace/graph/private-component-source.h>
  33 #include <babeltrace/graph/private-component-sink.h>
  34 #include <babeltrace/graph/private-port.h>
  35 #include <babeltrace/graph/private-connection.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <stdbool.h>
  39 #include <babeltrace/assert-internal.h>
  40 #include <glib.h>
  41
  42 #include "tap/tap.h"
  43
  44 #define NR_TESTS        99
  45
  46 enum event_type {
  47         COMP_ACCEPT_PORT_CONNECTION,
  48         COMP_PORT_CONNECTED,
  49         COMP_PORT_DISCONNECTED,
  50         GRAPH_PORT_ADDED,
  51         GRAPH_PORT_REMOVED,
  52         GRAPH_PORTS_CONNECTED,
  53         GRAPH_PORTS_DISCONNECTED,
  54 };
  55
  56 enum test {
  57         TEST_EMPTY_GRAPH,
  58         TEST_SIMPLE,
  59         TEST_SRC_PORT_CONNECTED_ERROR,
  60         TEST_SINK_PORT_CONNECTED_ERROR,
  61         TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED,
  62         TEST_SINK_REMOVES_PORT_IN_CONSUME,
  63         TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT,
  64 };
  65
  66 struct event {
  67         enum event_type type;
  68
  69         union {
  70                 struct {
  71                         struct bt_component *comp;
  72                         struct bt_port *self_port;
  73                         struct bt_port *other_port;
  74                 } comp_accept_port_connection;
  75
  76                 struct {
  77                         struct bt_component *comp;
  78                         struct bt_port *self_port;
  79                         struct bt_port *other_port;
  80                 } comp_port_connected;
  81
  82                 struct {
  83                         struct bt_component *comp;
  84                         struct bt_port *port;
  85                 } comp_port_disconnected;
  86
  87                 struct {
  88                         struct bt_component *comp;
  89                         struct bt_port *port;
  90                 } graph_port_added;
  91
  92                 struct {
  93                         struct bt_component *comp;
  94                         struct bt_port *port;
  95                 } graph_port_removed;
  96
  97                 struct {
  98                         struct bt_component *upstream_comp;
  99                         struct bt_component *downstream_comp;
 100                         struct bt_port *upstream_port;
 101                         struct bt_port *downstream_port;
 102                         struct bt_connection *conn;
 103                 } graph_ports_connected;
 104
 105                 struct {
 106                         struct bt_component *upstream_comp;
 107                         struct bt_component *downstream_comp;
 108                         struct bt_port *upstream_port;
 109                         struct bt_port *downstream_port;
 110                 } graph_ports_disconnected;
 111         } data;
 112 };
 113
 114 static GArray *events;
 115 static struct bt_component_class *src_comp_class;
 116 static struct bt_component_class *sink_comp_class;
 117 static enum test current_test;
 118
 119 static
 120 void clear_events(void)
 121 {
 122         g_array_set_size(events, 0);
 123 }
 124
 125 static
 126 void append_event(struct event *event)
 127 {
 128         g_array_append_val(events, *event);
 129 }
 130
 131 static
 132 bool compare_events(struct event *ev_a, struct event *ev_b)
 133 {
 134         if (ev_a->type != ev_b->type) {
 135                 return false;
 136         }
 137
 138         switch (ev_a->type) {
 139                 case COMP_ACCEPT_PORT_CONNECTION:
 140                         if (ev_a->data.comp_accept_port_connection.comp !=
 141                                         ev_b->data.comp_accept_port_connection.comp) {
 142                                 return false;
 143                         }
 144
 145                         if (ev_a->data.comp_accept_port_connection.self_port !=
 146                                         ev_b->data.comp_accept_port_connection.self_port) {
 147                                 return false;
 148                         }
 149
 150                         if (ev_a->data.comp_accept_port_connection.other_port !=
 151                                         ev_b->data.comp_accept_port_connection.other_port) {
 152                                 return false;
 153                         }
 154                         break;
 155                 case COMP_PORT_CONNECTED:
 156                         if (ev_a->data.comp_port_connected.comp !=
 157                                         ev_b->data.comp_port_connected.comp) {
 158                                 return false;
 159                         }
 160
 161                         if (ev_a->data.comp_port_connected.self_port !=
 162                                         ev_b->data.comp_port_connected.self_port) {
 163                                 return false;
 164                         }
 165
 166                         if (ev_a->data.comp_port_connected.other_port !=
 167                                         ev_b->data.comp_port_connected.other_port) {
 168                                 return false;
 169                         }
 170                         break;
 171                 case COMP_PORT_DISCONNECTED:
 172                         if (ev_a->data.comp_port_disconnected.comp !=
 173                                         ev_b->data.comp_port_disconnected.comp) {
 174                                 return false;
 175                         }
 176
 177                         if (ev_a->data.comp_port_disconnected.port !=
 178                                         ev_b->data.comp_port_disconnected.port) {
 179                                 return false;
 180                         }
 181                         break;
 182                 case GRAPH_PORT_ADDED:
 183                         if (ev_a->data.graph_port_added.comp !=
 184                                         ev_b->data.graph_port_added.comp) {
 185                                 return false;
 186                         }
 187
 188                         if (ev_a->data.graph_port_added.port !=
 189                                         ev_b->data.graph_port_added.port) {
 190                                 return false;
 191                         }
 192                         break;
 193                 case GRAPH_PORT_REMOVED:
 194                         if (ev_a->data.graph_port_removed.comp !=
 195                                         ev_b->data.graph_port_removed.comp) {
 196                                 return false;
 197                         }
 198
 199                         if (ev_a->data.graph_port_removed.port !=
 200                                         ev_b->data.graph_port_removed.port) {
 201                                 return false;
 202                         }
 203                         break;
 204                 case GRAPH_PORTS_CONNECTED:
 205                         if (ev_a->data.graph_ports_connected.upstream_comp !=
 206                                         ev_b->data.graph_ports_connected.upstream_comp) {
 207                                 return false;
 208                         }
 209
 210                         if (ev_a->data.graph_ports_connected.downstream_comp !=
 211                                         ev_b->data.graph_ports_connected.downstream_comp) {
 212                                 return false;
 213                         }
 214
 215                         if (ev_a->data.graph_ports_connected.upstream_port !=
 216                                         ev_b->data.graph_ports_connected.upstream_port) {
 217                                 return false;
 218                         }
 219
 220                         if (ev_a->data.graph_ports_connected.downstream_port !=
 221                                         ev_b->data.graph_ports_connected.downstream_port) {
 222                                 return false;
 223                         }
 224
 225                         if (ev_a->data.graph_ports_connected.conn !=
 226                                         ev_b->data.graph_ports_connected.conn) {
 227                                 return false;
 228                         }
 229                         break;
 230                 case GRAPH_PORTS_DISCONNECTED:
 231                         if (ev_a->data.graph_ports_disconnected.upstream_comp !=
 232                                         ev_b->data.graph_ports_disconnected.upstream_comp) {
 233                                 return false;
 234                         }
 235
 236                         if (ev_a->data.graph_ports_disconnected.downstream_comp !=
 237                                         ev_b->data.graph_ports_disconnected.downstream_comp) {
 238                                 return false;
 239                         }
 240
 241                         if (ev_a->data.graph_ports_disconnected.upstream_port !=
 242                                         ev_b->data.graph_ports_disconnected.upstream_port) {
 243                                 return false;
 244                         }
 245
 246                         if (ev_a->data.graph_ports_disconnected.downstream_port !=
 247                                         ev_b->data.graph_ports_disconnected.downstream_port) {
 248                                 return false;
 249                         }
 250                         break;
 251                 default:
 252                         abort();
 253         }
 254
 255         return true;
 256 }
 257
 258 static
 259 bool has_event(struct event *event)
 260 {
 261         size_t i;
 262
 263         for (i = 0; i < events->len; i++) {
 264                 struct event *ev = &g_array_index(events, struct event, i);
 265
 266                 if (compare_events(event, ev)) {
 267                         return true;
 268                 }
 269         }
 270
 271         return false;
 272 }
 273
 274 static
 275 size_t event_pos(struct event *event)
 276 {
 277         size_t i;
 278
 279         for (i = 0; i < events->len; i++) {
 280                 struct event *ev = &g_array_index(events, struct event, i);
 281
 282                 if (compare_events(event, ev)) {
 283                         return i;
 284                 }
 285         }
 286
 287         return SIZE_MAX;
 288 }
 289
 290 static
 291 enum bt_notification_iterator_status src_iter_next(
 292                 struct bt_private_connection_private_notification_iterator *priv_iterator,
 293                 bt_notification_array notifs, uint64_t capacity,
 294                 uint64_t *count)
 295 {
 296         return BT_NOTIFICATION_ITERATOR_STATUS_ERROR;
 297 }
 298
 299 static
 300 enum bt_component_status accept_port_connection(
 301                 struct bt_private_component *private_component,
 302                 struct bt_private_port *self_private_port,
 303                 struct bt_port *other_port)
 304 {
 305         struct event event = {
 306                 .type = COMP_ACCEPT_PORT_CONNECTION,
 307                 .data.comp_accept_port_connection = {
 308                         .comp = bt_component_borrow_from_private(private_component),
 309                         .self_port = bt_port_borrow_from_private(self_private_port),
 310                         .other_port = other_port,
 311                 },
 312         };
 313
 314         append_event(&event);
 315         return BT_COMPONENT_STATUS_OK;
 316 }
 317
 318 static
 319 enum bt_component_status src_port_connected(
 320                 struct bt_private_component *private_component,
 321                 struct bt_private_port *self_private_port,
 322                 struct bt_port *other_port)
 323 {
 324         int ret;
 325
 326         struct event event = {
 327                 .type = COMP_PORT_CONNECTED,
 328                 .data.comp_port_connected = {
 329                         .comp = bt_component_borrow_from_private(private_component),
 330                         .self_port = bt_port_borrow_from_private(self_private_port),
 331                         .other_port = other_port,
 332                 },
 333         };
 334
 335         append_event(&event);
 336
 337         switch (current_test) {
 338         case TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED:
 339                 ret = bt_private_component_source_add_output_private_port(
 340                         private_component, "hello", NULL, NULL);
 341                 BT_ASSERT(ret == 0);
 342                 break;
 343         case TEST_SRC_PORT_CONNECTED_ERROR:
 344                 return BT_COMPONENT_STATUS_ERROR;
 345         default:
 346                 break;
 347         }
 348
 349         return BT_COMPONENT_STATUS_OK;
 350 }
 351
 352 static
 353 void src_port_disconnected(struct bt_private_component *private_component,
 354                 struct bt_private_port *private_port)
 355 {
 356         int ret;
 357         struct event event = {
 358                 .type = COMP_PORT_DISCONNECTED,
 359                 .data.comp_port_disconnected = {
 360                         .comp = bt_component_borrow_from_private(private_component),
 361                         .port = bt_port_borrow_from_private(private_port),
 362                 },
 363         };
 364
 365         append_event(&event);
 366
 367         switch (current_test) {
 368         case TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT:
 369                 ret = bt_private_port_remove_from_component(private_port);
 370                 BT_ASSERT(ret == 0);
 371         default:
 372                 break;
 373         }
 374 }
 375
 376 static
 377 enum bt_component_status src_init(struct bt_private_component *priv_comp,
 378         struct bt_value *params, void *init_method_data)
 379 {
 380         int ret;
 381
 382         ret = bt_private_component_source_add_output_private_port(
 383                 priv_comp, "out", NULL, NULL);
 384         BT_ASSERT(ret == 0);
 385         return BT_COMPONENT_STATUS_OK;
 386 }
 387
 388 static
 389 enum bt_component_status sink_consume(
 390                 struct bt_private_component *priv_component)
 391 {
 392         struct bt_private_port *def_port;
 393         int ret;
 394
 395         switch (current_test) {
 396         case TEST_SINK_REMOVES_PORT_IN_CONSUME:
 397         case TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT:
 398                 def_port = bt_private_component_sink_get_input_private_port_by_name(
 399                         priv_component, "in");
 400                 BT_ASSERT(def_port);
 401                 ret = bt_private_port_remove_from_component(def_port);
 402                 BT_ASSERT(ret == 0);
 403                 bt_object_put_ref(def_port);
 404                 break;
 405         default:
 406                 break;
 407         }
 408
 409         return BT_COMPONENT_STATUS_OK;
 410 }
 411
 412 static
 413 enum bt_component_status sink_port_connected(
 414                 struct bt_private_component *private_component,
 415                 struct bt_private_port *self_private_port,
 416                 struct bt_port *other_port)
 417 {
 418         struct event event = {
 419                 .type = COMP_PORT_CONNECTED,
 420                 .data.comp_port_connected = {
 421                         .comp = bt_component_borrow_from_private(private_component),
 422                         .self_port = bt_port_borrow_from_private(self_private_port),
 423                         .other_port = other_port,
 424                 },
 425         };
 426
 427         append_event(&event);
 428
 429         if (current_test == TEST_SINK_PORT_CONNECTED_ERROR) {
 430                 return BT_COMPONENT_STATUS_ERROR;
 431         } else {
 432                 return BT_COMPONENT_STATUS_OK;
 433         }
 434 }
 435
 436 static
 437 void sink_port_disconnected(struct bt_private_component *private_component,
 438                 struct bt_private_port *private_port)
 439 {
 440         struct event event = {
 441                 .type = COMP_PORT_DISCONNECTED,
 442                 .data.comp_port_disconnected = {
 443                         .comp = bt_component_borrow_from_private(private_component),
 444                         .port = bt_port_borrow_from_private(private_port),
 445                 },
 446         };
 447
 448         append_event(&event);
 449 }
 450
 451 static
 452 enum bt_component_status sink_init(struct bt_private_component *priv_comp,
 453         struct bt_value *params, void *init_method_data)
 454 {
 455         int ret;
 456
 457         ret = bt_private_component_sink_add_input_private_port(priv_comp,
 458                 "in", NULL, NULL);
 459         BT_ASSERT(ret == 0);
 460         return BT_COMPONENT_STATUS_OK;
 461 }
 462
 463 static
 464 void graph_port_added(struct bt_port *port,
 465                 void *data)
 466 {
 467         struct bt_component *comp = bt_port_get_component(port);
 468
 469         BT_ASSERT(comp);
 470         bt_object_put_ref(comp);
 471
 472         struct event event = {
 473                 .type = GRAPH_PORT_ADDED,
 474                 .data.graph_port_added = {
 475                         .comp = comp,
 476                         .port = port,
 477                 },
 478         };
 479
 480         append_event(&event);
 481 }
 482
 483 static
 484 void graph_port_removed(struct bt_component *component,
 485                 struct bt_port *port, void *data)
 486 {
 487         struct event event = {
 488                 .type = GRAPH_PORT_REMOVED,
 489                 .data.graph_port_removed = {
 490                         .comp = component,
 491                         .port = port,
 492                 },
 493         };
 494
 495         append_event(&event);
 496 }
 497
 498 static
 499 void graph_ports_connected(struct bt_port *upstream_port,
 500                 struct bt_port *downstream_port, void *data)
 501 {
 502         struct bt_component *upstream_comp =
 503                 bt_port_get_component(upstream_port);
 504         struct bt_component *downstream_comp =
 505                 bt_port_get_component(downstream_port);
 506         struct bt_connection *conn = bt_port_get_connection(upstream_port);
 507
 508         BT_ASSERT(upstream_comp);
 509         BT_ASSERT(downstream_comp);
 510         BT_ASSERT(conn);
 511         bt_object_put_ref(upstream_comp);
 512         bt_object_put_ref(downstream_comp);
 513         bt_object_put_ref(conn);
 514
 515         struct event event = {
 516                 .type = GRAPH_PORTS_CONNECTED,
 517                 .data.graph_ports_connected = {
 518                         .upstream_comp = upstream_comp,
 519                         .downstream_comp = downstream_comp,
 520                         .upstream_port = upstream_port,
 521                         .downstream_port = downstream_port,
 522                         .conn = conn,
 523                 },
 524         };
 525
 526         append_event(&event);
 527 }
 528
 529 static
 530 void graph_ports_disconnected(
 531                 struct bt_component *upstream_comp,
 532                 struct bt_component *downstream_comp,
 533                 struct bt_port *upstream_port, struct bt_port *downstream_port,
 534                 void *data)
 535 {
 536         struct event event = {
 537                 .type = GRAPH_PORTS_DISCONNECTED,
 538                 .data.graph_ports_disconnected = {
 539                         .upstream_comp = upstream_comp,
 540                         .downstream_comp = downstream_comp,
 541                         .upstream_port = upstream_port,
 542                         .downstream_port = downstream_port,
 543                 },
 544         };
 545
 546         append_event(&event);
 547 }
 548
 549 static
 550 void init_test(void)
 551 {
 552         int ret;
 553
 554         src_comp_class = bt_component_class_source_create("src", src_iter_next);
 555         BT_ASSERT(src_comp_class);
 556         ret = bt_component_class_set_init_method(src_comp_class, src_init);
 557         BT_ASSERT(ret == 0);
 558         ret = bt_component_class_set_accept_port_connection_method(
 559                 src_comp_class, accept_port_connection);
 560         BT_ASSERT(ret == 0);
 561         ret = bt_component_class_set_port_connected_method(src_comp_class,
 562                 src_port_connected);
 563         BT_ASSERT(ret == 0);
 564         ret = bt_component_class_set_port_disconnected_method(
 565                 src_comp_class, src_port_disconnected);
 566         BT_ASSERT(ret == 0);
 567         sink_comp_class = bt_component_class_sink_create("sink", sink_consume);
 568         BT_ASSERT(sink_comp_class);
 569         ret = bt_component_class_set_init_method(sink_comp_class, sink_init);
 570         BT_ASSERT(ret == 0);
 571         ret = bt_component_class_set_accept_port_connection_method(
 572                 sink_comp_class, accept_port_connection);
 573         BT_ASSERT(ret == 0);
 574         ret = bt_component_class_set_port_connected_method(sink_comp_class,
 575                 sink_port_connected);
 576         BT_ASSERT(ret == 0);
 577         ret = bt_component_class_set_port_disconnected_method(sink_comp_class,
 578                 sink_port_disconnected);
 579         BT_ASSERT(ret == 0);
 580         bt_component_class_freeze(src_comp_class);
 581         bt_component_class_freeze(sink_comp_class);
 582         events = g_array_new(FALSE, TRUE, sizeof(struct event));
 583         BT_ASSERT(events);
 584 }
 585
 586 static
 587 void fini_test(void)
 588 {
 589         bt_object_put_ref(src_comp_class);
 590         bt_object_put_ref(sink_comp_class);
 591         g_array_free(events, TRUE);
 592 }
 593
 594 static
 595 struct bt_component *create_src(struct bt_private_graph *graph)
 596 {
 597         struct bt_component *comp;
 598         int ret;
 599
 600         ret = bt_private_graph_add_component(graph, src_comp_class, "src-comp", NULL,
 601                 &comp);
 602         BT_ASSERT(ret == 0);
 603         return comp;
 604 }
 605
 606 static
 607 struct bt_component *create_sink(struct bt_private_graph *graph)
 608 {
 609         struct bt_component *comp;
 610         int ret;
 611
 612         ret = bt_private_graph_add_component(graph, sink_comp_class, "sink-comp",
 613                 NULL, &comp);
 614         BT_ASSERT(ret == 0);
 615         return comp;
 616 }
 617
 618 static
 619 struct bt_private_graph *create_graph(void)
 620 {
 621         struct bt_private_graph *graph = bt_private_graph_create();
 622         int ret;
 623
 624         BT_ASSERT(graph);
 625         ret = bt_private_graph_add_port_added_listener(graph, graph_port_added, NULL,
 626                 NULL);
 627         BT_ASSERT(ret >= 0);
 628         ret = bt_private_graph_add_port_removed_listener(graph, graph_port_removed,
 629                 NULL, NULL);
 630         BT_ASSERT(ret >= 0);
 631         ret = bt_private_graph_add_ports_connected_listener(graph,
 632                 graph_ports_connected, NULL, NULL);
 633         BT_ASSERT(ret >= 0);
 634         ret = bt_private_graph_add_ports_disconnected_listener(graph,
 635                 graph_ports_disconnected, NULL, NULL);
 636         BT_ASSERT(ret >= 0);
 637         return graph;
 638 }
 639
 640 static
 641 void prepare_test(enum test test, const char *name)
 642 {
 643         clear_events();
 644         current_test = test;
 645         diag("test: %s", name);
 646 }
 647
 648 static
 649 void test_sink_removes_port_in_port_connected_then_src_removes_disconnected_port(void)
 650 {
 651         int ret;
 652         struct bt_component *src;
 653         struct bt_component *sink;
 654         struct bt_private_graph *graph;
 655         struct bt_port *src_def_port;
 656         struct bt_port *sink_def_port;
 657         struct bt_connection *conn;
 658         struct event event;
 659         enum bt_graph_status status;
 660         size_t src_accept_port_connection_pos;
 661         size_t sink_accept_port_connection_pos;
 662         size_t src_port_connected_pos;
 663         size_t sink_port_connected_pos;
 664         size_t graph_ports_connected;
 665         size_t src_port_disconnected_pos;
 666         size_t sink_port_disconnected_pos;
 667         size_t graph_ports_disconnected_pos;
 668         size_t graph_port_removed_src_pos;
 669         size_t graph_port_removed_sink_pos;
 670
 671         prepare_test(TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT,
 672                 "sink removes port in consume, then source removes disconnected port");
 673         graph = create_graph();
 674         BT_ASSERT(graph);
 675         src = create_src(graph);
 676         sink = create_sink(graph);
 677         src_def_port = bt_component_source_get_output_port_by_name(src, "out");
 678         BT_ASSERT(src_def_port);
 679         sink_def_port = bt_component_sink_get_input_port_by_name(sink, "in");
 680         BT_ASSERT(sink_def_port);
 681         status = bt_private_graph_connect_ports(graph, src_def_port, sink_def_port,
 682                 &conn);
 683         BT_ASSERT(status == 0);
 684         BT_ASSERT(conn);
 685
 686         /* We're supposed to have 7 events so far */
 687         ok(events->len == 7, "we have the expected number of events (before consume)");
 688
 689         /* Source's port added */
 690         event.type = GRAPH_PORT_ADDED;
 691         event.data.graph_port_added.comp = src;
 692         event.data.graph_port_added.port = src_def_port;
 693         ok(has_event(&event), "got the expected graph's port added event (for source, initial)");
 694
 695         /* Sink's port added */
 696         event.type = GRAPH_PORT_ADDED;
 697         event.data.graph_port_added.comp = sink;
 698         event.data.graph_port_added.port = sink_def_port;
 699         ok(has_event(&event), "got the expected graph's port added event (for sink, initial)");
 700
 701         /* Source's accept port connection */
 702         event.type = COMP_ACCEPT_PORT_CONNECTION;
 703         event.data.comp_accept_port_connection.comp = src;
 704         event.data.comp_accept_port_connection.self_port = src_def_port;
 705         event.data.comp_accept_port_connection.other_port = sink_def_port;
 706         ok(has_event(&event), "got the expected source's accept port connection event");
 707         src_accept_port_connection_pos = event_pos(&event);
 708
 709         /* Sink's accept port connection */
 710         event.type = COMP_ACCEPT_PORT_CONNECTION;
 711         event.data.comp_accept_port_connection.comp = sink;
 712         event.data.comp_accept_port_connection.self_port = sink_def_port;
 713         event.data.comp_accept_port_connection.other_port = src_def_port;
 714         ok(has_event(&event), "got the expected sink's accept port connection event");
 715         sink_accept_port_connection_pos = event_pos(&event);
 716
 717         /* Source's port connected */
 718         event.type = COMP_PORT_CONNECTED;
 719         event.data.comp_port_connected.comp = src;
 720         event.data.comp_port_connected.self_port = src_def_port;
 721         event.data.comp_port_connected.other_port = sink_def_port;
 722         ok(has_event(&event), "got the expected source's port connected event");
 723         src_port_connected_pos = event_pos(&event);
 724
 725         /* Sink's port connected */
 726         event.type = COMP_PORT_CONNECTED;
 727         event.data.comp_port_connected.comp = sink;
 728         event.data.comp_port_connected.self_port = sink_def_port;
 729         event.data.comp_port_connected.other_port = src_def_port;
 730         ok(has_event(&event), "got the expected sink's port connected event");
 731         sink_port_connected_pos = event_pos(&event);
 732
 733         /* Graph's ports connected */
 734         event.type = GRAPH_PORTS_CONNECTED;
 735         event.data.graph_ports_connected.upstream_comp = src;
 736         event.data.graph_ports_connected.downstream_comp = sink;
 737         event.data.graph_ports_connected.upstream_port = src_def_port;
 738         event.data.graph_ports_connected.downstream_port = sink_def_port;
 739         event.data.graph_ports_connected.conn = conn;
 740         ok(has_event(&event), "got the expected graph's ports connected event");
 741         graph_ports_connected = event_pos(&event);
 742
 743         /* Order of events */
 744         ok(src_port_connected_pos < graph_ports_connected,
 745                 "event order is good (1)");
 746         ok(sink_port_connected_pos < graph_ports_connected,
 747                 "event order is good (2)");
 748         ok(src_accept_port_connection_pos < src_port_connected_pos,
 749                 "event order is good (3)");
 750         ok(sink_accept_port_connection_pos < sink_port_connected_pos,
 751                 "event order is good (4)");
 752
 753         /* Consume sink once */
 754         clear_events();
 755         ret = bt_private_graph_consume(graph);
 756         BT_ASSERT(ret == 0);
 757
 758         /* We're supposed to have 5 new events */
 759         ok(events->len == 5, "we have the expected number of events (after consume)");
 760
 761         /* Source's port disconnected */
 762         event.type = COMP_PORT_DISCONNECTED;
 763         event.data.comp_port_disconnected.comp = src;
 764         event.data.comp_port_disconnected.port = src_def_port;
 765         ok(has_event(&event), "got the expected source's port disconnected event");
 766         src_port_disconnected_pos = event_pos(&event);
 767
 768         /* Sink's port disconnected */
 769         event.type = COMP_PORT_DISCONNECTED;
 770         event.data.comp_port_disconnected.comp = sink;
 771         event.data.comp_port_disconnected.port = sink_def_port;
 772         ok(has_event(&event), "got the expected sink's port disconnected event");
 773         sink_port_disconnected_pos = event_pos(&event);
 774
 775         /* Graph's ports disconnected */
 776         event.type = GRAPH_PORTS_DISCONNECTED;
 777         event.data.graph_ports_disconnected.upstream_comp = src;
 778         event.data.graph_ports_disconnected.downstream_comp = sink;
 779         event.data.graph_ports_disconnected.upstream_port = src_def_port;
 780         event.data.graph_ports_disconnected.downstream_port = sink_def_port;
 781         ok(has_event(&event), "got the expected graph's ports disconnected event");
 782         graph_ports_disconnected_pos = event_pos(&event);
 783
 784         /* Graph's port removed (sink) */
 785         event.type = GRAPH_PORT_REMOVED;
 786         event.data.graph_port_removed.comp = sink;
 787         event.data.graph_port_removed.port = sink_def_port;
 788         ok(has_event(&event), "got the expected graph's port removed event (for sink)");
 789         graph_port_removed_sink_pos = event_pos(&event);
 790
 791         /* Graph's port removed (source) */
 792         event.type = GRAPH_PORT_REMOVED;
 793         event.data.graph_port_removed.comp = src;
 794         event.data.graph_port_removed.port = src_def_port;
 795         ok(has_event(&event), "got the expected graph's port removed event (for source)");
 796         graph_port_removed_src_pos = event_pos(&event);
 797
 798         /* Order of events */
 799         ok(src_port_disconnected_pos < graph_ports_disconnected_pos,
 800                 "event order is good (5)");
 801         ok(src_port_disconnected_pos < graph_port_removed_sink_pos,
 802                 "event order is good (6)");
 803         ok(src_port_disconnected_pos < graph_port_removed_src_pos,
 804                 "event order is good (7)");
 805         ok(sink_port_disconnected_pos < graph_ports_disconnected_pos,
 806                 "event order is good (8)");
 807         ok(sink_port_disconnected_pos < graph_port_removed_sink_pos,
 808                 "event order is good (9)");
 809         ok(sink_port_disconnected_pos < graph_port_removed_src_pos,
 810                 "event order is good (10)");
 811         ok(graph_ports_disconnected_pos < graph_port_removed_sink_pos,
 812                 "event order is good (11)");
 813         ok(graph_port_removed_src_pos < graph_ports_disconnected_pos,
 814                 "event order is good (12)");
 815         ok(graph_port_removed_src_pos < graph_port_removed_sink_pos,
 816                 "event order is good (13)");
 817
 818         bt_object_put_ref(graph);
 819         bt_object_put_ref(sink);
 820         bt_object_put_ref(src);
 821         bt_object_put_ref(conn);
 822         bt_object_put_ref(src_def_port);
 823         bt_object_put_ref(sink_def_port);
 824 }
 825
 826 static
 827 void test_sink_removes_port_in_port_connected(void)
 828 {
 829         int ret;
 830         struct bt_component *src;
 831         struct bt_component *sink;
 832         struct bt_private_graph *graph;
 833         struct bt_port *src_def_port;
 834         struct bt_port *sink_def_port;
 835         struct bt_connection *conn;
 836         struct event event;
 837         enum bt_graph_status status;
 838         size_t src_accept_port_connection_pos;
 839         size_t sink_accept_port_connection_pos;
 840         size_t src_port_connected_pos;
 841         size_t sink_port_connected_pos;
 842         size_t graph_ports_connected_pos;
 843         size_t src_port_disconnected_pos;
 844         size_t sink_port_disconnected_pos;
 845         size_t graph_ports_disconnected_pos;
 846         size_t graph_port_removed_sink_pos;
 847
 848         prepare_test(TEST_SINK_REMOVES_PORT_IN_CONSUME,
 849                 "sink removes port in consume");
 850         graph = create_graph();
 851         BT_ASSERT(graph);
 852         src = create_src(graph);
 853         sink = create_sink(graph);
 854         src_def_port = bt_component_source_get_output_port_by_name(src, "out");
 855         BT_ASSERT(src_def_port);
 856         sink_def_port = bt_component_sink_get_input_port_by_name(sink, "in");
 857         BT_ASSERT(sink_def_port);
 858         status = bt_private_graph_connect_ports(graph, src_def_port, sink_def_port,
 859                 &conn);
 860         BT_ASSERT(status == 0);
 861
 862         /* We're supposed to have 7 events so far */
 863         ok(events->len == 7, "we have the expected number of events (before consume)");
 864
 865         /* Source's port added */
 866         event.type = GRAPH_PORT_ADDED;
 867         event.data.graph_port_added.comp = src;
 868         event.data.graph_port_added.port = src_def_port;
 869         ok(has_event(&event), "got the expected graph's port added event (for source, initial)");
 870
 871         /* Sink's port added */
 872         event.type = GRAPH_PORT_ADDED;
 873         event.data.graph_port_added.comp = sink;
 874         event.data.graph_port_added.port = sink_def_port;
 875         ok(has_event(&event), "got the expected graph's port added event (for sink, initial)");
 876
 877         /* Source's accept port connection */
 878         event.type = COMP_ACCEPT_PORT_CONNECTION;
 879         event.data.comp_accept_port_connection.comp = src;
 880         event.data.comp_accept_port_connection.self_port = src_def_port;
 881         event.data.comp_accept_port_connection.other_port = sink_def_port;
 882         ok(has_event(&event), "got the expected source's accept port connection event");
 883         src_accept_port_connection_pos = event_pos(&event);
 884
 885         /* Sink's accept port connection */
 886         event.type = COMP_ACCEPT_PORT_CONNECTION;
 887         event.data.comp_accept_port_connection.comp = sink;
 888         event.data.comp_accept_port_connection.self_port = sink_def_port;
 889         event.data.comp_accept_port_connection.other_port = src_def_port;
 890         ok(has_event(&event), "got the expected sink's accept port connection event");
 891         sink_accept_port_connection_pos = event_pos(&event);
 892
 893         /* Source's port connected */
 894         event.type = COMP_PORT_CONNECTED;
 895         event.data.comp_port_connected.comp = src;
 896         event.data.comp_port_connected.self_port = src_def_port;
 897         event.data.comp_port_connected.other_port = sink_def_port;
 898         ok(has_event(&event), "got the expected source's port connected event");
 899         src_port_connected_pos = event_pos(&event);
 900
 901         /* Sink's port connected */
 902         event.type = COMP_PORT_CONNECTED;
 903         event.data.comp_port_connected.comp = sink;
 904         event.data.comp_port_connected.self_port = sink_def_port;
 905         event.data.comp_port_connected.other_port = src_def_port;
 906         ok(has_event(&event), "got the expected sink's port connected event");
 907         sink_port_connected_pos = event_pos(&event);
 908
 909         /* Graph's ports connected */
 910         event.type = GRAPH_PORTS_CONNECTED;
 911         event.data.graph_ports_connected.upstream_comp = src;
 912         event.data.graph_ports_connected.downstream_comp = sink;
 913         event.data.graph_ports_connected.upstream_port = src_def_port;
 914         event.data.graph_ports_connected.downstream_port = sink_def_port;
 915         event.data.graph_ports_connected.conn = conn;
 916         ok(has_event(&event), "got the expected graph's ports connected event");
 917         graph_ports_connected_pos = event_pos(&event);
 918
 919         /* Order of events */
 920         ok(src_port_connected_pos < graph_ports_connected_pos,
 921                 "event order is good (1)");
 922         ok(sink_port_connected_pos < graph_ports_connected_pos,
 923                 "event order is good (2)");
 924         ok(src_accept_port_connection_pos < src_port_connected_pos,
 925                 "event order is good (3)");
 926         ok(sink_accept_port_connection_pos < sink_port_connected_pos,
 927                 "event order is good (4)");
 928
 929         /* Consume sink once */
 930         clear_events();
 931         ret = bt_private_graph_consume(graph);
 932         BT_ASSERT(ret == 0);
 933
 934         /* We're supposed to have 4 new events */
 935         ok(events->len == 4, "we have the expected number of events (after consume)");
 936
 937         /* Source's port disconnected */
 938         event.type = COMP_PORT_DISCONNECTED;
 939         event.data.comp_port_disconnected.comp = src;
 940         event.data.comp_port_disconnected.port = src_def_port;
 941         ok(has_event(&event), "got the expected source's port disconnected event");
 942         src_port_disconnected_pos = event_pos(&event);
 943
 944         /* Sink's port disconnected */
 945         event.type = COMP_PORT_DISCONNECTED;
 946         event.data.comp_port_disconnected.comp = sink;
 947         event.data.comp_port_disconnected.port = sink_def_port;
 948         ok(has_event(&event), "got the expected sink's port disconnected event");
 949         sink_port_disconnected_pos = event_pos(&event);
 950
 951         /* Graph's ports disconnected */
 952         event.type = GRAPH_PORTS_DISCONNECTED;
 953         event.data.graph_ports_disconnected.upstream_comp = src;
 954         event.data.graph_ports_disconnected.downstream_comp = sink;
 955         event.data.graph_ports_disconnected.upstream_port = src_def_port;
 956         event.data.graph_ports_disconnected.downstream_port = sink_def_port;
 957         ok(has_event(&event), "got the expected graph's ports disconnected event");
 958         graph_ports_disconnected_pos = event_pos(&event);
 959
 960         /* Graph's port removed (sink) */
 961         event.type = GRAPH_PORT_REMOVED;
 962         event.data.graph_port_removed.comp = sink;
 963         event.data.graph_port_removed.port = sink_def_port;
 964         ok(has_event(&event), "got the expected graph's port removed event (for sink)");
 965         graph_port_removed_sink_pos = event_pos(&event);
 966
 967         /* Order of events */
 968         ok(src_port_disconnected_pos < graph_ports_disconnected_pos,
 969                 "event order is good (5)");
 970         ok(src_port_disconnected_pos < graph_port_removed_sink_pos,
 971                 "event order is good (7)");
 972         ok(sink_port_disconnected_pos < graph_ports_disconnected_pos,
 973                 "event order is good (8)");
 974         ok(sink_port_disconnected_pos < graph_port_removed_sink_pos,
 975                 "event order is good (10)");
 976         ok(graph_ports_disconnected_pos < graph_port_removed_sink_pos,
 977                 "event order is good (11)");
 978
 979         bt_object_put_ref(graph);
 980         bt_object_put_ref(sink);
 981         bt_object_put_ref(src);
 982         bt_object_put_ref(conn);
 983         bt_object_put_ref(src_def_port);
 984         bt_object_put_ref(sink_def_port);
 985 }
 986
 987 static
 988 void test_src_adds_port_in_port_connected(void)
 989 {
 990         struct bt_component *src;
 991         struct bt_component *sink;
 992         struct bt_private_graph *graph;
 993         struct bt_port *src_def_port;
 994         struct bt_port *sink_def_port;
 995         struct bt_port *src_hello_port;
 996         struct bt_connection *conn;
 997         struct event event;
 998         enum bt_graph_status status;
 999         size_t src_accept_port_connection_pos;
1000         size_t sink_accept_port_connection_pos;
1001         size_t src_port_connected_pos;
1002         size_t sink_port_connected_pos;
1003         size_t graph_ports_connected_pos;
1004         size_t graph_port_added_src_pos;
1005
1006         prepare_test(TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED,
1007                 "source adds port in port connected");
1008         graph = create_graph();
1009         BT_ASSERT(graph);
1010         src = create_src(graph);
1011         sink = create_sink(graph);
1012         src_def_port = bt_component_source_get_output_port_by_name(src, "out");
1013         BT_ASSERT(src_def_port);
1014         sink_def_port = bt_component_sink_get_input_port_by_name(sink, "in");
1015         BT_ASSERT(sink_def_port);
1016         status = bt_private_graph_connect_ports(graph, src_def_port, sink_def_port,
1017                 &conn);
1018         BT_ASSERT(status == 0);
1019         src_hello_port = bt_component_source_get_output_port_by_name(src,
1020                 "hello");
1021         BT_ASSERT(src_hello_port);
1022
1023         /* We're supposed to have 8 events */
1024         ok(events->len == 8, "we have the expected number of events");
1025
1026         /* Source's port added */
1027         event.type = GRAPH_PORT_ADDED;
1028         event.data.graph_port_added.comp = src;
1029         event.data.graph_port_added.port = src_def_port;
1030         ok(has_event(&event), "got the expected graph's port added event (for source, initial)");
1031
1032         /* Sink's port added */
1033         event.type = GRAPH_PORT_ADDED;
1034         event.data.graph_port_added.comp = sink;
1035         event.data.graph_port_added.port = sink_def_port;
1036         ok(has_event(&event), "got the expected graph's port added event (for sink, initial)");
1037
1038         /* Source's accept port connection */
1039         event.type = COMP_ACCEPT_PORT_CONNECTION;
1040         event.data.comp_accept_port_connection.comp = src;
1041         event.data.comp_accept_port_connection.self_port = src_def_port;
1042         event.data.comp_accept_port_connection.other_port = sink_def_port;
1043         ok(has_event(&event), "got the expected source's accept port connection event");
1044         src_accept_port_connection_pos = event_pos(&event);
1045
1046         /* Sink's accept port connection */
1047         event.type = COMP_ACCEPT_PORT_CONNECTION;
1048         event.data.comp_accept_port_connection.comp = sink;
1049         event.data.comp_accept_port_connection.self_port = sink_def_port;
1050         event.data.comp_accept_port_connection.other_port = src_def_port;
1051         ok(has_event(&event), "got the expected sink's accept port connection event");
1052         sink_accept_port_connection_pos = event_pos(&event);
1053
1054         /* Source's port connected */
1055         event.type = COMP_PORT_CONNECTED;
1056         event.data.comp_port_connected.comp = src;
1057         event.data.comp_port_connected.self_port = src_def_port;
1058         event.data.comp_port_connected.other_port = sink_def_port;
1059         ok(has_event(&event), "got the expected source's port connected event");
1060         src_port_connected_pos = event_pos(&event);
1061
1062         /* Graph's port added (source) */
1063         event.type = GRAPH_PORT_ADDED;
1064         event.data.graph_port_added.comp = src;
1065         event.data.graph_port_added.port = src_hello_port;
1066         ok(has_event(&event), "got the expected graph's port added event (for source)");
1067         graph_port_added_src_pos = event_pos(&event);
1068
1069         /* Sink's port connected */
1070         event.type = COMP_PORT_CONNECTED;
1071         event.data.comp_port_connected.comp = sink;
1072         event.data.comp_port_connected.self_port = sink_def_port;
1073         event.data.comp_port_connected.other_port = src_def_port;
1074         ok(has_event(&event), "got the expected sink's port connected event");
1075         sink_port_connected_pos = event_pos(&event);
1076
1077         /* Graph's ports connected */
1078         event.type = GRAPH_PORTS_CONNECTED;
1079         event.data.graph_ports_connected.upstream_comp = src;
1080         event.data.graph_ports_connected.downstream_comp = sink;
1081         event.data.graph_ports_connected.upstream_port = src_def_port;
1082         event.data.graph_ports_connected.downstream_port = sink_def_port;
1083         event.data.graph_ports_connected.conn = conn;
1084         ok(has_event(&event), "got the expected graph's port connected event (for source)");
1085         graph_ports_connected_pos = event_pos(&event);
1086
1087         /* Order of events */
1088         ok(src_port_connected_pos < graph_ports_connected_pos,
1089                 "event order is good (1)");
1090         ok(sink_port_connected_pos < graph_ports_connected_pos,
1091                 "event order is good (2)");
1092         ok(src_accept_port_connection_pos < src_port_connected_pos,
1093                 "event order is good (3)");
1094         ok(sink_accept_port_connection_pos < sink_port_connected_pos,
1095                 "event order is good (4)");
1096         ok(src_port_connected_pos < graph_port_added_src_pos,
1097                 "event order is good (5)");
1098         ok(graph_port_added_src_pos < graph_ports_connected_pos,
1099                 "event order is good (6)");
1100
1101         bt_object_put_ref(graph);
1102         bt_object_put_ref(sink);
1103         bt_object_put_ref(src);
1104         bt_object_put_ref(conn);
1105         bt_object_put_ref(src_def_port);
1106         bt_object_put_ref(sink_def_port);
1107         bt_object_put_ref(src_hello_port);
1108 }
1109
1110 static
1111 void test_simple(void)
1112 {
1113         struct bt_component *src;
1114         struct bt_component *sink;
1115         struct bt_private_graph *graph;
1116         struct bt_port *src_def_port;
1117         struct bt_port *sink_def_port;
1118         struct bt_connection *conn;
1119         struct event event;
1120         enum bt_graph_status status;
1121         size_t src_accept_port_connection_pos;
1122         size_t sink_accept_port_connection_pos;
1123         size_t src_port_connected_pos;
1124         size_t sink_port_connected_pos;
1125         size_t graph_ports_connected_pos;
1126
1127         prepare_test(TEST_SIMPLE, "simple");
1128         graph = create_graph();
1129         BT_ASSERT(graph);
1130         src = create_src(graph);
1131         sink = create_sink(graph);
1132         src_def_port = bt_component_source_get_output_port_by_name(src, "out");
1133         BT_ASSERT(src_def_port);
1134         sink_def_port = bt_component_sink_get_input_port_by_name(sink, "in");
1135         BT_ASSERT(sink_def_port);
1136         status = bt_private_graph_connect_ports(graph, src_def_port, sink_def_port,
1137                 &conn);
1138         BT_ASSERT(status == 0);
1139
1140         /* We're supposed to have 7 events */
1141         ok(events->len == 7, "we have the expected number of events");
1142
1143         /* Source's port added */
1144         event.type = GRAPH_PORT_ADDED;
1145         event.data.graph_port_added.comp = src;
1146         event.data.graph_port_added.port = src_def_port;
1147         ok(has_event(&event), "got the expected graph's port added event (for source, initial)");
1148
1149         /* Sink's port added */
1150         event.type = GRAPH_PORT_ADDED;
1151         event.data.graph_port_added.comp = sink;
1152         event.data.graph_port_added.port = sink_def_port;
1153         ok(has_event(&event), "got the expected graph's port added event (for sink, initial)");
1154
1155         /* Source's accept port connection */
1156         event.type = COMP_ACCEPT_PORT_CONNECTION;
1157         event.data.comp_accept_port_connection.comp = src;
1158         event.data.comp_accept_port_connection.self_port = src_def_port;
1159         event.data.comp_accept_port_connection.other_port = sink_def_port;
1160         ok(has_event(&event), "got the expected source's accept port connection event");
1161         src_accept_port_connection_pos = event_pos(&event);
1162
1163         /* Sink's accept port connection */
1164         event.type = COMP_ACCEPT_PORT_CONNECTION;
1165         event.data.comp_accept_port_connection.comp = sink;
1166         event.data.comp_accept_port_connection.self_port = sink_def_port;
1167         event.data.comp_accept_port_connection.other_port = src_def_port;
1168         ok(has_event(&event), "got the expected sink's accept port connection event");
1169         sink_accept_port_connection_pos = event_pos(&event);
1170
1171         /* Source's port connected */
1172         event.type = COMP_PORT_CONNECTED;
1173         event.data.comp_port_connected.comp = src;
1174         event.data.comp_port_connected.self_port = src_def_port;
1175         event.data.comp_port_connected.other_port = sink_def_port;
1176         ok(has_event(&event), "got the expected source's port connected event");
1177         src_port_connected_pos = event_pos(&event);
1178
1179         /* Sink's port connected */
1180         event.type = COMP_PORT_CONNECTED;
1181         event.data.comp_port_connected.comp = sink;
1182         event.data.comp_port_connected.self_port = sink_def_port;
1183         event.data.comp_port_connected.other_port = src_def_port;
1184         ok(has_event(&event), "got the expected sink's port connected event");
1185         sink_port_connected_pos = event_pos(&event);
1186
1187         /* Graph's port connected */
1188         event.type = GRAPH_PORTS_CONNECTED;
1189         event.data.graph_ports_connected.upstream_comp = src;
1190         event.data.graph_ports_connected.downstream_comp = sink;
1191         event.data.graph_ports_connected.upstream_port = src_def_port;
1192         event.data.graph_ports_connected.downstream_port = sink_def_port;
1193         event.data.graph_ports_connected.conn = conn;
1194         ok(has_event(&event), "got the expected graph's ports connected event");
1195         graph_ports_connected_pos = event_pos(&event);
1196
1197         /* Order of events */
1198         ok(src_port_connected_pos < graph_ports_connected_pos,
1199                 "event order is good (1)");
1200         ok(sink_port_connected_pos < graph_ports_connected_pos,
1201                 "event order is good (2)");
1202         ok(src_accept_port_connection_pos < src_port_connected_pos,
1203                 "event order is good (3)");
1204         ok(sink_accept_port_connection_pos < sink_port_connected_pos,
1205                 "event order is good (4)");
1206
1207         bt_object_put_ref(graph);
1208         bt_object_put_ref(sink);
1209         bt_object_put_ref(src);
1210         bt_object_put_ref(conn);
1211         bt_object_put_ref(src_def_port);
1212         bt_object_put_ref(sink_def_port);
1213 }
1214
1215 static
1216 void test_src_port_connected_error(void)
1217 {
1218         struct bt_component *src;
1219         struct bt_component *sink;
1220         struct bt_private_graph *graph;
1221         struct bt_port *src_def_port;
1222         struct bt_port *sink_def_port;
1223         struct bt_connection *conn = NULL;
1224         struct event event;
1225         enum bt_graph_status status;
1226         size_t src_accept_port_connection_pos;
1227         size_t src_port_connected_pos;
1228
1229         prepare_test(TEST_SRC_PORT_CONNECTED_ERROR, "port connected error: source");
1230         graph = create_graph();
1231         BT_ASSERT(graph);
1232         src = create_src(graph);
1233         sink = create_sink(graph);
1234         src_def_port = bt_component_source_get_output_port_by_name(src, "out");
1235         BT_ASSERT(src_def_port);
1236         sink_def_port = bt_component_sink_get_input_port_by_name(sink, "in");
1237         BT_ASSERT(sink_def_port);
1238         status = bt_private_graph_connect_ports(graph, src_def_port, sink_def_port,
1239                 &conn);
1240         ok(status != BT_GRAPH_STATUS_OK,
1241                 "bt_private_graph_connect_ports() returns an error");
1242         ok(!conn, "returned connection is NULL");
1243
1244         /* We're supposed to have 5 events */
1245         ok(events->len == 5, "we have the expected number of events");
1246
1247         /* Source's port added */
1248         event.type = GRAPH_PORT_ADDED;
1249         event.data.graph_port_added.comp = src;
1250         event.data.graph_port_added.port = src_def_port;
1251         ok(has_event(&event), "got the expected graph's port added event (for source, initial)");
1252
1253         /* Sink's port added */
1254         event.type = GRAPH_PORT_ADDED;
1255         event.data.graph_port_added.comp = sink;
1256         event.data.graph_port_added.port = sink_def_port;
1257         ok(has_event(&event), "got the expected graph's port added event (for sink, initial)");
1258
1259         /* Source's accept port connection */
1260         event.type = COMP_ACCEPT_PORT_CONNECTION;
1261         event.data.comp_accept_port_connection.comp = src;
1262         event.data.comp_accept_port_connection.self_port = src_def_port;
1263         event.data.comp_accept_port_connection.other_port = sink_def_port;
1264         ok(has_event(&event), "got the expected source's accept port connection event");
1265         src_accept_port_connection_pos = event_pos(&event);
1266
1267         /* Sink's accept port connection */
1268         event.type = COMP_ACCEPT_PORT_CONNECTION;
1269         event.data.comp_accept_port_connection.comp = sink;
1270         event.data.comp_accept_port_connection.self_port = sink_def_port;
1271         event.data.comp_accept_port_connection.other_port = src_def_port;
1272         ok(has_event(&event), "got the expected sink's accept port connection event");
1273
1274         /* Source's port connected */
1275         event.type = COMP_PORT_CONNECTED;
1276         event.data.comp_port_connected.comp = src;
1277         event.data.comp_port_connected.self_port = src_def_port;
1278         event.data.comp_port_connected.other_port = sink_def_port;
1279         ok(has_event(&event), "got the expected source's port connected event");
1280         src_port_connected_pos = event_pos(&event);
1281
1282         /* Order of events */
1283         ok(src_accept_port_connection_pos < src_port_connected_pos,
1284                 "event order is good (1)");
1285
1286         bt_object_put_ref(graph);
1287         bt_object_put_ref(sink);
1288         bt_object_put_ref(src);
1289         bt_object_put_ref(conn);
1290         bt_object_put_ref(src_def_port);
1291         bt_object_put_ref(sink_def_port);
1292 }
1293
1294 static
1295 void test_sink_port_connected_error(void)
1296 {
1297         struct bt_component *src;
1298         struct bt_component *sink;
1299         struct bt_private_graph *graph;
1300         struct bt_port *src_def_port;
1301         struct bt_port *sink_def_port;
1302         struct bt_connection *conn = NULL;
1303         struct event event;
1304         enum bt_graph_status status;
1305         size_t src_accept_port_connection_pos;
1306         size_t sink_accept_port_connection_pos;
1307         size_t src_port_connected_pos;
1308         size_t src_port_disconnected_pos;
1309         size_t sink_port_connected_pos;
1310
1311         prepare_test(TEST_SINK_PORT_CONNECTED_ERROR, "port connected error: sink");
1312         graph = create_graph();
1313         BT_ASSERT(graph);
1314         src = create_src(graph);
1315         sink = create_sink(graph);
1316         src_def_port = bt_component_source_get_output_port_by_name(src, "out");
1317         BT_ASSERT(src_def_port);
1318         sink_def_port = bt_component_sink_get_input_port_by_name(sink, "in");
1319         BT_ASSERT(sink_def_port);
1320         status = bt_private_graph_connect_ports(graph, src_def_port, sink_def_port,
1321                 &conn);
1322         ok(status != BT_GRAPH_STATUS_OK,
1323                 "bt_private_graph_connect_ports() returns an error");
1324         ok(!conn, "returned connection is NULL");
1325
1326         /* We're supposed to have 5 events */
1327         ok(events->len == 7, "we have the expected number of events");
1328
1329         /* Source's port added */
1330         event.type = GRAPH_PORT_ADDED;
1331         event.data.graph_port_added.comp = src;
1332         event.data.graph_port_added.port = src_def_port;
1333         ok(has_event(&event), "got the expected graph's port added event (for source, initial)");
1334
1335         /* Sink's port added */
1336         event.type = GRAPH_PORT_ADDED;
1337         event.data.graph_port_added.comp = sink;
1338         event.data.graph_port_added.port = sink_def_port;
1339         ok(has_event(&event), "got the expected graph's port added event (for sink, initial)");
1340
1341         /* Source's accept port connection */
1342         event.type = COMP_ACCEPT_PORT_CONNECTION;
1343         event.data.comp_accept_port_connection.comp = src;
1344         event.data.comp_accept_port_connection.self_port = src_def_port;
1345         event.data.comp_accept_port_connection.other_port = sink_def_port;
1346         ok(has_event(&event), "got the expected source's accept port connection event");
1347         src_accept_port_connection_pos = event_pos(&event);
1348
1349         /* Sink's accept port connection */
1350         event.type = COMP_ACCEPT_PORT_CONNECTION;
1351         event.data.comp_accept_port_connection.comp = sink;
1352         event.data.comp_accept_port_connection.self_port = sink_def_port;
1353         event.data.comp_accept_port_connection.other_port = src_def_port;
1354         ok(has_event(&event), "got the expected sink's accept port connection event");
1355         sink_accept_port_connection_pos = event_pos(&event);
1356
1357         /* Source's port connected */
1358         event.type = COMP_PORT_CONNECTED;
1359         event.data.comp_port_connected.comp = src;
1360         event.data.comp_port_connected.self_port = src_def_port;
1361         event.data.comp_port_connected.other_port = sink_def_port;
1362         ok(has_event(&event), "got the expected source's port connected event");
1363         src_port_connected_pos = event_pos(&event);
1364
1365         /* Sink's port connected */
1366         event.type = COMP_PORT_CONNECTED;
1367         event.data.comp_port_connected.comp = sink;
1368         event.data.comp_port_connected.self_port = sink_def_port;
1369         event.data.comp_port_connected.other_port = src_def_port;
1370         ok(has_event(&event), "got the expected sink's port connected event");
1371         sink_port_connected_pos = event_pos(&event);
1372
1373         /* Source's port disconnected */
1374         event.type = COMP_PORT_DISCONNECTED;
1375         event.data.comp_port_disconnected.comp = src;
1376         event.data.comp_port_disconnected.port = src_def_port;
1377         ok(has_event(&event), "got the expected source's port disconnected event");
1378         src_port_disconnected_pos = event_pos(&event);
1379
1380         /* Order of events */
1381         ok(src_accept_port_connection_pos < src_port_connected_pos,
1382                 "event order is good (1)");
1383         ok(sink_accept_port_connection_pos < sink_port_connected_pos,
1384                 "event order is good (2)");
1385         ok(sink_port_connected_pos < src_port_disconnected_pos,
1386                 "event order is good (3)");
1387
1388         bt_object_put_ref(graph);
1389         bt_object_put_ref(sink);
1390         bt_object_put_ref(src);
1391         bt_object_put_ref(conn);
1392         bt_object_put_ref(src_def_port);
1393         bt_object_put_ref(sink_def_port);
1394 }
1395
1396 static
1397 void test_empty_graph(void)
1398 {
1399         struct bt_private_graph *graph;
1400
1401         prepare_test(TEST_EMPTY_GRAPH, "empty graph");
1402         graph = create_graph();
1403         ok(events->len == 0, "empty graph generates no events");
1404         bt_object_put_ref(graph);
1405 }
1406
1407 int main(int argc, char **argv)
1408 {
1409         plan_tests(NR_TESTS);
1410         init_test();
1411         test_empty_graph();
1412         test_simple();
1413         test_src_port_connected_error();
1414         test_sink_port_connected_error();
1415         test_src_adds_port_in_port_connected();
1416         test_sink_removes_port_in_port_connected();
1417         test_sink_removes_port_in_port_connected_then_src_removes_disconnected_port();
1418         fini_test();
1419         return exit_status();
1420 }