Update rvc mode cluters with new mode restrictions

src/app/tests/suites/certification/Test_TC_RVCCLEANM_1_1.yaml

@@ -42,25 +42,13 @@ tests:
               type: int16u
 
     - label: "Step 3: TH reads from the DUT the FeatureMap attribute."
-      PICS: " !RVCCLEANM.S.F00 "
       command: "readAttribute"
       attribute: "FeatureMap"
       response:
           value: 0
           constraints:
               type: bitmap32
 
-    - label:
-          "Step 3: Given RVCCLEANM.S.F00(DEPONOFF) ensure featuremap has the
-          correct bit set"
-      PICS: RVCCLEANM.S.F00
-      command: "readAttribute"
-      attribute: "FeatureMap"
-      response:
-          constraints:
-              type: bitmap32
-              hasMasksSet: [0x1]
-
     - label: "Step 4a: TH reads from the DUT the AttributeList attribute."
       PICS: PICS_EVENT_LIST_ENABLED
       command: "readAttribute"

src/app/tests/suites/certification/Test_TC_RVCRUNM_1_1.yaml

@@ -41,26 +41,14 @@ tests:
           constraints:
               type: int16u
 
-    - label: "Step 3a: TH reads from the DUT the FeatureMap attribute."
-      PICS: " !RVCRUNM.S.F00 "
+    - label: "Step 3: TH reads from the DUT the FeatureMap attribute."
       command: "readAttribute"
       attribute: "FeatureMap"
       response:
           value: 0
           constraints:
               type: bitmap32
 
-    - label:
-          "Step 3b: Given RVCRUNM.S.F00(DEPONOFF) ensure featuremap has the
-          correct bit set"
-      PICS: RVCRUNM.S.F00
-      command: "readAttribute"
-      attribute: "FeatureMap"
-      response:
-          constraints:
-              type: bitmap32
-              hasMasksSet: [0x1]
-
     - label: "Step 4a: TH reads from the DUT the AttributeList attribute."
       PICS: PICS_EVENT_LIST_ENABLED
       command: "readAttribute"

src/python_testing/TC_RVCCLEANM_1_2.py

@@ -18,7 +18,6 @@
 import logging
 
 import chip.clusters as Clusters
-from chip.clusters.Types import NullValue
 from matter_testing_support import MatterBaseTest, async_test_body, default_matter_test_main
 from mobly import asserts
 
@@ -28,6 +27,21 @@
 
 
 class TC_RVCCLEANM_1_2(MatterBaseTest):
+    def __init__(self, *args):
+        super().__init__(args)
+        self.commonTags = {0x0: 'Auto',
+                           0x1: 'Quick',
+                           0x2: 'Quiet',
+                           0x3: 'LowNoise',
+                           0x4: 'LowEnergy',
+                           0x5: 'Vacation',
+                           0x6: 'Min',
+                           0x7: 'Max',
+                           0x8: 'Night',
+                           0x9: 'Day'}
+        self.cleanTags = [tag.value for tag in Clusters.RvcCleanMode.Enums.ModeTag
+                          if tag is not Clusters.RvcCleanMode.Enums.ModeTag.kUnknownEnumValue]
+        self.supported_modes_dut = []
 
     async def read_mod_attribute_expect_success(self, endpoint, attribute):
         cluster = Clusters.Objects.RvcCleanMode
@@ -55,64 +69,74 @@ async def test_TC_RVCCLEANM_1_2(self):
 
             logging.info("SupportedModes: %s" % (supported_modes))
 
+            # Verify that the list has at least 2 and at most 255 entries
             asserts.assert_greater_equal(len(supported_modes), 2, "SupportedModes must have at least 2 entries!")
             asserts.assert_less_equal(len(supported_modes), 255, "SupportedModes must have at most 255 entries!")
 
-            modes = []
+            # Verify that each ModeOptionsStruct entry has a unique Mode field value
             for m in supported_modes:
-                if m.mode in modes:
+                if m.mode in self.supported_modes_dut:
                     asserts.fail("SupportedModes must have unique mode values!")
                 else:
