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