Add support for global structs/enums/bitmaps to YAML test harness.

Author: bzbarsky-apple

scripts/py_matter_yamltests/matter_yamltests/definitions.py

@@ -88,6 +88,10 @@ def __init__(self, sources: List[ParseSource]):
                     self.__responses_by_id[code][struct.code] = struct
                     self.__responses_by_name[name][struct.name] = struct.code
 
+        self.__global_bitmaps: dict[str, Bitmap] = {b.name: b for b in idl.global_bitmaps}
+        self.__global_enums: dict[str, Bitmap] = {e.name: e for e in idl.global_enums}
+        self.__global_structs: dict[str, Bitmap] = {s.name: s for s in idl.global_structs}
+
     def get_cluster_names(self) -> List[str]:
         return [name for name, _ in self.__clusters_by_name.items()]
 
@@ -257,9 +261,26 @@ def __get_targets_by_cluster_name(self, cluster_name: str, target_type: _ItemTyp
             _ItemType.Struct: self.__structs_by_name,
         }
 
+        global_target_mapping = {
+            _ItemType.Request: None,
+            _ItemType.Response: None,
+            _ItemType.Attribute: None,
+            _ItemType.Event: None,
+            _ItemType.Bitmap: self.__global_bitmaps,
+            _ItemType.Enum: self.__global_enums,
+            _ItemType.Struct: self.__global_structs,
+        }
+
         # The idl parser remove spaces
         cluster_name = cluster_name.replace(' ', '')
-        return target_mapping[target_type].get(cluster_name)
+        global_target = global_target_mapping[target_type]
+        target = target_mapping[target_type].get(cluster_name)
+
+        if target is None:
+            return global_target
+        if global_target is None:
+            return target
+        return target | global_target
 
 
 def SpecDefinitionsFromPaths(paths: str, pseudo_clusters: Optional[PseudoClusters] = PseudoClusters([])):

scripts/py_matter_yamltests/test_spec_definitions.py

@@ -102,6 +102,10 @@
 
 source_bitmap = '''<?xml version="1.0"?>
   <configurator>
+    <bitmap name="TestGlobalBitmap" type="bitmap8">
+      <field name="a" mask="0x1"/>
+    </bitmap>
+
     <bitmap name="TestBitmap" type="bitmap8">
       <cluster code="0x1234"/>
       <field name="a" mask="0x1"/>
@@ -126,6 +130,10 @@
 
 source_enum = '''<?xml version="1.0"?>
   <configurator>
+    <enum name="TestGlobalEnum" type="enum8">
+      <item name="a" value="0x00"/>
+    </enum>
+
     <enum name="TestEnum" type="enum8">
       <cluster code="0x1234"/>
       <item name="a" value="0x00"/>
@@ -150,6 +158,10 @@
 
 source_struct = '''<?xml version="1.0"?>
   <configurator>
+    <struct name="TestGlobalStruct">
+        <item name="a" type="boolean"/>
+    </struct>
+
     <struct name="TestStruct">
         <cluster code="0x1234"/>
         <item name="a" type="boolean"/>
@@ -310,10 +322,16 @@ def test_get_bitmap_by_name(self):
             [ParseSource(source=io.StringIO(source_bitmap), name='source_bitmap')])
         self.assertIsNone(definitions.get_bitmap_by_name(
             'WrongName', 'TestBitmap'))
+        self.assertIsNone(definitions.get_bitmap_by_name(
+            'TestWrong', 'TestBitmap'))
         self.assertIsNone(definitions.get_bitmap_by_name(
             'Test', 'TestWrongBitmap'))
         self.assertIsInstance(definitions.get_bitmap_by_name(
             'Test', 'TestBitmap'), Bitmap)
+        self.assertIsInstance(definitions.get_bitmap_by_name(
+            'Test', 'TestGlobalBitmap'), Bitmap)
+        self.assertIsInstance(definitions.get_bitmap_by_name(
+            'TestWrong', 'TestGlobalBitmap'), Bitmap)
         self.assertIsNone(definitions.get_bitmap_by_name('test', 'TestBitmap'))
         self.assertIsNone(definitions.get_bitmap_by_name('Test', 'testbitmap'))
 
@@ -322,10 +340,16 @@ def test_get_enum_by_name(self):
             [ParseSource(source=io.StringIO(source_enum), name='source_enum')])
         self.assertIsNone(definitions.get_enum_by_name(
             'WrongName', 'TestEnum'))
+        self.assertIsNone(definitions.get_enum_by_name(
+            'TestWrong', 'TestEnum'))
         self.assertIsNone(definitions.get_enum_by_name(
             'Test', 'TestWrongEnum'))
         self.assertIsInstance(
             definitions.get_enum_by_name('Test', 'TestEnum'), Enum)
+        self.assertIsInstance(
+            definitions.get_enum_by_name('Test', 'TestGlobalEnum'), Enum)
+        self.assertIsInstance(
+            definitions.get_enum_by_name('TestWrong', 'TestGlobalEnum'), Enum)
         self.assertIsNone(definitions.get_enum_by_name('test', 'TestEnum'))
         self.assertIsNone(definitions.get_enum_by_name('Test', 'testenum'))
 
@@ -334,10 +358,16 @@ def test_get_struct_by_name(self):
             [ParseSource(source=io.StringIO(source_struct), name='source_struct')])
         self.assertIsNone(definitions.get_struct_by_name(
             'WrongName', 'TestStruct'))
+        self.assertIsNone(definitions.get_struct_by_name(
+            'TestWrong', 'TestStruct'))
         self.assertIsNone(definitions.get_struct_by_name(
             'Test', 'TestWrongStruct'))
         self.assertIsInstance(definitions.get_struct_by_name(
             'Test', 'TestStruct'), Struct)
+        self.assertIsInstance(definitions.get_struct_by_name(
+            'Test', 'TestGlobalStruct'), Struct)
+        self.assertIsInstance(definitions.get_struct_by_name(
+            'TestWrong', 'TestGlobalStruct'), Struct)
         self.assertIsNone(definitions.get_struct_by_name('test', 'TestStruct'))
         self.assertIsNone(definitions.get_struct_by_name('Test', 'teststruct'))
 
@@ -365,16 +395,22 @@ def test_get_type_by_name(self):
             [ParseSource(source=io.StringIO(source_bitmap), name='source_bitmap')])
         self.assertIsInstance(definitions.get_type_by_name(
             'Test', 'TestBitmap'), Bitmap)
+        self.assertIsInstance(definitions.get_type_by_name(
+            'Test', 'TestGlobalBitmap'), Bitmap)
 
         definitions = SpecDefinitions(
             [ParseSource(source=io.StringIO(source_enum), name='source_enum')])
         self.assertIsInstance(
             definitions.get_type_by_name('Test', 'TestEnum'), Enum)
+        self.assertIsInstance(
+            definitions.get_type_by_name('Test', 'TestGlobalEnum'), Enum)
 
         definitions = SpecDefinitions(
             [ParseSource(source=io.StringIO(source_struct), name='source_struct')])
         self.assertIsInstance(definitions.get_type_by_name(
             'Test', 'TestStruct'), Struct)
+        self.assertIsInstance(definitions.get_type_by_name(
+            'Test', 'TestGlobalStruct'), Struct)
 
     def test_struct_is_fabric_scoped(self):
         definitions = SpecDefinitions(