Add dynamic array tracing tests

[deliverable/barectf.git] / barectf / config_parse_v2.py

diff --git a/barectf/config_parse_v2.py b/barectf/config_parse_v2.py
index 2fbf898addc0b1273557b7c2ea03db42295da494..668f0b9478ee599e662ab01e9d6a7304ce3368f7 100644 (file)
--- a/barectf/config_parse_v2.py
+++ b/barectf/config_parse_v2.py
@@ -80,7 +80,7 @@ class _Parser(config_parse_common._Parser):
             'floating-point': self._conv_real_ft_node,
             'str': self._conv_string_ft_node,
             'string': self._conv_string_ft_node,
-            'array': self._conv_static_array_ft_node,
+            'array': self._conv_array_ft_node,
             'struct': self._conv_struct_ft_node,
             'structure': self._conv_struct_ft_node,
         }
@@ -129,6 +129,9 @@ class _Parser(config_parse_common._Parser):
         # remove `encoding` property
         _del_prop_if_exists(v3_ft_node, 'encoding')
 
+        # remove `byte-order` property (always target BO in v3)
+        _del_prop_if_exists(v3_ft_node, 'byte-order')
+
         # remove `property-mappings` property
         _del_prop_if_exists(v3_ft_node, 'property-mappings')
 
@@ -219,12 +222,15 @@ class _Parser(config_parse_common._Parser):
 
     # Converts a v2 array field type node to a v3 (static) array field
     # type node and returns it.
-    def _conv_static_array_ft_node(self, v2_ft_node: _MapNode) -> _MapNode:
-        # class renamed to `static-array`
-        v3_ft_node: _MapNode = collections.OrderedDict({'class': 'static-array'})
+    def _conv_array_ft_node(self, v2_ft_node: _MapNode) -> _MapNode:
+        # class renamed to `static-array` or `dynamic-array`
+        is_dynamic = v2_ft_node['length'] == 'dynamic'
+        array_type = 'dynamic' if is_dynamic else 'static'
+        v3_ft_node: _MapNode = collections.OrderedDict({'class': f'{array_type}-array'})
 
-        # copy `length` property
-        _copy_prop_if_exists(v3_ft_node, v2_ft_node, 'length')
+        # copy `length` property if it's a static array field type
+        if not is_dynamic:
+            _copy_prop_if_exists(v3_ft_node, v2_ft_node, 'length')
 
         # convert element field type
         v3_ft_node['element-field-type'] = self._conv_ft_node(v2_ft_node['element-type'])
@@ -483,8 +489,9 @@ class _Parser(config_parse_common._Parser):
         v3_trace_type_node: _MapNode = collections.OrderedDict()
         v2_trace_node = v2_meta_node['trace']
 
-        # rename `byte-order` property to `$default-byte-order`
-        _copy_prop_if_exists(v3_trace_type_node, v2_trace_node, 'byte-order', '$default-byte-order')
+        # Move `byte-order` property to root node's `target-byte-order`
+        # property.
+        typing.cast(_MapNode, self._root_node)['target-byte-order'] = v2_trace_node['byte-order']
 
         # copy `uuid` property
         _copy_prop_if_exists(v3_trace_type_node, v2_trace_node, 'uuid')
@@ -658,7 +665,7 @@ class _Parser(config_parse_common._Parser):
         # Make sure that the current configuration node is valid
         # considering field types are not expanded yet.
         self._schema_validator.validate(self._root_node,
-                                        '2/config/config-pre-field-type-expansion')
+                                        'config/2/config-pre-field-type-expansion')
 
         meta_node = self._root_node['metadata']
         ft_aliases_node = meta_node.get('type-aliases')
@@ -679,7 +686,7 @@ class _Parser(config_parse_common._Parser):
     def _process_ev_type_node_include(self, ev_type_node: _MapNode) -> _MapNode:
         # Make sure the event type node is valid for the inclusion
         # processing stage.
-        self._schema_validator.validate(ev_type_node, '2/config/event-type-pre-include')
+        self._schema_validator.validate(ev_type_node, 'config/2/event-type-pre-include')
 
         # process inclusions
         return self._process_node_include(ev_type_node, self._process_ev_type_node_include)
@@ -698,7 +705,7 @@ class _Parser(config_parse_common._Parser):
 
         # Make sure the stream type node is valid for the inclusion
         # processing stage.
-        self._schema_validator.validate(stream_type_node, '2/config/stream-type-pre-include')
+        self._schema_validator.validate(stream_type_node, 'config/2/stream-type-pre-include')
 
         # process inclusions
         return self._process_node_include(stream_type_node, self._process_stream_type_node_include,
@@ -709,7 +716,7 @@ class _Parser(config_parse_common._Parser):
     def _process_trace_type_node_include(self, trace_type_node: _MapNode) -> _MapNode:
         # Make sure the trace type node is valid for the inclusion
         # processing stage.
-        self._schema_validator.validate(trace_type_node, '2/config/trace-type-pre-include')
+        self._schema_validator.validate(trace_type_node, 'config/2/trace-type-pre-include')
 
         # process inclusions
         return self._process_node_include(trace_type_node, self._process_trace_type_node_include)
@@ -719,7 +726,7 @@ class _Parser(config_parse_common._Parser):
     def _process_clk_type_node_include(self, clk_type_node: _MapNode) -> _MapNode:
         # Make sure the clock type node is valid for the inclusion
         # processing stage.
-        self._schema_validator.validate(clk_type_node, '2/config/clock-type-pre-include')
+        self._schema_validator.validate(clk_type_node, 'config/2/clock-type-pre-include')
 
         # process inclusions
         return self._process_node_include(clk_type_node, self._process_clk_type_node_include)
@@ -751,7 +758,7 @@ class _Parser(config_parse_common._Parser):
 
         # Make sure the metadata node is valid for the inclusion
         # processing stage.
-        self._schema_validator.validate(meta_node, '2/config/metadata-pre-include')
+        self._schema_validator.validate(meta_node, 'config/2/metadata-pre-include')
 
         # process inclusions
         return self._process_node_include(meta_node, self._process_meta_node_include,
@@ -779,7 +786,7 @@ class _Parser(config_parse_common._Parser):
         # First, make sure the configuration node itself is valid for
         # the inclusion processing stage.
         self._schema_validator.validate(self._root_node,
-                                        '2/config/config-pre-include')
+                                        'config/2/config-pre-include')
 
         # Process metadata node inclusions.
         #
@@ -799,7 +806,7 @@ class _Parser(config_parse_common._Parser):
         #
         # * Process inclusions.
         # * Expand field types (aliases and inheritance).
-        self._schema_validator.validate(self._root_node, '2/config/config-min')
+        self._schema_validator.validate(self._root_node, 'config/2/config-min')
 
         # process configuration node inclusions
         self._process_config_includes()
@@ -839,7 +846,7 @@ class _Parser(config_parse_common._Parser):
         # event type nodes can be log level aliases. Log level aliases
         # are also a feature of a barectf 3 configuration node,
         # therefore this is compatible.
-        self._schema_validator.validate(self._root_node, '2/config/config')
+        self._schema_validator.validate(self._root_node, 'config/2/config')
 
         # Transform the current configuration node into a valid v3
         # configuration node.