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         const struct bt_stream *stream;
  51         const 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_stream_class *src_stream_class;
  59 static struct bt_event_class *src_event_class;
  60 static struct bt_stream *src_stream1;
  61 static struct bt_stream *src_stream2;
  62 static struct bt_packet *src_stream1_packet1;
  63 static struct bt_packet *src_stream1_packet2;
  64 static struct bt_packet *src_stream2_packet1;
  65 static struct bt_packet *src_stream2_packet2;
  66 static const struct bt_stream *pub_src_stream1;
  67 static const struct bt_stream *pub_src_stream2;
  68 static const struct bt_packet *pub_src_stream1_packet1;
  69 static const struct bt_packet *pub_src_stream1_packet2;
  70 static const struct bt_packet *pub_src_stream2_packet1;
  71 static const 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_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_trace_create();
 258         BT_ASSERT(trace);
 259         src_stream_class = bt_stream_class_create(trace);
 260         BT_ASSERT(src_stream_class);
 261         src_event_class = bt_event_class_create(src_stream_class);
 262         BT_ASSERT(src_event_class);
 263         src_stream1 = bt_stream_create(src_stream_class);
 264         BT_ASSERT(src_stream1);
 265         pub_src_stream1 = src_stream1;
 266         src_stream2 = bt_stream_create(src_stream_class);
 267         BT_ASSERT(src_stream2);
 268         pub_src_stream2 = src_stream2;
 269         src_stream1_packet1 = bt_packet_create(src_stream1);
 270         BT_ASSERT(src_stream1_packet1);
 271         pub_src_stream1_packet1 = src_stream1_packet1;
 272         src_stream1_packet2 = bt_packet_create(src_stream1);
 273         BT_ASSERT(src_stream1_packet2);
 274         pub_src_stream1_packet2 = src_stream1_packet2;
 275         src_stream2_packet1 = bt_packet_create(src_stream2);
 276         BT_ASSERT(src_stream2_packet1);
 277         pub_src_stream2_packet1 = src_stream2_packet1;
 278         src_stream2_packet2 = bt_packet_create(src_stream2);
 279         BT_ASSERT(src_stream2_packet2);
 280         pub_src_stream2_packet2 = src_stream2_packet2;
 281
 282         if (debug) {
 283                 fprintf(stderr, ":: stream 1: %p\n", src_stream1);
 284                 fprintf(stderr, ":: stream 2: %p\n", src_stream2);
 285                 fprintf(stderr, ":: stream 1, packet 1: %p\n", src_stream1_packet1);
 286                 fprintf(stderr, ":: stream 1, packet 2: %p\n", src_stream1_packet2);
 287                 fprintf(stderr, ":: stream 2, packet 1: %p\n", src_stream2_packet1);
 288                 fprintf(stderr, ":: stream 2, packet 2: %p\n", src_stream2_packet2);
 289         }
 290
 291         bt_object_put_ref(trace);
 292 }
 293
 294 static
 295 void fini_static_data(void)
 296 {
 297         /* Test events */
 298         g_array_free(test_events, TRUE);
 299
 300         /* Metadata */
 301         bt_object_put_ref(src_stream_class);
 302         bt_object_put_ref(src_event_class);
 303         bt_object_put_ref(src_stream1);
 304         bt_object_put_ref(src_stream2);
 305         bt_object_put_ref(src_stream1_packet1);
 306         bt_object_put_ref(src_stream1_packet2);
 307         bt_object_put_ref(src_stream2_packet1);
 308         bt_object_put_ref(src_stream2_packet2);
 309 }
 310
 311 static
 312 void src_iter_finalize(struct bt_self_notification_iterator *self_notif_iter)
 313 {
 314         struct src_iter_user_data *user_data =
 315                 bt_self_notification_iterator_get_data(
 316                         self_notif_iter);
 317
 318         if (user_data) {
 319                 g_free(user_data);
 320         }
 321 }
 322
 323 static
 324 enum bt_self_notification_iterator_status src_iter_init(
 325                 struct bt_self_notification_iterator *self_notif_iter,
 326                 struct bt_self_component_source *self_comp,
 327                 struct bt_self_component_port_output *self_port)
 328 {
 329         struct src_iter_user_data *user_data =
 330                 g_new0(struct src_iter_user_data, 1);
 331
 332         BT_ASSERT(user_data);
 333         bt_self_notification_iterator_set_data(self_notif_iter, user_data);
 334
 335         switch (current_test) {
 336         case TEST_NO_AUTO_NOTIFS:
 337         case TEST_OUTPUT_PORT_NOTIFICATION_ITERATOR:
 338                 user_data->seq = seq_no_auto_notifs;
 339                 break;
 340         default:
 341                 abort();
 342         }
 343
 344         return BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK;
 345 }
 346
 347 static
 348 void src_iter_next_seq_one(struct bt_self_notification_iterator* notif_iter,
 349                 struct src_iter_user_data *user_data,
 350                 struct bt_notification **notif)
 351 {
 352         struct bt_packet *event_packet = NULL;
 353
 354         switch (user_data->seq[user_data->at]) {
 355         case SEQ_STREAM1_BEGIN:
 356                 *notif = bt_private_notification_as_notification(
 357                         bt_private_notification_stream_begin_create(
 358                                 notif_iter, src_stream1));
 359                 break;
 360         case SEQ_STREAM2_BEGIN:
 361                 *notif = bt_private_notification_as_notification(
 362                         bt_private_notification_stream_begin_create(
 363                                 notif_iter, src_stream2));
 364                 break;
 365         case SEQ_STREAM1_END:
 366                 *notif = bt_private_notification_as_notification(
 367                         bt_private_notification_stream_end_create(
 368                                 notif_iter, src_stream1));
 369                 break;
 370         case SEQ_STREAM2_END:
 371                 *notif = bt_private_notification_as_notification(
 372                         bt_private_notification_stream_end_create(
 373                                 notif_iter, src_stream2));
 374                 break;
 375         case SEQ_STREAM1_PACKET1_BEGIN:
 376                 *notif = bt_private_notification_as_notification(
 377                         bt_private_notification_packet_begin_create(
 378                                 notif_iter, src_stream1_packet1));
 379                 break;
 380         case SEQ_STREAM1_PACKET2_BEGIN:
 381                 *notif = bt_private_notification_as_notification(
 382                         bt_private_notification_packet_begin_create(
 383                                 notif_iter, src_stream1_packet2));
 384                 break;
 385         case SEQ_STREAM2_PACKET1_BEGIN:
 386                 *notif = bt_private_notification_as_notification(
 387                         bt_private_notification_packet_begin_create(
 388                                 notif_iter, src_stream2_packet1));
 389                 break;
 390         case SEQ_STREAM2_PACKET2_BEGIN:
 391                 *notif = bt_private_notification_as_notification(
 392                         bt_private_notification_packet_begin_create(
 393                                 notif_iter, src_stream2_packet2));
 394                 break;
 395         case SEQ_STREAM1_PACKET1_END:
 396                 *notif = bt_private_notification_as_notification(
 397                         bt_private_notification_packet_end_create(
 398                                 notif_iter, src_stream1_packet1));
 399                 break;
 400         case SEQ_STREAM1_PACKET2_END:
 401                 *notif = bt_private_notification_as_notification(
 402                         bt_private_notification_packet_end_create(
 403                                 notif_iter, src_stream1_packet2));
 404                 break;
 405         case SEQ_STREAM2_PACKET1_END:
 406                 *notif = bt_private_notification_as_notification(
 407                         bt_private_notification_packet_end_create(
 408                                 notif_iter, src_stream2_packet1));
 409                 break;
 410         case SEQ_STREAM2_PACKET2_END:
 411                 *notif = bt_private_notification_as_notification(
 412                         bt_private_notification_packet_end_create(
 413                                 notif_iter, src_stream2_packet2));
 414                 break;
 415         case SEQ_EVENT_STREAM1_PACKET1:
 416                 event_packet = src_stream1_packet1;
 417                 break;
 418         case SEQ_EVENT_STREAM1_PACKET2:
 419                 event_packet = src_stream1_packet2;
 420                 break;
 421         case SEQ_EVENT_STREAM2_PACKET1:
 422                 event_packet = src_stream2_packet1;
 423                 break;
 424         case SEQ_EVENT_STREAM2_PACKET2:
 425                 event_packet = src_stream2_packet2;
 426                 break;
 427         default:
 428                 abort();
 429         }
 430
 431         if (event_packet) {
 432                 *notif = bt_private_notification_as_notification(
 433                         bt_private_notification_event_create(
 434                                 notif_iter, src_event_class, event_packet));
 435         }
 436
 437         BT_ASSERT(*notif);
 438         user_data->at++;
 439 }
 440
 441 static
 442 enum bt_self_notification_iterator_status src_iter_next_seq(
 443                 struct bt_self_notification_iterator *notif_iter,
 444                 struct src_iter_user_data *user_data,
 445                 bt_notification_array notifs, uint64_t capacity,
 446                 uint64_t *count)
 447 {
 448         enum bt_self_notification_iterator_status status =
 449                 BT_SELF_NOTIFICATION_ITERATOR_STATUS_OK;
 450         uint64_t i = 0;
 451
 452         BT_ASSERT(user_data->seq);
 453
 454         if (user_data->seq[user_data->at] == SEQ_END) {
 455                 status = BT_SELF_NOTIFICATION_ITERATOR_STATUS_END;
 456                 goto end;
 457         }
 458
 459         while (i < capacity && user_data->seq[user_data->at] != SEQ_END) {
 460                 src_iter_next_seq_one(notif_iter, user_data, &notifs[i]);
 461                 i++;
 462         }
 463
 464         BT_ASSERT(i > 0 && i <= capacity);
 465         *count = i;
 466
 467 end:
 468         return status;
 469 }
 470
 471 static
 472 enum bt_self_notification_iterator_status src_iter_next(
 473                 struct bt_self_notification_iterator *self_notif_iter,
 474                 bt_notification_array notifs, uint64_t capacity,
 475                 uint64_t *count)
 476 {
 477         struct src_iter_user_data *user_data =
 478                 bt_self_notification_iterator_get_data(self_notif_iter);
 479
 480         BT_ASSERT(user_data);
 481         return src_iter_next_seq(self_notif_iter, user_data, notifs,
 482                 capacity, count);
 483 }
 484
 485 static
 486 enum bt_self_component_status src_init(
 487                 struct bt_self_component_source *self_comp,
 488                 const struct bt_value *params, void *init_method_data)
 489 {
 490         int ret;
 491
 492         ret = bt_self_component_source_add_output_port(
 493                 self_comp, "out", NULL, NULL);
 494         BT_ASSERT(ret == 0);
 495         return BT_SELF_COMPONENT_STATUS_OK;
 496 }
 497
 498 static
 499 void src_finalize(struct bt_self_component_source *self_comp)
 500 {
 501 }
 502
 503 static
 504 void append_test_events_from_notification(struct bt_notification *notification)
 505 {
 506         struct test_event test_event = { 0 };
 507
 508         switch (bt_notification_get_type(notification)) {
 509         case BT_NOTIFICATION_TYPE_EVENT:
 510         {
 511                 const struct bt_event *event;
 512
 513                 test_event.type = TEST_EV_TYPE_NOTIF_EVENT;
 514                 event = bt_notification_event_borrow_event(notification);
 515                 BT_ASSERT(event);
 516                 test_event.packet = bt_event_borrow_packet_const(event);
 517                 BT_ASSERT(test_event.packet);
 518                 break;
 519         }
 520         case BT_NOTIFICATION_TYPE_STREAM_BEGIN:
 521                 test_event.type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN;
 522                 test_event.stream =
 523                         bt_notification_stream_begin_borrow_stream(
 524                                 notification);
 525                 BT_ASSERT(test_event.stream);
 526                 break;
 527         case BT_NOTIFICATION_TYPE_STREAM_END:
 528                 test_event.type = TEST_EV_TYPE_NOTIF_STREAM_END;
 529                 test_event.stream =
 530                         bt_notification_stream_end_borrow_stream(notification);
 531                 BT_ASSERT(test_event.stream);
 532                 break;
 533         case BT_NOTIFICATION_TYPE_PACKET_BEGIN:
 534                 test_event.type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN;
 535                 test_event.packet =
 536                         bt_notification_packet_begin_borrow_packet(
 537                                 notification);
 538                 BT_ASSERT(test_event.packet);
 539                 break;
 540         case BT_NOTIFICATION_TYPE_PACKET_END:
 541                 test_event.type = TEST_EV_TYPE_NOTIF_PACKET_END;
 542                 test_event.packet =
 543                         bt_notification_packet_end_borrow_packet(notification);
 544                 BT_ASSERT(test_event.packet);
 545                 break;
 546         default:
 547                 test_event.type = TEST_EV_TYPE_NOTIF_UNEXPECTED;
 548                 break;
 549         }
 550
 551         if (test_event.packet) {
 552                 test_event.stream = bt_packet_borrow_stream_const(
 553                         test_event.packet);
 554                 BT_ASSERT(test_event.stream);
 555         }
 556
 557         append_test_event(&test_event);
 558 }
 559
 560 static
 561 enum bt_notification_iterator_status common_consume(
 562                 void *notif_iter, bool is_output_port_notif_iter)
 563 {
 564         enum bt_notification_iterator_status ret;
 565         bt_notification_array notifications = NULL;
 566         uint64_t count = 0;
 567         struct test_event test_event = { 0 };
 568         uint64_t i;
 569
 570         BT_ASSERT(notif_iter);
 571
 572         if (is_output_port_notif_iter) {
 573                 ret = bt_port_output_notification_iterator_next(notif_iter,
 574                         &notifications, &count);
 575         } else {
 576                 ret = bt_self_component_port_input_notification_iterator_next(
 577                         notif_iter, &notifications, &count);
 578         }
 579
 580         if (ret < 0) {
 581                 goto end;
 582         }
 583
 584         switch (ret) {
 585         case BT_NOTIFICATION_ITERATOR_STATUS_END:
 586                 test_event.type = TEST_EV_TYPE_END;
 587                 append_test_event(&test_event);
 588                 goto end;
 589         case BT_NOTIFICATION_ITERATOR_STATUS_AGAIN:
 590                 abort();
 591         default:
 592                 break;
 593         }
 594
 595         BT_ASSERT(notifications);
 596         BT_ASSERT(count > 0);
 597
 598         for (i = 0; i < count; i++) {
 599                 append_test_events_from_notification(notifications[i]);
 600                 bt_object_put_ref(notifications[i]);
 601         }
 602
 603 end:
 604         return ret;
 605 }
 606
 607 static
 608 enum bt_self_component_status sink_consume(
 609                 struct bt_self_component_sink *self_comp)
 610 {
 611         enum bt_self_component_status ret = BT_SELF_COMPONENT_STATUS_OK;
 612         struct sink_user_data *user_data =
 613                 bt_self_component_get_data(
 614                         bt_self_component_sink_as_self_component(
 615                                 self_comp));
 616         enum bt_notification_iterator_status it_ret;
 617
 618         BT_ASSERT(user_data && user_data->notif_iter);
 619         it_ret = common_consume(user_data->notif_iter, false);
 620
 621         if (it_ret < 0) {
 622                 ret = BT_SELF_COMPONENT_STATUS_ERROR;
 623                 goto end;
 624         }
 625
 626         switch (it_ret) {
 627         case BT_NOTIFICATION_ITERATOR_STATUS_END:
 628                 ret = BT_SELF_COMPONENT_STATUS_END;
 629                 BT_OBJECT_PUT_REF_AND_RESET(user_data->notif_iter);
 630                 goto end;
 631         case BT_NOTIFICATION_ITERATOR_STATUS_AGAIN:
 632                 abort();
 633         default:
 634                 break;
 635         }
 636
 637 end:
 638         return ret;
 639 }
 640
 641 static
 642 enum bt_self_component_status sink_port_connected(
 643                 struct bt_self_component_sink *self_comp,
 644                 struct bt_self_component_port_input *self_port,
 645                 struct bt_port_output *other_port)
 646 {
 647         struct sink_user_data *user_data =
 648                 bt_self_component_get_data(
 649                         bt_self_component_sink_as_self_component(
 650                                 self_comp));
 651
 652         BT_ASSERT(user_data);
 653         user_data->notif_iter =
 654                 bt_self_component_port_input_notification_iterator_create(
 655                         self_port);
 656         return BT_SELF_COMPONENT_STATUS_OK;
 657 }
 658
 659 static
 660 enum bt_self_component_status sink_init(
 661                 struct bt_self_component_sink *self_comp,
 662                 const struct bt_value *params, void *init_method_data)
 663 {
 664         struct sink_user_data *user_data = g_new0(struct sink_user_data, 1);
 665         int ret;
 666
 667         BT_ASSERT(user_data);
 668         bt_self_component_set_data(
 669                 bt_self_component_sink_as_self_component(self_comp),
 670                 user_data);
 671         ret = bt_self_component_sink_add_input_port(
 672                 self_comp, "in", NULL, NULL);
 673         BT_ASSERT(ret == 0);
 674         return BT_SELF_COMPONENT_STATUS_OK;
 675 }
 676
 677 static
 678 void sink_finalize(struct bt_self_component_sink *self_comp)
 679 {
 680         struct sink_user_data *user_data =
 681                 bt_self_component_get_data(
 682                         bt_self_component_sink_as_self_component(
 683                                 self_comp));
 684
 685         if (user_data) {
 686                 bt_object_put_ref(user_data->notif_iter);
 687                 g_free(user_data);
 688         }
 689 }
 690
 691 static
 692 void create_source_sink(struct bt_private_graph *graph,
 693                 struct bt_component_source **source,
 694                 struct bt_component_sink **sink)
 695 {
 696         struct bt_private_component_class_source *src_comp_class;
 697         struct bt_private_component_class_sink *sink_comp_class;
 698         int ret;
 699
 700         /* Create source component */
 701         if (source) {
 702                 src_comp_class = bt_private_component_class_source_create("src",
 703                         src_iter_next);
 704                 BT_ASSERT(src_comp_class);
 705                 ret = bt_private_component_class_source_set_init_method(
 706                         src_comp_class, src_init);
 707                 BT_ASSERT(ret == 0);
 708                 ret = bt_private_component_class_source_set_finalize_method(
 709                         src_comp_class, src_finalize);
 710                 BT_ASSERT(ret == 0);
 711                 ret = bt_private_component_class_source_set_notification_iterator_init_method(
 712                         src_comp_class, src_iter_init);
 713                 BT_ASSERT(ret == 0);
 714                 ret = bt_private_component_class_source_set_notification_iterator_finalize_method(
 715                         src_comp_class, src_iter_finalize);
 716                 BT_ASSERT(ret == 0);
 717                 ret = bt_private_graph_add_source_component(graph,
 718                         bt_private_component_class_source_as_component_class_source(
 719                                 src_comp_class), "source", NULL, source);
 720                 BT_ASSERT(ret == 0);
 721                 bt_object_put_ref(src_comp_class);
 722         }
 723
 724         /* Create sink component */
 725         if (sink) {
 726                 sink_comp_class = bt_private_component_class_sink_create("sink",
 727                         sink_consume);
 728                 BT_ASSERT(sink_comp_class);
 729                 ret = bt_private_component_class_sink_set_init_method(
 730                         sink_comp_class, sink_init);
 731                 BT_ASSERT(ret == 0);
 732                 ret = bt_private_component_class_sink_set_finalize_method(
 733                         sink_comp_class, sink_finalize);
 734                 ret = bt_private_component_class_sink_set_input_port_connected_method(
 735                         sink_comp_class, sink_port_connected);
 736                 BT_ASSERT(ret == 0);
 737                 ret = bt_private_graph_add_sink_component(graph,
 738                         bt_private_component_class_sink_as_component_class_sink(
 739                                 sink_comp_class),
 740                         "sink", NULL, sink);
 741                 BT_ASSERT(ret == 0);
 742                 bt_object_put_ref(sink_comp_class);
 743         }
 744 }
 745
 746 static
 747 void do_std_test(enum test test, const char *name,
 748                 const struct test_event *expected_test_events)
 749 {
 750         struct bt_component_source *src_comp;
 751         struct bt_component_sink *sink_comp;
 752         struct bt_port_output *upstream_port;
 753         struct bt_port_input *downstream_port;
 754         enum bt_graph_status graph_status = BT_GRAPH_STATUS_OK;
 755
 756         clear_test_events();
 757         current_test = test;
 758         diag("test: %s", name);
 759         BT_ASSERT(!graph);
 760         graph = bt_private_graph_create();
 761         BT_ASSERT(graph);
 762         create_source_sink(graph, &src_comp, &sink_comp);
 763
 764         /* Connect source to sink */
 765         upstream_port = bt_component_source_borrow_output_port_by_name(
 766                 src_comp, "out");
 767         BT_ASSERT(upstream_port);
 768         downstream_port = bt_component_sink_borrow_input_port_by_name(
 769                 sink_comp, "in");
 770         BT_ASSERT(downstream_port);
 771         graph_status = bt_private_graph_connect_ports(graph, upstream_port,
 772                 downstream_port, NULL);
 773
 774         /* Run the graph until the end */
 775         while (graph_status == BT_GRAPH_STATUS_OK ||
 776                         graph_status == BT_GRAPH_STATUS_AGAIN) {
 777                 graph_status = bt_private_graph_run(graph);
 778         }
 779
 780         ok(graph_status == BT_GRAPH_STATUS_END,
 781                 "graph finishes without any error");
 782
 783         /* Compare the resulting test events */
 784         if (expected_test_events) {
 785                 ok(compare_test_events(expected_test_events),
 786                         "the produced sequence of test events is the expected one");
 787         }
 788
 789         bt_object_put_ref(src_comp);
 790         bt_object_put_ref(sink_comp);
 791         BT_OBJECT_PUT_REF_AND_RESET(graph);
 792 }
 793
 794 static
 795 void test_no_auto_notifs(void)
 796 {
 797         const struct test_event expected_test_events[] = {
 798                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, .stream = pub_src_stream1, .packet = NULL, },
 799                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 800                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .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_STREAM_BEGIN, .stream = pub_src_stream2, .packet = NULL, },
 803                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 804                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, .stream = pub_src_stream2, .packet = pub_src_stream2_packet2, },
 805                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream2, .packet = pub_src_stream2_packet2, },
 806                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 807                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 808                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, .stream = pub_src_stream2, .packet = pub_src_stream2_packet2, },
 809                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, .stream = pub_src_stream1, .packet = pub_src_stream1_packet2, },
 810                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream1, .packet = pub_src_stream1_packet2, },
 811                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, .stream = pub_src_stream2, .packet = NULL, },
 812                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, .stream = pub_src_stream1, .packet = pub_src_stream1_packet2, },
 813                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, .stream = pub_src_stream1, .packet = NULL, },
 814                 { .type = TEST_EV_TYPE_END, },
 815                 { .type = TEST_EV_TYPE_SENTINEL, },
 816         };
 817
 818         do_std_test(TEST_NO_AUTO_NOTIFS, "no automatic notifications",
 819                 expected_test_events);
 820 }
 821
 822 static
 823 void test_output_port_notification_iterator(void)
 824 {
 825         const struct test_event expected_test_events[] = {
 826                 { .type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN, .stream = pub_src_stream1, .packet = NULL, },
 827                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 828                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .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_STREAM_BEGIN, .stream = pub_src_stream2, .packet = NULL, },
 831                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 832                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, .stream = pub_src_stream2, .packet = pub_src_stream2_packet2, },
 833                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream2, .packet = pub_src_stream2_packet2, },
 834                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 835                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, .stream = pub_src_stream1, .packet = pub_src_stream1_packet1, },
 836                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, .stream = pub_src_stream2, .packet = pub_src_stream2_packet2, },
 837                 { .type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN, .stream = pub_src_stream1, .packet = pub_src_stream1_packet2, },
 838                 { .type = TEST_EV_TYPE_NOTIF_EVENT, .stream = pub_src_stream1, .packet = pub_src_stream1_packet2, },
 839                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, .stream = pub_src_stream2, .packet = NULL, },
 840                 { .type = TEST_EV_TYPE_NOTIF_PACKET_END, .stream = pub_src_stream1, .packet = pub_src_stream1_packet2, },
 841                 { .type = TEST_EV_TYPE_NOTIF_STREAM_END, .stream = pub_src_stream1, .packet = NULL, },
 842                 { .type = TEST_EV_TYPE_END, },
 843                 { .type = TEST_EV_TYPE_SENTINEL, },
 844         };
 845         struct bt_component_source *src_comp;
 846         struct bt_port_output_notification_iterator *notif_iter;
 847         enum bt_notification_iterator_status iter_status =
 848                 BT_NOTIFICATION_ITERATOR_STATUS_OK;
 849         struct bt_port_output *upstream_port;
 850
 851         clear_test_events();
 852         current_test = TEST_OUTPUT_PORT_NOTIFICATION_ITERATOR;
 853         diag("test: output port notification iterator");
 854         BT_ASSERT(!graph);
 855         graph = bt_private_graph_create();
 856         BT_ASSERT(graph);
 857         create_source_sink(graph, &src_comp, NULL);
 858
 859         /* Create notification iterator on source's output port */
 860         upstream_port = bt_component_source_borrow_output_port_by_name(
 861                 src_comp, "out");
 862         notif_iter = bt_port_output_notification_iterator_create(graph,
 863                 upstream_port);
 864         ok(notif_iter, "bt_private_output_port_notification_iterator_create() succeeds");
 865
 866         /* Consume the notification iterator */
 867         while (iter_status == BT_NOTIFICATION_ITERATOR_STATUS_OK) {
 868                 iter_status = common_consume(notif_iter, true);
 869         }
 870
 871         ok(iter_status == BT_NOTIFICATION_ITERATOR_STATUS_END,
 872                 "output port notification iterator finishes without any error");
 873
 874         /* Compare the resulting test events */
 875         ok(compare_test_events(expected_test_events),
 876                 "the produced sequence of test events is the expected one");
 877
 878         bt_object_put_ref(src_comp);
 879         BT_OBJECT_PUT_REF_AND_RESET(graph);
 880         bt_object_put_ref(notif_iter);
 881 }
 882
 883 #define DEBUG_ENV_VAR   "TEST_BT_NOTIFICATION_ITERATOR_DEBUG"
 884
 885 int main(int argc, char **argv)
 886 {
 887         if (getenv(DEBUG_ENV_VAR) && strcmp(getenv(DEBUG_ENV_VAR), "1") == 0) {
 888                 debug = true;
 889         }
 890
 891         plan_tests(NR_TESTS);
 892         init_static_data();
 893         test_no_auto_notifs();
 894         test_output_port_notification_iterator();
 895         fini_static_data();
 896         return exit_status();
 897 }