assert-pre-internal.h: add BT_ASSERT_PRE_VALID_INDEX()

[babeltrace.git] / tests / lib / test_bt_ctf_field_type_validation.c

diff --git a/tests/lib/test_bt_ctf_field_type_validation.c b/tests/lib/test_bt_ctf_field_type_validation.c
index f88cecd533cd15158ff0edde557d939af89f3e8d..b31b6197d150bbcdab1de33d7f57b92561f03537 100644 (file)
--- 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 <babeltrace/ctf-ir/event-class.h>
 #include <babeltrace/ctf-ir/stream-class.h>
 #include <babeltrace/ctf-ir/trace.h>
-#include <assert.h>
+#include <babeltrace/assert-internal.h>
 #include <stdbool.h>
 #include <string.h>
 #include <stdarg.h>
@@ -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);