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