Google Git
Sign in
pigweed / third_party / github / project-chip / connectedhomeip / ad5253ace34269d07ca8afbd984aec319903ac56 / . / zzz_generated / placeholder / app1 / zap-generated / test / Commands.h
blob: 39a1b1b91f1eaad6f0fb10cea366dc9fe450802e [file] [log] [blame]
/*
*
* Copyright (c) 2022 Project CHIP Authors
*
* 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.
*/
// THIS FILE IS GENERATED BY ZAP
#pragma once
#include "TestCommand.h"
#include <lib/support/CHIPListUtils.h>
class Test_TC_BINFO_2_3_SimulatedSuite : public TestCommand
{
public:
Test_TC_BINFO_2_3_SimulatedSuite() : TestCommand("Test_TC_BINFO_2_3_Simulated", 21)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_BINFO_2_3_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 0:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Log OnOff Test Startup");
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::Log::Type value;
value.message = chip::Span<const char>("*** Basic Cluster Tests Readygarbage: not in length on purpose", 29);
return Log(kIdentityAlpha, value);
}
case 1: {
LogStep(1, "DUT reads DataModelRevision from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A0000"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::DataModelRevision::Id);
}
case 2: {
LogStep(2, "DUT reads VendorName from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A0001"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::VendorName::Id);
}
case 3: {
LogStep(3, "DUT reads VendorID from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A0002"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::VendorID::Id);
}
case 4: {
LogStep(4, "DUT reads ProductName from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A0003"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::ProductName::Id);
}
case 5: {
LogStep(5, "DUT reads ProductID from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A0004"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::ProductID::Id);
}
case 6: {
LogStep(6, "DUT reads NodeLabel from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A0005"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::NodeLabel::Id);
}
case 7: {
LogStep(7, "DUT reads Location from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A0006"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::Location::Id);
}
case 8: {
LogStep(8, "DUT reads HardwareVersion from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A0007"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::HardwareVersion::Id);
}
case 9: {
LogStep(9, "DUT reads HardwareVersionString from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A0008"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::HardwareVersionString::Id);
}
case 10: {
LogStep(10, "DUT reads SoftwareVersion from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A0009"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::SoftwareVersion::Id);
}
case 11: {
LogStep(11, "DUT reads SoftwareVersionString from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A000a"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::SoftwareVersionString::Id);
}
case 12: {
LogStep(12, "DUT reads ManufacturingDate from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A000b"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::ManufacturingDate::Id);
}
case 13: {
LogStep(13, "DUT reads PartNumber from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A000c"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::PartNumber::Id);
}
case 14: {
LogStep(14, "DUT reads ProductURL from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A000d"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::ProductURL::Id);
}
case 15: {
LogStep(15, "DUT reads ProductLabel from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A000e"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::ProductLabel::Id);
}
case 16: {
LogStep(16, "DUT reads SerialNumber from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A000f"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::SerialNumber::Id);
}
case 17: {
LogStep(17, "DUT reads LocalConfigDisabled from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A0010"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::LocalConfigDisabled::Id);
}
case 18: {
LogStep(18, "DUT reads Reachable from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A0011"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::Reachable::Id);
}
case 19: {
LogStep(19, "DUT reads UniqueID from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A0012"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::UniqueID::Id);
}
case 20: {
LogStep(20, "DUT reads CapabilityMinima from the TH");
VerifyOrDo(!ShouldSkip("BINFO.C.A0013"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BasicInformation::Id, BasicInformation::Attributes::CapabilityMinima::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_ACT_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_ACT_3_1_SimulatedSuite() : TestCommand("Test_TC_ACT_3_1_Simulated", 6)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_ACT_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 3:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 4:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 5:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Read attribute: ActionList");
VerifyOrDo(!ShouldSkip("ACT.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), Actions::Id, Actions::Attributes::ActionList::Id);
}
case 1: {
LogStep(1, "Read attribute: EndpointLists");
VerifyOrDo(!ShouldSkip("ACT.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), Actions::Id, Actions::Attributes::EndpointLists::Id);
}
case 2: {
LogStep(2, "Read attribute: SetupURL");
VerifyOrDo(!ShouldSkip("ACT.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), Actions::Id, Actions::Attributes::SetupURL::Id);
}
case 3: {
LogStep(3,
"Configure TH such that it implements mandatory and none of the optional attributes of the server-side of the "
"cluster, and that it also reflects this in global attributes such as FeatureMap and AttributeList.Commission "
"DUT to TH again");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 4: {
LogStep(4, "DUT reads all supported optional attributes from TH one at a time in a manufacturer specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && ACT.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 5: {
LogStep(5,
"DUT writes a suitable value to all supported optional attributes on the TH one at a time in a manufacturer "
"specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && ACT.C.AO-WRITE"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_BOOL_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_BOOL_3_1_SimulatedSuite() : TestCommand("Test_TC_BOOL_3_1_Simulated", 4)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_BOOL_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 1:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 2:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 3:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Read attribute: StateValue");
VerifyOrDo(!ShouldSkip("BOOL.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), BooleanState::Id, BooleanState::Attributes::StateValue::Id);
}
case 1: {
LogStep(1,
"Configure TH such that it implements mandatory and none of the optional attributes of the server-side of the "
"cluster, and that it also reflects this in global attributes such as FeatureMap and AttributeList.Commission "
"DUT to TH again");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 2: {
LogStep(2, "DUT reads all supported optional attributes from TH one at a time in a manufacturer specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 3: {
LogStep(3,
"DUT writes a suitable value to all supported optional attributes on the TH one at a time in a manufacturer "
"specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_DESC_2_2_SimulatedSuite : public TestCommand
{
public:
Test_TC_DESC_2_2_SimulatedSuite() : TestCommand("Test_TC_DESC_2_2_Simulated", 4)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_DESC_2_2_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "DUT reads DeviceTypeList from TH.");
VerifyOrDo(!ShouldSkip("DESC.C.A0000"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), Descriptor::Id, Descriptor::Attributes::DeviceTypeList::Id);
}
case 1: {
LogStep(1, "DUT reads ServerList from the TH");
VerifyOrDo(!ShouldSkip("DESC.C.A0001"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), Descriptor::Id, Descriptor::Attributes::ServerList::Id);
}
case 2: {
LogStep(2, "DUT reads ClientList attribute from the TH");
VerifyOrDo(!ShouldSkip("DESC.C.A0002"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), Descriptor::Id, Descriptor::Attributes::ClientList::Id);
}
case 3: {
LogStep(3, "DUT reads PartsList attribute from the TH");
VerifyOrDo(!ShouldSkip("DESC.C.A0003"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), Descriptor::Id, Descriptor::Attributes::PartsList::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_DGETH_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_DGETH_3_1_SimulatedSuite() : TestCommand("Test_TC_DGETH_3_1_Simulated", 9)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_DGETH_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Read attribute: PHYRate");
VerifyOrDo(!ShouldSkip("DGETH.C.A0000"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), EthernetNetworkDiagnostics::Id,
EthernetNetworkDiagnostics::Attributes::PHYRate::Id);
}
case 1: {
LogStep(1, "Read attribute: FullDuplex");
VerifyOrDo(!ShouldSkip("DGETH.C.A0001"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), EthernetNetworkDiagnostics::Id,
EthernetNetworkDiagnostics::Attributes::FullDuplex::Id);
}
case 2: {
LogStep(2, "Read attribute: PacketRxCount");
VerifyOrDo(!ShouldSkip("DGETH.C.A0002"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), EthernetNetworkDiagnostics::Id,
EthernetNetworkDiagnostics::Attributes::PacketRxCount::Id);
}
case 3: {
LogStep(3, "Read attribute: PacketTxCount");
VerifyOrDo(!ShouldSkip("DGETH.C.A0003"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), EthernetNetworkDiagnostics::Id,
EthernetNetworkDiagnostics::Attributes::PacketTxCount::Id);
}
case 4: {
LogStep(4, "Read attribute: TxErrCount");
VerifyOrDo(!ShouldSkip("DGETH.C.A0004"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), EthernetNetworkDiagnostics::Id,
EthernetNetworkDiagnostics::Attributes::TxErrCount::Id);
}
case 5: {
LogStep(5, "Read attribute: CollisionCount");
VerifyOrDo(!ShouldSkip("DGETH.C.A0005"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), EthernetNetworkDiagnostics::Id,
EthernetNetworkDiagnostics::Attributes::CollisionCount::Id);
}
case 6: {
LogStep(6, "Read attribute: OverrunCount");
VerifyOrDo(!ShouldSkip("DGETH.C.A0006"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), EthernetNetworkDiagnostics::Id,
EthernetNetworkDiagnostics::Attributes::OverrunCount::Id);
}
case 7: {
LogStep(7, "Read attribute: CarrierDetect");
VerifyOrDo(!ShouldSkip("DGETH.C.A0007"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), EthernetNetworkDiagnostics::Id,
EthernetNetworkDiagnostics::Attributes::CarrierDetect::Id);
}
case 8: {
LogStep(8, "Read attribute: TimeSinceReset");
VerifyOrDo(!ShouldSkip("DGETH.C.A0008"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), EthernetNetworkDiagnostics::Id,
EthernetNetworkDiagnostics::Attributes::TimeSinceReset::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_DGSW_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_DGSW_3_1_SimulatedSuite() : TestCommand("Test_TC_DGSW_3_1_Simulated", 4)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_DGSW_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Read attribute: ThreadMetrics");
VerifyOrDo(!ShouldSkip("DGSW.C.A0000"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), SoftwareDiagnostics::Id, SoftwareDiagnostics::Attributes::ThreadMetrics::Id);
}
case 1: {
LogStep(1, "Read attribute: CurrentHeapFree");
VerifyOrDo(!ShouldSkip("DGSW.C.A0001"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), SoftwareDiagnostics::Id, SoftwareDiagnostics::Attributes::CurrentHeapFree::Id);
}
case 2: {
LogStep(2, "Read attribute: CurrentHeapUsed");
VerifyOrDo(!ShouldSkip("DGSW.C.A0002"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), SoftwareDiagnostics::Id, SoftwareDiagnostics::Attributes::CurrentHeapUsed::Id);
}
case 3: {
LogStep(3, "Read attribute: CurrentHeapHighWatermark");
VerifyOrDo(!ShouldSkip("DGSW.C.A0003"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), SoftwareDiagnostics::Id,
SoftwareDiagnostics::Attributes::CurrentHeapHighWatermark::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_DGWIFI_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_DGWIFI_3_1_SimulatedSuite() : TestCommand("Test_TC_DGWIFI_3_1_Simulated", 13)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_DGWIFI_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Read attribute: BSSID");
VerifyOrDo(!ShouldSkip("DGWIFI.C.A0000"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), WiFiNetworkDiagnostics::Id, WiFiNetworkDiagnostics::Attributes::Bssid::Id);
}
case 1: {
LogStep(1, "Read attribute: SecurityType");
VerifyOrDo(!ShouldSkip("DGWIFI.C.A0001"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), WiFiNetworkDiagnostics::Id, WiFiNetworkDiagnostics::Attributes::SecurityType::Id);
}
case 2: {
LogStep(2, "Read attribute: WiFiVersion");
VerifyOrDo(!ShouldSkip("DGWIFI.C.A0002"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), WiFiNetworkDiagnostics::Id, WiFiNetworkDiagnostics::Attributes::WiFiVersion::Id);
}
case 3: {
LogStep(3, "Read attribute: ChannelNumber");
VerifyOrDo(!ShouldSkip("DGWIFI.C.A0003"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), WiFiNetworkDiagnostics::Id, WiFiNetworkDiagnostics::Attributes::ChannelNumber::Id);
}
case 4: {
LogStep(4, "Read attribute: RSSI");
VerifyOrDo(!ShouldSkip("DGWIFI.C.A0004"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), WiFiNetworkDiagnostics::Id, WiFiNetworkDiagnostics::Attributes::Rssi::Id);
}
case 5: {
LogStep(5, "Read attribute: BeaconLostCount");
VerifyOrDo(!ShouldSkip("DGWIFI.C.A0005"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), WiFiNetworkDiagnostics::Id,
WiFiNetworkDiagnostics::Attributes::BeaconLostCount::Id);
}
case 6: {
LogStep(6, "Read attribute: BeaconRxCount");
VerifyOrDo(!ShouldSkip("DGWIFI.C.A0006"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), WiFiNetworkDiagnostics::Id, WiFiNetworkDiagnostics::Attributes::BeaconRxCount::Id);
}
case 7: {
LogStep(7, "Read attribute: PacketMulticastRxCount");
VerifyOrDo(!ShouldSkip("DGWIFI.C.A0007"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), WiFiNetworkDiagnostics::Id,
WiFiNetworkDiagnostics::Attributes::PacketMulticastRxCount::Id);
}
case 8: {
LogStep(8, "Read attribute: PacketMulticastTxCount");
VerifyOrDo(!ShouldSkip("DGWIFI.C.A0008"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), WiFiNetworkDiagnostics::Id,
WiFiNetworkDiagnostics::Attributes::PacketMulticastTxCount::Id);
}
case 9: {
LogStep(9, "Read attribute: PacketUnicastRxCount");
VerifyOrDo(!ShouldSkip("DGWIFI.C.A0009"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), WiFiNetworkDiagnostics::Id,
WiFiNetworkDiagnostics::Attributes::PacketUnicastRxCount::Id);
}
case 10: {
LogStep(10, "Read attribute: PacketUnicastTxCount");
VerifyOrDo(!ShouldSkip("DGWIFI.C.A000a"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), WiFiNetworkDiagnostics::Id,
WiFiNetworkDiagnostics::Attributes::PacketUnicastTxCount::Id);
}
case 11: {
LogStep(11, "Read attribute: CurrentMaxRate");
VerifyOrDo(!ShouldSkip("DGWIFI.C.A000b"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), WiFiNetworkDiagnostics::Id,
WiFiNetworkDiagnostics::Attributes::CurrentMaxRate::Id);
}
case 12: {
LogStep(12, "Read attribute: OverrunCount");
VerifyOrDo(!ShouldSkip("DGWIFI.C.A000c"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), WiFiNetworkDiagnostics::Id, WiFiNetworkDiagnostics::Attributes::OverrunCount::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_FLW_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_FLW_3_1_SimulatedSuite() : TestCommand("Test_TC_FLW_3_1_Simulated", 7)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_FLW_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 4:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 5:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 6:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Read attribute: MeasuredValue");
VerifyOrDo(!ShouldSkip("FLW.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), FlowMeasurement::Id, FlowMeasurement::Attributes::MeasuredValue::Id);
}
case 1: {
LogStep(1, "Read attribute: MinMeasuredValue");
VerifyOrDo(!ShouldSkip("FLW.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), FlowMeasurement::Id, FlowMeasurement::Attributes::MinMeasuredValue::Id);
}
case 2: {
LogStep(2, "Read attribute: MaxMeasuredValue");
VerifyOrDo(!ShouldSkip("FLW.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), FlowMeasurement::Id, FlowMeasurement::Attributes::MaxMeasuredValue::Id);
}
case 3: {
LogStep(3, "Read attribute: Tolerance");
VerifyOrDo(!ShouldSkip("FLW.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), FlowMeasurement::Id, FlowMeasurement::Attributes::Tolerance::Id);
}
case 4: {
LogStep(4,
"Configure TH such that it implements mandatory and none of the optional attributes of the server-side of the "
"cluster, and that it also reflects this in global attributes such as FeatureMap and AttributeList. Commission "
"DUT to TH again.");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 5: {
LogStep(5, "DUT reads all supported optional attributes from TH one at a time in a manufacturer specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && FLW.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 6: {
LogStep(6,
"DUT writes a suitable value to all supported optional attributes on the TH one at a time in a manufacturer "
"specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_G_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_G_3_1_SimulatedSuite() : TestCommand("Test_TC_G_3_1_Simulated", 1)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_G_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "DUT reads NameSupport attribute value from TH");
VerifyOrDo(!ShouldSkip("G.C.A0000"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), Groups::Id, Groups::Attributes::NameSupport::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_I_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_I_3_1_SimulatedSuite() : TestCommand("Test_TC_I_3_1_Simulated", 7)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_I_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 4:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 5:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 6:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Read attribute: IdentifyTime");
VerifyOrDo(!ShouldSkip("I.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), Identify::Id, Identify::Attributes::IdentifyTime::Id);
}
case 1: {
LogStep(1, "Read attribute: identifytype");
VerifyOrDo(!ShouldSkip("I.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), Identify::Id, Identify::Attributes::IdentifyType::Id);
}
case 2: {
LogStep(2, "write attribute: IdentifyTime");
VerifyOrDo(!ShouldSkip("I.C.AM-WRITE"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), Identify::Id, Identify::Attributes::IdentifyTime::Id);
}
case 3: {
LogStep(3, "Readback attribute: IdentifyTime");
VerifyOrDo(!ShouldSkip("I.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), Identify::Id, Identify::Attributes::IdentifyTime::Id);
}
case 4: {
LogStep(4,
"Configure TH such that it implements mandatory and none of the optional attributes of the server-side of the "
"cluster, and that it also reflects this in global attributes such as FeatureMap and AttributeList.Commission "
"DUT to TH again");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 5: {
LogStep(5, "DUT reads all supported optional attributes from TH one at a time in a manufacturer specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 6: {
LogStep(6,
"DUT writes a suitable value to all supported optional attributes on the TH one at a time in a manufacturer "
"specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_PRS_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_PRS_3_1_SimulatedSuite() : TestCommand("Test_TC_PRS_3_1_Simulated", 12)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_PRS_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 9:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 10:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 11:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Read attribute: MeasuredValue");
VerifyOrDo(!ShouldSkip("PRS.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PressureMeasurement::Id, PressureMeasurement::Attributes::MeasuredValue::Id);
}
case 1: {
LogStep(1, "Read attribute: MinMeasuredValue");
VerifyOrDo(!ShouldSkip("PRS.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PressureMeasurement::Id, PressureMeasurement::Attributes::MinMeasuredValue::Id);
}
case 2: {
LogStep(2, "Read attribute: MaxMeasuredValue");
VerifyOrDo(!ShouldSkip("PRS.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PressureMeasurement::Id, PressureMeasurement::Attributes::MaxMeasuredValue::Id);
}
case 3: {
LogStep(3, "Read attribute: Tolerance");
VerifyOrDo(!ShouldSkip("PRS.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PressureMeasurement::Id, PressureMeasurement::Attributes::Tolerance::Id);
}
case 4: {
LogStep(4, "Read attribute: ScaledValue");
VerifyOrDo(!ShouldSkip("PRS.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PressureMeasurement::Id, PressureMeasurement::Attributes::ScaledValue::Id);
}
case 5: {
LogStep(5, "Read attribute: MinScaledValue");
VerifyOrDo(!ShouldSkip("PRS.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PressureMeasurement::Id, PressureMeasurement::Attributes::MinScaledValue::Id);
}
case 6: {
LogStep(6, "Read attribute: MaxScaledValue");
VerifyOrDo(!ShouldSkip("PRS.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PressureMeasurement::Id, PressureMeasurement::Attributes::MaxScaledValue::Id);
}
case 7: {
LogStep(7, "Read attribute: ScaledTolerance");
VerifyOrDo(!ShouldSkip("PRS.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PressureMeasurement::Id, PressureMeasurement::Attributes::ScaledTolerance::Id);
}
case 8: {
LogStep(8, "Read attribute: Scale");
VerifyOrDo(!ShouldSkip("PRS.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PressureMeasurement::Id, PressureMeasurement::Attributes::Scale::Id);
}
case 9: {
LogStep(9,
"Configure TH such that it implements mandatory and none of the optional attributes of the server-side of the "
"cluster, and that it also reflects this in global attributes such as FeatureMap and AttributeList.Commission "
"DUT to TH again.");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 10: {
LogStep(10, "DUT reads all supported optional attributes from TH one at a time in a manufacturer specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && PRS.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 11: {
LogStep(11,
"DUT writes a suitable value to all supported optional attributes on the TH one at a time in a manufacturer "
"specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_PS_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_PS_3_1_SimulatedSuite() : TestCommand("Test_TC_PS_3_1_Simulated", 34)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_PS_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 31:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 32:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 33:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Read attribute: Status");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::Status::Id);
}
case 1: {
LogStep(1, "Read attribute: Order");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::Order::Id);
}
case 2: {
LogStep(2, "Read attribute: Description");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::Description::Id);
}
case 3: {
LogStep(3, "Read attribute: WiredAssessedInputVoltage");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::WiredAssessedInputVoltage::Id);
}
case 4: {
LogStep(4, "Read attribute: WiredAssessedInputFrequency");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::WiredAssessedInputFrequency::Id);
}
case 5: {
LogStep(5, "Read attribute: WiredCurrentType");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::WiredCurrentType::Id);
}
case 6: {
LogStep(6, "Read attribute: WiredAssessedCurrent");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::WiredAssessedCurrent::Id);
}
case 7: {
LogStep(7, "Read attribute: WiredNominalVoltage");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::WiredNominalVoltage::Id);
}
case 8: {
LogStep(8, "Read attribute: WiredPresent");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::WiredPresent::Id);
}
case 9: {
LogStep(9, "Read attribute: WiredMaximumCurrent");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::WiredMaximumCurrent::Id);
}
case 10: {
LogStep(10, "Read attribute: ActiveWiredFaults");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::ActiveWiredFaults::Id);
}
case 11: {
LogStep(11, "Read attribute: BatVoltage");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::BatVoltage::Id);
}
case 12: {
LogStep(12, "Read attribute: BatPercentRemaining");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::BatPercentRemaining::Id);
}
case 13: {
LogStep(13, "Read attribute: BatTimeRemaining");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::BatTimeRemaining::Id);
}
case 14: {
LogStep(14, "Read attribute: BatChargeLevel");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::BatChargeLevel::Id);
}
case 15: {
LogStep(15, "Read attribute: BatReplacementNeeded");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::BatReplacementNeeded::Id);
}
case 16: {
LogStep(16, "Read attribute: BatReplaceability");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::BatReplaceability::Id);
}
case 17: {
LogStep(17, "Read attribute: BatPresent");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::BatPresent::Id);
}
case 18: {
LogStep(18, "Read attribute: ActiveBatFaults");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::ActiveBatFaults::Id);
}
case 19: {
LogStep(19, "Read attribute: BatReplacementDescription");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::BatReplacementDescription::Id);
}
case 20: {
LogStep(20, "Read attribute: BatCommonDesignation");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::BatCommonDesignation::Id);
}
case 21: {
LogStep(21, "Read attribute: BatANSIDesignation");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::BatANSIDesignation::Id);
}
case 22: {
LogStep(22, "Read attribute: BatIECDesignation");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::BatIECDesignation::Id);
}
case 23: {
LogStep(23, "Read attribute: BatApprovedChemistry");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::BatApprovedChemistry::Id);
}
case 24: {
LogStep(24, "Read attribute: BatCapacity");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::BatCapacity::Id);
}
case 25: {
LogStep(25, "Read attribute: BatQuantity");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::BatQuantity::Id);
}
case 26: {
LogStep(26, "Read attribute: BatChargeState");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::BatChargeState::Id);
}
case 27: {
LogStep(27, "Read attribute: BatTimeToFullCharge");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::BatTimeToFullCharge::Id);
}
case 28: {
LogStep(28, "Read attribute: BatFunctionalWhileCharging");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::BatFunctionalWhileCharging::Id);
}
case 29: {
LogStep(29, "Read attribute: BatChargingCurrent");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::BatChargingCurrent::Id);
}
case 30: {
LogStep(30, "Read attribute: ActiveBatChargeFaults");
return WaitAttribute(GetEndpoint(0), PowerSource::Id, PowerSource::Attributes::ActiveBatChargeFaults::Id);
}
case 31: {
LogStep(31,
"Configure TH such that it implements mandatory and none of the optional attributes of the server-side of the "
"cluster, and that it also reflects this in global attributes such as FeatureMap and AttributeList. Commission "
"DUT to TH again");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 32: {
LogStep(32, "DUT reads all supported optional attributes from TH one at a time in a manufacturer specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && PS.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 33: {
LogStep(33,
"DUT writes a suitable value to all supported optional attributes on the TH one at a time in a manufacturer "
"specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && PS.C.AO-WRITE"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_PSCFG_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_PSCFG_3_1_SimulatedSuite() : TestCommand("Test_TC_PSCFG_3_1_Simulated", 4)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_PSCFG_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 1:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 2:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 3:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Read attribute: Sources");
VerifyOrDo(!ShouldSkip("PSCFG.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PowerSourceConfiguration::Id, PowerSourceConfiguration::Attributes::Sources::Id);
}
case 1: {
LogStep(1,
"Configure TH such that it implements mandatory and none of the optional attributes of the server-side of the "
"cluster, and that it also reflects this in global attributes such as FeatureMap and AttributeList. Commission "
"DUT to TH again.");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 2: {
LogStep(2, "DUT reads all supported optional attributes from TH one at a time in a manufacturer specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 3: {
LogStep(3,
"DUT writes a suitable value to all supported optional attributes on the TH one at a time in a manufacturer "
"specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_RH_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_RH_3_1_SimulatedSuite() : TestCommand("Test_TC_RH_3_1_Simulated", 7)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_RH_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 4:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 5:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 6:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Read attribute MeasuredValue");
return WaitAttribute(GetEndpoint(0), RelativeHumidityMeasurement::Id,
RelativeHumidityMeasurement::Attributes::MeasuredValue::Id);
}
case 1: {
LogStep(1, "Read attribute MinMeasuredValue");
return WaitAttribute(GetEndpoint(0), RelativeHumidityMeasurement::Id,
RelativeHumidityMeasurement::Attributes::MinMeasuredValue::Id);
}
case 2: {
LogStep(2, "Read attribute MaxMeasuredValue");
return WaitAttribute(GetEndpoint(0), RelativeHumidityMeasurement::Id,
RelativeHumidityMeasurement::Attributes::MaxMeasuredValue::Id);
}
case 3: {
LogStep(3, "Read attribute Tolerance");
return WaitAttribute(GetEndpoint(0), RelativeHumidityMeasurement::Id,
RelativeHumidityMeasurement::Attributes::Tolerance::Id);
}
case 4: {
LogStep(4,
"Configure TH such that it implements mandatory and none of the optional attributes of the server-side of the "
"cluster, and that it also reflects this in global attributes such as FeatureMap and AttributeList.Commission "
"DUT to TH again");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 5: {
LogStep(5, "DUT reads all supported optional attributes from TH one at a time in a manufacturer specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 6: {
LogStep(6,
"DUT writes a suitable value to all supported optional attributes on the TH one at a time in a manufacturer "
"specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_SWTCH_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_SWTCH_3_1_SimulatedSuite() : TestCommand("Test_TC_SWTCH_3_1_Simulated", 6)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_SWTCH_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 3:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 4:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 5:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Read NumberOfPositions attribute");
VerifyOrDo(!ShouldSkip("SWTCH.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), Switch::Id, Switch::Attributes::NumberOfPositions::Id);
}
case 1: {
LogStep(1, "Read CurrentPosition attribute");
VerifyOrDo(!ShouldSkip("SWTCH.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), Switch::Id, Switch::Attributes::CurrentPosition::Id);
}
case 2: {
LogStep(2, "Read MultiPressMax attribute");
VerifyOrDo(!ShouldSkip("SWTCH.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), Switch::Id, Switch::Attributes::MultiPressMax::Id);
}
case 3: {
LogStep(3,
"Configure TH such that it implements mandatory and none of the optional attributes of the server-side of the "
"cluster, and that it also reflects this in global attributes such as FeatureMap and AttributeList. Commission "
"DUT to TH again.");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 4: {
LogStep(4, "DUT reads all supported optional attributes from TH one at a time in a manufacturer specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP && SWTCH.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 5: {
LogStep(5,
"DUT writes a suitable value to all supported optional attributes on the TH one at a time in a manufacturer "
"specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_WNCV_5_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_WNCV_5_1_SimulatedSuite() : TestCommand("Test_TC_WNCV_5_1_Simulated", 5)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_WNCV_5_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "DUT reads the FeatureMap attribute from TH");
VerifyOrDo(!ShouldSkip("WNCV.C.Afffc"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), WindowCovering::Id, WindowCovering::Attributes::FeatureMap::Id);
}
case 1: {
LogStep(1, "DUT reads the Type attribute from TH");
VerifyOrDo(!ShouldSkip("WNCV.C.A0000"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), WindowCovering::Id, WindowCovering::Attributes::Type::Id);
}
case 2: {
LogStep(2, "DUT reads the EndProductType attribute from TH");
VerifyOrDo(!ShouldSkip("WNCV.C.A000d"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), WindowCovering::Id, WindowCovering::Attributes::EndProductType::Id);
}
case 3: {
LogStep(3, "DUT reads the Mode attribute from TH");
VerifyOrDo(!ShouldSkip("WNCV.C.A0017"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), WindowCovering::Id, WindowCovering::Attributes::Mode::Id);
}
case 4: {
LogStep(4, "DUT reads the ConfigStatus attribute from TH");
VerifyOrDo(!ShouldSkip("WNCV.C.A0007"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), WindowCovering::Id, WindowCovering::Attributes::ConfigStatus::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_LCFG_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_LCFG_3_1_SimulatedSuite() : TestCommand("Test_TC_LCFG_3_1_Simulated", 2)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_LCFG_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "DUT reads SupportedLocales attribute from TH");
VerifyOrDo(!ShouldSkip("LCFG.C.A0001"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), LocalizationConfiguration::Id,
LocalizationConfiguration::Attributes::SupportedLocales::Id);
}
case 1: {
LogStep(1, "DUT reads ActiveLocale attribute from TH");
VerifyOrDo(!ShouldSkip("LCFG.C.A0000"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), LocalizationConfiguration::Id,
LocalizationConfiguration::Attributes::ActiveLocale::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_LUNIT_1_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_LUNIT_1_1_SimulatedSuite() : TestCommand("Test_TC_LUNIT_1_1_Simulated", 5)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_LUNIT_1_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "DUT read (0xFFFD) ClusterRevision attribute");
VerifyOrDo(!ShouldSkip("LUNIT.C.Afffd"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), UnitLocalization::Id, UnitLocalization::Attributes::ClusterRevision::Id);
}
case 1: {
LogStep(1, "DUT read (0xFFFC) FeatureMap attribute");
VerifyOrDo(!ShouldSkip("LUNIT.C.Afffc"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), UnitLocalization::Id, UnitLocalization::Attributes::FeatureMap::Id);
}
case 2: {
LogStep(2, "DUT read (0xFFFB) AttributeList attribute");
VerifyOrDo(!ShouldSkip("LUNIT.C.Afffb"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), UnitLocalization::Id, UnitLocalization::Attributes::AttributeList::Id);
}
case 3: {
LogStep(3, "DUT read (0xFFF9) AcceptedCommandList attribute");
VerifyOrDo(!ShouldSkip("LUNIT.C.Afff9"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), UnitLocalization::Id, UnitLocalization::Attributes::AcceptedCommandList::Id);
}
case 4: {
LogStep(4, "DUT read (0xFFF8) GeneratedCommandList attribute");
VerifyOrDo(!ShouldSkip("LUNIT.C.Afff8"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), UnitLocalization::Id, UnitLocalization::Attributes::GeneratedCommandList::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_LUNIT_2_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_LUNIT_2_1_SimulatedSuite() : TestCommand("Test_TC_LUNIT_2_1_Simulated", 3)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_LUNIT_2_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "DUT reads TemperatureUnit attribute from TH");
VerifyOrDo(!ShouldSkip("LUNIT.C.A0000"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), UnitLocalization::Id, UnitLocalization::Attributes::TemperatureUnit::Id);
}
case 1: {
LogStep(1, "DUT writes 2 to TemperatureUnit attribute on TH");
VerifyOrDo(!ShouldSkip("LUNIT.C.A0000"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), UnitLocalization::Id, UnitLocalization::Attributes::TemperatureUnit::Id);
}
case 2: {
LogStep(2, "DUT reads TemperatureUnit attribute from TH");
VerifyOrDo(!ShouldSkip("LUNIT.C.A0000"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), UnitLocalization::Id, UnitLocalization::Attributes::TemperatureUnit::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_OCC_2_2_SimulatedSuite : public TestCommand
{
public:
Test_TC_OCC_2_2_SimulatedSuite() : TestCommand("Test_TC_OCC_2_2_Simulated", 12)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_OCC_2_2_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "DUT reads from the TH the (0x0000) Occupancy attribute");
VerifyOrDo(!ShouldSkip("OCC.C.A0000"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), OccupancySensing::Id, OccupancySensing::Attributes::Occupancy::Id);
}
case 1: {
LogStep(1, "DUT reads from the TH the (0x0001) OccupancySensorType attribute");
VerifyOrDo(!ShouldSkip("OCC.C.A0001"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), OccupancySensing::Id, OccupancySensing::Attributes::OccupancySensorType::Id);
}
case 2: {
LogStep(2, "DUT reads from the TH the (0x0002) OccupancySensorTypeBitmap attribute");
VerifyOrDo(!ShouldSkip("OCC.C.A0002"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), OccupancySensing::Id, OccupancySensing::Attributes::OccupancySensorTypeBitmap::Id);
}
case 3: {
LogStep(3, "DUT reads from the TH the (0x0010) PIROccupiedToUnoccupiedDelay optional attribute");
VerifyOrDo(!ShouldSkip("OCC.C.A0010"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), OccupancySensing::Id,
OccupancySensing::Attributes::PIROccupiedToUnoccupiedDelay::Id);
}
case 4: {
LogStep(4, "DUT reads from the TH the (0x0011) PIRUnoccupiedToOccupiedDelay optional attribute");
VerifyOrDo(!ShouldSkip("OCC.C.A0011"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), OccupancySensing::Id,
OccupancySensing::Attributes::PIRUnoccupiedToOccupiedDelay::Id);
}
case 5: {
LogStep(5, "DUT reads from the TH the (0x0012) PIRUnoccupiedToOccupiedThreshold optional attribute");
VerifyOrDo(!ShouldSkip("OCC.C.A0012"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), OccupancySensing::Id,
OccupancySensing::Attributes::PIRUnoccupiedToOccupiedThreshold::Id);
}
case 6: {
LogStep(6, "DUT reads from the TH the (0x0020) UltrasonicOccupiedToUnoccupiedDelay optional attribute");
VerifyOrDo(!ShouldSkip("OCC.C.A0020"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), OccupancySensing::Id,
OccupancySensing::Attributes::UltrasonicOccupiedToUnoccupiedDelay::Id);
}
case 7: {
LogStep(7, "DUT reads from the TH the (0x0021) UltrasonicUnoccupiedToOccupiedDelay optional attribute");
VerifyOrDo(!ShouldSkip("OCC.C.A0021"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), OccupancySensing::Id,
OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedDelay::Id);
}
case 8: {
LogStep(8, "DUT reads from the TH the (0x0022) UltrasonicUnoccupiedToOccupiedThreshold optional attribute");
VerifyOrDo(!ShouldSkip("OCC.C.A0022"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), OccupancySensing::Id,
OccupancySensing::Attributes::UltrasonicUnoccupiedToOccupiedThreshold::Id);
}
case 9: {
LogStep(9, "DUT reads from the TH the (0x0030) PhysicalContactOccupiedToUnoccupiedDelay optional attribute");
VerifyOrDo(!ShouldSkip("OCC.C.A0030"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), OccupancySensing::Id,
OccupancySensing::Attributes::PhysicalContactOccupiedToUnoccupiedDelay::Id);
}
case 10: {
LogStep(10, "DUT reads from the TH the (0x0031) PhysicalContactUnoccupiedToOccupiedDelay optional attribute");
VerifyOrDo(!ShouldSkip("OCC.C.A0031"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), OccupancySensing::Id,
OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedDelay::Id);
}
case 11: {
LogStep(11, "DUT reads from the TH the (0x0032) PhysicalContactUnoccupiedToOccupiedThreshold optional attribute");
VerifyOrDo(!ShouldSkip("OCC.C.A0032"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), OccupancySensing::Id,
OccupancySensing::Attributes::PhysicalContactUnoccupiedToOccupiedThreshold::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_OCC_2_4_SimulatedSuite : public TestCommand
{
public:
Test_TC_OCC_2_4_SimulatedSuite() : TestCommand("Test_TC_OCC_2_4_Simulated", 2)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_OCC_2_4_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "TH reads OccupancySensorType attribute from DUT");
VerifyOrDo(!ShouldSkip("OCC.C.A0001"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), OccupancySensing::Id, OccupancySensing::Attributes::OccupancySensorType::Id);
}
case 1: {
LogStep(1, "TH reads OccupancySensorTypeBitmap attribute from DUT");
VerifyOrDo(!ShouldSkip("OCC.C.A0002"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), OccupancySensing::Id, OccupancySensing::Attributes::OccupancySensorTypeBitmap::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_ULABEL_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_ULABEL_3_1_SimulatedSuite() : TestCommand("Test_TC_ULABEL_3_1_Simulated", 2)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_ULABEL_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Read attribute: LabelList");
VerifyOrDo(!ShouldSkip("ULABEL.C.A0000"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), UserLabel::Id, UserLabel::Attributes::LabelList::Id);
}
case 1: {
LogStep(1, "write attribute: LabelList");
VerifyOrDo(!ShouldSkip("ULABEL.C.A0000"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), UserLabel::Id, UserLabel::Attributes::LabelList::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_FLABEL_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_FLABEL_3_1_SimulatedSuite() : TestCommand("Test_TC_FLABEL_3_1_Simulated", 1)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_FLABEL_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "DUT reads LabelList from the TH");
VerifyOrDo(!ShouldSkip("FLABEL.C.A0000"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), FixedLabel::Id, FixedLabel::Attributes::LabelList::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_LTIME_1_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_LTIME_1_1_SimulatedSuite() : TestCommand("Test_TC_LTIME_1_1_Simulated", 5)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_LTIME_1_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "DUT read (0xFFFD) ClusterRevision attribute");
VerifyOrDo(!ShouldSkip("LTIME.C.Afffd"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), TimeFormatLocalization::Id,
TimeFormatLocalization::Attributes::ClusterRevision::Id);
}
case 1: {
LogStep(1, "DUT read (0xFFFC) FeatureMap attribute");
VerifyOrDo(!ShouldSkip("LTIME.C.Afffc"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), TimeFormatLocalization::Id, TimeFormatLocalization::Attributes::FeatureMap::Id);
}
case 2: {
LogStep(2, "DUT read (0xFFFB) AttributeList attribute");
VerifyOrDo(!ShouldSkip("LTIME.C.Afffb"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), TimeFormatLocalization::Id, TimeFormatLocalization::Attributes::AttributeList::Id);
}
case 3: {
LogStep(3, "DUT read (0xFFF9) AcceptedCommandList attribute");
VerifyOrDo(!ShouldSkip("LTIME.C.Afff9"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), TimeFormatLocalization::Id,
TimeFormatLocalization::Attributes::AcceptedCommandList::Id);
}
case 4: {
LogStep(4, "DUT read (0xFFF8) GeneratedCommandList attribute");
VerifyOrDo(!ShouldSkip("LTIME.C.Afff8"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), TimeFormatLocalization::Id,
TimeFormatLocalization::Attributes::GeneratedCommandList::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_ILL_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_ILL_3_1_SimulatedSuite() : TestCommand("Test_TC_ILL_3_1_Simulated", 8)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_ILL_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 5:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 6:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 7:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Read attribute: MeasuredValue");
return WaitAttribute(GetEndpoint(0), IlluminanceMeasurement::Id, IlluminanceMeasurement::Attributes::MeasuredValue::Id);
}
case 1: {
LogStep(1, "Read attribute: MinMeasuredValue");
return WaitAttribute(GetEndpoint(0), IlluminanceMeasurement::Id,
IlluminanceMeasurement::Attributes::MinMeasuredValue::Id);
}
case 2: {
LogStep(2, "Read attribute: MaxMeasuredValue");
return WaitAttribute(GetEndpoint(0), IlluminanceMeasurement::Id,
IlluminanceMeasurement::Attributes::MaxMeasuredValue::Id);
}
case 3: {
LogStep(3, "Read attribute: Tolerance");
return WaitAttribute(GetEndpoint(0), IlluminanceMeasurement::Id, IlluminanceMeasurement::Attributes::Tolerance::Id);
}
case 4: {
LogStep(4, "Read attribute: LightSensorType");
return WaitAttribute(GetEndpoint(0), IlluminanceMeasurement::Id,
IlluminanceMeasurement::Attributes::LightSensorType::Id);
}
case 5: {
LogStep(5,
"Configure TH such that it implements mandatory and none of the optional attributes of the server-side of the "
"cluster, and that it also reflects this in global attributes such as FeatureMap and AttributeList.Commission "
"DUT to TH again");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 6: {
LogStep(6, "DUT reads all supported optional attributes from TH one at a time in a manufacturer specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 7: {
LogStep(7,
"DUT writes a suitable value to all supported optional attributes on the TH one at a time in a manufacturer "
"specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_DGSW_3_2_SimulatedSuite : public TestCommand
{
public:
Test_TC_DGSW_3_2_SimulatedSuite() : TestCommand("Test_TC_DGSW_3_2_Simulated", 1)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_DGSW_3_2_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "DUT sends ResetWatermarks to TH");
VerifyOrDo(!ShouldSkip("DGSW.C.C00.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(0), SoftwareDiagnostics::Id, SoftwareDiagnostics::Commands::ResetWatermarks::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_DGETH_3_2_SimulatedSuite : public TestCommand
{
public:
Test_TC_DGETH_3_2_SimulatedSuite() : TestCommand("Test_TC_DGETH_3_2_Simulated", 1)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_DGETH_3_2_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "DUT sends ResetCounts to TH");
VerifyOrDo(!ShouldSkip("DGETH.C.C00.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(0), EthernetNetworkDiagnostics::Id,
EthernetNetworkDiagnostics::Commands::ResetCounts::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_DGWIFI_3_2_SimulatedSuite : public TestCommand
{
public:
Test_TC_DGWIFI_3_2_SimulatedSuite() : TestCommand("Test_TC_DGWIFI_3_2_Simulated", 1)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_DGWIFI_3_2_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "DUT sends ResetCounts command to TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.C00.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(0), WiFiNetworkDiagnostics::Id, WiFiNetworkDiagnostics::Commands::ResetCounts::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_WNCV_6_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_WNCV_6_1_SimulatedSuite() : TestCommand("Test_TC_WNCV_6_1_Simulated", 3)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_WNCV_6_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "DUT sends UpOrOpen command to TH");
VerifyOrDo(!ShouldSkip("WNCV.C.C00.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(0), WindowCovering::Id, WindowCovering::Commands::UpOrOpen::Id);
}
case 1: {
LogStep(1, "DUT sends DownOrClose command to TH");
VerifyOrDo(!ShouldSkip("WNCV.C.C01.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(0), WindowCovering::Id, WindowCovering::Commands::DownOrClose::Id);
}
case 2: {
LogStep(2, "DUT sends StopMotion command to TH");
VerifyOrDo(!ShouldSkip("WNCV.C.C02.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(0), WindowCovering::Id, WindowCovering::Commands::StopMotion::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_WNCV_7_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_WNCV_7_1_SimulatedSuite() : TestCommand("Test_TC_WNCV_7_1_Simulated", 2)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_WNCV_7_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "If (PA_LF & LF) DUT sends GoToLiftPercentage command with 50% to DUT");
VerifyOrDo(!ShouldSkip("WNCV.C.C05.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(0), WindowCovering::Id, WindowCovering::Commands::GoToLiftPercentage::Id);
}
case 1: {
LogStep(1, "If (PA_TL & TL) DUT sends GoToTiltPercentage command with 50% to DUT");
VerifyOrDo(!ShouldSkip("WNCV.C.C08.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(0), WindowCovering::Id, WindowCovering::Commands::GoToTiltPercentage::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_CC_3_4_SimulatedSuite : public TestCommand
{
public:
Test_TC_CC_3_4_SimulatedSuite() : TestCommand("Test_TC_CC_3_4_Simulated", 16)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
AddArgument("ConfigTransitionTime", 0, UINT16_MAX, &mConfigTransitionTime);
}
~Test_TC_CC_3_4_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::Optional<uint16_t> mConfigTransitionTime;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 3:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 7:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 11:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 14:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "PreCondition: Set TH OnOff to On");
return WaitCommand(GetEndpoint(1), OnOff::Id, OnOff::Commands::On::Id);
}
case 1: {
LogStep(1, "DUT sends MoveToHue command to TH an Hue with _TransitionTime 300");
VerifyOrDo(!ShouldSkip("CC.C.C00.Tx && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::MoveToHue::Id);
}
case 2: {
LogStep(2, "DUT reads CurrentHue attribute from TH periodically");
VerifyOrDo(!ShouldSkip("CC.C.C00.Tx && CC.C.A0000 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentHue::Id);
}
case 3: {
LogStep(3, "Wait for ConfigTransitionTime");
VerifyOrDo(!ShouldSkip("CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 4: {
LogStep(4, "DUT reads CurrentHue attribute from TH periodically");
VerifyOrDo(!ShouldSkip("CC.C.C00.Tx && CC.C.A0000 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentHue::Id);
}
case 5: {
LogStep(5, "DUT sends MoveHue command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C01.Tx && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::MoveHue::Id);
}
case 6: {
LogStep(6, "DUT reads CurrentHue attribute from TH several times.");
VerifyOrDo(!ShouldSkip("CC.C.C01.Tx && CC.C.A0000 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentHue::Id);
}
case 7: {
LogStep(7, "Wait for ConfigTransitionTime");
VerifyOrDo(!ShouldSkip("CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 8: {
LogStep(8, "DUT reads CurrentHue attribute from TH several times.");
VerifyOrDo(!ShouldSkip("CC.C.C01.Tx && CC.C.A0000 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentHue::Id);
}
case 9: {
LogStep(9, "DUT sends StepHue command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C02.Tx && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::StepHue::Id);
}
case 10: {
LogStep(10, "DUT reads CurrentHue attribute from TH several times.");
VerifyOrDo(!ShouldSkip("CC.C.C02.Tx && CC.C.A0000 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentHue::Id);
}
case 11: {
LogStep(11, "Wait for ConfigTransitionTime");
VerifyOrDo(!ShouldSkip("CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 12: {
LogStep(12, "DUT reads CurrentHue attribute from TH several times.");
VerifyOrDo(!ShouldSkip("CC.C.C02.Tx && CC.C.A0000 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentHue::Id);
}
case 13: {
LogStep(13, "DUT sends StopMoveStep command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C03.Tx && CC.C.A0000 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::StopMoveStep::Id);
}
case 14: {
LogStep(14, "Wait for ConfigTransitionTime");
VerifyOrDo(!ShouldSkip("CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 15: {
LogStep(15, "Over TransitionTime, DUT reads CurrentHue attribute from TH");
VerifyOrDo(!ShouldSkip("CC.C.C03.Tx && CC.C.A0000 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentHue::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_CC_4_5_SimulatedSuite : public TestCommand
{
public:
Test_TC_CC_4_5_SimulatedSuite() : TestCommand("Test_TC_CC_4_5_Simulated", 22)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
AddArgument("ConfigTransitionTime", 0, UINT16_MAX, &mConfigTransitionTime);
}
~Test_TC_CC_4_5_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::Optional<uint16_t> mConfigTransitionTime;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 3:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 7:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 11:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 16:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 20:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "PreCondition: Set TH OnOff to On");
return WaitCommand(GetEndpoint(1), OnOff::Id, OnOff::Commands::On::Id);
}
case 1: {
LogStep(1, "DUT sends MoveToSaturation command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C03.Tx && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::MoveToSaturation::Id);
}
case 2: {
LogStep(2, "DUT reads CurrentSaturation attribute from TH periodically");
VerifyOrDo(!ShouldSkip("CC.C.C03.Tx && CC.C.A0001 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentSaturation::Id);
}
case 3: {
LogStep(3, "Wait for ConfigTransitionTime");
VerifyOrDo(!ShouldSkip("CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 4: {
LogStep(4, "DUT reads CurrentSaturation attribute from TH periodically");
VerifyOrDo(!ShouldSkip("CC.C.C03.Tx && CC.C.A0001 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentSaturation::Id);
}
case 5: {
LogStep(5, "DUT sends MoveSaturation command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C04.Tx && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::MoveSaturation::Id);
}
case 6: {
LogStep(6, "DUT reads CurrentSaturation attribute from TH several times.");
VerifyOrDo(!ShouldSkip("CC.C.C04.Tx && CC.C.A0001 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentSaturation::Id);
}
case 7: {
LogStep(7, "Wait for ConfigTransitionTime");
VerifyOrDo(!ShouldSkip("CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 8: {
LogStep(8, "DUT reads CurrentSaturation attribute from TH several times.");
VerifyOrDo(!ShouldSkip("CC.C.C04.Tx && CC.C.A0001 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentSaturation::Id);
}
case 9: {
LogStep(9, "DUT sends StepSaturation command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C05.Tx && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::StepSaturation::Id);
}
case 10: {
LogStep(10, "DUT reads CurrentSaturation attribute from TH several times.");
VerifyOrDo(!ShouldSkip("CC.C.C05.Tx && CC.C.A0001 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentSaturation::Id);
}
case 11: {
LogStep(11, "Wait for ConfigTransitionTime");
VerifyOrDo(!ShouldSkip("CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 12: {
LogStep(12, "DUT reads CurrentSaturation attribute from TH several times.");
VerifyOrDo(!ShouldSkip("CC.C.C05.Tx && CC.C.A0001 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentSaturation::Id);
}
case 13: {
LogStep(13, "DUT sends MoveToHueAndSaturation command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C06.Tx && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::MoveToHueAndSaturation::Id);
}
case 14: {
LogStep(14, "DUT reads CurrentSaturation attribute from TH several times.");
VerifyOrDo(!ShouldSkip("CC.C.C06.Tx && CC.C.A0001 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentSaturation::Id);
}
case 15: {
LogStep(15, "DUT reads CurrentHue attribute from TH periodically");
VerifyOrDo(!ShouldSkip("CC.C.C06.Tx && CC.C.A0000 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentHue::Id);
}
case 16: {
LogStep(16, "Wait for ConfigTransitionTime");
VerifyOrDo(!ShouldSkip("CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 17: {
LogStep(17, "DUT reads CurrentSaturation attribute from TH several times.");
VerifyOrDo(!ShouldSkip("CC.C.C06.Tx && CC.C.A0001 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentSaturation::Id);
}
case 18: {
LogStep(18, "DUT reads CurrentHue attribute from TH periodically");
VerifyOrDo(!ShouldSkip("CC.C.C06.Tx && CC.C.A0000 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentHue::Id);
}
case 19: {
LogStep(19, "DUT sends StopMoveStep command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C47.Tx && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::StopMoveStep::Id);
}
case 20: {
LogStep(20, "Wait for ConfigTransitionTime");
VerifyOrDo(!ShouldSkip("CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 21: {
LogStep(21, "Over TransitionTime, DUT reads CurrentSaturation attribute from TH");
VerifyOrDo(!ShouldSkip("CC.C.C47.Tx && CC.C.A0001 && CC.C.F00"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentSaturation::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_CC_5_4_SimulatedSuite : public TestCommand
{
public:
Test_TC_CC_5_4_SimulatedSuite() : TestCommand("Test_TC_CC_5_4_Simulated", 25)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("ConfigTransitionTime", 0, UINT16_MAX, &mConfigTransitionTime);
}
~Test_TC_CC_5_4_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<uint16_t> mTimeout;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mConfigTransitionTime;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 4:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 10:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 16:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 22:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "PreCondition: Set TH OnOff to On");
return WaitCommand(GetEndpoint(1), OnOff::Id, OnOff::Commands::On::Id);
}
case 1: {
LogStep(1, "DUT sends MoveToColor command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C07.Tx && CC.C.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::MoveToColor::Id);
}
case 2: {
LogStep(2, "DUT reads CurrentX attribute from TH(potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C07.Tx && CC.C.A0003 && CC.C.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentX::Id);
}
case 3: {
LogStep(3, "DUT reads CurrentY attribute from TH(potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C07.Tx && CC.C.A0004 && CC.C.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentY::Id);
}
case 4: {
LogStep(4, "Wait for ConfigTransitionTime");
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 5: {
LogStep(5, "DUT reads CurrentX attribute from TH(potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C07.Tx && CC.C.A0003 && CC.C.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentX::Id);
}
case 6: {
LogStep(6, "DUT reads CurrentY attribute from TH(potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C07.Tx && CC.C.A0004 && CC.C.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentY::Id);
}
case 7: {
LogStep(7, "DUT sends MoveColor command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C08.Tx && CC.C.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::MoveColor::Id);
}
case 8: {
LogStep(8, "DUT reads CurrentX attribute from TH(potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C08.Tx && CC.C.A0003 && CC.C.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentX::Id);
}
case 9: {
LogStep(9, "DUT reads CurrentY attribute from TH(potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C08.Tx && CC.C.A0004 && CC.C.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentY::Id);
}
case 10: {
LogStep(10, "Wait for ConfigTransitionTime");
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 11: {
LogStep(11, "DUT reads CurrentX attribute from TH(potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C08.Tx && CC.C.A0003 && CC.C.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentX::Id);
}
case 12: {
LogStep(12, "DUT reads CurrentY attribute from TH(potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C08.Tx && CC.C.A0004 && CC.C.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentY::Id);
}
case 13: {
LogStep(13, "DUT sends StepColor command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C09.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::StepColor::Id);
}
case 14: {
LogStep(14, "DUT reads CurrentX attribute from TH(potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C09.Tx && CC.C.A0003 && CC.C.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentX::Id);
}
case 15: {
LogStep(15, "DUT reads CurrentY attribute from TH(potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C09.Tx && CC.C.A0004 && CC.C.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentY::Id);
}
case 16: {
LogStep(16, "Wait for ConfigTransitionTime");
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 17: {
LogStep(17, "DUT reads CurrentX attribute from TH(potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C09.Tx && CC.C.A0003 && CC.C.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentX::Id);
}
case 18: {
LogStep(18, "DUT reads CurrentY attribute from TH(potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C09.Tx && CC.C.A0004 && CC.C.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentY::Id);
}
case 19: {
LogStep(19, "DUT sends StopMoveStep command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C47.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::StopMoveStep::Id);
}
case 20: {
LogStep(20, "DUT reads CurrentX attribute from TH(potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C47.Tx && CC.C.A0003 && CC.C.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentX::Id);
}
case 21: {
LogStep(21, "DUT reads CurrentY attribute from TH(potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C47.Tx && CC.C.A0004 && CC.C.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentY::Id);
}
case 22: {
LogStep(22, "Wait for ConfigTransitionTime");
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 23: {
LogStep(23, "DUT reads CurrentX attribute from TH(potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C47.Tx && CC.C.A0003 && CC.C.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentX::Id);
}
case 24: {
LogStep(
24,
"DUT reads CurrentY attribute from ConfiguredTime: type: int16u defaultValue: 30000TH(potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C47.Tx && CC.C.A0004 && CC.C.F03"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentY::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_CC_6_4_SimulatedSuite : public TestCommand
{
public:
Test_TC_CC_6_4_SimulatedSuite() : TestCommand("Test_TC_CC_6_4_Simulated", 18)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("ConfigTransitionTime", 0, UINT16_MAX, &mConfigTransitionTime);
}
~Test_TC_CC_6_4_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<uint16_t> mTimeout;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mConfigTransitionTime;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 5:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 9:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 13:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 16:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "PreCondition: Set TH OnOff to On");
return WaitCommand(GetEndpoint(1), OnOff::Id, OnOff::Commands::On::Id);
}
case 1: {
LogStep(1,
"* TH provides a server implementation of Color Control with F04(CT)=true and reasonable values of "
"ColorTempPhysicalMinMireds (e.g. 153 (6500K), ColorTempPhysicalMaxMireds (e.g. 454 (2200K)) DUT read "
"attribute ColorTempPhysicalMinMireds from TH");
VerifyOrDo(!ShouldSkip("CC.C.A400b && CC.C.F04"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorTempPhysicalMinMireds::Id);
}
case 2: {
LogStep(2,
"* TH provides a server implementation of Color Control with F04(CT)=true and reasonable values of "
"ColorTempPhysicalMinMireds (e.g. 153 (6500K), ColorTempPhysicalMaxMireds (e.g. 454 (2200K)) DUT read "
"attribute ColorTempPhysicalMaxMireds from TH");
VerifyOrDo(!ShouldSkip("CC.C.A400c && CC.C.F04"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorTempPhysicalMaxMireds::Id);
}
case 3: {
LogStep(3, "DUT sends MoveToColorTemperature command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C0a.Tx && CC.C.F04"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::MoveToColorTemperature::Id);
}
case 4: {
LogStep(4, "DUT reads CurrentColorTemperatureMireds attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C0a.Tx && CC.C.A0007 && CC.C.F04"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorTemperatureMireds::Id);
}
case 5: {
LogStep(5, "Wait for ConfigTransitionTime");
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 6: {
LogStep(6, "DUT reads CurrentColorTemperatureMireds attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C0a.Tx && CC.C.A0007 && CC.C.F04"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorTemperatureMireds::Id);
}
case 7: {
LogStep(7, "DUT sends MoveColorTemperatureMireds command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C4b.Tx && CC.C.F04"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::MoveColorTemperature::Id);
}
case 8: {
LogStep(8, "DUT reads CurrentColorTemperatureMireds attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C4b.Tx && CC.C.A0007 && CC.C.F04"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorTemperatureMireds::Id);
}
case 9: {
LogStep(9, "Wait for ConfigTransitionTime");
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 10: {
LogStep(10, "DUT reads CurrentColorTemperatureMireds attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C4b.Tx && CC.C.A0007 && CC.C.F04"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorTemperatureMireds::Id);
}
case 11: {
LogStep(11, "DUT sends StepColorTemperature command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C4c.Tx && CC.C.F04"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::StepColorTemperature::Id);
}
case 12: {
LogStep(12, "DUT reads CurrentColorTemperatureMireds attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C4c.Tx && CC.C.A0007 && CC.C.F04"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorTemperatureMireds::Id);
}
case 13: {
LogStep(13, "Wait for ConfigTransitionTime");
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 14: {
LogStep(14, "DUT reads CurrentColorTemperatureMireds attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C4c.Tx && CC.C.A0007 && CC.C.F04"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorTemperatureMireds::Id);
}
case 15: {
LogStep(15, "DUT sends StopMoveStep command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C47.Tx && CC.C.F04"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::StopMoveStep::Id);
}
case 16: {
LogStep(16, "Wait for ConfigTransitionTime");
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 17: {
LogStep(17, "DUT reads CurrentColorTemperatureMireds attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C47.Tx && CC.C.A0007 && CC.C.F04"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorTemperatureMireds::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_CC_7_5_SimulatedSuite : public TestCommand
{
public:
Test_TC_CC_7_5_SimulatedSuite() : TestCommand("Test_TC_CC_7_5_Simulated", 23)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("ConfigTransitionTime", 0, UINT16_MAX, &mConfigTransitionTime);
}
~Test_TC_CC_7_5_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<uint16_t> mTimeout;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mConfigTransitionTime;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 3:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 7:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 11:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 16:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 21:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "PreCondition: Set TH OnOff to On");
return WaitCommand(GetEndpoint(1), OnOff::Id, OnOff::Commands::On::Id);
}
case 1: {
LogStep(1, "DUT sends MoveToEnhancedHue command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C40.Tx && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::EnhancedMoveToHue::Id);
}
case 2: {
LogStep(2, "DUT reads EnhancedCurrentHue attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C40.Tx && CC.C.A4000 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::EnhancedCurrentHue::Id);
}
case 3: {
LogStep(3, "Wait for ConfigTransitionTime");
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 4: {
LogStep(4, "DUT reads EnhancedCurrentHue attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C40.Tx && CC.C.A4000 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::EnhancedCurrentHue::Id);
}
case 5: {
LogStep(5, "DUT sends MoveEnhanced Hue command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C41.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::EnhancedMoveHue::Id);
}
case 6: {
LogStep(6, "DUT reads EnhancedCurrentHue attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C41.Tx && CC.C.A4000 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::EnhancedCurrentHue::Id);
}
case 7: {
LogStep(7, "Wait for ConfigTransitionTime");
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 8: {
LogStep(8, "DUT reads EnhancedCurrentHue attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C41.Tx && CC.C.A4000 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::EnhancedCurrentHue::Id);
}
case 9: {
LogStep(9, "DUT sends StepEnhanced command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C42.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::EnhancedStepHue::Id);
}
case 10: {
LogStep(10, "DUT reads EnhancedCurrentHue attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C42.Tx && CC.C.A4000 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::EnhancedCurrentHue::Id);
}
case 11: {
LogStep(11, "Wait for ConfigTransitionTime");
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 12: {
LogStep(12, "DUT reads EnhancedCurrentHue attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C42.Tx && CC.C.A4000 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::EnhancedCurrentHue::Id);
}
case 13: {
LogStep(13, "DUT sends EnhancedMoveToHueAndSaturation command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C43.Tx && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::EnhancedMoveToHueAndSaturation::Id);
}
case 14: {
LogStep(14, "DUT reads EnhancedCurrentHue attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C43.Tx && CC.C.A4000 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::EnhancedCurrentHue::Id);
}
case 15: {
LogStep(15, "DUT reads CurrentSaturation attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C43.Tx && CC.C.A0001 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentSaturation::Id);
}
case 16: {
LogStep(16, "Wait for ConfigTransitionTime");
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 17: {
LogStep(17, "DUT reads EnhancedCurrentHue attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C43.Tx && CC.C.A4000 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::EnhancedCurrentHue::Id);
}
case 18: {
LogStep(18, "DUT reads CurrentSaturation attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C43.Tx && CC.C.A0001 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::CurrentSaturation::Id);
}
case 19: {
LogStep(19, "DUT sends StopMoveStep command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C47.Tx && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::StopMoveStep::Id);
}
case 20: {
LogStep(20, "DUT reads EnhancedCurrentHue attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C47.Tx && CC.C.A4000 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::EnhancedCurrentHue::Id);
}
case 21: {
LogStep(21, "Wait for ConfigTransitionTime");
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = mConfigTransitionTime.HasValue() ? mConfigTransitionTime.Value() : 3000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 22: {
LogStep(22, "DUT reads EnhancedCurrentHue attribute from TH (potentially multiple times)");
VerifyOrDo(!ShouldSkip("CC.C.C47.Tx && CC.C.A4000 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::EnhancedCurrentHue::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_CC_9_4_SimulatedSuite : public TestCommand
{
public:
Test_TC_CC_9_4_SimulatedSuite() : TestCommand("Test_TC_CC_9_4_Simulated", 19)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
}
~Test_TC_CC_9_4_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<uint16_t> mTimeout;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 7:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 9:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 11:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 13:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 15:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 17:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "PreCondition: Set TH OnOff to On");
return WaitCommand(GetEndpoint(1), OnOff::Id, OnOff::Commands::On::Id);
}
case 1: {
LogStep(1, "DUT sends ColorLoopSet command to TH");
VerifyOrDo(!ShouldSkip("CC.C.C44.Tx && CC.C.F02 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), ColorControl::Id, ColorControl::Commands::ColorLoopSet::Id);
}
case 2: {
LogStep(2, "DUT reads ColorLoopActive attribute from TH periodically");
VerifyOrDo(!ShouldSkip("CC.C.A4002 && CC.C.F02 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorLoopActive::Id);
}
case 3: {
LogStep(3, "DUT reads ColorLoopDirection attribute from TH periodically");
VerifyOrDo(!ShouldSkip("CC.C.A4003 && CC.C.F02 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorLoopDirection::Id);
}
case 4: {
LogStep(4, "DUT reads ColorLoopTime attribute from TH periodically");
VerifyOrDo(!ShouldSkip("CC.C.A4004 && CC.C.F02 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorLoopTime::Id);
}
case 5: {
LogStep(5, "DUT reads ColorLoopStartEnhancedHue attribute from TH periodically");
VerifyOrDo(!ShouldSkip("CC.C.A4005 && CC.C.F02 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::ColorLoopStartEnhancedHue::Id);
}
case 6: {
LogStep(6, "DUT reads EnhancedCurrentHue attribute from TH periodically");
VerifyOrDo(!ShouldSkip("CC.C.A4000 && CC.C.F02 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::EnhancedCurrentHue::Id);
}
case 7: {
LogStep(7, "Wait 5000ms");
VerifyOrDo(!ShouldSkip("CC.C.F02 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = 5000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 8: {
LogStep(8, "DUT reads EnhancedCurrentHue attribute from TH periodically");
VerifyOrDo(!ShouldSkip("CC.C.A4000 && CC.C.F02 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::EnhancedCurrentHue::Id);
}
case 9: {
LogStep(9, "Wait 5000ms");
VerifyOrDo(!ShouldSkip("CC.C.F02 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = 5000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 10: {
LogStep(10, "DUT reads EnhancedCurrentHue attribute from TH periodically");
VerifyOrDo(!ShouldSkip("CC.C.A4000 && CC.C.F02 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::EnhancedCurrentHue::Id);
}
case 11: {
LogStep(11, "Wait 5000ms");
VerifyOrDo(!ShouldSkip("CC.C.F02 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = 5000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 12: {
LogStep(12, "DUT reads EnhancedCurrentHue attribute from TH periodically");
VerifyOrDo(!ShouldSkip("CC.C.A4000 && CC.C.F02 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::EnhancedCurrentHue::Id);
}
case 13: {
LogStep(13, "Wait 5000ms");
VerifyOrDo(!ShouldSkip("CC.C.F02 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = 5000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 14: {
LogStep(14, "DUT reads EnhancedCurrentHue attribute from TH periodically");
VerifyOrDo(!ShouldSkip("CC.C.A4000 && CC.C.F02 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::EnhancedCurrentHue::Id);
}
case 15: {
LogStep(15, "Wait 5000ms");
VerifyOrDo(!ShouldSkip("CC.C.F02 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = 5000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 16: {
LogStep(16, "DUT reads EnhancedCurrentHue attribute from TH periodically");
VerifyOrDo(!ShouldSkip("CC.C.A4000 && CC.C.F02 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::EnhancedCurrentHue::Id);
}
case 17: {
LogStep(17, "Wait 5000ms");
VerifyOrDo(!ShouldSkip("CC.C.F02 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::DelayCommands::Commands::WaitForMs::Type value;
value.ms = 5000UL;
return WaitForMs(kIdentityAlpha, value);
}
case 18: {
LogStep(18, "DUT reads EnhancedCurrentHue attribute from TH periodically");
VerifyOrDo(!ShouldSkip("CC.C.A4000 && CC.C.F02 && CC.C.F01"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(1), ColorControl::Id, ColorControl::Attributes::EnhancedCurrentHue::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_DGTHREAD_3_2_SimulatedSuite : public TestCommand
{
public:
Test_TC_DGTHREAD_3_2_SimulatedSuite() : TestCommand("Test_TC_DGTHREAD_3_2_Simulated", 17)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_DGTHREAD_3_2_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "DUT reads TxUnicastCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0016"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::TxUnicastCount::Id);
}
case 1: {
LogStep(1, "DUT reads TxUnicastCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0017"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::TxUnicastCount::Id);
}
case 2: {
LogStep(2, "DUT reads TxBroadcastCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0018"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::TxBroadcastCount::Id);
}
case 3: {
LogStep(3, "DUT reads TxAckRequestedCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0019"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::TxAckRequestedCount::Id);
}
case 4: {
LogStep(4, "DUT reads TxAckedCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A001a"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::TxAckedCount::Id);
}
case 5: {
LogStep(5, "DUT reads TxNoAckRequestedCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A001b"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::TxNoAckRequestedCount::Id);
}
case 6: {
LogStep(6, "DUT reads TxDataCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A001c"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::TxDataCount::Id);
}
case 7: {
LogStep(7, "DUT reads TxDataPollCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A001d"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::TxDataPollCount::Id);
}
case 8: {
LogStep(8, "DUT reads TxBeaconCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A001e"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::TxBeaconCount::Id);
}
case 9: {
LogStep(9, "DUT reads TxBeaconRequestCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A001f"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::TxBeaconRequestCount::Id);
}
case 10: {
LogStep(10, "DUT reads TxOtherCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0020"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::TxOtherCount::Id);
}
case 11: {
LogStep(11, "DUT reads TxRetryCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0021"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::TxRetryCount::Id);
}
case 12: {
LogStep(12, "DUT reads TxDirectMaxRetryExpiryCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0022"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::TxDirectMaxRetryExpiryCount::Id);
}
case 13: {
LogStep(13, "DUT reads TxIndirectMaxRetryExpiryCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0023"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::TxIndirectMaxRetryExpiryCount::Id);
}
case 14: {
LogStep(14, "DUT reads TxErrCcaCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0024"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::TxErrCcaCount::Id);
}
case 15: {
LogStep(15, "DUT reads TxErrAbortCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0025"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::TxErrAbortCount::Id);
}
case 16: {
LogStep(16, "DUT reads TxErrBusyChannelCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0026"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::TxErrBusyChannelCount::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_DGTHREAD_3_3_SimulatedSuite : public TestCommand
{
public:
Test_TC_DGTHREAD_3_3_SimulatedSuite() : TestCommand("Test_TC_DGTHREAD_3_3_Simulated", 17)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_DGTHREAD_3_3_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "DUT reads RxTotalCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0027"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::RxTotalCount::Id);
}
case 1: {
LogStep(1, "DUT reads RxUnicastCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0028"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::RxUnicastCount::Id);
}
case 2: {
LogStep(2, "DUT reads RxBroadcastCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0029"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::RxBroadcastCount::Id);
}
case 3: {
LogStep(3, "DUT reads RxDataCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A002a"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::RxDataCount::Id);
}
case 4: {
LogStep(4, "DUT reads RxDataPollCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A002b"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::RxDataPollCount::Id);
}
case 5: {
LogStep(5, "DUT reads RxBeaconCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A002c"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::RxBeaconCount::Id);
}
case 6: {
LogStep(6, "DUT reads RxBeaconRequestCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A002d"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::RxBeaconRequestCount::Id);
}
case 7: {
LogStep(7, "DUT reads RxOtherCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A002e"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::RxOtherCount::Id);
}
case 8: {
LogStep(8, "DUT reads RxAddressFilteredCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A002f"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::RxAddressFilteredCount::Id);
}
case 9: {
LogStep(9, "DUT reads RxDestAddrFilteredCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0030"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::RxDestAddrFilteredCount::Id);
}
case 10: {
LogStep(10, "DUT reads RxDuplicatedCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0031"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::RxDuplicatedCount::Id);
}
case 11: {
LogStep(11, "DUT reads RxErrNoFrameCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0032"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::RxErrNoFrameCount::Id);
}
case 12: {
LogStep(12, "DUT reads RxErrUnknownNeighborCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0033"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::RxErrUnknownNeighborCount::Id);
}
case 13: {
LogStep(13, "DUT reads RxErrInvalidSrcAddrCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0034"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::RxErrInvalidSrcAddrCount::Id);
}
case 14: {
LogStep(14, "DUT reads RxErrSecCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0035"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::RxErrSecCount::Id);
}
case 15: {
LogStep(15, "DUT reads RxErrFcsCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0036"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::RxErrFcsCount::Id);
}
case 16: {
LogStep(16, "DUT reads RxErrOtherCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0037"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::RxErrOtherCount::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_DGTHREAD_3_4_SimulatedSuite : public TestCommand
{
public:
Test_TC_DGTHREAD_3_4_SimulatedSuite() : TestCommand("Test_TC_DGTHREAD_3_4_Simulated", 2)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_DGTHREAD_3_4_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "DUT sends ResetCounts command to TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.C00.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(0), ThreadNetworkDiagnostics::Id, ThreadNetworkDiagnostics::Commands::ResetCounts::Id);
}
case 1: {
LogStep(1, "DUT reads OverrunCount attribute value from TH");
VerifyOrDo(!ShouldSkip("DGTHREAD.C.A0006"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), ThreadNetworkDiagnostics::Id,
ThreadNetworkDiagnostics::Attributes::OverrunCount::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_LVL_2_3_SimulatedSuite : public TestCommand
{
public:
Test_TC_LVL_2_3_SimulatedSuite() : TestCommand("Test_TC_LVL_2_3_Simulated", 24)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_LVL_2_3_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 21:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 22:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 23:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Read mandatory attribute CurrentLevel");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::CurrentLevel::Id);
}
case 1: {
LogStep(1, "Read mandatory attribute OnLevel");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::OnLevel::Id);
}
case 2: {
LogStep(2, "Read mandatory attribute Options");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::Options::Id);
}
case 3: {
LogStep(3, "Read optional attribute RemainingTime");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::RemainingTime::Id);
}
case 4: {
LogStep(4, "Read optional attribute StartUpCurrentLevel");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::StartUpCurrentLevel::Id);
}
case 5: {
LogStep(5, "Read optional attribute CurrentFrequency");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::CurrentFrequency::Id);
}
case 6: {
LogStep(6, "Read optional attribute MinFrequency");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::MinFrequency::Id);
}
case 7: {
LogStep(7, "Read optional attribute MaxFrequency");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::MaxFrequency::Id);
}
case 8: {
LogStep(8, "Read optional attribute MinLevel");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::MinLevel::Id);
}
case 9: {
LogStep(9, "Read optional attribute MaxLevel");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::MaxLevel::Id);
}
case 10: {
LogStep(10, "Read optional attribute OnOffTransitionTime");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::OnOffTransitionTime::Id);
}
case 11: {
LogStep(11, "Read optional attribute OnTransitionTime");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::OnTransitionTime::Id);
}
case 12: {
LogStep(12, "Read optional attribute OffTransitionTime");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::OffTransitionTime::Id);
}
case 13: {
LogStep(13, "Read optional attribute DefaultMoveRate");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::DefaultMoveRate::Id);
}
case 14: {
LogStep(14, "Write mandatory attribute OnLevel");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::OnLevel::Id);
}
case 15: {
LogStep(15, "Write mandatory attribute Options");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::Options::Id);
}
case 16: {
LogStep(16, "Write optional attribute OnOffTransitionTime");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::OnOffTransitionTime::Id);
}
case 17: {
LogStep(17, "Write optional attribute OnTransitionTime");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::OnTransitionTime::Id);
}
case 18: {
LogStep(18, "Write optional attribute OffTransitionTime");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::OffTransitionTime::Id);
}
case 19: {
LogStep(19, "Write optional attribute DefaultMoveRate");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::DefaultMoveRate::Id);
}
case 20: {
LogStep(20, "Write optional attribute StartUpCurrentLevel");
return WaitAttribute(GetEndpoint(1), LevelControl::Id, LevelControl::Attributes::StartUpCurrentLevel::Id);
}
case 21: {
LogStep(21,
"Configure TH such that it implements mandatory and none of the optional attributes of the server-side of the "
"cluster, and that it also reflects this in global attributes such as FeatureMap and AttributeList.Commission "
"DUT to TH again");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 22: {
LogStep(22, "DUT reads all supported optional attributes from TH one at a time in a manufacturer specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 23: {
LogStep(23,
"DUT writes a suitable value to all supported optional attributes on the TH one at a time in a manufacturer "
"specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_OO_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_OO_3_1_SimulatedSuite() : TestCommand("Test_TC_OO_3_1_Simulated", 11)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_OO_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 8:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 9:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 10:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Read attribute OnOff");
return WaitAttribute(GetEndpoint(1), OnOff::Id, OnOff::Attributes::OnOff::Id);
}
case 1: {
LogStep(1, "Read attribute GlobalSceneControl");
return WaitAttribute(GetEndpoint(1), OnOff::Id, OnOff::Attributes::GlobalSceneControl::Id);
}
case 2: {
LogStep(2, "Read attribute OnTime");
return WaitAttribute(GetEndpoint(1), OnOff::Id, OnOff::Attributes::OnTime::Id);
}
case 3: {
LogStep(3, "Read attribute OffWaitTime");
return WaitAttribute(GetEndpoint(1), OnOff::Id, OnOff::Attributes::OffWaitTime::Id);
}
case 4: {
LogStep(4, "Read attribute StartUpOnOff");
return WaitAttribute(GetEndpoint(1), OnOff::Id, OnOff::Attributes::StartUpOnOff::Id);
}
case 5: {
LogStep(5, "Write attribute OnTime");
return WaitAttribute(GetEndpoint(1), OnOff::Id, OnOff::Attributes::OnTime::Id);
}
case 6: {
LogStep(6, "Write attribute OffWaitTime");
return WaitAttribute(GetEndpoint(1), OnOff::Id, OnOff::Attributes::OffWaitTime::Id);
}
case 7: {
LogStep(7, "Write attribute StartUpOnOff");
return WaitAttribute(GetEndpoint(1), OnOff::Id, OnOff::Attributes::StartUpOnOff::Id);
}
case 8: {
LogStep(8,
"Configure TH such that it implements mandatory and none of the optional attributes of the server-side of the "
"cluster, and that it also reflects this in global attributes such as FeatureMap and AttributeList.Commission "
"DUT to TH again");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 9: {
LogStep(9, "DUT reads all supported optional attributes from TH one at a time in a manufacturer specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 10: {
LogStep(10,
"DUT writes a suitable value to all supported optional attributes on the TH one at a time in a manufacturer "
"specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_OO_3_2_SimulatedSuite : public TestCommand
{
public:
Test_TC_OO_3_2_SimulatedSuite() : TestCommand("Test_TC_OO_3_2_Simulated", 6)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_OO_3_2_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "DUT issues an Off command to the TH");
VerifyOrDo(!ShouldSkip("OO.C.C00.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), OnOff::Id, OnOff::Commands::Off::Id);
}
case 1: {
LogStep(1, "DUT issues an On command to the TH");
VerifyOrDo(!ShouldSkip("OO.C.C01.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), OnOff::Id, OnOff::Commands::On::Id);
}
case 2: {
LogStep(2, "DUT issues an Toggle command to the TH");
VerifyOrDo(!ShouldSkip("OO.C.C02.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), OnOff::Id, OnOff::Commands::Toggle::Id);
}
case 3: {
LogStep(3, "DUT issues an OffWithEffect command to the TH");
VerifyOrDo(!ShouldSkip("OO.C.C40.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), OnOff::Id, OnOff::Commands::OffWithEffect::Id);
}
case 4: {
LogStep(4, "DUT issues an OnWithRecallGlobalScene command to the TH");
VerifyOrDo(!ShouldSkip("OO.C.C41.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), OnOff::Id, OnOff::Commands::OnWithRecallGlobalScene::Id);
}
case 5: {
LogStep(5, "DUT issues an OnWithTimedOff command to the TH");
VerifyOrDo(!ShouldSkip("OO.C.C42.Tx"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitCommand(GetEndpoint(1), OnOff::Id, OnOff::Commands::OnWithTimedOff::Id);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_TSUIC_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_TSUIC_3_1_SimulatedSuite() : TestCommand("Test_TC_TSUIC_3_1_Simulated", 9)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_TSUIC_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 6:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 7:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 8:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "DUT reads TemperatureDisplayMode attribute from TH");
return WaitAttribute(GetEndpoint(0), ThermostatUserInterfaceConfiguration::Id,
ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::Id);
}
case 1: {
LogStep(1, "DUT reads KeypadLockout attribute from TH");
return WaitAttribute(GetEndpoint(0), ThermostatUserInterfaceConfiguration::Id,
ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::Id);
}
case 2: {
LogStep(2, "DUT reads ScheduleProgrammingVisibility attribute from TH");
return WaitAttribute(GetEndpoint(0), ThermostatUserInterfaceConfiguration::Id,
ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::Id);
}
case 3: {
LogStep(3, "DUT writes TemperatureDisplayMode attribute from TH");
return WaitAttribute(GetEndpoint(0), ThermostatUserInterfaceConfiguration::Id,
ThermostatUserInterfaceConfiguration::Attributes::TemperatureDisplayMode::Id);
}
case 4: {
LogStep(4, "DUT writes KeypadLockout attribute from TH");
return WaitAttribute(GetEndpoint(0), ThermostatUserInterfaceConfiguration::Id,
ThermostatUserInterfaceConfiguration::Attributes::KeypadLockout::Id);
}
case 5: {
LogStep(5, "DUT writes ScheduleProgrammingVisibility attribute from TH");
return WaitAttribute(GetEndpoint(0), ThermostatUserInterfaceConfiguration::Id,
ThermostatUserInterfaceConfiguration::Attributes::ScheduleProgrammingVisibility::Id);
}
case 6: {
LogStep(6,
"Configure TH such that it implements mandatory and none of the optional attributes of the server-side of the "
"cluster, and that it also reflects this in global attributes such as FeatureMap and AttributeList.Commission "
"DUT to TH again");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 7: {
LogStep(7, "DUT reads all supported optional attributes from TH one at a time in a manufacturer specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 8: {
LogStep(8,
"DUT writes a suitable value to all supported optional attributes on the TH one at a time in a manufacturer "
"specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_PCC_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_PCC_3_1_SimulatedSuite() : TestCommand("Test_TC_PCC_3_1_Simulated", 30)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_PCC_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 27:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 28:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 29:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Read attribute MaxPressure");
VerifyOrDo(!ShouldSkip("PCC.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::MaxPressure::Id);
}
case 1: {
LogStep(1, "Read attribute MaxSpeed");
VerifyOrDo(!ShouldSkip("PCC.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::MaxSpeed::Id);
}
case 2: {
LogStep(2, "Read attribute MaxFlow");
VerifyOrDo(!ShouldSkip("PCC.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::MaxFlow::Id);
}
case 3: {
LogStep(3, "Read attribute EffectiveOperationMode");
VerifyOrDo(!ShouldSkip("PCC.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::EffectiveOperationMode::Id);
}
case 4: {
LogStep(4, "Read attribute EffectiveControlMode");
VerifyOrDo(!ShouldSkip("PCC.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::EffectiveControlMode::Id);
}
case 5: {
LogStep(5, "Read attribute Capacity");
VerifyOrDo(!ShouldSkip("PCC.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::Capacity::Id);
}
case 6: {
LogStep(6, "Read attribute OperationMode");
VerifyOrDo(!ShouldSkip("PCC.C.AM-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::OperationMode::Id);
}
case 7: {
LogStep(7, "Read attribute MinConstPressure");
VerifyOrDo(!ShouldSkip("PCC.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::MinConstPressure::Id);
}
case 8: {
LogStep(8, "Read attribute MaxConstPressure");
VerifyOrDo(!ShouldSkip("PCC.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::MaxConstPressure::Id);
}
case 9: {
LogStep(9, "Read attribute MinCompPressure");
VerifyOrDo(!ShouldSkip("PCC.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::MinCompPressure::Id);
}
case 10: {
LogStep(10, "Read attribute MaxCompPressure");
VerifyOrDo(!ShouldSkip("PCC.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::MaxCompPressure::Id);
}
case 11: {
LogStep(11, "Read attribute MinConstSpeed");
VerifyOrDo(!ShouldSkip("PCC.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::MinConstSpeed::Id);
}
case 12: {
LogStep(12, "Read attribute MaxConstSpeed");
VerifyOrDo(!ShouldSkip("PCC.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::MaxConstSpeed::Id);
}
case 13: {
LogStep(13, "Read attribute MinConstFlow");
VerifyOrDo(!ShouldSkip("PCC.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::MinConstFlow::Id);
}
case 14: {
LogStep(14, "Read attribute MaxConstFlow");
VerifyOrDo(!ShouldSkip("PCC.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::MaxConstFlow::Id);
}
case 15: {
LogStep(15, "Read attribute MinConstTemp");
VerifyOrDo(!ShouldSkip("PCC.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::MinConstTemp::Id);
}
case 16: {
LogStep(16, "Read attribute MaxConstTemp");
VerifyOrDo(!ShouldSkip("PCC.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::MaxConstTemp::Id);
}
case 17: {
LogStep(17, "Read attribute PumpStatus");
VerifyOrDo(!ShouldSkip("PCC.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::PumpStatus::Id);
}
case 18: {
LogStep(18, "Read attribute Speed");
VerifyOrDo(!ShouldSkip("PCC.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::Speed::Id);
}
case 19: {
LogStep(19, "Read attribute LifetimeRunningHours");
VerifyOrDo(!ShouldSkip("PCC.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::LifetimeRunningHours::Id);
}
case 20: {
LogStep(20, "Read attribute Power");
VerifyOrDo(!ShouldSkip("PCC.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::Power::Id);
}
case 21: {
LogStep(21, "Read attribute LifetimeEnergyConsumed");
VerifyOrDo(!ShouldSkip("PCC.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::Id);
}
case 22: {
LogStep(22, "Read attribute ControlMode");
VerifyOrDo(!ShouldSkip("PCC.C.AO-READ"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::ControlMode::Id);
}
case 23: {
LogStep(23, "Write attribute LifetimeRunningHours");
VerifyOrDo(!ShouldSkip("PCC.C.AO-WRITE"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::LifetimeRunningHours::Id);
}
case 24: {
LogStep(24, "Write attribute LifetimeEnergyConsumed");
VerifyOrDo(!ShouldSkip("PCC.C.AO-WRITE"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::LifetimeEnergyConsumed::Id);
}
case 25: {
LogStep(25, "Write attribute OperationMode");
VerifyOrDo(!ShouldSkip("PCC.C.AO-WRITE"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::OperationMode::Id);
}
case 26: {
LogStep(26, "Write attribute ControlMode");
VerifyOrDo(!ShouldSkip("PCC.C.AO-WRITE"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
return WaitAttribute(GetEndpoint(0), PumpConfigurationAndControl::Id,
PumpConfigurationAndControl::Attributes::ControlMode::Id);
}
case 27: {
LogStep(27,
"Configure TH such that it implements mandatory and none of the optional attributes of the server-side of the "
"cluster, and that it also reflects this in global attributes such as FeatureMap and AttributeList.Commission "
"DUT to TH again");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 28: {
LogStep(28, "DUT reads all supported optional attributes from TH one at a time in a manufacturer specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 29: {
LogStep(29,
"DUT writes a suitable value to all supported optional attributes on the TH one at a time in a manufacturer "
"specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
}
return CHIP_NO_ERROR;
}
};
class Test_TC_TMP_3_1_SimulatedSuite : public TestCommand
{
public:
Test_TC_TMP_3_1_SimulatedSuite() : TestCommand("Test_TC_TMP_3_1_Simulated", 7)
{
AddArgument("nodeId", 0, UINT64_MAX, &mNodeId);
AddArgument("cluster", &mCluster);
AddArgument("endpoint", 0, UINT16_MAX, &mEndpoint);
AddArgument("timeout", 0, UINT16_MAX, &mTimeout);
}
~Test_TC_TMP_3_1_SimulatedSuite() {}
private:
chip::Optional<chip::NodeId> mNodeId;
chip::Optional<chip::CharSpan> mCluster;
chip::Optional<chip::EndpointId> mEndpoint;
chip::Optional<uint16_t> mTimeout;
chip::EndpointId GetEndpoint(chip::EndpointId endpoint) { return mEndpoint.HasValue() ? mEndpoint.Value() : endpoint; }
//
// Tests methods
//
void OnResponse(const chip::app::StatusIB & status, chip::TLV::TLVReader * data) override
{
bool shouldContinue = false;
switch (mTestIndex - 1)
{
case 4:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 5:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
case 6:
VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0));
shouldContinue = true;
break;
default:
LogErrorOnFailure(ContinueOnChipMainThread(CHIP_ERROR_INVALID_ARGUMENT));
}
if (shouldContinue)
{
ContinueOnChipMainThread(CHIP_NO_ERROR);
}
}
CHIP_ERROR DoTestStep(uint16_t testIndex) override
{
using namespace chip::app::Clusters;
switch (testIndex)
{
case 0: {
LogStep(0, "Read attribute: MeasuredValue");
return WaitAttribute(GetEndpoint(0), TemperatureMeasurement::Id, TemperatureMeasurement::Attributes::MeasuredValue::Id);
}
case 1: {
LogStep(1, "Read attribute: MinMeasuredValue");
return WaitAttribute(GetEndpoint(0), TemperatureMeasurement::Id,
TemperatureMeasurement::Attributes::MinMeasuredValue::Id);
}
case 2: {
LogStep(2, "Read attribute: MaxMeasuredValue");
return WaitAttribute(GetEndpoint(0), TemperatureMeasurement::Id,
TemperatureMeasurement::Attributes::MaxMeasuredValue::Id);
}
case 3: {
LogStep(3, "Read attribute: Tolerance");
return WaitAttribute(GetEndpoint(0), TemperatureMeasurement::Id, TemperatureMeasurement::Attributes::Tolerance::Id);
}
case 4: {
LogStep(4,
"Configure TH such that it implements mandatory and none of the optional attributes of the server-side of the "
"cluster, and that it also reflects this in global attributes such as FeatureMap and AttributeList.Commission "
"DUT to TH again");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 5: {
LogStep(5, "DUT reads all supported optional attributes from TH one at a time in a manufacturer specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
case 6: {
LogStep(6,
"DUT writes a suitable value to all supported optional attributes on the TH one at a time in a manufacturer "
"specific order");
VerifyOrDo(!ShouldSkip("PICS_SKIP_SAMPLE_APP"), return ContinueOnChipMainThread(CHIP_NO_ERROR));
ListFreer listFreer;
chip::app::Clusters::LogCommands::Commands::UserPrompt::Type value;
value.message = chip::Span<const char>("Enter 'y' after successgarbage: not in length on purpose", 23);
value.expectedValue.Emplace();
value.expectedValue.Value() = chip::Span<const char>("ygarbage: not in length on purpose", 1);
return UserPrompt(kIdentityAlpha, value);
}
}
return CHIP_NO_ERROR;
}
};
std::unique_ptr<TestCommand> GetTestCommand(std::string testName)
{
if (testName == "Test_TC_BINFO_2_3_Simulated")
{
return std::unique_ptr<Test_TC_BINFO_2_3_SimulatedSuite>(new Test_TC_BINFO_2_3_SimulatedSuite());
}
if (testName == "Test_TC_ACT_3_1_Simulated")
{
return std::unique_ptr<Test_TC_ACT_3_1_SimulatedSuite>(new Test_TC_ACT_3_1_SimulatedSuite());
}
if (testName == "Test_TC_BOOL_3_1_Simulated")
{
return std::unique_ptr<Test_TC_BOOL_3_1_SimulatedSuite>(new Test_TC_BOOL_3_1_SimulatedSuite());
}
if (testName == "Test_TC_DESC_2_2_Simulated")
{
return std::unique_ptr<Test_TC_DESC_2_2_SimulatedSuite>(new Test_TC_DESC_2_2_SimulatedSuite());
}
if (testName == "Test_TC_DGETH_3_1_Simulated")
{
return std::unique_ptr<Test_TC_DGETH_3_1_SimulatedSuite>(new Test_TC_DGETH_3_1_SimulatedSuite());
}
if (testName == "Test_TC_DGSW_3_1_Simulated")
{
return std::unique_ptr<Test_TC_DGSW_3_1_SimulatedSuite>(new Test_TC_DGSW_3_1_SimulatedSuite());
}
if (testName == "Test_TC_DGWIFI_3_1_Simulated")
{
return std::unique_ptr<Test_TC_DGWIFI_3_1_SimulatedSuite>(new Test_TC_DGWIFI_3_1_SimulatedSuite());
}
if (testName == "Test_TC_FLW_3_1_Simulated")
{
return std::unique_ptr<Test_TC_FLW_3_1_SimulatedSuite>(new Test_TC_FLW_3_1_SimulatedSuite());
}
if (testName == "Test_TC_G_3_1_Simulated")
{
return std::unique_ptr<Test_TC_G_3_1_SimulatedSuite>(new Test_TC_G_3_1_SimulatedSuite());
}
if (testName == "Test_TC_I_3_1_Simulated")
{
return std::unique_ptr<Test_TC_I_3_1_SimulatedSuite>(new Test_TC_I_3_1_SimulatedSuite());
}
if (testName == "Test_TC_PRS_3_1_Simulated")
{
return std::unique_ptr<Test_TC_PRS_3_1_SimulatedSuite>(new Test_TC_PRS_3_1_SimulatedSuite());
}
if (testName == "Test_TC_PS_3_1_Simulated")
{
return std::unique_ptr<Test_TC_PS_3_1_SimulatedSuite>(new Test_TC_PS_3_1_SimulatedSuite());
}
if (testName == "Test_TC_PSCFG_3_1_Simulated")
{
return std::unique_ptr<Test_TC_PSCFG_3_1_SimulatedSuite>(new Test_TC_PSCFG_3_1_SimulatedSuite());
}
if (testName == "Test_TC_RH_3_1_Simulated")
{
return std::unique_ptr<Test_TC_RH_3_1_SimulatedSuite>(new Test_TC_RH_3_1_SimulatedSuite());
}
if (testName == "Test_TC_SWTCH_3_1_Simulated")
{
return std::unique_ptr<Test_TC_SWTCH_3_1_SimulatedSuite>(new Test_TC_SWTCH_3_1_SimulatedSuite());
}
if (testName == "Test_TC_WNCV_5_1_Simulated")
{
return std::unique_ptr<Test_TC_WNCV_5_1_SimulatedSuite>(new Test_TC_WNCV_5_1_SimulatedSuite());
}
if (testName == "Test_TC_LCFG_3_1_Simulated")
{
return std::unique_ptr<Test_TC_LCFG_3_1_SimulatedSuite>(new Test_TC_LCFG_3_1_SimulatedSuite());
}
if (testName == "Test_TC_LUNIT_1_1_Simulated")
{
return std::unique_ptr<Test_TC_LUNIT_1_1_SimulatedSuite>(new Test_TC_LUNIT_1_1_SimulatedSuite());
}
if (testName == "Test_TC_LUNIT_2_1_Simulated")
{
return std::unique_ptr<Test_TC_LUNIT_2_1_SimulatedSuite>(new Test_TC_LUNIT_2_1_SimulatedSuite());
}
if (testName == "Test_TC_OCC_2_2_Simulated")
{
return std::unique_ptr<Test_TC_OCC_2_2_SimulatedSuite>(new Test_TC_OCC_2_2_SimulatedSuite());
}
if (testName == "Test_TC_OCC_2_4_Simulated")
{
return std::unique_ptr<Test_TC_OCC_2_4_SimulatedSuite>(new Test_TC_OCC_2_4_SimulatedSuite());
}
if (testName == "Test_TC_ULABEL_3_1_Simulated")
{
return std::unique_ptr<Test_TC_ULABEL_3_1_SimulatedSuite>(new Test_TC_ULABEL_3_1_SimulatedSuite());
}
if (testName == "Test_TC_FLABEL_3_1_Simulated")
{
return std::unique_ptr<Test_TC_FLABEL_3_1_SimulatedSuite>(new Test_TC_FLABEL_3_1_SimulatedSuite());
}
if (testName == "Test_TC_LTIME_1_1_Simulated")
{
return std::unique_ptr<Test_TC_LTIME_1_1_SimulatedSuite>(new Test_TC_LTIME_1_1_SimulatedSuite());
}
if (testName == "Test_TC_ILL_3_1_Simulated")
{
return std::unique_ptr<Test_TC_ILL_3_1_SimulatedSuite>(new Test_TC_ILL_3_1_SimulatedSuite());
}
if (testName == "Test_TC_DGSW_3_2_Simulated")
{
return std::unique_ptr<Test_TC_DGSW_3_2_SimulatedSuite>(new Test_TC_DGSW_3_2_SimulatedSuite());
}
if (testName == "Test_TC_DGETH_3_2_Simulated")
{
return std::unique_ptr<Test_TC_DGETH_3_2_SimulatedSuite>(new Test_TC_DGETH_3_2_SimulatedSuite());
}
if (testName == "Test_TC_DGWIFI_3_2_Simulated")
{
return std::unique_ptr<Test_TC_DGWIFI_3_2_SimulatedSuite>(new Test_TC_DGWIFI_3_2_SimulatedSuite());
}
if (testName == "Test_TC_WNCV_6_1_Simulated")
{
return std::unique_ptr<Test_TC_WNCV_6_1_SimulatedSuite>(new Test_TC_WNCV_6_1_SimulatedSuite());
}
if (testName == "Test_TC_WNCV_7_1_Simulated")
{
return std::unique_ptr<Test_TC_WNCV_7_1_SimulatedSuite>(new Test_TC_WNCV_7_1_SimulatedSuite());
}
if (testName == "Test_TC_CC_3_4_Simulated")
{
return std::unique_ptr<Test_TC_CC_3_4_SimulatedSuite>(new Test_TC_CC_3_4_SimulatedSuite());
}
if (testName == "Test_TC_CC_4_5_Simulated")
{
return std::unique_ptr<Test_TC_CC_4_5_SimulatedSuite>(new Test_TC_CC_4_5_SimulatedSuite());
}
if (testName == "Test_TC_CC_5_4_Simulated")
{
return std::unique_ptr<Test_TC_CC_5_4_SimulatedSuite>(new Test_TC_CC_5_4_SimulatedSuite());
}
if (testName == "Test_TC_CC_6_4_Simulated")
{
return std::unique_ptr<Test_TC_CC_6_4_SimulatedSuite>(new Test_TC_CC_6_4_SimulatedSuite());
}
if (testName == "Test_TC_CC_7_5_Simulated")
{
return std::unique_ptr<Test_TC_CC_7_5_SimulatedSuite>(new Test_TC_CC_7_5_SimulatedSuite());
}
if (testName == "Test_TC_CC_9_4_Simulated")
{
return std::unique_ptr<Test_TC_CC_9_4_SimulatedSuite>(new Test_TC_CC_9_4_SimulatedSuite());
}
if (testName == "Test_TC_DGTHREAD_3_2_Simulated")
{
return std::unique_ptr<Test_TC_DGTHREAD_3_2_SimulatedSuite>(new Test_TC_DGTHREAD_3_2_SimulatedSuite());
}
if (testName == "Test_TC_DGTHREAD_3_3_Simulated")
{
return std::unique_ptr<Test_TC_DGTHREAD_3_3_SimulatedSuite>(new Test_TC_DGTHREAD_3_3_SimulatedSuite());
}
if (testName == "Test_TC_DGTHREAD_3_4_Simulated")
{
return std::unique_ptr<Test_TC_DGTHREAD_3_4_SimulatedSuite>(new Test_TC_DGTHREAD_3_4_SimulatedSuite());
}
if (testName == "Test_TC_LVL_2_3_Simulated")
{
return std::unique_ptr<Test_TC_LVL_2_3_SimulatedSuite>(new Test_TC_LVL_2_3_SimulatedSuite());
}
if (testName == "Test_TC_OO_3_1_Simulated")
{
return std::unique_ptr<Test_TC_OO_3_1_SimulatedSuite>(new Test_TC_OO_3_1_SimulatedSuite());
}
if (testName == "Test_TC_OO_3_2_Simulated")
{
return std::unique_ptr<Test_TC_OO_3_2_SimulatedSuite>(new Test_TC_OO_3_2_SimulatedSuite());
}
if (testName == "Test_TC_TSUIC_3_1_Simulated")
{
return std::unique_ptr<Test_TC_TSUIC_3_1_SimulatedSuite>(new Test_TC_TSUIC_3_1_SimulatedSuite());
}
if (testName == "Test_TC_PCC_3_1_Simulated")
{
return std::unique_ptr<Test_TC_PCC_3_1_SimulatedSuite>(new Test_TC_PCC_3_1_SimulatedSuite());
}
if (testName == "Test_TC_TMP_3_1_Simulated")
{
return std::unique_ptr<Test_TC_TMP_3_1_SimulatedSuite>(new Test_TC_TMP_3_1_SimulatedSuite());
}
return nullptr;
}
void PrintTestCommands()
{
ChipLogError(chipTool, "Supported commands:");
ChipLogError(chipTool, "\t* Test_TC_BINFO_2_3_Simulated");
ChipLogError(chipTool, "\t* Test_TC_ACT_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_BOOL_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_DESC_2_2_Simulated");
ChipLogError(chipTool, "\t* Test_TC_DGETH_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_DGSW_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_DGWIFI_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_FLW_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_G_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_I_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_PRS_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_PS_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_PSCFG_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_RH_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_SWTCH_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_WNCV_5_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_LCFG_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_LUNIT_1_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_LUNIT_2_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_OCC_2_2_Simulated");
ChipLogError(chipTool, "\t* Test_TC_OCC_2_4_Simulated");
ChipLogError(chipTool, "\t* Test_TC_ULABEL_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_FLABEL_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_LTIME_1_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_ILL_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_DGSW_3_2_Simulated");
ChipLogError(chipTool, "\t* Test_TC_DGETH_3_2_Simulated");
ChipLogError(chipTool, "\t* Test_TC_DGWIFI_3_2_Simulated");
ChipLogError(chipTool, "\t* Test_TC_WNCV_6_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_WNCV_7_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_CC_3_4_Simulated");
ChipLogError(chipTool, "\t* Test_TC_CC_4_5_Simulated");
ChipLogError(chipTool, "\t* Test_TC_CC_5_4_Simulated");
ChipLogError(chipTool, "\t* Test_TC_CC_6_4_Simulated");
ChipLogError(chipTool, "\t* Test_TC_CC_7_5_Simulated");
ChipLogError(chipTool, "\t* Test_TC_CC_9_4_Simulated");
ChipLogError(chipTool, "\t* Test_TC_DGTHREAD_3_2_Simulated");
ChipLogError(chipTool, "\t* Test_TC_DGTHREAD_3_3_Simulated");
ChipLogError(chipTool, "\t* Test_TC_DGTHREAD_3_4_Simulated");
ChipLogError(chipTool, "\t* Test_TC_LVL_2_3_Simulated");
ChipLogError(chipTool, "\t* Test_TC_OO_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_OO_3_2_Simulated");
ChipLogError(chipTool, "\t* Test_TC_TSUIC_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_PCC_3_1_Simulated");
ChipLogError(chipTool, "\t* Test_TC_TMP_3_1_Simulated");
}