diff --git a/src/python_testing/TC_TCCM_1_2.py b/src/python_testing/TC_TCCM_1_2.py index 011659f2087691..c945840dcae1e2 100644 --- a/src/python_testing/TC_TCCM_1_2.py +++ b/src/python_testing/TC_TCCM_1_2.py @@ -39,18 +39,19 @@ # === END CI TEST ARGUMENTS === -from tc_mode_base import ClusterModeCheck +from modebase_cluster_check import ModeBaseClusterChecks import chip.clusters as Clusters from chip.testing.matter_testing import MatterBaseTest, TestStep, async_test_body, default_matter_test_main -class TC_TCCM_1_2(MatterBaseTest, ClusterModeCheck): +class TC_TCCM_1_2(MatterBaseTest, ModeBaseClusterChecks): def __init__(self, *args): + self.cluster = Clusters.RefrigeratorAndTemperatureControlledCabinetMode super().__init__(*args) - ClusterModeCheck.__init__(self, - requested_cluster=Clusters.RefrigeratorAndTemperatureControlledCabinetMode) + ModeBaseClusterChecks.__init__(self, + modebase_derived_cluster=self.cluster) def desc_TC_TCCM_1_2(self) -> str: return "[TC-TCCM-1.2] Cluster attributes with DUT as Server" @@ -81,27 +82,29 @@ async def test_TC_TCCM_1_2(self): self.step(2) # Verify common checks for Mode Base as described in the TC-TCCM-1.2 - await self.check_supported_modes_and_labels(endpoint=endpoint) + supported_modes = await self.check_supported_modes_and_labels(endpoint=endpoint) # According to the spec, there should be at least one RapidCool or RapidFreeze tag in # the ones supported. - additional_tags = [Clusters.RefrigeratorAndTemperatureControlledCabinetMode.Enums.ModeTag.kRapidCool, - Clusters.RefrigeratorAndTemperatureControlledCabinetMode.Enums.ModeTag.kRapidFreeze] - self.check_tags_in_lists(requiredtags=additional_tags) + additional_tags = [self.cluster.Enums.ModeTag.kRapidCool, + self.cluster.Enums.ModeTag.kRapidFreeze] + self.check_tags_in_lists(supported_modes=supported_modes, required_tags=additional_tags) self.step(3) # Verify that the CurrentMode attribute has a valid value. - mode = Clusters.RefrigeratorAndTemperatureControlledCabinetMode.Attributes.CurrentMode - await self.read_and_check_mode(endpoint=endpoint, mode=mode) + mode = self.cluster.Attributes.CurrentMode + await self.read_and_check_mode(endpoint=endpoint, mode=mode, supported_modes=supported_modes) self.step(4) # Verify that the OnMode attribute has a valid value or null. - mode = Clusters.RefrigeratorAndTemperatureControlledCabinetMode.Attributes.OnMode - await self.read_and_check_mode(endpoint=endpoint, mode=mode, is_nullable=True) + mode = self.cluster.Attributes.OnMode + await self.read_and_check_mode(endpoint=endpoint, mode=mode, + supported_modes=supported_modes, is_nullable=True) self.step(5) # Verify that the StartUpMode has a valid value or null - mode = Clusters.RefrigeratorAndTemperatureControlledCabinetMode.Attributes.StartUpMode - await self.read_and_check_mode(endpoint=endpoint, mode=mode, is_nullable=True) + mode = self.cluster.Attributes.StartUpMode + await self.read_and_check_mode(endpoint=endpoint, mode=mode, + supported_modes=supported_modes, is_nullable=True) if __name__ == "__main__": diff --git a/src/python_testing/tc_mode_base.py b/src/python_testing/modebase_cluster_check.py similarity index 60% rename from src/python_testing/tc_mode_base.py rename to src/python_testing/modebase_cluster_check.py index ee1ee8c3f0efbe..aa151445560ca2 100644 --- a/src/python_testing/tc_mode_base.py +++ b/src/python_testing/modebase_cluster_check.py @@ -29,7 +29,7 @@ END_MFGTAGS_RANGE = 0xBFFF -class ClusterModeCheck: +class ModeBaseClusterChecks: """ Class that holds the common Mode checks between TCs Several TCs have similar checks in place for functionality that is common among them. @@ -40,15 +40,13 @@ class ClusterModeCheck: Attributes: - requested_cluster: A reference to the cluster to be tested, it should be a derived from the Mode Base cluster. + modebase_derived_cluster: A reference to the cluster to be tested, it should be a derived from the Mode Base cluster. """ - def __init__(self, requested_cluster): - self.modeTags = [tag.value for tag in requested_cluster.Enums.ModeTag] - self.requested_cluster = requested_cluster - self.attributes = requested_cluster.Attributes - self.supported_modes_dut = set() - self.supported_modes = None + def __init__(self, modebase_derived_cluster): + self.modeTags = [tag.value for tag in modebase_derived_cluster.Enums.ModeTag] + self.modebase_derived_cluster = modebase_derived_cluster + self.attributes = modebase_derived_cluster.Attributes async def check_supported_modes_and_labels(self, endpoint): """ Verifies the device supported modes and labels. @@ -57,50 +55,63 @@ async def check_supported_modes_and_labels(self, endpoint): - Between 2 and 255 entries. - The Mode values of all entries are unique. - The Label values of all entries are unique. + + Args: + endpoint: The endpoint used for the requests to the cluster. + + Returns: + A list of ModeOptionStruct supported by the cluster. """ # Get the supported modes - self.supported_modes = await self.read_single_attribute_check_success(endpoint=endpoint, - cluster=self.requested_cluster, - attribute=self.attributes.SupportedModes) + supported_modes = await self.read_single_attribute_check_success(endpoint=endpoint, + cluster=self.modebase_derived_cluster, + attribute=self.attributes.SupportedModes) # Check if the list of supported modes is larger than 2 - asserts.assert_greater_equal(len(self.supported_modes), 2, "SupportedModes must have at least 2 entries!") + asserts.assert_greater_equal(len(supported_modes), 2, "SupportedModes must have at least 2 entries!") # Check that supported modes are less than 255 - asserts.assert_less_equal(len(self.supported_modes), 255, "SupportedModes must have at most 255 entries!") + asserts.assert_less_equal(len(supported_modes), 255, "SupportedModes must have at most 255 entries!") # Check for repeated labels or modes labels = set() - for mode_options_struct in self.supported_modes: - # Verify that the modes in all ModeOptionsStruct in SupportedModes are unique. - if mode_options_struct.mode in self.supported_modes_dut: + modes = set() + for mode_option_struct in supported_modes: + # Verify that the modes in all ModeOptionStruct in SupportedModes are unique. + if mode_option_struct.mode in modes: asserts.fail("SupportedModes can't have repeated Mode values") else: - self.supported_modes_dut.add(mode_options_struct.mode) - # Verify that the labels in all ModeOptionsStruct in SupportedModes are unique. - if mode_options_struct.label in labels: + modes.add(mode_option_struct.mode) + # Verify that the labels in all ModeOptionStruct in SupportedModes are unique. + if mode_option_struct.label in labels: asserts.fail("SupportedModes can't have repeated Label values") else: - labels.add(mode_options_struct.label) + labels.add(mode_option_struct.label) + + return supported_modes - def check_tags_in_lists(self, requiredtags=None): + def check_tags_in_lists(self, supported_modes, required_tags=None): """ Validates the ModeTags values. - This function evaluates the ModeTags of each ModeOptionsStruct: + This function evaluates the ModeTags of each ModeOptionStruct: - Should have at least one tag. - Should be maximum 16bits in size. - Should be a Mfg tag or one of the supported ones (either common or specific). - Should have at least one common or specific tag. - If defined, verify that at least one of the "requiredTags" exists. + + Args: + supported_modes: A list of ModeOptionStruct. + required_tags: List of tags that are required according to the cluster spec. """ - # Verify the ModeTags on each ModeOptionsStruct - for mode_options_struct in self.supported_modes: + # Verify the ModeTags on each ModeOptionStruct + for mode_option_struct in supported_modes: # Shuld have at least one entry - if len(mode_options_struct.modeTags) == 0: + if len(mode_option_struct.modeTags) == 0: asserts.fail("The ModeTags field should have at least one entry.") # Check each ModelTag at_least_one_common_or_derived = False - for tag in mode_options_struct.modeTags: + for tag in mode_option_struct.modeTags: # Value should not larger than 16bits if tag.value > MAX_MODE_TAG or tag.value < 0: asserts.fail("Tag should not be larger than 16bits.") @@ -118,22 +129,31 @@ def check_tags_in_lists(self, requiredtags=None): if not at_least_one_common_or_derived: asserts.fail("There should be at least one common or derived tag on each ModeOptionsStruct") - if requiredtags: + if required_tags: has_required_tags = False - for mode_options_struct in self.supported_modes: - has_required_tags = any(tag.value in requiredtags for tag in mode_options_struct.modeTags) + for mode_options_struct in supported_modes: + has_required_tags = any(tag.value in required_tags for tag in mode_options_struct.modeTags) if has_required_tags: break asserts.assert_true(has_required_tags, "No ModeOptionsStruct has the required tags.") - async def read_and_check_mode(self, endpoint, mode, is_nullable=False): + async def read_and_check_mode(self, endpoint, mode, supported_modes, is_nullable=False): """Evaluates the current mode This functions checks if the requested mode attribute has a valid value from the SupportedModes, supports optional nullable values. + + Args: + endpoint: The endpoint used for the requests to the cluster. + mode: Mode that will be verified. + supported_modes: A list of ModeOptionStruct. + is_nullable: Optional argument to indicate if the tested mode allows NullValue """ - mode_value = await self.read_single_attribute_check_success(endpoint=endpoint, cluster=self.requested_cluster, attribute=mode) - is_valid = mode_value in self.supported_modes_dut + mode_value = await self.read_single_attribute_check_success(endpoint=endpoint, + cluster=self.modebase_derived_cluster, + attribute=mode) + supported_modes_dut = {mode_option_struct.mode for mode_option_struct in supported_modes} + is_valid = mode_value in supported_modes_dut if is_nullable and mode_value == NullValue: is_valid = True asserts.assert_true(is_valid, f"{mode} not supported")