tests/plugins/test-utils-muxer.c

   1 /*
   2  * Copyright 2017 - Philippe Proulx <pproulx@efficios.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; under version 2 of the License.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  16  */
  17
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <stdint.h>
  21 #include <stdbool.h>
  22 #include <inttypes.h>
  23 #include <string.h>
  24 #include <assert.h>
  25 #include <babeltrace/ctf-ir/event-class.h>
  26 #include <babeltrace/ctf-ir/event.h>
  27 #include <babeltrace/ctf-ir/field-types.h>
  28 #include <babeltrace/ctf-ir/fields.h>
  29 #include <babeltrace/ctf-ir/packet.h>
  30 #include <babeltrace/ctf-ir/stream-class.h>
  31 #include <babeltrace/ctf-ir/stream.h>
  32 #include <babeltrace/ctf-ir/trace.h>
  33 #include <babeltrace/graph/clock-class-priority-map.h>
  34 #include <babeltrace/graph/component-class-filter.h>
  35 #include <babeltrace/graph/component-class-sink.h>
  36 #include <babeltrace/graph/component-class-source.h>
  37 #include <babeltrace/graph/component-class.h>
  38 #include <babeltrace/graph/component-filter.h>
  39 #include <babeltrace/graph/component-sink.h>
  40 #include <babeltrace/graph/component-source.h>
  41 #include <babeltrace/graph/component.h>
  42 #include <babeltrace/graph/graph.h>
  43 #include <babeltrace/graph/notification-event.h>
  44 #include <babeltrace/graph/notification-inactivity.h>
  45 #include <babeltrace/graph/notification-iterator.h>
  46 #include <babeltrace/graph/notification-packet.h>
  47 #include <babeltrace/graph/port.h>
  48 #include <babeltrace/graph/private-component-source.h>
  49 #include <babeltrace/graph/private-component-sink.h>
  50 #include <babeltrace/graph/private-component.h>
  51 #include <babeltrace/graph/private-connection.h>
  52 #include <babeltrace/graph/private-notification-iterator.h>
  53 #include <babeltrace/graph/private-port.h>
  54 #include <babeltrace/plugin/plugin.h>
  55 #include <babeltrace/ref.h>
  56 #include <glib.h>
  57
  58 #include "tap/tap.h"
  59
  60 #define NR_TESTS        12
  61
  62 enum test {
  63         TEST_NO_TS,
  64         TEST_NO_UPSTREAM_CONNECTION,
  65         TEST_SIMPLE_4_PORTS,
  66         TEST_4_PORTS_WITH_RETRIES,
  67         TEST_SINGLE_END_THEN_MULTIPLE_FULL,
  68         TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL,
  69 };
  70
  71 enum test_event_type {
  72         TEST_EV_TYPE_NOTIF_UNEXPECTED,
  73         TEST_EV_TYPE_NOTIF_EVENT,
  74         TEST_EV_TYPE_NOTIF_INACTIVITY,
  75         TEST_EV_TYPE_NOTIF_PACKET_BEGIN,
  76         TEST_EV_TYPE_NOTIF_PACKET_END,
  77         TEST_EV_TYPE_NOTIF_STREAM_BEGIN,
  78         TEST_EV_TYPE_NOTIF_STREAM_END,
  79         TEST_EV_TYPE_AGAIN,
  80         TEST_EV_TYPE_END,
  81         TEST_EV_TYPE_SENTINEL,
  82 };
  83
  84 struct test_event {
  85         enum test_event_type type;
  86         int64_t ts_ns;
  87 };
  88
  89 struct source_muxer_sink {
  90         struct bt_component *source;
  91         struct bt_component *muxer;
  92         struct bt_component *sink;
  93 };
  94
  95 struct graph_listener_data {
  96         struct bt_graph *graph;
  97         struct bt_component *source;
  98         struct bt_component *muxer;
  99         struct bt_component *sink;
 100 };
 101
 102 static bool debug = false;
 103 static enum test current_test;
 104 static GArray *test_events;
 105 static struct bt_clock_class_priority_map *src_cc_prio_map;
 106 static struct bt_clock_class_priority_map *src_empty_cc_prio_map;
 107 static struct bt_ctf_clock_class *src_clock_class;
 108 static struct bt_ctf_stream_class *src_stream_class;
 109 static struct bt_ctf_event_class *src_event_class;
 110 static struct bt_ctf_packet *src_packet0;
 111 static struct bt_ctf_packet *src_packet1;
 112 static struct bt_ctf_packet *src_packet2;
 113 static struct bt_ctf_packet *src_packet3;
 114
 115 enum {
 116         SEQ_END = -1,
 117         SEQ_AGAIN = -2,
 118         SEQ_PACKET_BEGIN = -3,
 119         SEQ_PACKET_END = -4,
 120 };
 121
 122 struct src_iter_user_data {
 123         size_t iter_index;
 124         int64_t *seq;
 125         size_t at;
 126         struct bt_ctf_packet *packet;
 127 };
 128
 129 struct sink_user_data {
 130         struct bt_notification_iterator *notif_iter;
 131 };
 132
 133 static int64_t seq1[] = {
 134         24, 53, 97, 105, 119, 210, 222, 240, 292, 317, 353, 407, 433,
 135         473, 487, 504, 572, 615, 708, 766, 850, 852, 931, 951, 956, 996,
 136         SEQ_END,
 137 };
 138
 139 static int64_t seq2[] = {
 140         51, 59, 68, 77, 91, 121, 139, 170, 179, 266, 352, 454, 478, 631,
 141         644, 668, 714, 744, 750, 778, 790, 836, SEQ_END,
 142 };
 143
 144 static int64_t seq3[] = {
 145         8, 71, 209, 254, 298, 320, 350, 393, 419, 624, 651, 678, 717,
 146         731, 733, 788, 819, 820, 857, 892, 903, 944, 998, SEQ_END,
 147 };
 148
 149 static int64_t seq4[] = {
 150         41, 56, 120, 138, 154, 228, 471, 479, 481, 525, 591, 605, 612,
 151         618, 632, 670, 696, 825, 863, 867, 871, 884, 953, 985, 999,
 152         SEQ_END,
 153 };
 154
 155 static int64_t seq1_with_again[] = {
 156         24, 53, 97, 105, 119, 210, SEQ_AGAIN, 222, 240, 292, 317, 353,
 157         407, 433, 473, 487, 504, 572, 615, 708, 766, 850, 852, 931, 951,
 158         956, 996, SEQ_END,
 159 };
 160
 161 static int64_t seq2_with_again[] = {
 162         51, 59, 68, 77, 91, 121, 139, 170, 179, 266, 352, 454, 478, 631,
 163         644, 668, 714, 744, 750, 778, 790, 836, SEQ_AGAIN, SEQ_END,
 164 };
 165
 166 static int64_t seq3_with_again[] = {
 167         8, 71, 209, 254, 298, 320, 350, 393, 419, 624, 651, SEQ_AGAIN,
 168         678, 717, 731, 733, 788, 819, 820, 857, 892, 903, 944, 998,
 169         SEQ_END,
 170 };
 171
 172 static int64_t seq4_with_again[] = {
 173         SEQ_AGAIN, 41, 56, 120, 138, 154, 228, 471, 479, 481, 525, 591,
 174         605, 612, 618, 632, 670, 696, 825, 863, 867, 871, 884, 953, 985,
 175         999, SEQ_END,
 176 };
 177
 178 static int64_t seq5[] = {
 179         1, 4, 189, 1001, SEQ_END,
 180 };
 181
 182 static
 183 void clear_test_events(void)
 184 {
 185         g_array_set_size(test_events, 0);
 186 }
 187
 188 static
 189 void print_test_event(FILE *fp, const struct test_event *event)
 190 {
 191         fprintf(fp, "{ type = ");
 192
 193         switch (event->type) {
 194         case TEST_EV_TYPE_NOTIF_UNEXPECTED:
 195                 fprintf(fp, "TEST_EV_TYPE_NOTIF_UNEXPECTED");
 196                 break;
 197         case TEST_EV_TYPE_NOTIF_EVENT:
 198                 fprintf(fp, "TEST_EV_TYPE_NOTIF_EVENT");
 199                 break;
 200         case TEST_EV_TYPE_NOTIF_INACTIVITY:
 201                 fprintf(fp, "TEST_EV_TYPE_NOTIF_INACTIVITY");
 202                 break;
 203         case TEST_EV_TYPE_NOTIF_PACKET_BEGIN:
 204                 fprintf(fp, "TEST_EV_TYPE_NOTIF_PACKET_BEGIN");
 205                 break;
 206         case TEST_EV_TYPE_NOTIF_PACKET_END:
 207                 fprintf(fp, "TEST_EV_TYPE_NOTIF_PACKET_END");
 208                 break;
 209         case TEST_EV_TYPE_NOTIF_STREAM_BEGIN:
 210                 fprintf(fp, "TEST_EV_TYPE_NOTIF_STREAM_BEGIN");
 211                 break;
 212         case TEST_EV_TYPE_NOTIF_STREAM_END:
 213                 fprintf(fp, "TEST_EV_TYPE_NOTIF_STREAM_END");
 214                 break;
 215         case TEST_EV_TYPE_AGAIN:
 216                 fprintf(fp, "TEST_EV_TYPE_AGAIN");
 217                 break;
 218         case TEST_EV_TYPE_END:
 219                 fprintf(fp, "TEST_EV_TYPE_END");
 220                 break;
 221         case TEST_EV_TYPE_SENTINEL:
 222                 fprintf(fp, "TEST_EV_TYPE_SENTINEL");
 223                 break;
 224         default:
 225                 fprintf(fp, "(UNKNOWN)");
 226                 break;
 227         }
 228
 229         switch (event->type) {
 230         case TEST_EV_TYPE_NOTIF_EVENT:
 231         case TEST_EV_TYPE_NOTIF_INACTIVITY:
 232                 fprintf(fp, ", ts-ns = %" PRId64, event->ts_ns);
 233         default:
 234                 break;
 235         }
 236
 237         fprintf(fp, " }");
 238 }
 239
 240 static
 241 void append_test_event(struct test_event *event)
 242 {
 243         g_array_append_val(test_events, *event);
 244 }
 245
 246 static
 247 bool compare_single_test_events(const struct test_event *ev_a,
 248                 const struct test_event *ev_b)
 249 {
 250         if (debug) {
 251                 fprintf(stderr, ":: Comparing test events: ");
 252                 print_test_event(stderr, ev_a);
 253                 fprintf(stderr, " vs. ");
 254                 print_test_event(stderr, ev_b);
 255                 fprintf(stderr, "\n");
 256         }
 257
 258         if (ev_a->type != ev_b->type) {
 259                 return false;
 260         }
 261
 262         switch (ev_a->type) {
 263                 case TEST_EV_TYPE_NOTIF_EVENT:
 264                 case TEST_EV_TYPE_NOTIF_INACTIVITY:
 265                         if (ev_a->ts_ns != ev_b->ts_ns) {
 266                                 return false;
 267                         }
 268                         break;
 269                 default:
 270                         break;
 271         }
 272
 273         return true;
 274 }
 275
 276 static
 277 bool compare_test_events(const struct test_event *expected_events)
 278 {
 279         const struct test_event *expected_event = expected_events;
 280         size_t i = 0;
 281
 282         assert(expected_events);
 283
 284         while (true) {
 285                 const struct test_event *event;
 286
 287                 if (expected_event->type == TEST_EV_TYPE_SENTINEL) {
 288                         break;
 289                 }
 290
 291                 if (i >= test_events->len) {
 292                         return false;
 293                 }
 294
 295                 event = &g_array_index(test_events, struct test_event, i);
 296
 297                 if (!compare_single_test_events(event, expected_event)) {
 298                         return false;
 299                 }
 300
 301                 i++;
 302                 expected_event++;
 303         }
 304
 305         if (i != test_events->len) {
 306                 if (debug) {
 307                         fprintf(stderr, ":: Length mismatch\n");
 308                 }
 309
 310                 return false;
 311         }
 312
 313         return true;
 314 }
 315
 316 static
 317 void init_static_data(void)
 318 {
 319         int ret;
 320         struct bt_ctf_trace *trace;
 321         struct bt_ctf_stream *stream;
 322         struct bt_ctf_field_type *empty_struct_ft;
 323
 324         /* Test events */
 325         test_events = g_array_new(FALSE, TRUE, sizeof(struct test_event));
 326         assert(test_events);
 327
 328         /* Metadata */
 329         empty_struct_ft = bt_ctf_field_type_structure_create();
 330         assert(empty_struct_ft);
 331         trace = bt_ctf_trace_create();
 332         assert(trace);
 333         ret = bt_ctf_trace_set_native_byte_order(trace,
 334                 BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
 335         assert(ret == 0);
 336         ret = bt_ctf_trace_set_packet_header_type(trace, empty_struct_ft);
 337         assert(ret == 0);
 338         src_clock_class = bt_ctf_clock_class_create("my-clock");
 339         assert(src_clock_class);
 340         ret = bt_ctf_clock_class_set_is_absolute(src_clock_class, 1);
 341         assert(ret == 0);
 342         ret = bt_ctf_trace_add_clock_class(trace, src_clock_class);
 343         assert(ret == 0);
 344         src_empty_cc_prio_map = bt_clock_class_priority_map_create();
 345         assert(src_empty_cc_prio_map);
 346         src_cc_prio_map = bt_clock_class_priority_map_create();
 347         assert(src_cc_prio_map);
 348         ret = bt_clock_class_priority_map_add_clock_class(src_cc_prio_map,
 349                 src_clock_class, 0);
 350         assert(ret == 0);
 351         src_stream_class = bt_ctf_stream_class_create("my-stream-class");
 352         assert(src_stream_class);
 353         ret = bt_ctf_stream_class_set_packet_context_type(src_stream_class,
 354                 empty_struct_ft);
 355         assert(ret == 0);
 356         ret = bt_ctf_stream_class_set_event_header_type(src_stream_class,
 357                 empty_struct_ft);
 358         assert(ret == 0);
 359         ret = bt_ctf_stream_class_set_event_context_type(src_stream_class,
 360                 empty_struct_ft);
 361         assert(ret == 0);
 362         src_event_class = bt_ctf_event_class_create("my-event-class");
 363         ret = bt_ctf_event_class_set_context_type(src_event_class,
 364                 empty_struct_ft);
 365         assert(ret == 0);
 366         ret = bt_ctf_event_class_set_context_type(src_event_class,
 367                 empty_struct_ft);
 368         assert(ret == 0);
 369         ret = bt_ctf_stream_class_add_event_class(src_stream_class,
 370                 src_event_class);
 371         assert(ret == 0);
 372         ret = bt_ctf_trace_add_stream_class(trace, src_stream_class);
 373         assert(ret == 0);
 374         stream = bt_ctf_stream_create(src_stream_class, "stream0");
 375         assert(stream);
 376         src_packet0 = bt_ctf_packet_create(stream);
 377         assert(src_packet0);
 378         bt_put(stream);
 379         stream = bt_ctf_stream_create(src_stream_class, "stream1");
 380         assert(stream);
 381         src_packet1 = bt_ctf_packet_create(stream);
 382         assert(src_packet0);
 383         bt_put(stream);
 384         stream = bt_ctf_stream_create(src_stream_class, "stream2");
 385         assert(stream);
 386         src_packet2 = bt_ctf_packet_create(stream);
 387         assert(src_packet0);
 388         bt_put(stream);
 389         stream = bt_ctf_stream_create(src_stream_class, "stream3");
 390         assert(stream);
 391         src_packet3 = bt_ctf_packet_create(stream);
 392         assert(src_packet0);
 393         bt_put(stream);
 394
 395         bt_put(trace);
 396         bt_put(empty_struct_ft);
 397 }
 398
 399 static
 400 void fini_static_data(void)
 401 {
 402         /* Test events */
 403         g_array_free(test_events, TRUE);
 404
 405         /* Metadata */
 406         bt_put(src_empty_cc_prio_map);
 407         bt_put(src_cc_prio_map);
 408         bt_put(src_clock_class);
 409         bt_put(src_stream_class);
 410         bt_put(src_event_class);
 411         bt_put(src_packet0);
 412         bt_put(src_packet1);
 413         bt_put(src_packet2);
 414         bt_put(src_packet3);
 415 }
 416
 417 static
 418 void src_iter_finalize(
 419                 struct bt_private_notification_iterator *private_notification_iterator)
 420 {
 421         struct src_iter_user_data *user_data =
 422                 bt_private_notification_iterator_get_user_data(
 423                         private_notification_iterator);
 424
 425         if (user_data) {
 426                 g_free(user_data);
 427         }
 428 }
 429
 430 static
 431 enum bt_notification_iterator_status src_iter_init(
 432                 struct bt_private_notification_iterator *priv_notif_iter,
 433                 struct bt_private_port *private_port)
 434 {
 435         struct src_iter_user_data *user_data =
 436                 g_new0(struct src_iter_user_data, 1);
 437         struct bt_port *port = bt_port_from_private_port(private_port);
 438         const char *port_name;
 439         int ret;
 440
 441         assert(user_data);
 442         assert(port);
 443         ret = bt_private_notification_iterator_set_user_data(priv_notif_iter,
 444                 user_data);
 445         assert(ret == 0);
 446         port_name = bt_port_get_name(port);
 447         assert(port_name);
 448         user_data->iter_index = port_name[3] - '0';
 449         bt_put(port);
 450
 451         switch (user_data->iter_index) {
 452         case 0:
 453                 user_data->packet = src_packet0;
 454                 break;
 455         case 1:
 456                 user_data->packet = src_packet1;
 457                 break;
 458         case 2:
 459                 user_data->packet = src_packet2;
 460                 break;
 461         case 3:
 462                 user_data->packet = src_packet3;
 463                 break;
 464         default:
 465                 abort();
 466         }
 467
 468         switch (current_test) {
 469         case TEST_NO_TS:
 470                 if (user_data->iter_index == 1) {
 471                         user_data->seq = seq5;
 472                 }
 473                 break;
 474         case TEST_SIMPLE_4_PORTS:
 475                 if (user_data->iter_index == 0) {
 476                         user_data->seq = seq1;
 477                 } else if (user_data->iter_index == 1) {
 478                         user_data->seq = seq2;
 479                 } else if (user_data->iter_index == 2) {
 480                         user_data->seq = seq3;
 481                 } else {
 482                         user_data->seq = seq4;
 483                 }
 484                 break;
 485         case TEST_4_PORTS_WITH_RETRIES:
 486                 if (user_data->iter_index == 0) {
 487                         user_data->seq = seq1_with_again;
 488                 } else if (user_data->iter_index == 1) {
 489                         user_data->seq = seq2_with_again;
 490                 } else if (user_data->iter_index == 2) {
 491                         user_data->seq = seq3_with_again;
 492                 } else {
 493                         user_data->seq = seq4_with_again;
 494                 }
 495                 break;
 496         case TEST_SINGLE_END_THEN_MULTIPLE_FULL:
 497         case TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL:
 498                 if (user_data->iter_index == 0) {
 499                         /* Ignore: this iterator only returns END */
 500                 } else if (user_data->iter_index == 1) {
 501                         user_data->seq = seq2;
 502                 } else {
 503                         user_data->seq = seq3;
 504                 }
 505                 break;
 506         default:
 507                 abort();
 508         }
 509
 510         return BT_NOTIFICATION_ITERATOR_STATUS_OK;
 511 }
 512
 513 static
 514 struct bt_ctf_event *src_create_event(struct bt_ctf_packet *packet,
 515                 int64_t ts_ns)
 516 {
 517         struct bt_ctf_event *event = bt_ctf_event_create(src_event_class);
 518         int ret;
 519
 520         assert(event);
 521         ret = bt_ctf_event_set_packet(event, packet);
 522         assert(ret == 0);
 523
 524         if (ts_ns != -1) {
 525                 struct bt_ctf_clock_value *clock_value;
 526
 527                 clock_value = bt_ctf_clock_value_create(src_clock_class,
 528                         (uint64_t) ts_ns);
 529                 assert(clock_value);
 530                 ret = bt_ctf_event_set_clock_value(event, clock_value);
 531                 assert(ret == 0);
 532                 bt_put(clock_value);
 533         }
 534
 535         return event;
 536 }
 537
 538 static
 539 struct bt_notification_iterator_next_return src_iter_next_seq(
 540                 struct src_iter_user_data *user_data)
 541 {
 542         struct bt_notification_iterator_next_return next_return = {
 543                 .status = BT_NOTIFICATION_ITERATOR_STATUS_OK,
 544         };
 545         int64_t cur_ts_ns;
 546
 547         assert(user_data->seq);
 548         cur_ts_ns = user_data->seq[user_data->at];
 549
 550         switch (cur_ts_ns) {
 551         case SEQ_END:
 552                 next_return.status =
 553                         BT_NOTIFICATION_ITERATOR_STATUS_END;
 554                 break;
 555         case SEQ_AGAIN:
 556                 next_return.status =
 557                         BT_NOTIFICATION_ITERATOR_STATUS_AGAIN;
 558                 break;
 559         case SEQ_PACKET_BEGIN:
 560                 next_return.notification =
 561                         bt_notification_packet_begin_create(user_data->packet);
 562                 assert(next_return.notification);
 563                 break;
 564         case SEQ_PACKET_END:
 565                 next_return.notification =
 566                         bt_notification_packet_end_create(user_data->packet);
 567                 assert(next_return.notification);
 568                 break;
 569         default:
 570         {
 571                 struct bt_ctf_event *event = src_create_event(
 572                         user_data->packet, cur_ts_ns);
 573
 574                 assert(event);
 575                 next_return.notification = bt_notification_event_create(event,
 576                         src_cc_prio_map);
 577                 bt_put(event);
 578                 assert(next_return.notification);
 579                 break;
 580         }
 581         }
 582
 583         if (next_return.status != BT_NOTIFICATION_ITERATOR_STATUS_END) {
 584                 user_data->at++;
 585         }
 586
 587         return next_return;
 588 }
 589
 590 static
 591 struct bt_notification_iterator_next_return src_iter_next(
 592                 struct bt_private_notification_iterator *priv_iterator)
 593 {
 594         struct bt_notification_iterator_next_return next_return = {
 595                 .notification = NULL,
 596                 .status = BT_NOTIFICATION_ITERATOR_STATUS_OK,
 597         };
 598         struct src_iter_user_data *user_data =
 599                 bt_private_notification_iterator_get_user_data(priv_iterator);
 600         struct bt_private_component *private_component =
 601                 bt_private_notification_iterator_get_private_component(priv_iterator);
 602
 603         assert(user_data);
 604         assert(private_component);
 605
 606         switch (current_test) {
 607         case TEST_NO_TS:
 608                 if (user_data->iter_index == 0) {
 609                         if (user_data->at == 0) {
 610                                 next_return.notification =
 611                                         bt_notification_packet_begin_create(
 612                                                 user_data->packet);
 613                                 assert(next_return.notification);
 614                         } else if (user_data->at < 6) {
 615                                 struct bt_ctf_event *event = src_create_event(
 616                                         user_data->packet, -1);
 617
 618                                 assert(event);
 619                                 next_return.notification =
 620                                         bt_notification_event_create(event,
 621                                                 src_empty_cc_prio_map);
 622                                 assert(next_return.notification);
 623                                 bt_put(event);
 624                         } else {
 625                                 next_return.status =
 626                                         BT_NOTIFICATION_ITERATOR_STATUS_END;
 627                         }
 628
 629                         user_data->at++;
 630                 } else {
 631                         next_return = src_iter_next_seq(user_data);
 632                 }
 633                 break;
 634         case TEST_SIMPLE_4_PORTS:
 635         case TEST_4_PORTS_WITH_RETRIES:
 636                 next_return = src_iter_next_seq(user_data);
 637                 break;
 638         case TEST_SINGLE_END_THEN_MULTIPLE_FULL:
 639                 if (user_data->iter_index == 0) {
 640                         struct bt_private_port *priv_port;
 641
 642                         priv_port = bt_private_component_source_add_output_private_port(
 643                                 private_component, "out1", NULL);
 644                         assert(priv_port);
 645                         bt_put(priv_port);
 646                         priv_port = bt_private_component_source_add_output_private_port(
 647                                 private_component, "out2", NULL);
 648                         assert(priv_port);
 649                         bt_put(priv_port);
 650                         next_return.status = BT_NOTIFICATION_ITERATOR_STATUS_END;
 651                 } else {
 652                         next_return = src_iter_next_seq(user_data);
 653                 }
 654                 break;
 655         case TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL:
 656                 if (user_data->iter_index == 0) {
 657                         if (user_data->at == 0) {
 658                                 next_return.status = BT_NOTIFICATION_ITERATOR_STATUS_AGAIN;
 659                                 user_data->at++;
 660                         } else {
 661                                 struct bt_private_port *priv_port;
 662
 663                                 priv_port = bt_private_component_source_add_output_private_port(
 664                                         private_component, "out1", NULL);
 665                                 assert(priv_port);
 666                                 bt_put(priv_port);
 667                                 priv_port = bt_private_component_source_add_output_private_port(
 668                                         private_component, "out2", NULL);
 669                                 assert(priv_port);
 670                                 bt_put(priv_port);
 671                                 next_return.status = BT_NOTIFICATION_ITERATOR_STATUS_END;
 672                         }
 673                 } else {
 674                         next_return = src_iter_next_seq(user_data);
 675                 }
 676                 break;
 677         default:
 678                 abort();
 679         }
 680
 681         bt_put(private_component);
 682         return next_return;
 683 }
 684
 685 static
 686 enum bt_component_status src_init(
 687                 struct bt_private_component *private_component,
 688                 struct bt_value *params, void *init_method_data)
 689 {
 690         struct bt_private_port *priv_port;
 691         size_t nb_ports;
 692
 693         switch (current_test) {
 694         case TEST_NO_TS:
 695                 nb_ports = 2;
 696                 break;
 697         case TEST_SINGLE_END_THEN_MULTIPLE_FULL:
 698         case TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL:
 699                 nb_ports = 1;
 700                 break;
 701         default:
 702                 nb_ports = 4;
 703                 break;
 704         }
 705
 706         if (nb_ports >= 1) {
 707                 priv_port = bt_private_component_source_add_output_private_port(
 708                         private_component, "out0", NULL);
 709                 assert(priv_port);
 710                 bt_put(priv_port);
 711         }
 712
 713         if (nb_ports >= 2) {
 714                 priv_port = bt_private_component_source_add_output_private_port(
 715                         private_component, "out1", NULL);
 716                 assert(priv_port);
 717                 bt_put(priv_port);
 718         }
 719
 720         if (nb_ports >= 3) {
 721                 priv_port = bt_private_component_source_add_output_private_port(
 722                         private_component, "out2", NULL);
 723                 assert(priv_port);
 724                 bt_put(priv_port);
 725         }
 726
 727         if (nb_ports >= 4) {
 728                 priv_port = bt_private_component_source_add_output_private_port(
 729                         private_component, "out3", NULL);
 730                 assert(priv_port);
 731                 bt_put(priv_port);
 732         }
 733
 734         return BT_COMPONENT_STATUS_OK;
 735 }
 736
 737 static
 738 void src_finalize(struct bt_private_component *private_component)
 739 {
 740 }
 741
 742 static
 743 enum bt_component_status sink_consume(
 744                 struct bt_private_component *priv_component)
 745 {
 746         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 747         struct bt_notification *notification = NULL;
 748         struct sink_user_data *user_data =
 749                 bt_private_component_get_user_data(priv_component);
 750         enum bt_notification_iterator_status it_ret;
 751         struct test_event test_event;
 752         bool do_append_test_event = true;
 753
 754         assert(user_data && user_data->notif_iter);
 755         it_ret = bt_notification_iterator_next(user_data->notif_iter);
 756
 757         if (it_ret < 0) {
 758                 ret = BT_COMPONENT_STATUS_ERROR;
 759                 do_append_test_event = false;
 760                 goto end;
 761         }
 762
 763         switch (it_ret) {
 764         case BT_NOTIFICATION_ITERATOR_STATUS_END:
 765                 test_event.type = TEST_EV_TYPE_END;
 766                 ret = BT_COMPONENT_STATUS_END;
 767                 BT_PUT(user_data->notif_iter);
 768                 goto end;
 769         case BT_NOTIFICATION_ITERATOR_STATUS_AGAIN:
 770                 test_event.type = TEST_EV_TYPE_AGAIN;
 771                 ret = BT_COMPONENT_STATUS_AGAIN;
 772                 goto end;
 773         default:
 774                 break;
 775         }
 776
 777         notification = bt_notification_iterator_get_notification(
 778                 user_data->notif_iter);
 779         assert(notification);
 780
 781         switch (bt_notification_get_type(notification)) {
 782         case BT_NOTIFICATION_TYPE_EVENT:
 783         {
 784                 struct bt_ctf_event *event;
 785                 struct bt_clock_class_priority_map *cc_prio_map;
 786
 787                 test_event.type = TEST_EV_TYPE_NOTIF_EVENT;
 788                 cc_prio_map =
 789                         bt_notification_event_get_clock_class_priority_map(
 790                                 notification);
 791                 assert(cc_prio_map);
 792                 event = bt_notification_event_get_event(notification);
 793                 assert(event);
 794
 795                 if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map) > 0) {
 796                         struct bt_ctf_clock_value *clock_value;
 797                         struct bt_ctf_clock_class *clock_class =
 798                                 bt_clock_class_priority_map_get_highest_priority_clock_class(
 799                                         cc_prio_map);
 800
 801                         assert(clock_class);
 802                         clock_value = bt_ctf_event_get_clock_value(event,
 803                                 clock_class);
 804                         assert(clock_value);
 805                         ret = bt_ctf_clock_value_get_value_ns_from_epoch(
 806                                         clock_value, &test_event.ts_ns);
 807                         assert(ret == 0);
 808                         bt_put(clock_value);
 809                         bt_put(clock_class);
 810                 } else {
 811                         test_event.ts_ns = -1;
 812                 }
 813
 814                 bt_put(cc_prio_map);
 815                 bt_put(event);
 816                 break;
 817         }
 818         case BT_NOTIFICATION_TYPE_INACTIVITY:
 819         {
 820                 struct bt_clock_class_priority_map *cc_prio_map;
 821
 822                 test_event.type = TEST_EV_TYPE_NOTIF_INACTIVITY;
 823                 cc_prio_map = bt_notification_event_get_clock_class_priority_map(
 824                         notification);
 825                 assert(cc_prio_map);
 826
 827                 if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map) > 0) {
 828                         struct bt_ctf_clock_value *clock_value;
 829                         struct bt_ctf_clock_class *clock_class =
 830                                 bt_clock_class_priority_map_get_highest_priority_clock_class(
 831                                         cc_prio_map);
 832
 833                         assert(clock_class);
 834                         clock_value =
 835                                 bt_notification_inactivity_get_clock_value(
 836                                         notification, clock_class);
 837                         assert(clock_value);
 838                         ret = bt_ctf_clock_value_get_value_ns_from_epoch(
 839                                         clock_value, &test_event.ts_ns);
 840                         assert(ret == 0);
 841                         bt_put(clock_value);
 842                         bt_put(clock_class);
 843                 } else {
 844                         test_event.ts_ns = -1;
 845                 }
 846
 847                 bt_put(cc_prio_map);
 848                 break;
 849         }
 850         case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
 851                 test_event.type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN;
 852                 break;
 853         case BT_NOTIFICATION_TYPE_PACKET_END:
 854                 test_event.type = TEST_EV_TYPE_NOTIF_PACKET_END;
 855                 break;
 856         case BT_NOTIFICATION_TYPE_STREAM_BEGIN:
 857                 test_event.type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN;
 858                 break;
 859         case BT_NOTIFICATION_TYPE_STREAM_END:
 860                 test_event.type = TEST_EV_TYPE_NOTIF_STREAM_END;
 861                 break;
 862         default:
 863                 test_event.type = TEST_EV_TYPE_NOTIF_UNEXPECTED;
 864                 break;
 865         }
 866
 867 end:
 868         if (do_append_test_event) {
 869                 append_test_event(&test_event);
 870         }
 871
 872         bt_put(notification);
 873         return ret;
 874 }
 875
 876 static
 877 void sink_port_connected(struct bt_private_component *private_component,
 878                 struct bt_private_port *self_private_port,
 879                 struct bt_port *other_port)
 880 {
 881         struct bt_private_connection *priv_conn =
 882                 bt_private_port_get_private_connection(self_private_port);
 883         struct sink_user_data *user_data = bt_private_component_get_user_data(
 884                 private_component);
 885
 886         assert(user_data);
 887         assert(priv_conn);
 888         user_data->notif_iter =
 889                 bt_private_connection_create_notification_iterator(priv_conn,
 890                         NULL);
 891         assert(user_data->notif_iter);
 892         bt_put(priv_conn);
 893 }
 894
 895 static
 896 enum bt_component_status sink_init(
 897                 struct bt_private_component *private_component,
 898                 struct bt_value *params, void *init_method_data)
 899 {
 900         struct sink_user_data *user_data = g_new0(struct sink_user_data, 1);
 901         int ret;
 902         void *priv_port;
 903
 904         assert(user_data);
 905         ret = bt_private_component_set_user_data(private_component,
 906                 user_data);
 907         assert(ret == 0);
 908         priv_port = bt_private_component_sink_add_input_private_port(
 909                 private_component, "in", NULL);
 910         assert(priv_port);
 911         bt_put(priv_port);
 912         return BT_COMPONENT_STATUS_OK;
 913 }
 914
 915 static
 916 void sink_finalize(struct bt_private_component *private_component)
 917 {
 918         struct sink_user_data *user_data = bt_private_component_get_user_data(
 919                 private_component);
 920
 921         if (user_data) {
 922                 bt_put(user_data->notif_iter);
 923                 g_free(user_data);
 924         }
 925 }
 926
 927 static
 928 void create_source_muxer_sink(struct bt_component **source,
 929                 struct bt_component **muxer,
 930                 struct bt_component **sink)
 931 {
 932         struct bt_component_class *src_comp_class;
 933         struct bt_component_class *muxer_comp_class;
 934         struct bt_component_class *sink_comp_class;
 935         int ret;
 936
 937         /* Create source component */
 938         src_comp_class = bt_component_class_source_create("src", src_iter_next);
 939         assert(src_comp_class);
 940         ret = bt_component_class_set_init_method(src_comp_class, src_init);
 941         assert(ret == 0);
 942         ret = bt_component_class_set_finalize_method(src_comp_class,
 943                 src_finalize);
 944         assert(ret == 0);
 945         ret = bt_component_class_source_set_notification_iterator_init_method(
 946                 src_comp_class, src_iter_init);
 947         assert(ret == 0);
 948         ret = bt_component_class_source_set_notification_iterator_finalize_method(
 949                 src_comp_class, src_iter_finalize);
 950         assert(ret == 0);
 951         *source = bt_component_create(src_comp_class, "source", NULL);
 952         assert(*source);
 953
 954         /* Create muxer component */
 955         muxer_comp_class = bt_plugin_find_component_class("utils", "muxer",
 956                 BT_COMPONENT_CLASS_TYPE_FILTER);
 957         assert(muxer_comp_class);
 958         *muxer = bt_component_create(muxer_comp_class, "muxer", NULL);
 959         assert(*muxer);
 960
 961         /* Create sink component */
 962         sink_comp_class = bt_component_class_sink_create("sink", sink_consume);
 963         assert(sink_comp_class);
 964         ret = bt_component_class_set_init_method(sink_comp_class, sink_init);
 965         assert(ret == 0);
 966         ret = bt_component_class_set_finalize_method(sink_comp_class,
 967                 sink_finalize);
 968         ret = bt_component_class_set_port_connected_method(sink_comp_class,
 969                 sink_port_connected);
 970         assert(ret == 0);
 971         *sink = bt_component_create(sink_comp_class, "sink", NULL);
 972
 973         bt_put(src_comp_class);
 974         bt_put(muxer_comp_class);
 975         bt_put(sink_comp_class);
 976 }
 977
 978 static
 979 void do_std_test(enum test test, const char *name,
 980                 const struct test_event *expected_test_events,
 981                 bool with_upstream)
 982 {
 983         struct bt_component *src_comp;
 984         struct bt_component *muxer_comp;
 985         struct bt_component *sink_comp;
 986         struct bt_port *upstream_port;
 987         struct bt_port *downstream_port;
 988         struct bt_graph *graph;
 989         int64_t i;
 990         int64_t count;
 991         enum bt_graph_status graph_status = BT_GRAPH_STATUS_OK;
 992
 993         clear_test_events();
 994         current_test = test;
 995         diag("test: %s", name);
 996         create_source_muxer_sink(&src_comp, &muxer_comp, &sink_comp);
 997         graph = bt_graph_create();
 998         assert(graph);
 999
1000         /* Connect source output ports to muxer input ports */
1001         if (with_upstream) {
1002                 count = bt_component_source_get_output_port_count(src_comp);
1003                 assert(count >= 0);
1004
1005                 for (i = 0; i < count; i++) {
1006                         upstream_port = bt_component_source_get_output_port_by_index(
1007                                 src_comp, i);
1008                         assert(upstream_port);
1009                         downstream_port = bt_component_filter_get_input_port_by_index(
1010                                 muxer_comp, i);
1011                         assert(downstream_port);
1012                         graph_status = bt_graph_connect_ports(graph,
1013                                 upstream_port, downstream_port, NULL);
1014                         assert(graph_status == 0);
1015                         bt_put(upstream_port);
1016                         bt_put(downstream_port);
1017                 }
1018         }
1019
1020         /* Connect muxer output port to sink input port */
1021         upstream_port = bt_component_filter_get_output_port_by_name(muxer_comp,
1022                 "out");
1023         assert(upstream_port);
1024         downstream_port = bt_component_sink_get_input_port_by_name(sink_comp, "in");
1025         assert(downstream_port);
1026         graph_status = bt_graph_connect_ports(graph, upstream_port,
1027                 downstream_port, NULL);
1028         assert(graph_status == 0);
1029         bt_put(upstream_port);
1030         bt_put(downstream_port);
1031
1032         while (graph_status == BT_GRAPH_STATUS_OK ||
1033                         graph_status == BT_GRAPH_STATUS_AGAIN) {
1034                 graph_status = bt_graph_run(graph);
1035         }
1036
1037         ok(graph_status == BT_GRAPH_STATUS_END, "graph finishes without any error");
1038         ok(compare_test_events(expected_test_events),
1039                 "the produced sequence of test events is the expected one");
1040
1041         bt_put(src_comp);
1042         bt_put(muxer_comp);
1043         bt_put(sink_comp);
1044         bt_put(graph);
1045 }
1046
1047 static
1048 void test_no_ts(void)
1049 {
1050         const struct test_event expected_test_events[] = {
1051                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, },
1052                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, },
1053                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, },
1054                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, },
1055                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = -1, },
1056                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = -1, },
1057                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = -1, },
1058                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = -1, },
1059                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = -1, },
1060                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, },
1061                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, },
1062                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 1, },
1063                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 4, },
1064                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 189, },
1065                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 1001, },
1066                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, },
1067                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, },
1068                 { .type = TEST_EV_TYPE_END, },
1069                 { .type = TEST_EV_TYPE_SENTINEL, },
1070         };
1071
1072         do_std_test(TEST_NO_TS, "event notifications with no time",
1073                 expected_test_events, true);
1074 }
1075
1076 static
1077 void test_no_upstream_connection(void)
1078 {
1079         const struct test_event expected_test_events[] = {
1080                 { .type = TEST_EV_TYPE_END, },
1081                 { .type = TEST_EV_TYPE_SENTINEL, },
1082         };
1083
1084         do_std_test(TEST_NO_UPSTREAM_CONNECTION, "no upstream connection",
1085                 expected_test_events, false);
1086 }
1087
1088 static
1089 void test_simple_4_ports(void)
1090 {
1091         const struct test_event expected_test_events[] = {
1092                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, },
1093                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, },
1094                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, },
1095                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, },
1096                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, },
1097                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, },
1098                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, },
1099                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, },
1100                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 8 },
1101                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 24 },
1102                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 41 },
1103                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 51 },
1104                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 53 },
1105                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 56 },
1106                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 59 },
1107                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 68 },
1108                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 71 },
1109                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 77 },
1110                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 91 },
1111                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 97 },
1112                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 105 },
1113                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 119 },
1114                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 120 },
1115                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 121 },
1116                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 138 },
1117                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 139 },
1118                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 154 },
1119                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 170 },
1120                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 179 },
1121                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 209 },
1122                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 210 },
1123                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 222 },
1124                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 228 },
1125                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 240 },
1126                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 254 },
1127                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 266 },
1128                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 292 },
1129                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 298 },
1130                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 317 },
1131                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 320 },
1132                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 350 },
1133                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 352 },
1134                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 353 },
1135                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 393 },
1136                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 407 },
1137                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 419 },
1138                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 433 },
1139                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 454 },
1140                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 471 },
1141                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 473 },
1142                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 478 },
1143                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 479 },
1144                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 481 },
1145                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 487 },
1146                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 504 },
1147                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 525 },
1148                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 572 },
1149                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 591 },
1150                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 605 },
1151                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 612 },
1152                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 615 },
1153                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 618 },
1154                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 624 },
1155                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 631 },
1156                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 632 },
1157                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 644 },
1158                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 651 },
1159                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 668 },
1160                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 670 },
1161                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 678 },
1162                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 696 },
1163                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 708 },
1164                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 714 },
1165                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 717 },
1166                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 731 },
1167                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 733 },
1168                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 744 },
1169                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 750 },
1170                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 766 },
1171                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 778 },
1172                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 788 },
1173                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 790 },
1174                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 819 },
1175                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 820 },
1176                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 825 },
1177                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 836 },
1178                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, },
1179                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, },
1180                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 850 },
1181                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 852 },
1182                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 857 },
1183                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 863 },
1184                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 867 },
1185                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 871 },
1186                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 884 },
1187                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 892 },
1188                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 903 },
1189                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 931 },
1190                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 944 },
1191                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 951 },
1192                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 953 },
1193                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 956 },
1194                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 985 },
1195                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 996 },
1196                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, },
1197                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, },
1198                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 998 },
1199                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, },
1200                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, },
1201                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 999 },
1202                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, },
1203                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, },
1204                 { .type = TEST_EV_TYPE_END, },
1205                 { .type = TEST_EV_TYPE_SENTINEL, },
1206         };
1207
1208         do_std_test(TEST_SIMPLE_4_PORTS, "simple: 4 ports without retries",
1209                 expected_test_events, true);
1210 }
1211
1212 static
1213 void test_4_ports_with_retries(void)
1214 {
1215         const struct test_event expected_test_events[] = {
1216                 { .type = TEST_EV_TYPE_AGAIN, },
1217                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, },
1218                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, },
1219                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, },
1220                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, },
1221                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, },
1222                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, },
1223                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, },
1224                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, },
1225                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 8 },
1226                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 24 },
1227                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 41 },
1228                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 51 },
1229                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 53 },
1230                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 56 },
1231                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 59 },
1232                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 68 },
1233                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 71 },
1234                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 77 },
1235                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 91 },
1236                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 97 },
1237                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 105 },
1238                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 119 },
1239                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 120 },
1240                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 121 },
1241                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 138 },
1242                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 139 },
1243                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 154 },
1244                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 170 },
1245                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 179 },
1246                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 209 },
1247                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 210 },
1248                 { .type = TEST_EV_TYPE_AGAIN, },
1249                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 222 },
1250                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 228 },
1251                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 240 },
1252                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 254 },
1253                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 266 },
1254                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 292 },
1255                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 298 },
1256                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 317 },
1257                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 320 },
1258                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 350 },
1259                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 352 },
1260                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 353 },
1261                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 393 },
1262                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 407 },
1263                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 419 },
1264                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 433 },
1265                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 454 },
1266                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 471 },
1267                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 473 },
1268                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 478 },
1269                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 479 },
1270                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 481 },
1271                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 487 },
1272                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 504 },
1273                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 525 },
1274                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 572 },
1275                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 591 },
1276                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 605 },
1277                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 612 },
1278                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 615 },
1279                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 618 },
1280                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 624 },
1281                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 631 },
1282                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 632 },
1283                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 644 },
1284                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 651 },
1285                 { .type = TEST_EV_TYPE_AGAIN, },
1286                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 668 },
1287                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 670 },
1288                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 678 },
1289                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 696 },
1290                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 708 },
1291                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 714 },
1292                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 717 },
1293                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 731 },
1294                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 733 },
1295                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 744 },
1296                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 750 },
1297                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 766 },
1298                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 778 },
1299                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 788 },
1300                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 790 },
1301                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 819 },
1302                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 820 },
1303                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 825 },
1304                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 836 },
1305                 { .type = TEST_EV_TYPE_AGAIN, },
1306                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, },
1307                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, },
1308                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 850 },
1309                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 852 },
1310                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 857 },
1311                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 863 },
1312                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 867 },
1313                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 871 },
1314                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 884 },
1315                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 892 },
1316                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 903 },
1317                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 931 },
1318                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 944 },
1319                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 951 },
1320                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 953 },
1321                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 956 },
1322                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 985 },
1323                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 996 },
1324                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, },
1325                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, },
1326                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 998 },
1327                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, },
1328                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, },
1329                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 999 },
1330                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, },
1331                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, },
1332                 { .type = TEST_EV_TYPE_END, },
1333                 { .type = TEST_EV_TYPE_SENTINEL, },
1334         };
1335
1336         do_std_test(TEST_4_PORTS_WITH_RETRIES, "4 ports with retries",
1337                 expected_test_events, true);
1338 }
1339
1340 static
1341 void connect_port_to_first_avail_muxer_port(struct bt_graph *graph,
1342                 struct bt_port *source_port,
1343                 struct bt_component *muxer_comp)
1344 {
1345         struct bt_port *avail_muxer_port = NULL;
1346         int64_t i;
1347         int64_t count;
1348         enum bt_graph_status graph_status;
1349
1350         count = bt_component_filter_get_input_port_count(muxer_comp);
1351         assert(count >= 0);
1352
1353         for (i = 0; i < count; i++) {
1354                 struct bt_port *muxer_port =
1355                         bt_component_filter_get_input_port_by_index(
1356                                 muxer_comp, i);
1357
1358                 assert(muxer_port);
1359
1360                 if (!bt_port_is_connected(muxer_port)) {
1361                         BT_MOVE(avail_muxer_port, muxer_port);
1362                         break;
1363                 } else {
1364                         bt_put(muxer_port);
1365                 }
1366         }
1367
1368         graph_status = bt_graph_connect_ports(graph, source_port,
1369                 avail_muxer_port, NULL);
1370         assert(graph_status == 0);
1371         bt_put(avail_muxer_port);
1372 }
1373
1374 static
1375 void graph_port_added_listener_connect_to_avail_muxer_port(struct bt_port *port,
1376                 void *data)
1377 {
1378         struct graph_listener_data *graph_listener_data = data;
1379         struct bt_component *comp;
1380
1381         comp = bt_port_get_component(port);
1382         assert(comp);
1383
1384         if (comp != graph_listener_data->source) {
1385                 goto end;
1386         }
1387
1388         connect_port_to_first_avail_muxer_port(graph_listener_data->graph,
1389                 port, graph_listener_data->muxer);
1390
1391 end:
1392         bt_put(comp);
1393 }
1394
1395 static
1396 void test_single_end_then_multiple_full(void)
1397 {
1398         struct bt_component *src_comp;
1399         struct bt_component *muxer_comp;
1400         struct bt_component *sink_comp;
1401         struct bt_port *upstream_port;
1402         struct bt_port *downstream_port;
1403         struct bt_graph *graph;
1404         int64_t i;
1405         int64_t count;
1406         int ret;
1407         enum bt_graph_status graph_status = BT_GRAPH_STATUS_OK;
1408         struct graph_listener_data graph_listener_data;
1409         const struct test_event expected_test_events[] = {
1410                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, },
1411                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, },
1412                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, },
1413                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, },
1414                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 8 },
1415                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 51 },
1416                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 59 },
1417                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 68 },
1418                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 71 },
1419                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 77 },
1420                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 91 },
1421                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 121 },
1422                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 139 },
1423                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 170 },
1424                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 179 },
1425                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 209 },
1426                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 254 },
1427                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 266 },
1428                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 298 },
1429                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 320 },
1430                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 350 },
1431                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 352 },
1432                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 393 },
1433                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 419 },
1434                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 454 },
1435                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 478 },
1436                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 624 },
1437                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 631 },
1438                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 644 },
1439                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 651 },
1440                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 668 },
1441                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 678 },
1442                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 714 },
1443                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 717 },
1444                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 731 },
1445                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 733 },
1446                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 744 },
1447                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 750 },
1448                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 778 },
1449                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 788 },
1450                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 790 },
1451                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 819 },
1452                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 820 },
1453                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 836 },
1454                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, },
1455                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, },
1456                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 857 },
1457                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 892 },
1458                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 903 },
1459                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 944 },
1460                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 998 },
1461                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, },
1462                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, },
1463                 { .type = TEST_EV_TYPE_END, },
1464                 { .type = TEST_EV_TYPE_SENTINEL, },
1465         };
1466
1467         clear_test_events();
1468         current_test = TEST_SINGLE_END_THEN_MULTIPLE_FULL;
1469         diag("test: single end then multiple full");
1470         create_source_muxer_sink(&src_comp, &muxer_comp, &sink_comp);
1471         graph = bt_graph_create();
1472         assert(graph);
1473         graph_listener_data.graph = graph;
1474         graph_listener_data.source = src_comp;
1475         graph_listener_data.muxer = muxer_comp;
1476         graph_listener_data.sink = sink_comp;
1477         ret = bt_graph_add_port_added_listener(graph,
1478                 graph_port_added_listener_connect_to_avail_muxer_port,
1479                 &graph_listener_data);
1480         assert(ret >= 0);
1481
1482         /* Connect source output ports to muxer input ports */
1483         count = bt_component_source_get_output_port_count(src_comp);
1484         assert(ret == 0);
1485
1486         for (i = 0; i < count; i++) {
1487                 upstream_port = bt_component_source_get_output_port_by_index(
1488                         src_comp, i);
1489                 assert(upstream_port);
1490                 connect_port_to_first_avail_muxer_port(graph,
1491                         upstream_port, muxer_comp);
1492                 bt_put(upstream_port);
1493         }
1494
1495         /* Connect muxer output port to sink input port */
1496         upstream_port = bt_component_filter_get_output_port_by_name(muxer_comp,
1497                 "out");
1498         assert(upstream_port);
1499         downstream_port = bt_component_sink_get_input_port_by_name(sink_comp, "in");
1500         assert(downstream_port);
1501         graph_status = bt_graph_connect_ports(graph, upstream_port,
1502                 downstream_port, NULL);
1503         assert(graph_status == 0);
1504         bt_put(upstream_port);
1505         bt_put(downstream_port);
1506
1507         while (graph_status == BT_GRAPH_STATUS_OK ||
1508                         graph_status == BT_GRAPH_STATUS_AGAIN) {
1509                 graph_status = bt_graph_run(graph);
1510         }
1511
1512         ok(graph_status == BT_GRAPH_STATUS_END, "graph finishes without any error");
1513         ok(compare_test_events(expected_test_events),
1514                 "the produced sequence of test events is the expected one");
1515
1516         bt_put(src_comp);
1517         bt_put(muxer_comp);
1518         bt_put(sink_comp);
1519         bt_put(graph);
1520 }
1521
1522 static
1523 void test_single_again_end_then_multiple_full(void)
1524 {
1525         struct bt_component *src_comp;
1526         struct bt_component *muxer_comp;
1527         struct bt_component *sink_comp;
1528         struct bt_port *upstream_port;
1529         struct bt_port *downstream_port;
1530         struct bt_graph *graph;
1531         int64_t i;
1532         int64_t count;
1533         int ret;
1534         enum bt_graph_status graph_status = BT_GRAPH_STATUS_OK;
1535         struct graph_listener_data graph_listener_data;
1536         const struct test_event expected_test_events[] = {
1537                 { .type = TEST_EV_TYPE_AGAIN, },
1538                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, },
1539                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, },
1540                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, },
1541                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, },
1542                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 8 },
1543                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 51 },
1544                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 59 },
1545                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 68 },
1546                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 71 },
1547                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 77 },
1548                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 91 },
1549                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 121 },
1550                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 139 },
1551                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 170 },
1552                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 179 },
1553                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 209 },
1554                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 254 },
1555                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 266 },
1556                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 298 },
1557                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 320 },
1558                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 350 },
1559                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 352 },
1560                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 393 },
1561                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 419 },
1562                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 454 },
1563                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 478 },
1564                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 624 },
1565                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 631 },
1566                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 644 },
1567                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 651 },
1568                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 668 },
1569                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 678 },
1570                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 714 },
1571                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 717 },
1572                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 731 },
1573                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 733 },
1574                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 744 },
1575                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 750 },
1576                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 778 },
1577                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 788 },
1578                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 790 },
1579                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 819 },
1580                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 820 },
1581                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 836 },
1582                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, },
1583                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, },
1584                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 857 },
1585                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 892 },
1586                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 903 },
1587                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 944 },
1588                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .ts_ns = 998 },
1589                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, },
1590                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, },
1591                 { .type = TEST_EV_TYPE_END, },
1592                 { .type = TEST_EV_TYPE_SENTINEL, },
1593         };
1594
1595         clear_test_events();
1596         current_test = TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL;
1597         diag("test: single again then end then multiple full");
1598         create_source_muxer_sink(&src_comp, &muxer_comp, &sink_comp);
1599         graph = bt_graph_create();
1600         assert(graph);
1601         graph_listener_data.graph = graph;
1602         graph_listener_data.source = src_comp;
1603         graph_listener_data.muxer = muxer_comp;
1604         graph_listener_data.sink = sink_comp;
1605         ret = bt_graph_add_port_added_listener(graph,
1606                 graph_port_added_listener_connect_to_avail_muxer_port,
1607                 &graph_listener_data);
1608         assert(ret >= 0);
1609
1610         /* Connect source output ports to muxer input ports */
1611         count = bt_component_source_get_output_port_count(src_comp);
1612         assert(ret == 0);
1613
1614         for (i = 0; i < count; i++) {
1615                 upstream_port = bt_component_source_get_output_port_by_index(
1616                         src_comp, i);
1617                 assert(upstream_port);
1618                 connect_port_to_first_avail_muxer_port(graph,
1619                         upstream_port, muxer_comp);
1620                 bt_put(upstream_port);
1621         }
1622
1623         /* Connect muxer output port to sink input port */
1624         upstream_port = bt_component_filter_get_output_port_by_name(muxer_comp,
1625                 "out");
1626         assert(upstream_port);
1627         downstream_port = bt_component_sink_get_input_port_by_name(sink_comp, "in");
1628         assert(downstream_port);
1629         graph_status = bt_graph_connect_ports(graph, upstream_port,
1630                 downstream_port, NULL);
1631         assert(graph_status == 0);
1632         bt_put(upstream_port);
1633         bt_put(downstream_port);
1634
1635         while (graph_status == BT_GRAPH_STATUS_OK ||
1636                         graph_status == BT_GRAPH_STATUS_AGAIN) {
1637                 graph_status = bt_graph_run(graph);
1638         }
1639
1640         ok(graph_status == BT_GRAPH_STATUS_END, "graph finishes without any error");
1641         ok(compare_test_events(expected_test_events),
1642                 "the produced sequence of test events is the expected one");
1643
1644         bt_put(src_comp);
1645         bt_put(muxer_comp);
1646         bt_put(sink_comp);
1647         bt_put(graph);
1648 }
1649
1650 #define DEBUG_ENV_VAR   "TEST_UTILS_MUXER_DEBUG"
1651
1652 int main(int argc, char **argv)
1653 {
1654         if (getenv(DEBUG_ENV_VAR) && strcmp(getenv(DEBUG_ENV_VAR), "1") == 0) {
1655                 debug = true;
1656         }
1657
1658         plan_tests(NR_TESTS);
1659         init_static_data();
1660         test_no_ts();
1661         test_no_upstream_connection();
1662         test_simple_4_ports();
1663         test_4_ports_with_retries();
1664         test_single_end_then_multiple_full();
1665         test_single_again_end_then_multiple_full();
1666         fini_static_data();
1667         return exit_status();
1668 }