[Debug] Add automatic device attribute dump on composition test failures

src/python_testing/TC_DeviceBasicComposition.py

@@ -189,7 +189,7 @@
 from matter.clusters.Types import Nullable
 from matter.exceptions import ChipStackError
 from matter.interaction_model import InteractionModelError, Status
-from matter.testing.basic_composition import BasicCompositionTests
+from matter.testing.basic_composition import BasicCompositionTests, log_structured_data
 from matter.testing.global_attribute_ids import (AttributeIdType, ClusterIdType, CommandIdType, GlobalAttributeIds,
                                                  attribute_id_type, cluster_id_type, command_id_type)
 from matter.testing.matter_testing import MatterBaseTest, TestStep, async_test_body, default_matter_test_main
@@ -272,7 +272,7 @@ def check_no_duplicates(obj: Any) -> None:
         raise ValueError(f"Value {str(obj)} contains duplicate values")
 
 
-class TC_DeviceBasicComposition(MatterBaseTest, BasicCompositionTests):
+class TC_DeviceBasicComposition(BasicCompositionTests, MatterBaseTest):
     @async_test_body
     async def setup_class(self):
         super().setup_class()
@@ -604,12 +604,14 @@ class RequiredMandatoryAttribute:
                                                      attribute_id=manufacturer_value)
                     if suffix > attribute_standard_range_max and suffix < global_range_min:
                         self.record_error(self.get_test_name(), location=location,
-                                          problem=f"Manufacturer attribute in undefined range {manufacturer_value} in cluster {cluster_id}",
+                                          problem=f"Manufacturer attribute in undefined range {
+                                              manufacturer_value} in cluster {cluster_id}",
                                           spec_location=f"Cluster {cluster_id}")
                         success = False
                     elif suffix >= global_range_min:
                         self.record_error(self.get_test_name(), location=location,
-                                          problem=f"Manufacturer attribute in global range {manufacturer_value} in cluster {cluster_id}",
+                                          problem=f"Manufacturer attribute in global range {
+                                              manufacturer_value} in cluster {cluster_id}",
                                           spec_location=f"Cluster {cluster_id}")
                         success = False
 
@@ -930,7 +932,8 @@ def record_problems(problems):
             for ep, problem in problems.items():
                 location = AttributePathLocation(endpoint_id=ep, cluster_id=Clusters.Descriptor.id,
                                                  attribute_id=Clusters.Descriptor.Attributes.TagList.attribute_id)
-                msg = f'problem on ep {ep}: missing feature = {problem.missing_feature}, missing attribute = {problem.missing_attribute}, duplicates = {problem.duplicates}, same_tags = {problem.same_tag}'
+                msg = f'problem on ep {ep}: missing feature = {problem.missing_feature}, missing attribute = {
+                    problem.missing_attribute}, duplicates = {problem.duplicates}, same_tags = {problem.same_tag}'
                 self.record_error(self.get_test_name(), location=location, problem=msg, spec_location="Descriptor TagList")
 
         record_problems(problems)
@@ -966,13 +969,6 @@ def test_TC_IDM_12_1(self):
         json_str, txt_str = self.dump_wildcard(dump_device_composition_path)
 
         # Structured dump so we can pull these back out of the logs
-        def log_structured_data(start_tag: str, dump_string):
-            lines = dump_string.splitlines()
-            logging.info(f'{start_tag}BEGIN ({len(lines)} lines)====')
-            for line in lines:
-                logging.info(f'{start_tag}{line}')
-            logging.info(f'{start_tag}END ====')
-
         log_structured_data('==== json: ', json_str)
         log_structured_data('==== txt: ', txt_str)
 
