projects / babeltrace.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
ir: split event files into event and event-class files
[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 2a173e7de90b17b54df87be19d1128fa8e68b84d..a0fadef28267d39a6fcb99c1300781a1f7dde34c 100644 (file)
--- a/tests/lib/test_bt_ctf_field_type_validation.c
+++ b/tests/lib/test_bt_ctf_field_type_validation.c
@@ -19,9 +19,10 @@
  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
-#include <babeltrace/ctf-ir/event-types.h>
-#include <babeltrace/ctf-ir/event-types-internal.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>
@@ -1638,27 +1639,23 @@ end:
 
 static
 int validate_field_path(struct bt_ctf_field_type *field_type,
-               enum bt_ctf_node root, ...)
+               enum bt_ctf_scope root, ...)
 {
        int ret = 0;
        int len;
        int expected_index;
        int actual_index;
        int i = 0;
-       const struct bt_ctf_field_path *field_path;
+       struct bt_ctf_field_path *field_path = NULL;
        va_list ap;
 
        va_start(ap, root);
-
        if (bt_ctf_field_type_is_sequence(field_type)) {
-               field_path = ((struct bt_ctf_field_type_sequence *)
-                       field_type)->length_field_path;
+               field_path = bt_ctf_field_type_sequence_get_length_field_path(
+                               field_type);
        } else if (bt_ctf_field_type_is_variant(field_type)) {
-               field_path = ((struct bt_ctf_field_type_variant *)
-                       field_type)->tag_path;
-       } else {
-               ret = -1;
-               goto end;
+               field_path = bt_ctf_field_type_variant_get_tag_field_path(
+                               field_type);
        }
 
        if (!field_path) {
@@ -1666,12 +1663,12 @@ int validate_field_path(struct bt_ctf_field_type *field_type,
                goto end;
        }
 
-       if (field_path->root != root) {
+       if (bt_ctf_field_path_get_root_scope(field_path) != root) {
                ret = -1;
                goto end;
        }
 
-       len = field_path->path_indexes->len;
+       len = bt_ctf_field_path_get_index_count(field_path);
 
        while (true) {
                expected_index = va_arg(ap, int);
@@ -1684,9 +1681,9 @@ int validate_field_path(struct bt_ctf_field_type *field_type,
                        break;
                }
 
-               actual_index = g_array_index(field_path->path_indexes, int, i);
+               actual_index = bt_ctf_field_path_get_index(field_path, i);
 
-               if (actual_index != expected_index) {
+               if (actual_index == INT_MIN) {
                        ret = -1;
                        goto end;
                }
@@ -1699,6 +1696,7 @@ int validate_field_path(struct bt_ctf_field_type *field_type,
        }
 
 end:
+       BT_PUT(field_path);
        va_end(ap);
 
        return ret;
@@ -1739,7 +1737,7 @@ void validate_test_pass(struct bt_ctf_trace *trace)
 
        /* trace.packet.header.iron.fire.keen */
        ft_src = get_ft(ph, "iron", "fire", "keen", NULL);
-       ok(!validate_field_path(ft_src, CTF_NODE_TRACE_PACKET_HEADER,
+       ok(!validate_field_path(ft_src, BT_CTF_SCOPE_TRACE_PACKET_HEADER,
                3, 3, 0, FIELD_PATH_END),
                "trace.packet.header.iron.fire.keen has the correct field path");
        BT_PUT(ft_src);
@@ -1747,7 +1745,7 @@ void validate_test_pass(struct bt_ctf_trace *trace)
        /* trace.packet.header.iron.fire.keen.[element] */
        ft_src = get_ft(ph, "iron", "fire", "keen", "", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_TRACE_PACKET_HEADER, 3, 2, FIELD_PATH_END),
+               BT_CTF_SCOPE_TRACE_PACKET_HEADER, 3, 2, FIELD_PATH_END),
                "trace.packet.header.iron.fire.keen.[element] has the correct field path");
        ft_target = get_ft(ph, "iron", "parallel", NULL);
        ft_tag = bt_ctf_field_type_variant_get_tag_type(ft_src);
@@ -1760,35 +1758,35 @@ void validate_test_pass(struct bt_ctf_trace *trace)
        /* trace.packet.header.iron.fire.keen.[element].BLUE */
        ft_src = get_ft(ph, "iron", "fire", "keen", "", "BLUE", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_TRACE_PACKET_HEADER, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_TRACE_PACKET_HEADER, 0, FIELD_PATH_END),
                "trace.packet.header.iron.fire.keen.[element].BLUE has the correct field path");
        BT_PUT(ft_src);
 
        /* trace.packet.header.iron.report */
        ft_src = get_ft(ph, "iron", "report", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_TRACE_PACKET_HEADER, 3, 1, FIELD_PATH_END),
+               BT_CTF_SCOPE_TRACE_PACKET_HEADER, 3, 1, FIELD_PATH_END),
                "trace.packet.header.iron.report has the correct field path");
        BT_PUT(ft_src);
 
        /* trace.packet.header.iron.group */
        ft_src = get_ft(ph, "iron", "group", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_TRACE_PACKET_HEADER, 2, FIELD_PATH_END),
+               BT_CTF_SCOPE_TRACE_PACKET_HEADER, 2, FIELD_PATH_END),
                "trace.packet.header.iron.group has the correct field path");
        BT_PUT(ft_src);
 
        /* stream.packet.context.naive.[element] */
        ft_src = get_ft(pc, "naive", "", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_PACKET_CONTEXT, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_PACKET_CONTEXT, 0, FIELD_PATH_END),
                "stream.packet.context.naive.[element] has the correct field path");
        BT_PUT(ft_src);
 
        /* stream.packet.context.clover.whole */
        ft_src = get_ft(pc, "clover", "whole", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_TRACE_PACKET_HEADER, 3, 2, FIELD_PATH_END),
