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 6338a7b36b29da1d86cb8bc8e466350cf4314982..ad92e801f0846810f4e03fb8e35735cde2f8a200 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,15 @@
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
-#include <babeltrace/ctf-ir/event-types.h>
+#include <babeltrace/ref.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 +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);
@@ -158,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);
@@ -174,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);
@@ -188,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);
@@ -198,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);
@@ -212,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);
@@ -238,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);
@@ -248,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);
@@ -256,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);
@@ -266,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);
@@ -290,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);
@@ -298,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);
@@ -312,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);
@@ -450,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);
@@ -460,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);
@@ -470,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);
@@ -480,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);
@@ -498,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);
@@ -510,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);
@@ -522,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);
@@ -532,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);
@@ -544,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);
@@ -560,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);
@@ -580,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);
@@ -594,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);
@@ -701,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);
@@ -715,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);
@@ -733,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);
@@ -743,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);
@@ -751,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);
@@ -761,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);
@@ -775,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);
@@ -791,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);
@@ -898,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);
@@ -906,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);
@@ -918,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);
@@ -928,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);
@@ -942,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);
@@ -952,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);
@@ -968,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);
@@ -1116,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);
@@ -1130,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);
@@ -1138,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);
@@ -1146,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);
@@ -1158,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);
@@ -1168,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);
@@ -1176,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);
@@ -1190,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);
@@ -1204,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);
@@ -1212,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);
@@ -1220,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);
@@ -1228,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);
@@ -1236,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);
@@ -1244,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);
@@ -1414,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);
@@ -1428,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);
@@ -1436,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);
@@ -1444,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);
@@ -1452,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);
@@ -1460,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);
@@ -1468,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);
@@ -1482,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);
@@ -1490,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);
@@ -1498,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);
@@ -1506,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);
@@ -1514,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);
@@ -1522,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);
@@ -1637,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;
@@ -1648,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);
@@ -1716,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);
@@ -2194,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);
@@ -2204,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);
@@ -2212,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);
@@ -2278,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);
@@ -2288,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);
@@ -2296,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);
@@ -2366,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);
@@ -2376,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);
@@ -2384,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);
@@ -2394,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);
@@ -2473,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);
@@ -2487,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);
@@ -2497,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);
@@ -2507,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);
@@ -2583,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);
@@ -2593,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);
@@ -2601,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);
@@ -2611,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);
@@ -2687,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);
@@ -2699,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);
@@ -2707,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);
@@ -2717,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);
@@ -2800,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);
@@ -2820,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);
@@ -2830,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);
@@ -2842,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);
@@ -2866,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);
@@ -2905,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);
@@ -2919,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);