<?xml version="1.0" encoding="utf-8"?><!--
Autogenerated xml file - Version No:V_21_TE2-FALL2023
Generated date:2023-08-03 21:56:43
Cluster Name -RVC Operational State Cluster Test Plan
XML PICS -Ref Document:
version master a35005c,
Draft
2023-08-03 08:35:53 -0700
--><clusterPICS xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Generic-PICS-XML-Schema.xsd">
	<!--General cluster information-->
	<name>RVC Operational State Cluster Test Plan</name>
	<clusterId> </clusterId>
	<picsRoot> </picsRoot>
	<!--Cluster role information-->
	<usage>
		<picsItem>
			<itemNumber>RVCOPSTATE.S</itemNumber>
			<feature>Does the device implement the RVC Operational State cluster as a server?</feature>
			<reference>223.1. Role - allclusters.html[pdf]</reference>
			<status>O</status>
			<support>true</support>
		</picsItem>
	</usage>
	<!--PIXIT-->
	<pixit/>
	<!--Server side PICS-->
	<clusterSide type="Server">
		<!--Attributes PICS write-->
		<attributes>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.A0000</itemNumber>
				<feature>Does the device implement the PhaseList attribute?</feature>
				<reference>223.2.1. Attributes - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">M</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.A0001</itemNumber>
				<feature>Does the device implement the CurrentPhase attribute?</feature>
				<reference>223.2.1. Attributes - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">M</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.A0002</itemNumber>
				<feature>Does the device implement the CountdownTime attribute?</feature>
				<reference>223.2.1. Attributes - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>false</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.A0003</itemNumber>
				<feature>Does the device implement the OperationalStateList attribute?</feature>
				<reference>223.2.1. Attributes - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">M</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.A0004</itemNumber>
				<feature>Does the device implement the OperationalState attribute?</feature>
				<reference>223.2.1. Attributes - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">M</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.A0005</itemNumber>
				<feature>Does the device implement the OperationalError attribute?</feature>
				<reference>223.2.1. Attributes - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">M</status>
				<support>true</support>
			</picsItem>
		</attributes>
		<!--Events PICS write-->
		<events>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.E00</itemNumber>
				<feature>Does the device implement the OperationalError Event ?</feature>
				<reference>223.2.4. Events - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">M</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.E01</itemNumber>
				<feature>Does the device implement the OperationCompletion Event ?</feature>
				<reference>223.2.4. Events - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
		</events>
		<!--Commands generated PICS write-->
		<commandsGenerated>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.C04.Tx</itemNumber>
				<feature>Does the device implement generating the OperationalCommandResponse command?</feature>
				<reference>223.2.3. Commands generated - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S.C00.Rsp  OR  RVCOPSTATE.S.C01.Rsp  OR  RVCOPSTATE.S.C02.Rsp  OR  RVCOPSTATE.S.C03.Rsp">M</status>
				<support>true</support>
			</picsItem>
		</commandsGenerated>
		<!--Commands received PICS write-->
		<commandsReceived>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.C00.Rsp</itemNumber>
				<feature>Does the device implement receiving the Pause command?</feature>
				<reference>223.2.2. Commands received - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.C01.Rsp</itemNumber>
				<feature>Does the device implement receiving the Stop command?</feature>
				<reference>223.2.2. Commands received - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>false</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.C02.Rsp</itemNumber>
				<feature>Does the device implement receiving the Start command?</feature>
				<reference>223.2.2. Commands received - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>false</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.C03.Rsp</itemNumber>
				<feature>Does the device implement receiving the Resume command?</feature>
				<reference>223.2.2. Commands received - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
		</commandsReceived>
		<!--Features PICS write-->
		<features/>
		<!--Manual controllable PICS write-->
		<manually>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ST_STOPPED</itemNumber>
				<feature>Does the DUT support testing the Stopped(0x00) operational state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ST_RUNNING</itemNumber>
				<feature>Does the DUT support testing the Running(0x01) operational state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ST_PAUSED</itemNumber>
				<feature>Does the DUT support testing the Paused(0x02) operational state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ST_ERROR</itemNumber>
				<feature>Does the DUT support testing the Error(0x03) operational state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ST_SEEKING_CHARGER</itemNumber>
				<feature>Does the DUT support testing the SeekingCharger(0x40) operational state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ST_CHARGING</itemNumber>
				<feature>Does the DUT support testing the Charging(0x41) operational state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ST_DOCKED</itemNumber>
				<feature>Does the DUT support testing the Docked(0x42) operational state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ERR_NO_ERROR</itemNumber>
				<feature>Does the DUT support testing the NoError(0x00) error state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ERR_UNABLE_TO_START_OR_RESUME</itemNumber>
				<feature>Does the DUT support testing the UnableToStartOrResume(0x01) error state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ERR_UNABLE_TO_COMPLETE_OPERATION</itemNumber>
				<feature>Does the DUT support testing the UnableToCompleteOperation(0x02) error state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ERR_COMMAND_INVALID_IN_STATE</itemNumber>
				<feature>Does the DUT support testing the CommandInvalidInState(0x03) error state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ERR_FAILED_TO_FIND_CHARGING_DOCK</itemNumber>
				<feature>Does the DUT support testing the FailedToFindChargingDock(0x40) error state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ERR_STUCK</itemNumber>
				<feature>Does the DUT support testing the Stuck(0x41) error state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ERR_DUST_BIN_MISSING</itemNumber>
				<feature>Does the DUT support testing the DustBinMissing(0x42) error state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ERR_DUST_BIN_FULL</itemNumber>
				<feature>Does the DUT support testing the DustBinFull(0x43) error state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ERR_WATER_TANK_EMPTY</itemNumber>
				<feature>Does the DUT support testing the WaterTankEmpty(0x44) error state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ERR_WATER_TANK_MISSING</itemNumber>
				<feature>Does the DUT support testing the WaterTankMissing(0x45) error state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ERR_WATER_TANK_LID_OPEN</itemNumber>
				<feature>Does the DUT support testing the WaterTankLidOpen(0x46) error state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
			<picsItem>
				<itemNumber>RVCOPSTATE.S.M.ERR_MOP_CLEANING_PAD_MISSING</itemNumber>
				<feature>Does the DUT support testing the MopCleaningPadMissing(0x47) error state?</feature>
				<reference>223.2.5. Manual controllable - allclusters.html[pdf]</reference>
				<status cond="RVCOPSTATE.S">O</status>
				<support>true</support>
			</picsItem>
		</manually>
	</clusterSide>
	<!--Client side PICS-->
	<clusterSide type="Client">
		<!--Attributes PICS write-->
		<attributes/>
		<!--Events PICS write-->
		<events/>
		<!--Commands generated PICS write-->
		<commandsGenerated/>
		<!--Commands received PICS write-->
		<commandsReceived/>
		<!--Features PICS write-->
		<features/>
		<!--Manual controllable PICS write-->
		<manually/>
	</clusterSide>
</clusterPICS>