+               BT_CTF_SCOPE_TRACE_PACKET_HEADER, 3, 2, FIELD_PATH_END),
                "stream.packet.context.clover.whole has the correct field path");
        ft_target = get_ft(ph, "iron", "parallel", NULL);
        ft_tag = bt_ctf_field_type_variant_get_tag_type(ft_src);
@@ -1801,245 +1799,245 @@ void validate_test_pass(struct bt_ctf_trace *trace)
        /* stream.packet.context.clover.whole.BLUE */
        ft_src = get_ft(pc, "clover", "whole", "BLUE", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_TRACE_PACKET_HEADER, 3, 3, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_TRACE_PACKET_HEADER, 3, 3, 0, FIELD_PATH_END),
                "stream.packet.context.clover.whole.BLUE has the correct field path");
        BT_PUT(ft_src);
 
        /* stream.packet.context.clover.egg */
        ft_src = get_ft(pc, "clover", "egg", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_PACKET_CONTEXT, 4, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_PACKET_CONTEXT, 4, 0, FIELD_PATH_END),
                "stream.packet.context.clover.egg has the correct field path");
        BT_PUT(ft_src);
 
        /* stream.packet.context.clover.useful */
        ft_src = get_ft(pc, "clover", "useful", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_PACKET_CONTEXT, 2, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_PACKET_CONTEXT, 2, FIELD_PATH_END),
                "stream.packet.context.clover.useful has the correct field path");
        BT_PUT(ft_src);
 
        /* stream.event.header.action.lucky */
        ft_src = get_ft(eh, "action", "lucky", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_PACKET_CONTEXT, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_PACKET_CONTEXT, 0, FIELD_PATH_END),
                "stream.event.header.action.lucky has the correct field path");
        BT_PUT(ft_src);
 
        /* stream.event.header.stiff */
        ft_src = get_ft(eh, "stiff", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_PACKET_CONTEXT, 4, 1, 1, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_PACKET_CONTEXT, 4, 1, 1, FIELD_PATH_END),
                "stream.event.header.stiff has the correct field path");
        BT_PUT(ft_src);
 
        /* stream.event.header.fruit.apple */
        ft_src = get_ft(eh, "fruit", "apple", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_EVENT_HEADER, 2, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_EVENT_HEADER, 2, 0, FIELD_PATH_END),
                "stream.event.header.fruit.apple has the correct field path");
        BT_PUT(ft_src);
 
        /* stream.event.context.face.branch */
        ft_src = get_ft(sec, "face", "branch", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_PACKET_CONTEXT, 2, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_PACKET_CONTEXT, 2, FIELD_PATH_END),
                "stream.event.context.face.branch has the correct field path");
        BT_PUT(ft_src);
 
        /* stream.event.context.face.income */
        ft_src = get_ft(sec, "face", "income", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_TRACE_PACKET_HEADER, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_TRACE_PACKET_HEADER, 0, FIELD_PATH_END),
                "stream.event.context.face.income has the correct field path");
        BT_PUT(ft_src);
 
        /* stream.event.context.face.lucky */
        ft_src = get_ft(sec, "face", "lucky", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
                "stream.event.context.face.lucky has the correct field path");
        BT_PUT(ft_src);
 
        /* stream.event.context.dream */
        ft_src = get_ft(sec, "dream", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_PACKET_CONTEXT, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_PACKET_CONTEXT, 0, FIELD_PATH_END),
                "stream.event.context.dream has the correct field path");
        BT_PUT(ft_src);
 
        /* stream.event.context.dream.[element] */
        ft_src = get_ft(sec, "dream", "", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_TRACE_PACKET_HEADER, 3, 1, FIELD_PATH_END),
