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