-                    modes.append(m.mode)
+                    self.supported_modes_dut.append(m.mode)
 
+            # Verify that each ModeOptionsStruct entry has a unique Label field value
             labels = []
             for m in supported_modes:
                 if m.label in labels:
                     asserts.fail("SupportedModes must have unique mode label values!")
                 else:
                     labels.append(m.label)
 
-            # common mode tags
-            commonTags = {0x0: 'Auto',
-                          0x1: 'Quick',
-                          0x2: 'Quiet',
-                          0x3: 'LowNoise',
-                          0x4: 'LowEnergy',
-                          0x5: 'Vacation',
-                          0x6: 'Min',
-                          0x7: 'Max',
-                          0x8: 'Night',
-                          0x9: 'Day'}
-
-            cleanTags = [tag.value for tag in Clusters.RvcCleanMode.Enums.ModeTag
-                         if tag is not Clusters.RvcCleanMode.Enums.ModeTag.kUnknownEnumValue]
+            # Verify that each ModeOptionsStruct entry's ModeTags field has:
+            for m in supported_modes:
+                # * at least one entry
+                if len(m.modeTags) == 0:
+                    asserts.fail("SupportedModes must have at least one mode tag!")
 
+                at_least_one_common_or_clean_tag = False
+                for t in m.modeTags:
+                    # * the values of the Value fields that are not larger than 16 bits
+                    if t.value > 0xFFFF or t.value < 0:
+                        asserts.fail("Mode tage values must not be lager tha 16 bits!")
+
+                    # * for each Value field: {isCommonOrDerivedOrMfgTagsVal}
+                    is_mfg = (0x8000 <= t.value <= 0xBFFF)
+                    if (t.value not in self.commonTags and
+                            t.value not in self.cleanTags and
+                            not is_mfg):
+                        asserts.fail("Mode tag value is not a common tag, clean tag or vendor tag!")
+
+                    # * for at least one Value field: {isCommonOrDerivedTagsVal}
+                    if not is_mfg:
+                        at_least_one_common_or_clean_tag = True
+
+                if not at_least_one_common_or_clean_tag:
+                    asserts.fail("At least one mode tag must be a common tag or clean tag!")
+
+            # Verify that at least one ModeOptionsStruct entry includes either the
+            # Vacuum(0x4001) mode tag or the Mop(0x4002)mode tag in the ModeTags field
+            has_vacuum_or_mop_mode_tag = False
             for m in supported_modes:
+                if has_vacuum_or_mop_mode_tag:
+                    break
+
                 for t in m.modeTags:
-                    is_mfg = (0x8000 <= t.value and t.value <= 0xBFFF)
-                    asserts.assert_true(t.value in commonTags.keys() or t.value in cleanTags or is_mfg,
-                                        "Found a SupportedModes entry with invalid mode tag value!")
+                    if t.value in [Clusters.RvcCleanMode.Enums.ModeTag.kVacuum,
+                                   Clusters.RvcCleanMode.Enums.ModeTag.kMop]:
+                        has_vacuum_or_mop_mode_tag = True
+                        break
+
+            if not has_vacuum_or_mop_mode_tag:
+                asserts.fail("At least one ModeOptionsStruct entry must include either the "
+                             "Vacuum(0x4001) mode tag or the Mop(0x4002)mode tag in the ModeTags field")
 
         if self.check_pics("RVCCLEANM.S.A0001"):
             self.print_step(3, "Read CurrentMode attribute")
             current_mode = await self.read_mod_attribute_expect_success(endpoint=self.endpoint, attribute=attributes.CurrentMode)
 
             logging.info("CurrentMode: %s" % (current_mode))