+               BT_CTF_SCOPE_TRACE_PACKET_HEADER, 3, 1, FIELD_PATH_END),
                "stream.event.context.dream.[element] has the correct field path");
        BT_PUT(ft_src);
 
        /* stream.event.context.dream.[element].[element] */
        ft_src = get_ft(sec, "dream", "", "", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
                "stream.event.context.dream.[element].[element] has the correct field path");
        BT_PUT(ft_src);
 
        /* event.context.berry.porter */
        ft_src = get_ft(ectx, "berry", "porter", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
                "event.context.berry.porter has the correct field path");
        BT_PUT(ft_src);
 
        /* event.context.berry.porter */
        ft_src = get_ft(ectx, "berry", "porter", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
                "event.context.berry.porter has the correct field path");
        BT_PUT(ft_src);
 
        /* event.context.berry.mice */
        ft_src = get_ft(ectx, "berry", "mice", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_EVENT_HEADER, 2, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_EVENT_HEADER, 2, 0, FIELD_PATH_END),
                "event.context.berry.mice has the correct field path");
        BT_PUT(ft_src);
 
        /* event.context.berry.guard */
        ft_src = get_ft(ectx, "berry", "guard", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_PACKET_CONTEXT, 4, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_PACKET_CONTEXT, 4, 0, FIELD_PATH_END),
                "event.context.berry.guard has the correct field path");
        BT_PUT(ft_src);
 
        /* event.context.berry.one */
        ft_src = get_ft(ectx, "berry", "one", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_TRACE_PACKET_HEADER, 3, 3, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_TRACE_PACKET_HEADER, 3, 3, 0, FIELD_PATH_END),
                "event.context.berry.one has the correct field path");
        BT_PUT(ft_src);
 
        /* event.context.loud.toys */
        ft_src = get_ft(ectx, "loud", "toys", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_TRACE_PACKET_HEADER, 3, 3, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_TRACE_PACKET_HEADER, 3, 3, 0, FIELD_PATH_END),
                "event.context.loud.toys has the correct field path");
        BT_PUT(ft_src);
 
        /* event.context.loud.spoon */
        ft_src = get_ft(ectx, "loud", "spoon", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_PACKET_CONTEXT, 4, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_PACKET_CONTEXT, 4, 0, FIELD_PATH_END),
                "event.context.loud.spoon has the correct field path");
        BT_PUT(ft_src);
 
        /* event.context.loud.turkey */
        ft_src = get_ft(ectx, "loud", "turkey", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_EVENT_HEADER, 2, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_EVENT_HEADER, 2, 0, FIELD_PATH_END),
                "event.context.loud.turkey has the correct field path");
        BT_PUT(ft_src);
 
        /* event.context.loud.inform */
        ft_src = get_ft(ectx, "loud", "inform", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
                "event.context.loud.inform has the correct field path");
        BT_PUT(ft_src);
 
        /* event.context.loud.odd */
        ft_src = get_ft(ectx, "loud", "odd", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_EVENT_CONTEXT, 1, 3, FIELD_PATH_END),
