| # |
| # Copyright (c) 2024 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 time import sleep |
| |
| import chip.clusters as Clusters |
| from matter_testing_support import MatterBaseTest, async_test_body, default_matter_test_main |
| from mobly import asserts |
| |
| # This test requires several additional command line arguments. |
| # Run the test with |
| # --int-arg PIXIT.RVCRUNM.MODE_A:<mode id> PIXIT.RVCRUNM.MODE_B:<mode id> |
| |
| |
| def error_enum_to_text(error_enum): |
| try: |
| return f'{Clusters.RvcRunMode.Enums.ModeTag(error_enum).name} 0x{error_enum:02x}' |
| except AttributeError: |
| if error_enum == 0: |
| return "Success(0x00)" |
| elif error_enum == 0x1: |
| return "UnsupportedMode(0x01)" |
| elif error_enum == 0x2: |
| return "GenericFailure(0x02)" |
| elif error_enum == 0x3: |
| return "InvalidInMode(0x03)" |
| |
| raise AttributeError("Unknown Enum value") |
| |
| |
| class TC_RVCRUNM_2_2(MatterBaseTest): |
| |
| def __init__(self, *args): |
| super().__init__(*args) |
| self.endpoint = 0 |
| self.mode_a = 0 |
| self.mode_b = 0 |
| self.supported_run_modes = {} # these are the ModeOptionStructs |
| self.supported_run_modes_dut = [] |
| self.idle_mode_dut = 0 |
| self.is_ci = False |
| self.app_pipe = "/tmp/chip_rvc_fifo_" |
| |
| 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) |
| return ret |
| |
| async def read_current_mode_with_check(self, expected_mode): |
| run_mode = await self.read_mod_attribute_expect_success( |
| Clusters.RvcRunMode, |
| Clusters.RvcRunMode.Attributes.CurrentMode) |
| asserts.assert_true(run_mode == expected_mode, |
| "Expected the current mode to be %i, got %i" % (expected_mode, run_mode)) |
| |
| async def send_change_to_mode_cmd(self, new_mode) -> Clusters.Objects.RvcRunMode.Commands.ChangeToModeResponse: |
| ret = await self.send_single_cmd(cmd=Clusters.Objects.RvcRunMode.Commands.ChangeToMode(newMode=new_mode), |
| endpoint=self.endpoint) |
| return ret |
| |
| async def send_change_to_mode_with_check(self, new_mode, expected_error): |
| response = await self.send_change_to_mode_cmd(new_mode) |
| asserts.assert_true(response.status == expected_error, |
| "Expected a ChangeToMode response status of %s, got %s" % |
| (error_enum_to_text(expected_error), error_enum_to_text(response.status))) |
| |
| async def read_op_state_operational_state(self) -> Clusters.Objects.RvcOperationalState.Attributes.OperationalState: |
| ret = await self.read_mod_attribute_expect_success( |
| Clusters.RvcOperationalState, |
| Clusters.RvcOperationalState.Attributes.OperationalState) |
| return ret |
| |
| # Sends and out-of-band command to the rvc-app |
| def write_to_app_pipe(self, command): |
| with open(self.app_pipe, "w") as app_pipe: |
| app_pipe.write(command + "\n") |
| # Delay for pipe command to be processed (otherwise tests are flaky) |
| # TODO(#31239): centralize pipe write logic and remove the need of sleep |
| sleep(0.001) |
| |
| def pics_TC_RVCRUNM_2_2(self) -> list[str]: |
| return ["RVCRUNM.S"] |
| |
| @async_test_body |
| async def test_TC_RVCRUNM_2_2(self): |
| |
| if 'PIXIT.RVCRUNM.MODE_A' not in self.matter_test_config.global_test_params or \ |
| 'PIXIT.RVCRUNM.MODE_B' not in self.matter_test_config.global_test_params: |
| asserts.fail("There are missing arguments to the `--int-arg` flag! " |
| "Make sure that all of these arguments are given to this flag: \n" |
| "PIXIT.RVCRUNM.MODE_A:<mode id> \n" |
| "PIXIT.RVCRUNM.MODE_B:<mode id>") |
| |
| self.endpoint = self.matter_test_config.endpoint |
| self.is_ci = self.check_pics("PICS_SDK_CI_ONLY") |
| self.mode_a = self.matter_test_config.global_test_params['PIXIT.RVCRUNM.MODE_A'] |
| self.mode_b = self.matter_test_config.global_test_params['PIXIT.RVCRUNM.MODE_B'] |
| if self.is_ci: |
| app_pid = self.matter_test_config.app_pid |
| if app_pid == 0: |
| asserts.fail("The --app-pid flag must be set when PICS_SDK_CI_ONLY is set.c") |
| self.app_pipe = self.app_pipe + str(app_pid) |
| |
| asserts.assert_true(self.check_pics("RVCRUNM.S"), "RVCRUNM.S must be supported") |
| # I think that the following PICS should be listed in the preconditions section in the test plan as if either |
| # of these PICS is not supported, this test would not be useful. |
| 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") |
| asserts.assert_true(self.check_pics("RVCRUNM.S.C00.Rsp"), "RVCRUNM.S.C00.Rsp must be supported") |
| asserts.assert_true(self.check_pics("RVCRUNM.S.M.CAN_MANUALLY_CONTROLLED"), |
| "RVCRUNM.S.M.CAN_MANUALLY_CONTROLLED must be supported") |
| |
| # Starting the test steps |
| self.print_step(1, "Commissioning, already done") |
| |
| # Ensure that the device is in the correct state |
| if self.is_ci: |
| self.write_to_app_pipe('{"Name": "Reset"}') |
| |
| self.print_step(2, "Manually put the device in a RVC Run Mode cluster mode with " |
| "the Idle(0x4000) mode tag and in a device state that allows changing to either " |
| "of these modes: %i, %i" % (self.mode_a, self.mode_b)) |
| if not self.is_ci: |
| input("Press Enter when done.\n") |
| |
| 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) |
| |
| asserts.assert_false(self.mode_a == self.mode_b, |
| "PIXIT.RVCRUNM.MODE_A must be different from PIXIT.RVCRUNM.MODE_B") |
| |
| if self.mode_a not in self.supported_run_modes_dut or \ |
| self.mode_b not in self.supported_run_modes_dut: |
| asserts.fail("PIXIT.RVCRUNM.MODE_A and PIXIT.RVCRUNM.MODE_B must be valid supported modes.") |
| |
| for tag in self.supported_run_modes[self.mode_a].modeTags: |
| if tag.value == Clusters.RvcRunMode.Enums.ModeTag.kIdle: |
| asserts.fail("The mode chosen for PIXIT.RVCRUNM.MODE_A must not have the Idle(0x4000) mode tag.") |
| |
| for tag in self.supported_run_modes[self.mode_b].modeTags: |
| if tag.value == Clusters.RvcRunMode.Enums.ModeTag.kIdle: |
| asserts.fail("The mode chosen for PIXIT.RVCRUNM.MODE_B must not have the Idle(0x4000) mode tag.") |
| |
| 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) |
| |
| # Save the value as idle_mode_dut |
| self.idle_mode_dut = current_run_mode |
| |
| # Verify that the supported_run_modes_dut entry matching idle_mode_dut has the Idle (0x4000) mode tag. |
| idle_tag_present = False |
| for t in self.supported_run_modes[current_run_mode].modeTags: |
| if t.value == Clusters.RvcRunMode.Enums.ModeTag.kIdle: |
| idle_tag_present = True |
| asserts.assert_true(idle_tag_present, "The device must be in a mode with the Idle (0x4000) mode tag.") |
| |
| self.print_step(5, "Send ChangeToMode MODE_A command") |
| await self.send_change_to_mode_with_check(self.mode_a, 0) |
| # This step is not described in the test plan, but it ought to be |
| await self.read_current_mode_with_check(self.mode_a) |
| |
| self.print_step(6, "Send ChangeToMode MODE_B command") |
| await self.send_change_to_mode_with_check(self.mode_b, 3) |
| |
| self.print_step(7, "Send ChangeToMode idle command") |
| await self.send_change_to_mode_with_check(self.idle_mode_dut, 0) |
| # This step is not described in the test plan, but it ought to be |
| await self.read_current_mode_with_check(self.idle_mode_dut) |
| |
| self.print_step(8, "Read RVCOPSTATE's OperationalState attribute") |
| op_state = await self.read_op_state_operational_state() |
| |
| valid_op_states = [ |
| Clusters.OperationalState.Enums.OperationalStateEnum.kStopped, |
| Clusters.OperationalState.Enums.OperationalStateEnum.kPaused, |
| Clusters.RvcOperationalState.Enums.OperationalStateEnum.kCharging, |
| Clusters.RvcOperationalState.Enums.OperationalStateEnum.kDocked] |
| |
| if op_state not in valid_op_states: |
| self.print_step(9, "Manually put the device in one of Stopped(0x00), Paused(0x02), Charging(0x41) or Docked(0x42)") |
| if self.is_ci: |
| self.write_to_app_pipe('{"Name": "ChargerFound"}') |
| else: |
| input("Press Enter when done.\n") |
| |
| self.print_step(10, "Read RVCOPSTATE's OperationalState attribute") |
| op_state = await self.read_op_state_operational_state() |
| |
| asserts.assert_true(op_state in valid_op_states, |
| "Expected RVCOPSTATE's OperationalState attribute to be one of Stopped(0x00), Paused(0x02), Charging(0x41) or Docked(0x42)") |
| |
| self.print_step(11, "Send ChangeToMode MODE_B command") |
| await self.send_change_to_mode_with_check(self.mode_b, 0) |
| # This step is not described in the test plan, but it ought to be |
| await self.read_current_mode_with_check(self.mode_b) |
| |
| self.print_step(12, "Send ChangeToMode idle command") |
| await self.send_change_to_mode_with_check(self.idle_mode_dut, 0) |
| # This step is not described in the test plan, but it ought to be |
| await self.read_current_mode_with_check(self.idle_mode_dut) |
| |
| |
| if __name__ == "__main__": |
| default_matter_test_main() |
