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