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