From 25583cd07e351a64d645978905be94227355f0e5 Mon Sep 17 00:00:00 2001 From: Philippe Proulx Date: Tue, 5 Jun 2018 17:53:32 -0400 Subject: [PATCH] tests: use BT_ASSERT() instead of assert() This is more desirable because BT_ASSERT() "uses" the condition without evaluating it to avoid unused variable compiler warnings. Signed-off-by: Philippe Proulx --- tests/lib/test-plugin-plugins/sfs.c | 9 +- tests/lib/test_bt_ctf_field_type_validation.c | 1220 ++++++++--------- tests/lib/test_bt_notification_iterator.c | 152 +- tests/lib/test_bt_values.c | 102 +- tests/lib/test_cc_prio_map.c | 26 +- tests/lib/test_ctf_ir_ref.c | 74 +- tests/lib/test_ctf_writer.c | 66 +- tests/lib/test_graph_topo.c | 98 +- tests/lib/test_ir_visit.c | 30 +- tests/lib/test_plugin.c | 26 +- tests/plugins/test-utils-muxer.c | 246 ++-- tests/utils/tap/tap.c | 6 +- 12 files changed, 1028 insertions(+), 1027 deletions(-) diff --git a/tests/lib/test-plugin-plugins/sfs.c b/tests/lib/test-plugin-plugins/sfs.c index f3f4e192..f9d52130 100644 --- a/tests/lib/test-plugin-plugins/sfs.c +++ b/tests/lib/test-plugin-plugins/sfs.c @@ -19,7 +19,8 @@ #include #include #include -#include +#include +#include static enum bt_component_status sink_consume( struct bt_private_component *private_component) @@ -61,11 +62,11 @@ static struct bt_component_class_query_method_return query_method( }; int iret; - assert(ret.result); + BT_ASSERT(ret.result); iret = bt_value_array_append_string(ret.result, object); - assert(iret == 0); + BT_ASSERT(iret == 0); iret = bt_value_array_append(ret.result, params); - assert(iret == 0); + BT_ASSERT(iret == 0); return ret; } diff --git a/tests/lib/test_bt_ctf_field_type_validation.c b/tests/lib/test_bt_ctf_field_type_validation.c index f88cecd5..b31b6197 100644 --- a/tests/lib/test_bt_ctf_field_type_validation.c +++ b/tests/lib/test_bt_ctf_field_type_validation.c @@ -26,7 +26,7 @@ #include #include #include -#include +#include #include #include #include @@ -138,191 +138,191 @@ struct bt_field_type *get_good_packet_header_field_type(void) int ret; root = bt_field_type_structure_create(); - assert(root); + BT_ASSERT(root); ret = bt_field_type_set_alignment(root, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_magic = bt_field_type_integer_create(32); - assert(root_magic); + BT_ASSERT(root_magic); ret = bt_field_type_integer_set_is_signed(root_magic, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_magic, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_magic, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_magic, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_magic, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_magic, "magic"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_uuid_elem = bt_field_type_integer_create(8); - assert(root_uuid_elem); + BT_ASSERT(root_uuid_elem); ret = bt_field_type_integer_set_is_signed(root_uuid_elem, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_uuid_elem, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_uuid_elem, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_uuid_elem, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_uuid_elem, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_uuid = bt_field_type_array_create(root_uuid_elem, 16); - assert(root_uuid); + BT_ASSERT(root_uuid); ret = bt_field_type_structure_add_field(root, root_uuid, "uuid"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_stream_id = bt_field_type_integer_create(32); - assert(root_stream_id); + BT_ASSERT(root_stream_id); ret = bt_field_type_integer_set_is_signed(root_stream_id, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_stream_id, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_stream_id, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_stream_id, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_stream_id, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_stream_id, "stream_id"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_iron = bt_field_type_structure_create(); - assert(root_iron); + BT_ASSERT(root_iron); ret = bt_field_type_set_alignment(root_iron, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_iron_listen = bt_field_type_string_create(); - assert(root_iron_listen); + BT_ASSERT(root_iron_listen); ret = bt_field_type_string_set_encoding(root_iron_listen, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root_iron, root_iron_listen, "listen"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_iron_dust = bt_field_type_integer_create(23); - assert(root_iron_dust); + BT_ASSERT(root_iron_dust); ret = bt_field_type_integer_set_is_signed(root_iron_dust, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_iron_dust, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_iron_dust, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_iron_dust, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_iron_dust, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root_iron, root_iron_dust, "dust"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_iron_parallel_int = bt_field_type_integer_create(10); - assert(root_iron_parallel_int); + BT_ASSERT(root_iron_parallel_int); ret = bt_field_type_integer_set_is_signed(root_iron_parallel_int, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_iron_parallel_int, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_iron_parallel_int, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_iron_parallel_int, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_iron_parallel_int, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); root_iron_parallel = bt_field_type_enumeration_create(root_iron_parallel_int); - assert(root_iron_parallel); + BT_ASSERT(root_iron_parallel); ret = bt_field_type_enumeration_unsigned_add_mapping(root_iron_parallel, "RED", 0, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_enumeration_unsigned_add_mapping(root_iron_parallel, "BLUE", 1, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_enumeration_unsigned_add_mapping(root_iron_parallel, "YELLOW", 2, 2); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root_iron, root_iron_parallel, "parallel"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_iron_fire = bt_field_type_structure_create(); - assert(root_iron_fire); + BT_ASSERT(root_iron_fire); ret = bt_field_type_set_alignment(root_iron_fire, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_iron_fire_word = bt_field_type_integer_create(17); - assert(root_iron_fire_word); + BT_ASSERT(root_iron_fire_word); ret = bt_field_type_integer_set_is_signed(root_iron_fire_word, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_iron_fire_word, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_iron_fire_word, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_iron_fire_word, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_iron_fire_word, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root_iron_fire, root_iron_fire_word, "word"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_iron_fire_rabbit = bt_field_type_string_create(); - assert(root_iron_fire_rabbit); + BT_ASSERT(root_iron_fire_rabbit); ret = bt_field_type_string_set_encoding(root_iron_fire_rabbit, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root_iron_fire, root_iron_fire_rabbit, "rabbit"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_iron_fire_keen_elem = bt_field_type_variant_create(NULL, "iron.parallel"); - assert(root_iron_fire_keen_elem); + BT_ASSERT(root_iron_fire_keen_elem); root_iron_fire_keen_elem_RED = bt_field_type_string_create(); - assert(root_iron_fire_keen_elem_RED); + BT_ASSERT(root_iron_fire_keen_elem_RED); ret = bt_field_type_string_set_encoding(root_iron_fire_keen_elem_RED, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_variant_add_field(root_iron_fire_keen_elem, root_iron_fire_keen_elem_RED, "RED"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_iron_fire_keen_elem_BLUE_elem = bt_field_type_integer_create(5); - assert(root_iron_fire_keen_elem_BLUE_elem); + BT_ASSERT(root_iron_fire_keen_elem_BLUE_elem); ret = bt_field_type_integer_set_is_signed(root_iron_fire_keen_elem_BLUE_elem, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_iron_fire_keen_elem_BLUE_elem, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_iron_fire_keen_elem_BLUE_elem, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_iron_fire_keen_elem_BLUE_elem, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_iron_fire_keen_elem_BLUE_elem, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); root_iron_fire_keen_elem_BLUE = bt_field_type_sequence_create(root_iron_fire_keen_elem_BLUE_elem, "magic"); - assert(root_iron_fire_keen_elem_BLUE); + BT_ASSERT(root_iron_fire_keen_elem_BLUE); ret = bt_field_type_variant_add_field(root_iron_fire_keen_elem, root_iron_fire_keen_elem_BLUE, "BLUE"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_iron_fire_keen_elem_YELLOW = bt_field_type_structure_create(); - assert(root_iron_fire_keen_elem_YELLOW); + BT_ASSERT(root_iron_fire_keen_elem_YELLOW); ret = bt_field_type_set_alignment(root_iron_fire_keen_elem_YELLOW, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_variant_add_field(root_iron_fire_keen_elem, root_iron_fire_keen_elem_YELLOW, "YELLOW"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_iron_fire_keen = bt_field_type_sequence_create(root_iron_fire_keen_elem, "word"); - assert(root_iron_fire_keen); + BT_ASSERT(root_iron_fire_keen); ret = bt_field_type_structure_add_field(root_iron_fire, root_iron_fire_keen, "keen"); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root_iron, root_iron_fire, "fire"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_iron_report_elem = bt_field_type_string_create(); - assert(root_iron_report_elem); + BT_ASSERT(root_iron_report_elem); ret = bt_field_type_string_set_encoding(root_iron_report_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_iron_report = bt_field_type_sequence_create(root_iron_report_elem, "trace.packet.header.iron.dust"); - assert(root_iron_report); + BT_ASSERT(root_iron_report); ret = bt_field_type_structure_add_field(root_iron, root_iron_report, "report"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_iron_group_elem = bt_field_type_string_create(); - assert(root_iron_group_elem); + BT_ASSERT(root_iron_group_elem); ret = bt_field_type_string_set_encoding(root_iron_group_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_iron_group = bt_field_type_sequence_create(root_iron_group_elem, "trace.packet.header.stream_id"); - assert(root_iron_group); + BT_ASSERT(root_iron_group); ret = bt_field_type_structure_add_field(root_iron, root_iron_group, "group"); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_iron, "iron"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_serious = bt_field_type_integer_create(1); - assert(root_serious); + BT_ASSERT(root_serious); ret = bt_field_type_integer_set_is_signed(root_serious, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_serious, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_serious, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_serious, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_serious, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_serious, "serious"); - assert(ret == 0); + BT_ASSERT(ret == 0); BT_PUT(root_magic); BT_PUT(root_uuid); @@ -444,163 +444,163 @@ struct bt_field_type *get_good_packet_context_field_type(void) int ret; root = bt_field_type_structure_create(); - assert(root); + BT_ASSERT(root); ret = bt_field_type_set_alignment(root, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_placid = bt_field_type_integer_create(32); - assert(root_placid); + BT_ASSERT(root_placid); ret = bt_field_type_integer_set_is_signed(root_placid, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_placid, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_placid, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_placid, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_placid, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_placid, "placid"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_meow = bt_field_type_string_create(); - assert(root_meow); + BT_ASSERT(root_meow); ret = bt_field_type_string_set_encoding(root_meow, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_meow, "meow"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_serious = bt_field_type_integer_create(11); - assert(root_serious); + BT_ASSERT(root_serious); ret = bt_field_type_integer_set_is_signed(root_serious, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_serious, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_serious, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_serious, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_serious, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_serious, "serious"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_naive_elem_elem = bt_field_type_string_create(); - assert(root_naive_elem_elem); + BT_ASSERT(root_naive_elem_elem); ret = bt_field_type_string_set_encoding(root_naive_elem_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_naive_elem = bt_field_type_sequence_create(root_naive_elem_elem, "placid"); - assert(root_naive_elem); + BT_ASSERT(root_naive_elem); root_naive = bt_field_type_array_create(root_naive_elem, 17); - assert(root_naive); + BT_ASSERT(root_naive); ret = bt_field_type_structure_add_field(root, root_naive, "naive"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_clover = bt_field_type_structure_create(); - assert(root_clover); + BT_ASSERT(root_clover); ret = bt_field_type_set_alignment(root_clover, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); root_clover_oval = bt_field_type_integer_create(17); - assert(root_clover_oval); + BT_ASSERT(root_clover_oval); ret = bt_field_type_integer_set_is_signed(root_clover_oval, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_clover_oval, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_clover_oval, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_clover_oval, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_clover_oval, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root_clover, root_clover_oval, "oval"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_clover_whole = bt_field_type_variant_create(NULL, "iron.parallel"); - assert(root_clover_whole); + BT_ASSERT(root_clover_whole); root_clover_whole_BLUE_elem = bt_field_type_string_create(); - assert(root_clover_whole_BLUE_elem); + BT_ASSERT(root_clover_whole_BLUE_elem); ret = bt_field_type_string_set_encoding(root_clover_whole_BLUE_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_clover_whole_BLUE = bt_field_type_sequence_create(root_clover_whole_BLUE_elem, "trace.packet.header.iron.fire.word"); - assert(root_clover_whole_BLUE); + BT_ASSERT(root_clover_whole_BLUE); ret = bt_field_type_variant_add_field(root_clover_whole, root_clover_whole_BLUE, "BLUE"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_clover_whole_RED = bt_field_type_integer_create(44); - assert(root_clover_whole_RED); + BT_ASSERT(root_clover_whole_RED); ret = bt_field_type_integer_set_is_signed(root_clover_whole_RED, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_clover_whole_RED, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_clover_whole_RED, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_clover_whole_RED, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_clover_whole_RED, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_variant_add_field(root_clover_whole, root_clover_whole_RED, "RED"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_clover_whole_YELLOW = bt_field_type_string_create(); - assert(root_clover_whole_YELLOW); + BT_ASSERT(root_clover_whole_YELLOW); ret = bt_field_type_string_set_encoding(root_clover_whole_YELLOW, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_variant_add_field(root_clover_whole, root_clover_whole_YELLOW, "YELLOW"); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root_clover, root_clover_whole, "whole"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_clover_egg_elem = bt_field_type_integer_create(55); - assert(root_clover_egg_elem); + BT_ASSERT(root_clover_egg_elem); ret = bt_field_type_integer_set_is_signed(root_clover_egg_elem, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_clover_egg_elem, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_clover_egg_elem, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_clover_egg_elem, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_clover_egg_elem, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); root_clover_egg = bt_field_type_sequence_create(root_clover_egg_elem, "stream.packet.context.clover.oval"); - assert(root_clover_egg); + BT_ASSERT(root_clover_egg); ret = bt_field_type_structure_add_field(root_clover, root_clover_egg, "egg"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_clover_square_int = bt_field_type_integer_create(12); - assert(root_clover_square_int); + BT_ASSERT(root_clover_square_int); ret = bt_field_type_integer_set_is_signed(root_clover_square_int, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_clover_square_int, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_clover_square_int, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_clover_square_int, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_clover_square_int, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); root_clover_square = bt_field_type_enumeration_create(root_clover_square_int); - assert(root_clover_square); + BT_ASSERT(root_clover_square); ret = bt_field_type_enumeration_unsigned_add_mapping(root_clover_square, "YOUNG", 0, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_enumeration_unsigned_add_mapping(root_clover_square, "OLD", 1, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root_clover, root_clover_square, "square"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_clover_useful_elem = bt_field_type_integer_create(2); - assert(root_clover_useful_elem); + BT_ASSERT(root_clover_useful_elem); ret = bt_field_type_integer_set_is_signed(root_clover_useful_elem, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_clover_useful_elem, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_clover_useful_elem, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_clover_useful_elem, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_clover_useful_elem, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); root_clover_useful = bt_field_type_sequence_create(root_clover_useful_elem, "serious"); - assert(root_clover_useful); + BT_ASSERT(root_clover_useful); ret = bt_field_type_structure_add_field(root_clover, root_clover_useful, "useful"); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_clover, "clover"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_tart = bt_field_type_string_create(); - assert(root_tart); + BT_ASSERT(root_tart); ret = bt_field_type_string_set_encoding(root_tart, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_tart, "tart"); - assert(ret == 0); + BT_ASSERT(ret == 0); BT_PUT(root_placid); BT_PUT(root_meow); @@ -695,117 +695,117 @@ struct bt_field_type *get_good_event_header_field_type(void) int ret; root = bt_field_type_structure_create(); - assert(root); + BT_ASSERT(root); ret = bt_field_type_set_alignment(root, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_id = bt_field_type_integer_create(17); - assert(root_id); + BT_ASSERT(root_id); ret = bt_field_type_integer_set_is_signed(root_id, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_id, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_id, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_id, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_id, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_id, "id"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_timestamp = bt_field_type_integer_create(64); - assert(root_timestamp); + BT_ASSERT(root_timestamp); ret = bt_field_type_integer_set_is_signed(root_timestamp, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_timestamp, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_timestamp, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_timestamp, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_timestamp, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_timestamp, "timestamp"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_action = bt_field_type_structure_create(); - assert(root_action); + BT_ASSERT(root_action); ret = bt_field_type_set_alignment(root_action, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_action_special = bt_field_type_integer_create(17); - assert(root_action_special); + BT_ASSERT(root_action_special); ret = bt_field_type_integer_set_is_signed(root_action_special, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_action_special, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_action_special, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_action_special, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_action_special, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root_action, root_action_special, "special"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_action_lucky_elem = bt_field_type_string_create(); - assert(root_action_lucky_elem); + BT_ASSERT(root_action_lucky_elem); ret = bt_field_type_string_set_encoding(root_action_lucky_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_action_lucky = bt_field_type_sequence_create(root_action_lucky_elem, "stream.packet.context.placid"); - assert(root_action_lucky); + BT_ASSERT(root_action_lucky); ret = bt_field_type_structure_add_field(root_action, root_action_lucky, "lucky"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_action_dream = bt_field_type_string_create(); - assert(root_action_dream); + BT_ASSERT(root_action_dream); ret = bt_field_type_string_set_encoding(root_action_dream, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root_action, root_action_dream, "dream"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_action_grandiose_elem = bt_field_type_integer_create(3); - assert(root_action_grandiose_elem); + BT_ASSERT(root_action_grandiose_elem); ret = bt_field_type_integer_set_is_signed(root_action_grandiose_elem, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_action_grandiose_elem, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_action_grandiose_elem, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_action_grandiose_elem, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_action_grandiose_elem, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); root_action_grandiose = bt_field_type_sequence_create(root_action_grandiose_elem, "trace.packet.header.serious"); - assert(root_action_grandiose); + BT_ASSERT(root_action_grandiose); ret = bt_field_type_structure_add_field(root_action, root_action_grandiose, "grandiose"); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_action, "action"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_stiff_elem = bt_field_type_string_create(); - assert(root_stiff_elem); + BT_ASSERT(root_stiff_elem); ret = bt_field_type_string_set_encoding(root_stiff_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_stiff = bt_field_type_sequence_create(root_stiff_elem, "clover.whole.RED"); - assert(root_stiff); + BT_ASSERT(root_stiff); ret = bt_field_type_structure_add_field(root, root_stiff, "stiff"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_fruit = bt_field_type_structure_create(); - assert(root_fruit); + BT_ASSERT(root_fruit); ret = bt_field_type_set_alignment(root_fruit, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); root_fruit_apple_elem = bt_field_type_integer_create(5); - assert(root_fruit_apple_elem); + BT_ASSERT(root_fruit_apple_elem); ret = bt_field_type_integer_set_is_signed(root_fruit_apple_elem, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_fruit_apple_elem, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_fruit_apple_elem, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_fruit_apple_elem, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_fruit_apple_elem, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); root_fruit_apple = bt_field_type_sequence_create(root_fruit_apple_elem, "action.special"); - assert(root_fruit_apple); + BT_ASSERT(root_fruit_apple); ret = bt_field_type_structure_add_field(root_fruit, root_fruit_apple, "apple"); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_fruit, "fruit"); - assert(ret == 0); + BT_ASSERT(ret == 0); BT_PUT(root_id); BT_PUT(root_timestamp); @@ -892,93 +892,93 @@ struct bt_field_type *get_good_stream_event_context_field_type(void) int ret; root = bt_field_type_structure_create(); - assert(root); + BT_ASSERT(root); ret = bt_field_type_set_alignment(root, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_face = bt_field_type_structure_create(); - assert(root_face); + BT_ASSERT(root_face); ret = bt_field_type_set_alignment(root_face, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_face_branch_elem = bt_field_type_string_create(); - assert(root_face_branch_elem); + BT_ASSERT(root_face_branch_elem); ret = bt_field_type_string_set_encoding(root_face_branch_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_face_branch = bt_field_type_sequence_create(root_face_branch_elem, "serious"); - assert(root_face_branch); + BT_ASSERT(root_face_branch); ret = bt_field_type_structure_add_field(root_face, root_face_branch, "branch"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_face_income_elem = bt_field_type_string_create(); - assert(root_face_income_elem); + BT_ASSERT(root_face_income_elem); ret = bt_field_type_string_set_encoding(root_face_income_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_face_income = bt_field_type_sequence_create(root_face_income_elem, "magic"); - assert(root_face_income); + BT_ASSERT(root_face_income); ret = bt_field_type_structure_add_field(root_face, root_face_income, "income"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_face_magic = bt_field_type_integer_create(23); - assert(root_face_magic); + BT_ASSERT(root_face_magic); ret = bt_field_type_integer_set_is_signed(root_face_magic, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_face_magic, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_face_magic, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_face_magic, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_face_magic, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root_face, root_face_magic, "magic"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_face_lucky_elem = bt_field_type_string_create(); - assert(root_face_lucky_elem); + BT_ASSERT(root_face_lucky_elem); ret = bt_field_type_string_set_encoding(root_face_lucky_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_face_lucky = bt_field_type_sequence_create(root_face_lucky_elem, "magic"); - assert(root_face_lucky); + BT_ASSERT(root_face_lucky); ret = bt_field_type_structure_add_field(root_face, root_face_lucky, "lucky"); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_face, "face"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_cats = bt_field_type_integer_create(5); - assert(root_cats); + BT_ASSERT(root_cats); ret = bt_field_type_integer_set_is_signed(root_cats, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_cats, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_cats, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_cats, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_cats, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_cats, "cats"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_dream_elem_elem_elem = bt_field_type_string_create(); - assert(root_dream_elem_elem_elem); + BT_ASSERT(root_dream_elem_elem_elem); ret = bt_field_type_string_set_encoding(root_dream_elem_elem_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_dream_elem_elem = bt_field_type_sequence_create(root_dream_elem_elem_elem, "stream.event.context.face.magic"); - assert(root_dream_elem_elem); + BT_ASSERT(root_dream_elem_elem); root_dream_elem = bt_field_type_sequence_create(root_dream_elem_elem, "trace.packet.header.iron.dust"); - assert(root_dream_elem); + BT_ASSERT(root_dream_elem); root_dream = bt_field_type_sequence_create(root_dream_elem, "stream.packet.context.placid"); - assert(root_dream); + BT_ASSERT(root_dream); ret = bt_field_type_structure_add_field(root, root_dream, "dream"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_stream_id = bt_field_type_integer_create(9); - assert(root_stream_id); + BT_ASSERT(root_stream_id); ret = bt_field_type_integer_set_is_signed(root_stream_id, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_stream_id, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_stream_id, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_stream_id, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_stream_id, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_stream_id, "stream_id"); - assert(ret == 0); + BT_ASSERT(ret == 0); BT_PUT(root_face); BT_PUT(root_face_branch); @@ -1110,151 +1110,151 @@ struct bt_field_type *get_good_event_context_field_type(void) int ret; root = bt_field_type_structure_create(); - assert(root); + BT_ASSERT(root); ret = bt_field_type_set_alignment(root, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_film = bt_field_type_integer_create(19); - assert(root_film); + BT_ASSERT(root_film); ret = bt_field_type_integer_set_is_signed(root_film, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_film, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_film, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_film, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_film, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_film, "film"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_berry = bt_field_type_structure_create(); - assert(root_berry); + BT_ASSERT(root_berry); ret = bt_field_type_set_alignment(root_berry, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_berry_pine_elem = bt_field_type_string_create(); - assert(root_berry_pine_elem); + BT_ASSERT(root_berry_pine_elem); ret = bt_field_type_string_set_encoding(root_berry_pine_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_berry_pine = bt_field_type_sequence_create(root_berry_pine_elem, "stream_id"); - assert(root_berry_pine); + BT_ASSERT(root_berry_pine); ret = bt_field_type_structure_add_field(root_berry, root_berry_pine, "pine"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_berry_porter_elem = bt_field_type_string_create(); - assert(root_berry_porter_elem); + BT_ASSERT(root_berry_porter_elem); ret = bt_field_type_string_set_encoding(root_berry_porter_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_berry_porter = bt_field_type_sequence_create(root_berry_porter_elem, "face.magic"); - assert(root_berry_porter); + BT_ASSERT(root_berry_porter); ret = bt_field_type_structure_add_field(root_berry, root_berry_porter, "porter"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_berry_mice_elem = bt_field_type_string_create(); - assert(root_berry_mice_elem); + BT_ASSERT(root_berry_mice_elem); ret = bt_field_type_string_set_encoding(root_berry_mice_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_berry_mice = bt_field_type_sequence_create(root_berry_mice_elem, "action.special"); - assert(root_berry_mice); + BT_ASSERT(root_berry_mice); ret = bt_field_type_structure_add_field(root_berry, root_berry_mice, "mice"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_berry_third = bt_field_type_integer_create(18); - assert(root_berry_third); + BT_ASSERT(root_berry_third); ret = bt_field_type_integer_set_is_signed(root_berry_third, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_berry_third, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_berry_third, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_berry_third, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_berry_third, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root_berry, root_berry_third, "third"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_berry_guard_elem = bt_field_type_string_create(); - assert(root_berry_guard_elem); + BT_ASSERT(root_berry_guard_elem); ret = bt_field_type_string_set_encoding(root_berry_guard_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_berry_guard = bt_field_type_sequence_create(root_berry_guard_elem, "clover.oval"); - assert(root_berry_guard); + BT_ASSERT(root_berry_guard); ret = bt_field_type_structure_add_field(root_berry, root_berry_guard, "guard"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_berry_one_elem = bt_field_type_string_create(); - assert(root_berry_one_elem); + BT_ASSERT(root_berry_one_elem); ret = bt_field_type_string_set_encoding(root_berry_one_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_berry_one = bt_field_type_sequence_create(root_berry_one_elem, "iron.fire.word"); - assert(root_berry_one); + BT_ASSERT(root_berry_one); ret = bt_field_type_structure_add_field(root_berry, root_berry_one, "one"); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_berry, "berry"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_cats = bt_field_type_integer_create(55); - assert(root_cats); + BT_ASSERT(root_cats); ret = bt_field_type_integer_set_is_signed(root_cats, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_cats, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_cats, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_cats, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_cats, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_cats, "cats"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_loud = bt_field_type_structure_create(); - assert(root_loud); + BT_ASSERT(root_loud); ret = bt_field_type_set_alignment(root_loud, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_loud_toys_elem = bt_field_type_string_create(); - assert(root_loud_toys_elem); + BT_ASSERT(root_loud_toys_elem); ret = bt_field_type_string_set_encoding(root_loud_toys_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_loud_toys = bt_field_type_sequence_create(root_loud_toys_elem, "trace.packet.header.iron.fire.word"); - assert(root_loud_toys); + BT_ASSERT(root_loud_toys); ret = bt_field_type_structure_add_field(root_loud, root_loud_toys, "toys"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_loud_spoon_elem = bt_field_type_string_create(); - assert(root_loud_spoon_elem); + BT_ASSERT(root_loud_spoon_elem); ret = bt_field_type_string_set_encoding(root_loud_spoon_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_loud_spoon = bt_field_type_sequence_create(root_loud_spoon_elem, "stream.packet.context.clover.oval"); - assert(root_loud_spoon); + BT_ASSERT(root_loud_spoon); ret = bt_field_type_structure_add_field(root_loud, root_loud_spoon, "spoon"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_loud_turkey_elem = bt_field_type_string_create(); - assert(root_loud_turkey_elem); + BT_ASSERT(root_loud_turkey_elem); ret = bt_field_type_string_set_encoding(root_loud_turkey_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_loud_turkey = bt_field_type_sequence_create(root_loud_turkey_elem, "stream.event.header.action.special"); - assert(root_loud_turkey); + BT_ASSERT(root_loud_turkey); ret = bt_field_type_structure_add_field(root_loud, root_loud_turkey, "turkey"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_loud_inform_elem = bt_field_type_string_create(); - assert(root_loud_inform_elem); + BT_ASSERT(root_loud_inform_elem); ret = bt_field_type_string_set_encoding(root_loud_inform_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_loud_inform = bt_field_type_sequence_create(root_loud_inform_elem, "stream.event.context.face.magic"); - assert(root_loud_inform); + BT_ASSERT(root_loud_inform); ret = bt_field_type_structure_add_field(root_loud, root_loud_inform, "inform"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_loud_odd_elem = bt_field_type_string_create(); - assert(root_loud_odd_elem); + BT_ASSERT(root_loud_odd_elem); ret = bt_field_type_string_set_encoding(root_loud_odd_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_loud_odd = bt_field_type_sequence_create(root_loud_odd_elem, "berry.third"); - assert(root_loud_odd); + BT_ASSERT(root_loud_odd); ret = bt_field_type_structure_add_field(root_loud, root_loud_odd, "odd"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_loud_amuck_elem = bt_field_type_string_create(); - assert(root_loud_amuck_elem); + BT_ASSERT(root_loud_amuck_elem); ret = bt_field_type_string_set_encoding(root_loud_amuck_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_loud_amuck = bt_field_type_sequence_create(root_loud_amuck_elem, "event.context.film"); - assert(root_loud_amuck); + BT_ASSERT(root_loud_amuck); ret = bt_field_type_structure_add_field(root_loud, root_loud_amuck, "amuck"); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_loud, "loud"); - assert(ret == 0); + BT_ASSERT(ret == 0); BT_PUT(root_film); BT_PUT(root_berry); @@ -1408,131 +1408,131 @@ struct bt_field_type *get_good_event_payload_field_type(void) int ret; root = bt_field_type_structure_create(); - assert(root); + BT_ASSERT(root); ret = bt_field_type_set_alignment(root, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_splendid = bt_field_type_integer_create(12); - assert(root_splendid); + BT_ASSERT(root_splendid); ret = bt_field_type_integer_set_is_signed(root_splendid, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_splendid, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_splendid, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_splendid, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_splendid, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_splendid, "splendid"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_relative = bt_field_type_structure_create(); - assert(root_relative); + BT_ASSERT(root_relative); ret = bt_field_type_set_alignment(root_relative, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_relative_equal_elem = bt_field_type_string_create(); - assert(root_relative_equal_elem); + BT_ASSERT(root_relative_equal_elem); ret = bt_field_type_string_set_encoding(root_relative_equal_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_relative_equal = bt_field_type_sequence_create(root_relative_equal_elem, "splendid"); - assert(root_relative_equal); + BT_ASSERT(root_relative_equal); ret = bt_field_type_structure_add_field(root_relative, root_relative_equal, "equal"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_relative_amuck_elem = bt_field_type_string_create(); - assert(root_relative_amuck_elem); + BT_ASSERT(root_relative_amuck_elem); ret = bt_field_type_string_set_encoding(root_relative_amuck_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_relative_amuck = bt_field_type_sequence_create(root_relative_amuck_elem, "id"); - assert(root_relative_amuck); + BT_ASSERT(root_relative_amuck); ret = bt_field_type_structure_add_field(root_relative, root_relative_amuck, "amuck"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_relative_push_elem = bt_field_type_string_create(); - assert(root_relative_push_elem); + BT_ASSERT(root_relative_push_elem); ret = bt_field_type_string_set_encoding(root_relative_push_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_relative_push = bt_field_type_sequence_create(root_relative_push_elem, "berry.third"); - assert(root_relative_push); + BT_ASSERT(root_relative_push); ret = bt_field_type_structure_add_field(root_relative, root_relative_push, "push"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_relative_brick_elem = bt_field_type_string_create(); - assert(root_relative_brick_elem); + BT_ASSERT(root_relative_brick_elem); ret = bt_field_type_string_set_encoding(root_relative_brick_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_relative_brick = bt_field_type_sequence_create(root_relative_brick_elem, "face.magic"); - assert(root_relative_brick); + BT_ASSERT(root_relative_brick); ret = bt_field_type_structure_add_field(root_relative, root_relative_brick, "brick"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_relative_crush_elem = bt_field_type_string_create(); - assert(root_relative_crush_elem); + BT_ASSERT(root_relative_crush_elem); ret = bt_field_type_string_set_encoding(root_relative_crush_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_relative_crush = bt_field_type_sequence_create(root_relative_crush_elem, "serious"); - assert(root_relative_crush); + BT_ASSERT(root_relative_crush); ret = bt_field_type_structure_add_field(root_relative, root_relative_crush, "crush"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_relative_canvas_elem = bt_field_type_string_create(); - assert(root_relative_canvas_elem); + BT_ASSERT(root_relative_canvas_elem); ret = bt_field_type_string_set_encoding(root_relative_canvas_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_relative_canvas = bt_field_type_sequence_create(root_relative_canvas_elem, "iron.dust"); - assert(root_relative_canvas); + BT_ASSERT(root_relative_canvas); ret = bt_field_type_structure_add_field(root_relative, root_relative_canvas, "canvas"); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_relative, "relative"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_absolute = bt_field_type_structure_create(); - assert(root_absolute); + BT_ASSERT(root_absolute); ret = bt_field_type_set_alignment(root_absolute, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_absolute_equal_elem = bt_field_type_string_create(); - assert(root_absolute_equal_elem); + BT_ASSERT(root_absolute_equal_elem); ret = bt_field_type_string_set_encoding(root_absolute_equal_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_absolute_equal = bt_field_type_sequence_create(root_absolute_equal_elem, "event.fields.splendid"); - assert(root_absolute_equal); + BT_ASSERT(root_absolute_equal); ret = bt_field_type_structure_add_field(root_absolute, root_absolute_equal, "equal"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_absolute_amuck_elem = bt_field_type_string_create(); - assert(root_absolute_amuck_elem); + BT_ASSERT(root_absolute_amuck_elem); ret = bt_field_type_string_set_encoding(root_absolute_amuck_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_absolute_amuck = bt_field_type_sequence_create(root_absolute_amuck_elem, "stream.event.header.id"); - assert(root_absolute_amuck); + BT_ASSERT(root_absolute_amuck); ret = bt_field_type_structure_add_field(root_absolute, root_absolute_amuck, "amuck"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_absolute_push_elem = bt_field_type_string_create(); - assert(root_absolute_push_elem); + BT_ASSERT(root_absolute_push_elem); ret = bt_field_type_string_set_encoding(root_absolute_push_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_absolute_push = bt_field_type_sequence_create(root_absolute_push_elem, "event.context.berry.third"); - assert(root_absolute_push); + BT_ASSERT(root_absolute_push); ret = bt_field_type_structure_add_field(root_absolute, root_absolute_push, "push"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_absolute_brick_elem = bt_field_type_string_create(); - assert(root_absolute_brick_elem); + BT_ASSERT(root_absolute_brick_elem); ret = bt_field_type_string_set_encoding(root_absolute_brick_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_absolute_brick = bt_field_type_sequence_create(root_absolute_brick_elem, "stream.event.context.face.magic"); - assert(root_absolute_brick); + BT_ASSERT(root_absolute_brick); ret = bt_field_type_structure_add_field(root_absolute, root_absolute_brick, "brick"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_absolute_crush_elem = bt_field_type_string_create(); - assert(root_absolute_crush_elem); + BT_ASSERT(root_absolute_crush_elem); ret = bt_field_type_string_set_encoding(root_absolute_crush_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_absolute_crush = bt_field_type_sequence_create(root_absolute_crush_elem, "stream.packet.context.serious"); - assert(root_absolute_crush); + BT_ASSERT(root_absolute_crush); ret = bt_field_type_structure_add_field(root_absolute, root_absolute_crush, "crush"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_absolute_canvas_elem = bt_field_type_string_create(); - assert(root_absolute_canvas_elem); + BT_ASSERT(root_absolute_canvas_elem); ret = bt_field_type_string_set_encoding(root_absolute_canvas_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_absolute_canvas = bt_field_type_sequence_create(root_absolute_canvas_elem, "trace.packet.header.iron.dust"); - assert(root_absolute_canvas); + BT_ASSERT(root_absolute_canvas); ret = bt_field_type_structure_add_field(root_absolute, root_absolute_canvas, "canvas"); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_absolute, "absolute"); - assert(ret == 0); + BT_ASSERT(ret == 0); BT_PUT(root_splendid); BT_PUT(root_relative); @@ -1599,7 +1599,7 @@ struct bt_field_type *get_child_ft(struct bt_field_type *parent_ft, break; } - assert(ft); + BT_ASSERT(ft); return ft; } @@ -1720,9 +1720,9 @@ void validate_test_pass(struct bt_trace *trace) struct bt_field_type *ft_tag = NULL; sc = bt_trace_get_stream_class_by_index(trace, 0); - assert(sc); + BT_ASSERT(sc); ec = bt_stream_class_get_event_class_by_index(sc, 0); - assert(ec); + BT_ASSERT(ec); ph = bt_trace_get_packet_header_field_type(trace); ok(ph, "Trace packet header still exists after successful validation"); @@ -2070,40 +2070,40 @@ void test_pass(void) struct bt_field_type *ep; trace = bt_trace_create(); - assert(trace); + BT_ASSERT(trace); sc = bt_stream_class_create("nice_piece_of_stream_class"); - assert(sc); + BT_ASSERT(sc); ec = bt_event_class_create("oh_what_an_event_class"); - assert(ec); + BT_ASSERT(ec); ph = get_good_packet_header_field_type(); - assert(ph); + BT_ASSERT(ph); pc = get_good_packet_context_field_type(); - assert(pc); + BT_ASSERT(pc); eh = get_good_event_header_field_type(); - assert(eh); + BT_ASSERT(eh); sec = get_good_stream_event_context_field_type(); - assert(sec); + BT_ASSERT(sec); ectx = get_good_event_context_field_type(); - assert(ec); + BT_ASSERT(ec); ep = get_good_event_payload_field_type(); - assert(ep); + BT_ASSERT(ep); ret = bt_trace_set_packet_header_field_type(trace, ph); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_stream_class_set_packet_context_field_type(sc, pc); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_stream_class_set_event_header_field_type(sc, eh); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_stream_class_set_event_context_field_type(sc, sec); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_event_class_set_context_field_type(ec, ectx); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_event_class_set_payload_field_type(ec, ep); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_stream_class_add_event_class(sc, ec); - assert(ret == 0); + BT_ASSERT(ret == 0); /* Validation happens here */ ret = bt_trace_add_stream_class(trace, sc); @@ -2132,24 +2132,24 @@ int try_add_event_class_to_trace(struct bt_field_type *ectx, struct bt_event_class *ec; trace = bt_trace_create(); - assert(trace); + BT_ASSERT(trace); sc = bt_stream_class_create("sc"); - assert(sc); + BT_ASSERT(sc); ec = bt_event_class_create("ec"); - assert(ec); + BT_ASSERT(ec); if (ectx) { ret = bt_event_class_set_context_field_type(ec, ectx); - assert(ret == 0); + BT_ASSERT(ret == 0); } if (ep) { ret = bt_event_class_set_payload_field_type(ec, ep); - assert(ret == 0); + BT_ASSERT(ret == 0); } ret = bt_stream_class_add_event_class(sc, ec); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_trace_add_stream_class(trace, sc); BT_PUT(ec); BT_PUT(sc); @@ -2186,37 +2186,37 @@ struct bt_field_type *test_fail_unavailable_root_get_event_payload(void) int ret; root = bt_field_type_structure_create(); - assert(root); + BT_ASSERT(root); ret = bt_field_type_set_alignment(root, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_a = bt_field_type_integer_create(32); - assert(root_a); + BT_ASSERT(root_a); ret = bt_field_type_integer_set_is_signed(root_a, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_a, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_a, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_a, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_a, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_a, "a"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_b_elem = bt_field_type_string_create(); - assert(root_b_elem); + BT_ASSERT(root_b_elem); ret = bt_field_type_string_set_encoding(root_b_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_b = bt_field_type_sequence_create(root_b_elem, "stream.event.context.lol"); - assert(root_b); + BT_ASSERT(root_b); ret = bt_field_type_structure_add_field(root, root_b, "b"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_c = bt_field_type_string_create(); - assert(root_c); + BT_ASSERT(root_c); ret = bt_field_type_string_set_encoding(root_c, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_c, "c"); - assert(ret == 0); + BT_ASSERT(ret == 0); BT_PUT(root_a); BT_PUT(root_b); @@ -2232,7 +2232,7 @@ void test_fail_unavailable_root(void) struct bt_field_type *ep; ep = test_fail_unavailable_root_get_event_payload(); - assert(ep); + BT_ASSERT(ep); ok(try_add_event_class_to_trace(NULL, ep), "Sequence FT with length in unavailable root is invalid"); @@ -2268,37 +2268,37 @@ struct bt_field_type *test_fail_target_is_root_get_event_payload(void) int ret; root = bt_field_type_structure_create(); - assert(root); + BT_ASSERT(root); ret = bt_field_type_set_alignment(root, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_a = bt_field_type_integer_create(32); - assert(root_a); + BT_ASSERT(root_a); ret = bt_field_type_integer_set_is_signed(root_a, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_a, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_a, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_a, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_a, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_a, "a"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_b_elem = bt_field_type_string_create(); - assert(root_b_elem); + BT_ASSERT(root_b_elem); ret = bt_field_type_string_set_encoding(root_b_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_b = bt_field_type_sequence_create(root_b_elem, "event.fields"); - assert(root_b); + BT_ASSERT(root_b); ret = bt_field_type_structure_add_field(root, root_b, "b"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_c = bt_field_type_string_create(); - assert(root_c); + BT_ASSERT(root_c); ret = bt_field_type_string_set_encoding(root_c, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_c, "c"); - assert(ret == 0); + BT_ASSERT(ret == 0); BT_PUT(root_a); BT_PUT(root_b); @@ -2314,7 +2314,7 @@ void test_fail_target_is_root(void) struct bt_field_type *ep; ep = test_fail_target_is_root_get_event_payload(); - assert(ep); + BT_ASSERT(ep); ok(try_add_event_class_to_trace(NULL, ep), "Sequence FT with root as its length is invalid"); BT_PUT(ep); @@ -2353,51 +2353,51 @@ struct bt_field_type *test_fail_target_is_after_source_get_ep(void) int ret; root = bt_field_type_structure_create(); - assert(root); + BT_ASSERT(root); ret = bt_field_type_set_alignment(root, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_a = bt_field_type_integer_create(32); - assert(root_a); + BT_ASSERT(root_a); ret = bt_field_type_integer_set_is_signed(root_a, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_a, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_a, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_a, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_a, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_a, "a"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_b_elem = bt_field_type_string_create(); - assert(root_b_elem); + BT_ASSERT(root_b_elem); ret = bt_field_type_string_set_encoding(root_b_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_b = bt_field_type_sequence_create(root_b_elem, "d"); - assert(root_b); + BT_ASSERT(root_b); ret = bt_field_type_structure_add_field(root, root_b, "b"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_c = bt_field_type_string_create(); - assert(root_c); + BT_ASSERT(root_c); ret = bt_field_type_string_set_encoding(root_c, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_c, "c"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_d = bt_field_type_integer_create(17); - assert(root_d); + BT_ASSERT(root_d); ret = bt_field_type_integer_set_is_signed(root_d, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_d, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_d, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_d, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_d, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_d, "d"); - assert(ret == 0); + BT_ASSERT(ret == 0); BT_PUT(root_a); BT_PUT(root_b); @@ -2414,7 +2414,7 @@ void test_fail_target_is_after_source(void) struct bt_field_type *ep; ep = test_fail_target_is_after_source_get_ep(); - assert(ep); + BT_ASSERT(ep); ok(try_add_event_class_to_trace(NULL, ep), "Sequence FT with length after it is invalid"); BT_PUT(ep); @@ -2457,57 +2457,57 @@ struct bt_field_type *test_fail_target_is_ancestor_of_source_get_ep(void) int ret; root = bt_field_type_structure_create(); - assert(root); + BT_ASSERT(root); ret = bt_field_type_set_alignment(root, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_a = bt_field_type_integer_create(32); - assert(root_a); + BT_ASSERT(root_a); ret = bt_field_type_integer_set_is_signed(root_a, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_a, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_a, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_a, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_a, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_a, "a"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_z = bt_field_type_structure_create(); - assert(root_z); + BT_ASSERT(root_z); ret = bt_field_type_set_alignment(root_z, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_z_b_elem = bt_field_type_string_create(); - assert(root_z_b_elem); + BT_ASSERT(root_z_b_elem); ret = bt_field_type_string_set_encoding(root_z_b_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_z_b = bt_field_type_sequence_create(root_z_b_elem, "z"); - assert(root_z_b); + BT_ASSERT(root_z_b); ret = bt_field_type_structure_add_field(root_z, root_z_b, "b"); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_z, "z"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_c = bt_field_type_string_create(); - assert(root_c); + BT_ASSERT(root_c); ret = bt_field_type_string_set_encoding(root_c, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_c, "c"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_d = bt_field_type_integer_create(17); - assert(root_d); + BT_ASSERT(root_d); ret = bt_field_type_integer_set_is_signed(root_d, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_d, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_d, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_d, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_d, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_d, "d"); - assert(ret == 0); + BT_ASSERT(ret == 0); BT_PUT(root_a); BT_PUT(root_z); @@ -2525,7 +2525,7 @@ void test_fail_target_is_ancestor_of_source(void) struct bt_field_type *ep; ep = test_fail_target_is_ancestor_of_source_get_ep(); - assert(ep); + BT_ASSERT(ep); ok(try_add_event_class_to_trace(NULL, ep), "Sequence FT with ancestor as its length is invalid"); BT_PUT(ep); @@ -2564,51 +2564,51 @@ struct bt_field_type *test_fail_target_is_source_get_event_payload(void) int ret; root = bt_field_type_structure_create(); - assert(root); + BT_ASSERT(root); ret = bt_field_type_set_alignment(root, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_a = bt_field_type_integer_create(32); - assert(root_a); + BT_ASSERT(root_a); ret = bt_field_type_integer_set_is_signed(root_a, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_a, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_a, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_a, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_a, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_a, "a"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_b_elem = bt_field_type_string_create(); - assert(root_b_elem); + BT_ASSERT(root_b_elem); ret = bt_field_type_string_set_encoding(root_b_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_b = bt_field_type_sequence_create(root_b_elem, "event.fields.b"); - assert(root_b); + BT_ASSERT(root_b); ret = bt_field_type_structure_add_field(root, root_b, "b"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_c = bt_field_type_string_create(); - assert(root_c); + BT_ASSERT(root_c); ret = bt_field_type_string_set_encoding(root_c, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_c, "c"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_d = bt_field_type_integer_create(17); - assert(root_d); + BT_ASSERT(root_d); ret = bt_field_type_integer_set_is_signed(root_d, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_d, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_d, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_d, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_d, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_d, "d"); - assert(ret == 0); + BT_ASSERT(ret == 0); BT_PUT(root_a); BT_PUT(root_b); @@ -2625,7 +2625,7 @@ void test_fail_target_is_source(void) struct bt_field_type *ep; ep = test_fail_target_is_source_get_event_payload(); - assert(ep); + BT_ASSERT(ep); ok(try_add_event_class_to_trace(NULL, ep), "Sequence FT with itself as its length is invalid"); BT_PUT(ep); @@ -2665,53 +2665,53 @@ struct bt_field_type *test_fail_variant_tag_is_not_enum_get_ep(void) int ret; root = bt_field_type_structure_create(); - assert(root); + BT_ASSERT(root); ret = bt_field_type_set_alignment(root, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_a = bt_field_type_integer_create(32); - assert(root_a); + BT_ASSERT(root_a); ret = bt_field_type_integer_set_is_signed(root_a, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_a, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_a, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_a, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_a, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_a, "a"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_b = bt_field_type_variant_create(NULL, "a"); - assert(root_b); + BT_ASSERT(root_b); root_b_HELLO = bt_field_type_string_create(); - assert(root_b_HELLO); + BT_ASSERT(root_b_HELLO); ret = bt_field_type_string_set_encoding(root_b_HELLO, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_variant_add_field(root_b, root_b_HELLO, "HELLO"); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_b, "b"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_c = bt_field_type_string_create(); - assert(root_c); + BT_ASSERT(root_c); ret = bt_field_type_string_set_encoding(root_c, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_c, "c"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_d = bt_field_type_integer_create(17); - assert(root_d); + BT_ASSERT(root_d); ret = bt_field_type_integer_set_is_signed(root_d, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_d, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_d, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_d, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_d, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_d, "d"); - assert(ret == 0); + BT_ASSERT(ret == 0); BT_PUT(root_a); BT_PUT(root_b); @@ -2728,7 +2728,7 @@ void test_fail_variant_tag_is_not_enum(void) struct bt_field_type *ep; ep = test_fail_variant_tag_is_not_enum_get_ep(); - assert(ep); + BT_ASSERT(ep); ok(try_add_event_class_to_trace(NULL, ep), "Variant FT with non-enum FT as its tag FT is invalid"); BT_PUT(ep); @@ -2775,61 +2775,61 @@ struct bt_field_type *test_fail_variant_tag_mismatch_mappings_get_ep(void) int ret; root = bt_field_type_structure_create(); - assert(root); + BT_ASSERT(root); ret = bt_field_type_set_alignment(root, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_a_int = bt_field_type_integer_create(16); - assert(root_a_int); + BT_ASSERT(root_a_int); ret = bt_field_type_integer_set_is_signed(root_a_int, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_a_int, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_a_int, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_a_int, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_a_int, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_a = bt_field_type_enumeration_create(root_a_int); - assert(root_a); + BT_ASSERT(root_a); ret = bt_field_type_enumeration_unsigned_add_mapping(root_a, "GLASS", 0, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_enumeration_unsigned_add_mapping(root_a, "OF", 1, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_enumeration_unsigned_add_mapping(root_a, "WATER", 2, 2); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_a, "a"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_b = bt_field_type_variant_create(NULL, "a"); - assert(root_b); + BT_ASSERT(root_b); root_b_GLASS = bt_field_type_string_create(); - assert(root_b_GLASS); + BT_ASSERT(root_b_GLASS); ret = bt_field_type_string_set_encoding(root_b_GLASS, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_variant_add_field(root_b, root_b_GLASS, "GLASS"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_b_OF = bt_field_type_integer_create(2); - assert(root_b_OF); + BT_ASSERT(root_b_OF); ret = bt_field_type_integer_set_is_signed(root_b_OF, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_base(root_b_OF, 10); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_encoding(root_b_OF, BT_STRING_ENCODING_NONE); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_byte_order(root_b_OF, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_set_alignment(root_b_OF, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_variant_add_field(root_b, root_b_OF, "OF"); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_b, "b"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_c = bt_field_type_string_create(); - assert(root_c); + BT_ASSERT(root_c); ret = bt_field_type_string_set_encoding(root_c, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_c, "c"); - assert(ret == 0); + BT_ASSERT(ret == 0); BT_PUT(root_a); BT_PUT(root_a_int); @@ -2847,7 +2847,7 @@ void test_fail_variant_tag_mismatch_mappings(void) struct bt_field_type *ep; ep = test_fail_variant_tag_mismatch_mappings_get_ep(); - assert(ep); + BT_ASSERT(ep); ok(try_add_event_class_to_trace(NULL, ep) == 0, "Variant FT with mismatching tag FT is valid"); BT_PUT(ep); @@ -2881,29 +2881,29 @@ struct bt_field_type *test_fail_sequence_tag_is_not_int_get_ep(void) int ret; root = bt_field_type_structure_create(); - assert(root); + BT_ASSERT(root); ret = bt_field_type_set_alignment(root, 8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_a = bt_field_type_string_create(); - assert(root_a); + BT_ASSERT(root_a); ret = bt_field_type_string_set_encoding(root_a, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_a, "a"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_b_elem = bt_field_type_string_create(); - assert(root_b_elem); + BT_ASSERT(root_b_elem); ret = bt_field_type_string_set_encoding(root_b_elem, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); root_b = bt_field_type_sequence_create(root_b_elem, "a"); - assert(root_b); + BT_ASSERT(root_b); ret = bt_field_type_structure_add_field(root, root_b, "b"); - assert(ret == 0); + BT_ASSERT(ret == 0); root_c = bt_field_type_string_create(); - assert(root_c); + BT_ASSERT(root_c); ret = bt_field_type_string_set_encoding(root_c, BT_STRING_ENCODING_UTF8); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_structure_add_field(root, root_c, "c"); - assert(ret == 0); + BT_ASSERT(ret == 0); BT_PUT(root_a); BT_PUT(root_b); @@ -2919,7 +2919,7 @@ void test_fail_sequence_tag_is_not_int(void) struct bt_field_type *ep; ep = test_fail_sequence_tag_is_not_int_get_ep(); - assert(ep); + BT_ASSERT(ep); ok(try_add_event_class_to_trace(NULL, ep), "Sequence FT with non-enum length FT is invalid"); BT_PUT(ep); diff --git a/tests/lib/test_bt_notification_iterator.c b/tests/lib/test_bt_notification_iterator.c index be3f6dd8..97c2075a 100644 --- a/tests/lib/test_bt_notification_iterator.c +++ b/tests/lib/test_bt_notification_iterator.c @@ -21,7 +21,7 @@ #include #include #include -#include +#include #include #include #include @@ -246,7 +246,7 @@ bool compare_test_events(const struct test_event *expected_events) const struct test_event *expected_event = expected_events; size_t i = 0; - assert(expected_events); + BT_ASSERT(expected_events); while (true) { const struct test_event *event; @@ -285,52 +285,52 @@ void init_static_data(void) /* Test events */ test_events = g_array_new(FALSE, TRUE, sizeof(struct test_event)); - assert(test_events); + BT_ASSERT(test_events); /* Metadata */ empty_struct_ft = bt_field_type_structure_create(); - assert(empty_struct_ft); + BT_ASSERT(empty_struct_ft); trace = bt_trace_create(); - assert(trace); + BT_ASSERT(trace); ret = bt_trace_set_packet_header_field_type(trace, empty_struct_ft); - assert(ret == 0); + BT_ASSERT(ret == 0); src_empty_cc_prio_map = bt_clock_class_priority_map_create(); - assert(src_empty_cc_prio_map); + BT_ASSERT(src_empty_cc_prio_map); src_stream_class = bt_stream_class_create("my-stream-class"); - assert(src_stream_class); + BT_ASSERT(src_stream_class); ret = bt_stream_class_set_packet_context_field_type(src_stream_class, empty_struct_ft); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_stream_class_set_event_header_field_type(src_stream_class, empty_struct_ft); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_stream_class_set_event_context_field_type(src_stream_class, empty_struct_ft); - assert(ret == 0); + BT_ASSERT(ret == 0); src_event_class = bt_event_class_create("my-event-class"); ret = bt_event_class_set_context_field_type(src_event_class, empty_struct_ft); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_event_class_set_payload_field_type(src_event_class, empty_struct_ft); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_stream_class_add_event_class(src_stream_class, src_event_class); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_trace_add_stream_class(trace, src_stream_class); - assert(ret == 0); + BT_ASSERT(ret == 0); src_stream1 = bt_stream_create(src_stream_class, "stream-1", 0); - assert(src_stream1); + BT_ASSERT(src_stream1); src_stream2 = bt_stream_create(src_stream_class, "stream-2", 1); - assert(src_stream2); + BT_ASSERT(src_stream2); src_stream1_packet1 = bt_packet_create(src_stream1); - assert(src_stream1_packet1); + BT_ASSERT(src_stream1_packet1); src_stream1_packet2 = bt_packet_create(src_stream1); - assert(src_stream1_packet2); + BT_ASSERT(src_stream1_packet2); src_stream2_packet1 = bt_packet_create(src_stream2); - assert(src_stream2_packet1); + BT_ASSERT(src_stream2_packet1); src_stream2_packet2 = bt_packet_create(src_stream2); - assert(src_stream2_packet2); + BT_ASSERT(src_stream2_packet2); if (debug) { fprintf(stderr, ":: stream 1: %p\n", src_stream1); @@ -385,10 +385,10 @@ enum bt_notification_iterator_status src_iter_init( g_new0(struct src_iter_user_data, 1); int ret; - assert(user_data); + BT_ASSERT(user_data); ret = bt_private_connection_private_notification_iterator_set_user_data( priv_notif_iter, user_data); - assert(ret == 0); + BT_ASSERT(ret == 0); switch (current_test) { case TEST_NO_AUTO_NOTIFS: @@ -412,7 +412,7 @@ struct bt_notification_iterator_next_method_return src_iter_next_seq( int64_t cur_ts_ns; struct bt_packet *event_packet = NULL; - assert(user_data->seq); + BT_ASSERT(user_data->seq); cur_ts_ns = user_data->seq[user_data->at]; switch (cur_ts_ns) { @@ -424,75 +424,75 @@ struct bt_notification_iterator_next_method_return src_iter_next_seq( next_return.notification = bt_notification_inactivity_create(graph, src_empty_cc_prio_map); - assert(next_return.notification); + BT_ASSERT(next_return.notification); break; case SEQ_STREAM1_BEGIN: next_return.notification = bt_notification_stream_begin_create(graph, src_stream1); - assert(next_return.notification); + BT_ASSERT(next_return.notification); break; case SEQ_STREAM2_BEGIN: next_return.notification = bt_notification_stream_begin_create(graph, src_stream2); - assert(next_return.notification); + BT_ASSERT(next_return.notification); break; case SEQ_STREAM1_END: next_return.notification = bt_notification_stream_end_create(graph, src_stream1); - assert(next_return.notification); + BT_ASSERT(next_return.notification); break; case SEQ_STREAM2_END: next_return.notification = bt_notification_stream_end_create(graph, src_stream2); - assert(next_return.notification); + BT_ASSERT(next_return.notification); break; case SEQ_STREAM1_PACKET1_BEGIN: next_return.notification = bt_notification_packet_begin_create(graph, src_stream1_packet1); - assert(next_return.notification); + BT_ASSERT(next_return.notification); break; case SEQ_STREAM1_PACKET2_BEGIN: next_return.notification = bt_notification_packet_begin_create(graph, src_stream1_packet2); - assert(next_return.notification); + BT_ASSERT(next_return.notification); break; case SEQ_STREAM2_PACKET1_BEGIN: next_return.notification = bt_notification_packet_begin_create(graph, src_stream2_packet1); - assert(next_return.notification); + BT_ASSERT(next_return.notification); break; case SEQ_STREAM2_PACKET2_BEGIN: next_return.notification = bt_notification_packet_begin_create(graph, src_stream2_packet2); - assert(next_return.notification); + BT_ASSERT(next_return.notification); break; case SEQ_STREAM1_PACKET1_END: next_return.notification = bt_notification_packet_end_create(graph, src_stream1_packet1); - assert(next_return.notification); + BT_ASSERT(next_return.notification); break; case SEQ_STREAM1_PACKET2_END: next_return.notification = bt_notification_packet_end_create(graph, src_stream1_packet2); - assert(next_return.notification); + BT_ASSERT(next_return.notification); break; case SEQ_STREAM2_PACKET1_END: next_return.notification = bt_notification_packet_end_create(graph, src_stream2_packet1); - assert(next_return.notification); + BT_ASSERT(next_return.notification); break; case SEQ_STREAM2_PACKET2_END: next_return.notification = bt_notification_packet_end_create(graph, src_stream2_packet2); - assert(next_return.notification); + BT_ASSERT(next_return.notification); break; case SEQ_EVENT_STREAM1_PACKET1: event_packet = src_stream1_packet1; @@ -513,8 +513,8 @@ struct bt_notification_iterator_next_method_return src_iter_next_seq( if (event_packet) { next_return.notification = bt_notification_event_create(graph, src_event_class, - event_packet, src_empty_cc_prio_map); - assert(next_return.notification); + event_packet, src_empty_cc_prio_map); + BT_ASSERT(next_return.notification); } if (next_return.status != BT_NOTIFICATION_ITERATOR_STATUS_END) { @@ -535,7 +535,7 @@ struct bt_notification_iterator_next_method_return src_iter_next( struct src_iter_user_data *user_data = bt_private_connection_private_notification_iterator_get_user_data(priv_iterator); - assert(user_data); + BT_ASSERT(user_data); next_return = src_iter_next_seq(user_data); return next_return; } @@ -549,7 +549,7 @@ enum bt_component_status src_init( ret = bt_private_component_source_add_output_private_port( private_component, "out", NULL, NULL); - assert(ret == 0); + BT_ASSERT(ret == 0); return BT_COMPONENT_STATUS_OK; } @@ -566,7 +566,7 @@ enum bt_notification_iterator_status common_consume( struct bt_notification *notification = NULL; struct test_event test_event = { 0 }; bool do_append_test_event = true; - assert(notif_iter); + BT_ASSERT(notif_iter); ret = bt_notification_iterator_next(notif_iter); if (ret < 0) { @@ -586,7 +586,7 @@ enum bt_notification_iterator_status common_consume( notification = bt_notification_iterator_get_notification( notif_iter); - assert(notification); + BT_ASSERT(notification); switch (bt_notification_get_type(notification)) { case BT_NOTIFICATION_TYPE_EVENT: @@ -595,9 +595,9 @@ enum bt_notification_iterator_status common_consume( test_event.type = TEST_EV_TYPE_NOTIF_EVENT; event = bt_notification_event_borrow_event(notification); - assert(event); + BT_ASSERT(event); test_event.packet = bt_event_borrow_packet(event); - assert(test_event.packet); + BT_ASSERT(test_event.packet); break; } case BT_NOTIFICATION_TYPE_INACTIVITY: @@ -607,25 +607,25 @@ enum bt_notification_iterator_status common_consume( test_event.type = TEST_EV_TYPE_NOTIF_STREAM_BEGIN; test_event.stream = bt_notification_stream_begin_borrow_stream(notification); - assert(test_event.stream); + BT_ASSERT(test_event.stream); break; case BT_NOTIFICATION_TYPE_STREAM_END: test_event.type = TEST_EV_TYPE_NOTIF_STREAM_END; test_event.stream = bt_notification_stream_end_borrow_stream(notification); - assert(test_event.stream); + BT_ASSERT(test_event.stream); break; case BT_NOTIFICATION_TYPE_PACKET_BEGIN: test_event.type = TEST_EV_TYPE_NOTIF_PACKET_BEGIN; test_event.packet = bt_notification_packet_begin_borrow_packet(notification); - assert(test_event.packet); + BT_ASSERT(test_event.packet); break; case BT_NOTIFICATION_TYPE_PACKET_END: test_event.type = TEST_EV_TYPE_NOTIF_PACKET_END; test_event.packet = bt_notification_packet_end_borrow_packet(notification); - assert(test_event.packet); + BT_ASSERT(test_event.packet); break; default: test_event.type = TEST_EV_TYPE_NOTIF_UNEXPECTED; @@ -634,7 +634,7 @@ enum bt_notification_iterator_status common_consume( if (test_event.packet) { test_event.stream = bt_packet_borrow_stream(test_event.packet); - assert(test_event.stream); + BT_ASSERT(test_event.stream); } end: @@ -655,7 +655,7 @@ enum bt_component_status sink_consume( bt_private_component_get_user_data(priv_component); enum bt_notification_iterator_status it_ret; - assert(user_data && user_data->notif_iter); + BT_ASSERT(user_data && user_data->notif_iter); it_ret = common_consume(user_data->notif_iter); if (it_ret < 0) { @@ -689,11 +689,11 @@ void sink_port_connected(struct bt_private_component *private_component, private_component); enum bt_connection_status conn_status; - assert(user_data); - assert(priv_conn); + BT_ASSERT(user_data); + BT_ASSERT(priv_conn); conn_status = bt_private_connection_create_notification_iterator( priv_conn, &user_data->notif_iter); - assert(conn_status == 0); + BT_ASSERT(conn_status == 0); bt_put(priv_conn); } @@ -705,13 +705,13 @@ enum bt_component_status sink_init( struct sink_user_data *user_data = g_new0(struct sink_user_data, 1); int ret; - assert(user_data); + BT_ASSERT(user_data); ret = bt_private_component_set_user_data(private_component, user_data); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_private_component_sink_add_input_private_port( private_component, "in", NULL, NULL); - assert(ret == 0); + BT_ASSERT(ret == 0); return BT_COMPONENT_STATUS_OK; } @@ -739,22 +739,22 @@ void create_source_sink(struct bt_graph *graph, struct bt_component **source, if (source) { src_comp_class = bt_component_class_source_create("src", src_iter_next); - assert(src_comp_class); + BT_ASSERT(src_comp_class); ret = bt_component_class_set_init_method(src_comp_class, src_init); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_component_class_set_finalize_method(src_comp_class, src_finalize); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_component_class_source_set_notification_iterator_init_method( src_comp_class, src_iter_init); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_component_class_source_set_notification_iterator_finalize_method( src_comp_class, src_iter_finalize); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_graph_add_component(graph, src_comp_class, "source", NULL, source); - assert(ret == 0); + BT_ASSERT(ret == 0); bt_put(src_comp_class); } @@ -762,18 +762,18 @@ void create_source_sink(struct bt_graph *graph, struct bt_component **source, if (sink) { sink_comp_class = bt_component_class_sink_create("sink", sink_consume); - assert(sink_comp_class); + BT_ASSERT(sink_comp_class); ret = bt_component_class_set_init_method(sink_comp_class, sink_init); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_component_class_set_finalize_method(sink_comp_class, sink_finalize); ret = bt_component_class_set_port_connected_method( sink_comp_class, sink_port_connected); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_graph_add_component(graph, sink_comp_class, "sink", NULL, sink); - assert(ret == 0); + BT_ASSERT(ret == 0); bt_put(sink_comp_class); } } @@ -791,16 +791,16 @@ void do_std_test(enum test test, const char *name, clear_test_events(); current_test = test; diag("test: %s", name); - assert(!graph); + BT_ASSERT(!graph); graph = bt_graph_create(); - assert(graph); + BT_ASSERT(graph); create_source_sink(graph, &src_comp, &sink_comp); /* Connect source to sink */ upstream_port = bt_component_source_get_output_port_by_name(src_comp, "out"); - assert(upstream_port); + BT_ASSERT(upstream_port); downstream_port = bt_component_sink_get_input_port_by_name(sink_comp, "in"); - assert(downstream_port); + BT_ASSERT(downstream_port); graph_status = bt_graph_connect_ports(graph, upstream_port, downstream_port, NULL); bt_put(upstream_port); @@ -885,9 +885,9 @@ void test_output_port_notification_iterator(void) clear_test_events(); current_test = TEST_OUTPUT_PORT_NOTIFICATION_ITERATOR; diag("test: output port notification iterator"); - assert(!graph); + BT_ASSERT(!graph); graph = bt_graph_create(); - assert(graph); + BT_ASSERT(graph); create_source_sink(graph, &src_comp, NULL); /* Create notification iterator on source's output port */ @@ -924,16 +924,16 @@ void test_output_port_notification_iterator_cannot_consume(void) clear_test_events(); current_test = TEST_OUTPUT_PORT_NOTIFICATION_ITERATOR; diag("test: cannot consume graph with existing output port notification iterator"); - assert(!graph); + BT_ASSERT(!graph); graph = bt_graph_create(); - assert(graph); + BT_ASSERT(graph); create_source_sink(graph, &src_comp, NULL); /* Create notification iterator on source's output port */ upstream_port = bt_component_source_get_output_port_by_name(src_comp, "out"); notif_iter = bt_output_port_notification_iterator_create(upstream_port, NULL); - assert(notif_iter); + BT_ASSERT(notif_iter); bt_put(upstream_port); /* diff --git a/tests/lib/test_bt_values.c b/tests/lib/test_bt_values.c index f407a19f..9ff58a12 100644 --- a/tests/lib/test_bt_values.c +++ b/tests/lib/test_bt_values.c @@ -22,7 +22,7 @@ #include #include -#include +#include #include #include "tap/tap.h" @@ -55,7 +55,7 @@ void test_bool(void) ret = bt_value_bool_get(obj, &value); ok(!ret && !value, "default boolean value object value is BT_FALSE"); - assert(!bt_value_bool_set(obj, BT_FALSE)); + BT_ASSERT(!bt_value_bool_set(obj, BT_FALSE)); ret = bt_value_bool_set(obj, BT_TRUE); ok(!ret, "bt_value_bool_set() succeeds"); ret = bt_value_bool_get(obj, &value); @@ -233,7 +233,7 @@ void test_array(void) "bt_value_array_get() returns an value object with the appropriate type (null)"); obj = bt_value_integer_create_init(1001); - assert(obj); + BT_ASSERT(obj); ok(!bt_value_array_set(array_obj, 2, obj), "bt_value_array_set() succeeds"); BT_PUT(obj); @@ -241,7 +241,7 @@ void test_array(void) ok(obj && bt_value_is_integer(obj), "bt_value_array_set() inserts an value object with the appropriate type"); ret = bt_value_integer_get(obj, &int_value); - assert(!ret); + BT_ASSERT(!ret); ok(int_value == 1001, "bt_value_array_set() inserts an value object with the appropriate value"); BT_PUT(obj); @@ -636,7 +636,7 @@ void test_compare_bool(void) struct bt_value *bool2 = bt_value_bool_create_init(BT_TRUE); struct bt_value *bool3 = bt_value_bool_create_init(BT_FALSE); - assert(bool1 && bool2 && bool3); + BT_ASSERT(bool1 && bool2 && bool3); ok(!bt_value_compare(bt_value_null, bool1), "cannot compare null value object and bt_bool value object"); ok(!bt_value_compare(bool1, bool2), @@ -656,7 +656,7 @@ void test_compare_integer(void) struct bt_value *int2 = bt_value_integer_create_init(-23); struct bt_value *int3 = bt_value_integer_create_init(10); - assert(int1 && int2 && int3); + BT_ASSERT(int1 && int2 && int3); ok(!bt_value_compare(bt_value_null, int1), "cannot compare null value object and integer value object"); ok(!bt_value_compare(int1, int2), @@ -676,7 +676,7 @@ void test_compare_float(void) struct bt_value *float2 = bt_value_float_create_init(-14.23); struct bt_value *float3 = bt_value_float_create_init(17.38); - assert(float1 && float2 && float3); + BT_ASSERT(float1 && float2 && float3); ok(!bt_value_compare(bt_value_null, float1), "cannot compare null value object and floating point number value object"); @@ -697,7 +697,7 @@ void test_compare_string(void) struct bt_value *string2 = bt_value_string_create_init("bt_value"); struct bt_value *string3 = bt_value_string_create_init("hello"); - assert(string1 && string2 && string3); + BT_ASSERT(string1 && string2 && string3); ok(!bt_value_compare(bt_value_null, string1), "cannot compare null value object and string value object"); @@ -718,23 +718,23 @@ void test_compare_array(void) struct bt_value *array2 = bt_value_array_create(); struct bt_value *array3 = bt_value_array_create(); - assert(array1 && array2 && array3); + BT_ASSERT(array1 && array2 && array3); ok(bt_value_compare(array1, array2), "empty array value objects are equivalent"); - assert(!bt_value_array_append_integer(array1, 23)); - assert(!bt_value_array_append_float(array1, 14.2)); - assert(!bt_value_array_append_bool(array1, BT_FALSE)); - assert(!bt_value_array_append_float(array2, 14.2)); - assert(!bt_value_array_append_integer(array2, 23)); - assert(!bt_value_array_append_bool(array2, BT_FALSE)); - assert(!bt_value_array_append_integer(array3, 23)); - assert(!bt_value_array_append_float(array3, 14.2)); - assert(!bt_value_array_append_bool(array3, BT_FALSE)); - assert(bt_value_array_size(array1) == 3); - assert(bt_value_array_size(array2) == 3); - assert(bt_value_array_size(array3) == 3); + BT_ASSERT(!bt_value_array_append_integer(array1, 23)); + BT_ASSERT(!bt_value_array_append_float(array1, 14.2)); + BT_ASSERT(!bt_value_array_append_bool(array1, BT_FALSE)); + BT_ASSERT(!bt_value_array_append_float(array2, 14.2)); + BT_ASSERT(!bt_value_array_append_integer(array2, 23)); + BT_ASSERT(!bt_value_array_append_bool(array2, BT_FALSE)); + BT_ASSERT(!bt_value_array_append_integer(array3, 23)); + BT_ASSERT(!bt_value_array_append_float(array3, 14.2)); + BT_ASSERT(!bt_value_array_append_bool(array3, BT_FALSE)); + BT_ASSERT(bt_value_array_size(array1) == 3); + BT_ASSERT(bt_value_array_size(array2) == 3); + BT_ASSERT(bt_value_array_size(array3) == 3); ok(!bt_value_compare(bt_value_null, array1), "cannot compare null value object and array value object"); @@ -755,23 +755,23 @@ void test_compare_map(void) struct bt_value *map2 = bt_value_map_create(); struct bt_value *map3 = bt_value_map_create(); - assert(map1 && map2 && map3); + BT_ASSERT(map1 && map2 && map3); ok(bt_value_compare(map1, map2), "empty map value objects are equivalent"); - assert(!bt_value_map_insert_integer(map1, "one", 23)); - assert(!bt_value_map_insert_float(map1, "two", 14.2)); - assert(!bt_value_map_insert_bool(map1, "three", BT_FALSE)); - assert(!bt_value_map_insert_float(map2, "one", 14.2)); - assert(!bt_value_map_insert_integer(map2, "two", 23)); - assert(!bt_value_map_insert_bool(map2, "three", BT_FALSE)); - assert(!bt_value_map_insert_bool(map3, "three", BT_FALSE)); - assert(!bt_value_map_insert_integer(map3, "one", 23)); - assert(!bt_value_map_insert_float(map3, "two", 14.2)); - assert(bt_value_map_size(map1) == 3); - assert(bt_value_map_size(map2) == 3); - assert(bt_value_map_size(map3) == 3); + BT_ASSERT(!bt_value_map_insert_integer(map1, "one", 23)); + BT_ASSERT(!bt_value_map_insert_float(map1, "two", 14.2)); + BT_ASSERT(!bt_value_map_insert_bool(map1, "three", BT_FALSE)); + BT_ASSERT(!bt_value_map_insert_float(map2, "one", 14.2)); + BT_ASSERT(!bt_value_map_insert_integer(map2, "two", 23)); + BT_ASSERT(!bt_value_map_insert_bool(map2, "three", BT_FALSE)); + BT_ASSERT(!bt_value_map_insert_bool(map3, "three", BT_FALSE)); + BT_ASSERT(!bt_value_map_insert_integer(map3, "one", 23)); + BT_ASSERT(!bt_value_map_insert_float(map3, "two", 14.2)); + BT_ASSERT(bt_value_map_size(map1) == 3); + BT_ASSERT(bt_value_map_size(map2) == 3); + BT_ASSERT(bt_value_map_size(map3) == 3); ok(!bt_value_compare(bt_value_null, map1), "cannot compare null value object and map value object"); @@ -823,15 +823,15 @@ void test_copy(void) array_obj = bt_value_array_create(); map_obj = bt_value_map_create(); - assert(bool_obj && integer_obj && float_obj && string_obj && + BT_ASSERT(bool_obj && integer_obj && float_obj && string_obj && array_obj && map_obj); - assert(!bt_value_array_append(array_obj, bool_obj)); - assert(!bt_value_array_append(array_obj, integer_obj)); - assert(!bt_value_array_append(array_obj, float_obj)); - assert(!bt_value_array_append(array_obj, bt_value_null)); - assert(!bt_value_map_insert(map_obj, "array", array_obj)); - assert(!bt_value_map_insert(map_obj, "string", string_obj)); + BT_ASSERT(!bt_value_array_append(array_obj, bool_obj)); + BT_ASSERT(!bt_value_array_append(array_obj, integer_obj)); + BT_ASSERT(!bt_value_array_append(array_obj, float_obj)); + BT_ASSERT(!bt_value_array_append(array_obj, bt_value_null)); + BT_ASSERT(!bt_value_map_insert(map_obj, "array", array_obj)); + BT_ASSERT(!bt_value_map_insert(map_obj, "string", string_obj)); map_copy_obj = bt_value_copy(map_obj); ok(map_copy_obj, @@ -901,23 +901,23 @@ void test_extend(void) struct bt_value *array = bt_value_array_create(); enum bt_value_status status; - assert(base_map); - assert(extension_map); - assert(array); + BT_ASSERT(base_map); + BT_ASSERT(extension_map); + BT_ASSERT(array); status = bt_value_map_insert_bool(base_map, "file", BT_TRUE); - assert(status == BT_VALUE_STATUS_OK); + BT_ASSERT(status == BT_VALUE_STATUS_OK); status = bt_value_map_insert_bool(base_map, "edit", BT_FALSE); - assert(status == BT_VALUE_STATUS_OK); + BT_ASSERT(status == BT_VALUE_STATUS_OK); status = bt_value_map_insert_integer(base_map, "selection", 17); - assert(status == BT_VALUE_STATUS_OK); + BT_ASSERT(status == BT_VALUE_STATUS_OK); status = bt_value_map_insert_integer(base_map, "find", -34); - assert(status == BT_VALUE_STATUS_OK); + BT_ASSERT(status == BT_VALUE_STATUS_OK); status = bt_value_map_insert_bool(extension_map, "edit", BT_TRUE); - assert(status == BT_VALUE_STATUS_OK); + BT_ASSERT(status == BT_VALUE_STATUS_OK); status = bt_value_map_insert_integer(extension_map, "find", 101); - assert(status == BT_VALUE_STATUS_OK); + BT_ASSERT(status == BT_VALUE_STATUS_OK); status = bt_value_map_insert_float(extension_map, "project", -404); - assert(status == BT_VALUE_STATUS_OK); + BT_ASSERT(status == BT_VALUE_STATUS_OK); extended_map = bt_value_map_extend(base_map, extension_map); ok(extended_map, "bt_value_map_extend() succeeds"); ok(bt_value_map_size(extended_map) == 5, diff --git a/tests/lib/test_cc_prio_map.c b/tests/lib/test_cc_prio_map.c index b9378d34..9982b797 100644 --- a/tests/lib/test_cc_prio_map.c +++ b/tests/lib/test_cc_prio_map.c @@ -20,7 +20,7 @@ #include #include #include -#include +#include #include "tap/tap.h" @@ -40,27 +40,27 @@ static void test_clock_class_priority_map(void) cc_prio_map = bt_clock_class_priority_map_create(); ok(cc_prio_map, "bt_clock_class_priority_map_create() succeeds"); cc1 = bt_clock_class_create("cc1", 1); - assert(cc1); + BT_ASSERT(cc1); cc2 = bt_clock_class_create("cc2", 2); - assert(cc2); + BT_ASSERT(cc2); cc3 = bt_clock_class_create("cc3", 3); - assert(cc3); + BT_ASSERT(cc3); ok(!bt_clock_class_priority_map_get_highest_priority_clock_class(cc_prio_map), "bt_clock_class_priority_map_get_highest_priority_clock_class() returns NULL when there's no clock classes"); ret = bt_clock_class_priority_map_add_clock_class(cc_prio_map, cc2, 75); - assert(ret == 0); + BT_ASSERT(ret == 0); cc = bt_clock_class_priority_map_get_highest_priority_clock_class(cc_prio_map); ok(cc == cc2, "bt_clock_class_priority_map_get_highest_priority_clock_class() returns the expected clock class (1)"); BT_PUT(cc); ret = bt_clock_class_priority_map_add_clock_class(cc_prio_map, cc1, 1001); - assert(ret == 0); + BT_ASSERT(ret == 0); cc = bt_clock_class_priority_map_get_highest_priority_clock_class(cc_prio_map); ok(cc == cc2, "bt_clock_class_priority_map_get_highest_priority_clock_class() returns the expected clock class (2)"); BT_PUT(cc); ret = bt_clock_class_priority_map_add_clock_class(cc_prio_map, cc3, 11); - assert(ret == 0); + BT_ASSERT(ret == 0); cc = bt_clock_class_priority_map_get_highest_priority_clock_class(cc_prio_map); ok(cc == cc3, "bt_clock_class_priority_map_get_highest_priority_clock_class() returns the expected clock class (3)"); @@ -70,25 +70,25 @@ static void test_clock_class_priority_map(void) ok(prio == 1001, "bt_clock_class_priority_map_get_clock_class_priority() returns the expected priority (1)"); ret = bt_clock_class_priority_map_get_clock_class_priority(cc_prio_map, cc2, &prio); - assert(ret == 0); + BT_ASSERT(ret == 0); ok(prio == 75, "bt_clock_class_priority_map_get_clock_class_priority() returns the expected priority (2)"); ret = bt_clock_class_priority_map_get_clock_class_priority(cc_prio_map, cc3, &prio); - assert(ret == 0); + BT_ASSERT(ret == 0); ok(prio == 11, "bt_clock_class_priority_map_get_clock_class_priority() returns the expected priority (3)"); cc_prio_map_copy = bt_clock_class_priority_map_copy(cc_prio_map); ok(cc_prio_map_copy, "bt_clock_class_priority_map_copy() succeeds"); ret = bt_clock_class_priority_map_get_clock_class_priority(cc_prio_map_copy, cc1, &prio); - assert(ret == 0); + BT_ASSERT(ret == 0); ok(prio == 1001, "bt_clock_class_priority_map_get_clock_class_priority() returns the expected priority (1, copy)"); ret = bt_clock_class_priority_map_get_clock_class_priority(cc_prio_map_copy, cc2, &prio); - assert(ret == 0); + BT_ASSERT(ret == 0); ok(prio == 75, "bt_clock_class_priority_map_get_clock_class_priority() returns the expected priority (2, copy)"); ret = bt_clock_class_priority_map_get_clock_class_priority(cc_prio_map_copy, cc3, &prio); - assert(ret == 0); + BT_ASSERT(ret == 0); ok(prio == 11, "bt_clock_class_priority_map_get_clock_class_priority() returns the expected priority (3, copy)"); cc = bt_clock_class_priority_map_get_highest_priority_clock_class(cc_prio_map_copy); @@ -98,7 +98,7 @@ static void test_clock_class_priority_map(void) ret = bt_clock_class_priority_map_add_clock_class(cc_prio_map_copy, cc3, 253); ok(ret == 0, "bt_clock_class_priority_map_add_clock_class() succeeds for an existing clock class"); ret = bt_clock_class_priority_map_get_clock_class_priority(cc_prio_map_copy, cc3, &prio); - assert(ret == 0); + BT_ASSERT(ret == 0); ok(prio == 253, "bt_clock_class_priority_map_get_clock_class_priority() returns the expected priority (updated, copy)"); cc = bt_clock_class_priority_map_get_highest_priority_clock_class(cc_prio_map_copy); diff --git a/tests/lib/test_ctf_ir_ref.c b/tests/lib/test_ctf_ir_ref.c index 9e9260bb..c5ad8fcb 100644 --- a/tests/lib/test_ctf_ir_ref.c +++ b/tests/lib/test_ctf_ir_ref.c @@ -36,7 +36,7 @@ #include #include #include -#include +#include #include "common.h" #define NR_TESTS 41 @@ -196,7 +196,7 @@ static struct bt_event_class *create_simple_event(const char *name) struct bt_event_class *event = NULL; struct bt_field_type *payload = NULL; - assert(name); + BT_ASSERT(name); event = bt_event_class_create(name); if (!event) { diag("Failed to create simple event"); @@ -238,7 +238,7 @@ static struct bt_event_class *create_complex_event(const char *name) struct bt_event_class *event = NULL; struct bt_field_type *inner = NULL, *outer = NULL; - assert(name); + BT_ASSERT(name); event = bt_event_class_create(name); if (!event) { diag("Failed to create complex event"); @@ -287,35 +287,35 @@ static void set_stream_class_field_types( int ret; packet_context_type = bt_field_type_structure_create(); - assert(packet_context_type); + BT_ASSERT(packet_context_type); ft = bt_field_type_integer_create(32); - assert(ft); + BT_ASSERT(ft); ret = bt_field_type_structure_add_field(packet_context_type, ft, "packet_size"); - assert(ret == 0); + BT_ASSERT(ret == 0); bt_put(ft); ft = bt_field_type_integer_create(32); - assert(ft); + BT_ASSERT(ft); ret = bt_field_type_structure_add_field(packet_context_type, ft, "content_size"); - assert(ret == 0); + BT_ASSERT(ret == 0); bt_put(ft); event_header_type = bt_field_type_structure_create(); - assert(event_header_type); + BT_ASSERT(event_header_type); ft = bt_field_type_integer_create(32); - assert(ft); + BT_ASSERT(ft); ret = bt_field_type_structure_add_field(event_header_type, ft, "id"); - assert(ret == 0); + BT_ASSERT(ret == 0); bt_put(ft); ret = bt_stream_class_set_packet_context_field_type(stream_class, packet_context_type); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_stream_class_set_event_header_field_type(stream_class, event_header_type); - assert(ret == 0); + BT_ASSERT(ret == 0); bt_put(packet_context_type); bt_put(event_header_type); @@ -414,17 +414,17 @@ static void set_trace_packet_header(struct bt_trace *trace) int ret; packet_header_type = bt_field_type_structure_create(); - assert(packet_header_type); + BT_ASSERT(packet_header_type); ft = bt_field_type_integer_create(32); - assert(ft); + BT_ASSERT(ft); ret = bt_field_type_structure_add_field(packet_header_type, ft, "stream_id"); - assert(ret == 0); + BT_ASSERT(ret == 0); bt_put(ft); ret = bt_trace_set_packet_header_field_type(trace, packet_header_type); - assert(ret == 0); + BT_ASSERT(ret == 0); bt_put(packet_header_type); } @@ -647,51 +647,51 @@ static void create_writer_user_full(struct writer_user *user) } user->writer = bt_ctf_writer_create(trace_path); - assert(user->writer); + BT_ASSERT(user->writer); ret = bt_ctf_writer_set_byte_order(user->writer, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); user->tc = bt_ctf_writer_get_trace(user->writer); - assert(user->tc); + BT_ASSERT(user->tc); user->sc = bt_ctf_stream_class_create("sc"); - assert(user->sc); + BT_ASSERT(user->sc); clock = bt_ctf_clock_create("the_clock"); - assert(clock); + BT_ASSERT(clock); ret = bt_ctf_writer_add_clock(user->writer, clock); - assert(!ret); + BT_ASSERT(!ret); ret = bt_ctf_stream_class_set_clock(user->sc, clock); - assert(!ret); + BT_ASSERT(!ret); BT_PUT(clock); user->stream = bt_ctf_writer_create_stream(user->writer, user->sc); - assert(user->stream); + BT_ASSERT(user->stream); user->ec = bt_ctf_event_class_create("ec"); - assert(user->ec); + BT_ASSERT(user->ec); ft = create_writer_integer_struct(); - assert(ft); + BT_ASSERT(ft); ret = bt_ctf_event_class_set_payload_field_type(user->ec, ft); BT_PUT(ft); - assert(!ret); + BT_ASSERT(!ret); ret = bt_ctf_stream_class_add_event_class(user->sc, user->ec); - assert(!ret); + BT_ASSERT(!ret); user->event = bt_ctf_event_create(user->ec); - assert(user->event); + BT_ASSERT(user->event); field = bt_ctf_event_get_payload(user->event, "payload_8"); - assert(field); + BT_ASSERT(field); ret = bt_ctf_field_integer_unsigned_set_value(field, 10); - assert(!ret); + BT_ASSERT(!ret); BT_PUT(field); field = bt_ctf_event_get_payload(user->event, "payload_16"); - assert(field); + BT_ASSERT(field); ret = bt_ctf_field_integer_unsigned_set_value(field, 20); - assert(!ret); + BT_ASSERT(!ret); BT_PUT(field); field = bt_ctf_event_get_payload(user->event, "payload_32"); - assert(field); + BT_ASSERT(field); ret = bt_ctf_field_integer_unsigned_set_value(field, 30); - assert(!ret); + BT_ASSERT(!ret); BT_PUT(field); ret = bt_ctf_stream_append_event(user->stream, user->event); - assert(!ret); + BT_ASSERT(!ret); recursive_rmdir(trace_path); g_free(trace_path); } diff --git a/tests/lib/test_ctf_writer.c b/tests/lib/test_ctf_writer.c index 928ff982..de0b6123 100644 --- a/tests/lib/test_ctf_writer.c +++ b/tests/lib/test_ctf_writer.c @@ -37,7 +37,7 @@ #include #include #include -#include +#include #include #include "tap/tap.h" #include @@ -301,7 +301,7 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, bt_ctf_event_class_add_field(simple_event_class, float_type, "float_field"); - assert(!bt_ctf_event_class_set_id(simple_event_class, 13)); + BT_ASSERT(!bt_ctf_event_class_set_id(simple_event_class, 13)); /* Set an event context type which will contain a single integer. */ ok(!bt_ctf_field_type_structure_add_field(event_context_type, uint_12_type, @@ -329,22 +329,22 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, BT_PUT(event_payload_type); event_payload_type = bt_ctf_event_class_get_payload_field_type( simple_event_class); - assert(event_payload_type); + BT_ASSERT(event_payload_type); event_context_type = bt_ctf_event_class_get_context_field_type( simple_event_class); - assert(event_context_type); + BT_ASSERT(event_context_type); ep_integer_field_type = bt_ctf_field_type_structure_get_field_type_by_name( event_payload_type, "integer_field"); - assert(ep_integer_field_type); + BT_ASSERT(ep_integer_field_type); ep_enum_field_type = bt_ctf_field_type_structure_get_field_type_by_name( event_payload_type, "enum_field"); - assert(ep_enum_field_type); + BT_ASSERT(ep_enum_field_type); ep_enum_field_unsigned_type = bt_ctf_field_type_structure_get_field_type_by_name( event_payload_type, "enum_field_unsigned"); - assert(ep_enum_field_unsigned_type); + BT_ASSERT(ep_enum_field_unsigned_type); ok(bt_ctf_stream_class_get_event_class_count(stream_class) == 1, "bt_ctf_stream_class_get_event_class_count returns a correct number of event classes"); @@ -377,18 +377,18 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, "bt_ctf_field_floating_point_get_value returns a correct value"); enum_field = bt_ctf_field_create(ep_enum_field_type); - assert(enum_field); + BT_ASSERT(enum_field); enum_container_field = bt_ctf_field_enumeration_get_container(enum_field); ok(bt_ctf_field_integer_signed_set_value( enum_container_field, -42) == 0, "Set signed enumeration container value"); ret = bt_ctf_event_set_payload(simple_event, "enum_field", enum_field); - assert(!ret); + BT_ASSERT(!ret); BT_PUT(iter); enum_field_unsigned = bt_ctf_field_create(ep_enum_field_unsigned_type); - assert(enum_field_unsigned); + BT_ASSERT(enum_field_unsigned); enum_container_field_unsigned = bt_ctf_field_enumeration_get_container( enum_field_unsigned); ok(bt_ctf_field_integer_unsigned_set_value( @@ -396,14 +396,14 @@ void append_simple_event(struct bt_ctf_stream_class *stream_class, "Set unsigned enumeration container value"); ret = bt_ctf_event_set_payload(simple_event, "enum_field_unsigned", enum_field_unsigned); - assert(!ret); + BT_ASSERT(!ret); ok(bt_ctf_clock_set_time(clock, current_time) == 0, "Set clock time"); /* Populate stream event context */ stream_event_context = bt_ctf_event_get_stream_event_context(simple_event); - assert(stream_event_context); + BT_ASSERT(stream_event_context); stream_event_context_field = bt_ctf_field_structure_get_field_by_name( stream_event_context, "common_event_context"); bt_ctf_field_integer_unsigned_set_value(stream_event_context_field, 42); @@ -785,7 +785,7 @@ void append_complex_event(struct bt_ctf_stream_class *stream_class, } stream_event_ctx_field = bt_ctf_event_get_stream_event_context(event); - assert(stream_event_ctx_field); + BT_ASSERT(stream_event_ctx_field); stream_event_ctx_int_field = bt_ctf_field_structure_get_field_by_name( stream_event_ctx_field, "common_event_context"); BT_PUT(stream_event_ctx_field); @@ -917,7 +917,7 @@ void type_field_tests() "bt_ctf_field_type_integer_get_encoding returns a correct value"); int_16_type = bt_ctf_field_type_integer_create(16); - assert(int_16_type); + BT_ASSERT(int_16_type); ok(!bt_ctf_field_type_integer_set_signed(int_16_type, 1), "Set signedness of 16 bit integer to true"); ok(bt_ctf_field_type_integer_get_signed(int_16_type) == 1, @@ -1102,13 +1102,13 @@ void packet_resize_test(struct bt_ctf_stream_class *stream_class, * appropriate fields. */ ep_type = bt_ctf_event_class_get_payload_field_type(event_class); - assert(ep_type); + BT_ASSERT(ep_type); ep_field_1_type = bt_ctf_field_type_structure_get_field_type_by_name( ep_type, "field_1"); - assert(ep_field_1_type); + BT_ASSERT(ep_field_1_type); ep_a_string_type = bt_ctf_field_type_structure_get_field_type_by_name( ep_type, "a_string"); - assert(ep_a_string_type); + BT_ASSERT(ep_a_string_type); event = bt_ctf_event_create(event_class); ret_field = bt_ctf_event_get_payload(event, 0); @@ -1212,9 +1212,9 @@ void test_empty_stream(struct bt_ctf_writer *writer) } ret = bt_ctf_stream_class_set_packet_context_type(stream_class, NULL); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_ctf_stream_class_set_event_header_type(stream_class, NULL); - assert(ret == 0); + BT_ASSERT(ret == 0); ok(bt_ctf_stream_class_get_trace(stream_class) == NULL, "bt_ctf_stream_class_get_trace returns NULL when stream class is orphaned"); @@ -1539,14 +1539,14 @@ void append_existing_event_class(struct bt_ctf_stream_class *stream_class) struct bt_ctf_event_class *event_class; event_class = bt_ctf_event_class_create("Simple Event"); - assert(event_class); + BT_ASSERT(event_class); ok(bt_ctf_stream_class_add_event_class(stream_class, event_class) == 0, "two event classes with the same name may cohabit within the same stream class"); bt_put(event_class); event_class = bt_ctf_event_class_create("different name, ok"); - assert(event_class); - assert(!bt_ctf_event_class_set_id(event_class, 13)); + BT_ASSERT(event_class); + BT_ASSERT(!bt_ctf_event_class_set_id(event_class, 13)); ok(bt_ctf_stream_class_add_event_class(stream_class, event_class), "two event classes with the same ID cannot cohabit within the same stream class"); bt_put(event_class); @@ -1559,15 +1559,15 @@ void test_clock_utils(void) struct bt_ctf_clock *clock = NULL; clock = bt_ctf_clock_create("water"); - assert(clock); + BT_ASSERT(clock); ret = bt_ctf_clock_set_offset_s(clock, 1234); - assert(!ret); + BT_ASSERT(!ret); ret = bt_ctf_clock_set_offset(clock, 1000); - assert(!ret); + BT_ASSERT(!ret); ret = bt_ctf_clock_set_frequency(clock, 1000000000); - assert(!ret); + BT_ASSERT(!ret); ret = bt_ctf_clock_set_frequency(clock, 1534); - assert(!ret); + BT_ASSERT(!ret); BT_PUT(clock); } @@ -1667,7 +1667,7 @@ int main(int argc, char **argv) /* Test bt_ctf_trace_set_environment_field with an integer object */ obj = bt_value_integer_create_init(23); - assert(obj); + BT_ASSERT(obj); ok(bt_ctf_trace_set_environment_field(NULL, "test_env_int_obj", obj), "bt_ctf_trace_set_environment_field handles a NULL trace correctly"); ok(bt_ctf_trace_set_environment_field(trace, NULL, obj), @@ -1680,7 +1680,7 @@ int main(int argc, char **argv) /* Test bt_ctf_trace_set_environment_field with a string object */ obj = bt_value_string_create_init("the value"); - assert(obj); + BT_ASSERT(obj); ok(!bt_ctf_trace_set_environment_field(trace, "test_env_str_obj", obj), "bt_ctf_trace_set_environment_field succeeds in adding a string object"); BT_PUT(obj); @@ -1997,7 +1997,7 @@ int main(int argc, char **argv) /* Instantiate a stream and append events */ ret = bt_ctf_writer_add_clock(writer, clock); - assert(ret == 0); + BT_ASSERT(ret == 0); ok(bt_ctf_trace_get_stream_count(trace) == 0, "bt_ctf_trace_get_stream_count() succeeds and returns the correct value (0)"); @@ -2045,13 +2045,13 @@ int main(int argc, char **argv) BT_PUT(packet_context_type); BT_PUT(stream_event_context_type); packet_header_type = bt_ctf_trace_get_packet_header_field_type(trace); - assert(packet_header_type); + BT_ASSERT(packet_header_type); packet_context_type = bt_ctf_stream_class_get_packet_context_type(stream_class); - assert(packet_context_type); + BT_ASSERT(packet_context_type); stream_event_context_type = bt_ctf_stream_class_get_event_context_type(stream_class); - assert(stream_event_context_type); + BT_ASSERT(stream_event_context_type); /* * Try to modify the packet context type after a stream has been diff --git a/tests/lib/test_graph_topo.c b/tests/lib/test_graph_topo.c index 185c6c22..e69a61a8 100644 --- a/tests/lib/test_graph_topo.c +++ b/tests/lib/test_graph_topo.c @@ -35,7 +35,7 @@ #include #include #include -#include +#include #include #include "tap/tap.h" @@ -336,7 +336,7 @@ void src_port_connected(struct bt_private_component *private_component, case TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED: ret = bt_private_component_source_add_output_private_port( private_component, "hello", NULL, NULL); - assert(ret == 0); + BT_ASSERT(ret == 0); break; default: break; @@ -361,7 +361,7 @@ void src_port_disconnected(struct bt_private_component *private_component, switch (current_test) { case TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT: ret = bt_private_port_remove_from_component(private_port); - assert(ret == 0); + BT_ASSERT(ret == 0); default: break; } @@ -375,7 +375,7 @@ enum bt_component_status src_init(struct bt_private_component *priv_comp, ret = bt_private_component_source_add_output_private_port( priv_comp, "out", NULL, NULL); - assert(ret == 0); + BT_ASSERT(ret == 0); return BT_COMPONENT_STATUS_OK; } @@ -391,9 +391,9 @@ enum bt_component_status sink_consume( case TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT: def_port = bt_private_component_sink_get_input_private_port_by_name( priv_component, "in"); - assert(def_port); + BT_ASSERT(def_port); ret = bt_private_port_remove_from_component(def_port); - assert(ret == 0); + BT_ASSERT(ret == 0); bt_put(def_port); break; default: @@ -443,7 +443,7 @@ enum bt_component_status sink_init(struct bt_private_component *priv_comp, ret = bt_private_component_sink_add_input_private_port(priv_comp, "in", NULL, NULL); - assert(ret == 0); + BT_ASSERT(ret == 0); return BT_COMPONENT_STATUS_OK; } @@ -453,7 +453,7 @@ void graph_port_added(struct bt_port *port, { struct bt_component *comp = bt_port_get_component(port); - assert(comp); + BT_ASSERT(comp); bt_put(comp); struct event event = { @@ -492,9 +492,9 @@ void graph_ports_connected(struct bt_port *upstream_port, bt_port_get_component(downstream_port); struct bt_connection *conn = bt_port_get_connection(upstream_port); - assert(upstream_comp); - assert(downstream_comp); - assert(conn); + BT_ASSERT(upstream_comp); + BT_ASSERT(downstream_comp); + BT_ASSERT(conn); bt_put(upstream_comp); bt_put(downstream_comp); bt_put(conn); @@ -539,35 +539,35 @@ void init_test(void) int ret; src_comp_class = bt_component_class_source_create("src", src_iter_next); - assert(src_comp_class); + BT_ASSERT(src_comp_class); ret = bt_component_class_set_init_method(src_comp_class, src_init); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_component_class_set_accept_port_connection_method( src_comp_class, accept_port_connection); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_component_class_set_port_connected_method(src_comp_class, src_port_connected); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_component_class_set_port_disconnected_method( src_comp_class, src_port_disconnected); - assert(ret == 0); + BT_ASSERT(ret == 0); sink_comp_class = bt_component_class_sink_create("sink", sink_consume); - assert(sink_comp_class); + BT_ASSERT(sink_comp_class); ret = bt_component_class_set_init_method(sink_comp_class, sink_init); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_component_class_set_accept_port_connection_method( sink_comp_class, accept_port_connection); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_component_class_set_port_connected_method(sink_comp_class, sink_port_connected); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_component_class_set_port_disconnected_method(sink_comp_class, sink_port_disconnected); - assert(ret == 0); + BT_ASSERT(ret == 0); bt_component_class_freeze(src_comp_class); bt_component_class_freeze(sink_comp_class); events = g_array_new(FALSE, TRUE, sizeof(struct event)); - assert(events); + BT_ASSERT(events); } static @@ -586,7 +586,7 @@ struct bt_component *create_src(struct bt_graph *graph) ret = bt_graph_add_component(graph, src_comp_class, "src-comp", NULL, &comp); - assert(ret == 0); + BT_ASSERT(ret == 0); return comp; } @@ -598,7 +598,7 @@ struct bt_component *create_sink(struct bt_graph *graph) ret = bt_graph_add_component(graph, sink_comp_class, "sink-comp", NULL, &comp); - assert(ret == 0); + BT_ASSERT(ret == 0); return comp; } @@ -608,19 +608,19 @@ struct bt_graph *create_graph(void) struct bt_graph *graph = bt_graph_create(); int ret; - assert(graph); + BT_ASSERT(graph); ret = bt_graph_add_port_added_listener(graph, graph_port_added, NULL, NULL); - assert(ret >= 0); + BT_ASSERT(ret >= 0); ret = bt_graph_add_port_removed_listener(graph, graph_port_removed, NULL, NULL); - assert(ret >= 0); + BT_ASSERT(ret >= 0); ret = bt_graph_add_ports_connected_listener(graph, graph_ports_connected, NULL, NULL); - assert(ret >= 0); + BT_ASSERT(ret >= 0); ret = bt_graph_add_ports_disconnected_listener(graph, graph_ports_disconnected, NULL, NULL); - assert(ret >= 0); + BT_ASSERT(ret >= 0); return graph; } @@ -658,17 +658,17 @@ void test_sink_removes_port_in_port_connected_then_src_removes_disconnected_port prepare_test(TEST_SINK_REMOVES_PORT_IN_CONSUME_THEN_SRC_REMOVES_DISCONNECTED_PORT, "sink removes port in consume, then source removes disconnected port"); graph = create_graph(); - assert(graph); + BT_ASSERT(graph); src = create_src(graph); sink = create_sink(graph); src_def_port = bt_component_source_get_output_port_by_name(src, "out"); - assert(src_def_port); + BT_ASSERT(src_def_port); sink_def_port = bt_component_sink_get_input_port_by_name(sink, "in"); - assert(sink_def_port); + BT_ASSERT(sink_def_port); status = bt_graph_connect_ports(graph, src_def_port, sink_def_port, &conn); - assert(status == 0); - assert(conn); + BT_ASSERT(status == 0); + BT_ASSERT(conn); /* We're supposed to have 7 events so far */ ok(events->len == 7, "we have the expected number of events (before consume)"); @@ -740,7 +740,7 @@ void test_sink_removes_port_in_port_connected_then_src_removes_disconnected_port /* Consume sink once */ clear_events(); ret = bt_graph_consume(graph); - assert(ret == 0); + BT_ASSERT(ret == 0); /* We're supposed to have 5 new events */ ok(events->len == 5, "we have the expected number of events (after consume)"); @@ -835,16 +835,16 @@ void test_sink_removes_port_in_port_connected(void) prepare_test(TEST_SINK_REMOVES_PORT_IN_CONSUME, "sink removes port in consume"); graph = create_graph(); - assert(graph); + BT_ASSERT(graph); src = create_src(graph); sink = create_sink(graph); src_def_port = bt_component_source_get_output_port_by_name(src, "out"); - assert(src_def_port); + BT_ASSERT(src_def_port); sink_def_port = bt_component_sink_get_input_port_by_name(sink, "in"); - assert(sink_def_port); + BT_ASSERT(sink_def_port); status = bt_graph_connect_ports(graph, src_def_port, sink_def_port, &conn); - assert(status == 0); + BT_ASSERT(status == 0); /* We're supposed to have 7 events so far */ ok(events->len == 7, "we have the expected number of events (before consume)"); @@ -916,7 +916,7 @@ void test_sink_removes_port_in_port_connected(void) /* Consume sink once */ clear_events(); ret = bt_graph_consume(graph); - assert(ret == 0); + BT_ASSERT(ret == 0); /* We're supposed to have 4 new events */ ok(events->len == 4, "we have the expected number of events (after consume)"); @@ -993,19 +993,19 @@ void test_src_adds_port_in_port_connected(void) prepare_test(TEST_SRC_ADDS_PORT_IN_PORT_CONNECTED, "source adds port in port connected"); graph = create_graph(); - assert(graph); + BT_ASSERT(graph); src = create_src(graph); sink = create_sink(graph); src_def_port = bt_component_source_get_output_port_by_name(src, "out"); - assert(src_def_port); + BT_ASSERT(src_def_port); sink_def_port = bt_component_sink_get_input_port_by_name(sink, "in"); - assert(sink_def_port); + BT_ASSERT(sink_def_port); status = bt_graph_connect_ports(graph, src_def_port, sink_def_port, &conn); - assert(status == 0); + BT_ASSERT(status == 0); src_hello_port = bt_component_source_get_output_port_by_name(src, "hello"); - assert(src_hello_port); + BT_ASSERT(src_hello_port); /* We're supposed to have 8 events */ ok(events->len == 8, "we have the expected number of events"); @@ -1113,16 +1113,16 @@ void test_simple(void) prepare_test(TEST_SIMPLE, "simple"); graph = create_graph(); - assert(graph); + BT_ASSERT(graph); src = create_src(graph); sink = create_sink(graph); src_def_port = bt_component_source_get_output_port_by_name(src, "out"); - assert(src_def_port); + BT_ASSERT(src_def_port); sink_def_port = bt_component_sink_get_input_port_by_name(sink, "in"); - assert(sink_def_port); + BT_ASSERT(sink_def_port); status = bt_graph_connect_ports(graph, src_def_port, sink_def_port, &conn); - assert(status == 0); + BT_ASSERT(status == 0); /* We're supposed to have 7 events */ ok(events->len == 7, "we have the expected number of events"); diff --git a/tests/lib/test_ir_visit.c b/tests/lib/test_ir_visit.c index 50498c2c..bc2da8e7 100644 --- a/tests/lib/test_ir_visit.c +++ b/tests/lib/test_ir_visit.c @@ -29,7 +29,7 @@ #include #include #include -#include +#include #define NR_TESTS 13 @@ -107,35 +107,35 @@ static void set_stream_class_field_types( int ret; packet_context_type = bt_field_type_structure_create(); - assert(packet_context_type); + BT_ASSERT(packet_context_type); ft = bt_field_type_integer_create(32); - assert(ft); + BT_ASSERT(ft); ret = bt_field_type_structure_add_field(packet_context_type, ft, "packet_size"); - assert(ret == 0); + BT_ASSERT(ret == 0); bt_put(ft); ft = bt_field_type_integer_create(32); - assert(ft); + BT_ASSERT(ft); ret = bt_field_type_structure_add_field(packet_context_type, ft, "content_size"); - assert(ret == 0); + BT_ASSERT(ret == 0); bt_put(ft); event_header_type = bt_field_type_structure_create(); - assert(event_header_type); + BT_ASSERT(event_header_type); ft = bt_field_type_integer_create(32); - assert(ft); + BT_ASSERT(ft); ret = bt_field_type_structure_add_field(event_header_type, ft, "id"); - assert(ret == 0); + BT_ASSERT(ret == 0); bt_put(ft); ret = bt_stream_class_set_packet_context_field_type(stream_class, packet_context_type); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_stream_class_set_event_header_field_type(stream_class, event_header_type); - assert(ret == 0); + BT_ASSERT(ret == 0); bt_put(packet_context_type); bt_put(event_header_type); @@ -148,17 +148,17 @@ static void set_trace_packet_header(struct bt_trace *trace) int ret; packet_header_type = bt_field_type_structure_create(); - assert(packet_header_type); + BT_ASSERT(packet_header_type); ft = bt_field_type_integer_create(32); - assert(ft); + BT_ASSERT(ft); ret = bt_field_type_structure_add_field(packet_header_type, ft, "stream_id"); - assert(ret == 0); + BT_ASSERT(ret == 0); bt_put(ft); ret = bt_trace_set_packet_header_field_type(trace, packet_header_type); - assert(ret == 0); + BT_ASSERT(ret == 0); bt_put(packet_header_type); } diff --git a/tests/lib/test_plugin.c b/tests/lib/test_plugin.c index c367b90d..c8578827 100644 --- a/tests/lib/test_plugin.c +++ b/tests/lib/test_plugin.c @@ -28,7 +28,7 @@ #include #include #include -#include +#include #include #include "tap/tap.h" #include "common.h" @@ -114,7 +114,7 @@ static void test_minimal(const char *plugin_dir) struct bt_plugin *plugin; char *minimal_path = get_test_plugin_path(plugin_dir, "minimal"); - assert(minimal_path); + BT_ASSERT(minimal_path); diag("minimal plugin test below"); reset_test_plugin_env_vars(); @@ -172,12 +172,12 @@ static void test_sfs(const char *plugin_dir) struct bt_query_executor *query_exec = bt_query_executor_create(); int ret; - assert(query_exec); - assert(sfs_path); + BT_ASSERT(query_exec); + BT_ASSERT(sfs_path); diag("sfs plugin test below"); plugin_set = bt_plugin_create_all_from_file(sfs_path); - assert(plugin_set && bt_plugin_set_get_plugin_count(plugin_set) == 1); + BT_ASSERT(plugin_set && bt_plugin_set_get_plugin_count(plugin_set) == 1); plugin = bt_plugin_set_get_plugin(plugin_set, 0); ok(bt_plugin_get_version(plugin, &major, &minor, &patch, &extra) == BT_PLUGIN_STATUS_OK, @@ -217,7 +217,7 @@ static void test_sfs(const char *plugin_dir) BT_COMPONENT_CLASS_TYPE_SOURCE), "bt_plugin_get_component_class_by_name_and_type() does not find a component class given the wrong type"); params = bt_value_integer_create_init(23); - assert(params); + BT_ASSERT(params); ret = bt_query_executor_query(NULL, filter_comp_class, "object", params, &results); ok (ret, "bt_query_executor_query() handles NULL (query executor)"); @@ -230,11 +230,11 @@ static void test_sfs(const char *plugin_dir) ret = bt_query_executor_query(query_exec, filter_comp_class, "get-something", params, &results); ok(ret == 0 && results, "bt_query_executor_query() succeeds"); - assert(bt_value_is_array(results) && bt_value_array_size(results) == 2); + BT_ASSERT(bt_value_is_array(results) && bt_value_array_size(results) == 2); object = bt_value_array_get(results, 0); - assert(object && bt_value_is_string(object)); + BT_ASSERT(object && bt_value_is_string(object)); value_ret = bt_value_string_get(object, &object_str); - assert(value_ret == BT_VALUE_STATUS_OK); + BT_ASSERT(value_ret == BT_VALUE_STATUS_OK); ok(strcmp(object_str, "get-something") == 0, "bt_component_class_query() receives the expected object name"); res_params = bt_value_array_get(results, 1); @@ -244,7 +244,7 @@ static void test_sfs(const char *plugin_dir) diag("> putting the plugin object here"); BT_PUT(plugin); graph = bt_graph_create(); - assert(graph); + BT_ASSERT(graph); graph_ret = bt_graph_add_component(graph, sink_comp_class, "the-sink", NULL, &sink_component); ok(graph_ret == BT_GRAPH_STATUS_OK && sink_component, @@ -253,7 +253,7 @@ static void test_sfs(const char *plugin_dir) BT_PUT(source_comp_class); bt_put(graph); graph = bt_graph_create(); - assert(graph); + BT_ASSERT(graph); graph_ret = bt_graph_add_component(graph, sink_comp_class, "the-sink", NULL, &sink_component); ok(graph_ret == BT_GRAPH_STATUS_OK && sink_component, @@ -262,7 +262,7 @@ static void test_sfs(const char *plugin_dir) BT_PUT(filter_comp_class); bt_put(graph); graph = bt_graph_create(); - assert(graph); + BT_ASSERT(graph); graph_ret = bt_graph_add_component(graph, sink_comp_class, "the-sink", NULL, &sink_component); ok(graph_ret == BT_GRAPH_STATUS_OK && sink_component, @@ -320,7 +320,7 @@ static void test_find(const char *plugin_dir) "8db46494-a398-466a-9649-c765ae077629" G_SEARCHPATH_SEPARATOR_S, NON_EXISTING_PATH, plugin_dir); - assert(ret > 0 && plugin_path); + BT_ASSERT(ret > 0 && plugin_path); g_setenv("BABELTRACE_PLUGIN_PATH", plugin_path, 1); plugin = bt_plugin_find("test_minimal"); ok(plugin, diff --git a/tests/plugins/test-utils-muxer.c b/tests/plugins/test-utils-muxer.c index c02bbbef..7648fa11 100644 --- a/tests/plugins/test-utils-muxer.c +++ b/tests/plugins/test-utils-muxer.c @@ -21,7 +21,7 @@ #include #include #include -#include +#include #include #include @@ -262,7 +262,7 @@ bool compare_test_events(const struct test_event *expected_events) const struct test_event *expected_event = expected_events; size_t i = 0; - assert(expected_events); + BT_ASSERT(expected_events); while (true) { const struct test_event *event; @@ -308,82 +308,82 @@ void init_static_data(void) /* Test events */ test_events = g_array_new(FALSE, TRUE, sizeof(struct test_event)); - assert(test_events); + BT_ASSERT(test_events); /* Metadata */ empty_struct_ft = bt_field_type_structure_create(); - assert(empty_struct_ft); + BT_ASSERT(empty_struct_ft); src_clock_class = bt_clock_class_create("my-clock", 1000000000); - assert(src_clock_class); + BT_ASSERT(src_clock_class); trace = bt_trace_create(); - assert(trace); + BT_ASSERT(trace); ret = bt_trace_set_native_byte_order(trace, BT_BYTE_ORDER_LITTLE_ENDIAN); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_trace_set_packet_header_field_type(trace, empty_struct_ft); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_clock_class_set_is_absolute(src_clock_class, 1); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_trace_add_clock_class(trace, src_clock_class); - assert(ret == 0); + BT_ASSERT(ret == 0); src_empty_cc_prio_map = bt_clock_class_priority_map_create(); - assert(src_empty_cc_prio_map); + BT_ASSERT(src_empty_cc_prio_map); src_cc_prio_map = bt_clock_class_priority_map_create(); - assert(src_cc_prio_map); + BT_ASSERT(src_cc_prio_map); ret = bt_clock_class_priority_map_add_clock_class(src_cc_prio_map, src_clock_class, 0); - assert(ret == 0); + BT_ASSERT(ret == 0); src_stream_class = bt_stream_class_create("my-stream-class"); - assert(src_stream_class); + BT_ASSERT(src_stream_class); ret = bt_stream_class_set_packet_context_field_type(src_stream_class, empty_struct_ft); - assert(ret == 0); + BT_ASSERT(ret == 0); eh_ft = bt_field_type_structure_create(); - assert(eh_ft); + BT_ASSERT(eh_ft); eh_ts_ft = bt_field_type_integer_create(64); - assert(eh_ts_ft); + BT_ASSERT(eh_ts_ft); ret = bt_field_type_structure_add_field(eh_ft, eh_ts_ft, "ts"); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_field_type_integer_set_mapped_clock_class(eh_ts_ft, src_clock_class); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_stream_class_set_event_header_field_type(src_stream_class, eh_ft); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_stream_class_set_event_context_field_type(src_stream_class, empty_struct_ft); - assert(ret == 0); + BT_ASSERT(ret == 0); src_event_class = bt_event_class_create("my-event-class"); ret = bt_event_class_set_context_field_type(src_event_class, empty_struct_ft); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_event_class_set_context_field_type(src_event_class, empty_struct_ft); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_stream_class_add_event_class(src_stream_class, src_event_class); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_trace_add_stream_class(trace, src_stream_class); - assert(ret == 0); + BT_ASSERT(ret == 0); stream = bt_stream_create(src_stream_class, "stream0", 0); - assert(stream); + BT_ASSERT(stream); src_packet0 = bt_packet_create(stream); - assert(src_packet0); + BT_ASSERT(src_packet0); bt_put(stream); stream = bt_stream_create(src_stream_class, "stream1", 1); - assert(stream); + BT_ASSERT(stream); src_packet1 = bt_packet_create(stream); - assert(src_packet0); + BT_ASSERT(src_packet0); bt_put(stream); stream = bt_stream_create(src_stream_class, "stream2", 2); - assert(stream); + BT_ASSERT(stream); src_packet2 = bt_packet_create(stream); - assert(src_packet0); + BT_ASSERT(src_packet0); bt_put(stream); stream = bt_stream_create(src_stream_class, "stream3", 3); - assert(stream); + BT_ASSERT(stream); src_packet3 = bt_packet_create(stream); - assert(src_packet0); + BT_ASSERT(src_packet0); bt_put(stream); bt_put(trace); @@ -434,13 +434,13 @@ enum bt_notification_iterator_status src_iter_init( const char *port_name; int ret; - assert(user_data); - assert(port); + BT_ASSERT(user_data); + BT_ASSERT(port); ret = bt_private_connection_private_notification_iterator_set_user_data(priv_notif_iter, user_data); - assert(ret == 0); + BT_ASSERT(ret == 0); port_name = bt_port_get_name(port); - assert(port_name); + BT_ASSERT(port_name); user_data->iter_index = port_name[3] - '0'; switch (user_data->iter_index) { @@ -517,19 +517,19 @@ struct bt_notification *src_create_event_notif(struct bt_packet *packet, notif = bt_notification_event_create(graph, src_event_class, packet, cc_prio_map); - assert(notif); + BT_ASSERT(notif); event = bt_notification_event_borrow_event(notif); - assert(event); + BT_ASSERT(event); field = bt_event_borrow_header(event); - assert(field); + BT_ASSERT(field); field = bt_field_structure_borrow_field_by_name(field, "ts"); - assert(field); + BT_ASSERT(field); ret = bt_field_integer_unsigned_set_value(field, (uint64_t) ts_ns); - assert(ret == 0); + BT_ASSERT(ret == 0); clock_value = bt_event_borrow_clock_value(event, src_clock_class); - assert(clock_value); + BT_ASSERT(clock_value); ret = bt_clock_value_set_value(clock_value, (uint64_t) ts_ns); - assert(ret == 0); + BT_ASSERT(ret == 0); return notif; } @@ -543,7 +543,7 @@ struct bt_notification_iterator_next_method_return src_iter_next_seq( int64_t cur_ts_ns; struct bt_stream *stream; - assert(user_data->seq); + BT_ASSERT(user_data->seq); cur_ts_ns = user_data->seq[user_data->at]; switch (cur_ts_ns) { @@ -559,33 +559,33 @@ struct bt_notification_iterator_next_method_return src_iter_next_seq( next_return.notification = bt_notification_packet_begin_create(graph, user_data->packet); - assert(next_return.notification); + BT_ASSERT(next_return.notification); break; case SEQ_PACKET_END: next_return.notification = bt_notification_packet_end_create(graph, user_data->packet); - assert(next_return.notification); + BT_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_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_ASSERT(next_return.notification); bt_put(stream); break; default: { next_return.notification = src_create_event_notif( user_data->packet, src_cc_prio_map, cur_ts_ns); - assert(next_return.notification); + BT_ASSERT(next_return.notification); break; } } @@ -612,8 +612,8 @@ struct bt_notification_iterator_next_method_return src_iter_next( struct bt_stream *stream; int ret; - assert(user_data); - assert(private_component); + BT_ASSERT(user_data); + BT_ASSERT(private_component); switch (current_test) { case TEST_NO_TS: @@ -624,30 +624,30 @@ struct bt_notification_iterator_next_method_return src_iter_next( bt_notification_stream_begin_create( graph, stream); bt_put(stream); - assert(next_return.notification); + BT_ASSERT(next_return.notification); } else if (user_data->at == 1) { next_return.notification = bt_notification_packet_begin_create( graph, user_data->packet); - assert(next_return.notification); + BT_ASSERT(next_return.notification); } else if (user_data->at < 7) { next_return.notification = src_create_event_notif( user_data->packet, src_empty_cc_prio_map, 0); - assert(next_return.notification); + BT_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); + BT_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_ASSERT(next_return.notification); } else { next_return.status = BT_NOTIFICATION_ITERATOR_STATUS_END; @@ -666,10 +666,10 @@ struct bt_notification_iterator_next_method_return src_iter_next( if (user_data->iter_index == 0) { ret = bt_private_component_source_add_output_private_port( private_component, "out1", NULL, NULL); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_private_component_source_add_output_private_port( private_component, "out2", NULL, NULL); - assert(ret == 0); + BT_ASSERT(ret == 0); next_return.status = BT_NOTIFICATION_ITERATOR_STATUS_END; } else { next_return = src_iter_next_seq(user_data); @@ -683,10 +683,10 @@ struct bt_notification_iterator_next_method_return src_iter_next( } else { ret = bt_private_component_source_add_output_private_port( private_component, "out1", NULL, NULL); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_private_component_source_add_output_private_port( private_component, "out2", NULL, NULL); - assert(ret == 0); + BT_ASSERT(ret == 0); next_return.status = BT_NOTIFICATION_ITERATOR_STATUS_END; } } else { @@ -725,25 +725,25 @@ enum bt_component_status src_init( if (nb_ports >= 1) { ret = bt_private_component_source_add_output_private_port( private_component, "out0", NULL, NULL); - assert(ret == 0); + BT_ASSERT(ret == 0); } if (nb_ports >= 2) { ret = bt_private_component_source_add_output_private_port( private_component, "out1", NULL, NULL); - assert(ret == 0); + BT_ASSERT(ret == 0); } if (nb_ports >= 3) { ret = bt_private_component_source_add_output_private_port( private_component, "out2", NULL, NULL); - assert(ret == 0); + BT_ASSERT(ret == 0); } if (nb_ports >= 4) { ret = bt_private_component_source_add_output_private_port( private_component, "out3", NULL, NULL); - assert(ret == 0); + BT_ASSERT(ret == 0); } return BT_COMPONENT_STATUS_OK; @@ -766,7 +766,7 @@ enum bt_component_status sink_consume( struct test_event test_event; bool do_append_test_event = true; - assert(user_data && user_data->notif_iter); + BT_ASSERT(user_data && user_data->notif_iter); it_ret = bt_notification_iterator_next(user_data->notif_iter); if (it_ret < 0) { @@ -791,7 +791,7 @@ enum bt_component_status sink_consume( notification = bt_notification_iterator_get_notification( user_data->notif_iter); - assert(notification); + BT_ASSERT(notification); switch (bt_notification_get_type(notification)) { case BT_NOTIFICATION_TYPE_EVENT: @@ -803,9 +803,9 @@ enum bt_component_status sink_consume( cc_prio_map = bt_notification_event_borrow_clock_class_priority_map( notification); - assert(cc_prio_map); + BT_ASSERT(cc_prio_map); event = bt_notification_event_borrow_event(notification); - assert(event); + BT_ASSERT(event); if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map) > 0) { struct bt_clock_value *clock_value; @@ -813,13 +813,13 @@ enum bt_component_status sink_consume( bt_clock_class_priority_map_borrow_highest_priority_clock_class( cc_prio_map); - assert(clock_class); + BT_ASSERT(clock_class); clock_value = bt_event_borrow_clock_value(event, clock_class); - assert(clock_value); + BT_ASSERT(clock_value); ret = bt_clock_value_get_value_ns_from_epoch( clock_value, &test_event.ts_ns); - assert(ret == 0); + BT_ASSERT(ret == 0); } else { test_event.ts_ns = -1; } @@ -833,7 +833,7 @@ enum bt_component_status sink_consume( test_event.type = TEST_EV_TYPE_NOTIF_INACTIVITY; cc_prio_map = bt_notification_inactivity_borrow_clock_class_priority_map( notification); - assert(cc_prio_map); + BT_ASSERT(cc_prio_map); if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map) > 0) { struct bt_clock_value *clock_value; @@ -841,14 +841,14 @@ enum bt_component_status sink_consume( bt_clock_class_priority_map_borrow_highest_priority_clock_class( cc_prio_map); - assert(clock_class); + BT_ASSERT(clock_class); clock_value = bt_notification_inactivity_borrow_clock_value( notification, clock_class); - assert(clock_value); + BT_ASSERT(clock_value); ret = bt_clock_value_get_value_ns_from_epoch( clock_value, &test_event.ts_ns); - assert(ret == 0); + BT_ASSERT(ret == 0); } else { test_event.ts_ns = -1; } @@ -892,11 +892,11 @@ void sink_port_connected(struct bt_private_component *private_component, private_component); enum bt_connection_status conn_status; - assert(user_data); - assert(priv_conn); + BT_ASSERT(user_data); + BT_ASSERT(priv_conn); conn_status = bt_private_connection_create_notification_iterator( priv_conn, &user_data->notif_iter); - assert(conn_status == 0); + BT_ASSERT(conn_status == 0); bt_put(priv_conn); } @@ -908,13 +908,13 @@ enum bt_component_status sink_init( struct sink_user_data *user_data = g_new0(struct sink_user_data, 1); int ret; - assert(user_data); + BT_ASSERT(user_data); ret = bt_private_component_set_user_data(private_component, user_data); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_private_component_sink_add_input_private_port( private_component, "in", NULL, NULL); - assert(ret == 0); + BT_ASSERT(ret == 0); return BT_COMPONENT_STATUS_OK; } @@ -943,40 +943,40 @@ void create_source_muxer_sink(struct bt_graph *graph, /* Create source component */ src_comp_class = bt_component_class_source_create("src", src_iter_next); - assert(src_comp_class); + BT_ASSERT(src_comp_class); ret = bt_component_class_set_init_method(src_comp_class, src_init); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_component_class_set_finalize_method(src_comp_class, src_finalize); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_component_class_source_set_notification_iterator_init_method( src_comp_class, src_iter_init); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_component_class_source_set_notification_iterator_finalize_method( src_comp_class, src_iter_finalize); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_graph_add_component(graph, src_comp_class, "source", NULL, source); - assert(ret == 0); + BT_ASSERT(ret == 0); /* Create muxer component */ muxer_comp_class = bt_plugin_find_component_class("utils", "muxer", BT_COMPONENT_CLASS_TYPE_FILTER); - assert(muxer_comp_class); + BT_ASSERT(muxer_comp_class); ret = bt_graph_add_component(graph, muxer_comp_class, "muxer", NULL, muxer); - assert(ret == 0); + BT_ASSERT(ret == 0); /* Create sink component */ sink_comp_class = bt_component_class_sink_create("sink", sink_consume); - assert(sink_comp_class); + BT_ASSERT(sink_comp_class); ret = bt_component_class_set_init_method(sink_comp_class, sink_init); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_component_class_set_finalize_method(sink_comp_class, sink_finalize); ret = bt_component_class_set_port_connected_method(sink_comp_class, sink_port_connected); - assert(ret == 0); + BT_ASSERT(ret == 0); ret = bt_graph_add_component(graph, sink_comp_class, "sink", NULL, sink); - assert(ret == 0); + BT_ASSERT(ret == 0); bt_put(src_comp_class); bt_put(muxer_comp_class); @@ -1000,26 +1000,26 @@ void do_std_test(enum test test, const char *name, clear_test_events(); current_test = test; diag("test: %s", name); - assert(!graph); + BT_ASSERT(!graph); graph = bt_graph_create(); - assert(graph); + BT_ASSERT(graph); create_source_muxer_sink(graph, &src_comp, &muxer_comp, &sink_comp); /* Connect source output ports to muxer input ports */ if (with_upstream) { count = bt_component_source_get_output_port_count(src_comp); - assert(count >= 0); + BT_ASSERT(count >= 0); for (i = 0; i < count; i++) { upstream_port = bt_component_source_get_output_port_by_index( src_comp, i); - assert(upstream_port); + BT_ASSERT(upstream_port); downstream_port = bt_component_filter_get_input_port_by_index( muxer_comp, i); - assert(downstream_port); + BT_ASSERT(downstream_port); graph_status = bt_graph_connect_ports(graph, upstream_port, downstream_port, NULL); - assert(graph_status == 0); + BT_ASSERT(graph_status == 0); bt_put(upstream_port); bt_put(downstream_port); } @@ -1028,12 +1028,12 @@ void do_std_test(enum test test, const char *name, /* Connect muxer output port to sink input port */ upstream_port = bt_component_filter_get_output_port_by_name(muxer_comp, "out"); - assert(upstream_port); + BT_ASSERT(upstream_port); downstream_port = bt_component_sink_get_input_port_by_name(sink_comp, "in"); - assert(downstream_port); + BT_ASSERT(downstream_port); graph_status = bt_graph_connect_ports(graph, upstream_port, downstream_port, NULL); - assert(graph_status == 0); + BT_ASSERT(graph_status == 0); bt_put(upstream_port); bt_put(downstream_port); @@ -1356,14 +1356,14 @@ void connect_port_to_first_avail_muxer_port(struct bt_graph *graph, enum bt_graph_status graph_status; count = bt_component_filter_get_input_port_count(muxer_comp); - assert(count >= 0); + BT_ASSERT(count >= 0); for (i = 0; i < count; i++) { struct bt_port *muxer_port = bt_component_filter_get_input_port_by_index( muxer_comp, i); - assert(muxer_port); + BT_ASSERT(muxer_port); if (!bt_port_is_connected(muxer_port)) { BT_MOVE(avail_muxer_port, muxer_port); @@ -1375,7 +1375,7 @@ void connect_port_to_first_avail_muxer_port(struct bt_graph *graph, graph_status = bt_graph_connect_ports(graph, source_port, avail_muxer_port, NULL); - assert(graph_status == 0); + BT_ASSERT(graph_status == 0); bt_put(avail_muxer_port); } @@ -1387,7 +1387,7 @@ void graph_port_added_listener_connect_to_avail_muxer_port(struct bt_port *port, struct bt_component *comp; comp = bt_port_get_component(port); - assert(comp); + BT_ASSERT(comp); if (comp != graph_listener_data->source) { goto end; @@ -1474,9 +1474,9 @@ 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); + BT_ASSERT(!graph); graph = bt_graph_create(); - assert(graph); + BT_ASSERT(graph); create_source_muxer_sink(graph, &src_comp, &muxer_comp, &sink_comp); graph_listener_data.graph = graph; graph_listener_data.source = src_comp; @@ -1485,16 +1485,16 @@ void test_single_end_then_multiple_full(void) ret = bt_graph_add_port_added_listener(graph, graph_port_added_listener_connect_to_avail_muxer_port, NULL, &graph_listener_data); - assert(ret >= 0); + BT_ASSERT(ret >= 0); /* Connect source output ports to muxer input ports */ count = bt_component_source_get_output_port_count(src_comp); - assert(ret == 0); + BT_ASSERT(ret == 0); for (i = 0; i < count; i++) { upstream_port = bt_component_source_get_output_port_by_index( src_comp, i); - assert(upstream_port); + BT_ASSERT(upstream_port); connect_port_to_first_avail_muxer_port(graph, upstream_port, muxer_comp); bt_put(upstream_port); @@ -1503,12 +1503,12 @@ void test_single_end_then_multiple_full(void) /* Connect muxer output port to sink input port */ upstream_port = bt_component_filter_get_output_port_by_name(muxer_comp, "out"); - assert(upstream_port); + BT_ASSERT(upstream_port); downstream_port = bt_component_sink_get_input_port_by_name(sink_comp, "in"); - assert(downstream_port); + BT_ASSERT(downstream_port); graph_status = bt_graph_connect_ports(graph, upstream_port, downstream_port, NULL); - assert(graph_status == 0); + BT_ASSERT(graph_status == 0); bt_put(upstream_port); bt_put(downstream_port); @@ -1602,9 +1602,9 @@ 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); + BT_ASSERT(!graph); graph = bt_graph_create(); - assert(graph); + BT_ASSERT(graph); create_source_muxer_sink(graph, &src_comp, &muxer_comp, &sink_comp); graph_listener_data.graph = graph; graph_listener_data.source = src_comp; @@ -1613,16 +1613,16 @@ void test_single_again_end_then_multiple_full(void) ret = bt_graph_add_port_added_listener(graph, graph_port_added_listener_connect_to_avail_muxer_port, NULL, &graph_listener_data); - assert(ret >= 0); + BT_ASSERT(ret >= 0); /* Connect source output ports to muxer input ports */ count = bt_component_source_get_output_port_count(src_comp); - assert(ret == 0); + BT_ASSERT(ret == 0); for (i = 0; i < count; i++) { upstream_port = bt_component_source_get_output_port_by_index( src_comp, i); - assert(upstream_port); + BT_ASSERT(upstream_port); connect_port_to_first_avail_muxer_port(graph, upstream_port, muxer_comp); bt_put(upstream_port); @@ -1631,12 +1631,12 @@ void test_single_again_end_then_multiple_full(void) /* Connect muxer output port to sink input port */ upstream_port = bt_component_filter_get_output_port_by_name(muxer_comp, "out"); - assert(upstream_port); + BT_ASSERT(upstream_port); downstream_port = bt_component_sink_get_input_port_by_name(sink_comp, "in"); - assert(downstream_port); + BT_ASSERT(downstream_port); graph_status = bt_graph_connect_ports(graph, upstream_port, downstream_port, NULL); - assert(graph_status == 0); + BT_ASSERT(graph_status == 0); bt_put(upstream_port); bt_put(downstream_port); diff --git a/tests/utils/tap/tap.c b/tests/utils/tap/tap.c index 4d09a58a..d3d3f3df 100644 --- a/tests/utils/tap/tap.c +++ b/tests/utils/tap/tap.c @@ -29,7 +29,7 @@ #include #include #include -#include +#include #include #include @@ -304,7 +304,7 @@ diag_multiline(const char *val) { size_t len, i, line_start_idx = 0; - assert(val); + BT_ASSERT(val); len = strlen(val); for (i = 0; i < len; i++) { @@ -314,7 +314,7 @@ diag_multiline(const char *val) continue; } - assert((i - line_start_idx + 1) <= INT_MAX); + BT_ASSERT((i - line_start_idx + 1) <= INT_MAX); line_length = i - line_start_idx + 1; fprintf(stderr, "# %.*s", line_length, &val[line_start_idx]); line_start_idx = i + 1; -- 2.34.1