X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=tests%2Fplugins%2Ftest-utils-muxer.c;h=c02bbbef7d097837f9536c8157935ef6897bdc42;hb=5c5632787fc9cafa602c89a28966bcfd01ec0204;hp=292ee0fec6f4bc8432b985c4017438114ecc00d2;hpb=50842bdc4c21f3de2b63e29cdac730af8b6dcca6;p=babeltrace.git diff --git a/tests/plugins/test-utils-muxer.c b/tests/plugins/test-utils-muxer.c index 292ee0fe..c02bbbef 100644 --- a/tests/plugins/test-utils-muxer.c +++ b/tests/plugins/test-utils-muxer.c @@ -72,6 +72,7 @@ struct graph_listener_data { static bool debug = false; static enum test current_test; static GArray *test_events; +static struct bt_graph *graph; static struct bt_clock_class_priority_map *src_cc_prio_map; static struct bt_clock_class_priority_map *src_empty_cc_prio_map; static struct bt_clock_class *src_clock_class; @@ -87,6 +88,8 @@ enum { SEQ_AGAIN = -2, SEQ_PACKET_BEGIN = -3, SEQ_PACKET_END = -4, + SEQ_STREAM_BEGIN = -5, + SEQ_STREAM_END = -6, }; struct src_iter_user_data { @@ -101,52 +104,62 @@ struct sink_user_data { }; static int64_t seq1[] = { - 24, 53, 97, 105, 119, 210, 222, 240, 292, 317, 353, 407, 433, - 473, 487, 504, 572, 615, 708, 766, 850, 852, 931, 951, 956, 996, - SEQ_END, + SEQ_STREAM_BEGIN, SEQ_PACKET_BEGIN, 24, 53, 97, 105, 119, 210, + 222, 240, 292, 317, 353, 407, 433, 473, 487, 504, 572, 615, 708, + 766, 850, 852, 931, 951, 956, 996, SEQ_PACKET_END, + SEQ_STREAM_END, SEQ_END, }; static int64_t seq2[] = { - 51, 59, 68, 77, 91, 121, 139, 170, 179, 266, 352, 454, 478, 631, - 644, 668, 714, 744, 750, 778, 790, 836, SEQ_END, + SEQ_STREAM_BEGIN, SEQ_PACKET_BEGIN, 51, 59, 68, 77, 91, 121, + 139, 170, 179, 266, 352, 454, 478, 631, 644, 668, 714, 744, 750, + 778, 790, 836, SEQ_PACKET_END, SEQ_STREAM_END, SEQ_END, }; static int64_t seq3[] = { - 8, 71, 209, 254, 298, 320, 350, 393, 419, 624, 651, 678, 717, - 731, 733, 788, 819, 820, 857, 892, 903, 944, 998, SEQ_END, + SEQ_STREAM_BEGIN, SEQ_PACKET_BEGIN, 8, 71, 209, 254, 298, 320, + 350, 393, 419, 624, 651, 678, 717, 731, 733, 788, 819, 820, 857, + 892, 903, 944, 998, SEQ_PACKET_END, SEQ_STREAM_END, SEQ_END, }; static int64_t seq4[] = { - 41, 56, 120, 138, 154, 228, 471, 479, 481, 525, 591, 605, 612, - 618, 632, 670, 696, 825, 863, 867, 871, 884, 953, 985, 999, + SEQ_STREAM_BEGIN, SEQ_PACKET_BEGIN, 41, 56, 120, 138, 154, 228, + 471, 479, 481, 525, 591, 605, 612, 618, 632, 670, 696, 825, 863, + 867, 871, 884, 953, 985, 999, SEQ_PACKET_END, SEQ_STREAM_END, SEQ_END, }; static int64_t seq1_with_again[] = { - 24, 53, 97, 105, 119, 210, SEQ_AGAIN, 222, 240, 292, 317, 353, - 407, 433, 473, 487, 504, 572, 615, 708, 766, 850, 852, 931, 951, - 956, 996, SEQ_END, + SEQ_STREAM_BEGIN, SEQ_PACKET_BEGIN, 24, 53, 97, 105, 119, 210, + SEQ_AGAIN, 222, 240, 292, 317, 353, 407, 433, 473, 487, 504, + 572, 615, 708, 766, 850, 852, 931, 951, 956, 996, + SEQ_PACKET_END, SEQ_STREAM_END, SEQ_END, }; static int64_t seq2_with_again[] = { - 51, 59, 68, 77, 91, 121, 139, 170, 179, 266, 352, 454, 478, 631, - 644, 668, 714, 744, 750, 778, 790, 836, SEQ_AGAIN, SEQ_END, + SEQ_STREAM_BEGIN, SEQ_PACKET_BEGIN, 51, 59, 68, 77, 91, 121, + 139, 170, 179, 266, 352, 454, 478, 631, 644, 668, 714, 744, 750, + 778, 790, 836, SEQ_AGAIN, SEQ_PACKET_END, SEQ_STREAM_END, + SEQ_END, }; static int64_t seq3_with_again[] = { - 8, 71, 209, 254, 298, 320, 350, 393, 419, 624, 651, SEQ_AGAIN, - 678, 717, 731, 733, 788, 819, 820, 857, 892, 903, 944, 998, - SEQ_END, + SEQ_STREAM_BEGIN, SEQ_PACKET_BEGIN, 8, 71, 209, 254, 298, 320, + 350, 393, 419, 624, 651, SEQ_AGAIN, 678, 717, 731, 733, 788, + 819, 820, 857, 892, 903, 944, 998, SEQ_PACKET_END, + SEQ_STREAM_END, SEQ_END, }; static int64_t seq4_with_again[] = { - SEQ_AGAIN, 41, 56, 120, 138, 154, 228, 471, 479, 481, 525, 591, - 605, 612, 618, 632, 670, 696, 825, 863, 867, 871, 884, 953, 985, - 999, SEQ_END, + SEQ_AGAIN, SEQ_STREAM_BEGIN, SEQ_PACKET_BEGIN, 41, 56, 120, 138, + 154, 228, 471, 479, 481, 525, 591, 605, 612, 618, 632, 670, 696, + 825, 863, 867, 871, 884, 953, 985, 999, SEQ_PACKET_END, + SEQ_STREAM_END, SEQ_END, }; static int64_t seq5[] = { - 1, 4, 189, 1001, SEQ_END, + SEQ_STREAM_BEGIN, SEQ_PACKET_BEGIN, 1, 4, 189, 1001, + SEQ_PACKET_END, SEQ_STREAM_END, SEQ_END, }; static @@ -290,6 +303,8 @@ void init_static_data(void) struct bt_trace *trace; struct bt_stream *stream; struct bt_field_type *empty_struct_ft; + struct bt_field_type *eh_ft; + struct bt_field_type *eh_ts_ft; /* Test events */ test_events = g_array_new(FALSE, TRUE, sizeof(struct test_event)); @@ -298,15 +313,15 @@ void init_static_data(void) /* Metadata */ empty_struct_ft = bt_field_type_structure_create(); assert(empty_struct_ft); + src_clock_class = bt_clock_class_create("my-clock", 1000000000); + assert(src_clock_class); trace = bt_trace_create(); assert(trace); ret = bt_trace_set_native_byte_order(trace, BT_BYTE_ORDER_LITTLE_ENDIAN); assert(ret == 0); - ret = bt_trace_set_packet_header_type(trace, empty_struct_ft); + ret = bt_trace_set_packet_header_field_type(trace, empty_struct_ft); assert(ret == 0); - src_clock_class = bt_clock_class_create("my-clock", 1000000000); - assert(src_clock_class); ret = bt_clock_class_set_is_absolute(src_clock_class, 1); assert(ret == 0); ret = bt_trace_add_clock_class(trace, src_clock_class); @@ -320,20 +335,29 @@ void init_static_data(void) assert(ret == 0); src_stream_class = bt_stream_class_create("my-stream-class"); assert(src_stream_class); - ret = bt_stream_class_set_packet_context_type(src_stream_class, + ret = bt_stream_class_set_packet_context_field_type(src_stream_class, empty_struct_ft); assert(ret == 0); - ret = bt_stream_class_set_event_header_type(src_stream_class, - empty_struct_ft); + eh_ft = bt_field_type_structure_create(); + assert(eh_ft); + eh_ts_ft = bt_field_type_integer_create(64); + assert(eh_ts_ft); + ret = bt_field_type_structure_add_field(eh_ft, eh_ts_ft, "ts"); + assert(ret == 0); + ret = bt_field_type_integer_set_mapped_clock_class(eh_ts_ft, + src_clock_class); + assert(ret == 0); + ret = bt_stream_class_set_event_header_field_type(src_stream_class, + eh_ft); assert(ret == 0); - ret = bt_stream_class_set_event_context_type(src_stream_class, + ret = bt_stream_class_set_event_context_field_type(src_stream_class, empty_struct_ft); assert(ret == 0); src_event_class = bt_event_class_create("my-event-class"); - ret = bt_event_class_set_context_type(src_event_class, + ret = bt_event_class_set_context_field_type(src_event_class, empty_struct_ft); assert(ret == 0); - ret = bt_event_class_set_context_type(src_event_class, + ret = bt_event_class_set_context_field_type(src_event_class, empty_struct_ft); assert(ret == 0); ret = bt_stream_class_add_event_class(src_stream_class, @@ -341,22 +365,22 @@ void init_static_data(void) assert(ret == 0); ret = bt_trace_add_stream_class(trace, src_stream_class); assert(ret == 0); - stream = bt_stream_create(src_stream_class, "stream0"); + stream = bt_stream_create(src_stream_class, "stream0", 0); assert(stream); src_packet0 = bt_packet_create(stream); assert(src_packet0); bt_put(stream); - stream = bt_stream_create(src_stream_class, "stream1"); + stream = bt_stream_create(src_stream_class, "stream1", 1); assert(stream); src_packet1 = bt_packet_create(stream); assert(src_packet0); bt_put(stream); - stream = bt_stream_create(src_stream_class, "stream2"); + stream = bt_stream_create(src_stream_class, "stream2", 2); assert(stream); src_packet2 = bt_packet_create(stream); assert(src_packet0); bt_put(stream); - stream = bt_stream_create(src_stream_class, "stream3"); + stream = bt_stream_create(src_stream_class, "stream3", 3); assert(stream); src_packet3 = bt_packet_create(stream); assert(src_packet0); @@ -364,6 +388,8 @@ void init_static_data(void) bt_put(trace); bt_put(empty_struct_ft); + bt_put(eh_ft); + bt_put(eh_ts_ft); } static @@ -404,7 +430,7 @@ enum bt_notification_iterator_status src_iter_init( { struct src_iter_user_data *user_data = g_new0(struct src_iter_user_data, 1); - struct bt_port *port = bt_port_from_private(private_port); + struct bt_port *port = bt_port_borrow_from_private(private_port); const char *port_name; int ret; @@ -416,7 +442,6 @@ enum bt_notification_iterator_status src_iter_init( port_name = bt_port_get_name(port); assert(port_name); user_data->iter_index = port_name[3] - '0'; - bt_put(port); switch (user_data->iter_index) { case 0: @@ -481,28 +506,31 @@ enum bt_notification_iterator_status src_iter_init( } static -struct bt_event *src_create_event(struct bt_packet *packet, - int64_t ts_ns) +struct bt_notification *src_create_event_notif(struct bt_packet *packet, + struct bt_clock_class_priority_map *cc_prio_map, int64_t ts_ns) { - struct bt_event *event = bt_event_create(src_event_class); int ret; - + struct bt_event *event; + struct bt_notification *notif; + struct bt_clock_value *clock_value; + struct bt_field *field; + + notif = bt_notification_event_create(graph, src_event_class, + packet, cc_prio_map); + assert(notif); + event = bt_notification_event_borrow_event(notif); assert(event); - ret = bt_event_set_packet(event, packet); + field = bt_event_borrow_header(event); + assert(field); + field = bt_field_structure_borrow_field_by_name(field, "ts"); + assert(field); + ret = bt_field_integer_unsigned_set_value(field, (uint64_t) ts_ns); assert(ret == 0); - - if (ts_ns != -1) { - struct bt_clock_value *clock_value; - - clock_value = bt_clock_value_create(src_clock_class, - (uint64_t) ts_ns); - assert(clock_value); - ret = bt_event_set_clock_value(event, clock_value); - assert(ret == 0); - bt_put(clock_value); - } - - return event; + clock_value = bt_event_borrow_clock_value(event, src_clock_class); + assert(clock_value); + ret = bt_clock_value_set_value(clock_value, (uint64_t) ts_ns); + assert(ret == 0); + return notif; } static @@ -513,6 +541,7 @@ struct bt_notification_iterator_next_method_return src_iter_next_seq( .status = BT_NOTIFICATION_ITERATOR_STATUS_OK, }; int64_t cur_ts_ns; + struct bt_stream *stream; assert(user_data->seq); cur_ts_ns = user_data->seq[user_data->at]; @@ -528,23 +557,34 @@ struct bt_notification_iterator_next_method_return src_iter_next_seq( break; case SEQ_PACKET_BEGIN: next_return.notification = - bt_notification_packet_begin_create(user_data->packet); + bt_notification_packet_begin_create(graph, + user_data->packet); assert(next_return.notification); break; case SEQ_PACKET_END: next_return.notification = - bt_notification_packet_end_create(user_data->packet); + bt_notification_packet_end_create(graph, + user_data->packet); assert(next_return.notification); break; + case SEQ_STREAM_BEGIN: + stream = bt_packet_get_stream(user_data->packet); + next_return.notification = + bt_notification_stream_begin_create(graph, stream); + assert(next_return.notification); + bt_put(stream); + break; + case SEQ_STREAM_END: + stream = bt_packet_get_stream(user_data->packet); + next_return.notification = + bt_notification_stream_end_create(graph, stream); + assert(next_return.notification); + bt_put(stream); + break; default: { - struct bt_event *event = src_create_event( - user_data->packet, cur_ts_ns); - - assert(event); - next_return.notification = bt_notification_event_create(event, - src_cc_prio_map); - bt_put(event); + next_return.notification = src_create_event_notif( + user_data->packet, src_cc_prio_map, cur_ts_ns); assert(next_return.notification); break; } @@ -569,6 +609,7 @@ struct bt_notification_iterator_next_method_return src_iter_next( bt_private_connection_private_notification_iterator_get_user_data(priv_iterator); struct bt_private_component *private_component = bt_private_connection_private_notification_iterator_get_private_component(priv_iterator); + struct bt_stream *stream; int ret; assert(user_data); @@ -578,20 +619,35 @@ struct bt_notification_iterator_next_method_return src_iter_next( case TEST_NO_TS: if (user_data->iter_index == 0) { if (user_data->at == 0) { + stream = bt_packet_get_stream(user_data->packet); + next_return.notification = + bt_notification_stream_begin_create( + graph, stream); + bt_put(stream); + assert(next_return.notification); + } else if (user_data->at == 1) { next_return.notification = bt_notification_packet_begin_create( - user_data->packet); + graph, user_data->packet); assert(next_return.notification); - } else if (user_data->at < 6) { - struct bt_event *event = src_create_event( - user_data->packet, -1); - - assert(event); + } else if (user_data->at < 7) { next_return.notification = - bt_notification_event_create(event, - src_empty_cc_prio_map); + src_create_event_notif( + user_data->packet, + src_empty_cc_prio_map, 0); + assert(next_return.notification); + } else if (user_data->at == 7) { + next_return.notification = + bt_notification_packet_end_create( + graph, user_data->packet); + assert(next_return.notification); + } else if (user_data->at == 8) { + stream = bt_packet_get_stream(user_data->packet); + next_return.notification = + bt_notification_stream_end_create( + graph, stream); + bt_put(stream); assert(next_return.notification); - bt_put(event); } else { next_return.status = BT_NOTIFICATION_ITERATOR_STATUS_END; @@ -745,33 +801,29 @@ enum bt_component_status sink_consume( test_event.type = TEST_EV_TYPE_NOTIF_EVENT; cc_prio_map = - bt_notification_event_get_clock_class_priority_map( + bt_notification_event_borrow_clock_class_priority_map( notification); assert(cc_prio_map); - event = bt_notification_event_get_event(notification); + event = bt_notification_event_borrow_event(notification); assert(event); if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map) > 0) { struct bt_clock_value *clock_value; struct bt_clock_class *clock_class = - bt_clock_class_priority_map_get_highest_priority_clock_class( + bt_clock_class_priority_map_borrow_highest_priority_clock_class( cc_prio_map); assert(clock_class); - clock_value = bt_event_get_clock_value(event, + clock_value = bt_event_borrow_clock_value(event, clock_class); assert(clock_value); ret = bt_clock_value_get_value_ns_from_epoch( clock_value, &test_event.ts_ns); assert(ret == 0); - bt_put(clock_value); - bt_put(clock_class); } else { test_event.ts_ns = -1; } - bt_put(cc_prio_map); - bt_put(event); break; } case BT_NOTIFICATION_TYPE_INACTIVITY: @@ -779,31 +831,28 @@ enum bt_component_status sink_consume( struct bt_clock_class_priority_map *cc_prio_map; test_event.type = TEST_EV_TYPE_NOTIF_INACTIVITY; - cc_prio_map = bt_notification_event_get_clock_class_priority_map( + cc_prio_map = bt_notification_inactivity_borrow_clock_class_priority_map( notification); assert(cc_prio_map); if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map) > 0) { struct bt_clock_value *clock_value; struct bt_clock_class *clock_class = - bt_clock_class_priority_map_get_highest_priority_clock_class( + bt_clock_class_priority_map_borrow_highest_priority_clock_class( cc_prio_map); assert(clock_class); clock_value = - bt_notification_inactivity_get_clock_value( + bt_notification_inactivity_borrow_clock_value( notification, clock_class); assert(clock_value); ret = bt_clock_value_get_value_ns_from_epoch( clock_value, &test_event.ts_ns); assert(ret == 0); - bt_put(clock_value); - bt_put(clock_class); } else { test_event.ts_ns = -1; } - bt_put(cc_prio_map); break; } case BT_NOTIFICATION_TYPE_PACKET_BEGIN: @@ -846,7 +895,7 @@ void sink_port_connected(struct bt_private_component *private_component, assert(user_data); assert(priv_conn); conn_status = bt_private_connection_create_notification_iterator( - priv_conn, NULL, &user_data->notif_iter); + priv_conn, &user_data->notif_iter); assert(conn_status == 0); bt_put(priv_conn); } @@ -944,7 +993,6 @@ void do_std_test(enum test test, const char *name, struct bt_component *sink_comp; struct bt_port *upstream_port; struct bt_port *downstream_port; - struct bt_graph *graph; int64_t i; int64_t count; enum bt_graph_status graph_status = BT_GRAPH_STATUS_OK; @@ -952,6 +1000,7 @@ void do_std_test(enum test test, const char *name, clear_test_events(); current_test = test; diag("test: %s", name); + assert(!graph); graph = bt_graph_create(); assert(graph); create_source_muxer_sink(graph, &src_comp, &muxer_comp, &sink_comp); @@ -1000,7 +1049,7 @@ void do_std_test(enum test test, const char *name, bt_put(src_comp); bt_put(muxer_comp); bt_put(sink_comp); - bt_put(graph); + BT_PUT(graph); } static @@ -1359,7 +1408,6 @@ void test_single_end_then_multiple_full(void) struct bt_component *sink_comp; struct bt_port *upstream_port; struct bt_port *downstream_port; - struct bt_graph *graph; int64_t i; int64_t count; int ret; @@ -1426,6 +1474,7 @@ void test_single_end_then_multiple_full(void) clear_test_events(); current_test = TEST_SINGLE_END_THEN_MULTIPLE_FULL; diag("test: single end then multiple full"); + assert(!graph); graph = bt_graph_create(); assert(graph); create_source_muxer_sink(graph, &src_comp, &muxer_comp, &sink_comp); @@ -1475,7 +1524,7 @@ void test_single_end_then_multiple_full(void) bt_put(src_comp); bt_put(muxer_comp); bt_put(sink_comp); - bt_put(graph); + BT_PUT(graph); } static @@ -1486,7 +1535,6 @@ void test_single_again_end_then_multiple_full(void) struct bt_component *sink_comp; struct bt_port *upstream_port; struct bt_port *downstream_port; - struct bt_graph *graph; int64_t i; int64_t count; int ret; @@ -1554,6 +1602,7 @@ void test_single_again_end_then_multiple_full(void) clear_test_events(); current_test = TEST_SINGLE_AGAIN_END_THEN_MULTIPLE_FULL; diag("test: single again then end then multiple full"); + assert(!graph); graph = bt_graph_create(); assert(graph); create_source_muxer_sink(graph, &src_comp, &muxer_comp, &sink_comp); @@ -1603,7 +1652,7 @@ void test_single_again_end_then_multiple_full(void) bt_put(src_comp); bt_put(muxer_comp); bt_put(sink_comp); - bt_put(graph); + BT_PUT(graph); } #define DEBUG_ENV_VAR "TEST_UTILS_MUXER_DEBUG"