+               BT_CTF_SCOPE_EVENT_CONTEXT, 1, 3, FIELD_PATH_END),
                "event.context.loud.odd has the correct field path");
        BT_PUT(ft_src);
 
        /* event.context.loud.amuck */
        ft_src = get_ft(ectx, "loud", "amuck", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_EVENT_CONTEXT, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_EVENT_CONTEXT, 0, FIELD_PATH_END),
                "event.context.loud.amuck has the correct field path");
        BT_PUT(ft_src);
 
        /* event.fields.relative.equal */
        ft_src = get_ft(ep, "relative", "equal", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_EVENT_FIELDS, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_EVENT_FIELDS, 0, FIELD_PATH_END),
                "event.fields.relative.equal has the correct field path");
        BT_PUT(ft_src);
 
        /* event.fields.relative.amuck */
        ft_src = get_ft(ep, "relative", "amuck", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_EVENT_HEADER, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_EVENT_HEADER, 0, FIELD_PATH_END),
                "event.fields.relative.amuck has the correct field path");
        BT_PUT(ft_src);
 
        /* event.fields.relative.push */
        ft_src = get_ft(ep, "relative", "push", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_EVENT_CONTEXT, 1, 3, FIELD_PATH_END),
+               BT_CTF_SCOPE_EVENT_CONTEXT, 1, 3, FIELD_PATH_END),
                "event.fields.relative.push has the correct field path");
        BT_PUT(ft_src);
 
        /* event.fields.relative.brick */
        ft_src = get_ft(ep, "relative", "brick", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
                "event.fields.relative.brick has the correct field path");
        BT_PUT(ft_src);
 
        /* event.fields.relative.crush */
        ft_src = get_ft(ep, "relative", "crush", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_PACKET_CONTEXT, 2, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_PACKET_CONTEXT, 2, FIELD_PATH_END),
                "event.fields.relative.crush has the correct field path");
        BT_PUT(ft_src);
 
        /* event.fields.relative.canvas */
        ft_src = get_ft(ep, "relative", "canvas", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_TRACE_PACKET_HEADER, 3, 1, FIELD_PATH_END),
+               BT_CTF_SCOPE_TRACE_PACKET_HEADER, 3, 1, FIELD_PATH_END),
                "event.fields.relative.canvas has the correct field path");
        BT_PUT(ft_src);
 
        /* event.fields.absolute.equal */
        ft_src = get_ft(ep, "absolute", "equal", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_EVENT_FIELDS, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_EVENT_FIELDS, 0, FIELD_PATH_END),
                "event.fields.absolute.equal has the correct field path");
        BT_PUT(ft_src);
 
        /* event.fields.absolute.amuck */
        ft_src = get_ft(ep, "absolute", "amuck", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_EVENT_HEADER, 0, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_EVENT_HEADER, 0, FIELD_PATH_END),
                "event.fields.absolute.amuck has the correct field path");
        BT_PUT(ft_src);
 
        /* event.fields.absolute.push */
        ft_src = get_ft(ep, "absolute", "push", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_EVENT_CONTEXT, 1, 3, FIELD_PATH_END),
+               BT_CTF_SCOPE_EVENT_CONTEXT, 1, 3, FIELD_PATH_END),
                "event.fields.absolute.push has the correct field path");
        BT_PUT(ft_src);
 
        /* event.fields.absolute.brick */
        ft_src = get_ft(ep, "absolute", "brick", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_EVENT_CONTEXT, 0, 2, FIELD_PATH_END),
                "event.fields.absolute.brick has the correct field path");
        BT_PUT(ft_src);
 
        /* event.fields.absolute.crush */
        ft_src = get_ft(ep, "absolute", "crush", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_STREAM_PACKET_CONTEXT, 2, FIELD_PATH_END),
+               BT_CTF_SCOPE_STREAM_PACKET_CONTEXT, 2, FIELD_PATH_END),
                "event.fields.absolute.crush has the correct field path");
        BT_PUT(ft_src);
 
        /* event.fields.absolute.canvas */
        ft_src = get_ft(ep, "absolute", "canvas", NULL);
        ok(!validate_field_path(ft_src,
-               CTF_NODE_TRACE_PACKET_HEADER, 3, 1, FIELD_PATH_END),
+               BT_CTF_SCOPE_TRACE_PACKET_HEADER, 3, 1, FIELD_PATH_END),
                "event.fields.absolute.canvas has the correct field path");
        BT_PUT(ft_src);
 
BabelTrace - Trace Format Babel Tower
This page took 0.029999 seconds and 4 git commands to generate.