tests/lib/test_bt_notification_iterator.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 <babeltrace/babeltrace.h>
  25 #include <babeltrace/assert-internal.h>
  26 #include <glib.h>
  27
  28 #include "tap/tap.h"
  29
  30 #define NR_TESTS        5
  31
  32 enum test {
  33         TEST_NO_AUTO_NOTIFS,
  34         TEST_OUTPUT_PORT_NOTIFICATION_ITERATOR,
  35 };
  36
  37 enum test_event_type {
  38         TEST_EV_TYPE_NOTIF_UNEXPECTED,
  39         TEST_EV_TYPE_NOTIF_EVENT,
  40         TEST_EV_TYPE_NOTIF_STREAM_BEGIN,
  41         TEST_EV_TYPE_NOTIF_PACKET_BEGIN,
  42         TEST_EV_TYPE_NOTIF_PACKET_END,
  43         TEST_EV_TYPE_NOTIF_STREAM_END,
  44         TEST_EV_TYPE_END,
  45         TEST_EV_TYPE_SENTINEL,
  46 };
  47
  48 struct test_event {
  49         enum test_event_type type;
  50         struct bt_stream *stream;
  51         struct bt_packet *packet;
  52 };
  53
  54 static bool debug = false;
  55 static enum test current_test;
  56 static GArray *test_events;
  57 static struct bt_private_graph *graph;
  58 static struct bt_private_stream_class *src_stream_class;
  59 static struct bt_private_event_class *src_event_class;
  60 static struct bt_private_stream *src_stream1;
  61 static struct bt_private_stream *src_stream2;
  62 static struct bt_private_packet *src_stream1_packet1;
  63 static struct bt_private_packet *src_stream1_packet2;
  64 static struct bt_private_packet *src_stream2_packet1;
  65 static struct bt_private_packet *src_stream2_packet2;
  66 static struct bt_stream *pub_src_stream1;
  67 static struct bt_stream *pub_src_stream2;
  68 static struct bt_packet *pub_src_stream1_packet1;
  69 static struct bt_packet *pub_src_stream1_packet2;
  70 static struct bt_packet *pub_src_stream2_packet1;
  71 static struct bt_packet *pub_src_stream2_packet2;
  72
  73 enum {
  74         SEQ_END = -1,
  75         SEQ_STREAM1_BEGIN = -2,
  76         SEQ_STREAM2_BEGIN = -3,
  77         SEQ_STREAM1_END = -4,
  78         SEQ_STREAM2_END = -5,
  79         SEQ_STREAM1_PACKET1_BEGIN = -6,
  80         SEQ_STREAM1_PACKET2_BEGIN = -7,
  81         SEQ_STREAM2_PACKET1_BEGIN = -8,
  82         SEQ_STREAM2_PACKET2_BEGIN = -9,
  83         SEQ_STREAM1_PACKET1_END = -10,
  84         SEQ_STREAM1_PACKET2_END = -11,
  85         SEQ_STREAM2_PACKET1_END = -12,
  86         SEQ_STREAM2_PACKET2_END = -13,
  87         SEQ_EVENT_STREAM1_PACKET1 = -14,
  88         SEQ_EVENT_STREAM1_PACKET2 = -15,
  89         SEQ_EVENT_STREAM2_PACKET1 = -16,
  90         SEQ_EVENT_STREAM2_PACKET2 = -17,
  91 };
  92
  93 struct src_iter_user_data {
  94         int64_t *seq;
  95         size_t at;
  96 };
  97
  98 struct sink_user_data {
  99         void *notif_iter;
 100 };
 101
 102 /*
 103  * No automatic notifications generated in this block.
 104  * Stream 2 notifications are more indented.
 105  */
 106 static int64_t seq_no_auto_notifs[] = {
 107         SEQ_STREAM1_BEGIN,
 108         SEQ_STREAM1_PACKET1_BEGIN,
 109         SEQ_EVENT_STREAM1_PACKET1,
 110         SEQ_EVENT_STREAM1_PACKET1,
 111                 SEQ_STREAM2_BEGIN,
 112         SEQ_EVENT_STREAM1_PACKET1,
 113                 SEQ_STREAM2_PACKET2_BEGIN,
 114                 SEQ_EVENT_STREAM2_PACKET2,
 115         SEQ_EVENT_STREAM1_PACKET1,
 116         SEQ_STREAM1_PACKET1_END,
 117                 SEQ_STREAM2_PACKET2_END,
 118         SEQ_STREAM1_PACKET2_BEGIN,
 119         SEQ_EVENT_STREAM1_PACKET2,
 120                 SEQ_STREAM2_END,
 121         SEQ_STREAM1_PACKET2_END,
 122         SEQ_STREAM1_END,
 123         SEQ_END,
 124 };
 125
 126 static
 127 void clear_test_events(void)
 128 {
 129         g_array_set_size(test_events, 0);
 130 }
 131
 132 static
 133 void print_test_event(FILE *fp, const struct test_event *event)
 134 {
 135         fprintf(fp, "{ type = ");
 136
 137         switch (event->type) {
 138         case TEST_EV_TYPE_NOTIF_UNEXPECTED:
 139                 fprintf(fp, "TEST_EV_TYPE_NOTIF_UNEXPECTED");
 140                 break;
 141         case TEST_EV_TYPE_NOTIF_EVENT:
 142                 fprintf(fp, "TEST_EV_TYPE_NOTIF_EVENT");
 143                 break;
 144         case TEST_EV_TYPE_NOTIF_STREAM_BEGIN:
 145                 fprintf(fp, "TEST_EV_TYPE_NOTIF_STREAM_BEGIN");
 146                 break;
 147         case TEST_EV_TYPE_NOTIF_STREAM_END:
 148                 fprintf(fp, "TEST_EV_TYPE_NOTIF_STREAM_END");
 149                 break;
 150         case TEST_EV_TYPE_NOTIF_PACKET_BEGIN:
 151                 fprintf(fp, "TEST_EV_TYPE_NOTIF_PACKET_BEGIN");
 152                 break;
 153         case TEST_EV_TYPE_NOTIF_PACKET_END:
 154                 fprintf(fp, "TEST_EV_TYPE_NOTIF_PACKET_END");
 155                 break;
 156         case TEST_EV_TYPE_END:
 157                 fprintf(fp, "TEST_EV_TYPE_END");
 158                 break;
 159         case TEST_EV_TYPE_SENTINEL:
 160                 fprintf(fp, "TEST_EV_TYPE_SENTINEL");
 161                 break;
 162         default:
 163                 fprintf(fp, "(UNKNOWN)");
 164                 break;
 165         }
 166
 167         fprintf(fp, ", stream = %p, packet = %p }", event->stream,
 168                 event->packet);
 169 }
 170
 171 static
 172 void append_test_event(struct test_event *event)
 173 {
 174         g_array_append_val(test_events, *event);
 175 }
 176
 177 static
 178 bool compare_single_test_events(const struct test_event *ev_a,
 179                 const struct test_event *ev_b)
 180 {
 181         if (debug) {
 182                 fprintf(stderr, ":: Comparing test events: ");
 183                 print_test_event(stderr, ev_a);
 184                 fprintf(stderr, " vs. ");
 185                 print_test_event(stderr, ev_b);
 186                 fprintf(stderr, "\n");
 187         }
 188
 189         if (ev_a->type != ev_b->type) {
 190                 return false;
 191         }
 192
 193         switch (ev_a->type) {
 194         case TEST_EV_TYPE_END:
 195         case TEST_EV_TYPE_SENTINEL:
 196                 break;
 197         default:
 198                 if (ev_a->stream != ev_b->stream) {
 199                         return false;
 200                 }
 201
 202                 if (ev_a->packet != ev_b->packet) {
 203                         return false;
 204                 }
 205                 break;
 206         }
 207
 208         return true;
 209 }
 210
 211 static
 212 bool compare_test_events(const struct test_event *expected_events)
 213 {
 214         const struct test_event *expected_event = expected_events;
 215         size_t i = 0;
 216
 217         BT_ASSERT(expected_events);
 218
 219         while (true) {
 220                 const struct test_event *event;
 221
 222                 if (expected_event->type == TEST_EV_TYPE_SENTINEL) {
 223                         break;
 224                 }
 225
 226                 if (i >= test_events->len) {
 227                         return false;
 228                 }
 229
 230                 event = &g_array_index(test_events, struct test_event, i);
 231
 232                 if (!compare_single_test_events(event, expected_event)) {
 233                         return false;
 234                 }
 235
 236                 i++;
 237                 expected_event++;
 238         }
 239
 240         if (i != test_events->len) {
 241                 return false;
 242         }
 243
 244         return true;
 245 }
 246
 247 static
 248 void init_static_data(void)
 249 {
 250         struct bt_private_trace *trace;
 251
 252         /* Test events */
 253         test_events = g_array_new(FALSE, TRUE, sizeof(struct test_event));
 254         BT_ASSERT(test_events);
 255
 256         /* Metadata */
 257         trace = bt_private_trace_create();
 258         BT_ASSERT(trace);
 259         src_stream_class = bt_private_stream_class_create(trace);
 260         BT_ASSERT(src_stream_class);
 261         src_event_class = bt_private_event_class_create(src_stream_class);
 262         BT_ASSERT(src_event_class);
 263         src_stream1 = bt_private_stream_create(src_stream_class);
 264         BT_ASSERT(src_stream1);
 265         pub_src_stream1 = bt_private_stream_borrow_stream(src_stream1);
 266         src_stream2 = bt_private_stream_create(src_stream_class);
 267         BT_ASSERT(src_stream2);
 268         pub_src_stream2 = bt_private_stream_borrow_stream(src_stream2);
 269         src_stream1_packet1 = bt_private_packet_create(src_stream1);
 270         BT_ASSERT(src_stream1_packet1);
 271         pub_src_stream1_packet1 = bt_private_packet_borrow_packet(
 272                 src_stream1_packet1);
 273         src_stream1_packet2 = bt_private_packet_create(src_stream1);
 274         BT_ASSERT(src_stream1_packet2);
 275         pub_src_stream1_packet2 = bt_private_packet_borrow_packet(
 276                 src_stream1_packet2);
 277         src_stream2_packet1 = bt_private_packet_create(src_stream2);
 278         BT_ASSERT(src_stream2_packet1);
 279         pub_src_stream2_packet1 = bt_private_packet_borrow_packet(
 280                 src_stream2_packet1);
 281         src_stream2_packet2 = bt_private_packet_create(src_stream2);
 282         BT_ASSERT(src_stream2_packet2);
 283         pub_src_stream2_packet2 = bt_private_packet_borrow_packet(
 284                 src_stream2_packet2);
 285
 286         if (debug) {
 287                 fprintf(stderr, ":: stream 1: %p\n", src_stream1);
 288                 fprintf(stderr, ":: stream 2: %p\n", src_stream2);
 289                 fprintf(stderr, ":: stream 1, packet 1: %p\n", src_stream1_packet1);
 290                 fprintf(stderr, ":: stream 1, packet 2: %p\n", src_stream1_packet2);
 291                 fprintf(stderr, ":: stream 2, packet 1: %p\n", src_stream2_packet1);
 292                 fprintf(stderr, ":: stream 2, packet 2: %p\n", src_stream2_packet2);
 293         }
 294
 295         bt_object_put_ref(trace);
 296 }
 297
 298 static
 299 void fini_static_data(void)
 300 {
 301         /* Test events */
 302         g_array_free(test_events, TRUE);
 303
 304         /* Metadata */
 305         bt_object_put_ref(src_stream_class);
 306         bt_object_put_ref(src_event_class);
 307         bt_object_put_ref(src_stream1);
 308         bt_object_put_ref(src_stream2);
 309         bt_object_put_ref(src_stream1_packet1);
 310         bt_object_put_ref(src_stream1_packet2);
 311         bt_object_put_ref(src_stream2_packet1);
 312         bt_object_put_ref(src_stream2_packet2);
 313 }
 314
 315 static
 316 void src_iter_finalize(struct bt_self_notification_iterator *self_notif_iter)
 317 {
 318         struct src_iter_user_data *user_data =
 319                 bt_self_notification_iterator_get_data(
 320                         self_notif_iter);
 321
 322         if (user_data) {
 323                 g_free(user_data);
 324         }
 325 }
 326
 327 static
 328 enum bt_self_notification_iterator_status src_iter_init(
 329                 struct bt_self_notification_iterator *self_notif_iter,
 330                 struct bt_self_component_source *self_comp,
 331                 struct bt_self_component_port_output *self_port)
 332 {
 333         struct src_iter_user_data *user_data =
 334                 g_new0(struct src_iter_user_data, 1);
 335
 336         BT_ASSERT(user_data);
 337         bt_self_notification_iterator_set_data(self_notif_iter, user_data);
 338
 339         switch (current_test) {
 340         case TEST_NO_AUTO_NOTIFS:
 341         case TEST_OUTPUT_PORT_NOTIFICATION_ITERATOR:
 342                 user_data->seq = seq_no_auto_notifs;
 343                 break;
 344         default:
 345                 abort();
 346         }
 347
 348         return BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK;
 349 }
 350
 351 static
 352 void src_iter_next_seq_one(struct bt_self_notification_iterator* notif_iter,
 353                 struct src_iter_user_data *user_data,
 354                 struct bt_notification **notif)
 355 {
 356         struct bt_private_packet *event_packet = NULL;
 357
 358         switch (user_data->seq[user_data->at]) {
 359         case SEQ_STREAM1_BEGIN:
 360                 *notif = bt_private_notification_borrow_notification(
 361                         bt_private_notification_stream_begin_create(
 362                                 notif_iter, src_stream1));
 363                 break;
 364         case SEQ_STREAM2_BEGIN:
 365                 *notif = bt_private_notification_borrow_notification(
 366                         bt_private_notification_stream_begin_create(
 367                                 notif_iter, src_stream2));
 368                 break;
 369         case SEQ_STREAM1_END:
 370                 *notif = bt_private_notification_borrow_notification(
 371                         bt_private_notification_stream_end_create(
 372                                 notif_iter, src_stream1));
 373                 break;
 374         case SEQ_STREAM2_END:
 375                 *notif = bt_private_notification_borrow_notification(
 376                         bt_private_notification_stream_end_create(
 377                                 notif_iter, src_stream2));
 378                 break;
 379         case SEQ_STREAM1_PACKET1_BEGIN:
 380                 *notif = bt_private_notification_borrow_notification(
 381                         bt_private_notification_packet_begin_create(
 382                                 notif_iter, src_stream1_packet1));
 383                 break;
 384         case SEQ_STREAM1_PACKET2_BEGIN:
 385                 *notif = bt_private_notification_borrow_notification(
 386                         bt_private_notification_packet_begin_create(
 387                                 notif_iter, src_stream1_packet2));
 388                 break;
 389         case SEQ_STREAM2_PACKET1_BEGIN:
 390                 *notif = bt_private_notification_borrow_notification(
 391                         bt_private_notification_packet_begin_create(
 392                                 notif_iter, src_stream2_packet1));
 393                 break;
 394         case SEQ_STREAM2_PACKET2_BEGIN:
 395                 *notif = bt_private_notification_borrow_notification(
 396                         bt_private_notification_packet_begin_create(
 397                                 notif_iter, src_stream2_packet2));
 398                 break;
 399         case SEQ_STREAM1_PACKET1_END:
 400                 *notif = bt_private_notification_borrow_notification(
 401                         bt_private_notification_packet_end_create(
 402                                 notif_iter, src_stream1_packet1));
 403                 break;
 404         case SEQ_STREAM1_PACKET2_END:
 405                 *notif = bt_private_notification_borrow_notification(
 406                         bt_private_notification_packet_end_create(
 407                                 notif_iter, src_stream1_packet2));
 408                 break;
 409         case SEQ_STREAM2_PACKET1_END:
 410                 *notif = bt_private_notification_borrow_notification(
 411                         bt_private_notification_packet_end_create(
 412                                 notif_iter, src_stream2_packet1));
 413                 break;
 414         case SEQ_STREAM2_PACKET2_END:
 415                 *notif = bt_private_notification_borrow_notification(
 416                         bt_private_notification_packet_end_create(
 417                                 notif_iter, src_stream2_packet2));
 418                 break;
 419         case SEQ_EVENT_STREAM1_PACKET1:
 420                 event_packet = src_stream1_packet1;
 421                 break;
 422         case SEQ_EVENT_STREAM1_PACKET2:
 423                 event_packet = src_stream1_packet2;
 424                 break;
 425         case SEQ_EVENT_STREAM2_PACKET1:
 426                 event_packet = src_stream2_packet1;
 427                 break;
 428         case SEQ_EVENT_STREAM2_PACKET2:
 429                 event_packet = src_stream2_packet2;
 430                 break;
 431         default:
 432                 abort();
 433         }
 434
 435         if (event_packet) {
 436                 *notif = bt_private_notification_borrow_notification(
 437                         bt_private_notification_event_create(
 438                                 notif_iter, src_event_class, event_packet));
 439         }
 440
 441         BT_ASSERT(*notif);
 442         user_data->at++;
 443 }
 444
 445 static
 446 enum bt_self_notification_iterator_status src_iter_next_seq(
 447                 struct bt_self_notification_iterator *notif_iter,
 448                 struct src_iter_user_data *user_data,
 449                 bt_notification_array notifs, uint64_t capacity,
 450                 uint64_t *count)
 451 {
 452         enum bt_self_notification_iterator_status status =
 453                 BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK;
 454         uint64_t i = 0;
 455
 456         BT_ASSERT(user_data->seq);
 457
 458         if (user_data->seq[user_data->at] == SEQ_END) {
 459                 status = BT_SELF_NOTIFICATION_ITERATOR_STATUS_END;
 460                 goto end;
 461         }
 462
 463         while (i < capacity && user_data->seq[user_data->at] != SEQ_END) {
 464                 src_iter_next_seq_one(notif_iter, user_data, &notifs[i]);
 465                 i++;
 466         }
 467
 468         BT_ASSERT(i > 0 && i <= capacity);
 469         *count = i;
 470
 471 end:
 472         return status;
 473 }
 474
 475 static
 476 enum bt_self_notification_iterator_status src_iter_next(
 477                 struct bt_self_notification_iterator *self_notif_iter,
 478                 bt_notification_array notifs, uint64_t capacity,
 479                 uint64_t *count)
 480 {
 481         struct src_iter_user_data *user_data =
 482                 bt_self_notification_iterator_get_data(self_notif_iter);
 483
 484         BT_ASSERT(user_data);
 485         return src_iter_next_seq(self_notif_iter, user_data, notifs,
 486                 capacity, count);
 487 }
 488
 489 static
 490 enum bt_self_component_status src_init(
 491                 struct bt_self_component_source *self_comp,
 492                 struct bt_value *params, void *init_method_data)
 493 {
 494         int ret;
 495
 496         ret = bt_self_component_source_add_output_port(
 497                 self_comp, "out", NULL, NULL);
 498         BT_ASSERT(ret == 0);
 499         return BT_SELF_COMPONENT_STATUS_OK;
 500 }
 501
 502 static
 503 void src_finalize(struct bt_self_component_source *self_comp)
 504 {
 505 }
 506
 507 static
 508 void append_test_events_from_notification(struct bt_notification *notification)
 509 {
 510         struct test_event test_event = { 0 };
 511
 512         switch (bt_notification_get_type(notification)) {
 513         case BT_NOTIFICATION_TYPE_EVENT:
 514         {
 515                 struct bt_event *event;
 516
 517                 test_event.type = TEST_EV_TYPE_NOTIF_EVENT;
 518                 event = bt_notification_event_borrow_event(notification);
 519                 BT_ASSERT(event);
 520                 test_event.packet = bt_event_borrow_packet(event);
 521                 BT_ASSERT(test_event.packet);
 522                 break;
 523         }
 524         case BT_NOTIFICATION_TYPE_STREAM_BEGIN:
 525                 test_event.type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN;
 526                 test_event.stream =
 527                         bt_notification_stream_begin_borrow_stream(notification);
 528                 BT_ASSERT(test_event.stream);
 529                 break;
 530         case BT_NOTIFICATION_TYPE_STREAM_END:
 531                 test_event.type = TEST_EV_TYPE_NOTIF_STREAM_END;
 532                 test_event.stream =
 533                         bt_notification_stream_end_borrow_stream(notification);
 534                 BT_ASSERT(test_event.stream);
 535                 break;
 536         case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
 537                 test_event.type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN;
 538                 test_event.packet =
 539                         bt_notification_packet_begin_borrow_packet(notification);
 540                 BT_ASSERT(test_event.packet);
 541                 break;
 542         case BT_NOTIFICATION_TYPE_PACKET_END:
 543                 test_event.type = TEST_EV_TYPE_NOTIF_PACKET_END;
 544                 test_event.packet =
 545                         bt_notification_packet_end_borrow_packet(notification);
 546                 BT_ASSERT(test_event.packet);
 547                 break;
 548         default:
 549                 test_event.type = TEST_EV_TYPE_NOTIF_UNEXPECTED;
 550                 break;
 551         }
 552
 553         if (test_event.packet) {
 554                 test_event.stream = bt_packet_borrow_stream(test_event.packet);
 555                 BT_ASSERT(test_event.stream);
 556         }
 557
 558         append_test_event(&test_event);
 559 }
 560
 561 static
 562 enum bt_notification_iterator_status common_consume(
 563                 void *notif_iter, bool is_output_port_notif_iter)
 564 {
 565         enum bt_notification_iterator_status ret;
 566         bt_notification_array notifications = NULL;
 567         uint64_t count = 0;
 568         struct test_event test_event = { 0 };
 569         uint64_t i;
 570
 571         BT_ASSERT(notif_iter);
 572
 573         if (is_output_port_notif_iter) {
 574                 ret = bt_port_output_notification_iterator_next(notif_iter,
 575                         &notifications, &count);
 576         } else {
 577                 ret = bt_self_component_port_input_notification_iterator_next(
 578                         notif_iter, &notifications, &count);
 579         }
 580
 581         if (ret < 0) {
 582                 goto end;
 583         }
 584
 585         switch (ret) {
 586         case BT_NOTIFICATION_ITERATOR_STATUS_END:
 587                 test_event.type = TEST_EV_TYPE_END;
 588                 append_test_event(&test_event);
 589                 goto end;
 590         case BT_NOTIFICATION_ITERATOR_STATUS_AGAIN:
 591                 abort();
 592         default:
 593                 break;
 594         }
 595
 596         BT_ASSERT(notifications);
 597         BT_ASSERT(count > 0);
 598
 599         for (i = 0; i < count; i++) {
 600                 append_test_events_from_notification(notifications[i]);
 601                 bt_object_put_ref(notifications[i]);
 602         }
 603
 604 end:
 605         return ret;
 606 }
 607
 608 static
 609 enum bt_self_component_status sink_consume(
 610                 struct bt_self_component_sink *self_comp)
 611 {
 612         enum bt_self_component_status ret = BT_SELF_COMPONENT_STATUS_OK;
 613         struct sink_user_data *user_data =
 614                 bt_self_component_get_data(
 615                         bt_self_component_sink_borrow_self_component(
 616                                 self_comp));
 617         enum bt_notification_iterator_status it_ret;
 618
 619         BT_ASSERT(user_data && user_data->notif_iter);
 620         it_ret = common_consume(user_data->notif_iter, false);
 621
 622         if (it_ret < 0) {
 623                 ret = BT_SELF_COMPONENT_STATUS_ERROR;
 624                 goto end;
 625         }
 626
 627         switch (it_ret) {
 628         case BT_NOTIFICATION_ITERATOR_STATUS_END:
 629                 ret = BT_SELF_COMPONENT_STATUS_END;
 630                 BT_OBJECT_PUT_REF_AND_RESET(user_data->notif_iter);
 631                 goto end;
 632         case BT_NOTIFICATION_ITERATOR_STATUS_AGAIN:
 633                 abort();
 634         default:
 635                 break;
 636         }
 637
 638 end:
 639         return ret;
 640 }
 641
 642 static
 643 enum bt_self_component_status sink_port_connected(
 644                 struct bt_self_component_sink *self_comp,
 645                 struct bt_self_component_port_input *self_port,
 646                 struct bt_port_output *other_port)
 647 {
 648         struct sink_user_data *user_data =
 649                 bt_self_component_get_data(
 650                         bt_self_component_sink_borrow_self_component(
 651                                 self_comp));
 652
 653         BT_ASSERT(user_data);
 654         user_data->notif_iter =
 655                 bt_self_component_port_input_notification_iterator_create(
 656                         self_port);
 657         return BT_SELF_COMPONENT_STATUS_OK;
 658 }
 659
 660 static
 661 enum bt_self_component_status sink_init(
 662                 struct bt_self_component_sink *self_comp,
 663                 struct bt_value *params, void *init_method_data)
 664 {
 665         struct sink_user_data *user_data = g_new0(struct sink_user_data, 1);
 666         int ret;
 667
 668         BT_ASSERT(user_data);
 669         bt_self_component_set_data(
 670                 bt_self_component_sink_borrow_self_component(self_comp),
 671                 user_data);
 672         ret = bt_self_component_sink_add_input_port(
 673                 self_comp, "in", NULL, NULL);
 674         BT_ASSERT(ret == 0);
 675         return BT_SELF_COMPONENT_STATUS_OK;
 676 }
 677
 678 static
 679 void sink_finalize(struct bt_self_component_sink *self_comp)
 680 {
 681         struct sink_user_data *user_data =
 682                 bt_self_component_get_data(
 683                         bt_self_component_sink_borrow_self_component(
 684                                 self_comp));
 685
 686         if (user_data) {
 687                 bt_object_put_ref(user_data->notif_iter);
 688                 g_free(user_data);
 689         }
 690 }
 691
 692 static
 693 void create_source_sink(struct bt_private_graph *graph,
 694                 struct bt_component_source **source,
 695                 struct bt_component_sink **sink)
 696 {
 697         struct bt_private_component_class_source *src_comp_class;
 698         struct bt_private_component_class_sink *sink_comp_class;
 699         int ret;
 700
 701         /* Create source component */
 702         if (source) {
 703                 src_comp_class = bt_private_component_class_source_create("src",
 704                         src_iter_next);
 705                 BT_ASSERT(src_comp_class);
 706                 ret = bt_private_component_class_source_set_init_method(
 707                         src_comp_class, src_init);
 708                 BT_ASSERT(ret == 0);
 709                 ret = bt_private_component_class_source_set_finalize_method(
 710                         src_comp_class, src_finalize);
 711                 BT_ASSERT(ret == 0);
 712                 ret = bt_private_component_class_source_set_notification_iterator_init_method(
 713                         src_comp_class, src_iter_init);
 714                 BT_ASSERT(ret == 0);
 715                 ret = bt_private_component_class_source_set_notification_iterator_finalize_method(
 716                         src_comp_class, src_iter_finalize);
 717                 BT_ASSERT(ret == 0);
 718                 ret = bt_private_graph_add_source_component(graph,
 719                         bt_private_component_class_source_borrow_component_class_source(
 720                                 src_comp_class), "source", NULL, source);
 721                 BT_ASSERT(ret == 0);
 722                 bt_object_put_ref(src_comp_class);
 723         }
 724
 725         /* Create sink component */
 726         if (sink) {
 727                 sink_comp_class = bt_private_component_class_sink_create("sink",
 728                         sink_consume);
 729                 BT_ASSERT(sink_comp_class);
 730                 ret = bt_private_component_class_sink_set_init_method(
 731                         sink_comp_class, sink_init);
 732                 BT_ASSERT(ret == 0);
 733                 ret = bt_private_component_class_sink_set_finalize_method(
 734                         sink_comp_class, sink_finalize);
 735                 ret = bt_private_component_class_sink_set_input_port_connected_method(
 736                         sink_comp_class, sink_port_connected);
 737                 BT_ASSERT(ret == 0);
 738                 ret = bt_private_graph_add_sink_component(graph,
 739                         bt_private_component_class_sink_borrow_component_class_sink(
 740                                 sink_comp_class),
 741                         "sink", NULL, sink);
 742                 BT_ASSERT(ret == 0);
 743                 bt_object_put_ref(sink_comp_class);
 744         }
 745 }
 746
 747 static
 748 void do_std_test(enum test test, const char *name,
 749                 const struct test_event *expected_test_events)
 750 {
 751         struct bt_component_source *src_comp;
 752         struct bt_component_sink *sink_comp;
 753         struct bt_port_output *upstream_port;
 754         struct bt_port_input *downstream_port;
 755         enum bt_graph_status graph_status = BT_GRAPH_STATUS_OK;
 756
 757         clear_test_events();
 758         current_test = test;
 759         diag("test: %s", name);
 760         BT_ASSERT(!graph);
 761         graph = bt_private_graph_create();
 762         BT_ASSERT(graph);
 763         create_source_sink(graph, &src_comp, &sink_comp);
 764
 765         /* Connect source to sink */
 766         upstream_port = bt_component_source_borrow_output_port_by_name(
 767                 src_comp, "out");
 768         BT_ASSERT(upstream_port);
 769         downstream_port = bt_component_sink_borrow_input_port_by_name(
 770                 sink_comp, "in");
 771         BT_ASSERT(downstream_port);
 772         graph_status = bt_private_graph_connect_ports(graph, upstream_port,
 773                 downstream_port, NULL);
 774
 775         /* Run the graph until the end */
 776         while (graph_status == BT_GRAPH_STATUS_OK ||
 777                         graph_status == BT_GRAPH_STATUS_AGAIN) {
 778                 graph_status = bt_private_graph_run(graph);
 779         }
 780
 781         ok(graph_status == BT_GRAPH_STATUS_END,
 782                 "graph finishes without any error");
 783
 784         /* Compare the resulting test events */
 785         if (expected_test_events) {
 786                 ok(compare_test_events(expected_test_events),
 787                         "the produced sequence of test events is the expected one");
 788         }
 789
 790         bt_object_put_ref(src_comp);
 791         bt_object_put_ref(sink_comp);
 792         BT_OBJECT_PUT_REF_AND_RESET(graph);
 793 }
 794
 795 static
 796 void test_no_auto_notifs(void)
 797 {
 798         const struct test_event expected_test_events[] = {
 799                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, .stream = pub_src_stream1, .packet = NULL, },
 800                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 801                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 802                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 803                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, .stream = pub_src_stream2, .packet = NULL, },
 804                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 805                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, .stream = pub_src_stream2, .packet = pub_src_stream2_packet2, },
 806                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream2, .packet = pub_src_stream2_packet2, },
 807                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 808                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 809                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, .stream = pub_src_stream2, .packet = pub_src_stream2_packet2, },
 810                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, .stream = pub_src_stream1, .packet = pub_src_stream1_packet2, },
 811                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream1, .packet = pub_src_stream1_packet2, },
 812                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, .stream = pub_src_stream2, .packet = NULL, },
 813                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, .stream = pub_src_stream1, .packet = pub_src_stream1_packet2, },
 814                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, .stream = pub_src_stream1, .packet = NULL, },
 815                 { .type = TEST_EV_TYPE_END, },
 816                 { .type = TEST_EV_TYPE_SENTINEL, },
 817         };
 818
 819         do_std_test(TEST_NO_AUTO_NOTIFS, "no automatic notifications",
 820                 expected_test_events);
 821 }
 822
 823 static
 824 void test_output_port_notification_iterator(void)
 825 {
 826         const struct test_event expected_test_events[] = {
 827                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, .stream = pub_src_stream1, .packet = NULL, },
 828                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 829                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 830                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 831                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, .stream = pub_src_stream2, .packet = NULL, },
 832                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 833                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, .stream = pub_src_stream2, .packet = pub_src_stream2_packet2, },
 834                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream2, .packet = pub_src_stream2_packet2, },
 835                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 836                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 837                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, .stream = pub_src_stream2, .packet = pub_src_stream2_packet2, },
 838                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, .stream = pub_src_stream1, .packet = pub_src_stream1_packet2, },
 839                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream1, .packet = pub_src_stream1_packet2, },
 840                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, .stream = pub_src_stream2, .packet = NULL, },
 841                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, .stream = pub_src_stream1, .packet = pub_src_stream1_packet2, },
 842                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, .stream = pub_src_stream1, .packet = NULL, },
 843                 { .type = TEST_EV_TYPE_END, },
 844                 { .type = TEST_EV_TYPE_SENTINEL, },
 845         };
 846         struct bt_component_source *src_comp;
 847         struct bt_port_output_notification_iterator *notif_iter;
 848         enum bt_notification_iterator_status iter_status =
 849                 BT_NOTIFICATION_ITERATOR_STATUS_OK;
 850         struct bt_port_output *upstream_port;
 851
 852         clear_test_events();
 853         current_test = TEST_OUTPUT_PORT_NOTIFICATION_ITERATOR;
 854         diag("test: output port notification iterator");
 855         BT_ASSERT(!graph);
 856         graph = bt_private_graph_create();
 857         BT_ASSERT(graph);
 858         create_source_sink(graph, &src_comp, NULL);
 859
 860         /* Create notification iterator on source's output port */
 861         upstream_port = bt_component_source_borrow_output_port_by_name(
 862                 src_comp, "out");
 863         notif_iter = bt_port_output_notification_iterator_create(graph,
 864                 upstream_port, NULL);
 865         ok(notif_iter, "bt_private_output_port_notification_iterator_create() succeeds");
 866
 867         /* Consume the notification iterator */
 868         while (iter_status == BT_NOTIFICATION_ITERATOR_STATUS_OK) {
 869                 iter_status = common_consume(notif_iter, true);
 870         }
 871
 872         ok(iter_status == BT_NOTIFICATION_ITERATOR_STATUS_END,
 873                 "output port notification iterator finishes without any error");
 874
 875         /* Compare the resulting test events */
 876         ok(compare_test_events(expected_test_events),
 877                 "the produced sequence of test events is the expected one");
 878
 879         bt_object_put_ref(src_comp);
 880         BT_OBJECT_PUT_REF_AND_RESET(graph);
 881         bt_object_put_ref(notif_iter);
 882 }
 883
 884 #define DEBUG_ENV_VAR   "TEST_BT_NOTIFICATION_ITERATOR_DEBUG"
 885
 886 int main(int argc, char **argv)
 887 {
 888         if (getenv(DEBUG_ENV_VAR) && strcmp(getenv(DEBUG_ENV_VAR), "1") == 0) {
 889                 debug = true;
 890         }
 891
 892         plan_tests(NR_TESTS);
 893         init_static_data();
 894         test_no_auto_notifs();
 895         test_output_port_notification_iterator();
 896         fini_static_data();
 897         return exit_status();
 898 }