X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=tests%2Flib%2Ftest_bt_ctf_field_type_validation.c;h=b31b6197d150bbcdab1de33d7f57b92561f03537;hb=25583cd07e351a64d645978905be94227355f0e5;hp=f88cecd533cd15158ff0edde557d939af89f3e8d;hpb=2dd764c1b4c758c8843e4e06e56012661b656166;p=babeltrace.git 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);