| # |
| # 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 typing import Callable |
| |
| import chip.clusters as Clusters |
| import TC_DefaultWarnings |
| from chip.testing.matter_testing import MatterBaseTest, default_matter_test_main |
| from mobly import asserts |
| |
| |
| class TestDefaultChecker(MatterBaseTest): |
| ''' This is a unit-style test of the defaults test. It runs the individual test functions against mocks.''' |
| |
| def setup_test(self): |
| self.test = TC_DefaultWarnings.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 = {TC_DefaultWarnings.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_vendor_name_is_not_default_check(self): |
| def run_check(vendor_name: str, set_override: bool, expect_problem: bool): |
| self.test.user_params = {TC_DefaultWarnings.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 = {TC_DefaultWarnings.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 = {TC_DefaultWarnings.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 = {TC_DefaultWarnings.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 = {TC_DefaultWarnings.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, |
| TC_DefaultWarnings.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, |
| TC_DefaultWarnings.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, |
| TC_DefaultWarnings.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 = {TC_DefaultWarnings.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 = {TC_DefaultWarnings.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 = {TC_DefaultWarnings.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 TC_DefaultWarnings.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(TC_DefaultWarnings.DEFAULT_FIXED_LABEL_VALUES, set_override=False, expect_problem=True) |
| run_check(TC_DefaultWarnings.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 = {TC_DefaultWarnings.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() |