-            asserts.assert_true(current_mode in modes, "CurrentMode is not a supported mode!")
-
-        if self.check_pics("RVCCLEANM.S.A0003"):
-            self.print_step(4, "Read OnMode attribute")
-            on_mode = await self.read_mod_attribute_expect_success(endpoint=self.endpoint, attribute=attributes.OnMode)
-
-            logging.info("OnMode: %s" % (on_mode))
-            asserts.assert_true(on_mode in modes or on_mode == NullValue, "OnMode is not a supported mode!")
-
-        if self.check_pics("RVCCLEANM.S.A0002"):
-            self.print_step(5, "Read StartUpMode attribute")
-            startup_mode = await self.read_mod_attribute_expect_success(endpoint=self.endpoint, attribute=attributes.StartUpMode)
-
-            logging.info("StartUpMode: %s" % (startup_mode))
-            asserts.assert_true(startup_mode in modes or startup_mode == NullValue, "StartUpMode is not a supported mode!")
+            asserts.assert_true(current_mode in self.supported_modes_dut, "CurrentMode is not a supported mode!")
 
 
 if __name__ == "__main__":

src/python_testing/TC_RVCCLEANM_2_2.py

@@ -0,0 +1,146 @@
+#
+#    Copyright (c) 2023 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.
+#
+
+import chip.clusters as Clusters
+from matter_testing_support import MatterBaseTest, async_test_body, default_matter_test_main, type_matches
+from mobly import asserts
+
+# This test requires several additional command line arguments
+# run with
+# --int-arg PIXIT_ENDPOINT:<endpoint> PIXIT.RVCCLEANM.MODE_CHANGE_OK:<mode id> PIXIT.RVCCLEANM.MODE_CHANGE_FAIL:<mode id>
+
+
+class TC_RVCCLEANM_2_2(MatterBaseTest):
+
+    def __init__(self, *args):
+        super().__init__(args)
+        self.endpoint = 0
+        self.supported_run_modes = {}  # these are the ModeOptionStructs
+        self.supported_run_modes_dut = []
+        self.supported_clean_modes_dut = []
+        self.run_mode_dut = 0
+        self.old_clean_mode_dut = 0
+        self.new_clean_mode_th = 0
+
+    async def read_mod_attribute_expect_success(self, cluster, attribute):
+        return await self.read_single_attribute_check_success(
+            endpoint=self.endpoint, cluster=cluster, attribute=attribute)
+
+    async def read_run_supported_modes(self) -> Clusters.Objects.RvcRunMode.Attributes.SupportedModes:
+        ret = await self.read_mod_attribute_expect_success(
+            Clusters.RvcRunMode,
+            Clusters.RvcRunMode.Attributes.SupportedModes)
+        asserts.assert_true(type_matches(ret, Clusters.Objects.RvcRunMode.Attributes.SupportedModes), "")
+        return ret
+
+    async def read_clean_supported_modes(self) -> Clusters.Objects.RvcCleanMode.Attributes.SupportedModes:
+        ret = await self.read_mod_attribute_expect_success(
+            Clusters.RvcCleanMode,
+            Clusters.RvcCleanMode.Attributes.SupportedModes)
+        asserts.assert_true(type_matches(ret, Clusters.Objects.RvcCleanMode.Attributes.SupportedModes), "")
+        return ret
+
+    async def send_change_to_mode_cmd(self, newMode) -> Clusters.Objects.RvcCleanMode.Commands.ChangeToModeResponse:
+        ret = await self.send_single_cmd(cmd=Clusters.Objects.RvcCleanMode.Commands.ChangeToMode(newMode=newMode), endpoint=self.endpoint)
+        asserts.assert_true(type_matches(ret, Clusters.Objects.RvcCleanMode.Commands.ChangeToModeResponse),
+                            "Unexpected return type for ChangeToMode")
+        return ret
+
+    # Prints the instruction and waits for a user input to continue
+    def print_instruction(self, step_number, instruction):
+        self.print_step(step_number, instruction)
+        input("Press Enter when done.\n")
+
+    @async_test_body
+    async def test_TC_RVCCLEANM_2_2(self):
+
+        asserts.assert_true('PIXIT_ENDPOINT' in self.matter_test_config.global_test_params,
+                            "PIXIT_ENDPOINT must be included on the command line in "
+                            "the --int-arg flag as PIXIT_ENDPOINT:<endpoint>")
+
+        self.endpoint = self.matter_test_config.global_test_params['PIXIT_ENDPOINT']
+
+        asserts.assert_true(self.check_pics("RVCCLEANM.S"), "RVCCLEANM.S must be supported")
+        asserts.assert_true(self.check_pics("RVCRUNM.S.A0000"), "RVCRUNM.S.A0000 must be supported")
+        asserts.assert_true(self.check_pics("RVCRUNM.S.A0001"), "RVCRUNM.S.A0001 must be supported")
+
+        self.print_step(1, "Commissioning, already done")
+
+        self.print_instruction(2, "Manually put the device in a state in which the RVC Run Mode "
+                                  "cluster’s CurrentMode attribute is set to a mode without the Idle mode tag.")
+
+        self.print_step(3, "Read the RvcRunMode SupportedModes attribute")
+        supported_run_modes = await self.read_run_supported_modes()
+        for mode in supported_run_modes:
+            self.supported_run_modes[mode.mode] = mode
+            # Save the Mode field values as supported_run_modes_dut
+            self.supported_run_modes_dut.append(mode.mode)
+
+        self.print_step(4, "Read the RvcRunMode CurrentMode attribute")
+        current_run_mode = await self.read_mod_attribute_expect_success(
+            Clusters.RvcRunMode,
+            Clusters.RvcRunMode.Attributes.CurrentMode)
+
+        # Verify that the DUT response contains an integer value
+        asserts.assert_true(type_matches(current_run_mode, Clusters.RvcRunMode.Attributes.CurrentMode),
+                            "CurrentMode must be an integer")
+
+        # Save the value as run_mode_dut
+        self.run_mode_dut = current_run_mode
+
+        # Verify that the supported_run_modes_dut entry matching run_mode_dut does not have the Idle (0x4000) mode tag.
+        for t in self.supported_run_modes[current_run_mode].modeTags:
+            if t.value == Clusters.RvcRunMode.Enums.ModeTag.kIdle:
+                asserts.fail("The device must  be is a mode with the Idle (0x4000) mode tag.")
+
+        self.print_step(5, "Read the RvcCleanMode SupportedModes attribute")
+        supported_clean_modes = await self.read_clean_supported_modes()
+        for mode in supported_clean_modes:
+            # Verify that the DUT response contains a list of ModeOptionsStruct entries
+            asserts.assert_true(type_matches(mode, Clusters.RvcCleanMode.Attributes.SupportedModes),
+                                "Supported modes must be of type ModeOptionsStruct!")
+            # Save the Mode field values as supported_run_modes_dut
+            self.supported_clean_modes_dut.append(mode.mode)
+
+        self.print_step(6, "Read the RvcCleanMode CurrentMode attribute")
+        current_clean_mode = await self.read_mod_attribute_expect_success(
+            Clusters.RvcCleanMode,
+            Clusters.RvcCleanMode.Attributes.CurrentMode)
+
+        # Verify that the DUT response contains an integer value
+        asserts.assert_true(type_matches(current_clean_mode, Clusters.RvcCleanMode.Attributes.CurrentMode),
+                            "CurrentMode must be an integer")
+
+        # Save the value as old_clean_mode_dut
+        self.old_clean_mode_dut = current_clean_mode
+
+        # Select from supported_clean_modes_dut a value which is different from old_clean_mode_dut,
+        # and save it as new_clean_mode_th
+        for mode in self.supported_clean_modes_dut:
+            if mode != self.old_clean_mode_dut:
+                self.new_clean_mode_th = mode
+                break
+
+        self.print_step(7, "Send ChangeToMode command")
+        response = await self.send_change_to_mode_cmd(self.new_clean_mode_th)
+        asserts.assert_equal(response.status, 3,
+                             "The response should contain a ChangeToModeResponse command "
+                             "with the Status set to InvalidInMode(0x03).")
+
+
+if __name__ == "__main__":
+    default_matter_test_main()