@@ -1216,7 +1212,8 @@ async def test_TC_DESC_2_1(self):
                         self.record_error(
                             self.get_test_name(),
                             location=location,
-                            problem=f"EndpointUniqueId attribute length is {len(value)} bytes which exceeds the maximum allowed 32 bytes",
+                            problem=f"EndpointUniqueId attribute length is {
+                                len(value)} bytes which exceeds the maximum allowed 32 bytes",
                             spec_location="EndpointUniqueId attribute"
                         )
                         self.fail_current_test(

src/python_testing/TC_DeviceConformance.py

@@ -41,7 +41,7 @@
 from matter.testing.matter_testing import MatterBaseTest, TestStep, async_test_body, default_matter_test_main
 
 
-class TC_DeviceConformance(MatterBaseTest, DeviceConformanceTests):
+class TC_DeviceConformance(DeviceConformanceTests, MatterBaseTest):
     @async_test_body
     async def setup_class(self):
         super().setup_class()

src/python_testing/matter_testing_infrastructure/matter/testing/basic_composition.py

@@ -41,6 +41,23 @@
 LOGGER = logging.getLogger(__name__)
 
 
+def log_structured_data(start_tag: str, dump_string: str):
+    """Log structured data with a clear start and end marker.
+
+    This function is used to output device attribute dumps and other structured 
+    data to logs in a format that can be easily extracted for debugging.
+
+    Args:
+        start_tag: A prefix tag to identify the type of data being logged
+        dump_string: The data to be logged
+    """
+    lines = dump_string.splitlines()
+    LOGGER.info(f'{start_tag}BEGIN ({len(lines)} lines)====')
+    for line in lines:
+        LOGGER.info(f'{start_tag}{line}')
+    LOGGER.info(f'{start_tag}END ====')
+
+
 @dataclass
 class ArlData:
     have_arl: bool

src/python_testing/matter_testing_infrastructure/matter/testing/matter_testing.py

@@ -206,7 +206,7 @@ def setup_class(self):
         self.stored_global_wildcard = None
 
     def teardown_class(self):
-        """Final teardown after all tests: log all problems.
+        """Final teardown after all tests: log all problems and dump device attributes if available.
             Test authors may overwrite this method in the derived class to perform teardown that is common for all tests
              This function is called only once per class. To perform teardown after each test, use teardown_test.
              Test authors that implement steps in this function need to be careful of step handling if there is
@@ -222,8 +222,54 @@ def teardown_class(self):
             for problem in self.problems:
                 LOGGER.info(str(problem))
             LOGGER.info("###########################################################")
+
+            # Attempt to dump device attribute data for debugging when problems are found
+            self._dump_device_attributes_on_failure()
         super().teardown_class()
 
+    def _dump_device_attributes_on_failure(self):
+        """
+        Dump device attribute data when problems are found for debugging purposes.
+
+        This method attempts to generate a device attribute dump if the test has
+        collected endpoint data. It's designed to be safe and not interfere with
+        the original test failure reporting.
+        """
+        try:
+            # Check if we have endpoints_tlv data (from BasicCompositionTests or similar)
+            if hasattr(self, 'endpoints_tlv') and self.endpoints_tlv:
+                LOGGER.info("MatterBaseTest: Problems detected - generating device attribute dump")
+
+                # Check if we have the dump_wildcard method (from BasicCompositionTests)
+                if hasattr(self, 'dump_wildcard'):
+                    LOGGER.info("Device attribute data available - generating dump")
+                    _, txt_str = self.dump_wildcard(None)
+                    # Only dump the text format - it's more readable for debugging
+                    self._log_structured_data('==== FAILURE_DUMP_txt: ', txt_str)
+                else:
+                    LOGGER.info("dump_wildcard method not available - skipping device attribute dump")
+            else:
+                LOGGER.debug("No device attribute data available (endpoints_tlv not populated)")
+        except Exception as e:
+            # Don't let logging errors interfere with the original test failure
+            LOGGER.warning(f"Failed to generate device attribute dump: {e}")
+
+    def _log_structured_data(self, start_tag: str, dump_string: str):
+        """Log structured data with a clear start and end marker.
+
+        This function is used to output device attribute dumps and other structured 
+        data to logs in a format that can be easily extracted for debugging.
+
+        Args:
+            start_tag: A prefix tag to identify the type of data being logged
+            dump_string: The data to be logged
+        """
+        lines = dump_string.splitlines()
+        LOGGER.info(f'{start_tag}BEGIN ({len(lines)} lines)====')
+        for line in lines:
+            LOGGER.info(f'{start_tag}{line}')
+        LOGGER.info(f'{start_tag}END ====')
+
     def setup_test(self):
         """Set up for each individual test execution.