Avoid unnecessary inclusions in public headers

[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 a0fadef28267d39a6fcb99c1300781a1f7dde34c..ad92e801f0846810f4e03fb8e35735cde2f8a200 100644 (file)
--- a/tests/lib/test_bt_ctf_field_type_validation.c
+++ b/tests/lib/test_bt_ctf_field_type_validation.c
@@ -19,6 +19,7 @@
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
+#include <babeltrace/ref.h>
 #include <babeltrace/ctf-ir/field-types.h>
 #include <babeltrace/ctf-ir/field-path.h>
 #include <babeltrace/ctf-ir/event.h>
@@ -26,6 +27,7 @@
 #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>
@@ -145,7 +147,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);
@@ -159,7 +161,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);
@@ -175,7 +177,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);
@@ -189,7 +191,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);
@@ -199,7 +201,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);
@@ -213,7 +215,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);
@@ -239,7 +241,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);
@@ -249,7 +251,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);
@@ -257,7 +259,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);
@@ -267,7 +269,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);
@@ -291,7 +293,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);
@@ -299,7 +301,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);
@@ -313,7 +315,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);
@@ -451,7 +453,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);
@@ -461,7 +463,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);
@@ -471,7 +473,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);
@@ -481,7 +483,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);
@@ -499,7 +501,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);
@@ -511,7 +513,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);
@@ -523,7 +525,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);
@@ -533,7 +535,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);
@@ -545,7 +547,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);
@@ -561,7 +563,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);
@@ -581,7 +583,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);
@@ -595,7 +597,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);
@@ -702,7 +704,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);
@@ -716,7 +718,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);
@@ -734,7 +736,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);
@@ -744,7 +746,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);
@@ -752,7 +754,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);
@@ -762,7 +764,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);
@@ -776,7 +778,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);
@@ -792,7 +794,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);
@@ -899,7 +901,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);
@@ -907,7 +909,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);
@@ -919,7 +921,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);
@@ -929,7 +931,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);
@@ -943,7 +945,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);
@@ -953,7 +955,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);
@@ -969,7 +971,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);
@@ -1117,7 +1119,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);
@@ -1131,7 +1133,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);
@@ -1139,7 +1141,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);
@@ -1147,7 +1149,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);
@@ -1159,7 +1161,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);
@@ -1169,7 +1171,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);
@@ -1177,7 +1179,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);
@@ -1191,7 +1193,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);
@@ -1205,7 +1207,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);
@@ -1213,7 +1215,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);
@@ -1221,7 +1223,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);
@@ -1229,7 +1231,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);
@@ -1237,7 +1239,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);
@@ -1245,7 +1247,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);
@@ -1415,7 +1417,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);
@@ -1429,7 +1431,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);
@@ -1437,7 +1439,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);
@@ -1445,7 +1447,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);
@@ -1453,7 +1455,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);
@@ -1461,7 +1463,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);
@@ -1469,7 +1471,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);
@@ -1483,7 +1485,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);
@@ -1491,7 +1493,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);
@@ -1499,7 +1501,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);
@@ -1507,7 +1509,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);
@@ -1515,7 +1517,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);
@@ -1523,7 +1525,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);
@@ -1638,9 +1640,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;
@@ -1649,7 +1651,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);
@@ -1717,9 +1719,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);
@@ -2195,7 +2197,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);
@@ -2205,7 +2207,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);
@@ -2213,7 +2215,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);
@@ -2279,7 +2281,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);
@@ -2289,7 +2291,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);
@@ -2297,7 +2299,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);
@@ -2367,7 +2369,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);
@@ -2377,7 +2379,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);
@@ -2385,7 +2387,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);
@@ -2395,7 +2397,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);
@@ -2474,7 +2476,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);
@@ -2488,7 +2490,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);
@@ -2498,7 +2500,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);
@@ -2508,7 +2510,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);
@@ -2584,7 +2586,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);
@@ -2594,7 +2596,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);
@@ -2602,7 +2604,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);
@@ -2612,7 +2614,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);
@@ -2688,7 +2690,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);
@@ -2700,7 +2702,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);
@@ -2708,7 +2710,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);
@@ -2718,7 +2720,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);
@@ -2801,7 +2803,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);
@@ -2821,7 +2823,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);
@@ -2831,7 +2833,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);
@@ -2843,7 +2845,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);
@@ -2867,7 +2869,7 @@ void test_fail_variant_tag_mismatch_mappings(void)
        ep = test_fail_variant_tag_mismatch_mappings_get_ep();
        assert(ep);
        event = create_event_with_context_and_payload(NULL, ep);
-       ok(!event, "Variant FT with mismatching tag FT is invalid");
+       ok(event, "Variant FT with mismatching tag FT is valid");
 
        BT_PUT(ep);
        BT_PUT(event);
@@ -2906,13 +2908,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);
@@ -2920,7 +2922,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);