| # | |
| # Copyright (c) 2025 Project CHIP Authors | |
| # All rights reserved. | |
| # | |
| # Licensed under the Apache License, Version 2.0 (the "License"); | |
| # you may not use this file except in compliance with the License. | |
| # You may obtain a copy of the License at | |
| # | |
| # http://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, software | |
| # distributed under the License is distributed on an "AS IS" BASIS, | |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| # See the License for the specific language governing permissions and | |
| # limitations under the License. | |
| # | |
| from collections.abc import Callable | |
| from mobly import asserts | |
| import matter.clusters as Clusters | |
| import matter.testing.default_checker as DefaultChecker | |
| from matter.testing.matter_testing import CertificationUnitTestNoDevice | |
| from matter.testing.runner import default_matter_test_main | |
| class TestDefaultChecker(CertificationUnitTestNoDevice): | |
| ''' This is a unit-style test of the defaults test. It runs the individual test functions against mocks.''' | |
| def setup_test(self): | |
| self.test = DefaultChecker.DefaultChecker() | |
| self.test.mark_current_step_skipped = self.mark_current_step_skipped | |
| self.skipped = 0 | |
| super().setup_test() | |
| def mark_current_step_skipped(self): | |
| ''' Override of the base mark_current_step_skipped so the tests here can assert that these get called correctly.''' | |
| self.skipped += 1 | |
| def test_product_name_is_not_default_check(self): | |
| def run_check(product_name: str, set_override: bool, expect_problem: bool): | |
| self.test.user_params = {DefaultChecker.FLAG_PRODUCT_NAME: set_override} | |
| self.test.problems = [] | |
| self.test.endpoints = {0: {Clusters.BasicInformation: {Clusters.BasicInformation.Attributes.ProductName: product_name}}} | |
| self.test.check_default_product_name() | |
| if expect_problem: | |
| asserts.assert_equal(len(self.test.problems), 1, | |
| f"did not generate expected problem when testing with product name {product_name} (override = {set_override})") | |
| else: | |
| asserts.assert_equal(len(self.test.problems), 0, | |
| f"Unexpected problem when testing with product name {product_name} (override = {set_override})") | |
| asserts.assert_equal(self.skipped, 0, "Internal error: skip not reset properly") | |
| run_check('TEST_PRODUCT', set_override=False, expect_problem=True) | |
| run_check('TestBad', set_override=False, expect_problem=True) | |
| run_check('BadTest', set_override=False, expect_problem=True) | |
| run_check('TEST_PRODUCT', set_override=True, expect_problem=False) | |
| run_check('TestBad', set_override=True, expect_problem=False) | |
| run_check('BadTest', set_override=True, expect_problem=False) | |
| run_check('OK name', set_override=False, expect_problem=False) | |
| run_check('OK name', set_override=True, expect_problem=False) | |
| asserts.assert_equal(self.skipped, 4, "Some override tests did not mark steps skipped") | |
| def test_manufacturing_date_is_not_default_check(self): | |
| def run_check(manufacturing_date: str, set_override: bool, expect_problem: bool): | |
| self.test.user_params = {DefaultChecker.FLAG_MANUFACTURING_DATE: set_override} | |
| self.test.problems = [] | |
| self.test.endpoints = {0: {Clusters.BasicInformation: { | |
| Clusters.BasicInformation.Attributes.ManufacturingDate: manufacturing_date}}} | |
| self.test.check_default_manufacturing_date() | |
| if expect_problem: | |
| asserts.assert_equal(len(self.test.problems), 1, | |
| f"did not generate expected problem when testing with manufacturing date {manufacturing_date} (override = {set_override})") | |
| else: | |
| asserts.assert_equal(len(self.test.problems), 0, | |
| f"Unexpected problem when testing with manufacturing date {manufacturing_date} (override = {set_override})") | |
| # Attribute not present -> should be skipped, no problem | |
| self.skipped = 0 | |
| self.test.problems = [] | |
| self.test.user_params = {} | |
| self.test.endpoints = {0: {Clusters.BasicInformation: {}}} | |
| self.test.check_default_manufacturing_date() | |
| asserts.assert_equal(len(self.test.problems), 0, | |
| "Unexpected problem when ManufacturingDate attribute is not present") | |
| asserts.assert_equal(self.skipped, 1, "Absent ManufacturingDate did not mark step skipped") | |
| self.skipped = 0 | |
| run_check('20200101', set_override=False, expect_problem=True) | |
| run_check('20200102', set_override=False, expect_problem=False) | |
| run_check('20200102', set_override=True, expect_problem=False) | |
| run_check('20200101', set_override=True, expect_problem=False) | |
| run_check('20200101-test1', set_override=False, expect_problem=True) | |
| run_check('20200102-test2', set_override=False, expect_problem=False) | |
| asserts.assert_equal(self.skipped, 2, "Some override tests did not mark steps skipped") | |
| def test_vendor_name_is_not_default_check(self): | |
| def run_check(vendor_name: str, set_override: bool, expect_problem: bool): | |
| self.test.user_params = {DefaultChecker.FLAG_VENDOR_NAME: set_override} | |
| self.test.problems = [] | |
| self.test.endpoints = {0: {Clusters.BasicInformation: {Clusters.BasicInformation.Attributes.VendorName: vendor_name}}} | |
| self.test.check_default_vendor_name() | |
| if expect_problem: | |
| asserts.assert_equal(len(self.test.problems), 1, | |
| f"did not generate expected problem when testing with vendor name {vendor_name} (override = {set_override})") | |
| else: | |
| asserts.assert_equal(len(self.test.problems), 0, | |
| f"Unexpected problem when testing with vendor name {vendor_name} (override = {set_override})") | |
| asserts.assert_equal(self.skipped, 0, "Skip not reset properly") | |
| run_check('TEST_VENDOR', set_override=False, expect_problem=True) | |
| run_check('TestBad', set_override=False, expect_problem=True) | |
| run_check('BadTest', set_override=False, expect_problem=True) | |
| run_check('TEST_VENDOR', set_override=True, expect_problem=False) | |
| run_check('TestBad', set_override=True, expect_problem=False) | |
| run_check('BadTest', set_override=True, expect_problem=False) | |
| run_check('OK name', set_override=False, expect_problem=False) | |
| run_check('OK name', set_override=True, expect_problem=False) | |
| asserts.assert_equal(self.skipped, 4, "Some override tests did not mark steps skipped") | |
| def test_vendor_id_is_not_default_check(self): | |
| def run_check(vendor_id: int, set_override: bool, expect_problem: bool): | |
| self.test.user_params = {DefaultChecker.FLAG_VENDOR_ID: set_override} | |
| self.test.problems = [] | |
| self.test.endpoints = {0: {Clusters.BasicInformation: {Clusters.BasicInformation.Attributes.VendorID: vendor_id}}} | |
| self.test.check_default_vendor_id() | |
| if expect_problem: | |
| asserts.assert_equal(len(self.test.problems), 1, | |
| f"did not generate expected problem when testing with vendor id {vendor_id} (override = {set_override})") | |
| else: | |
| asserts.assert_equal(len(self.test.problems), 0, | |
| f"Unexpected problem when testing with vendor id {vendor_id} (override = {set_override})") | |
| asserts.assert_equal(self.skipped, 0, "Skip not reset properly") | |
| run_check(0xFFF1, set_override=False, expect_problem=True) | |
| run_check(0xFFF2, set_override=False, expect_problem=True) | |
| run_check(0, set_override=False, expect_problem=True) | |
| run_check(0xFFF1, set_override=True, expect_problem=False) | |
| run_check(0xFFF2, set_override=True, expect_problem=False) | |
| run_check(0, set_override=True, expect_problem=False) | |
| run_check(0x6006, set_override=False, expect_problem=False) | |
| run_check(0x6006, set_override=True, expect_problem=False) | |
| asserts.assert_equal(self.skipped, 4, "Some override tests did not mark steps skipped") | |
| def test_calendar_is_not_default_check(self): | |
| enum = Clusters.TimeFormatLocalization.Enums.CalendarTypeEnum | |
| def run_check(calendar_type: Clusters.TimeFormatLocalization.Enums.CalendarTypeEnum, set_override: bool, expect_problem: bool): | |
| self.test.user_params = {DefaultChecker.FLAG_DEFAULT_CALENDAR_FORMAT: set_override} | |
| self.test.problems = [] | |
| self.test.endpoints = {0: {Clusters.TimeFormatLocalization: { | |
| Clusters.TimeFormatLocalization.Attributes.ActiveCalendarType: calendar_type}}} | |
| self.test.check_default_calendar_format() | |
| if expect_problem: | |
| asserts.assert_equal(len(self.test.problems), 1, | |
| f"did not generate expected problem when testing with calendar type {calendar_type} (override = {set_override})") | |
| else: | |
| asserts.assert_equal(len(self.test.problems), 0, | |
| f"Unexpected problem when testing with calendar {calendar_type} (override = {set_override})") | |
| asserts.assert_equal(self.skipped, 0, "Skip not reset properly") | |
| run_check(enum.kBuddhist, set_override=False, expect_problem=True) | |
| run_check(enum.kChinese, set_override=False, expect_problem=False) | |
| run_check(enum.kBuddhist, set_override=True, expect_problem=False) | |
| run_check(enum.kChinese, set_override=True, expect_problem=False) | |
| asserts.assert_equal(self.skipped, 2, "Some override tests did not mark steps skipped") | |
| # Cluster not present | |
| self.skipped = 0 | |
| self.test.problems = [] | |
| self.test.user_params = {} | |
| self.test.endpoints = {0: {}} | |
| self.test.check_default_calendar_format() | |
| asserts.assert_equal(len(self.test.problems), 0, | |
| "Unexpected problem when testing device with no TimeFormatLocalization cluster") | |
| # Should have marked this as skipped | |
| asserts.assert_equal(self.skipped, 1, "Some override tests did not mark steps skipped") | |
| # Flag should also work here | |
| self.skipped = 0 | |
| self.test.user_params = {DefaultChecker.FLAG_DEFAULT_CALENDAR_FORMAT: True} | |
| self.test.check_default_calendar_format() | |
| asserts.assert_equal(len(self.test.problems), 0, | |
| "Unexpected problem when testing device with no TimeFormatLocalization cluster and override") | |
| # Should have marked this as skipped | |
| asserts.assert_equal(self.skipped, 1, "Some override tests did not mark steps skipped") | |
| # Attribute not present | |
| self.skipped = 0 | |
| self.test.problems = [] | |
| self.test.user_params = {} | |
| self.test.endpoints = {0: {Clusters.TimeFormatLocalization: {}}} | |
| self.test.check_default_calendar_format() | |
| asserts.assert_equal(len(self.test.problems), 0, | |
| "Unexpected problem when testing device with no ActiveCalendarType attribute") | |
| # Should have marked this as skipped | |
| asserts.assert_equal(self.skipped, 1, "Override test did not mark steps skipped") | |
| # Flag should also work here | |
| self.skipped = 0 | |
| self.test.user_params = {DefaultChecker.FLAG_DEFAULT_CALENDAR_FORMAT: True} | |
| self.test.check_default_calendar_format() | |
| asserts.assert_equal(len(self.test.problems), 0, | |
| "Unexpected problem when testing device with no ActiveCalendarType cluster and override") | |
| # Should have marked this as skipped | |
| asserts.assert_equal(self.skipped, 1, "Override test did not mark steps skipped") | |
| def _cluster_presence_test(self, cluster: Clusters.ClusterObjects.Cluster, fn: Callable, flag: str): | |
| def test_endpoint(endpoint: int): | |
| # no problem expected when cluster is not present | |
| self.test.problems = [] | |
| self.test.user_params = {} | |
| self.test.endpoints = {endpoint: {Clusters.Descriptor: {Clusters.Descriptor.Attributes.ServerList: []}}} | |
| fn() | |
| asserts.assert_equal(len(self.test.problems), 0, | |
| f"Unexpected problem when testing for cluster presence of cluster {cluster} on endpoint {endpoint} (override = False)") | |
| # No problem when testing with override flag, but should get skip marked | |
| self.skipped = 0 | |
| self.test.user_params = {flag: True} | |
| fn() | |
| asserts.assert_equal(len(self.test.problems), 0, | |
| f"Unexpected problem when testing for cluster presence of cluster {cluster} on endpoint {endpoint} (override = True)") | |
| asserts.assert_equal(self.skipped, 1, f"Test not marked skipped as expected (cluster = {cluster} flag = {flag})") | |
| # Should get a problem when the cluster is present | |
| self.test.user_params = {flag: False} | |
| self.test.endpoints = {endpoint: {cluster: {}, Clusters.Descriptor: { | |
| Clusters.Descriptor.Attributes.ServerList: [cluster.id]}}} | |
| fn() | |
| asserts.assert_equal(len(self.test.problems), 1, | |
| f"Did not get expected problem notification when testing with {cluster} on endpoint {endpoint}") | |
| self.test.user_params = {flag: True} | |
| self.skipped = 0 | |
| self.test.problems = [] | |
| fn() | |
| asserts.assert_equal(len( | |
| self.test.problems), 0, f"Unexpected problem notification when testing with {cluster} on endpoint {endpoint} and override {flag} set") | |
| asserts.assert_equal(self.skipped, 1, f"Test with override flag {flag} did not mark skipped") | |
| test_endpoint(0) | |
| test_endpoint(1) | |
| def test_unit_testing_is_not_present_check(self): | |
| self._cluster_presence_test(Clusters.UnitTesting, self.test.check_unit_testing_cluster_presence, | |
| DefaultChecker.FLAG_UNIT_TESTING) | |
| def test_fault_injection_is_not_present_check(self): | |
| self._cluster_presence_test(Clusters.FaultInjection, self.test.check_fault_injection_cluster_presence, | |
| DefaultChecker.FLAG_FAULT_INJECTION) | |
| def test_sample_mei_is_not_present_check(self): | |
| self._cluster_presence_test(Clusters.SampleMei, self.test.check_sample_mei_cluster_presence, | |
| DefaultChecker.FLAG_SAMPLE_MEI) | |
| def test_fixed_label_is_not_empty_check(self): | |
| def run_check(label_list: list[Clusters.FixedLabel.Structs.LabelStruct], set_override: bool, expect_problem: bool): | |
| self.test.user_params = {DefaultChecker.FLAG_FIXED_LABEL_EMPTY: set_override} | |
| self.test.problems = [] | |
| self.test.endpoints = {0: {Clusters.FixedLabel: {Clusters.FixedLabel.Attributes.LabelList: label_list}}} | |
| self.test.check_fixed_label_cluster_empty() | |
| if expect_problem: | |
| asserts.assert_equal(len(self.test.problems), 1, | |
| f"did not generate expected problem when testing with empty fixed label list (override = {set_override})") | |
| else: | |
| asserts.assert_equal(len(self.test.problems), 0, | |
| f"Unexpected problem when testing with non-empty fixed label list (override = {set_override})") | |
| asserts.assert_equal(self.skipped, 0, "Skip not reset properly") | |
| run_check([], set_override=False, expect_problem=True) | |
| run_check([Clusters.FixedLabel.Structs.LabelStruct("test", "val")], set_override=False, expect_problem=False) | |
| run_check([], set_override=True, expect_problem=False) | |
| run_check([Clusters.FixedLabel.Structs.LabelStruct("test", "val")], set_override=True, expect_problem=False) | |
| asserts.assert_equal(self.skipped, 2, "Some override tests did not mark steps skipped") | |
| # Cluster not present | |
| self.skipped = 0 | |
| self.test.problems = [] | |
| self.test.user_params = {} | |
| self.test.endpoints = {0: {}} | |
| self.test.check_fixed_label_cluster_empty() | |
| asserts.assert_equal(len(self.test.problems), 0, | |
| "Unexpected problem when testing device with no FixedLabel cluster") | |
| # Should have marked this as skipped | |
| asserts.assert_equal(self.skipped, 1, "Some override tests did not mark steps skipped") | |
| # Flag should also work here | |
| self.skipped = 0 | |
| self.test.user_params = {DefaultChecker.FLAG_FIXED_LABEL_EMPTY: True} | |
| self.test.check_fixed_label_cluster_empty() | |
| asserts.assert_equal(len(self.test.problems), 0, | |
| "Unexpected problem when testing device with no TimeFormatLocalization cluster and override") | |
| # Should have marked this as skipped | |
| asserts.assert_equal(self.skipped, 1, "Some override tests did not mark steps skipped") | |
| def test_fixed_label_is_not_default_check(self): | |
| def run_check(label_list: list[Clusters.FixedLabel.Structs.LabelStruct], set_override: bool, expect_problem: bool): | |
| self.skipped = 0 | |
| self.test.user_params = {DefaultChecker.FLAG_FIXED_LABEL_DEFAULT_VALUES: set_override} | |
| self.test.problems = [] | |
| self.test.endpoints = {0: {Clusters.FixedLabel: {Clusters.FixedLabel.Attributes.LabelList: label_list}}} | |
| self.test.check_fixed_label_cluster_defaults() | |
| if expect_problem: | |
| asserts.assert_equal(len(self.test.problems), 1, | |
| f"did not generate expected problem when testing with empty fixed label list (override = {set_override})") | |
| else: | |
| asserts.assert_equal(len(self.test.problems), 0, | |
| f"Unexpected problem when testing with non-empty fixed label list (override = {set_override})") | |
| if set_override: | |
| asserts.assert_equal(self.skipped, 1, "Test with override did not mark steps skipped") | |
| asserts.assert_equal(self.skipped, 0, "Skip not reset properly") | |
| for default_label in DefaultChecker.DEFAULT_FIXED_LABEL_VALUES: | |
| run_check([default_label], set_override=False, expect_problem=True) | |
| run_check([default_label], set_override=True, expect_problem=False) | |
| run_check(DefaultChecker.DEFAULT_FIXED_LABEL_VALUES, set_override=False, expect_problem=True) | |
| run_check(DefaultChecker.DEFAULT_FIXED_LABEL_VALUES, set_override=True, expect_problem=False) | |
| run_check([Clusters.FixedLabel.Structs.LabelStruct("test", "val")], set_override=False, expect_problem=False) | |
| run_check([Clusters.FixedLabel.Structs.LabelStruct("test", "val")], set_override=True, expect_problem=False) | |
| # Cluster not present | |
| self.skipped = 0 | |
| self.test.problems = [] | |
| self.test.user_params = {} | |
| self.test.endpoints = {0: {}} | |
| self.test.check_fixed_label_cluster_defaults() | |
| asserts.assert_equal(len(self.test.problems), 0, | |
| "Unexpected problem when testing device with no FixedLabel cluster") | |
| # Should have marked this as skipped | |
| asserts.assert_equal(self.skipped, 1, "Some override tests did not mark steps skipped") | |
| # Flag should also work here | |
| self.skipped = 0 | |
| self.test.user_params = {DefaultChecker.FLAG_FIXED_LABEL_DEFAULT_VALUES: True} | |
| self.test.check_fixed_label_cluster_defaults() | |
| asserts.assert_equal(len(self.test.problems), 0, | |
| "Unexpected problem when testing device with no FixedLabel cluster and override") | |
| # Should have marked this as skipped | |
| asserts.assert_equal(self.skipped, 1, "Some override tests did not mark steps skipped") | |
| if __name__ == "__main__": | |
| default_matter_test_main() |