Test fix: fixed allocation size used for variable length input

[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 0e8b07880c0df90c31a945380cb2668819cc455f..ab1f782fbab68201afc7a8f679d92b8002d5ca5f 100644 (file)
--- a/tests/lib/test_bt_ctf_field_type_validation.c
+++ b/tests/lib/test_bt_ctf_field_type_validation.c
@@ -19,12 +19,14 @@
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
-#include <babeltrace/ctf-ir/event-types.h>
+#include <babeltrace/ctf-ir/field-types.h>
 #include <babeltrace/ctf-ir/field-path.h>
 #include <babeltrace/ctf-ir/event.h>
+#include <babeltrace/ctf-ir/event-class.h>
 #include <babeltrace/ctf-ir/stream-class.h>
 #include <babeltrace/ctf-ir/trace.h>
 #include <assert.h>
+#include <stdbool.h>
 #include <string.h>
 #include <stdarg.h>
 #include <glib.h>
@@ -144,7 +146,7 @@ struct bt_ctf_field_type *get_good_packet_header_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_magic, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_magic, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_magic, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_magic, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -158,7 +160,7 @@ struct bt_ctf_field_type *get_good_packet_header_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_uuid_elem, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_uuid_elem, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_uuid_elem, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_uuid_elem, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -174,7 +176,7 @@ struct bt_ctf_field_type *get_good_packet_header_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_stream_id, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_stream_id, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_stream_id, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_stream_id, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -188,7 +190,7 @@ struct bt_ctf_field_type *get_good_packet_header_type(void)
        assert(ret == 0);
        root_iron_listen = bt_ctf_field_type_string_create();
        assert(root_iron_listen);
-       ret = bt_ctf_field_type_string_set_encoding(root_iron_listen, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_iron_listen, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        ret = bt_ctf_field_type_structure_add_field(root_iron, root_iron_listen, "listen");
        assert(ret == 0);
@@ -198,7 +200,7 @@ struct bt_ctf_field_type *get_good_packet_header_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_iron_dust, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_iron_dust, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_iron_dust, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_iron_dust, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -212,7 +214,7 @@ struct bt_ctf_field_type *get_good_packet_header_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_iron_parallel_int, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_iron_parallel_int, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_iron_parallel_int, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_iron_parallel_int, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -238,7 +240,7 @@ struct bt_ctf_field_type *get_good_packet_header_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_iron_fire_word, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_iron_fire_word, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_iron_fire_word, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_iron_fire_word, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -248,7 +250,7 @@ struct bt_ctf_field_type *get_good_packet_header_type(void)
        assert(ret == 0);
        root_iron_fire_rabbit = bt_ctf_field_type_string_create();
        assert(root_iron_fire_rabbit);
-       ret = bt_ctf_field_type_string_set_encoding(root_iron_fire_rabbit, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_iron_fire_rabbit, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        ret = bt_ctf_field_type_structure_add_field(root_iron_fire, root_iron_fire_rabbit, "rabbit");
        assert(ret == 0);
@@ -256,7 +258,7 @@ struct bt_ctf_field_type *get_good_packet_header_type(void)
        assert(root_iron_fire_keen_elem);
        root_iron_fire_keen_elem_RED = bt_ctf_field_type_string_create();
        assert(root_iron_fire_keen_elem_RED);
-       ret = bt_ctf_field_type_string_set_encoding(root_iron_fire_keen_elem_RED, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_iron_fire_keen_elem_RED, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        ret = bt_ctf_field_type_variant_add_field(root_iron_fire_keen_elem, root_iron_fire_keen_elem_RED, "RED");
        assert(ret == 0);
@@ -266,7 +268,7 @@ struct bt_ctf_field_type *get_good_packet_header_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_iron_fire_keen_elem_BLUE_elem, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_iron_fire_keen_elem_BLUE_elem, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_iron_fire_keen_elem_BLUE_elem, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_iron_fire_keen_elem_BLUE_elem, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -290,7 +292,7 @@ struct bt_ctf_field_type *get_good_packet_header_type(void)
        assert(ret == 0);
        root_iron_report_elem = bt_ctf_field_type_string_create();
        assert(root_iron_report_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_iron_report_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_iron_report_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_iron_report = bt_ctf_field_type_sequence_create(root_iron_report_elem, "trace.packet.header.iron.dust");
        assert(root_iron_report);
@@ -298,7 +300,7 @@ struct bt_ctf_field_type *get_good_packet_header_type(void)
        assert(ret == 0);
        root_iron_group_elem = bt_ctf_field_type_string_create();
        assert(root_iron_group_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_iron_group_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_iron_group_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_iron_group = bt_ctf_field_type_sequence_create(root_iron_group_elem, "trace.packet.header.stream_id");
        assert(root_iron_group);
@@ -312,7 +314,7 @@ struct bt_ctf_field_type *get_good_packet_header_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_serious, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_serious, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_serious, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_serious, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -450,7 +452,7 @@ struct bt_ctf_field_type *get_good_packet_context_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_placid, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_placid, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_placid, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_placid, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -460,7 +462,7 @@ struct bt_ctf_field_type *get_good_packet_context_type(void)
        assert(ret == 0);
        root_meow = bt_ctf_field_type_string_create();
        assert(root_meow);
-       ret = bt_ctf_field_type_string_set_encoding(root_meow, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_meow, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        ret = bt_ctf_field_type_structure_add_field(root, root_meow, "meow");
        assert(ret == 0);
@@ -470,7 +472,7 @@ struct bt_ctf_field_type *get_good_packet_context_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_serious, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_serious, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_serious, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_serious, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -480,7 +482,7 @@ struct bt_ctf_field_type *get_good_packet_context_type(void)
        assert(ret == 0);
        root_naive_elem_elem = bt_ctf_field_type_string_create();
        assert(root_naive_elem_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_naive_elem_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_naive_elem_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_naive_elem = bt_ctf_field_type_sequence_create(root_naive_elem_elem, "placid");
        assert(root_naive_elem);
@@ -498,7 +500,7 @@ struct bt_ctf_field_type *get_good_packet_context_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_clover_oval, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_clover_oval, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_clover_oval, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_clover_oval, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -510,7 +512,7 @@ struct bt_ctf_field_type *get_good_packet_context_type(void)
        assert(root_clover_whole);
        root_clover_whole_BLUE_elem = bt_ctf_field_type_string_create();
        assert(root_clover_whole_BLUE_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_clover_whole_BLUE_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_clover_whole_BLUE_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_clover_whole_BLUE = bt_ctf_field_type_sequence_create(root_clover_whole_BLUE_elem, "trace.packet.header.iron.fire.word");
        assert(root_clover_whole_BLUE);
@@ -522,7 +524,7 @@ struct bt_ctf_field_type *get_good_packet_context_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_clover_whole_RED, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_clover_whole_RED, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_clover_whole_RED, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_clover_whole_RED, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -532,7 +534,7 @@ struct bt_ctf_field_type *get_good_packet_context_type(void)
        assert(ret == 0);
        root_clover_whole_YELLOW = bt_ctf_field_type_string_create();
        assert(root_clover_whole_YELLOW);
-       ret = bt_ctf_field_type_string_set_encoding(root_clover_whole_YELLOW, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_clover_whole_YELLOW, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        ret = bt_ctf_field_type_variant_add_field(root_clover_whole, root_clover_whole_YELLOW, "YELLOW");
        assert(ret == 0);
@@ -544,7 +546,7 @@ struct bt_ctf_field_type *get_good_packet_context_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_clover_egg_elem, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_clover_egg_elem, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_clover_egg_elem, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_clover_egg_elem, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -560,7 +562,7 @@ struct bt_ctf_field_type *get_good_packet_context_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_clover_square_int, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_clover_square_int, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_clover_square_int, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_clover_square_int, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -580,7 +582,7 @@ struct bt_ctf_field_type *get_good_packet_context_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_clover_useful_elem, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_clover_useful_elem, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_clover_useful_elem, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_clover_useful_elem, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -594,7 +596,7 @@ struct bt_ctf_field_type *get_good_packet_context_type(void)
        assert(ret == 0);
        root_tart = bt_ctf_field_type_string_create();
        assert(root_tart);
-       ret = bt_ctf_field_type_string_set_encoding(root_tart, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_tart, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        ret = bt_ctf_field_type_structure_add_field(root, root_tart, "tart");
        assert(ret == 0);
@@ -701,7 +703,7 @@ struct bt_ctf_field_type *get_good_event_header_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_id, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_id, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_id, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_id, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -715,7 +717,7 @@ struct bt_ctf_field_type *get_good_event_header_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_timestamp, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_timestamp, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_timestamp, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_timestamp, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -733,7 +735,7 @@ struct bt_ctf_field_type *get_good_event_header_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_action_special, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_action_special, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_action_special, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_action_special, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -743,7 +745,7 @@ struct bt_ctf_field_type *get_good_event_header_type(void)
        assert(ret == 0);
        root_action_lucky_elem = bt_ctf_field_type_string_create();
        assert(root_action_lucky_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_action_lucky_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_action_lucky_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_action_lucky = bt_ctf_field_type_sequence_create(root_action_lucky_elem, "stream.packet.context.placid");
        assert(root_action_lucky);
@@ -751,7 +753,7 @@ struct bt_ctf_field_type *get_good_event_header_type(void)
        assert(ret == 0);
        root_action_dream = bt_ctf_field_type_string_create();
        assert(root_action_dream);
-       ret = bt_ctf_field_type_string_set_encoding(root_action_dream, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_action_dream, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        ret = bt_ctf_field_type_structure_add_field(root_action, root_action_dream, "dream");
        assert(ret == 0);
@@ -761,7 +763,7 @@ struct bt_ctf_field_type *get_good_event_header_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_action_grandiose_elem, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_action_grandiose_elem, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_action_grandiose_elem, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_action_grandiose_elem, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -775,7 +777,7 @@ struct bt_ctf_field_type *get_good_event_header_type(void)
        assert(ret == 0);
        root_stiff_elem = bt_ctf_field_type_string_create();
        assert(root_stiff_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_stiff_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_stiff_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_stiff = bt_ctf_field_type_sequence_create(root_stiff_elem, "clover.whole.RED");
        assert(root_stiff);
@@ -791,7 +793,7 @@ struct bt_ctf_field_type *get_good_event_header_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_fruit_apple_elem, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_fruit_apple_elem, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_fruit_apple_elem, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_fruit_apple_elem, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -898,7 +900,7 @@ struct bt_ctf_field_type *get_good_stream_event_context_type(void)
        assert(ret == 0);
        root_face_branch_elem = bt_ctf_field_type_string_create();
        assert(root_face_branch_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_face_branch_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_face_branch_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_face_branch = bt_ctf_field_type_sequence_create(root_face_branch_elem, "serious");
        assert(root_face_branch);
@@ -906,7 +908,7 @@ struct bt_ctf_field_type *get_good_stream_event_context_type(void)
        assert(ret == 0);
        root_face_income_elem = bt_ctf_field_type_string_create();
        assert(root_face_income_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_face_income_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_face_income_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_face_income = bt_ctf_field_type_sequence_create(root_face_income_elem, "magic");
        assert(root_face_income);
@@ -918,7 +920,7 @@ struct bt_ctf_field_type *get_good_stream_event_context_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_face_magic, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_face_magic, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_face_magic, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_face_magic, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -928,7 +930,7 @@ struct bt_ctf_field_type *get_good_stream_event_context_type(void)
        assert(ret == 0);
        root_face_lucky_elem = bt_ctf_field_type_string_create();
        assert(root_face_lucky_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_face_lucky_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_face_lucky_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_face_lucky = bt_ctf_field_type_sequence_create(root_face_lucky_elem, "magic");
        assert(root_face_lucky);
@@ -942,7 +944,7 @@ struct bt_ctf_field_type *get_good_stream_event_context_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_cats, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_cats, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_cats, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_cats, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -952,7 +954,7 @@ struct bt_ctf_field_type *get_good_stream_event_context_type(void)
        assert(ret == 0);
        root_dream_elem_elem_elem = bt_ctf_field_type_string_create();
        assert(root_dream_elem_elem_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_dream_elem_elem_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_dream_elem_elem_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_dream_elem_elem = bt_ctf_field_type_sequence_create(root_dream_elem_elem_elem, "stream.event.context.face.magic");
        assert(root_dream_elem_elem);
@@ -968,7 +970,7 @@ struct bt_ctf_field_type *get_good_stream_event_context_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_stream_id, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_stream_id, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_stream_id, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_stream_id, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -1116,7 +1118,7 @@ struct bt_ctf_field_type *get_good_event_context_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_film, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_film, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_film, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_film, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -1130,7 +1132,7 @@ struct bt_ctf_field_type *get_good_event_context_type(void)
        assert(ret == 0);
        root_berry_pine_elem = bt_ctf_field_type_string_create();
        assert(root_berry_pine_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_berry_pine_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_berry_pine_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_berry_pine = bt_ctf_field_type_sequence_create(root_berry_pine_elem, "stream_id");
        assert(root_berry_pine);
@@ -1138,7 +1140,7 @@ struct bt_ctf_field_type *get_good_event_context_type(void)
        assert(ret == 0);
        root_berry_porter_elem = bt_ctf_field_type_string_create();
        assert(root_berry_porter_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_berry_porter_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_berry_porter_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_berry_porter = bt_ctf_field_type_sequence_create(root_berry_porter_elem, "face.magic");
        assert(root_berry_porter);
@@ -1146,7 +1148,7 @@ struct bt_ctf_field_type *get_good_event_context_type(void)
        assert(ret == 0);
        root_berry_mice_elem = bt_ctf_field_type_string_create();
        assert(root_berry_mice_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_berry_mice_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_berry_mice_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_berry_mice = bt_ctf_field_type_sequence_create(root_berry_mice_elem, "action.special");
        assert(root_berry_mice);
@@ -1158,7 +1160,7 @@ struct bt_ctf_field_type *get_good_event_context_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_berry_third, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_berry_third, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_berry_third, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_berry_third, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -1168,7 +1170,7 @@ struct bt_ctf_field_type *get_good_event_context_type(void)
        assert(ret == 0);
        root_berry_guard_elem = bt_ctf_field_type_string_create();
        assert(root_berry_guard_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_berry_guard_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_berry_guard_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_berry_guard = bt_ctf_field_type_sequence_create(root_berry_guard_elem, "clover.oval");
        assert(root_berry_guard);
@@ -1176,7 +1178,7 @@ struct bt_ctf_field_type *get_good_event_context_type(void)
        assert(ret == 0);
        root_berry_one_elem = bt_ctf_field_type_string_create();
        assert(root_berry_one_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_berry_one_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_berry_one_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_berry_one = bt_ctf_field_type_sequence_create(root_berry_one_elem, "iron.fire.word");
        assert(root_berry_one);
@@ -1190,7 +1192,7 @@ struct bt_ctf_field_type *get_good_event_context_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_cats, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_cats, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_cats, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_cats, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -1204,7 +1206,7 @@ struct bt_ctf_field_type *get_good_event_context_type(void)
        assert(ret == 0);
        root_loud_toys_elem = bt_ctf_field_type_string_create();
        assert(root_loud_toys_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_loud_toys_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_loud_toys_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_loud_toys = bt_ctf_field_type_sequence_create(root_loud_toys_elem, "trace.packet.header.iron.fire.word");
        assert(root_loud_toys);
@@ -1212,7 +1214,7 @@ struct bt_ctf_field_type *get_good_event_context_type(void)
        assert(ret == 0);
        root_loud_spoon_elem = bt_ctf_field_type_string_create();
        assert(root_loud_spoon_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_loud_spoon_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_loud_spoon_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_loud_spoon = bt_ctf_field_type_sequence_create(root_loud_spoon_elem, "stream.packet.context.clover.oval");
        assert(root_loud_spoon);
@@ -1220,7 +1222,7 @@ struct bt_ctf_field_type *get_good_event_context_type(void)
        assert(ret == 0);
        root_loud_turkey_elem = bt_ctf_field_type_string_create();
        assert(root_loud_turkey_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_loud_turkey_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_loud_turkey_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_loud_turkey = bt_ctf_field_type_sequence_create(root_loud_turkey_elem, "stream.event.header.action.special");
        assert(root_loud_turkey);
@@ -1228,7 +1230,7 @@ struct bt_ctf_field_type *get_good_event_context_type(void)
        assert(ret == 0);
        root_loud_inform_elem = bt_ctf_field_type_string_create();
        assert(root_loud_inform_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_loud_inform_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_loud_inform_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_loud_inform = bt_ctf_field_type_sequence_create(root_loud_inform_elem, "stream.event.context.face.magic");
        assert(root_loud_inform);
@@ -1236,7 +1238,7 @@ struct bt_ctf_field_type *get_good_event_context_type(void)
        assert(ret == 0);
        root_loud_odd_elem = bt_ctf_field_type_string_create();
        assert(root_loud_odd_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_loud_odd_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_loud_odd_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_loud_odd = bt_ctf_field_type_sequence_create(root_loud_odd_elem, "berry.third");
        assert(root_loud_odd);
@@ -1244,7 +1246,7 @@ struct bt_ctf_field_type *get_good_event_context_type(void)
        assert(ret == 0);
        root_loud_amuck_elem = bt_ctf_field_type_string_create();
        assert(root_loud_amuck_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_loud_amuck_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_loud_amuck_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_loud_amuck = bt_ctf_field_type_sequence_create(root_loud_amuck_elem, "event.context.film");
        assert(root_loud_amuck);
@@ -1414,7 +1416,7 @@ struct bt_ctf_field_type *get_good_event_payload_type(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_splendid, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_splendid, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_splendid, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_splendid, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -1428,7 +1430,7 @@ struct bt_ctf_field_type *get_good_event_payload_type(void)
        assert(ret == 0);
        root_relative_equal_elem = bt_ctf_field_type_string_create();
        assert(root_relative_equal_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_relative_equal_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_relative_equal_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_relative_equal = bt_ctf_field_type_sequence_create(root_relative_equal_elem, "splendid");
        assert(root_relative_equal);
@@ -1436,7 +1438,7 @@ struct bt_ctf_field_type *get_good_event_payload_type(void)
        assert(ret == 0);
        root_relative_amuck_elem = bt_ctf_field_type_string_create();
        assert(root_relative_amuck_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_relative_amuck_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_relative_amuck_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_relative_amuck = bt_ctf_field_type_sequence_create(root_relative_amuck_elem, "id");
        assert(root_relative_amuck);
@@ -1444,7 +1446,7 @@ struct bt_ctf_field_type *get_good_event_payload_type(void)
        assert(ret == 0);
        root_relative_push_elem = bt_ctf_field_type_string_create();
        assert(root_relative_push_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_relative_push_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_relative_push_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_relative_push = bt_ctf_field_type_sequence_create(root_relative_push_elem, "berry.third");
        assert(root_relative_push);
@@ -1452,7 +1454,7 @@ struct bt_ctf_field_type *get_good_event_payload_type(void)
        assert(ret == 0);
        root_relative_brick_elem = bt_ctf_field_type_string_create();
        assert(root_relative_brick_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_relative_brick_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_relative_brick_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_relative_brick = bt_ctf_field_type_sequence_create(root_relative_brick_elem, "face.magic");
        assert(root_relative_brick);
@@ -1460,7 +1462,7 @@ struct bt_ctf_field_type *get_good_event_payload_type(void)
        assert(ret == 0);
        root_relative_crush_elem = bt_ctf_field_type_string_create();
        assert(root_relative_crush_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_relative_crush_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_relative_crush_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_relative_crush = bt_ctf_field_type_sequence_create(root_relative_crush_elem, "serious");
        assert(root_relative_crush);
@@ -1468,7 +1470,7 @@ struct bt_ctf_field_type *get_good_event_payload_type(void)
        assert(ret == 0);
        root_relative_canvas_elem = bt_ctf_field_type_string_create();
        assert(root_relative_canvas_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_relative_canvas_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_relative_canvas_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_relative_canvas = bt_ctf_field_type_sequence_create(root_relative_canvas_elem, "iron.dust");
        assert(root_relative_canvas);
@@ -1482,7 +1484,7 @@ struct bt_ctf_field_type *get_good_event_payload_type(void)
        assert(ret == 0);
        root_absolute_equal_elem = bt_ctf_field_type_string_create();
        assert(root_absolute_equal_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_absolute_equal_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_absolute_equal_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_absolute_equal = bt_ctf_field_type_sequence_create(root_absolute_equal_elem, "event.fields.splendid");
        assert(root_absolute_equal);
@@ -1490,7 +1492,7 @@ struct bt_ctf_field_type *get_good_event_payload_type(void)
        assert(ret == 0);
        root_absolute_amuck_elem = bt_ctf_field_type_string_create();
        assert(root_absolute_amuck_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_absolute_amuck_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_absolute_amuck_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_absolute_amuck = bt_ctf_field_type_sequence_create(root_absolute_amuck_elem, "stream.event.header.id");
        assert(root_absolute_amuck);
@@ -1498,7 +1500,7 @@ struct bt_ctf_field_type *get_good_event_payload_type(void)
        assert(ret == 0);
        root_absolute_push_elem = bt_ctf_field_type_string_create();
        assert(root_absolute_push_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_absolute_push_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_absolute_push_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_absolute_push = bt_ctf_field_type_sequence_create(root_absolute_push_elem, "event.context.berry.third");
        assert(root_absolute_push);
@@ -1506,7 +1508,7 @@ struct bt_ctf_field_type *get_good_event_payload_type(void)
        assert(ret == 0);
        root_absolute_brick_elem = bt_ctf_field_type_string_create();
        assert(root_absolute_brick_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_absolute_brick_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_absolute_brick_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_absolute_brick = bt_ctf_field_type_sequence_create(root_absolute_brick_elem, "stream.event.context.face.magic");
        assert(root_absolute_brick);
@@ -1514,7 +1516,7 @@ struct bt_ctf_field_type *get_good_event_payload_type(void)
        assert(ret == 0);
        root_absolute_crush_elem = bt_ctf_field_type_string_create();
        assert(root_absolute_crush_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_absolute_crush_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_absolute_crush_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_absolute_crush = bt_ctf_field_type_sequence_create(root_absolute_crush_elem, "stream.packet.context.serious");
        assert(root_absolute_crush);
@@ -1522,7 +1524,7 @@ struct bt_ctf_field_type *get_good_event_payload_type(void)
        assert(ret == 0);
        root_absolute_canvas_elem = bt_ctf_field_type_string_create();
        assert(root_absolute_canvas_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_absolute_canvas_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_absolute_canvas_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_absolute_canvas = bt_ctf_field_type_sequence_create(root_absolute_canvas_elem, "trace.packet.header.iron.dust");
        assert(root_absolute_canvas);
@@ -1637,9 +1639,9 @@ end:
 #define FIELD_PATH_END -2
 
 static
-int validate_field_path(struct bt_ctf_field_type *field_type,
-               enum bt_ctf_scope root, ...)
+int validate_field_path(struct bt_ctf_field_type *field_type, int int_root, ...)
 {
+       enum bt_ctf_scope root = int_root;
        int ret = 0;
        int len;
        int expected_index;
@@ -1648,7 +1650,7 @@ int validate_field_path(struct bt_ctf_field_type *field_type,
        struct bt_ctf_field_path *field_path = NULL;
        va_list ap;
 
-       va_start(ap, root);
+       va_start(ap, int_root);
        if (bt_ctf_field_type_is_sequence(field_type)) {
                field_path = bt_ctf_field_type_sequence_get_length_field_path(
                                field_type);
@@ -1662,7 +1664,7 @@ int validate_field_path(struct bt_ctf_field_type *field_type,
                goto end;
        }
 
-       if (bt_ctf_field_path_get_root(field_path) != root) {
+       if (bt_ctf_field_path_get_root_scope(field_path) != root) {
                ret = -1;
                goto end;
        }
@@ -1716,9 +1718,9 @@ void validate_test_pass(struct bt_ctf_trace *trace)
        struct bt_ctf_field_type *ft_target = NULL;
        struct bt_ctf_field_type *ft_tag = NULL;
 
-       sc = bt_ctf_trace_get_stream_class(trace, 0);
+       sc = bt_ctf_trace_get_stream_class_by_index(trace, 0);
        assert(sc);
-       ec = bt_ctf_stream_class_get_event_class(sc, 0);
+       ec = bt_ctf_stream_class_get_event_class_by_index(sc, 0);
        assert(ec);
 
        ph = bt_ctf_trace_get_packet_header_type(trace);
@@ -2194,7 +2196,7 @@ struct bt_ctf_field_type *test_fail_unavailable_root_get_event_payload(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_a, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_a, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_a, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_a, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -2204,7 +2206,7 @@ struct bt_ctf_field_type *test_fail_unavailable_root_get_event_payload(void)
        assert(ret == 0);
        root_b_elem = bt_ctf_field_type_string_create();
        assert(root_b_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_b_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_b_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_b = bt_ctf_field_type_sequence_create(root_b_elem, "stream.event.context.lol");
        assert(root_b);
@@ -2212,7 +2214,7 @@ struct bt_ctf_field_type *test_fail_unavailable_root_get_event_payload(void)
        assert(ret == 0);
        root_c = bt_ctf_field_type_string_create();
        assert(root_c);
-       ret = bt_ctf_field_type_string_set_encoding(root_c, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_c, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        ret = bt_ctf_field_type_structure_add_field(root, root_c, "c");
        assert(ret == 0);
@@ -2278,7 +2280,7 @@ struct bt_ctf_field_type *test_fail_target_is_root_get_event_payload(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_a, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_a, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_a, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_a, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -2288,7 +2290,7 @@ struct bt_ctf_field_type *test_fail_target_is_root_get_event_payload(void)
        assert(ret == 0);
        root_b_elem = bt_ctf_field_type_string_create();
        assert(root_b_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_b_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_b_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_b = bt_ctf_field_type_sequence_create(root_b_elem, "event.fields");
        assert(root_b);
@@ -2296,7 +2298,7 @@ struct bt_ctf_field_type *test_fail_target_is_root_get_event_payload(void)
        assert(ret == 0);
        root_c = bt_ctf_field_type_string_create();
        assert(root_c);
-       ret = bt_ctf_field_type_string_set_encoding(root_c, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_c, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        ret = bt_ctf_field_type_structure_add_field(root, root_c, "c");
        assert(ret == 0);
@@ -2366,7 +2368,7 @@ struct bt_ctf_field_type *test_fail_target_is_after_source_get_ep(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_a, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_a, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_a, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_a, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -2376,7 +2378,7 @@ struct bt_ctf_field_type *test_fail_target_is_after_source_get_ep(void)
        assert(ret == 0);
        root_b_elem = bt_ctf_field_type_string_create();
        assert(root_b_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_b_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_b_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_b = bt_ctf_field_type_sequence_create(root_b_elem, "d");
        assert(root_b);
@@ -2384,7 +2386,7 @@ struct bt_ctf_field_type *test_fail_target_is_after_source_get_ep(void)
        assert(ret == 0);
        root_c = bt_ctf_field_type_string_create();
        assert(root_c);
-       ret = bt_ctf_field_type_string_set_encoding(root_c, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_c, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        ret = bt_ctf_field_type_structure_add_field(root, root_c, "c");
        assert(ret == 0);
@@ -2394,7 +2396,7 @@ struct bt_ctf_field_type *test_fail_target_is_after_source_get_ep(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_d, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_d, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_d, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_d, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -2473,7 +2475,7 @@ struct bt_ctf_field_type *test_fail_target_is_ancestor_of_source_get_ep(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_a, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_a, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_a, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_a, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -2487,7 +2489,7 @@ struct bt_ctf_field_type *test_fail_target_is_ancestor_of_source_get_ep(void)
        assert(ret == 0);
        root_z_b_elem = bt_ctf_field_type_string_create();
        assert(root_z_b_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_z_b_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_z_b_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_z_b = bt_ctf_field_type_sequence_create(root_z_b_elem, "z");
        assert(root_z_b);
@@ -2497,7 +2499,7 @@ struct bt_ctf_field_type *test_fail_target_is_ancestor_of_source_get_ep(void)
        assert(ret == 0);
        root_c = bt_ctf_field_type_string_create();
        assert(root_c);
-       ret = bt_ctf_field_type_string_set_encoding(root_c, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_c, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        ret = bt_ctf_field_type_structure_add_field(root, root_c, "c");
        assert(ret == 0);
@@ -2507,7 +2509,7 @@ struct bt_ctf_field_type *test_fail_target_is_ancestor_of_source_get_ep(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_d, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_d, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_d, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_d, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -2583,7 +2585,7 @@ struct bt_ctf_field_type *test_fail_target_is_source_get_event_payload(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_a, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_a, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_a, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_a, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -2593,7 +2595,7 @@ struct bt_ctf_field_type *test_fail_target_is_source_get_event_payload(void)
        assert(ret == 0);
        root_b_elem = bt_ctf_field_type_string_create();
        assert(root_b_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_b_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_b_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_b = bt_ctf_field_type_sequence_create(root_b_elem, "event.fields.b");
        assert(root_b);
@@ -2601,7 +2603,7 @@ struct bt_ctf_field_type *test_fail_target_is_source_get_event_payload(void)
        assert(ret == 0);
        root_c = bt_ctf_field_type_string_create();
        assert(root_c);
-       ret = bt_ctf_field_type_string_set_encoding(root_c, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_c, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        ret = bt_ctf_field_type_structure_add_field(root, root_c, "c");
        assert(ret == 0);
@@ -2611,7 +2613,7 @@ struct bt_ctf_field_type *test_fail_target_is_source_get_event_payload(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_d, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_d, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_d, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_d, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -2687,7 +2689,7 @@ struct bt_ctf_field_type *test_fail_variant_tag_is_not_enum_get_ep(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_a, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_a, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_a, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_a, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -2699,7 +2701,7 @@ struct bt_ctf_field_type *test_fail_variant_tag_is_not_enum_get_ep(void)
        assert(root_b);
        root_b_HELLO = bt_ctf_field_type_string_create();
        assert(root_b_HELLO);
-       ret = bt_ctf_field_type_string_set_encoding(root_b_HELLO, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_b_HELLO, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        ret = bt_ctf_field_type_variant_add_field(root_b, root_b_HELLO, "HELLO");
        assert(ret == 0);
@@ -2707,7 +2709,7 @@ struct bt_ctf_field_type *test_fail_variant_tag_is_not_enum_get_ep(void)
        assert(ret == 0);
        root_c = bt_ctf_field_type_string_create();
        assert(root_c);
-       ret = bt_ctf_field_type_string_set_encoding(root_c, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_c, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        ret = bt_ctf_field_type_structure_add_field(root, root_c, "c");
        assert(ret == 0);
@@ -2717,7 +2719,7 @@ struct bt_ctf_field_type *test_fail_variant_tag_is_not_enum_get_ep(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_d, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_d, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_d, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_d, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -2800,7 +2802,7 @@ struct bt_ctf_field_type *test_fail_variant_tag_mismatch_mappings_get_ep(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_a_int, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_a_int, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_a_int, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_a_int, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -2820,7 +2822,7 @@ struct bt_ctf_field_type *test_fail_variant_tag_mismatch_mappings_get_ep(void)
        assert(root_b);
        root_b_GLASS = bt_ctf_field_type_string_create();
        assert(root_b_GLASS);
-       ret = bt_ctf_field_type_string_set_encoding(root_b_GLASS, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_b_GLASS, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        ret = bt_ctf_field_type_variant_add_field(root_b, root_b_GLASS, "GLASS");
        assert(ret == 0);
@@ -2830,7 +2832,7 @@ struct bt_ctf_field_type *test_fail_variant_tag_mismatch_mappings_get_ep(void)
        assert(ret == 0);
        ret = bt_ctf_field_type_integer_set_base(root_b_OF, 10);
        assert(ret == 0);
-       ret = bt_ctf_field_type_integer_set_encoding(root_b_OF, CTF_STRING_NONE);
+       ret = bt_ctf_field_type_integer_set_encoding(root_b_OF, BT_CTF_STRING_ENCODING_NONE);
        assert(ret == 0);
        ret = bt_ctf_field_type_set_byte_order(root_b_OF, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN);
        assert(ret == 0);
@@ -2842,7 +2844,7 @@ struct bt_ctf_field_type *test_fail_variant_tag_mismatch_mappings_get_ep(void)
        assert(ret == 0);
        root_c = bt_ctf_field_type_string_create();
        assert(root_c);
-       ret = bt_ctf_field_type_string_set_encoding(root_c, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_c, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        ret = bt_ctf_field_type_structure_add_field(root, root_c, "c");
        assert(ret == 0);
@@ -2905,13 +2907,13 @@ struct bt_ctf_field_type *test_fail_sequence_tag_is_not_int_get_ep(void)
        assert(ret == 0);
        root_a = bt_ctf_field_type_string_create();
        assert(root_a);
-       ret = bt_ctf_field_type_string_set_encoding(root_a, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_a, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        ret = bt_ctf_field_type_structure_add_field(root, root_a, "a");
        assert(ret == 0);
        root_b_elem = bt_ctf_field_type_string_create();
        assert(root_b_elem);
-       ret = bt_ctf_field_type_string_set_encoding(root_b_elem, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_b_elem, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        root_b = bt_ctf_field_type_sequence_create(root_b_elem, "a");
        assert(root_b);
@@ -2919,7 +2921,7 @@ struct bt_ctf_field_type *test_fail_sequence_tag_is_not_int_get_ep(void)
        assert(ret == 0);
        root_c = bt_ctf_field_type_string_create();
        assert(root_c);
-       ret = bt_ctf_field_type_string_set_encoding(root_c, CTF_STRING_UTF8);
+       ret = bt_ctf_field_type_string_set_encoding(root_c, BT_CTF_STRING_ENCODING_UTF8);
        assert(ret == 0);
        ret = bt_ctf_field_type_structure_add_field(root, root_c, "c");
        assert(ret == 0);