diff --git a/src/app/common/BUILD.gn b/src/app/common/BUILD.gn index 648016563ac5d5..fee9795dc5982c 100644 --- a/src/app/common/BUILD.gn +++ b/src/app/common/BUILD.gn @@ -18,6 +18,8 @@ static_library("cluster-objects") { output_name = "libClusterObjects" sources = [ + "${chip_root}/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h", + "${chip_root}/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h", "${chip_root}/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp", "${chip_root}/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h", ] diff --git a/src/app/common/templates/templates.json b/src/app/common/templates/templates.json index b21737864ca180..2e1ba3043bc24b 100644 --- a/src/app/common/templates/templates.json +++ b/src/app/common/templates/templates.json @@ -120,13 +120,18 @@ }, { "path": "../../zap-templates/templates/app/cluster-objects-src.zapt", - "name": "Cluster objects header for Interaction Model", + "name": "Cluster objects source for Interaction Model", "output": "cluster-objects.cpp" }, { "path": "../../zap-templates/templates/app/cluster-enums.zapt", - "name": "Enum and bitmap definitions for clusters", + "name": "Enum and bitmap header for clusters", "output": "cluster-enums.h" + }, + { + "path": "../../zap-templates/templates/app/cluster-enums-check.zapt", + "name": "Enum and bitmap method check header for clusters", + "output": "cluster-enums-check.h" } ] } diff --git a/src/app/data-model/Decode.h b/src/app/data-model/Decode.h index 9becc5af42a551..6e31d22b4aafb4 100644 --- a/src/app/data-model/Decode.h +++ b/src/app/data-model/Decode.h @@ -18,6 +18,7 @@ #pragma once +#include #include #include #include @@ -28,6 +29,13 @@ namespace chip { namespace app { +namespace Clusters { +static auto __attribute__((unused)) EnsureKnownEnumValue(chip::VendorId val) +{ + return val; +} +} // namespace Clusters + namespace DataModel { // @@ -48,7 +56,9 @@ CHIP_ERROR Decode(TLV::TLVReader & reader, X & x) template ::value, int> = 0> CHIP_ERROR Decode(TLV::TLVReader & reader, X & x) { - return reader.Get(x); + ReturnErrorOnFailure(reader.Get(x)); + x = Clusters::EnsureKnownEnumValue(x); + return CHIP_NO_ERROR; } template diff --git a/src/app/tests/TestDataModelSerialization.cpp b/src/app/tests/TestDataModelSerialization.cpp index 368b6e7d9d23a9..3c922f348b4514 100644 --- a/src/app/tests/TestDataModelSerialization.cpp +++ b/src/app/tests/TestDataModelSerialization.cpp @@ -42,6 +42,7 @@ class TestDataModelSerialization { public: static void TestDataModelSerialization_EncAndDecSimpleStruct(nlTestSuite * apSuite, void * apContext); + static void TestDataModelSerialization_EncAndDecSimpleStructNegativeEnum(nlTestSuite * apSuite, void * apContext); static void TestDataModelSerialization_EncAndDecNestedStruct(nlTestSuite * apSuite, void * apContext); static void TestDataModelSerialization_EncAndDecNestedStructList(nlTestSuite * apSuite, void * apContext); static void TestDataModelSerialization_EncAndDecDecodableNestedStructList(nlTestSuite * apSuite, void * apContext); @@ -221,6 +222,55 @@ void TestDataModelSerialization::TestDataModelSerialization_EncAndDecSimpleStruc } } +void TestDataModelSerialization::TestDataModelSerialization_EncAndDecSimpleStructNegativeEnum(nlTestSuite * apSuite, + void * apContext) +{ + CHIP_ERROR err; + auto * _this = static_cast(apContext); + + _this->mpSuite = apSuite; + _this->SetupBuf(); + + // + // Encode + // + { + TestCluster::Structs::SimpleStruct::Type t; + uint8_t buf[4] = { 0, 1, 2, 3 }; + char strbuf[10] = "chip"; + + t.a = 20; + t.b = true; + t.c = static_cast(10); + t.d = buf; + + t.e = Span{ strbuf, strlen(strbuf) }; + + t.f.Set(TestCluster::SimpleBitmap::kValueC); + + err = DataModel::Encode(_this->mWriter, TLV::AnonymousTag(), t); + NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + + err = _this->mWriter.Finalize(); + NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + + _this->DumpBuf(); + } + + // + // Decode + // + { + TestCluster::Structs::SimpleStruct::Type t; + + _this->SetupReader(); + + err = DataModel::Decode(_this->mReader, t); + NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + NL_TEST_ASSERT(apSuite, to_underlying(t.c) == 4); + } +} + void TestDataModelSerialization::TestDataModelSerialization_EncAndDecNestedStruct(nlTestSuite * apSuite, void * apContext) { CHIP_ERROR err; @@ -1057,6 +1107,7 @@ int Finalize(void * aContext) const nlTest sTests[] = { NL_TEST_DEF("TestDataModelSerialization_EncAndDecSimple", TestDataModelSerialization::TestDataModelSerialization_EncAndDecSimpleStruct), + NL_TEST_DEF("TestDataModelSerialization_EncAndDecSimpleStructNegativeEnum", TestDataModelSerialization::TestDataModelSerialization_EncAndDecSimpleStructNegativeEnum), NL_TEST_DEF("TestDataModelSerialization_EncAndDecNestedStruct", TestDataModelSerialization::TestDataModelSerialization_EncAndDecNestedStruct), NL_TEST_DEF("TestDataModelSerialization_EncAndDecDecodableNestedStructList", TestDataModelSerialization::TestDataModelSerialization_EncAndDecDecodableNestedStructList), NL_TEST_DEF("TestDataModelSerialization_EncAndDecDecodableDoubleNestedStructList", TestDataModelSerialization::TestDataModelSerialization_EncAndDecDecodableDoubleNestedStructList), diff --git a/src/app/tests/suites/TestCluster.yaml b/src/app/tests/suites/TestCluster.yaml index 85b33b6525d9a0..e1ddaba5939780 100644 --- a/src/app/tests/suites/TestCluster.yaml +++ b/src/app/tests/suites/TestCluster.yaml @@ -1038,13 +1038,28 @@ tests: - name: "arg1" value: 20003 - name: "arg2" - value: 101 + value: 1 response: + values: + - name: "arg1" + value: 20003 + - name: "arg2" + value: 1 + + - label: "Send a command with a vendor_id and invalid enum" + command: "TestEnumsRequest" + arguments: values: - name: "arg1" value: 20003 - name: "arg2" value: 101 + response: + values: + - name: "arg1" + value: 20003 + - name: "arg2" + value: 4 # Tests for Struct @@ -2766,13 +2781,13 @@ tests: command: "writeAttribute" attribute: "nullable_enum_attr" arguments: - value: 254 + value: 3 - label: "Read attribute NULLABLE_SIMPLE_ENUM Max Value" command: "readAttribute" attribute: "nullable_enum_attr" response: - value: 254 + value: 3 - label: "Write attribute NULLABLE_SIMPLE_ENUM Invalid Value" command: "writeAttribute" @@ -2786,8 +2801,8 @@ tests: command: "readAttribute" attribute: "nullable_enum_attr" response: - saveAs: nullableEnumAttr254 - value: 254 + saveAs: nullableEnumAttr3 + value: 3 - label: "Write attribute NULLABLE_SIMPLE_ENUM null Value" command: "writeAttribute" @@ -2801,12 +2816,12 @@ tests: response: value: null - - label: "Read attribute NULLABLE_SIMPLE_ENUM not 254 Value" + - label: "Read attribute NULLABLE_SIMPLE_ENUM not 3 Value" command: "readAttribute" attribute: "nullable_enum_attr" response: constraints: - notValue: nullableEnumAttr254 + notValue: nullableEnumAttr3 # Tests for Octet String attribute diff --git a/src/app/zap-templates/templates/app/cluster-enums-check.zapt b/src/app/zap-templates/templates/app/cluster-enums-check.zapt new file mode 100644 index 00000000000000..883a19b5cf0aee --- /dev/null +++ b/src/app/zap-templates/templates/app/cluster-enums-check.zapt @@ -0,0 +1,41 @@ +{{> header}} + +#pragma once + +#include + +namespace chip { +namespace app { +namespace Clusters { +{{#zcl_clusters}} +{{#zcl_enums}} +static auto __attribute__((unused)) EnsureKnownEnumValue({{asUpperCamelCase ../name}}::{{asType label}} val) +{ + using EnumType = {{asUpperCamelCase ../name}}::{{asType label}}; + switch (val) { +{{#if (isWeaklyTypedEnum label)}} +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +{{/if}} + {{#zcl_enum_items}} + case EnumType::k{{asUpperCamelCase label}}: + {{/zcl_enum_items}} +{{#if (isWeaklyTypedEnum label)}} +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + {{#zcl_enum_items}} + case EMBER_ZCL_{{asDelimitedMacro parent.label}}_{{asDelimitedMacro label}}: + {{/zcl_enum_items}} +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +{{/if}} + return val; + default: + return static_cast({{first_unused_enum_value mode="first_unused"}}); + } +} +{{/zcl_enums}} + +{{/zcl_clusters}} +} // namespace Clusters +} // namespace app +} // namespace chip diff --git a/src/app/zap-templates/templates/app/cluster-enums.zapt b/src/app/zap-templates/templates/app/cluster-enums.zapt index b03ba4ec0d054f..0f2ae2bb7a2181 100644 --- a/src/app/zap-templates/templates/app/cluster-enums.zapt +++ b/src/app/zap-templates/templates/app/cluster-enums.zapt @@ -28,8 +28,9 @@ k{{asUpperCamelCase label}} = {{asHex value 2}}, {{#if (isWeaklyTypedEnum label)}} #else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using {{asType label}} = EmberAf{{asType label}}; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM {{/if}} +static {{asType label}} k{{asType label}}FirstUnusedEnumVal = static_cast<{{asType label}}>({{first_unused_enum_value mode="first_unused"}}); {{/zcl_enums}} {{#zcl_bitmaps}} diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h b/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h new file mode 100644 index 00000000000000..aa5a52f169a00c --- /dev/null +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h @@ -0,0 +1,2138 @@ +/* + * + * 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 + +namespace chip { +namespace app { +namespace Clusters { + +static auto __attribute__((unused)) EnsureKnownEnumValue(Identify::IdentifyEffectIdentifier val) +{ + using EnumType = Identify::IdentifyEffectIdentifier; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kBlink: + case EnumType::kBreathe: + case EnumType::kOkay: + case EnumType::kChannelChange: + case EnumType::kFinishEffect: + case EnumType::kStopEffect: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_BLINK: + case EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_BREATHE: + case EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_OKAY: + case EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_CHANNEL_CHANGE: + case EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_FINISH_EFFECT: + case EMBER_ZCL_IDENTIFY_EFFECT_IDENTIFIER_STOP_EFFECT: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(3); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(Identify::IdentifyEffectVariant val) +{ + using EnumType = Identify::IdentifyEffectVariant; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kDefault: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_IDENTIFY_EFFECT_VARIANT_DEFAULT: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(1); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(Identify::IdentifyIdentifyType val) +{ + using EnumType = Identify::IdentifyIdentifyType; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kNone: + case EnumType::kVisibleLight: + case EnumType::kVisibleLED: + case EnumType::kAudibleBeep: + case EnumType::kDisplay: + case EnumType::kActuator: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_IDENTIFY_IDENTIFY_TYPE_NONE: + case EMBER_ZCL_IDENTIFY_IDENTIFY_TYPE_VISIBLE_LIGHT: + case EMBER_ZCL_IDENTIFY_IDENTIFY_TYPE_VISIBLE_LED: + case EMBER_ZCL_IDENTIFY_IDENTIFY_TYPE_AUDIBLE_BEEP: + case EMBER_ZCL_IDENTIFY_IDENTIFY_TYPE_DISPLAY: + case EMBER_ZCL_IDENTIFY_IDENTIFY_TYPE_ACTUATOR: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(6); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(OnOff::OnOffDelayedAllOffEffectVariant val) +{ + using EnumType = OnOff::OnOffDelayedAllOffEffectVariant; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kFadeToOffIn0p8Seconds: + case EnumType::kNoFade: + case EnumType::k50PercentDimDownIn0p8SecondsThenFadeToOffIn12Seconds: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_ON_OFF_DELAYED_ALL_OFF_EFFECT_VARIANT_FADE_TO_OFF_IN_0P8_SECONDS: + case EMBER_ZCL_ON_OFF_DELAYED_ALL_OFF_EFFECT_VARIANT_NO_FADE: + case EMBER_ZCL_ON_OFF_DELAYED_ALL_OFF_EFFECT_VARIANT_50_PERCENT_DIM_DOWN_IN_0P8_SECONDS_THEN_FADE_TO_OFF_IN_12_SECONDS: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(3); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(OnOff::OnOffDyingLightEffectVariant val) +{ + using EnumType = OnOff::OnOffDyingLightEffectVariant; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::k20PercenterDimUpIn0p5SecondsThenFadeToOffIn1Second: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_ON_OFF_DYING_LIGHT_EFFECT_VARIANT_20_PERCENTER_DIM_UP_IN_0P5_SECONDS_THEN_FADE_TO_OFF_IN_1_SECOND: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(1); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(OnOff::OnOffEffectIdentifier val) +{ + using EnumType = OnOff::OnOffEffectIdentifier; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kDelayedAllOff: + case EnumType::kDyingLight: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_ON_OFF_EFFECT_IDENTIFIER_DELAYED_ALL_OFF: + case EMBER_ZCL_ON_OFF_EFFECT_IDENTIFIER_DYING_LIGHT: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(2); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(OnOff::OnOffStartUpOnOff val) +{ + using EnumType = OnOff::OnOffStartUpOnOff; + switch (val) + { + case EnumType::kOff: + case EnumType::kOn: + case EnumType::kTogglePreviousOnOff: + return val; + default: + return static_cast(3); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(LevelControl::MoveMode val) +{ + using EnumType = LevelControl::MoveMode; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kUp: + case EnumType::kDown: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_MOVE_MODE_UP: + case EMBER_ZCL_MOVE_MODE_DOWN: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(2); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(LevelControl::StepMode val) +{ + using EnumType = LevelControl::StepMode; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kUp: + case EnumType::kDown: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_STEP_MODE_UP: + case EMBER_ZCL_STEP_MODE_DOWN: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(2); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(ApplianceControl::ApplianceStatus val) +{ + using EnumType = ApplianceControl::ApplianceStatus; + switch (val) + { + case EnumType::kOff: + case EnumType::kStandBy: + case EnumType::kProgrammed: + case EnumType::kProgrammedWaitingToStart: + case EnumType::kRunning: + case EnumType::kPause: + case EnumType::kEndProgrammed: + case EnumType::kFailure: + case EnumType::kProgrammeInterrupted: + case EnumType::kIdle: + case EnumType::kRinseHold: + case EnumType::kService: + case EnumType::kSuperfreezing: + case EnumType::kSupercooling: + case EnumType::kSuperheating: + return val; + default: + return static_cast(0); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(ApplianceControl::CommandIdentification val) +{ + using EnumType = ApplianceControl::CommandIdentification; + switch (val) + { + case EnumType::kStart: + case EnumType::kStop: + case EnumType::kPause: + case EnumType::kStartSuperfreezing: + case EnumType::kStopSuperfreezing: + case EnumType::kStartSupercooling: + case EnumType::kStopSupercooling: + case EnumType::kDisableGas: + case EnumType::kEnableGas: + case EnumType::kEnableEnergyControl: + case EnumType::kDisableEnergyControl: + return val; + default: + return static_cast(0); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(ApplianceControl::WarningEvent val) +{ + using EnumType = ApplianceControl::WarningEvent; + switch (val) + { + case EnumType::kWarning1OverallPowerAboveAvailablePowerLevel: + case EnumType::kWarning2OverallPowerAbovePowerThresholdLevel: + case EnumType::kWarning3OverallPowerBackBelowTheAvailablePowerLevel: + case EnumType::kWarning4OverallPowerBackBelowThePowerThresholdLevel: + case EnumType::kWarning5OverallPowerWillBePotentiallyAboveAvailablePowerLevelIfTheApplianceStarts: + return val; + default: + return static_cast(5); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(AccessControl::AuthMode val) +{ + using EnumType = AccessControl::AuthMode; + switch (val) + { + case EnumType::kPase: + case EnumType::kCase: + case EnumType::kGroup: + return val; + default: + return static_cast(0); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(AccessControl::ChangeTypeEnum val) +{ + using EnumType = AccessControl::ChangeTypeEnum; + switch (val) + { + case EnumType::kChanged: + case EnumType::kAdded: + case EnumType::kRemoved: + return val; + default: + return static_cast(3); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(AccessControl::Privilege val) +{ + using EnumType = AccessControl::Privilege; + switch (val) + { + case EnumType::kView: + case EnumType::kProxyView: + case EnumType::kOperate: + case EnumType::kManage: + case EnumType::kAdminister: + return val; + default: + return static_cast(0); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(BridgedActions::ActionErrorEnum val) +{ + using EnumType = BridgedActions::ActionErrorEnum; + switch (val) + { + case EnumType::kUnknown: + case EnumType::kInterrupted: + return val; + default: + return static_cast(2); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(BridgedActions::ActionStateEnum val) +{ + using EnumType = BridgedActions::ActionStateEnum; + switch (val) + { + case EnumType::kInactive: + case EnumType::kActive: + case EnumType::kPaused: + case EnumType::kDisabled: + return val; + default: + return static_cast(4); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(BridgedActions::ActionTypeEnum val) +{ + using EnumType = BridgedActions::ActionTypeEnum; + switch (val) + { + case EnumType::kOther: + case EnumType::kScene: + case EnumType::kSequence: + case EnumType::kAutomation: + case EnumType::kException: + case EnumType::kNotification: + case EnumType::kAlarm: + return val; + default: + return static_cast(7); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(BridgedActions::EndpointListTypeEnum val) +{ + using EnumType = BridgedActions::EndpointListTypeEnum; + switch (val) + { + case EnumType::kOther: + case EnumType::kRoom: + case EnumType::kZone: + return val; + default: + return static_cast(3); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(OtaSoftwareUpdateProvider::OTAApplyUpdateAction val) +{ + using EnumType = OtaSoftwareUpdateProvider::OTAApplyUpdateAction; + switch (val) + { + case EnumType::kProceed: + case EnumType::kAwaitNextAction: + case EnumType::kDiscontinue: + return val; + default: + return static_cast(3); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(OtaSoftwareUpdateProvider::OTADownloadProtocol val) +{ + using EnumType = OtaSoftwareUpdateProvider::OTADownloadProtocol; + switch (val) + { + case EnumType::kBDXSynchronous: + case EnumType::kBDXAsynchronous: + case EnumType::kHttps: + case EnumType::kVendorSpecific: + return val; + default: + return static_cast(4); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(OtaSoftwareUpdateProvider::OTAQueryStatus val) +{ + using EnumType = OtaSoftwareUpdateProvider::OTAQueryStatus; + switch (val) + { + case EnumType::kUpdateAvailable: + case EnumType::kBusy: + case EnumType::kNotAvailable: + case EnumType::kDownloadProtocolNotSupported: + return val; + default: + return static_cast(4); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(OtaSoftwareUpdateRequestor::OTAAnnouncementReason val) +{ + using EnumType = OtaSoftwareUpdateRequestor::OTAAnnouncementReason; + switch (val) + { + case EnumType::kSimpleAnnouncement: + case EnumType::kUpdateAvailable: + case EnumType::kUrgentUpdateAvailable: + return val; + default: + return static_cast(3); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(OtaSoftwareUpdateRequestor::OTAChangeReasonEnum val) +{ + using EnumType = OtaSoftwareUpdateRequestor::OTAChangeReasonEnum; + switch (val) + { + case EnumType::kUnknown: + case EnumType::kSuccess: + case EnumType::kFailure: + case EnumType::kTimeOut: + case EnumType::kDelayByProvider: + return val; + default: + return static_cast(5); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(OtaSoftwareUpdateRequestor::OTAUpdateStateEnum val) +{ + using EnumType = OtaSoftwareUpdateRequestor::OTAUpdateStateEnum; + switch (val) + { + case EnumType::kUnknown: + case EnumType::kIdle: + case EnumType::kQuerying: + case EnumType::kDelayedOnQuery: + case EnumType::kDownloading: + case EnumType::kApplying: + case EnumType::kDelayedOnApply: + case EnumType::kRollingBack: + case EnumType::kDelayedOnUserConsent: + return val; + default: + return static_cast(9); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(TimeFormatLocalization::CalendarType val) +{ + using EnumType = TimeFormatLocalization::CalendarType; + switch (val) + { + case EnumType::kBuddhist: + case EnumType::kChinese: + case EnumType::kCoptic: + case EnumType::kEthiopian: + case EnumType::kGregorian: + case EnumType::kHebrew: + case EnumType::kIndian: + case EnumType::kIslamic: + case EnumType::kJapanese: + case EnumType::kKorean: + case EnumType::kPersian: + case EnumType::kTaiwanese: + return val; + default: + return static_cast(12); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(TimeFormatLocalization::HourFormat val) +{ + using EnumType = TimeFormatLocalization::HourFormat; + switch (val) + { + case EnumType::k12hr: + case EnumType::k24hr: + return val; + default: + return static_cast(2); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(UnitLocalization::TempUnit val) +{ + using EnumType = UnitLocalization::TempUnit; + switch (val) + { + case EnumType::kFahrenheit: + case EnumType::kCelsius: + case EnumType::kKelvin: + return val; + default: + return static_cast(3); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::BatChargeFault val) +{ + using EnumType = PowerSource::BatChargeFault; + switch (val) + { + case EnumType::kUnspecfied: + case EnumType::kAmbientTooHot: + case EnumType::kAmbientTooCold: + case EnumType::kBatteryTooHot: + case EnumType::kBatteryTooCold: + case EnumType::kBatteryAbsent: + case EnumType::kBatteryOverVoltage: + case EnumType::kBatteryUnderVoltage: + case EnumType::kChargerOverVoltage: + case EnumType::kChargerUnderVoltage: + case EnumType::kSafetyTimeout: + return val; + default: + return static_cast(11); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::BatChargeLevel val) +{ + using EnumType = PowerSource::BatChargeLevel; + switch (val) + { + case EnumType::kOk: + case EnumType::kWarning: + case EnumType::kCritical: + return val; + default: + return static_cast(3); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::BatChargeState val) +{ + using EnumType = PowerSource::BatChargeState; + switch (val) + { + case EnumType::kUnknown: + case EnumType::kIsCharging: + case EnumType::kIsAtFullCharge: + case EnumType::kIsNotCharging: + return val; + default: + return static_cast(4); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::BatFault val) +{ + using EnumType = PowerSource::BatFault; + switch (val) + { + case EnumType::kUnspecfied: + case EnumType::kOverTemp: + case EnumType::kUnderTemp: + return val; + default: + return static_cast(3); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::BatReplaceability val) +{ + using EnumType = PowerSource::BatReplaceability; + switch (val) + { + case EnumType::kUnspecified: + case EnumType::kNotReplaceable: + case EnumType::kUserReplaceable: + case EnumType::kFactoryReplaceable: + return val; + default: + return static_cast(4); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::PowerSourceStatus val) +{ + using EnumType = PowerSource::PowerSourceStatus; + switch (val) + { + case EnumType::kUnspecfied: + case EnumType::kActive: + case EnumType::kStandby: + case EnumType::kUnavailable: + return val; + default: + return static_cast(4); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::WiredCurrentType val) +{ + using EnumType = PowerSource::WiredCurrentType; + switch (val) + { + case EnumType::kAc: + case EnumType::kDc: + return val; + default: + return static_cast(2); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(PowerSource::WiredFault val) +{ + using EnumType = PowerSource::WiredFault; + switch (val) + { + case EnumType::kUnspecfied: + case EnumType::kOverVoltage: + case EnumType::kUnderVoltage: + return val; + default: + return static_cast(3); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralCommissioning::CommissioningError val) +{ + using EnumType = GeneralCommissioning::CommissioningError; + switch (val) + { + case EnumType::kOk: + case EnumType::kValueOutsideRange: + case EnumType::kInvalidAuthentication: + case EnumType::kNoFailSafe: + case EnumType::kBusyWithOtherAdmin: + return val; + default: + return static_cast(5); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralCommissioning::RegulatoryLocationType val) +{ + using EnumType = GeneralCommissioning::RegulatoryLocationType; + switch (val) + { + case EnumType::kIndoor: + case EnumType::kOutdoor: + case EnumType::kIndoorOutdoor: + return val; + default: + return static_cast(3); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(NetworkCommissioning::NetworkCommissioningStatus val) +{ + using EnumType = NetworkCommissioning::NetworkCommissioningStatus; + switch (val) + { + case EnumType::kSuccess: + case EnumType::kOutOfRange: + case EnumType::kBoundsExceeded: + case EnumType::kNetworkIDNotFound: + case EnumType::kDuplicateNetworkID: + case EnumType::kNetworkNotFound: + case EnumType::kRegulatoryError: + case EnumType::kAuthFailure: + case EnumType::kUnsupportedSecurity: + case EnumType::kOtherConnectionFailure: + case EnumType::kIPV6Failed: + case EnumType::kIPBindFailed: + case EnumType::kUnknownError: + return val; + default: + return static_cast(13); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(NetworkCommissioning::WiFiBand val) +{ + using EnumType = NetworkCommissioning::WiFiBand; + switch (val) + { + case EnumType::k2g4: + case EnumType::k3g65: + case EnumType::k5g: + case EnumType::k6g: + case EnumType::k60g: + return val; + default: + return static_cast(5); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(DiagnosticLogs::LogsIntent val) +{ + using EnumType = DiagnosticLogs::LogsIntent; + switch (val) + { + case EnumType::kEndUserSupport: + case EnumType::kNetworkDiag: + case EnumType::kCrashLogs: + return val; + default: + return static_cast(3); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DiagnosticLogs::LogsStatus val) +{ + using EnumType = DiagnosticLogs::LogsStatus; + switch (val) + { + case EnumType::kSuccess: + case EnumType::kExhausted: + case EnumType::kNoLogs: + case EnumType::kBusy: + case EnumType::kDenied: + return val; + default: + return static_cast(5); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DiagnosticLogs::LogsTransferProtocol val) +{ + using EnumType = DiagnosticLogs::LogsTransferProtocol; + switch (val) + { + case EnumType::kResponsePayload: + case EnumType::kBdx: + return val; + default: + return static_cast(2); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralDiagnostics::BootReasonType val) +{ + using EnumType = GeneralDiagnostics::BootReasonType; + switch (val) + { + case EnumType::kUnspecified: + case EnumType::kPowerOnReboot: + case EnumType::kBrownOutReset: + case EnumType::kSoftwareWatchdogReset: + case EnumType::kHardwareWatchdogReset: + case EnumType::kSoftwareUpdateCompleted: + case EnumType::kSoftwareReset: + return val; + default: + return static_cast(7); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralDiagnostics::HardwareFaultType val) +{ + using EnumType = GeneralDiagnostics::HardwareFaultType; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kUnspecified: + case EnumType::kRadio: + case EnumType::kSensor: + case EnumType::kResettableOverTemp: + case EnumType::kNonResettableOverTemp: + case EnumType::kPowerSource: + case EnumType::kVisualDisplayFault: + case EnumType::kAudioOutputFault: + case EnumType::kUserInterfaceFault: + case EnumType::kNonVolatileMemoryError: + case EnumType::kTamperDetected: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_HARDWARE_FAULT_TYPE_UNSPECIFIED: + case EMBER_ZCL_HARDWARE_FAULT_TYPE_RADIO: + case EMBER_ZCL_HARDWARE_FAULT_TYPE_SENSOR: + case EMBER_ZCL_HARDWARE_FAULT_TYPE_RESETTABLE_OVER_TEMP: + case EMBER_ZCL_HARDWARE_FAULT_TYPE_NON_RESETTABLE_OVER_TEMP: + case EMBER_ZCL_HARDWARE_FAULT_TYPE_POWER_SOURCE: + case EMBER_ZCL_HARDWARE_FAULT_TYPE_VISUAL_DISPLAY_FAULT: + case EMBER_ZCL_HARDWARE_FAULT_TYPE_AUDIO_OUTPUT_FAULT: + case EMBER_ZCL_HARDWARE_FAULT_TYPE_USER_INTERFACE_FAULT: + case EMBER_ZCL_HARDWARE_FAULT_TYPE_NON_VOLATILE_MEMORY_ERROR: + case EMBER_ZCL_HARDWARE_FAULT_TYPE_TAMPER_DETECTED: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(11); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralDiagnostics::InterfaceType val) +{ + using EnumType = GeneralDiagnostics::InterfaceType; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kUnspecified: + case EnumType::kWiFi: + case EnumType::kEthernet: + case EnumType::kCellular: + case EnumType::kThread: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_INTERFACE_TYPE_UNSPECIFIED: + case EMBER_ZCL_INTERFACE_TYPE_WI_FI: + case EMBER_ZCL_INTERFACE_TYPE_ETHERNET: + case EMBER_ZCL_INTERFACE_TYPE_CELLULAR: + case EMBER_ZCL_INTERFACE_TYPE_THREAD: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(5); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralDiagnostics::NetworkFaultType val) +{ + using EnumType = GeneralDiagnostics::NetworkFaultType; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kUnspecified: + case EnumType::kHardwareFailure: + case EnumType::kNetworkJammed: + case EnumType::kConnectionFailed: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_NETWORK_FAULT_TYPE_UNSPECIFIED: + case EMBER_ZCL_NETWORK_FAULT_TYPE_HARDWARE_FAILURE: + case EMBER_ZCL_NETWORK_FAULT_TYPE_NETWORK_JAMMED: + case EMBER_ZCL_NETWORK_FAULT_TYPE_CONNECTION_FAILED: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(4); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(GeneralDiagnostics::RadioFaultType val) +{ + using EnumType = GeneralDiagnostics::RadioFaultType; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kUnspecified: + case EnumType::kWiFiFault: + case EnumType::kCellularFault: + case EnumType::kThreadFault: + case EnumType::kNFCFault: + case EnumType::kBLEFault: + case EnumType::kEthernetFault: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_RADIO_FAULT_TYPE_UNSPECIFIED: + case EMBER_ZCL_RADIO_FAULT_TYPE_WI_FI_FAULT: + case EMBER_ZCL_RADIO_FAULT_TYPE_CELLULAR_FAULT: + case EMBER_ZCL_RADIO_FAULT_TYPE_THREAD_FAULT: + case EMBER_ZCL_RADIO_FAULT_TYPE_NFC_FAULT: + case EMBER_ZCL_RADIO_FAULT_TYPE_BLE_FAULT: + case EMBER_ZCL_RADIO_FAULT_TYPE_ETHERNET_FAULT: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(7); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(ThreadNetworkDiagnostics::NetworkFault val) +{ + using EnumType = ThreadNetworkDiagnostics::NetworkFault; + switch (val) + { + case EnumType::kUnspecified: + case EnumType::kLinkDown: + case EnumType::kHardwareFailure: + case EnumType::kNetworkJammed: + return val; + default: + return static_cast(4); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(ThreadNetworkDiagnostics::RoutingRole val) +{ + using EnumType = ThreadNetworkDiagnostics::RoutingRole; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kUnspecified: + case EnumType::kUnassigned: + case EnumType::kSleepyEndDevice: + case EnumType::kEndDevice: + case EnumType::kReed: + case EnumType::kRouter: + case EnumType::kLeader: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_ROUTING_ROLE_UNSPECIFIED: + case EMBER_ZCL_ROUTING_ROLE_UNASSIGNED: + case EMBER_ZCL_ROUTING_ROLE_SLEEPY_END_DEVICE: + case EMBER_ZCL_ROUTING_ROLE_END_DEVICE: + case EMBER_ZCL_ROUTING_ROLE_REED: + case EMBER_ZCL_ROUTING_ROLE_ROUTER: + case EMBER_ZCL_ROUTING_ROLE_LEADER: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(7); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(ThreadNetworkDiagnostics::ThreadConnectionStatus val) +{ + using EnumType = ThreadNetworkDiagnostics::ThreadConnectionStatus; + switch (val) + { + case EnumType::kConnected: + case EnumType::kNotConnected: + return val; + default: + return static_cast(2); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(WiFiNetworkDiagnostics::AssociationFailureCause val) +{ + using EnumType = WiFiNetworkDiagnostics::AssociationFailureCause; + switch (val) + { + case EnumType::kUnknown: + case EnumType::kAssociationFailed: + case EnumType::kAuthenticationFailed: + case EnumType::kSsidNotFound: + return val; + default: + return static_cast(4); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(WiFiNetworkDiagnostics::SecurityType val) +{ + using EnumType = WiFiNetworkDiagnostics::SecurityType; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kUnspecified: + case EnumType::kNone: + case EnumType::kWep: + case EnumType::kWpa: + case EnumType::kWpa2: + case EnumType::kWpa3: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_SECURITY_TYPE_UNSPECIFIED: + case EMBER_ZCL_SECURITY_TYPE_NONE: + case EMBER_ZCL_SECURITY_TYPE_WEP: + case EMBER_ZCL_SECURITY_TYPE_WPA: + case EMBER_ZCL_SECURITY_TYPE_WPA2: + case EMBER_ZCL_SECURITY_TYPE_WPA3: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(6); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(WiFiNetworkDiagnostics::WiFiConnectionStatus val) +{ + using EnumType = WiFiNetworkDiagnostics::WiFiConnectionStatus; + switch (val) + { + case EnumType::kConnected: + case EnumType::kNotConnected: + return val; + default: + return static_cast(2); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(WiFiNetworkDiagnostics::WiFiVersionType val) +{ + using EnumType = WiFiNetworkDiagnostics::WiFiVersionType; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::k80211a: + case EnumType::k80211b: + case EnumType::k80211g: + case EnumType::k80211n: + case EnumType::k80211ac: + case EnumType::k80211ax: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_WI_FI_VERSION_TYPE_802__11A: + case EMBER_ZCL_WI_FI_VERSION_TYPE_802__11B: + case EMBER_ZCL_WI_FI_VERSION_TYPE_802__11G: + case EMBER_ZCL_WI_FI_VERSION_TYPE_802__11N: + case EMBER_ZCL_WI_FI_VERSION_TYPE_802__11AC: + case EMBER_ZCL_WI_FI_VERSION_TYPE_802__11AX: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(6); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(EthernetNetworkDiagnostics::PHYRateType val) +{ + using EnumType = EthernetNetworkDiagnostics::PHYRateType; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::k10m: + case EnumType::k100m: + case EnumType::k1000m: + case EnumType::k25g: + case EnumType::k5g: + case EnumType::k10g: + case EnumType::k40g: + case EnumType::k100g: + case EnumType::k200g: + case EnumType::k400g: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_PHY_RATE_TYPE_10_M: + case EMBER_ZCL_PHY_RATE_TYPE_100_M: + case EMBER_ZCL_PHY_RATE_TYPE_1000_M: + case EMBER_ZCL_PHY_RATE_TYPE_2__5_G: + case EMBER_ZCL_PHY_RATE_TYPE_5_G: + case EMBER_ZCL_PHY_RATE_TYPE_10_G: + case EMBER_ZCL_PHY_RATE_TYPE_40_G: + case EMBER_ZCL_PHY_RATE_TYPE_100_G: + case EMBER_ZCL_PHY_RATE_TYPE_200_G: + case EMBER_ZCL_PHY_RATE_TYPE_400_G: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(10); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(AdministratorCommissioning::CommissioningWindowStatus val) +{ + using EnumType = AdministratorCommissioning::CommissioningWindowStatus; + switch (val) + { + case EnumType::kWindowNotOpen: + case EnumType::kEnhancedWindowOpen: + case EnumType::kBasicWindowOpen: + return val; + default: + return static_cast(3); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(AdministratorCommissioning::StatusCode val) +{ + using EnumType = AdministratorCommissioning::StatusCode; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kBusy: + case EnumType::kPAKEParameterError: + case EnumType::kWindowNotOpen: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_STATUS_CODE_BUSY: + case EMBER_ZCL_STATUS_CODE_PAKE_PARAMETER_ERROR: + case EMBER_ZCL_STATUS_CODE_WINDOW_NOT_OPEN: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(0); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(OperationalCredentials::OperationalCertStatus val) +{ + using EnumType = OperationalCredentials::OperationalCertStatus; + switch (val) + { + case EnumType::kSuccess: + case EnumType::kInvalidPublicKey: + case EnumType::kInvalidNodeOpId: + case EnumType::kInvalidNOC: + case EnumType::kMissingCsr: + case EnumType::kTableFull: + case EnumType::kInvalidAdminSubject: + case EnumType::kInsufficientPrivilege: + case EnumType::kFabricConflict: + case EnumType::kLabelConflict: + case EnumType::kInvalidFabricIndex: + return val; + default: + return static_cast(7); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(GroupKeyManagement::GroupKeySecurityPolicy val) +{ + using EnumType = GroupKeyManagement::GroupKeySecurityPolicy; + switch (val) + { + case EnumType::kTrustFirst: + case EnumType::kCacheAndSync: + return val; + default: + return static_cast(2); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlAlarmCode val) +{ + using EnumType = DoorLock::DlAlarmCode; + switch (val) + { + case EnumType::kLockJammed: + case EnumType::kLockFactoryReset: + case EnumType::kLockRadioPowerCycled: + case EnumType::kWrongCodeEntryLimit: + case EnumType::kFrontEsceutcheonRemoved: + case EnumType::kDoorForcedOpen: + case EnumType::kDoorAjar: + case EnumType::kForcedUser: + return val; + default: + return static_cast(2); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlCredentialRule val) +{ + using EnumType = DoorLock::DlCredentialRule; + switch (val) + { + case EnumType::kSingle: + case EnumType::kDouble: + case EnumType::kTri: + return val; + default: + return static_cast(3); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlCredentialType val) +{ + using EnumType = DoorLock::DlCredentialType; + switch (val) + { + case EnumType::kProgrammingPIN: + case EnumType::kPin: + case EnumType::kRfid: + case EnumType::kFingerprint: + case EnumType::kFingerVein: + case EnumType::kFace: + return val; + default: + return static_cast(6); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlDataOperationType val) +{ + using EnumType = DoorLock::DlDataOperationType; + switch (val) + { + case EnumType::kAdd: + case EnumType::kClear: + case EnumType::kModify: + return val; + default: + return static_cast(3); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlDoorState val) +{ + using EnumType = DoorLock::DlDoorState; + switch (val) + { + case EnumType::kDoorOpen: + case EnumType::kDoorClosed: + case EnumType::kDoorJammed: + case EnumType::kDoorForcedOpen: + case EnumType::kDoorUnspecifiedError: + case EnumType::kDoorAjar: + return val; + default: + return static_cast(6); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlLockDataType val) +{ + using EnumType = DoorLock::DlLockDataType; + switch (val) + { + case EnumType::kUnspecified: + case EnumType::kProgrammingCode: + case EnumType::kUserIndex: + case EnumType::kWeekDaySchedule: + case EnumType::kYearDaySchedule: + case EnumType::kHolidaySchedule: + case EnumType::kPin: + case EnumType::kRfid: + case EnumType::kFingerprint: + return val; + default: + return static_cast(9); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlLockOperationType val) +{ + using EnumType = DoorLock::DlLockOperationType; + switch (val) + { + case EnumType::kLock: + case EnumType::kUnlock: + case EnumType::kNonAccessUserEvent: + case EnumType::kForcedUserEvent: + return val; + default: + return static_cast(4); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlLockState val) +{ + using EnumType = DoorLock::DlLockState; + switch (val) + { + case EnumType::kNotFullyLocked: + case EnumType::kLocked: + case EnumType::kUnlocked: + return val; + default: + return static_cast(3); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlLockType val) +{ + using EnumType = DoorLock::DlLockType; + switch (val) + { + case EnumType::kDeadBolt: + case EnumType::kMagnetic: + case EnumType::kOther: + case EnumType::kMortise: + case EnumType::kRim: + case EnumType::kLatchBolt: + case EnumType::kCylindricalLock: + case EnumType::kTubularLock: + case EnumType::kInterconnectedLock: + case EnumType::kDeadLatch: + case EnumType::kDoorFurniture: + return val; + default: + return static_cast(11); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlOperatingMode val) +{ + using EnumType = DoorLock::DlOperatingMode; + switch (val) + { + case EnumType::kNormal: + case EnumType::kVacation: + case EnumType::kPrivacy: + case EnumType::kNoRemoteLockUnlock: + case EnumType::kPassage: + return val; + default: + return static_cast(5); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlOperationError val) +{ + using EnumType = DoorLock::DlOperationError; + switch (val) + { + case EnumType::kUnspecified: + case EnumType::kInvalidCredential: + case EnumType::kDisabledUserDenied: + case EnumType::kRestricted: + case EnumType::kInsufficientBattery: + return val; + default: + return static_cast(5); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlOperationSource val) +{ + using EnumType = DoorLock::DlOperationSource; + switch (val) + { + case EnumType::kUnspecified: + case EnumType::kManual: + case EnumType::kProprietaryRemote: + case EnumType::kKeypad: + case EnumType::kAuto: + case EnumType::kButton: + case EnumType::kSchedule: + case EnumType::kRemote: + case EnumType::kRfid: + case EnumType::kBiometric: + return val; + default: + return static_cast(10); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlStatus val) +{ + using EnumType = DoorLock::DlStatus; + switch (val) + { + case EnumType::kSuccess: + case EnumType::kFailure: + case EnumType::kDuplicate: + case EnumType::kOccupied: + case EnumType::kInvalidField: + case EnumType::kResourceExhausted: + case EnumType::kNotFound: + return val; + default: + return static_cast(4); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlUserStatus val) +{ + using EnumType = DoorLock::DlUserStatus; + switch (val) + { + case EnumType::kAvailable: + case EnumType::kOccupiedEnabled: + case EnumType::kOccupiedDisabled: + return val; + default: + return static_cast(2); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DlUserType val) +{ + using EnumType = DoorLock::DlUserType; + switch (val) + { + case EnumType::kUnrestrictedUser: + case EnumType::kYearDayScheduleUser: + case EnumType::kWeekDayScheduleUser: + case EnumType::kProgrammingUser: + case EnumType::kNonAccessUser: + case EnumType::kForcedUser: + case EnumType::kDisposableUser: + case EnumType::kExpiringUser: + case EnumType::kScheduleRestrictedUser: + case EnumType::kRemoteOnlyUser: + return val; + default: + return static_cast(10); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DoorLockOperationEventCode val) +{ + using EnumType = DoorLock::DoorLockOperationEventCode; + switch (val) + { + case EnumType::kUnknownOrMfgSpecific: + case EnumType::kLock: + case EnumType::kUnlock: + case EnumType::kLockInvalidPinOrId: + case EnumType::kLockInvalidSchedule: + case EnumType::kUnlockInvalidPinOrId: + case EnumType::kUnlockInvalidSchedule: + case EnumType::kOneTouchLock: + case EnumType::kKeyLock: + case EnumType::kKeyUnlock: + case EnumType::kAutoLock: + case EnumType::kScheduleLock: + case EnumType::kScheduleUnlock: + case EnumType::kManualLock: + case EnumType::kManualUnlock: + return val; + default: + return static_cast(15); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DoorLockProgrammingEventCode val) +{ + using EnumType = DoorLock::DoorLockProgrammingEventCode; + switch (val) + { + case EnumType::kUnknownOrMfgSpecific: + case EnumType::kMasterCodeChanged: + case EnumType::kPinAdded: + case EnumType::kPinDeleted: + case EnumType::kPinChanged: + case EnumType::kIdAdded: + case EnumType::kIdDeleted: + return val; + default: + return static_cast(7); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DoorLockSetPinOrIdStatus val) +{ + using EnumType = DoorLock::DoorLockSetPinOrIdStatus; + switch (val) + { + case EnumType::kSuccess: + case EnumType::kGeneralFailure: + case EnumType::kMemoryFull: + case EnumType::kDuplicateCodeError: + return val; + default: + return static_cast(4); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DoorLockUserStatus val) +{ + using EnumType = DoorLock::DoorLockUserStatus; + switch (val) + { + case EnumType::kAvailable: + case EnumType::kOccupiedEnabled: + case EnumType::kOccupiedDisabled: + case EnumType::kNotSupported: + return val; + default: + return static_cast(2); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(DoorLock::DoorLockUserType val) +{ + using EnumType = DoorLock::DoorLockUserType; + switch (val) + { + case EnumType::kUnrestricted: + case EnumType::kYearDayScheduleUser: + case EnumType::kWeekDayScheduleUser: + case EnumType::kMasterUser: + case EnumType::kNonAccessUser: + case EnumType::kNotSupported: + return val; + default: + return static_cast(5); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(WindowCovering::EndProductType val) +{ + using EnumType = WindowCovering::EndProductType; + switch (val) + { + case EnumType::kRollerShade: + case EnumType::kRomanShade: + case EnumType::kBalloonShade: + case EnumType::kWovenWood: + case EnumType::kPleatedShade: + case EnumType::kCellularShade: + case EnumType::kLayeredShade: + case EnumType::kLayeredShade2D: + case EnumType::kSheerShade: + case EnumType::kTiltOnlyInteriorBlind: + case EnumType::kInteriorBlind: + case EnumType::kVerticalBlindStripCurtain: + case EnumType::kInteriorVenetianBlind: + case EnumType::kExteriorVenetianBlind: + case EnumType::kLateralLeftCurtain: + case EnumType::kLateralRightCurtain: + case EnumType::kCentralCurtain: + case EnumType::kRollerShutter: + case EnumType::kExteriorVerticalScreen: + case EnumType::kAwningTerracePatio: + case EnumType::kAwningVerticalScreen: + case EnumType::kTiltOnlyPergola: + case EnumType::kSwingingShutter: + case EnumType::kSlidingShutter: + case EnumType::kUnknown: + return val; + default: + return static_cast(24); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(WindowCovering::Type val) +{ + using EnumType = WindowCovering::Type; + switch (val) + { + case EnumType::kRollerShade: + case EnumType::kRollerShade2Motor: + case EnumType::kRollerShadeExterior: + case EnumType::kRollerShadeExterior2Motor: + case EnumType::kDrapery: + case EnumType::kAwning: + case EnumType::kShutter: + case EnumType::kTiltBlindTiltOnly: + case EnumType::kTiltBlindLiftAndTilt: + case EnumType::kProjectorScreen: + case EnumType::kUnknown: + return val; + default: + return static_cast(10); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(PumpConfigurationAndControl::PumpControlMode val) +{ + using EnumType = PumpConfigurationAndControl::PumpControlMode; + switch (val) + { + case EnumType::kConstantSpeed: + case EnumType::kConstantPressure: + case EnumType::kProportionalPressure: + case EnumType::kConstantFlow: + case EnumType::kConstantTemperature: + case EnumType::kAutomatic: + return val; + default: + return static_cast(4); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(PumpConfigurationAndControl::PumpOperationMode val) +{ + using EnumType = PumpConfigurationAndControl::PumpOperationMode; + switch (val) + { + case EnumType::kNormal: + case EnumType::kMinimum: + case EnumType::kMaximum: + case EnumType::kLocal: + return val; + default: + return static_cast(4); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::SetpointAdjustMode val) +{ + using EnumType = Thermostat::SetpointAdjustMode; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kHeatSetpoint: + case EnumType::kCoolSetpoint: + case EnumType::kHeatAndCoolSetpoints: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_SETPOINT_ADJUST_MODE_HEAT_SETPOINT: + case EMBER_ZCL_SETPOINT_ADJUST_MODE_COOL_SETPOINT: + case EMBER_ZCL_SETPOINT_ADJUST_MODE_HEAT_AND_COOL_SETPOINTS: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(3); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::ThermostatControlSequence val) +{ + using EnumType = Thermostat::ThermostatControlSequence; + switch (val) + { + case EnumType::kCoolingOnly: + case EnumType::kCoolingWithReheat: + case EnumType::kHeatingOnly: + case EnumType::kHeatingWithReheat: + case EnumType::kCoolingAndHeating: + case EnumType::kCoolingAndHeatingWithReheat: + return val; + default: + return static_cast(6); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::ThermostatRunningMode val) +{ + using EnumType = Thermostat::ThermostatRunningMode; + switch (val) + { + case EnumType::kOff: + case EnumType::kCool: + case EnumType::kHeat: + return val; + default: + return static_cast(1); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(Thermostat::ThermostatSystemMode val) +{ + using EnumType = Thermostat::ThermostatSystemMode; + switch (val) + { + case EnumType::kOff: + case EnumType::kAuto: + case EnumType::kCool: + case EnumType::kHeat: + case EnumType::kEmergencyHeating: + case EnumType::kPrecooling: + case EnumType::kFanOnly: + return val; + default: + return static_cast(2); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(FanControl::FanModeSequenceType val) +{ + using EnumType = FanControl::FanModeSequenceType; + switch (val) + { + case EnumType::kOffLowMedHigh: + case EnumType::kOffLowHigh: + case EnumType::kOffLowMedHighAuto: + case EnumType::kOffLowHighAuto: + case EnumType::kOffOnAuto: + case EnumType::kOffOn: + return val; + default: + return static_cast(6); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(FanControl::FanModeType val) +{ + using EnumType = FanControl::FanModeType; + switch (val) + { + case EnumType::kOff: + case EnumType::kLow: + case EnumType::kMedium: + case EnumType::kHigh: + case EnumType::kOn: + case EnumType::kAuto: + case EnumType::kSmart: + return val; + default: + return static_cast(7); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::ColorLoopAction val) +{ + using EnumType = ColorControl::ColorLoopAction; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kDeactivate: + case EnumType::kActivateFromColorLoopStartEnhancedHue: + case EnumType::kActivateFromEnhancedCurrentHue: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_COLOR_LOOP_ACTION_DEACTIVATE: + case EMBER_ZCL_COLOR_LOOP_ACTION_ACTIVATE_FROM_COLOR_LOOP_START_ENHANCED_HUE: + case EMBER_ZCL_COLOR_LOOP_ACTION_ACTIVATE_FROM_ENHANCED_CURRENT_HUE: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(3); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::ColorLoopDirection val) +{ + using EnumType = ColorControl::ColorLoopDirection; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kDecrementHue: + case EnumType::kIncrementHue: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_COLOR_LOOP_DIRECTION_DECREMENT_HUE: + case EMBER_ZCL_COLOR_LOOP_DIRECTION_INCREMENT_HUE: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(2); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::ColorMode val) +{ + using EnumType = ColorControl::ColorMode; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kCurrentHueAndCurrentSaturation: + case EnumType::kCurrentXAndCurrentY: + case EnumType::kColorTemperature: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_COLOR_MODE_CURRENT_HUE_AND_CURRENT_SATURATION: + case EMBER_ZCL_COLOR_MODE_CURRENT_X_AND_CURRENT_Y: + case EMBER_ZCL_COLOR_MODE_COLOR_TEMPERATURE: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(3); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::HueDirection val) +{ + using EnumType = ColorControl::HueDirection; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kShortestDistance: + case EnumType::kLongestDistance: + case EnumType::kUp: + case EnumType::kDown: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_HUE_DIRECTION_SHORTEST_DISTANCE: + case EMBER_ZCL_HUE_DIRECTION_LONGEST_DISTANCE: + case EMBER_ZCL_HUE_DIRECTION_UP: + case EMBER_ZCL_HUE_DIRECTION_DOWN: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(4); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::HueMoveMode val) +{ + using EnumType = ColorControl::HueMoveMode; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kStop: + case EnumType::kUp: + case EnumType::kDown: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_HUE_MOVE_MODE_STOP: + case EMBER_ZCL_HUE_MOVE_MODE_UP: + case EMBER_ZCL_HUE_MOVE_MODE_DOWN: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(2); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::HueStepMode val) +{ + using EnumType = ColorControl::HueStepMode; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kUp: + case EnumType::kDown: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_HUE_STEP_MODE_UP: + case EMBER_ZCL_HUE_STEP_MODE_DOWN: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(0); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::SaturationMoveMode val) +{ + using EnumType = ColorControl::SaturationMoveMode; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kStop: + case EnumType::kUp: + case EnumType::kDown: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_SATURATION_MOVE_MODE_STOP: + case EMBER_ZCL_SATURATION_MOVE_MODE_UP: + case EMBER_ZCL_SATURATION_MOVE_MODE_DOWN: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(2); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(ColorControl::SaturationStepMode val) +{ + using EnumType = ColorControl::SaturationStepMode; + switch (val) + { +// Need to convert consumers to using the new enum classes, so we +// don't just have casts all over. +#ifdef CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EnumType::kUp: + case EnumType::kDown: +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + case EMBER_ZCL_SATURATION_STEP_MODE_UP: + case EMBER_ZCL_SATURATION_STEP_MODE_DOWN: +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM + return val; + default: + return static_cast(0); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(IlluminanceMeasurement::LightSensorType val) +{ + using EnumType = IlluminanceMeasurement::LightSensorType; + switch (val) + { + case EnumType::kPhotodiode: + case EnumType::kCmos: + return val; + default: + return static_cast(2); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(Channel::ChannelStatusEnum val) +{ + using EnumType = Channel::ChannelStatusEnum; + switch (val) + { + case EnumType::kSuccess: + case EnumType::kMultipleMatches: + case EnumType::kNoMatches: + return val; + default: + return static_cast(3); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(Channel::LineupInfoTypeEnum val) +{ + using EnumType = Channel::LineupInfoTypeEnum; + switch (val) + { + case EnumType::kMso: + return val; + default: + return static_cast(1); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(TargetNavigator::TargetNavigatorStatusEnum val) +{ + using EnumType = TargetNavigator::TargetNavigatorStatusEnum; + switch (val) + { + case EnumType::kSuccess: + case EnumType::kTargetNotFound: + case EnumType::kNotAllowed: + return val; + default: + return static_cast(3); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(MediaPlayback::MediaPlaybackStatusEnum val) +{ + using EnumType = MediaPlayback::MediaPlaybackStatusEnum; + switch (val) + { + case EnumType::kSuccess: + case EnumType::kInvalidStateForCommand: + case EnumType::kNotAllowed: + case EnumType::kNotActive: + case EnumType::kSpeedOutOfRange: + case EnumType::kSeekOutOfRange: + return val; + default: + return static_cast(6); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(MediaPlayback::PlaybackStateEnum val) +{ + using EnumType = MediaPlayback::PlaybackStateEnum; + switch (val) + { + case EnumType::kPlaying: + case EnumType::kPaused: + case EnumType::kNotPlaying: + case EnumType::kBuffering: + return val; + default: + return static_cast(4); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(MediaInput::InputTypeEnum val) +{ + using EnumType = MediaInput::InputTypeEnum; + switch (val) + { + case EnumType::kInternal: + case EnumType::kAux: + case EnumType::kCoax: + case EnumType::kComposite: + case EnumType::kHdmi: + case EnumType::kInput: + case EnumType::kLine: + case EnumType::kOptical: + case EnumType::kVideo: + case EnumType::kScart: + case EnumType::kUsb: + case EnumType::kOther: + return val; + default: + return static_cast(12); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(KeypadInput::CecKeyCode val) +{ + using EnumType = KeypadInput::CecKeyCode; + switch (val) + { + case EnumType::kSelect: + case EnumType::kUp: + case EnumType::kDown: + case EnumType::kLeft: + case EnumType::kRight: + case EnumType::kRightUp: + case EnumType::kRightDown: + case EnumType::kLeftUp: + case EnumType::kLeftDown: + case EnumType::kRootMenu: + case EnumType::kSetupMenu: + case EnumType::kContentsMenu: + case EnumType::kFavoriteMenu: + case EnumType::kExit: + case EnumType::kMediaTopMenu: + case EnumType::kMediaContextSensitiveMenu: + case EnumType::kNumberEntryMode: + case EnumType::kNumber11: + case EnumType::kNumber12: + case EnumType::kNumber0OrNumber10: + case EnumType::kNumbers1: + case EnumType::kNumbers2: + case EnumType::kNumbers3: + case EnumType::kNumbers4: + case EnumType::kNumbers5: + case EnumType::kNumbers6: + case EnumType::kNumbers7: + case EnumType::kNumbers8: + case EnumType::kNumbers9: + case EnumType::kDot: + case EnumType::kEnter: + case EnumType::kClear: + case EnumType::kNextFavorite: + case EnumType::kChannelUp: + case EnumType::kChannelDown: + case EnumType::kPreviousChannel: + case EnumType::kSoundSelect: + case EnumType::kInputSelect: + case EnumType::kDisplayInformation: + case EnumType::kHelp: + case EnumType::kPageUp: + case EnumType::kPageDown: + case EnumType::kPower: + case EnumType::kVolumeUp: + case EnumType::kVolumeDown: + case EnumType::kMute: + case EnumType::kPlay: + case EnumType::kStop: + case EnumType::kPause: + case EnumType::kRecord: + case EnumType::kRewind: + case EnumType::kFastForward: + case EnumType::kEject: + case EnumType::kForward: + case EnumType::kBackward: + case EnumType::kStopRecord: + case EnumType::kPauseRecord: + case EnumType::kReserved: + case EnumType::kAngle: + case EnumType::kSubPicture: + case EnumType::kVideoOnDemand: + case EnumType::kElectronicProgramGuide: + case EnumType::kTimerProgramming: + case EnumType::kInitialConfiguration: + case EnumType::kSelectBroadcastType: + case EnumType::kSelectSoundPresentation: + case EnumType::kPlayFunction: + case EnumType::kPausePlayFunction: + case EnumType::kRecordFunction: + case EnumType::kPauseRecordFunction: + case EnumType::kStopFunction: + case EnumType::kMuteFunction: + case EnumType::kRestoreVolumeFunction: + case EnumType::kTuneFunction: + case EnumType::kSelectMediaFunction: + case EnumType::kSelectAvInputFunction: + case EnumType::kSelectAudioInputFunction: + case EnumType::kPowerToggleFunction: + case EnumType::kPowerOffFunction: + case EnumType::kPowerOnFunction: + case EnumType::kF1Blue: + case EnumType::kF2Red: + case EnumType::kF3Green: + case EnumType::kF4Yellow: + case EnumType::kF5: + case EnumType::kData: + return val; + default: + return static_cast(14); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(KeypadInput::KeypadInputStatusEnum val) +{ + using EnumType = KeypadInput::KeypadInputStatusEnum; + switch (val) + { + case EnumType::kSuccess: + case EnumType::kUnsupportedKey: + case EnumType::kInvalidKeyInCurrentState: + return val; + default: + return static_cast(3); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(ContentLauncher::ContentLaunchStatusEnum val) +{ + using EnumType = ContentLauncher::ContentLaunchStatusEnum; + switch (val) + { + case EnumType::kSuccess: + case EnumType::kUrlNotAvailable: + case EnumType::kAuthFailed: + return val; + default: + return static_cast(3); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(ContentLauncher::MetricTypeEnum val) +{ + using EnumType = ContentLauncher::MetricTypeEnum; + switch (val) + { + case EnumType::kPixels: + case EnumType::kPercentage: + return val; + default: + return static_cast(2); + } +} +static auto __attribute__((unused)) EnsureKnownEnumValue(ContentLauncher::ParameterEnum val) +{ + using EnumType = ContentLauncher::ParameterEnum; + switch (val) + { + case EnumType::kActor: + case EnumType::kChannel: + case EnumType::kCharacter: + case EnumType::kDirector: + case EnumType::kEvent: + case EnumType::kFranchise: + case EnumType::kGenre: + case EnumType::kLeague: + case EnumType::kPopularity: + case EnumType::kProvider: + case EnumType::kSport: + case EnumType::kSportsTeam: + case EnumType::kType: + return val; + default: + return static_cast(13); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(AudioOutput::OutputTypeEnum val) +{ + using EnumType = AudioOutput::OutputTypeEnum; + switch (val) + { + case EnumType::kHdmi: + case EnumType::kBt: + case EnumType::kOptical: + case EnumType::kHeadphone: + case EnumType::kInternal: + case EnumType::kOther: + return val; + default: + return static_cast(6); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(ApplicationLauncher::ApplicationLauncherStatusEnum val) +{ + using EnumType = ApplicationLauncher::ApplicationLauncherStatusEnum; + switch (val) + { + case EnumType::kSuccess: + case EnumType::kAppNotAvailable: + case EnumType::kSystemBusy: + return val; + default: + return static_cast(3); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(ApplicationBasic::ApplicationStatusEnum val) +{ + using EnumType = ApplicationBasic::ApplicationStatusEnum; + switch (val) + { + case EnumType::kStopped: + case EnumType::kActiveVisibleFocus: + case EnumType::kActiveHidden: + case EnumType::kActiveVisibleNotFocus: + return val; + default: + return static_cast(4); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(ApplianceEventsAndAlert::EventIdentification val) +{ + using EnumType = ApplianceEventsAndAlert::EventIdentification; + switch (val) + { + case EnumType::kEndOfCycle: + case EnumType::kTemperatureReached: + case EnumType::kEndOfCooking: + case EnumType::kSwitchingOff: + case EnumType::kWrongData: + return val; + default: + return static_cast(0); + } +} + +static auto __attribute__((unused)) EnsureKnownEnumValue(TestCluster::SimpleEnum val) +{ + using EnumType = TestCluster::SimpleEnum; + switch (val) + { + case EnumType::kUnspecified: + case EnumType::kValueA: + case EnumType::kValueB: + case EnumType::kValueC: + return val; + default: + return static_cast(4); + } +} + +} // namespace Clusters +} // namespace app +} // namespace chip diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h b/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h index ebf0648f0fba01..a8e43a189efa96 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-enums.h @@ -48,9 +48,10 @@ enum class IdentifyEffectIdentifier : uint8_t kFinishEffect = 0xFE, kStopEffect = 0xFF, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using IdentifyEffectIdentifier = EmberAfIdentifyEffectIdentifier; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static IdentifyEffectIdentifier kIdentifyEffectIdentifierFirstUnusedEnumVal = static_cast(3); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -60,9 +61,10 @@ enum class IdentifyEffectVariant : uint8_t { kDefault = 0x00, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using IdentifyEffectVariant = EmberAfIdentifyEffectVariant; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static IdentifyEffectVariant kIdentifyEffectVariantFirstUnusedEnumVal = static_cast(1); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -77,9 +79,10 @@ enum class IdentifyIdentifyType : uint8_t kDisplay = 0x04, kActuator = 0x05, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using IdentifyIdentifyType = EmberAfIdentifyIdentifyType; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static IdentifyIdentifyType kIdentifyIdentifyTypeFirstUnusedEnumVal = static_cast(6); } // namespace Identify namespace Groups { @@ -112,9 +115,11 @@ enum class OnOffDelayedAllOffEffectVariant : uint8_t kNoFade = 0x01, k50PercentDimDownIn0p8SecondsThenFadeToOffIn12Seconds = 0x02, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using OnOffDelayedAllOffEffectVariant = EmberAfOnOffDelayedAllOffEffectVariant; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static OnOffDelayedAllOffEffectVariant kOnOffDelayedAllOffEffectVariantFirstUnusedEnumVal = + static_cast(3); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -124,9 +129,10 @@ enum class OnOffDyingLightEffectVariant : uint8_t { k20PercenterDimUpIn0p5SecondsThenFadeToOffIn1Second = 0x00, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using OnOffDyingLightEffectVariant = EmberAfOnOffDyingLightEffectVariant; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static OnOffDyingLightEffectVariant kOnOffDyingLightEffectVariantFirstUnusedEnumVal = static_cast(1); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -137,9 +143,10 @@ enum class OnOffEffectIdentifier : uint8_t kDelayedAllOff = 0x00, kDyingLight = 0x01, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using OnOffEffectIdentifier = EmberAfOnOffEffectIdentifier; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static OnOffEffectIdentifier kOnOffEffectIdentifierFirstUnusedEnumVal = static_cast(2); // Enum for OnOffStartUpOnOff enum class OnOffStartUpOnOff : uint8_t @@ -148,6 +155,7 @@ enum class OnOffStartUpOnOff : uint8_t kOn = 0x01, kTogglePreviousOnOff = 0x02, }; +static OnOffStartUpOnOff kOnOffStartUpOnOffFirstUnusedEnumVal = static_cast(3); // Bitmap for OnOffControl enum class OnOffControl : uint8_t @@ -182,9 +190,10 @@ enum class MoveMode : uint8_t kUp = 0x00, kDown = 0x01, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using MoveMode = EmberAfMoveMode; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static MoveMode kMoveModeFirstUnusedEnumVal = static_cast(2); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -195,9 +204,10 @@ enum class StepMode : uint8_t kUp = 0x00, kDown = 0x01, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using StepMode = EmberAfStepMode; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static StepMode kStepModeFirstUnusedEnumVal = static_cast(2); // Bitmap for LevelControlFeature enum class LevelControlFeature : uint32_t @@ -241,6 +251,7 @@ enum class ApplianceStatus : uint8_t kSupercooling = 0x0E, kSuperheating = 0x0F, }; +static ApplianceStatus kApplianceStatusFirstUnusedEnumVal = static_cast(0); // Enum for CommandIdentification enum class CommandIdentification : uint8_t @@ -257,6 +268,7 @@ enum class CommandIdentification : uint8_t kEnableEnergyControl = 0x0A, kDisableEnergyControl = 0x0B, }; +static CommandIdentification kCommandIdentificationFirstUnusedEnumVal = static_cast(0); // Enum for WarningEvent enum class WarningEvent : uint8_t @@ -267,6 +279,7 @@ enum class WarningEvent : uint8_t kWarning4OverallPowerBackBelowThePowerThresholdLevel = 0x03, kWarning5OverallPowerWillBePotentiallyAboveAvailablePowerLevelIfTheApplianceStarts = 0x04, }; +static WarningEvent kWarningEventFirstUnusedEnumVal = static_cast(5); // Bitmap for RemoteEnableFlagsAndDeviceStatus2 enum class RemoteEnableFlagsAndDeviceStatus2 : uint8_t @@ -294,6 +307,7 @@ enum class AuthMode : uint8_t kCase = 0x02, kGroup = 0x03, }; +static AuthMode kAuthModeFirstUnusedEnumVal = static_cast(0); // Enum for ChangeTypeEnum enum class ChangeTypeEnum : uint8_t @@ -302,6 +316,7 @@ enum class ChangeTypeEnum : uint8_t kAdded = 0x01, kRemoved = 0x02, }; +static ChangeTypeEnum kChangeTypeEnumFirstUnusedEnumVal = static_cast(3); // Enum for Privilege enum class Privilege : uint8_t @@ -312,6 +327,7 @@ enum class Privilege : uint8_t kManage = 0x04, kAdminister = 0x05, }; +static Privilege kPrivilegeFirstUnusedEnumVal = static_cast(0); } // namespace AccessControl namespace PollControl { @@ -325,6 +341,7 @@ enum class ActionErrorEnum : uint8_t kUnknown = 0x00, kInterrupted = 0x01, }; +static ActionErrorEnum kActionErrorEnumFirstUnusedEnumVal = static_cast(2); // Enum for ActionStateEnum enum class ActionStateEnum : uint8_t @@ -334,6 +351,7 @@ enum class ActionStateEnum : uint8_t kPaused = 0x02, kDisabled = 0x03, }; +static ActionStateEnum kActionStateEnumFirstUnusedEnumVal = static_cast(4); // Enum for ActionTypeEnum enum class ActionTypeEnum : uint8_t @@ -346,6 +364,7 @@ enum class ActionTypeEnum : uint8_t kNotification = 0x05, kAlarm = 0x06, }; +static ActionTypeEnum kActionTypeEnumFirstUnusedEnumVal = static_cast(7); // Enum for EndpointListTypeEnum enum class EndpointListTypeEnum : uint8_t @@ -354,6 +373,7 @@ enum class EndpointListTypeEnum : uint8_t kRoom = 0x01, kZone = 0x02, }; +static EndpointListTypeEnum kEndpointListTypeEnumFirstUnusedEnumVal = static_cast(3); // Bitmap for CommandBits enum class CommandBits : uint16_t @@ -385,6 +405,7 @@ enum class OTAApplyUpdateAction : uint8_t kAwaitNextAction = 0x01, kDiscontinue = 0x02, }; +static OTAApplyUpdateAction kOTAApplyUpdateActionFirstUnusedEnumVal = static_cast(3); // Enum for OTADownloadProtocol enum class OTADownloadProtocol : uint8_t @@ -394,6 +415,7 @@ enum class OTADownloadProtocol : uint8_t kHttps = 0x02, kVendorSpecific = 0x03, }; +static OTADownloadProtocol kOTADownloadProtocolFirstUnusedEnumVal = static_cast(4); // Enum for OTAQueryStatus enum class OTAQueryStatus : uint8_t @@ -403,6 +425,7 @@ enum class OTAQueryStatus : uint8_t kNotAvailable = 0x02, kDownloadProtocolNotSupported = 0x03, }; +static OTAQueryStatus kOTAQueryStatusFirstUnusedEnumVal = static_cast(4); } // namespace OtaSoftwareUpdateProvider namespace OtaSoftwareUpdateRequestor { @@ -414,6 +437,7 @@ enum class OTAAnnouncementReason : uint8_t kUpdateAvailable = 0x01, kUrgentUpdateAvailable = 0x02, }; +static OTAAnnouncementReason kOTAAnnouncementReasonFirstUnusedEnumVal = static_cast(3); // Enum for OTAChangeReasonEnum enum class OTAChangeReasonEnum : uint8_t @@ -424,6 +448,7 @@ enum class OTAChangeReasonEnum : uint8_t kTimeOut = 0x03, kDelayByProvider = 0x04, }; +static OTAChangeReasonEnum kOTAChangeReasonEnumFirstUnusedEnumVal = static_cast(5); // Enum for OTAUpdateStateEnum enum class OTAUpdateStateEnum : uint8_t @@ -438,6 +463,7 @@ enum class OTAUpdateStateEnum : uint8_t kRollingBack = 0x07, kDelayedOnUserConsent = 0x08, }; +static OTAUpdateStateEnum kOTAUpdateStateEnumFirstUnusedEnumVal = static_cast(9); } // namespace OtaSoftwareUpdateRequestor namespace LocalizationConfiguration { @@ -461,6 +487,7 @@ enum class CalendarType : uint8_t kPersian = 0x0A, kTaiwanese = 0x0B, }; +static CalendarType kCalendarTypeFirstUnusedEnumVal = static_cast(12); // Enum for HourFormat enum class HourFormat : uint8_t @@ -468,6 +495,7 @@ enum class HourFormat : uint8_t k12hr = 0x00, k24hr = 0x01, }; +static HourFormat kHourFormatFirstUnusedEnumVal = static_cast(2); } // namespace TimeFormatLocalization namespace UnitLocalization { @@ -479,6 +507,7 @@ enum class TempUnit : uint8_t kCelsius = 0x01, kKelvin = 0x02, }; +static TempUnit kTempUnitFirstUnusedEnumVal = static_cast(3); // Bitmap for UnitLocalizationFeature enum class UnitLocalizationFeature : uint32_t @@ -507,6 +536,7 @@ enum class BatChargeFault : uint8_t kChargerUnderVoltage = 0x09, kSafetyTimeout = 0x0A, }; +static BatChargeFault kBatChargeFaultFirstUnusedEnumVal = static_cast(11); // Enum for BatChargeLevel enum class BatChargeLevel : uint8_t @@ -515,6 +545,7 @@ enum class BatChargeLevel : uint8_t kWarning = 0x01, kCritical = 0x02, }; +static BatChargeLevel kBatChargeLevelFirstUnusedEnumVal = static_cast(3); // Enum for BatChargeState enum class BatChargeState : uint8_t @@ -524,6 +555,7 @@ enum class BatChargeState : uint8_t kIsAtFullCharge = 0x02, kIsNotCharging = 0x03, }; +static BatChargeState kBatChargeStateFirstUnusedEnumVal = static_cast(4); // Enum for BatFault enum class BatFault : uint8_t @@ -532,6 +564,7 @@ enum class BatFault : uint8_t kOverTemp = 0x01, kUnderTemp = 0x02, }; +static BatFault kBatFaultFirstUnusedEnumVal = static_cast(3); // Enum for BatReplaceability enum class BatReplaceability : uint8_t @@ -541,6 +574,7 @@ enum class BatReplaceability : uint8_t kUserReplaceable = 0x02, kFactoryReplaceable = 0x03, }; +static BatReplaceability kBatReplaceabilityFirstUnusedEnumVal = static_cast(4); // Enum for PowerSourceStatus enum class PowerSourceStatus : uint8_t @@ -550,6 +584,7 @@ enum class PowerSourceStatus : uint8_t kStandby = 0x02, kUnavailable = 0x03, }; +static PowerSourceStatus kPowerSourceStatusFirstUnusedEnumVal = static_cast(4); // Enum for WiredCurrentType enum class WiredCurrentType : uint8_t @@ -557,6 +592,7 @@ enum class WiredCurrentType : uint8_t kAc = 0x00, kDc = 0x01, }; +static WiredCurrentType kWiredCurrentTypeFirstUnusedEnumVal = static_cast(2); // Enum for WiredFault enum class WiredFault : uint8_t @@ -565,6 +601,7 @@ enum class WiredFault : uint8_t kOverVoltage = 0x01, kUnderVoltage = 0x02, }; +static WiredFault kWiredFaultFirstUnusedEnumVal = static_cast(3); // Bitmap for PowerSourceFeature enum class PowerSourceFeature : uint32_t @@ -587,6 +624,7 @@ enum class CommissioningError : uint8_t kNoFailSafe = 0x03, kBusyWithOtherAdmin = 0x04, }; +static CommissioningError kCommissioningErrorFirstUnusedEnumVal = static_cast(5); // Enum for RegulatoryLocationType enum class RegulatoryLocationType : uint8_t @@ -595,6 +633,7 @@ enum class RegulatoryLocationType : uint8_t kOutdoor = 0x01, kIndoorOutdoor = 0x02, }; +static RegulatoryLocationType kRegulatoryLocationTypeFirstUnusedEnumVal = static_cast(3); } // namespace GeneralCommissioning namespace NetworkCommissioning { @@ -616,6 +655,7 @@ enum class NetworkCommissioningStatus : uint8_t kIPBindFailed = 0x0B, kUnknownError = 0x0C, }; +static NetworkCommissioningStatus kNetworkCommissioningStatusFirstUnusedEnumVal = static_cast(13); // Enum for WiFiBand enum class WiFiBand : uint8_t @@ -626,6 +666,7 @@ enum class WiFiBand : uint8_t k6g = 0x03, k60g = 0x04, }; +static WiFiBand kWiFiBandFirstUnusedEnumVal = static_cast(5); // Bitmap for NetworkCommissioningFeature enum class NetworkCommissioningFeature : uint32_t @@ -655,6 +696,7 @@ enum class LogsIntent : uint8_t kNetworkDiag = 0x01, kCrashLogs = 0x02, }; +static LogsIntent kLogsIntentFirstUnusedEnumVal = static_cast(3); // Enum for LogsStatus enum class LogsStatus : uint8_t @@ -665,6 +707,7 @@ enum class LogsStatus : uint8_t kBusy = 0x03, kDenied = 0x04, }; +static LogsStatus kLogsStatusFirstUnusedEnumVal = static_cast(5); // Enum for LogsTransferProtocol enum class LogsTransferProtocol : uint8_t @@ -672,6 +715,7 @@ enum class LogsTransferProtocol : uint8_t kResponsePayload = 0x00, kBdx = 0x01, }; +static LogsTransferProtocol kLogsTransferProtocolFirstUnusedEnumVal = static_cast(2); } // namespace DiagnosticLogs namespace GeneralDiagnostics { @@ -687,6 +731,7 @@ enum class BootReasonType : uint8_t kSoftwareUpdateCompleted = 0x05, kSoftwareReset = 0x06, }; +static BootReasonType kBootReasonTypeFirstUnusedEnumVal = static_cast(7); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -706,9 +751,10 @@ enum class HardwareFaultType : uint8_t kNonVolatileMemoryError = 0x09, kTamperDetected = 0x0A, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using HardwareFaultType = EmberAfHardwareFaultType; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static HardwareFaultType kHardwareFaultTypeFirstUnusedEnumVal = static_cast(11); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -722,9 +768,10 @@ enum class InterfaceType : uint8_t kCellular = 0x03, kThread = 0x04, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using InterfaceType = EmberAfInterfaceType; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static InterfaceType kInterfaceTypeFirstUnusedEnumVal = static_cast(5); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -737,9 +784,10 @@ enum class NetworkFaultType : uint8_t kNetworkJammed = 0x02, kConnectionFailed = 0x03, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using NetworkFaultType = EmberAfNetworkFaultType; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static NetworkFaultType kNetworkFaultTypeFirstUnusedEnumVal = static_cast(4); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -755,9 +803,10 @@ enum class RadioFaultType : uint8_t kBLEFault = 0x05, kEthernetFault = 0x06, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using RadioFaultType = EmberAfRadioFaultType; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static RadioFaultType kRadioFaultTypeFirstUnusedEnumVal = static_cast(7); } // namespace GeneralDiagnostics namespace SoftwareDiagnostics { @@ -779,6 +828,7 @@ enum class NetworkFault : uint8_t kHardwareFailure = 0x02, kNetworkJammed = 0x03, }; +static NetworkFault kNetworkFaultFirstUnusedEnumVal = static_cast(4); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -794,9 +844,10 @@ enum class RoutingRole : uint8_t kRouter = 0x05, kLeader = 0x06, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using RoutingRole = EmberAfRoutingRole; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static RoutingRole kRoutingRoleFirstUnusedEnumVal = static_cast(7); // Enum for ThreadConnectionStatus enum class ThreadConnectionStatus : uint8_t @@ -804,6 +855,7 @@ enum class ThreadConnectionStatus : uint8_t kConnected = 0x00, kNotConnected = 0x01, }; +static ThreadConnectionStatus kThreadConnectionStatusFirstUnusedEnumVal = static_cast(2); // Bitmap for ThreadNetworkDiagnosticsFeature enum class ThreadNetworkDiagnosticsFeature : uint32_t @@ -825,6 +877,7 @@ enum class AssociationFailureCause : uint8_t kAuthenticationFailed = 0x02, kSsidNotFound = 0x03, }; +static AssociationFailureCause kAssociationFailureCauseFirstUnusedEnumVal = static_cast(4); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -839,9 +892,10 @@ enum class SecurityType : uint8_t kWpa2 = 0x04, kWpa3 = 0x05, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using SecurityType = EmberAfSecurityType; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static SecurityType kSecurityTypeFirstUnusedEnumVal = static_cast(6); // Enum for WiFiConnectionStatus enum class WiFiConnectionStatus : uint8_t @@ -849,6 +903,7 @@ enum class WiFiConnectionStatus : uint8_t kConnected = 0x00, kNotConnected = 0x01, }; +static WiFiConnectionStatus kWiFiConnectionStatusFirstUnusedEnumVal = static_cast(2); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -863,9 +918,10 @@ enum class WiFiVersionType : uint8_t k80211ac = 0x04, k80211ax = 0x05, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using WiFiVersionType = EmberAfWiFiVersionType; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static WiFiVersionType kWiFiVersionTypeFirstUnusedEnumVal = static_cast(6); } // namespace WiFiNetworkDiagnostics namespace EthernetNetworkDiagnostics { @@ -887,9 +943,10 @@ enum class PHYRateType : uint8_t k200g = 0x08, k400g = 0x09, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using PHYRateType = EmberAfPHYRateType; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static PHYRateType kPHYRateTypeFirstUnusedEnumVal = static_cast(10); } // namespace EthernetNetworkDiagnostics namespace TimeSynchronization { @@ -910,6 +967,7 @@ enum class CommissioningWindowStatus : uint8_t kEnhancedWindowOpen = 0x01, kBasicWindowOpen = 0x02, }; +static CommissioningWindowStatus kCommissioningWindowStatusFirstUnusedEnumVal = static_cast(3); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -921,9 +979,10 @@ enum class StatusCode : uint8_t kPAKEParameterError = 0x02, kWindowNotOpen = 0x03, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using StatusCode = EmberAfStatusCode; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static StatusCode kStatusCodeFirstUnusedEnumVal = static_cast(0); } // namespace AdministratorCommissioning namespace OperationalCredentials { @@ -943,6 +1002,7 @@ enum class OperationalCertStatus : uint8_t kLabelConflict = 0x0A, kInvalidFabricIndex = 0x0B, }; +static OperationalCertStatus kOperationalCertStatusFirstUnusedEnumVal = static_cast(7); } // namespace OperationalCredentials namespace GroupKeyManagement { @@ -953,6 +1013,7 @@ enum class GroupKeySecurityPolicy : uint8_t kTrustFirst = 0x00, kCacheAndSync = 0x01, }; +static GroupKeySecurityPolicy kGroupKeySecurityPolicyFirstUnusedEnumVal = static_cast(2); } // namespace GroupKeyManagement namespace FixedLabel { @@ -999,6 +1060,7 @@ enum class DlAlarmCode : uint8_t kDoorAjar = 0x07, kForcedUser = 0x08, }; +static DlAlarmCode kDlAlarmCodeFirstUnusedEnumVal = static_cast(2); // Enum for DlCredentialRule enum class DlCredentialRule : uint8_t @@ -1007,6 +1069,7 @@ enum class DlCredentialRule : uint8_t kDouble = 0x01, kTri = 0x02, }; +static DlCredentialRule kDlCredentialRuleFirstUnusedEnumVal = static_cast(3); // Enum for DlCredentialType enum class DlCredentialType : uint8_t @@ -1018,6 +1081,7 @@ enum class DlCredentialType : uint8_t kFingerVein = 0x04, kFace = 0x05, }; +static DlCredentialType kDlCredentialTypeFirstUnusedEnumVal = static_cast(6); // Enum for DlDataOperationType enum class DlDataOperationType : uint8_t @@ -1026,6 +1090,7 @@ enum class DlDataOperationType : uint8_t kClear = 0x01, kModify = 0x02, }; +static DlDataOperationType kDlDataOperationTypeFirstUnusedEnumVal = static_cast(3); // Enum for DlDoorState enum class DlDoorState : uint8_t @@ -1037,6 +1102,7 @@ enum class DlDoorState : uint8_t kDoorUnspecifiedError = 0x04, kDoorAjar = 0x05, }; +static DlDoorState kDlDoorStateFirstUnusedEnumVal = static_cast(6); // Enum for DlLockDataType enum class DlLockDataType : uint8_t @@ -1051,6 +1117,7 @@ enum class DlLockDataType : uint8_t kRfid = 0x07, kFingerprint = 0x08, }; +static DlLockDataType kDlLockDataTypeFirstUnusedEnumVal = static_cast(9); // Enum for DlLockOperationType enum class DlLockOperationType : uint8_t @@ -1060,6 +1127,7 @@ enum class DlLockOperationType : uint8_t kNonAccessUserEvent = 0x02, kForcedUserEvent = 0x03, }; +static DlLockOperationType kDlLockOperationTypeFirstUnusedEnumVal = static_cast(4); // Enum for DlLockState enum class DlLockState : uint8_t @@ -1068,6 +1136,7 @@ enum class DlLockState : uint8_t kLocked = 0x01, kUnlocked = 0x02, }; +static DlLockState kDlLockStateFirstUnusedEnumVal = static_cast(3); // Enum for DlLockType enum class DlLockType : uint8_t @@ -1084,6 +1153,7 @@ enum class DlLockType : uint8_t kDeadLatch = 0x09, kDoorFurniture = 0x0A, }; +static DlLockType kDlLockTypeFirstUnusedEnumVal = static_cast(11); // Enum for DlOperatingMode enum class DlOperatingMode : uint8_t @@ -1094,6 +1164,7 @@ enum class DlOperatingMode : uint8_t kNoRemoteLockUnlock = 0x03, kPassage = 0x04, }; +static DlOperatingMode kDlOperatingModeFirstUnusedEnumVal = static_cast(5); // Enum for DlOperationError enum class DlOperationError : uint8_t @@ -1104,6 +1175,7 @@ enum class DlOperationError : uint8_t kRestricted = 0x03, kInsufficientBattery = 0x04, }; +static DlOperationError kDlOperationErrorFirstUnusedEnumVal = static_cast(5); // Enum for DlOperationSource enum class DlOperationSource : uint8_t @@ -1119,6 +1191,7 @@ enum class DlOperationSource : uint8_t kRfid = 0x08, kBiometric = 0x09, }; +static DlOperationSource kDlOperationSourceFirstUnusedEnumVal = static_cast(10); // Enum for DlStatus enum class DlStatus : uint8_t @@ -1131,6 +1204,7 @@ enum class DlStatus : uint8_t kResourceExhausted = 0x89, kNotFound = 0x8B, }; +static DlStatus kDlStatusFirstUnusedEnumVal = static_cast(4); // Enum for DlUserStatus enum class DlUserStatus : uint8_t @@ -1139,6 +1213,7 @@ enum class DlUserStatus : uint8_t kOccupiedEnabled = 0x01, kOccupiedDisabled = 0x03, }; +static DlUserStatus kDlUserStatusFirstUnusedEnumVal = static_cast(2); // Enum for DlUserType enum class DlUserType : uint8_t @@ -1154,6 +1229,7 @@ enum class DlUserType : uint8_t kScheduleRestrictedUser = 0x08, kRemoteOnlyUser = 0x09, }; +static DlUserType kDlUserTypeFirstUnusedEnumVal = static_cast(10); // Enum for DoorLockOperationEventCode enum class DoorLockOperationEventCode : uint8_t @@ -1174,6 +1250,7 @@ enum class DoorLockOperationEventCode : uint8_t kManualLock = 0x0D, kManualUnlock = 0x0E, }; +static DoorLockOperationEventCode kDoorLockOperationEventCodeFirstUnusedEnumVal = static_cast(15); // Enum for DoorLockProgrammingEventCode enum class DoorLockProgrammingEventCode : uint8_t @@ -1186,6 +1263,7 @@ enum class DoorLockProgrammingEventCode : uint8_t kIdAdded = 0x05, kIdDeleted = 0x06, }; +static DoorLockProgrammingEventCode kDoorLockProgrammingEventCodeFirstUnusedEnumVal = static_cast(7); // Enum for DoorLockSetPinOrIdStatus enum class DoorLockSetPinOrIdStatus : uint8_t @@ -1195,6 +1273,7 @@ enum class DoorLockSetPinOrIdStatus : uint8_t kMemoryFull = 0x02, kDuplicateCodeError = 0x03, }; +static DoorLockSetPinOrIdStatus kDoorLockSetPinOrIdStatusFirstUnusedEnumVal = static_cast(4); // Enum for DoorLockUserStatus enum class DoorLockUserStatus : uint8_t @@ -1204,6 +1283,7 @@ enum class DoorLockUserStatus : uint8_t kOccupiedDisabled = 0x03, kNotSupported = 0xFF, }; +static DoorLockUserStatus kDoorLockUserStatusFirstUnusedEnumVal = static_cast(2); // Enum for DoorLockUserType enum class DoorLockUserType : uint8_t @@ -1215,6 +1295,7 @@ enum class DoorLockUserType : uint8_t kNonAccessUser = 0x04, kNotSupported = 0xFF, }; +static DoorLockUserType kDoorLockUserTypeFirstUnusedEnumVal = static_cast(5); // Bitmap for DlCredentialRuleMask enum class DlCredentialRuleMask : uint8_t @@ -1416,6 +1497,7 @@ enum class EndProductType : uint8_t kSlidingShutter = 0x17, kUnknown = 0xFF, }; +static EndProductType kEndProductTypeFirstUnusedEnumVal = static_cast(24); // Enum for Type enum class Type : uint8_t @@ -1432,6 +1514,7 @@ enum class Type : uint8_t kProjectorScreen = 0x09, kUnknown = 0xFF, }; +static Type kTypeFirstUnusedEnumVal = static_cast(10); // Bitmap for ConfigStatus enum class ConfigStatus : uint8_t @@ -1505,6 +1588,7 @@ enum class PumpControlMode : uint8_t kConstantTemperature = 0x05, kAutomatic = 0x07, }; +static PumpControlMode kPumpControlModeFirstUnusedEnumVal = static_cast(4); // Enum for PumpOperationMode enum class PumpOperationMode : uint8_t @@ -1514,6 +1598,7 @@ enum class PumpOperationMode : uint8_t kMaximum = 0x02, kLocal = 0x03, }; +static PumpOperationMode kPumpOperationModeFirstUnusedEnumVal = static_cast(4); // Bitmap for PumpStatus enum class PumpStatus : uint16_t @@ -1542,9 +1627,10 @@ enum class SetpointAdjustMode : uint8_t kCoolSetpoint = 0x01, kHeatAndCoolSetpoints = 0x02, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using SetpointAdjustMode = EmberAfSetpointAdjustMode; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static SetpointAdjustMode kSetpointAdjustModeFirstUnusedEnumVal = static_cast(3); // Enum for ThermostatControlSequence enum class ThermostatControlSequence : uint8_t @@ -1556,6 +1642,7 @@ enum class ThermostatControlSequence : uint8_t kCoolingAndHeating = 0x04, kCoolingAndHeatingWithReheat = 0x05, }; +static ThermostatControlSequence kThermostatControlSequenceFirstUnusedEnumVal = static_cast(6); // Enum for ThermostatRunningMode enum class ThermostatRunningMode : uint8_t @@ -1564,6 +1651,7 @@ enum class ThermostatRunningMode : uint8_t kCool = 0x03, kHeat = 0x04, }; +static ThermostatRunningMode kThermostatRunningModeFirstUnusedEnumVal = static_cast(1); // Enum for ThermostatSystemMode enum class ThermostatSystemMode : uint8_t @@ -1576,6 +1664,7 @@ enum class ThermostatSystemMode : uint8_t kPrecooling = 0x06, kFanOnly = 0x07, }; +static ThermostatSystemMode kThermostatSystemModeFirstUnusedEnumVal = static_cast(2); // Bitmap for DayOfWeek enum class DayOfWeek : uint8_t @@ -1621,6 +1710,7 @@ enum class FanModeSequenceType : uint8_t kOffOnAuto = 0x04, kOffOn = 0x05, }; +static FanModeSequenceType kFanModeSequenceTypeFirstUnusedEnumVal = static_cast(6); // Enum for FanModeType enum class FanModeType : uint8_t @@ -1633,6 +1723,7 @@ enum class FanModeType : uint8_t kAuto = 0x05, kSmart = 0x06, }; +static FanModeType kFanModeTypeFirstUnusedEnumVal = static_cast(7); // Bitmap for FanControlFeature enum class FanControlFeature : uint32_t @@ -1684,9 +1775,10 @@ enum class ColorLoopAction : uint8_t kActivateFromColorLoopStartEnhancedHue = 0x01, kActivateFromEnhancedCurrentHue = 0x02, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using ColorLoopAction = EmberAfColorLoopAction; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static ColorLoopAction kColorLoopActionFirstUnusedEnumVal = static_cast(3); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -1697,9 +1789,10 @@ enum class ColorLoopDirection : uint8_t kDecrementHue = 0x00, kIncrementHue = 0x01, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using ColorLoopDirection = EmberAfColorLoopDirection; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static ColorLoopDirection kColorLoopDirectionFirstUnusedEnumVal = static_cast(2); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -1711,9 +1804,10 @@ enum class ColorMode : uint8_t kCurrentXAndCurrentY = 0x01, kColorTemperature = 0x02, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using ColorMode = EmberAfColorMode; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static ColorMode kColorModeFirstUnusedEnumVal = static_cast(3); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -1726,9 +1820,10 @@ enum class HueDirection : uint8_t kUp = 0x02, kDown = 0x03, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using HueDirection = EmberAfHueDirection; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static HueDirection kHueDirectionFirstUnusedEnumVal = static_cast(4); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -1740,9 +1835,10 @@ enum class HueMoveMode : uint8_t kUp = 0x01, kDown = 0x03, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using HueMoveMode = EmberAfHueMoveMode; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static HueMoveMode kHueMoveModeFirstUnusedEnumVal = static_cast(2); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -1753,9 +1849,10 @@ enum class HueStepMode : uint8_t kUp = 0x01, kDown = 0x03, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using HueStepMode = EmberAfHueStepMode; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static HueStepMode kHueStepModeFirstUnusedEnumVal = static_cast(0); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -1767,9 +1864,10 @@ enum class SaturationMoveMode : uint8_t kUp = 0x01, kDown = 0x03, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using SaturationMoveMode = EmberAfSaturationMoveMode; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static SaturationMoveMode kSaturationMoveModeFirstUnusedEnumVal = static_cast(2); // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -1780,9 +1878,10 @@ enum class SaturationStepMode : uint8_t kUp = 0x01, kDown = 0x03, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using SaturationStepMode = EmberAfSaturationStepMode; -#endif +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +static SaturationStepMode kSaturationStepModeFirstUnusedEnumVal = static_cast(0); // Bitmap for ColorCapabilities enum class ColorCapabilities : uint16_t @@ -1825,6 +1924,7 @@ enum class LightSensorType : uint8_t kPhotodiode = 0x00, kCmos = 0x01, }; +static LightSensorType kLightSensorTypeFirstUnusedEnumVal = static_cast(2); } // namespace IlluminanceMeasurement namespace TemperatureMeasurement { @@ -1950,12 +2050,14 @@ enum class ChannelStatusEnum : uint8_t kMultipleMatches = 0x01, kNoMatches = 0x02, }; +static ChannelStatusEnum kChannelStatusEnumFirstUnusedEnumVal = static_cast(3); // Enum for LineupInfoTypeEnum enum class LineupInfoTypeEnum : uint8_t { kMso = 0x00, }; +static LineupInfoTypeEnum kLineupInfoTypeEnumFirstUnusedEnumVal = static_cast(1); // Bitmap for ChannelFeature enum class ChannelFeature : uint32_t @@ -1974,6 +2076,7 @@ enum class TargetNavigatorStatusEnum : uint8_t kTargetNotFound = 0x01, kNotAllowed = 0x02, }; +static TargetNavigatorStatusEnum kTargetNavigatorStatusEnumFirstUnusedEnumVal = static_cast(3); } // namespace TargetNavigator namespace MediaPlayback { @@ -1988,6 +2091,7 @@ enum class MediaPlaybackStatusEnum : uint8_t kSpeedOutOfRange = 0x04, kSeekOutOfRange = 0x05, }; +static MediaPlaybackStatusEnum kMediaPlaybackStatusEnumFirstUnusedEnumVal = static_cast(6); // Enum for PlaybackStateEnum enum class PlaybackStateEnum : uint8_t @@ -1997,6 +2101,7 @@ enum class PlaybackStateEnum : uint8_t kNotPlaying = 0x02, kBuffering = 0x03, }; +static PlaybackStateEnum kPlaybackStateEnumFirstUnusedEnumVal = static_cast(4); } // namespace MediaPlayback namespace MediaInput { @@ -2017,6 +2122,7 @@ enum class InputTypeEnum : uint8_t kUsb = 0x0A, kOther = 0x0B, }; +static InputTypeEnum kInputTypeEnumFirstUnusedEnumVal = static_cast(12); // Bitmap for MediaInputFeature enum class MediaInputFeature : uint32_t @@ -2120,6 +2226,7 @@ enum class CecKeyCode : uint8_t kF5 = 0x75, kData = 0x76, }; +static CecKeyCode kCecKeyCodeFirstUnusedEnumVal = static_cast(14); // Enum for KeypadInputStatusEnum enum class KeypadInputStatusEnum : uint8_t @@ -2128,6 +2235,7 @@ enum class KeypadInputStatusEnum : uint8_t kUnsupportedKey = 0x01, kInvalidKeyInCurrentState = 0x02, }; +static KeypadInputStatusEnum kKeypadInputStatusEnumFirstUnusedEnumVal = static_cast(3); // Bitmap for KeypadInputFeature enum class KeypadInputFeature : uint32_t @@ -2147,6 +2255,7 @@ enum class ContentLaunchStatusEnum : uint8_t kUrlNotAvailable = 0x01, kAuthFailed = 0x02, }; +static ContentLaunchStatusEnum kContentLaunchStatusEnumFirstUnusedEnumVal = static_cast(3); // Enum for MetricTypeEnum enum class MetricTypeEnum : uint8_t @@ -2154,6 +2263,7 @@ enum class MetricTypeEnum : uint8_t kPixels = 0x00, kPercentage = 0x01, }; +static MetricTypeEnum kMetricTypeEnumFirstUnusedEnumVal = static_cast(2); // Enum for ParameterEnum enum class ParameterEnum : uint8_t @@ -2172,6 +2282,7 @@ enum class ParameterEnum : uint8_t kSportsTeam = 0x0B, kType = 0x0C, }; +static ParameterEnum kParameterEnumFirstUnusedEnumVal = static_cast(13); // Bitmap for ContentLauncherFeature enum class ContentLauncherFeature : uint32_t @@ -2200,6 +2311,7 @@ enum class OutputTypeEnum : uint8_t kInternal = 0x04, kOther = 0x05, }; +static OutputTypeEnum kOutputTypeEnumFirstUnusedEnumVal = static_cast(6); // Bitmap for AudioOutputFeature enum class AudioOutputFeature : uint32_t @@ -2217,6 +2329,8 @@ enum class ApplicationLauncherStatusEnum : uint8_t kAppNotAvailable = 0x01, kSystemBusy = 0x02, }; +static ApplicationLauncherStatusEnum kApplicationLauncherStatusEnumFirstUnusedEnumVal = + static_cast(3); // Bitmap for ApplicationLauncherFeature enum class ApplicationLauncherFeature : uint32_t @@ -2235,6 +2349,7 @@ enum class ApplicationStatusEnum : uint8_t kActiveHidden = 0x02, kActiveVisibleNotFocus = 0x03, }; +static ApplicationStatusEnum kApplicationStatusEnumFirstUnusedEnumVal = static_cast(4); } // namespace ApplicationBasic namespace AccountLogin { @@ -2257,6 +2372,7 @@ enum class EventIdentification : uint8_t kSwitchingOff = 0x06, kWrongData = 0x07, }; +static EventIdentification kEventIdentificationFirstUnusedEnumVal = static_cast(0); // Bitmap for AlertCount enum class AlertCount : uint8_t @@ -2290,6 +2406,7 @@ enum class SimpleEnum : uint8_t kValueB = 0x02, kValueC = 0x03, }; +static SimpleEnum kSimpleEnumFirstUnusedEnumVal = static_cast(4); // Bitmap for Bitmap16MaskMap enum class Bitmap16MaskMap : uint16_t diff --git a/zzz_generated/chip-tool/zap-generated/test/Commands.h b/zzz_generated/chip-tool/zap-generated/test/Commands.h index 01d664952d5d38..b02719bc2b6e2a 100644 --- a/zzz_generated/chip-tool/zap-generated/test/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/test/Commands.h @@ -39010,7 +39010,7 @@ class TV_MediaInputClusterSuite : public TestCommand class TestClusterSuite : public TestCommand { public: - TestClusterSuite(CredentialIssuerCommands * credsIssuerConfig) : TestCommand("TestCluster", 489, credsIssuerConfig) + TestClusterSuite(CredentialIssuerCommands * credsIssuerConfig) : TestCommand("TestCluster", 490, credsIssuerConfig) { AddArgument("nodeId", 0, UINT64_MAX, &mNodeId); AddArgument("cluster", &mCluster); @@ -39045,7 +39045,7 @@ class TestClusterSuite : public TestCommand chip::app::DataModel::Nullable booValueNull; chip::app::DataModel::Nullable> nullableValue254; - chip::app::DataModel::Nullable nullableEnumAttr254; + chip::app::DataModel::Nullable nullableEnumAttr3; uint8_t * nullableOctetStrTestValueBuffer = nullptr; chip::app::DataModel::Nullable nullableOctetStrTestValue; char * nullableCharStringSaveBuffer = nullptr; @@ -40088,10 +40088,19 @@ class TestClusterSuite : public TestCommand chip::app::Clusters::TestCluster::Commands::TestEnumsResponse::DecodableType value; VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); VerifyOrReturn(CheckValue("arg1", value.arg1, 20003U)); - VerifyOrReturn(CheckValue("arg2", value.arg2, 101U)); + VerifyOrReturn(CheckValue("arg2", value.arg2, 1U)); } break; case 155: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + { + chip::app::Clusters::TestCluster::Commands::TestEnumsResponse::DecodableType value; + VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); + VerifyOrReturn(CheckValue("arg1", value.arg1, 20003U)); + VerifyOrReturn(CheckValue("arg2", value.arg2, 4U)); + } + break; + case 156: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType value; @@ -40099,7 +40108,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("value", value.value, true)); } break; - case 156: + case 157: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType value; @@ -40107,7 +40116,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("value", value.value, false)); } break; - case 157: + case 158: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType value; @@ -40115,7 +40124,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("value", value.value, true)); } break; - case 158: + case 159: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType value; @@ -40123,7 +40132,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("value", value.value, false)); } break; - case 159: + case 160: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType value; @@ -40131,7 +40140,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("value", value.value, true)); } break; - case 160: + case 161: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType value; @@ -40139,7 +40148,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("value", value.value, false)); } break; - case 161: + case 162: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::TestCluster::Commands::SimpleStructResponse::DecodableType value; @@ -40155,7 +40164,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("arg1.h", value.arg1.h, 0.1)); } break; - case 162: + case 163: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType value; @@ -40163,7 +40172,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("value", value.value, true)); } break; - case 163: + case 164: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType value; @@ -40171,7 +40180,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("value", value.value, false)); } break; - case 164: + case 165: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::TestCluster::Commands::TestListInt8UReverseResponse::DecodableType value; @@ -40200,7 +40209,7 @@ class TestClusterSuite : public TestCommand } } break; - case 165: + case 166: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::TestCluster::Commands::TestListInt8UReverseResponse::DecodableType value; @@ -40211,7 +40220,7 @@ class TestClusterSuite : public TestCommand } } break; - case 166: + case 167: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType value; @@ -40219,7 +40228,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("value", value.value, true)); } break; - case 167: + case 168: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType value; @@ -40227,7 +40236,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("value", value.value, false)); } break; - case 168: + case 169: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType value; @@ -40235,7 +40244,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("value", value.value, true)); } break; - case 169: + case 170: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType value; @@ -40243,10 +40252,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("value", value.value, false)); } break; - case 170: + case 171: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 171: + case 172: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::DecodableList value; @@ -40265,10 +40274,10 @@ class TestClusterSuite : public TestCommand } } break; - case 172: + case 173: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 173: + case 174: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::DecodableList value; @@ -40291,10 +40300,10 @@ class TestClusterSuite : public TestCommand } } break; - case 174: + case 175: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 175: + case 176: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::DecodableList @@ -40322,7 +40331,7 @@ class TestClusterSuite : public TestCommand } } break; - case 176: + case 177: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::TestCluster::Commands::TestNullableOptionalResponse::DecodableType value; @@ -40337,7 +40346,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("originalValue.Value().Value()", value.originalValue.Value().Value(), 5U)); } break; - case 177: + case 178: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::TestCluster::Commands::TestNullableOptionalResponse::DecodableType value; @@ -40345,7 +40354,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("wasPresent", value.wasPresent, false)); } break; - case 178: + case 179: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::DecodableList< @@ -40366,10 +40375,10 @@ class TestClusterSuite : public TestCommand } } break; - case 179: + case 180: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 180: + case 181: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::DecodableList< @@ -40403,10 +40412,10 @@ class TestClusterSuite : public TestCommand } } break; - case 181: + case 182: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 182: + case 183: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40415,10 +40424,10 @@ class TestClusterSuite : public TestCommand booValueNull = value; } break; - case 183: + case 184: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 184: + case 185: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40427,7 +40436,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableBoolean.Value()", value.Value(), true)); } break; - case 185: + case 186: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40435,10 +40444,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, booValueNull)); } break; - case 186: + case 187: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 187: + case 188: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable> value; @@ -40447,10 +40456,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableBitmap8.Value()", value.Value(), 254U)); } break; - case 188: + case 189: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 189: + case 190: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable> value; @@ -40460,10 +40469,10 @@ class TestClusterSuite : public TestCommand nullableValue254 = value; } break; - case 190: + case 191: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 191: + case 192: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable> value; @@ -40471,7 +40480,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableBitmap8", value)); } break; - case 192: + case 193: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable> value; @@ -40479,10 +40488,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, nullableValue254)); } break; - case 193: + case 194: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 194: + case 195: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable> value; @@ -40491,10 +40500,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableBitmap16.Value()", value.Value(), 65534U)); } break; - case 195: + case 196: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 196: + case 197: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable> value; @@ -40503,10 +40512,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableBitmap16.Value()", value.Value(), 65534U)); } break; - case 197: + case 198: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 198: + case 199: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable> value; @@ -40514,10 +40523,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableBitmap16", value)); } break; - case 199: + case 200: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 200: + case 201: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable> value; @@ -40526,10 +40535,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableBitmap32.Value()", value.Value(), 4294967294UL)); } break; - case 201: + case 202: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 202: + case 203: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable> value; @@ -40538,10 +40547,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableBitmap32.Value()", value.Value(), 4294967294UL)); } break; - case 203: + case 204: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 204: + case 205: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable> value; @@ -40549,10 +40558,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableBitmap32", value)); } break; - case 205: + case 206: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 206: + case 207: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable> value; @@ -40561,10 +40570,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableBitmap64.Value()", value.Value(), 18446744073709551614ULL)); } break; - case 207: + case 208: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 208: + case 209: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable> value; @@ -40573,10 +40582,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableBitmap64.Value()", value.Value(), 18446744073709551614ULL)); } break; - case 209: + case 210: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 210: + case 211: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable> value; @@ -40584,10 +40593,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableBitmap64", value)); } break; - case 211: + case 212: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 212: + case 213: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40596,10 +40605,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt8u.Value()", value.Value(), 0U)); } break; - case 213: + case 214: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 214: + case 215: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40608,10 +40617,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt8u.Value()", value.Value(), 254U)); } break; - case 215: + case 216: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 216: + case 217: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40620,7 +40629,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt8u.Value()", value.Value(), 254U)); } break; - case 217: + case 218: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40628,10 +40637,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNonNull("value", value)); } break; - case 218: + case 219: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 219: + case 220: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40639,7 +40648,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableInt8u", value)); } break; - case 220: + case 221: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40648,7 +40657,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 254U)); } break; - case 221: + case 222: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40656,10 +40665,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, 254U)); } break; - case 222: + case 223: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 223: + case 224: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40668,7 +40677,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 254U)); } break; - case 224: + case 225: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40676,10 +40685,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, 129U)); } break; - case 225: + case 226: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 226: + case 227: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40688,10 +40697,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt16u.Value()", value.Value(), 0U)); } break; - case 227: + case 228: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 228: + case 229: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40700,10 +40709,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt16u.Value()", value.Value(), 65534U)); } break; - case 229: + case 230: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 230: + case 231: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40712,10 +40721,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt16u.Value()", value.Value(), 65534U)); } break; - case 231: + case 232: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 232: + case 233: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40723,7 +40732,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableInt16u", value)); } break; - case 233: + case 234: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40732,7 +40741,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 65534U)); } break; - case 234: + case 235: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40740,10 +40749,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, 65534U)); } break; - case 235: + case 236: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 236: + case 237: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40752,7 +40761,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 65534U)); } break; - case 237: + case 238: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40760,10 +40769,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, 32001U)); } break; - case 238: + case 239: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 239: + case 240: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40772,10 +40781,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt32u.Value()", value.Value(), 0UL)); } break; - case 240: + case 241: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 241: + case 242: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40784,10 +40793,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt32u.Value()", value.Value(), 4294967294UL)); } break; - case 242: + case 243: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 243: + case 244: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40796,10 +40805,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt32u.Value()", value.Value(), 4294967294UL)); } break; - case 244: + case 245: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 245: + case 246: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40807,7 +40816,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableInt32u", value)); } break; - case 246: + case 247: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40816,7 +40825,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 4294967294UL)); } break; - case 247: + case 248: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40824,10 +40833,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, 4294967294UL)); } break; - case 248: + case 249: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 249: + case 250: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40836,7 +40845,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 4294967294UL)); } break; - case 250: + case 251: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40844,10 +40853,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, 2147483648UL)); } break; - case 251: + case 252: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 252: + case 253: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40856,10 +40865,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt64u.Value()", value.Value(), 0ULL)); } break; - case 253: + case 254: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 254: + case 255: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40868,10 +40877,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt64u.Value()", value.Value(), 18446744073709551614ULL)); } break; - case 255: + case 256: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 256: + case 257: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40880,10 +40889,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt64u.Value()", value.Value(), 18446744073709551614ULL)); } break; - case 257: + case 258: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 258: + case 259: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40891,7 +40900,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableInt64u", value)); } break; - case 259: + case 260: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40900,7 +40909,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 18446744073709551614ULL)); } break; - case 260: + case 261: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40908,10 +40917,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, 18446744073709551614ULL)); } break; - case 261: + case 262: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 262: + case 263: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40920,7 +40929,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 18446744073709551614ULL)); } break; - case 263: + case 264: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40928,10 +40937,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, 18000000000000000001ULL)); } break; - case 264: + case 265: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 265: + case 266: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40940,10 +40949,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt8s.Value()", value.Value(), -127)); } break; - case 266: + case 267: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 267: + case 268: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40952,10 +40961,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt8s.Value()", value.Value(), -127)); } break; - case 268: + case 269: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 269: + case 270: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40963,7 +40972,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableInt8s", value)); } break; - case 270: + case 271: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40972,7 +40981,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 127)); } break; - case 271: + case 272: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40980,10 +40989,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, -127)); } break; - case 272: + case 273: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 273: + case 274: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -40992,7 +41001,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 127)); } break; - case 274: + case 275: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41000,10 +41009,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, -126)); } break; - case 275: + case 276: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 276: + case 277: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41012,10 +41021,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt16s.Value()", value.Value(), -32767)); } break; - case 277: + case 278: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 278: + case 279: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41024,10 +41033,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt16s.Value()", value.Value(), -32767)); } break; - case 279: + case 280: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 280: + case 281: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41035,7 +41044,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableInt16s", value)); } break; - case 281: + case 282: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41044,7 +41053,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 32767)); } break; - case 282: + case 283: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41052,10 +41061,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, -32767)); } break; - case 283: + case 284: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 284: + case 285: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41064,7 +41073,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 32767)); } break; - case 285: + case 286: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41072,10 +41081,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, -32766)); } break; - case 286: + case 287: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 287: + case 288: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41084,10 +41093,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt32s.Value()", value.Value(), -2147483647L)); } break; - case 288: + case 289: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 289: + case 290: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41096,10 +41105,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt32s.Value()", value.Value(), -2147483647L)); } break; - case 290: + case 291: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 291: + case 292: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41107,7 +41116,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableInt32s", value)); } break; - case 292: + case 293: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41116,7 +41125,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 2147483647L)); } break; - case 293: + case 294: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41124,10 +41133,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, -2147483647L)); } break; - case 294: + case 295: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 295: + case 296: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41136,7 +41145,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 2147483647L)); } break; - case 296: + case 297: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41144,10 +41153,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, -2147483646L)); } break; - case 297: + case 298: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 298: + case 299: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41156,10 +41165,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt64s.Value()", value.Value(), -9223372036854775807LL)); } break; - case 299: + case 300: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 300: + case 301: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41168,10 +41177,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableInt64s.Value()", value.Value(), -9223372036854775807LL)); } break; - case 301: + case 302: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 302: + case 303: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41179,7 +41188,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableInt64s", value)); } break; - case 303: + case 304: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41188,7 +41197,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 9223372036854775807LL)); } break; - case 304: + case 305: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41196,10 +41205,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, -9223372036854775807LL)); } break; - case 305: + case 306: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 306: + case 307: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41208,7 +41217,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintMaxValue("value", value, 9223372036854775807LL)); } break; - case 307: + case 308: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41216,10 +41225,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, -9223372036854775806LL)); } break; - case 308: + case 309: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 309: + case 310: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41228,10 +41237,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", value.Value(), 0.1f)); } break; - case 310: + case 311: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 311: + case 312: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41240,10 +41249,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", value.Value(), INFINITY)); } break; - case 312: + case 313: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 313: + case 314: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41252,10 +41261,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", value.Value(), -INFINITY)); } break; - case 314: + case 315: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 315: + case 316: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41263,10 +41272,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableFloatSingle", value)); } break; - case 316: + case 317: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 317: + case 318: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41275,10 +41284,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", value.Value(), 0.0f)); } break; - case 318: + case 319: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 319: + case 320: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41287,10 +41296,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", value.Value(), 0.1234567890123)); } break; - case 320: + case 321: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 321: + case 322: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41299,10 +41308,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", value.Value(), INFINITY)); } break; - case 322: + case 323: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 323: + case 324: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41311,10 +41320,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", value.Value(), -INFINITY)); } break; - case 324: + case 325: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 325: + case 326: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41322,10 +41331,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableFloatDouble", value)); } break; - case 326: + case 327: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 327: + case 328: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41334,10 +41343,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", value.Value(), 0)); } break; - case 328: + case 329: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 329: + case 330: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41346,10 +41355,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableEnum8.Value()", value.Value(), 0U)); } break; - case 330: + case 331: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 331: + case 332: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41358,10 +41367,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableEnum8.Value()", value.Value(), 254U)); } break; - case 332: + case 333: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 333: + case 334: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41370,10 +41379,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableEnum8.Value()", value.Value(), 254U)); } break; - case 334: + case 335: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 335: + case 336: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41381,10 +41390,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableEnum8", value)); } break; - case 336: + case 337: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 337: + case 338: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41393,10 +41402,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableEnum16.Value()", value.Value(), 0U)); } break; - case 338: + case 339: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 339: + case 340: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41405,10 +41414,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableEnum16.Value()", value.Value(), 65534U)); } break; - case 340: + case 341: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 341: + case 342: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41417,10 +41426,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableEnum16.Value()", value.Value(), 65534U)); } break; - case 342: + case 343: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 343: + case 344: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41428,10 +41437,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableEnum16", value)); } break; - case 344: + case 345: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 345: + case 346: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41440,35 +41449,35 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableEnumAttr.Value()", value.Value(), 0U)); } break; - case 346: + case 347: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 347: + case 348: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); VerifyOrReturn(CheckValueNonNull("nullableEnumAttr", value)); - VerifyOrReturn(CheckValue("nullableEnumAttr.Value()", value.Value(), 254U)); + VerifyOrReturn(CheckValue("nullableEnumAttr.Value()", value.Value(), 3U)); } break; - case 348: + case 349: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; - case 349: + case 350: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); VerifyOrReturn(CheckValueNonNull("nullableEnumAttr", value)); - VerifyOrReturn(CheckValue("nullableEnumAttr.Value()", value.Value(), 254U)); - nullableEnumAttr254 = value; + VerifyOrReturn(CheckValue("nullableEnumAttr.Value()", value.Value(), 3U)); + nullableEnumAttr3 = value; } break; - case 350: + case 351: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 351: + case 352: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41476,15 +41485,15 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableEnumAttr", value)); } break; - case 352: + case 353: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); - VerifyOrReturn(CheckConstraintNotValue("value", value, nullableEnumAttr254)); + VerifyOrReturn(CheckConstraintNotValue("value", value, nullableEnumAttr3)); } break; - case 353: + case 354: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41494,10 +41503,10 @@ class TestClusterSuite : public TestCommand chip::ByteSpan(chip::Uint8::from_const_char(""), 0))); } break; - case 354: + case 355: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 355: + case 356: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41521,10 +41530,10 @@ class TestClusterSuite : public TestCommand } } break; - case 356: + case 357: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 357: + case 358: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41532,10 +41541,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableOctetString", value)); } break; - case 358: + case 359: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 359: + case 360: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41545,7 +41554,7 @@ class TestClusterSuite : public TestCommand chip::ByteSpan(chip::Uint8::from_const_char(""), 0))); } break; - case 360: + case 361: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41553,7 +41562,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, nullableOctetStrTestValue)); } break; - case 361: + case 362: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41562,10 +41571,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", value.Value(), chip::CharSpan("", 0))); } break; - case 362: + case 363: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 363: + case 364: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41588,7 +41597,7 @@ class TestClusterSuite : public TestCommand } } break; - case 364: + case 365: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41604,10 +41613,10 @@ class TestClusterSuite : public TestCommand } } break; - case 365: + case 366: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 366: + case 367: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41615,10 +41624,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableCharString", value)); } break; - case 367: + case 368: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 368: + case 369: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41627,7 +41636,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", value.Value(), chip::CharSpan("", 0))); } break; - case 369: + case 370: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41635,19 +41644,19 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckConstraintNotValue("value", value, nullableCharStringSave)); } break; - case 370: + case 371: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_UNSUPPORTED_ENDPOINT)); break; - case 371: + case 372: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER)); break; - case 372: + case 373: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_INVALID_VALUE)); break; - case 373: + case 374: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 374: + case 375: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::DecodableList value; @@ -41666,10 +41675,10 @@ class TestClusterSuite : public TestCommand } } break; - case 375: + case 376: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 376: + case 377: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::DecodableList value; @@ -41689,7 +41698,7 @@ class TestClusterSuite : public TestCommand } shouldContinue = true; break; - case 377: + case 378: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { uint8_t value; @@ -41697,9 +41706,6 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt8u", value, 70U)); } break; - case 378: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); - break; case 379: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; @@ -41710,6 +41716,9 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 382: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + break; + case 383: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { uint8_t value; @@ -41717,10 +41726,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt8u", value, 70U)); } break; - case 383: + case 384: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 384: + case 385: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { uint8_t value; @@ -41728,10 +41737,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt8u", value, 20U)); } break; - case 385: + case 386: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 386: + case 387: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { uint8_t value; @@ -41739,10 +41748,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt8u", value, 100U)); } break; - case 387: + case 388: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 388: + case 389: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { uint8_t value; @@ -41750,7 +41759,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt8u", value, 50U)); } break; - case 389: + case 390: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { uint16_t value; @@ -41758,9 +41767,6 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt16u", value, 200U)); } break; - case 390: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); - break; case 391: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; @@ -41771,6 +41777,9 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 394: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + break; + case 395: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { uint16_t value; @@ -41778,10 +41787,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt16u", value, 200U)); } break; - case 395: + case 396: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 396: + case 397: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { uint16_t value; @@ -41789,10 +41798,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt16u", value, 100U)); } break; - case 397: + case 398: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 398: + case 399: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { uint16_t value; @@ -41800,10 +41809,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt16u", value, 1000U)); } break; - case 399: + case 400: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 400: + case 401: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { uint16_t value; @@ -41811,7 +41820,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt16u", value, 500U)); } break; - case 401: + case 402: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { int8_t value; @@ -41819,9 +41828,6 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt8s", value, -20)); } break; - case 402: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); - break; case 403: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; @@ -41832,6 +41838,9 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 406: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + break; + case 407: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { int8_t value; @@ -41839,10 +41848,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt8s", value, -20)); } break; - case 407: + case 408: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 408: + case 409: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { int8_t value; @@ -41850,10 +41859,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt8s", value, -40)); } break; - case 409: + case 410: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 410: + case 411: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { int8_t value; @@ -41861,10 +41870,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt8s", value, 50)); } break; - case 411: + case 412: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 412: + case 413: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { int8_t value; @@ -41872,7 +41881,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt8s", value, 6)); } break; - case 413: + case 414: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { int16_t value; @@ -41880,9 +41889,6 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt16s", value, -100)); } break; - case 414: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); - break; case 415: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; @@ -41893,6 +41899,9 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 418: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + break; + case 419: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { int16_t value; @@ -41900,10 +41909,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt16s", value, -100)); } break; - case 419: + case 420: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 420: + case 421: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { int16_t value; @@ -41911,10 +41920,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt16s", value, -150)); } break; - case 421: + case 422: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 422: + case 423: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { int16_t value; @@ -41922,10 +41931,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt16s", value, 200)); } break; - case 423: + case 424: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 424: + case 425: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { int16_t value; @@ -41933,7 +41942,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("rangeRestrictedInt16s", value, 7)); } break; - case 425: + case 426: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41942,9 +41951,6 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", value.Value(), 70U)); } break; - case 426: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); - break; case 427: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; @@ -41955,6 +41961,9 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 430: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + break; + case 431: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41963,10 +41972,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", value.Value(), 70U)); } break; - case 431: + case 432: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 432: + case 433: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41975,10 +41984,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", value.Value(), 20U)); } break; - case 433: + case 434: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 434: + case 435: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41987,10 +41996,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", value.Value(), 100U)); } break; - case 435: + case 436: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 436: + case 437: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41999,10 +42008,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", value.Value(), 50U)); } break; - case 437: + case 438: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 438: + case 439: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42010,7 +42019,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt8u", value)); } break; - case 439: + case 440: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42019,9 +42028,6 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", value.Value(), 200U)); } break; - case 440: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); - break; case 441: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; @@ -42032,6 +42038,9 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 444: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + break; + case 445: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42040,10 +42049,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", value.Value(), 200U)); } break; - case 445: + case 446: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 446: + case 447: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42052,10 +42061,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", value.Value(), 100U)); } break; - case 447: + case 448: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 448: + case 449: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42064,10 +42073,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", value.Value(), 1000U)); } break; - case 449: + case 450: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 450: + case 451: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42076,10 +42085,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", value.Value(), 500U)); } break; - case 451: + case 452: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 452: + case 453: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42087,7 +42096,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt16u", value)); } break; - case 453: + case 454: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42096,9 +42105,6 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", value.Value(), -20)); } break; - case 454: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); - break; case 455: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; @@ -42109,6 +42115,9 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 458: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + break; + case 459: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42117,10 +42126,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", value.Value(), -20)); } break; - case 459: + case 460: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 460: + case 461: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42129,10 +42138,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", value.Value(), -40)); } break; - case 461: + case 462: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 462: + case 463: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42141,10 +42150,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", value.Value(), 50)); } break; - case 463: + case 464: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 464: + case 465: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42153,10 +42162,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", value.Value(), 6)); } break; - case 465: + case 466: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 466: + case 467: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42164,7 +42173,7 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt8s", value)); } break; - case 467: + case 468: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42173,9 +42182,6 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", value.Value(), -100)); } break; - case 468: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); - break; case 469: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; @@ -42186,6 +42192,9 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 472: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + break; + case 473: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42194,10 +42203,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", value.Value(), -100)); } break; - case 473: + case 474: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 474: + case 475: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42206,10 +42215,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", value.Value(), -150)); } break; - case 475: + case 476: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 476: + case 477: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42218,10 +42227,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", value.Value(), 200)); } break; - case 477: + case 478: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 478: + case 479: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42230,10 +42239,10 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", value.Value(), 7)); } break; - case 479: + case 480: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 480: + case 481: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42241,19 +42250,19 @@ class TestClusterSuite : public TestCommand VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt16s", value)); } break; - case 481: + case 482: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_INVALID_DATA_TYPE)); break; - case 482: + case 483: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_FAILURE)); break; - case 483: + case 484: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_INVALID_DATA_TYPE)); break; - case 484: + case 485: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_FAILURE)); break; - case 485: + case 486: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::DecodableList value; @@ -42300,7 +42309,7 @@ class TestClusterSuite : public TestCommand } } break; - case 486: + case 487: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::DecodableList value; @@ -42329,10 +42338,10 @@ class TestClusterSuite : public TestCommand } } break; - case 487: + case 488: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; - case 488: + case 489: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::Clusters::TestCluster::Structs::SimpleStruct::DecodableType value; @@ -43419,14 +43428,25 @@ class TestClusterSuite : public TestCommand ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestEnumsRequest::Type value; value.arg1 = static_cast(20003); - value.arg2 = static_cast(101); + value.arg2 = static_cast(1); return SendCommand(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Commands::TestEnumsRequest::Id, value, chip::NullOptional ); } case 155: { - LogStep(155, "Send Test Command With Struct Argument and arg1.b is true"); + LogStep(155, "Send a command with a vendor_id and invalid enum"); + ListFreer listFreer; + chip::app::Clusters::TestCluster::Commands::TestEnumsRequest::Type value; + value.arg1 = static_cast(20003); + value.arg2 = static_cast(101); + return SendCommand(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Commands::TestEnumsRequest::Id, value, + chip::NullOptional + + ); + } + case 156: { + LogStep(156, "Send Test Command With Struct Argument and arg1.b is true"); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestStructArgumentRequest::Type value; @@ -43444,8 +43464,8 @@ class TestClusterSuite : public TestCommand ); } - case 156: { - LogStep(156, "Send Test Command With Struct Argument and arg1.b is false"); + case 157: { + LogStep(157, "Send Test Command With Struct Argument and arg1.b is false"); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestStructArgumentRequest::Type value; @@ -43463,8 +43483,8 @@ class TestClusterSuite : public TestCommand ); } - case 157: { - LogStep(157, "Send Test Command With Nested Struct Argument and arg1.c.b is true"); + case 158: { + LogStep(158, "Send Test Command With Nested Struct Argument and arg1.c.b is true"); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestNestedStructArgumentRequest::Type value; @@ -43485,8 +43505,8 @@ class TestClusterSuite : public TestCommand ); } - case 158: { - LogStep(158, "Send Test Command With Nested Struct Argument arg1.c.b is false"); + case 159: { + LogStep(159, "Send Test Command With Nested Struct Argument arg1.c.b is false"); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestNestedStructArgumentRequest::Type value; @@ -43507,8 +43527,8 @@ class TestClusterSuite : public TestCommand ); } - case 159: { - LogStep(159, "Send Test Command With Nested Struct List Argument and all fields b of arg1.d are true"); + case 160: { + LogStep(160, "Send Test Command With Nested Struct List Argument and all fields b of arg1.d are true"); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestNestedStructListArgumentRequest::Type value; @@ -43586,8 +43606,8 @@ class TestClusterSuite : public TestCommand ); } - case 160: { - LogStep(160, "Send Test Command With Nested Struct List Argument and some fields b of arg1.d are false"); + case 161: { + LogStep(161, "Send Test Command With Nested Struct List Argument and some fields b of arg1.d are false"); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestNestedStructListArgumentRequest::Type value; @@ -43665,8 +43685,8 @@ class TestClusterSuite : public TestCommand ); } - case 161: { - LogStep(161, "Send Test Command With Struct Argument and see what we get back"); + case 162: { + LogStep(162, "Send Test Command With Struct Argument and see what we get back"); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::SimpleStructEchoRequest::Type value; @@ -43684,8 +43704,8 @@ class TestClusterSuite : public TestCommand ); } - case 162: { - LogStep(162, "Send Test Command With List of INT8U and none of them is set to 0"); + case 163: { + LogStep(163, "Send Test Command With List of INT8U and none of them is set to 0"); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestListInt8UArgumentRequest::Type value; @@ -43708,8 +43728,8 @@ class TestClusterSuite : public TestCommand ); } - case 163: { - LogStep(163, "Send Test Command With List of INT8U and one of them is set to 0"); + case 164: { + LogStep(164, "Send Test Command With List of INT8U and one of them is set to 0"); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestListInt8UArgumentRequest::Type value; @@ -43733,8 +43753,8 @@ class TestClusterSuite : public TestCommand ); } - case 164: { - LogStep(164, "Send Test Command With List of INT8U and get it reversed"); + case 165: { + LogStep(165, "Send Test Command With List of INT8U and get it reversed"); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestListInt8UReverseRequest::Type value; @@ -43757,8 +43777,8 @@ class TestClusterSuite : public TestCommand ); } - case 165: { - LogStep(165, "Send Test Command With empty List of INT8U and get an empty list back"); + case 166: { + LogStep(166, "Send Test Command With empty List of INT8U and get an empty list back"); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestListInt8UReverseRequest::Type value; @@ -43768,8 +43788,8 @@ class TestClusterSuite : public TestCommand ); } - case 166: { - LogStep(166, "Send Test Command With List of Struct Argument and arg1.b of first item is true"); + case 167: { + LogStep(167, "Send Test Command With List of Struct Argument and arg1.b of first item is true"); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestListStructArgumentRequest::Type value; @@ -43805,8 +43825,8 @@ class TestClusterSuite : public TestCommand ); } - case 167: { - LogStep(167, "Send Test Command With List of Struct Argument and arg1.b of first item is false"); + case 168: { + LogStep(168, "Send Test Command With List of Struct Argument and arg1.b of first item is false"); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestListStructArgumentRequest::Type value; @@ -43842,8 +43862,8 @@ class TestClusterSuite : public TestCommand ); } - case 168: { - LogStep(168, + case 169: { + LogStep(169, "Send Test Command With List of Nested Struct List Argument and all fields b of elements of arg1.d are true"); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestListNestedStructListArgumentRequest::Type value; @@ -43931,8 +43951,8 @@ class TestClusterSuite : public TestCommand ); } - case 169: { - LogStep(169, "Send Test Command With Nested Struct List Argument and some fields b of elements of arg1.d are false"); + case 170: { + LogStep(170, "Send Test Command With Nested Struct List Argument and some fields b of elements of arg1.d are false"); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestListNestedStructListArgumentRequest::Type value; @@ -44019,8 +44039,8 @@ class TestClusterSuite : public TestCommand ); } - case 170: { - LogStep(170, "Write attribute LIST With List of INT8U and none of them is set to 0"); + case 171: { + LogStep(171, "Write attribute LIST With List of INT8U and none of them is set to 0"); ListFreer listFreer; chip::app::DataModel::List value; @@ -44036,13 +44056,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::ListInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 171: { - LogStep(171, "Read attribute LIST With List of INT8U"); + case 172: { + LogStep(172, "Read attribute LIST With List of INT8U"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::ListInt8u::Id, true, chip::NullOptional); } - case 172: { - LogStep(172, "Write attribute LIST With List of OCTET_STRING"); + case 173: { + LogStep(173, "Write attribute LIST With List of OCTET_STRING"); ListFreer listFreer; chip::app::DataModel::List value; @@ -44058,13 +44078,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::ListOctetString::Id, value, chip::NullOptional, chip::NullOptional); } - case 173: { - LogStep(173, "Read attribute LIST With List of OCTET_STRING"); + case 174: { + LogStep(174, "Read attribute LIST With List of OCTET_STRING"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::ListOctetString::Id, true, chip::NullOptional); } - case 174: { - LogStep(174, "Write attribute LIST With List of LIST_STRUCT_OCTET_STRING"); + case 175: { + LogStep(175, "Write attribute LIST With List of LIST_STRUCT_OCTET_STRING"); ListFreer listFreer; chip::app::DataModel::List value; @@ -44095,13 +44115,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::ListStructOctetString::Id, value, chip::NullOptional, chip::NullOptional); } - case 175: { - LogStep(175, "Read attribute LIST With List of LIST_STRUCT_OCTET_STRING"); + case 176: { + LogStep(176, "Read attribute LIST With List of LIST_STRUCT_OCTET_STRING"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::ListStructOctetString::Id, true, chip::NullOptional); } - case 176: { - LogStep(176, "Send Test Command with optional arg set."); + case 177: { + LogStep(177, "Send Test Command with optional arg set."); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestNullableOptionalRequest::Type value; value.arg1.Emplace(); @@ -44112,8 +44132,8 @@ class TestClusterSuite : public TestCommand ); } - case 177: { - LogStep(177, "Send Test Command without its optional arg."); + case 178: { + LogStep(178, "Send Test Command without its optional arg."); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestNullableOptionalRequest::Type value; return SendCommand(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, @@ -44121,13 +44141,13 @@ class TestClusterSuite : public TestCommand ); } - case 178: { - LogStep(178, "Read list of structs containing nullables and optionals"); + case 179: { + LogStep(179, "Read list of structs containing nullables and optionals"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::ListNullablesAndOptionalsStruct::Id, true, chip::NullOptional); } - case 179: { - LogStep(179, "Write list of structs containing nullables and optionals"); + case 180: { + LogStep(180, "Write list of structs containing nullables and optionals"); ListFreer listFreer; chip::app::DataModel::List value; @@ -44157,26 +44177,26 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::ListNullablesAndOptionalsStruct::Id, value, chip::NullOptional, chip::NullOptional); } - case 180: { - LogStep(180, "Read list of structs containing nullables and optionals after writing"); + case 181: { + LogStep(181, "Read list of structs containing nullables and optionals after writing"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::ListNullablesAndOptionalsStruct::Id, true, chip::NullOptional); } - case 181: { - LogStep(181, "Write attribute NULLABLE_BOOLEAN null"); + case 182: { + LogStep(182, "Write attribute NULLABLE_BOOLEAN null"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBoolean::Id, value, chip::NullOptional, chip::NullOptional); } - case 182: { - LogStep(182, "Read attribute NULLABLE_BOOLEAN null"); + case 183: { + LogStep(183, "Read attribute NULLABLE_BOOLEAN null"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBoolean::Id, true, chip::NullOptional); } - case 183: { - LogStep(183, "Write attribute NULLABLE_BOOLEAN True"); + case 184: { + LogStep(184, "Write attribute NULLABLE_BOOLEAN True"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44184,18 +44204,18 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBoolean::Id, value, chip::NullOptional, chip::NullOptional); } - case 184: { - LogStep(184, "Read attribute NULLABLE_BOOLEAN True"); + case 185: { + LogStep(185, "Read attribute NULLABLE_BOOLEAN True"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBoolean::Id, true, chip::NullOptional); } - case 185: { - LogStep(185, "Read attribute NULLABLE_BOOLEAN not null"); + case 186: { + LogStep(186, "Read attribute NULLABLE_BOOLEAN not null"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBoolean::Id, true, chip::NullOptional); } - case 186: { - LogStep(186, "Write attribute NULLABLE_BITMAP8 Max Value"); + case 187: { + LogStep(187, "Write attribute NULLABLE_BITMAP8 Max Value"); ListFreer listFreer; chip::app::DataModel::Nullable> value; value.SetNonNull(); @@ -44203,13 +44223,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap8::Id, value, chip::NullOptional, chip::NullOptional); } - case 187: { - LogStep(187, "Read attribute NULLABLE_BITMAP8 Max Value"); + case 188: { + LogStep(188, "Read attribute NULLABLE_BITMAP8 Max Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap8::Id, true, chip::NullOptional); } - case 188: { - LogStep(188, "Write attribute NULLABLE_BITMAP8 Invalid Value"); + case 189: { + LogStep(189, "Write attribute NULLABLE_BITMAP8 Invalid Value"); ListFreer listFreer; chip::app::DataModel::Nullable> value; value.SetNonNull(); @@ -44217,31 +44237,31 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap8::Id, value, chip::NullOptional, chip::NullOptional); } - case 189: { - LogStep(189, "Read attribute NULLABLE_BITMAP8 unchanged Value"); + case 190: { + LogStep(190, "Read attribute NULLABLE_BITMAP8 unchanged Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap8::Id, true, chip::NullOptional); } - case 190: { - LogStep(190, "Write attribute NULLABLE_BITMAP8 null Value"); + case 191: { + LogStep(191, "Write attribute NULLABLE_BITMAP8 null Value"); ListFreer listFreer; chip::app::DataModel::Nullable> value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap8::Id, value, chip::NullOptional, chip::NullOptional); } - case 191: { - LogStep(191, "Read attribute NULLABLE_BITMAP8 null Value"); + case 192: { + LogStep(192, "Read attribute NULLABLE_BITMAP8 null Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap8::Id, true, chip::NullOptional); } - case 192: { - LogStep(192, "Read attribute NULLABLE_BITMAP8 not 254 Value"); + case 193: { + LogStep(193, "Read attribute NULLABLE_BITMAP8 not 254 Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap8::Id, true, chip::NullOptional); } - case 193: { - LogStep(193, "Write attribute NULLABLE_BITMAP16 Max Value"); + case 194: { + LogStep(194, "Write attribute NULLABLE_BITMAP16 Max Value"); ListFreer listFreer; chip::app::DataModel::Nullable> value; value.SetNonNull(); @@ -44249,13 +44269,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap16::Id, value, chip::NullOptional, chip::NullOptional); } - case 194: { - LogStep(194, "Read attribute NULLABLE_BITMAP16 Max Value"); + case 195: { + LogStep(195, "Read attribute NULLABLE_BITMAP16 Max Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap16::Id, true, chip::NullOptional); } - case 195: { - LogStep(195, "Write attribute NULLABLE_BITMAP16 Invalid Value"); + case 196: { + LogStep(196, "Write attribute NULLABLE_BITMAP16 Invalid Value"); ListFreer listFreer; chip::app::DataModel::Nullable> value; value.SetNonNull(); @@ -44263,26 +44283,26 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap16::Id, value, chip::NullOptional, chip::NullOptional); } - case 196: { - LogStep(196, "Read attribute NULLABLE_BITMAP16 unchanged Value"); + case 197: { + LogStep(197, "Read attribute NULLABLE_BITMAP16 unchanged Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap16::Id, true, chip::NullOptional); } - case 197: { - LogStep(197, "Write attribute NULLABLE_BITMAP16 null Value"); + case 198: { + LogStep(198, "Write attribute NULLABLE_BITMAP16 null Value"); ListFreer listFreer; chip::app::DataModel::Nullable> value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap16::Id, value, chip::NullOptional, chip::NullOptional); } - case 198: { - LogStep(198, "Read attribute NULLABLE_BITMAP16 null Value"); + case 199: { + LogStep(199, "Read attribute NULLABLE_BITMAP16 null Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap16::Id, true, chip::NullOptional); } - case 199: { - LogStep(199, "Write attribute NULLABLE_BITMAP32 Max Value"); + case 200: { + LogStep(200, "Write attribute NULLABLE_BITMAP32 Max Value"); ListFreer listFreer; chip::app::DataModel::Nullable> value; value.SetNonNull(); @@ -44290,13 +44310,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap32::Id, value, chip::NullOptional, chip::NullOptional); } - case 200: { - LogStep(200, "Read attribute NULLABLE_BITMAP32 Max Value"); + case 201: { + LogStep(201, "Read attribute NULLABLE_BITMAP32 Max Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap32::Id, true, chip::NullOptional); } - case 201: { - LogStep(201, "Write attribute NULLABLE_BITMAP32 Invalid Value"); + case 202: { + LogStep(202, "Write attribute NULLABLE_BITMAP32 Invalid Value"); ListFreer listFreer; chip::app::DataModel::Nullable> value; value.SetNonNull(); @@ -44304,26 +44324,26 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap32::Id, value, chip::NullOptional, chip::NullOptional); } - case 202: { - LogStep(202, "Read attribute NULLABLE_BITMAP32 unchanged Value"); + case 203: { + LogStep(203, "Read attribute NULLABLE_BITMAP32 unchanged Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap32::Id, true, chip::NullOptional); } - case 203: { - LogStep(203, "Write attribute NULLABLE_BITMAP32 null Value"); + case 204: { + LogStep(204, "Write attribute NULLABLE_BITMAP32 null Value"); ListFreer listFreer; chip::app::DataModel::Nullable> value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap32::Id, value, chip::NullOptional, chip::NullOptional); } - case 204: { - LogStep(204, "Read attribute NULLABLE_BITMAP32 null Value"); + case 205: { + LogStep(205, "Read attribute NULLABLE_BITMAP32 null Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap32::Id, true, chip::NullOptional); } - case 205: { - LogStep(205, "Write attribute NULLABLE_BITMAP64 Max Value"); + case 206: { + LogStep(206, "Write attribute NULLABLE_BITMAP64 Max Value"); ListFreer listFreer; chip::app::DataModel::Nullable> value; value.SetNonNull(); @@ -44331,13 +44351,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap64::Id, value, chip::NullOptional, chip::NullOptional); } - case 206: { - LogStep(206, "Read attribute NULLABLE_BITMAP64 Max Value"); + case 207: { + LogStep(207, "Read attribute NULLABLE_BITMAP64 Max Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap64::Id, true, chip::NullOptional); } - case 207: { - LogStep(207, "Write attribute NULLABLE_BITMAP64 Invalid Value"); + case 208: { + LogStep(208, "Write attribute NULLABLE_BITMAP64 Invalid Value"); ListFreer listFreer; chip::app::DataModel::Nullable> value; value.SetNonNull(); @@ -44345,26 +44365,26 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap64::Id, value, chip::NullOptional, chip::NullOptional); } - case 208: { - LogStep(208, "Read attribute NULLABLE_BITMAP64 unchanged Value"); + case 209: { + LogStep(209, "Read attribute NULLABLE_BITMAP64 unchanged Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap64::Id, true, chip::NullOptional); } - case 209: { - LogStep(209, "Write attribute NULLABLE_BITMAP64 null Value"); + case 210: { + LogStep(210, "Write attribute NULLABLE_BITMAP64 null Value"); ListFreer listFreer; chip::app::DataModel::Nullable> value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap64::Id, value, chip::NullOptional, chip::NullOptional); } - case 210: { - LogStep(210, "Read attribute NULLABLE_BITMAP64 null Value"); + case 211: { + LogStep(211, "Read attribute NULLABLE_BITMAP64 null Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableBitmap64::Id, true, chip::NullOptional); } - case 211: { - LogStep(211, "Write attribute NULLABLE_INT8U Min Value"); + case 212: { + LogStep(212, "Write attribute NULLABLE_INT8U Min Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44372,13 +44392,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 212: { - LogStep(212, "Read attribute NULLABLE_INT8U Min Value"); + case 213: { + LogStep(213, "Read attribute NULLABLE_INT8U Min Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8u::Id, true, chip::NullOptional); } - case 213: { - LogStep(213, "Write attribute NULLABLE_INT8U Max Value"); + case 214: { + LogStep(214, "Write attribute NULLABLE_INT8U Max Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44386,13 +44406,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 214: { - LogStep(214, "Read attribute NULLABLE_INT8U Max Value"); + case 215: { + LogStep(215, "Read attribute NULLABLE_INT8U Max Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8u::Id, true, chip::NullOptional); } - case 215: { - LogStep(215, "Write attribute NULLABLE_INT8U Invalid Value"); + case 216: { + LogStep(216, "Write attribute NULLABLE_INT8U Invalid Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44400,41 +44420,41 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 216: { - LogStep(216, "Read attribute NULLABLE_INT8U unchanged Value"); + case 217: { + LogStep(217, "Read attribute NULLABLE_INT8U unchanged Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8u::Id, true, chip::NullOptional); } - case 217: { - LogStep(217, "Read attribute NULLABLE_INT8U unchanged Value with constraint"); + case 218: { + LogStep(218, "Read attribute NULLABLE_INT8U unchanged Value with constraint"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8u::Id, true, chip::NullOptional); } - case 218: { - LogStep(218, "Write attribute NULLABLE_INT8U null Value"); + case 219: { + LogStep(219, "Write attribute NULLABLE_INT8U null Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 219: { - LogStep(219, "Read attribute NULLABLE_INT8U null Value"); - return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8u::Id, true, - chip::NullOptional); - } case 220: { - LogStep(220, "Read attribute NULLABLE_INT8U null Value & range"); + LogStep(220, "Read attribute NULLABLE_INT8U null Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8u::Id, true, chip::NullOptional); } case 221: { - LogStep(221, "Read attribute NULLABLE_INT8U null Value & not"); + LogStep(221, "Read attribute NULLABLE_INT8U null Value & range"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8u::Id, true, chip::NullOptional); } case 222: { - LogStep(222, "Write attribute NULLABLE_INT8U Value"); + LogStep(222, "Read attribute NULLABLE_INT8U null Value & not"); + return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8u::Id, true, + chip::NullOptional); + } + case 223: { + LogStep(223, "Write attribute NULLABLE_INT8U Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44442,18 +44462,18 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 223: { - LogStep(223, "Read attribute NULLABLE_INT8U Value in range"); + case 224: { + LogStep(224, "Read attribute NULLABLE_INT8U Value in range"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8u::Id, true, chip::NullOptional); } - case 224: { - LogStep(224, "Read attribute NULLABLE_INT8U notValue OK"); + case 225: { + LogStep(225, "Read attribute NULLABLE_INT8U notValue OK"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8u::Id, true, chip::NullOptional); } - case 225: { - LogStep(225, "Write attribute NULLABLE_INT16U Min Value"); + case 226: { + LogStep(226, "Write attribute NULLABLE_INT16U Min Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44461,13 +44481,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 226: { - LogStep(226, "Read attribute NULLABLE_INT16U Min Value"); + case 227: { + LogStep(227, "Read attribute NULLABLE_INT16U Min Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16u::Id, true, chip::NullOptional); } - case 227: { - LogStep(227, "Write attribute NULLABLE_INT16U Max Value"); + case 228: { + LogStep(228, "Write attribute NULLABLE_INT16U Max Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44475,13 +44495,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 228: { - LogStep(228, "Read attribute NULLABLE_INT16U Max Value"); + case 229: { + LogStep(229, "Read attribute NULLABLE_INT16U Max Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16u::Id, true, chip::NullOptional); } - case 229: { - LogStep(229, "Write attribute NULLABLE_INT16U Invalid Value"); + case 230: { + LogStep(230, "Write attribute NULLABLE_INT16U Invalid Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44489,36 +44509,36 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 230: { - LogStep(230, "Read attribute NULLABLE_INT16U unchanged Value"); + case 231: { + LogStep(231, "Read attribute NULLABLE_INT16U unchanged Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16u::Id, true, chip::NullOptional); } - case 231: { - LogStep(231, "Write attribute NULLABLE_INT16U null Value"); + case 232: { + LogStep(232, "Write attribute NULLABLE_INT16U null Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 232: { - LogStep(232, "Read attribute NULLABLE_INT16U null Value"); - return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16u::Id, true, - chip::NullOptional); - } case 233: { - LogStep(233, "Read attribute NULLABLE_INT16U null Value & range"); + LogStep(233, "Read attribute NULLABLE_INT16U null Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16u::Id, true, chip::NullOptional); } case 234: { - LogStep(234, "Read attribute NULLABLE_INT16U null Value & not"); + LogStep(234, "Read attribute NULLABLE_INT16U null Value & range"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16u::Id, true, chip::NullOptional); } case 235: { - LogStep(235, "Write attribute NULLABLE_INT16U Value"); + LogStep(235, "Read attribute NULLABLE_INT16U null Value & not"); + return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16u::Id, true, + chip::NullOptional); + } + case 236: { + LogStep(236, "Write attribute NULLABLE_INT16U Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44526,18 +44546,18 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 236: { - LogStep(236, "Read attribute NULLABLE_INT16U Value in range"); + case 237: { + LogStep(237, "Read attribute NULLABLE_INT16U Value in range"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16u::Id, true, chip::NullOptional); } - case 237: { - LogStep(237, "Read attribute NULLABLE_INT16U notValue OK"); + case 238: { + LogStep(238, "Read attribute NULLABLE_INT16U notValue OK"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16u::Id, true, chip::NullOptional); } - case 238: { - LogStep(238, "Write attribute NULLABLE_INT32U Min Value"); + case 239: { + LogStep(239, "Write attribute NULLABLE_INT32U Min Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44545,13 +44565,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32u::Id, value, chip::NullOptional, chip::NullOptional); } - case 239: { - LogStep(239, "Read attribute NULLABLE_INT32U Min Value"); + case 240: { + LogStep(240, "Read attribute NULLABLE_INT32U Min Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32u::Id, true, chip::NullOptional); } - case 240: { - LogStep(240, "Write attribute NULLABLE_INT32U Max Value"); + case 241: { + LogStep(241, "Write attribute NULLABLE_INT32U Max Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44559,13 +44579,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32u::Id, value, chip::NullOptional, chip::NullOptional); } - case 241: { - LogStep(241, "Read attribute NULLABLE_INT32U Max Value"); + case 242: { + LogStep(242, "Read attribute NULLABLE_INT32U Max Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32u::Id, true, chip::NullOptional); } - case 242: { - LogStep(242, "Write attribute NULLABLE_INT32U Invalid Value"); + case 243: { + LogStep(243, "Write attribute NULLABLE_INT32U Invalid Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44573,36 +44593,36 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32u::Id, value, chip::NullOptional, chip::NullOptional); } - case 243: { - LogStep(243, "Read attribute NULLABLE_INT32U unchanged Value"); + case 244: { + LogStep(244, "Read attribute NULLABLE_INT32U unchanged Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32u::Id, true, chip::NullOptional); } - case 244: { - LogStep(244, "Write attribute NULLABLE_INT32U null Value"); + case 245: { + LogStep(245, "Write attribute NULLABLE_INT32U null Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32u::Id, value, chip::NullOptional, chip::NullOptional); } - case 245: { - LogStep(245, "Read attribute NULLABLE_INT32U null Value"); - return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32u::Id, true, - chip::NullOptional); - } case 246: { - LogStep(246, "Read attribute NULLABLE_INT32U null Value & range"); + LogStep(246, "Read attribute NULLABLE_INT32U null Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32u::Id, true, chip::NullOptional); } case 247: { - LogStep(247, "Read attribute NULLABLE_INT32U null Value & not"); + LogStep(247, "Read attribute NULLABLE_INT32U null Value & range"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32u::Id, true, chip::NullOptional); } case 248: { - LogStep(248, "Write attribute NULLABLE_INT32U Value"); + LogStep(248, "Read attribute NULLABLE_INT32U null Value & not"); + return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32u::Id, true, + chip::NullOptional); + } + case 249: { + LogStep(249, "Write attribute NULLABLE_INT32U Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44610,18 +44630,18 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32u::Id, value, chip::NullOptional, chip::NullOptional); } - case 249: { - LogStep(249, "Read attribute NULLABLE_INT32U Value in range"); + case 250: { + LogStep(250, "Read attribute NULLABLE_INT32U Value in range"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32u::Id, true, chip::NullOptional); } - case 250: { - LogStep(250, "Read attribute NULLABLE_INT32U notValue OK"); + case 251: { + LogStep(251, "Read attribute NULLABLE_INT32U notValue OK"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32u::Id, true, chip::NullOptional); } - case 251: { - LogStep(251, "Write attribute NULLABLE_INT64U Min Value"); + case 252: { + LogStep(252, "Write attribute NULLABLE_INT64U Min Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44629,13 +44649,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64u::Id, value, chip::NullOptional, chip::NullOptional); } - case 252: { - LogStep(252, "Read attribute NULLABLE_INT64U Min Value"); + case 253: { + LogStep(253, "Read attribute NULLABLE_INT64U Min Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64u::Id, true, chip::NullOptional); } - case 253: { - LogStep(253, "Write attribute NULLABLE_INT64U Max Value"); + case 254: { + LogStep(254, "Write attribute NULLABLE_INT64U Max Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44643,13 +44663,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64u::Id, value, chip::NullOptional, chip::NullOptional); } - case 254: { - LogStep(254, "Read attribute NULLABLE_INT64U Max Value"); + case 255: { + LogStep(255, "Read attribute NULLABLE_INT64U Max Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64u::Id, true, chip::NullOptional); } - case 255: { - LogStep(255, "Write attribute NULLABLE_INT64U Invalid Value"); + case 256: { + LogStep(256, "Write attribute NULLABLE_INT64U Invalid Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44657,36 +44677,36 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64u::Id, value, chip::NullOptional, chip::NullOptional); } - case 256: { - LogStep(256, "Read attribute NULLABLE_INT64U unchanged Value"); + case 257: { + LogStep(257, "Read attribute NULLABLE_INT64U unchanged Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64u::Id, true, chip::NullOptional); } - case 257: { - LogStep(257, "Write attribute NULLABLE_INT64U null Value"); + case 258: { + LogStep(258, "Write attribute NULLABLE_INT64U null Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64u::Id, value, chip::NullOptional, chip::NullOptional); } - case 258: { - LogStep(258, "Read attribute NULLABLE_INT64U null Value"); - return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64u::Id, true, - chip::NullOptional); - } case 259: { - LogStep(259, "Read attribute NULLABLE_INT64U null Value & range"); + LogStep(259, "Read attribute NULLABLE_INT64U null Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64u::Id, true, chip::NullOptional); } case 260: { - LogStep(260, "Read attribute NULLABLE_INT64U null Value & not"); + LogStep(260, "Read attribute NULLABLE_INT64U null Value & range"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64u::Id, true, chip::NullOptional); } case 261: { - LogStep(261, "Write attribute NULLABLE_INT64U Value"); + LogStep(261, "Read attribute NULLABLE_INT64U null Value & not"); + return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64u::Id, true, + chip::NullOptional); + } + case 262: { + LogStep(262, "Write attribute NULLABLE_INT64U Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44694,18 +44714,18 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64u::Id, value, chip::NullOptional, chip::NullOptional); } - case 262: { - LogStep(262, "Read attribute NULLABLE_INT64U Value in range"); + case 263: { + LogStep(263, "Read attribute NULLABLE_INT64U Value in range"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64u::Id, true, chip::NullOptional); } - case 263: { - LogStep(263, "Read attribute NULLABLE_INT64U notValue OK"); + case 264: { + LogStep(264, "Read attribute NULLABLE_INT64U notValue OK"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64u::Id, true, chip::NullOptional); } - case 264: { - LogStep(264, "Write attribute NULLABLE_INT8S Min Value"); + case 265: { + LogStep(265, "Write attribute NULLABLE_INT8S Min Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44713,13 +44733,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 265: { - LogStep(265, "Read attribute NULLABLE_INT8S Min Value"); + case 266: { + LogStep(266, "Read attribute NULLABLE_INT8S Min Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8s::Id, true, chip::NullOptional); } - case 266: { - LogStep(266, "Write attribute NULLABLE_INT8S Invalid Value"); + case 267: { + LogStep(267, "Write attribute NULLABLE_INT8S Invalid Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44727,36 +44747,36 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 267: { - LogStep(267, "Read attribute NULLABLE_INT8S unchanged Value"); + case 268: { + LogStep(268, "Read attribute NULLABLE_INT8S unchanged Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8s::Id, true, chip::NullOptional); } - case 268: { - LogStep(268, "Write attribute NULLABLE_INT8S null Value"); + case 269: { + LogStep(269, "Write attribute NULLABLE_INT8S null Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 269: { - LogStep(269, "Read attribute NULLABLE_INT8S null Value"); - return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8s::Id, true, - chip::NullOptional); - } case 270: { - LogStep(270, "Read attribute NULLABLE_INT8S null Value & range"); + LogStep(270, "Read attribute NULLABLE_INT8S null Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8s::Id, true, chip::NullOptional); } case 271: { - LogStep(271, "Read attribute NULLABLE_INT8S null Value & not"); + LogStep(271, "Read attribute NULLABLE_INT8S null Value & range"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8s::Id, true, chip::NullOptional); } case 272: { - LogStep(272, "Write attribute NULLABLE_INT8S Value"); + LogStep(272, "Read attribute NULLABLE_INT8S null Value & not"); + return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8s::Id, true, + chip::NullOptional); + } + case 273: { + LogStep(273, "Write attribute NULLABLE_INT8S Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44764,18 +44784,18 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 273: { - LogStep(273, "Read attribute NULLABLE_INT8S Value in range"); + case 274: { + LogStep(274, "Read attribute NULLABLE_INT8S Value in range"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8s::Id, true, chip::NullOptional); } - case 274: { - LogStep(274, "Read attribute NULLABLE_INT8S notValue OK"); + case 275: { + LogStep(275, "Read attribute NULLABLE_INT8S notValue OK"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt8s::Id, true, chip::NullOptional); } - case 275: { - LogStep(275, "Write attribute NULLABLE_INT16S Min Value"); + case 276: { + LogStep(276, "Write attribute NULLABLE_INT16S Min Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44783,13 +44803,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 276: { - LogStep(276, "Read attribute NULLABLE_INT16S Min Value"); + case 277: { + LogStep(277, "Read attribute NULLABLE_INT16S Min Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16s::Id, true, chip::NullOptional); } - case 277: { - LogStep(277, "Write attribute NULLABLE_INT16S Invalid Value"); + case 278: { + LogStep(278, "Write attribute NULLABLE_INT16S Invalid Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44797,36 +44817,36 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 278: { - LogStep(278, "Read attribute NULLABLE_INT16S unchanged Value"); + case 279: { + LogStep(279, "Read attribute NULLABLE_INT16S unchanged Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16s::Id, true, chip::NullOptional); } - case 279: { - LogStep(279, "Write attribute NULLABLE_INT16S null Value"); + case 280: { + LogStep(280, "Write attribute NULLABLE_INT16S null Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 280: { - LogStep(280, "Read attribute NULLABLE_INT16S null Value"); - return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16s::Id, true, - chip::NullOptional); - } case 281: { - LogStep(281, "Read attribute NULLABLE_INT16S null Value & range"); + LogStep(281, "Read attribute NULLABLE_INT16S null Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16s::Id, true, chip::NullOptional); } case 282: { - LogStep(282, "Read attribute NULLABLE_INT16S null Value & not"); + LogStep(282, "Read attribute NULLABLE_INT16S null Value & range"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16s::Id, true, chip::NullOptional); } case 283: { - LogStep(283, "Write attribute NULLABLE_INT16S Value"); + LogStep(283, "Read attribute NULLABLE_INT16S null Value & not"); + return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16s::Id, true, + chip::NullOptional); + } + case 284: { + LogStep(284, "Write attribute NULLABLE_INT16S Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44834,18 +44854,18 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 284: { - LogStep(284, "Read attribute NULLABLE_INT16S Value in range"); + case 285: { + LogStep(285, "Read attribute NULLABLE_INT16S Value in range"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16s::Id, true, chip::NullOptional); } - case 285: { - LogStep(285, "Read attribute NULLABLE_INT16S notValue OK"); + case 286: { + LogStep(286, "Read attribute NULLABLE_INT16S notValue OK"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt16s::Id, true, chip::NullOptional); } - case 286: { - LogStep(286, "Write attribute NULLABLE_INT32S Min Value"); + case 287: { + LogStep(287, "Write attribute NULLABLE_INT32S Min Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44853,13 +44873,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32s::Id, value, chip::NullOptional, chip::NullOptional); } - case 287: { - LogStep(287, "Read attribute NULLABLE_INT32S Min Value"); + case 288: { + LogStep(288, "Read attribute NULLABLE_INT32S Min Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32s::Id, true, chip::NullOptional); } - case 288: { - LogStep(288, "Write attribute NULLABLE_INT32S Invalid Value"); + case 289: { + LogStep(289, "Write attribute NULLABLE_INT32S Invalid Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44867,36 +44887,36 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32s::Id, value, chip::NullOptional, chip::NullOptional); } - case 289: { - LogStep(289, "Read attribute NULLABLE_INT32S unchanged Value"); + case 290: { + LogStep(290, "Read attribute NULLABLE_INT32S unchanged Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32s::Id, true, chip::NullOptional); } - case 290: { - LogStep(290, "Write attribute NULLABLE_INT32S null Value"); + case 291: { + LogStep(291, "Write attribute NULLABLE_INT32S null Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32s::Id, value, chip::NullOptional, chip::NullOptional); } - case 291: { - LogStep(291, "Read attribute NULLABLE_INT32S null Value"); - return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32s::Id, true, - chip::NullOptional); - } case 292: { - LogStep(292, "Read attribute NULLABLE_INT32S null Value & range"); + LogStep(292, "Read attribute NULLABLE_INT32S null Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32s::Id, true, chip::NullOptional); } case 293: { - LogStep(293, "Read attribute NULLABLE_INT32S null Value & not"); + LogStep(293, "Read attribute NULLABLE_INT32S null Value & range"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32s::Id, true, chip::NullOptional); } case 294: { - LogStep(294, "Write attribute NULLABLE_INT32S Value"); + LogStep(294, "Read attribute NULLABLE_INT32S null Value & not"); + return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32s::Id, true, + chip::NullOptional); + } + case 295: { + LogStep(295, "Write attribute NULLABLE_INT32S Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44904,18 +44924,18 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32s::Id, value, chip::NullOptional, chip::NullOptional); } - case 295: { - LogStep(295, "Read attribute NULLABLE_INT32S Value in range"); + case 296: { + LogStep(296, "Read attribute NULLABLE_INT32S Value in range"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32s::Id, true, chip::NullOptional); } - case 296: { - LogStep(296, "Read attribute NULLABLE_INT32S notValue OK"); + case 297: { + LogStep(297, "Read attribute NULLABLE_INT32S notValue OK"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt32s::Id, true, chip::NullOptional); } - case 297: { - LogStep(297, "Write attribute NULLABLE_INT64S Min Value"); + case 298: { + LogStep(298, "Write attribute NULLABLE_INT64S Min Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44923,13 +44943,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64s::Id, value, chip::NullOptional, chip::NullOptional); } - case 298: { - LogStep(298, "Read attribute NULLABLE_INT64S Min Value"); + case 299: { + LogStep(299, "Read attribute NULLABLE_INT64S Min Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64s::Id, true, chip::NullOptional); } - case 299: { - LogStep(299, "Write attribute NULLABLE_INT64S Invalid Value"); + case 300: { + LogStep(300, "Write attribute NULLABLE_INT64S Invalid Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44937,36 +44957,36 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64s::Id, value, chip::NullOptional, chip::NullOptional); } - case 300: { - LogStep(300, "Read attribute NULLABLE_INT64S unchanged Value"); + case 301: { + LogStep(301, "Read attribute NULLABLE_INT64S unchanged Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64s::Id, true, chip::NullOptional); } - case 301: { - LogStep(301, "Write attribute NULLABLE_INT64S null Value"); + case 302: { + LogStep(302, "Write attribute NULLABLE_INT64S null Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64s::Id, value, chip::NullOptional, chip::NullOptional); } - case 302: { - LogStep(302, "Read attribute NULLABLE_INT64S null Value"); - return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64s::Id, true, - chip::NullOptional); - } case 303: { - LogStep(303, "Read attribute NULLABLE_INT64S null Value & range"); + LogStep(303, "Read attribute NULLABLE_INT64S null Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64s::Id, true, chip::NullOptional); } case 304: { - LogStep(304, "Read attribute NULLABLE_INT64S null Value & not"); + LogStep(304, "Read attribute NULLABLE_INT64S null Value & range"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64s::Id, true, chip::NullOptional); } case 305: { - LogStep(305, "Write attribute NULLABLE_INT64S Value"); + LogStep(305, "Read attribute NULLABLE_INT64S null Value & not"); + return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64s::Id, true, + chip::NullOptional); + } + case 306: { + LogStep(306, "Write attribute NULLABLE_INT64S Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44974,18 +44994,18 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64s::Id, value, chip::NullOptional, chip::NullOptional); } - case 306: { - LogStep(306, "Read attribute NULLABLE_INT64S Value in range"); + case 307: { + LogStep(307, "Read attribute NULLABLE_INT64S Value in range"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64s::Id, true, chip::NullOptional); } - case 307: { - LogStep(307, "Read attribute NULLABLE_INT64S notValue OK"); + case 308: { + LogStep(308, "Read attribute NULLABLE_INT64S notValue OK"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableInt64s::Id, true, chip::NullOptional); } - case 308: { - LogStep(308, "Write attribute NULLABLE_SINGLE medium Value"); + case 309: { + LogStep(309, "Write attribute NULLABLE_SINGLE medium Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -44993,13 +45013,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatSingle::Id, value, chip::NullOptional, chip::NullOptional); } - case 309: { - LogStep(309, "Read attribute NULLABLE_SINGLE medium Value"); + case 310: { + LogStep(310, "Read attribute NULLABLE_SINGLE medium Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatSingle::Id, true, chip::NullOptional); } - case 310: { - LogStep(310, "Write attribute NULLABLE_SINGLE largest Value"); + case 311: { + LogStep(311, "Write attribute NULLABLE_SINGLE largest Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45007,13 +45027,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatSingle::Id, value, chip::NullOptional, chip::NullOptional); } - case 311: { - LogStep(311, "Read attribute NULLABLE_SINGLE largest Value"); + case 312: { + LogStep(312, "Read attribute NULLABLE_SINGLE largest Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatSingle::Id, true, chip::NullOptional); } - case 312: { - LogStep(312, "Write attribute NULLABLE_SINGLE smallest Value"); + case 313: { + LogStep(313, "Write attribute NULLABLE_SINGLE smallest Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45021,26 +45041,26 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatSingle::Id, value, chip::NullOptional, chip::NullOptional); } - case 313: { - LogStep(313, "Read attribute NULLABLE_SINGLE smallest Value"); + case 314: { + LogStep(314, "Read attribute NULLABLE_SINGLE smallest Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatSingle::Id, true, chip::NullOptional); } - case 314: { - LogStep(314, "Write attribute NULLABLE_SINGLE null Value"); + case 315: { + LogStep(315, "Write attribute NULLABLE_SINGLE null Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatSingle::Id, value, chip::NullOptional, chip::NullOptional); } - case 315: { - LogStep(315, "Read attribute NULLABLE_SINGLE null Value"); + case 316: { + LogStep(316, "Read attribute NULLABLE_SINGLE null Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatSingle::Id, true, chip::NullOptional); } - case 316: { - LogStep(316, "Write attribute NULLABLE_SINGLE 0 Value"); + case 317: { + LogStep(317, "Write attribute NULLABLE_SINGLE 0 Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45048,13 +45068,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatSingle::Id, value, chip::NullOptional, chip::NullOptional); } - case 317: { - LogStep(317, "Read attribute NULLABLE_SINGLE 0 Value"); + case 318: { + LogStep(318, "Read attribute NULLABLE_SINGLE 0 Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatSingle::Id, true, chip::NullOptional); } - case 318: { - LogStep(318, "Write attribute NULLABLE_DOUBLE medium Value"); + case 319: { + LogStep(319, "Write attribute NULLABLE_DOUBLE medium Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45062,13 +45082,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatDouble::Id, value, chip::NullOptional, chip::NullOptional); } - case 319: { - LogStep(319, "Read attribute NULLABLE_DOUBLE medium Value"); + case 320: { + LogStep(320, "Read attribute NULLABLE_DOUBLE medium Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatDouble::Id, true, chip::NullOptional); } - case 320: { - LogStep(320, "Write attribute NULLABLE_DOUBLE largest Value"); + case 321: { + LogStep(321, "Write attribute NULLABLE_DOUBLE largest Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45076,13 +45096,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatDouble::Id, value, chip::NullOptional, chip::NullOptional); } - case 321: { - LogStep(321, "Read attribute NULLABLE_DOUBLE largest Value"); + case 322: { + LogStep(322, "Read attribute NULLABLE_DOUBLE largest Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatDouble::Id, true, chip::NullOptional); } - case 322: { - LogStep(322, "Write attribute NULLABLE_DOUBLE smallest Value"); + case 323: { + LogStep(323, "Write attribute NULLABLE_DOUBLE smallest Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45090,26 +45110,26 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatDouble::Id, value, chip::NullOptional, chip::NullOptional); } - case 323: { - LogStep(323, "Read attribute NULLABLE_DOUBLE smallest Value"); + case 324: { + LogStep(324, "Read attribute NULLABLE_DOUBLE smallest Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatDouble::Id, true, chip::NullOptional); } - case 324: { - LogStep(324, "Write attribute NULLABLE_DOUBLE null Value"); + case 325: { + LogStep(325, "Write attribute NULLABLE_DOUBLE null Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatDouble::Id, value, chip::NullOptional, chip::NullOptional); } - case 325: { - LogStep(325, "Read attribute NULLABLE_DOUBLE null Value"); + case 326: { + LogStep(326, "Read attribute NULLABLE_DOUBLE null Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatDouble::Id, true, chip::NullOptional); } - case 326: { - LogStep(326, "Write attribute NULLABLE_DOUBLE 0 Value"); + case 327: { + LogStep(327, "Write attribute NULLABLE_DOUBLE 0 Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45117,13 +45137,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatDouble::Id, value, chip::NullOptional, chip::NullOptional); } - case 327: { - LogStep(327, "Read attribute NULLABLE_DOUBLE 0 Value"); + case 328: { + LogStep(328, "Read attribute NULLABLE_DOUBLE 0 Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableFloatDouble::Id, true, chip::NullOptional); } - case 328: { - LogStep(328, "Write attribute NULLABLE_ENUM8 Min Value"); + case 329: { + LogStep(329, "Write attribute NULLABLE_ENUM8 Min Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45131,13 +45151,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnum8::Id, value, chip::NullOptional, chip::NullOptional); } - case 329: { - LogStep(329, "Read attribute NULLABLE_ENUM8 Min Value"); + case 330: { + LogStep(330, "Read attribute NULLABLE_ENUM8 Min Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnum8::Id, true, chip::NullOptional); } - case 330: { - LogStep(330, "Write attribute NULLABLE_ENUM8 Max Value"); + case 331: { + LogStep(331, "Write attribute NULLABLE_ENUM8 Max Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45145,13 +45165,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnum8::Id, value, chip::NullOptional, chip::NullOptional); } - case 331: { - LogStep(331, "Read attribute NULLABLE_ENUM8 Max Value"); + case 332: { + LogStep(332, "Read attribute NULLABLE_ENUM8 Max Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnum8::Id, true, chip::NullOptional); } - case 332: { - LogStep(332, "Write attribute NULLABLE_ENUM8 Invalid Value"); + case 333: { + LogStep(333, "Write attribute NULLABLE_ENUM8 Invalid Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45159,26 +45179,26 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnum8::Id, value, chip::NullOptional, chip::NullOptional); } - case 333: { - LogStep(333, "Read attribute NULLABLE_ENUM8 unchanged Value"); + case 334: { + LogStep(334, "Read attribute NULLABLE_ENUM8 unchanged Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnum8::Id, true, chip::NullOptional); } - case 334: { - LogStep(334, "Write attribute NULLABLE_ENUM8 null Value"); + case 335: { + LogStep(335, "Write attribute NULLABLE_ENUM8 null Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnum8::Id, value, chip::NullOptional, chip::NullOptional); } - case 335: { - LogStep(335, "Read attribute NULLABLE_ENUM8 null Value"); + case 336: { + LogStep(336, "Read attribute NULLABLE_ENUM8 null Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnum8::Id, true, chip::NullOptional); } - case 336: { - LogStep(336, "Write attribute NULLABLE_ENUM16 Min Value"); + case 337: { + LogStep(337, "Write attribute NULLABLE_ENUM16 Min Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45186,13 +45206,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnum16::Id, value, chip::NullOptional, chip::NullOptional); } - case 337: { - LogStep(337, "Read attribute NULLABLE_ENUM16 Min Value"); + case 338: { + LogStep(338, "Read attribute NULLABLE_ENUM16 Min Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnum16::Id, true, chip::NullOptional); } - case 338: { - LogStep(338, "Write attribute NULLABLE_ENUM16 Max Value"); + case 339: { + LogStep(339, "Write attribute NULLABLE_ENUM16 Max Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45200,13 +45220,13 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnum16::Id, value, chip::NullOptional, chip::NullOptional); } - case 339: { - LogStep(339, "Read attribute NULLABLE_ENUM16 Max Value"); + case 340: { + LogStep(340, "Read attribute NULLABLE_ENUM16 Max Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnum16::Id, true, chip::NullOptional); } - case 340: { - LogStep(340, "Write attribute NULLABLE_ENUM16 Invalid Value"); + case 341: { + LogStep(341, "Write attribute NULLABLE_ENUM16 Invalid Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45214,26 +45234,26 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnum16::Id, value, chip::NullOptional, chip::NullOptional); } - case 341: { - LogStep(341, "Read attribute NULLABLE_ENUM16 unchanged Value"); + case 342: { + LogStep(342, "Read attribute NULLABLE_ENUM16 unchanged Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnum16::Id, true, chip::NullOptional); } - case 342: { - LogStep(342, "Write attribute NULLABLE_ENUM16 null Value"); + case 343: { + LogStep(343, "Write attribute NULLABLE_ENUM16 null Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnum16::Id, value, chip::NullOptional, chip::NullOptional); } - case 343: { - LogStep(343, "Read attribute NULLABLE_ENUM16 null Value"); + case 344: { + LogStep(344, "Read attribute NULLABLE_ENUM16 null Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnum16::Id, true, chip::NullOptional); } - case 344: { - LogStep(344, "Write attribute NULLABLE_SIMPLE_ENUM Min Value"); + case 345: { + LogStep(345, "Write attribute NULLABLE_SIMPLE_ENUM Min Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45241,27 +45261,27 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnumAttr::Id, value, chip::NullOptional, chip::NullOptional); } - case 345: { - LogStep(345, "Read attribute NULLABLE_SIMPLE_ENUM Min Value"); + case 346: { + LogStep(346, "Read attribute NULLABLE_SIMPLE_ENUM Min Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnumAttr::Id, true, chip::NullOptional); } - case 346: { - LogStep(346, "Write attribute NULLABLE_SIMPLE_ENUM Max Value"); + case 347: { + LogStep(347, "Write attribute NULLABLE_SIMPLE_ENUM Max Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); - value.Value() = static_cast(254); + value.Value() = static_cast(3); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnumAttr::Id, value, chip::NullOptional, chip::NullOptional); } - case 347: { - LogStep(347, "Read attribute NULLABLE_SIMPLE_ENUM Max Value"); + case 348: { + LogStep(348, "Read attribute NULLABLE_SIMPLE_ENUM Max Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnumAttr::Id, true, chip::NullOptional); } - case 348: { - LogStep(348, "Write attribute NULLABLE_SIMPLE_ENUM Invalid Value"); + case 349: { + LogStep(349, "Write attribute NULLABLE_SIMPLE_ENUM Invalid Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45269,36 +45289,36 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnumAttr::Id, value, chip::NullOptional, chip::NullOptional); } - case 349: { - LogStep(349, "Read attribute NULLABLE_SIMPLE_ENUM unchanged Value"); + case 350: { + LogStep(350, "Read attribute NULLABLE_SIMPLE_ENUM unchanged Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnumAttr::Id, true, chip::NullOptional); } - case 350: { - LogStep(350, "Write attribute NULLABLE_SIMPLE_ENUM null Value"); + case 351: { + LogStep(351, "Write attribute NULLABLE_SIMPLE_ENUM null Value"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnumAttr::Id, value, chip::NullOptional, chip::NullOptional); } - case 351: { - LogStep(351, "Read attribute NULLABLE_SIMPLE_ENUM null Value"); + case 352: { + LogStep(352, "Read attribute NULLABLE_SIMPLE_ENUM null Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnumAttr::Id, true, chip::NullOptional); } - case 352: { - LogStep(352, "Read attribute NULLABLE_SIMPLE_ENUM not 254 Value"); + case 353: { + LogStep(353, "Read attribute NULLABLE_SIMPLE_ENUM not 3 Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableEnumAttr::Id, true, chip::NullOptional); } - case 353: { - LogStep(353, "Read attribute NULLABLE_OCTET_STRING Default Value"); + case 354: { + LogStep(354, "Read attribute NULLABLE_OCTET_STRING Default Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableOctetString::Id, true, chip::NullOptional); } - case 354: { - LogStep(354, "Write attribute NULLABLE_OCTET_STRING"); + case 355: { + LogStep(355, "Write attribute NULLABLE_OCTET_STRING"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45306,26 +45326,26 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableOctetString::Id, value, chip::NullOptional, chip::NullOptional); } - case 355: { - LogStep(355, "Read attribute NULLABLE_OCTET_STRING"); + case 356: { + LogStep(356, "Read attribute NULLABLE_OCTET_STRING"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableOctetString::Id, true, chip::NullOptional); } - case 356: { - LogStep(356, "Write attribute NULLABLE_OCTET_STRING"); + case 357: { + LogStep(357, "Write attribute NULLABLE_OCTET_STRING"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableOctetString::Id, value, chip::NullOptional, chip::NullOptional); } - case 357: { - LogStep(357, "Read attribute NULLABLE_OCTET_STRING"); + case 358: { + LogStep(358, "Read attribute NULLABLE_OCTET_STRING"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableOctetString::Id, true, chip::NullOptional); } - case 358: { - LogStep(358, "Write attribute NULLABLE_OCTET_STRING"); + case 359: { + LogStep(359, "Write attribute NULLABLE_OCTET_STRING"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45333,23 +45353,23 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableOctetString::Id, value, chip::NullOptional, chip::NullOptional); } - case 359: { - LogStep(359, "Read attribute NULLABLE_OCTET_STRING"); + case 360: { + LogStep(360, "Read attribute NULLABLE_OCTET_STRING"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableOctetString::Id, true, chip::NullOptional); } - case 360: { - LogStep(360, "Read attribute NULLABLE_OCTET_STRING not TestValue"); + case 361: { + LogStep(361, "Read attribute NULLABLE_OCTET_STRING not TestValue"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableOctetString::Id, true, chip::NullOptional); } - case 361: { - LogStep(361, "Read attribute NULLABLE_CHAR_STRING Default Value"); + case 362: { + LogStep(362, "Read attribute NULLABLE_CHAR_STRING Default Value"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableCharString::Id, true, chip::NullOptional); } - case 362: { - LogStep(362, "Write attribute NULLABLE_CHAR_STRING"); + case 363: { + LogStep(363, "Write attribute NULLABLE_CHAR_STRING"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45357,31 +45377,31 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableCharString::Id, value, chip::NullOptional, chip::NullOptional); } - case 363: { - LogStep(363, "Read attribute NULLABLE_CHAR_STRING"); - return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableCharString::Id, - true, chip::NullOptional); - } case 364: { LogStep(364, "Read attribute NULLABLE_CHAR_STRING"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableCharString::Id, true, chip::NullOptional); } case 365: { - LogStep(365, "Write attribute NULLABLE_CHAR_STRING - Value too long"); + LogStep(365, "Read attribute NULLABLE_CHAR_STRING"); + return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableCharString::Id, + true, chip::NullOptional); + } + case 366: { + LogStep(366, "Write attribute NULLABLE_CHAR_STRING - Value too long"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableCharString::Id, value, chip::NullOptional, chip::NullOptional); } - case 366: { - LogStep(366, "Read attribute NULLABLE_CHAR_STRING"); + case 367: { + LogStep(367, "Read attribute NULLABLE_CHAR_STRING"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableCharString::Id, true, chip::NullOptional); } - case 367: { - LogStep(367, "Write attribute NULLABLE_CHAR_STRING - Empty"); + case 368: { + LogStep(368, "Write attribute NULLABLE_CHAR_STRING - Empty"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45389,28 +45409,28 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableCharString::Id, value, chip::NullOptional, chip::NullOptional); } - case 368: { - LogStep(368, "Read attribute NULLABLE_CHAR_STRING"); + case 369: { + LogStep(369, "Read attribute NULLABLE_CHAR_STRING"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableCharString::Id, true, chip::NullOptional); } - case 369: { - LogStep(369, "Read attribute NULLABLE_CHAR_STRING not ☉T☉"); + case 370: { + LogStep(370, "Read attribute NULLABLE_CHAR_STRING not ☉T☉"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableCharString::Id, true, chip::NullOptional); } - case 370: { - LogStep(370, "Read attribute from nonexistent endpoint."); + case 371: { + LogStep(371, "Read attribute from nonexistent endpoint."); return ReadAttribute(kIdentityAlpha, GetEndpoint(200), TestCluster::Id, TestCluster::Attributes::ListInt8u::Id, true, chip::NullOptional); } - case 371: { - LogStep(371, "Read attribute from nonexistent cluster."); + case 372: { + LogStep(372, "Read attribute from nonexistent cluster."); return ReadAttribute(kIdentityAlpha, GetEndpoint(0), TestCluster::Id, TestCluster::Attributes::ListInt8u::Id, true, chip::NullOptional); } - case 372: { - LogStep(372, "Send a command that takes an optional parameter but do not set it."); + case 373: { + LogStep(373, "Send a command that takes an optional parameter but do not set it."); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestSimpleOptionalArgumentRequest::Type value; return SendCommand(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, @@ -45418,8 +45438,8 @@ class TestClusterSuite : public TestCommand ); } - case 373: { - LogStep(373, "Send a command that takes an optional parameter but do not set it."); + case 374: { + LogStep(374, "Send a command that takes an optional parameter but do not set it."); ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestSimpleOptionalArgumentRequest::Type value; value.arg1.Emplace(); @@ -45429,13 +45449,13 @@ class TestClusterSuite : public TestCommand ); } - case 374: { - LogStep(374, "Subscribe to list attribute"); + case 375: { + LogStep(375, "Subscribe to list attribute"); return SubscribeAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::ListInt8u::Id, 2, 5, true, chip::NullOptional, chip::NullOptional); } - case 375: { - LogStep(375, "Write subscribed-to list attribute"); + case 376: { + LogStep(376, "Write subscribed-to list attribute"); ListFreer listFreer; chip::app::DataModel::List value; @@ -45451,98 +45471,98 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::ListInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 376: { - LogStep(376, "Check for list attribute report"); + case 377: { + LogStep(377, "Check for list attribute report"); return WaitForReport(); } - case 377: { - LogStep(377, "Read range-restricted unsigned 8-bit integer"); + case 378: { + LogStep(378, "Read range-restricted unsigned 8-bit integer"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8u::Id, true, chip::NullOptional); } - case 378: { - LogStep(378, "Write min value to a range-restricted unsigned 8-bit integer"); + case 379: { + LogStep(379, "Write min value to a range-restricted unsigned 8-bit integer"); ListFreer listFreer; uint8_t value; value = 0U; return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 379: { - LogStep(379, "Write just-below-range value to a range-restricted unsigned 8-bit integer"); + case 380: { + LogStep(380, "Write just-below-range value to a range-restricted unsigned 8-bit integer"); ListFreer listFreer; uint8_t value; value = 19U; return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 380: { - LogStep(380, "Write just-above-range value to a range-restricted unsigned 8-bit integer"); + case 381: { + LogStep(381, "Write just-above-range value to a range-restricted unsigned 8-bit integer"); ListFreer listFreer; uint8_t value; value = 101U; return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 381: { - LogStep(381, "Write max value to a range-restricted unsigned 8-bit integer"); + case 382: { + LogStep(382, "Write max value to a range-restricted unsigned 8-bit integer"); ListFreer listFreer; uint8_t value; value = 255U; return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 382: { - LogStep(382, "Verify range-restricted unsigned 8-bit integer value has not changed"); + case 383: { + LogStep(383, "Verify range-restricted unsigned 8-bit integer value has not changed"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8u::Id, true, chip::NullOptional); } - case 383: { - LogStep(383, "Write min valid value to a range-restricted unsigned 8-bit integer"); + case 384: { + LogStep(384, "Write min valid value to a range-restricted unsigned 8-bit integer"); ListFreer listFreer; uint8_t value; value = 20U; return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 384: { - LogStep(384, "Verify range-restricted unsigned 8-bit integer value is at min valid"); + case 385: { + LogStep(385, "Verify range-restricted unsigned 8-bit integer value is at min valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8u::Id, true, chip::NullOptional); } - case 385: { - LogStep(385, "Write max valid value to a range-restricted unsigned 8-bit integer"); + case 386: { + LogStep(386, "Write max valid value to a range-restricted unsigned 8-bit integer"); ListFreer listFreer; uint8_t value; value = 100U; return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 386: { - LogStep(386, "Verify range-restricted unsigned 8-bit integer value is at max valid"); + case 387: { + LogStep(387, "Verify range-restricted unsigned 8-bit integer value is at max valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8u::Id, true, chip::NullOptional); } - case 387: { - LogStep(387, "Write middle valid value to a range-restricted unsigned 8-bit integer"); + case 388: { + LogStep(388, "Write middle valid value to a range-restricted unsigned 8-bit integer"); ListFreer listFreer; uint8_t value; value = 50U; return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 388: { - LogStep(388, "Verify range-restricted unsigned 8-bit integer value is at mid valid"); + case 389: { + LogStep(389, "Verify range-restricted unsigned 8-bit integer value is at mid valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8u::Id, true, chip::NullOptional); } - case 389: { - LogStep(389, "Read range-restricted unsigned 16-bit integer"); + case 390: { + LogStep(390, "Read range-restricted unsigned 16-bit integer"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt16u::Id, true, chip::NullOptional); } - case 390: { - LogStep(390, "Write min value to a range-restricted unsigned 16-bit integer"); + case 391: { + LogStep(391, "Write min value to a range-restricted unsigned 16-bit integer"); ListFreer listFreer; uint16_t value; value = 0U; @@ -45550,8 +45570,8 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::RangeRestrictedInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 391: { - LogStep(391, "Write just-below-range value to a range-restricted unsigned 16-bit integer"); + case 392: { + LogStep(392, "Write just-below-range value to a range-restricted unsigned 16-bit integer"); ListFreer listFreer; uint16_t value; value = 99U; @@ -45559,8 +45579,8 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::RangeRestrictedInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 392: { - LogStep(392, "Write just-above-range value to a range-restricted unsigned 16-bit integer"); + case 393: { + LogStep(393, "Write just-above-range value to a range-restricted unsigned 16-bit integer"); ListFreer listFreer; uint16_t value; value = 1001U; @@ -45568,8 +45588,8 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::RangeRestrictedInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 393: { - LogStep(393, "Write max value to a range-restricted unsigned 16-bit integer"); + case 394: { + LogStep(394, "Write max value to a range-restricted unsigned 16-bit integer"); ListFreer listFreer; uint16_t value; value = 65535U; @@ -45577,13 +45597,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::RangeRestrictedInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 394: { - LogStep(394, "Verify range-restricted unsigned 16-bit integer value has not changed"); + case 395: { + LogStep(395, "Verify range-restricted unsigned 16-bit integer value has not changed"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt16u::Id, true, chip::NullOptional); } - case 395: { - LogStep(395, "Write min valid value to a range-restricted unsigned 16-bit integer"); + case 396: { + LogStep(396, "Write min valid value to a range-restricted unsigned 16-bit integer"); ListFreer listFreer; uint16_t value; value = 100U; @@ -45591,13 +45611,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::RangeRestrictedInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 396: { - LogStep(396, "Verify range-restricted unsigned 16-bit integer value is at min valid"); + case 397: { + LogStep(397, "Verify range-restricted unsigned 16-bit integer value is at min valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt16u::Id, true, chip::NullOptional); } - case 397: { - LogStep(397, "Write max valid value to a range-restricted unsigned 16-bit integer"); + case 398: { + LogStep(398, "Write max valid value to a range-restricted unsigned 16-bit integer"); ListFreer listFreer; uint16_t value; value = 1000U; @@ -45605,13 +45625,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::RangeRestrictedInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 398: { - LogStep(398, "Verify range-restricted unsigned 16-bit integer value is at max valid"); + case 399: { + LogStep(399, "Verify range-restricted unsigned 16-bit integer value is at max valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt16u::Id, true, chip::NullOptional); } - case 399: { - LogStep(399, "Write middle valid value to a range-restricted unsigned 16-bit integer"); + case 400: { + LogStep(400, "Write middle valid value to a range-restricted unsigned 16-bit integer"); ListFreer listFreer; uint16_t value; value = 500U; @@ -45619,99 +45639,99 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::RangeRestrictedInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 400: { - LogStep(400, "Verify range-restricted unsigned 16-bit integer value is at mid valid"); + case 401: { + LogStep(401, "Verify range-restricted unsigned 16-bit integer value is at mid valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt16u::Id, true, chip::NullOptional); } - case 401: { - LogStep(401, "Read range-restricted signed 8-bit integer"); + case 402: { + LogStep(402, "Read range-restricted signed 8-bit integer"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8s::Id, true, chip::NullOptional); } - case 402: { - LogStep(402, "Write min value to a range-restricted signed 8-bit integer"); + case 403: { + LogStep(403, "Write min value to a range-restricted signed 8-bit integer"); ListFreer listFreer; int8_t value; value = -128; return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 403: { - LogStep(403, "Write just-below-range value to a range-restricted signed 8-bit integer"); + case 404: { + LogStep(404, "Write just-below-range value to a range-restricted signed 8-bit integer"); ListFreer listFreer; int8_t value; value = -41; return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 404: { - LogStep(404, "Write just-above-range value to a range-restricted signed 8-bit integer"); + case 405: { + LogStep(405, "Write just-above-range value to a range-restricted signed 8-bit integer"); ListFreer listFreer; int8_t value; value = 51; return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 405: { - LogStep(405, "Write max value to a range-restricted signed 8-bit integer"); + case 406: { + LogStep(406, "Write max value to a range-restricted signed 8-bit integer"); ListFreer listFreer; int8_t value; value = 127; return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 406: { - LogStep(406, "Verify range-restricted signed 8-bit integer value has not changed"); + case 407: { + LogStep(407, "Verify range-restricted signed 8-bit integer value has not changed"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8s::Id, true, chip::NullOptional); } - case 407: { - LogStep(407, "Write min valid value to a range-restricted signed 8-bit integer"); + case 408: { + LogStep(408, "Write min valid value to a range-restricted signed 8-bit integer"); ListFreer listFreer; int8_t value; value = -40; return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 408: { - LogStep(408, "Verify range-restricted signed 8-bit integer value is at min valid"); + case 409: { + LogStep(409, "Verify range-restricted signed 8-bit integer value is at min valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8s::Id, true, chip::NullOptional); } - case 409: { - LogStep(409, "Write max valid value to a range-restricted signed 8-bit integer"); + case 410: { + LogStep(410, "Write max valid value to a range-restricted signed 8-bit integer"); ListFreer listFreer; int8_t value; value = 50; return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 410: { - LogStep(410, "Verify range-restricted signed 8-bit integer value is at max valid"); + case 411: { + LogStep(411, "Verify range-restricted signed 8-bit integer value is at max valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8s::Id, true, chip::NullOptional); } - case 411: { - LogStep(411, "Write middle valid value to a range-restricted signed 8-bit integer"); + case 412: { + LogStep(412, "Write middle valid value to a range-restricted signed 8-bit integer"); ListFreer listFreer; int8_t value; value = 6; return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 412: { - LogStep(412, "Verify range-restricted signed 8-bit integer value is at mid valid"); + case 413: { + LogStep(413, "Verify range-restricted signed 8-bit integer value is at mid valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt8s::Id, true, chip::NullOptional); } - case 413: { - LogStep(413, "Read range-restricted signed 16-bit integer"); + case 414: { + LogStep(414, "Read range-restricted signed 16-bit integer"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt16s::Id, true, chip::NullOptional); } - case 414: { - LogStep(414, "Write min value to a range-restricted signed 16-bit integer"); + case 415: { + LogStep(415, "Write min value to a range-restricted signed 16-bit integer"); ListFreer listFreer; int16_t value; value = -32768; @@ -45719,8 +45739,8 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::RangeRestrictedInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 415: { - LogStep(415, "Write just-below-range value to a range-restricted signed 16-bit integer"); + case 416: { + LogStep(416, "Write just-below-range value to a range-restricted signed 16-bit integer"); ListFreer listFreer; int16_t value; value = -151; @@ -45728,8 +45748,8 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::RangeRestrictedInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 416: { - LogStep(416, "Write just-above-range value to a range-restricted signed 16-bit integer"); + case 417: { + LogStep(417, "Write just-above-range value to a range-restricted signed 16-bit integer"); ListFreer listFreer; int16_t value; value = 201; @@ -45737,8 +45757,8 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::RangeRestrictedInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 417: { - LogStep(417, "Write max value to a range-restricted signed 16-bit integer"); + case 418: { + LogStep(418, "Write max value to a range-restricted signed 16-bit integer"); ListFreer listFreer; int16_t value; value = 32767; @@ -45746,13 +45766,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::RangeRestrictedInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 418: { - LogStep(418, "Verify range-restricted signed 16-bit integer value has not changed"); + case 419: { + LogStep(419, "Verify range-restricted signed 16-bit integer value has not changed"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt16s::Id, true, chip::NullOptional); } - case 419: { - LogStep(419, "Write min valid value to a range-restricted signed 16-bit integer"); + case 420: { + LogStep(420, "Write min valid value to a range-restricted signed 16-bit integer"); ListFreer listFreer; int16_t value; value = -150; @@ -45760,13 +45780,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::RangeRestrictedInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 420: { - LogStep(420, "Verify range-restricted signed 16-bit integer value is at min valid"); + case 421: { + LogStep(421, "Verify range-restricted signed 16-bit integer value is at min valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt16s::Id, true, chip::NullOptional); } - case 421: { - LogStep(421, "Write max valid value to a range-restricted signed 16-bit integer"); + case 422: { + LogStep(422, "Write max valid value to a range-restricted signed 16-bit integer"); ListFreer listFreer; int16_t value; value = 200; @@ -45774,13 +45794,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::RangeRestrictedInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 422: { - LogStep(422, "Verify range-restricted signed 16-bit integer value is at max valid"); + case 423: { + LogStep(423, "Verify range-restricted signed 16-bit integer value is at max valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt16s::Id, true, chip::NullOptional); } - case 423: { - LogStep(423, "Write middle valid value to a range-restricted signed 16-bit integer"); + case 424: { + LogStep(424, "Write middle valid value to a range-restricted signed 16-bit integer"); ListFreer listFreer; int16_t value; value = 7; @@ -45788,18 +45808,18 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::RangeRestrictedInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 424: { - LogStep(424, "Verify range-restricted signed 16-bit integer value is at mid valid"); + case 425: { + LogStep(425, "Verify range-restricted signed 16-bit integer value is at mid valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::RangeRestrictedInt16s::Id, true, chip::NullOptional); } - case 425: { - LogStep(425, "Read nullable range-restricted unsigned 8-bit integer"); + case 426: { + LogStep(426, "Read nullable range-restricted unsigned 8-bit integer"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt8u::Id, true, chip::NullOptional); } - case 426: { - LogStep(426, "Write min value to a nullable range-restricted unsigned 8-bit integer"); + case 427: { + LogStep(427, "Write min value to a nullable range-restricted unsigned 8-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45808,8 +45828,8 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 427: { - LogStep(427, "Write just-below-range value to a nullable range-restricted unsigned 8-bit integer"); + case 428: { + LogStep(428, "Write just-below-range value to a nullable range-restricted unsigned 8-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45818,8 +45838,8 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 428: { - LogStep(428, "Write just-above-range value to a nullable range-restricted unsigned 8-bit integer"); + case 429: { + LogStep(429, "Write just-above-range value to a nullable range-restricted unsigned 8-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45828,8 +45848,8 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 429: { - LogStep(429, "Write max value to a nullable range-restricted unsigned 8-bit integer"); + case 430: { + LogStep(430, "Write max value to a nullable range-restricted unsigned 8-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45838,13 +45858,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 430: { - LogStep(430, "Verify nullable range-restricted unsigned 8-bit integer value has not changed"); + case 431: { + LogStep(431, "Verify nullable range-restricted unsigned 8-bit integer value has not changed"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt8u::Id, true, chip::NullOptional); } - case 431: { - LogStep(431, "Write min valid value to a nullable range-restricted unsigned 8-bit integer"); + case 432: { + LogStep(432, "Write min valid value to a nullable range-restricted unsigned 8-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45853,13 +45873,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 432: { - LogStep(432, "Verify nullable range-restricted unsigned 8-bit integer value is at min valid"); + case 433: { + LogStep(433, "Verify nullable range-restricted unsigned 8-bit integer value is at min valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt8u::Id, true, chip::NullOptional); } - case 433: { - LogStep(433, "Write max valid value to a nullable range-restricted unsigned 8-bit integer"); + case 434: { + LogStep(434, "Write max valid value to a nullable range-restricted unsigned 8-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45868,13 +45888,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 434: { - LogStep(434, "Verify nullable range-restricted unsigned 8-bit integer value is at max valid"); + case 435: { + LogStep(435, "Verify nullable range-restricted unsigned 8-bit integer value is at max valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt8u::Id, true, chip::NullOptional); } - case 435: { - LogStep(435, "Write middle valid value to a nullable range-restricted unsigned 8-bit integer"); + case 436: { + LogStep(436, "Write middle valid value to a nullable range-restricted unsigned 8-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45883,13 +45903,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 436: { - LogStep(436, "Verify nullable range-restricted unsigned 8-bit integer value is at mid valid"); + case 437: { + LogStep(437, "Verify nullable range-restricted unsigned 8-bit integer value is at mid valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt8u::Id, true, chip::NullOptional); } - case 437: { - LogStep(437, "Write null value to a nullable range-restricted unsigned 8-bit integer"); + case 438: { + LogStep(438, "Write null value to a nullable range-restricted unsigned 8-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); @@ -45897,18 +45917,18 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt8u::Id, value, chip::NullOptional, chip::NullOptional); } - case 438: { - LogStep(438, "Verify nullable range-restricted unsigned 8-bit integer value is null"); + case 439: { + LogStep(439, "Verify nullable range-restricted unsigned 8-bit integer value is null"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt8u::Id, true, chip::NullOptional); } - case 439: { - LogStep(439, "Read nullable range-restricted unsigned 16-bit integer"); + case 440: { + LogStep(440, "Read nullable range-restricted unsigned 16-bit integer"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt16u::Id, true, chip::NullOptional); } - case 440: { - LogStep(440, "Write min value to a nullable range-restricted unsigned 16-bit integer"); + case 441: { + LogStep(441, "Write min value to a nullable range-restricted unsigned 16-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45917,8 +45937,8 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 441: { - LogStep(441, "Write just-below-range value to a nullable range-restricted unsigned 16-bit integer"); + case 442: { + LogStep(442, "Write just-below-range value to a nullable range-restricted unsigned 16-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45927,8 +45947,8 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 442: { - LogStep(442, "Write just-above-range value to a nullable range-restricted unsigned 16-bit integer"); + case 443: { + LogStep(443, "Write just-above-range value to a nullable range-restricted unsigned 16-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45937,8 +45957,8 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 443: { - LogStep(443, "Write max value to a nullable range-restricted unsigned 16-bit integer"); + case 444: { + LogStep(444, "Write max value to a nullable range-restricted unsigned 16-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45947,13 +45967,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 444: { - LogStep(444, "Verify nullable range-restricted unsigned 16-bit integer value has not changed"); + case 445: { + LogStep(445, "Verify nullable range-restricted unsigned 16-bit integer value has not changed"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt16u::Id, true, chip::NullOptional); } - case 445: { - LogStep(445, "Write min valid value to a nullable range-restricted unsigned 16-bit integer"); + case 446: { + LogStep(446, "Write min valid value to a nullable range-restricted unsigned 16-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45962,13 +45982,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 446: { - LogStep(446, "Verify nullable range-restricted unsigned 16-bit integer value is at min valid"); + case 447: { + LogStep(447, "Verify nullable range-restricted unsigned 16-bit integer value is at min valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt16u::Id, true, chip::NullOptional); } - case 447: { - LogStep(447, "Write max valid value to a nullable range-restricted unsigned 16-bit integer"); + case 448: { + LogStep(448, "Write max valid value to a nullable range-restricted unsigned 16-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45977,13 +45997,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 448: { - LogStep(448, "Verify nullable range-restricted unsigned 16-bit integer value is at max valid"); + case 449: { + LogStep(449, "Verify nullable range-restricted unsigned 16-bit integer value is at max valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt16u::Id, true, chip::NullOptional); } - case 449: { - LogStep(449, "Write middle valid value to a nullable range-restricted unsigned 16-bit integer"); + case 450: { + LogStep(450, "Write middle valid value to a nullable range-restricted unsigned 16-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -45992,13 +46012,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 450: { - LogStep(450, "Verify nullable range-restricted unsigned 16-bit integer value is at mid valid"); + case 451: { + LogStep(451, "Verify nullable range-restricted unsigned 16-bit integer value is at mid valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt16u::Id, true, chip::NullOptional); } - case 451: { - LogStep(451, "Write null value to a nullable range-restricted unsigned 16-bit integer"); + case 452: { + LogStep(452, "Write null value to a nullable range-restricted unsigned 16-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); @@ -46006,18 +46026,18 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt16u::Id, value, chip::NullOptional, chip::NullOptional); } - case 452: { - LogStep(452, "Verify nullable range-restricted unsigned 16-bit integer value is null"); + case 453: { + LogStep(453, "Verify nullable range-restricted unsigned 16-bit integer value is null"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt16u::Id, true, chip::NullOptional); } - case 453: { - LogStep(453, "Read nullable range-restricted signed 8-bit integer"); + case 454: { + LogStep(454, "Read nullable range-restricted signed 8-bit integer"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt8s::Id, true, chip::NullOptional); } - case 454: { - LogStep(454, "Write min value to a nullable range-restricted signed 8-bit integer"); + case 455: { + LogStep(455, "Write min value to a nullable range-restricted signed 8-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -46026,8 +46046,8 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 455: { - LogStep(455, "Write just-below-range value to a nullable range-restricted signed 8-bit integer"); + case 456: { + LogStep(456, "Write just-below-range value to a nullable range-restricted signed 8-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -46036,8 +46056,8 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 456: { - LogStep(456, "Write just-above-range value to a nullable range-restricted signed 8-bit integer"); + case 457: { + LogStep(457, "Write just-above-range value to a nullable range-restricted signed 8-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -46046,8 +46066,8 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 457: { - LogStep(457, "Write max value to a nullable range-restricted signed 8-bit integer"); + case 458: { + LogStep(458, "Write max value to a nullable range-restricted signed 8-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -46056,13 +46076,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 458: { - LogStep(458, "Verify nullable range-restricted signed 8-bit integer value has not changed"); + case 459: { + LogStep(459, "Verify nullable range-restricted signed 8-bit integer value has not changed"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt8s::Id, true, chip::NullOptional); } - case 459: { - LogStep(459, "Write min valid value to a nullable range-restricted signed 8-bit integer"); + case 460: { + LogStep(460, "Write min valid value to a nullable range-restricted signed 8-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -46071,13 +46091,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 460: { - LogStep(460, "Verify nullable range-restricted signed 8-bit integer value is at min valid"); + case 461: { + LogStep(461, "Verify nullable range-restricted signed 8-bit integer value is at min valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt8s::Id, true, chip::NullOptional); } - case 461: { - LogStep(461, "Write max valid value to a nullable range-restricted signed 8-bit integer"); + case 462: { + LogStep(462, "Write max valid value to a nullable range-restricted signed 8-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -46086,13 +46106,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 462: { - LogStep(462, "Verify nullable range-restricted signed 8-bit integer value is at max valid"); + case 463: { + LogStep(463, "Verify nullable range-restricted signed 8-bit integer value is at max valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt8s::Id, true, chip::NullOptional); } - case 463: { - LogStep(463, "Write middle valid value to a nullable range-restricted signed 8-bit integer"); + case 464: { + LogStep(464, "Write middle valid value to a nullable range-restricted signed 8-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -46101,13 +46121,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 464: { - LogStep(464, "Verify nullable range-restricted signed 8-bit integer value is at mid valid"); + case 465: { + LogStep(465, "Verify nullable range-restricted signed 8-bit integer value is at mid valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt8s::Id, true, chip::NullOptional); } - case 465: { - LogStep(465, "Write null value to a nullable range-restricted signed 8-bit integer"); + case 466: { + LogStep(466, "Write null value to a nullable range-restricted signed 8-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); @@ -46115,18 +46135,18 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt8s::Id, value, chip::NullOptional, chip::NullOptional); } - case 466: { - LogStep(466, "Verify nullable range-restricted signed 8-bit integer value is at null"); + case 467: { + LogStep(467, "Verify nullable range-restricted signed 8-bit integer value is at null"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt8s::Id, true, chip::NullOptional); } - case 467: { - LogStep(467, "Read nullable range-restricted signed 16-bit integer"); + case 468: { + LogStep(468, "Read nullable range-restricted signed 16-bit integer"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt16s::Id, true, chip::NullOptional); } - case 468: { - LogStep(468, "Write min value to a nullable range-restricted signed 16-bit integer"); + case 469: { + LogStep(469, "Write min value to a nullable range-restricted signed 16-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -46135,8 +46155,8 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 469: { - LogStep(469, "Write just-below-range value to a nullable range-restricted signed 16-bit integer"); + case 470: { + LogStep(470, "Write just-below-range value to a nullable range-restricted signed 16-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -46145,8 +46165,8 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 470: { - LogStep(470, "Write just-above-range value to a nullable range-restricted signed 16-bit integer"); + case 471: { + LogStep(471, "Write just-above-range value to a nullable range-restricted signed 16-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -46155,8 +46175,8 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 471: { - LogStep(471, "Write max value to a nullable range-restricted signed 16-bit integer"); + case 472: { + LogStep(472, "Write max value to a nullable range-restricted signed 16-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -46165,13 +46185,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 472: { - LogStep(472, "Verify nullable range-restricted signed 16-bit integer value has not changed"); + case 473: { + LogStep(473, "Verify nullable range-restricted signed 16-bit integer value has not changed"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt16s::Id, true, chip::NullOptional); } - case 473: { - LogStep(473, "Write min valid value to a nullable range-restricted signed 16-bit integer"); + case 474: { + LogStep(474, "Write min valid value to a nullable range-restricted signed 16-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -46180,13 +46200,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 474: { - LogStep(474, "Verify nullable range-restricted signed 16-bit integer value is at min valid"); + case 475: { + LogStep(475, "Verify nullable range-restricted signed 16-bit integer value is at min valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt16s::Id, true, chip::NullOptional); } - case 475: { - LogStep(475, "Write max valid value to a nullable range-restricted signed 16-bit integer"); + case 476: { + LogStep(476, "Write max valid value to a nullable range-restricted signed 16-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -46195,13 +46215,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 476: { - LogStep(476, "Verify nullable range-restricted signed 16-bit integer value is at max valid"); + case 477: { + LogStep(477, "Verify nullable range-restricted signed 16-bit integer value is at max valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt16s::Id, true, chip::NullOptional); } - case 477: { - LogStep(477, "Write middle valid value to a nullable range-restricted signed 16-bit integer"); + case 478: { + LogStep(478, "Write middle valid value to a nullable range-restricted signed 16-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNonNull(); @@ -46210,13 +46230,13 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 478: { - LogStep(478, "Verify nullable range-restricted signed 16-bit integer value is at mid valid"); + case 479: { + LogStep(479, "Verify nullable range-restricted signed 16-bit integer value is at mid valid"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt16s::Id, true, chip::NullOptional); } - case 479: { - LogStep(479, "Write null value to a nullable range-restricted signed 16-bit integer"); + case 480: { + LogStep(480, "Write null value to a nullable range-restricted signed 16-bit integer"); ListFreer listFreer; chip::app::DataModel::Nullable value; value.SetNull(); @@ -46224,49 +46244,49 @@ class TestClusterSuite : public TestCommand TestCluster::Attributes::NullableRangeRestrictedInt16s::Id, value, chip::NullOptional, chip::NullOptional); } - case 480: { - LogStep(480, "Verify nullable range-restricted signed 16-bit integer value is null"); + case 481: { + LogStep(481, "Verify nullable range-restricted signed 16-bit integer value is null"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::NullableRangeRestrictedInt16s::Id, true, chip::NullOptional); } - case 481: { - LogStep(481, "Write attribute that returns general status on write"); + case 482: { + LogStep(482, "Write attribute that returns general status on write"); ListFreer listFreer; bool value; value = false; return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::GeneralErrorBoolean::Id, value, chip::NullOptional, chip::NullOptional); } - case 482: { - LogStep(482, "Write attribute that returns cluster-specific status on write"); + case 483: { + LogStep(483, "Write attribute that returns cluster-specific status on write"); ListFreer listFreer; bool value; value = false; return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::ClusterErrorBoolean::Id, value, chip::NullOptional, chip::NullOptional); } - case 483: { - LogStep(483, "Read attribute that returns general status on read"); + case 484: { + LogStep(484, "Read attribute that returns general status on read"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::GeneralErrorBoolean::Id, true, chip::NullOptional); } - case 484: { - LogStep(484, "read attribute that returns cluster-specific status on read"); + case 485: { + LogStep(485, "read attribute that returns cluster-specific status on read"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::ClusterErrorBoolean::Id, true, chip::NullOptional); } - case 485: { - LogStep(485, "read AcceptedCommandList attribute"); + case 486: { + LogStep(486, "read AcceptedCommandList attribute"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::AcceptedCommandList::Id, true, chip::NullOptional); } - case 486: { - LogStep(486, "read GeneratedCommandList attribute"); + case 487: { + LogStep(487, "read GeneratedCommandList attribute"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::GeneratedCommandList::Id, true, chip::NullOptional); } - case 487: { - LogStep(487, "Write struct-typed attribute"); + case 488: { + LogStep(488, "Write struct-typed attribute"); ListFreer listFreer; chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type value; @@ -46282,8 +46302,8 @@ class TestClusterSuite : public TestCommand return WriteAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::StructAttr::Id, value, chip::NullOptional, chip::NullOptional); } - case 488: { - LogStep(488, "Read struct-typed attribute"); + case 489: { + LogStep(489, "Read struct-typed attribute"); return ReadAttribute(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Attributes::StructAttr::Id, true, chip::NullOptional); } diff --git a/zzz_generated/controller-clusters/zap-generated/IMClusterCommandHandler.cpp b/zzz_generated/controller-clusters/zap-generated/IMClusterCommandHandler.cpp index dbcfc737576d37..fac4aeb91acae3 100644 --- a/zzz_generated/controller-clusters/zap-generated/IMClusterCommandHandler.cpp +++ b/zzz_generated/controller-clusters/zap-generated/IMClusterCommandHandler.cpp @@ -40,7 +40,6 @@ namespace app { // Cluster specific command parsing namespace Clusters { - } // namespace Clusters void DispatchSingleClusterCommand(const ConcreteCommandPath & aCommandPath, TLV::TLVReader & aReader, CommandHandler * apCommandObj) diff --git a/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h b/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h index b6b89c6a760c64..8a852bd2dbbad1 100644 --- a/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h +++ b/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h @@ -64045,890 +64045,889 @@ class TestCluster : public TestCommandBridge { err = TestSendACommandWithAVendorIdAndEnum_154(); break; case 155: - ChipLogProgress(chipTool, " ***** Test Step 155 : Send Test Command With Struct Argument and arg1.b is true\n"); - err = TestSendTestCommandWithStructArgumentAndArg1bIsTrue_155(); + ChipLogProgress(chipTool, " ***** Test Step 155 : Send a command with a vendor_id and invalid enum\n"); + err = TestSendACommandWithAVendorIdAndInvalidEnum_155(); break; case 156: - ChipLogProgress(chipTool, " ***** Test Step 156 : Send Test Command With Struct Argument and arg1.b is false\n"); - err = TestSendTestCommandWithStructArgumentAndArg1bIsFalse_156(); + ChipLogProgress(chipTool, " ***** Test Step 156 : Send Test Command With Struct Argument and arg1.b is true\n"); + err = TestSendTestCommandWithStructArgumentAndArg1bIsTrue_156(); break; case 157: - ChipLogProgress( - chipTool, " ***** Test Step 157 : Send Test Command With Nested Struct Argument and arg1.c.b is true\n"); - err = TestSendTestCommandWithNestedStructArgumentAndArg1cbIsTrue_157(); + ChipLogProgress(chipTool, " ***** Test Step 157 : Send Test Command With Struct Argument and arg1.b is false\n"); + err = TestSendTestCommandWithStructArgumentAndArg1bIsFalse_157(); break; case 158: - ChipLogProgress(chipTool, " ***** Test Step 158 : Send Test Command With Nested Struct Argument arg1.c.b is false\n"); - err = TestSendTestCommandWithNestedStructArgumentArg1cbIsFalse_158(); + ChipLogProgress( + chipTool, " ***** Test Step 158 : Send Test Command With Nested Struct Argument and arg1.c.b is true\n"); + err = TestSendTestCommandWithNestedStructArgumentAndArg1cbIsTrue_158(); break; case 159: - ChipLogProgress(chipTool, - " ***** Test Step 159 : Send Test Command With Nested Struct List Argument and all fields b of arg1.d are true\n"); - err = TestSendTestCommandWithNestedStructListArgumentAndAllFieldsBOfArg1dAreTrue_159(); + ChipLogProgress(chipTool, " ***** Test Step 159 : Send Test Command With Nested Struct Argument arg1.c.b is false\n"); + err = TestSendTestCommandWithNestedStructArgumentArg1cbIsFalse_159(); break; case 160: ChipLogProgress(chipTool, - " ***** Test Step 160 : Send Test Command With Nested Struct List Argument and some fields b of arg1.d are " - "false\n"); - err = TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfArg1dAreFalse_160(); + " ***** Test Step 160 : Send Test Command With Nested Struct List Argument and all fields b of arg1.d are true\n"); + err = TestSendTestCommandWithNestedStructListArgumentAndAllFieldsBOfArg1dAreTrue_160(); break; case 161: - ChipLogProgress(chipTool, " ***** Test Step 161 : Send Test Command With Struct Argument and see what we get back\n"); - err = TestSendTestCommandWithStructArgumentAndSeeWhatWeGetBack_161(); + ChipLogProgress(chipTool, + " ***** Test Step 161 : Send Test Command With Nested Struct List Argument and some fields b of arg1.d are " + "false\n"); + err = TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfArg1dAreFalse_161(); break; case 162: - ChipLogProgress(chipTool, " ***** Test Step 162 : Send Test Command With List of INT8U and none of them is set to 0\n"); - err = TestSendTestCommandWithListOfInt8uAndNoneOfThemIsSetTo0_162(); + ChipLogProgress(chipTool, " ***** Test Step 162 : Send Test Command With Struct Argument and see what we get back\n"); + err = TestSendTestCommandWithStructArgumentAndSeeWhatWeGetBack_162(); break; case 163: - ChipLogProgress(chipTool, " ***** Test Step 163 : Send Test Command With List of INT8U and one of them is set to 0\n"); - err = TestSendTestCommandWithListOfInt8uAndOneOfThemIsSetTo0_163(); + ChipLogProgress(chipTool, " ***** Test Step 163 : Send Test Command With List of INT8U and none of them is set to 0\n"); + err = TestSendTestCommandWithListOfInt8uAndNoneOfThemIsSetTo0_163(); break; case 164: - ChipLogProgress(chipTool, " ***** Test Step 164 : Send Test Command With List of INT8U and get it reversed\n"); - err = TestSendTestCommandWithListOfInt8uAndGetItReversed_164(); + ChipLogProgress(chipTool, " ***** Test Step 164 : Send Test Command With List of INT8U and one of them is set to 0\n"); + err = TestSendTestCommandWithListOfInt8uAndOneOfThemIsSetTo0_164(); break; case 165: - ChipLogProgress( - chipTool, " ***** Test Step 165 : Send Test Command With empty List of INT8U and get an empty list back\n"); - err = TestSendTestCommandWithEmptyListOfInt8uAndGetAnEmptyListBack_165(); + ChipLogProgress(chipTool, " ***** Test Step 165 : Send Test Command With List of INT8U and get it reversed\n"); + err = TestSendTestCommandWithListOfInt8uAndGetItReversed_165(); break; case 166: - ChipLogProgress(chipTool, - " ***** Test Step 166 : Send Test Command With List of Struct Argument and arg1.b of first item is true\n"); - err = TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsTrue_166(); + ChipLogProgress( + chipTool, " ***** Test Step 166 : Send Test Command With empty List of INT8U and get an empty list back\n"); + err = TestSendTestCommandWithEmptyListOfInt8uAndGetAnEmptyListBack_166(); break; case 167: ChipLogProgress(chipTool, - " ***** Test Step 167 : Send Test Command With List of Struct Argument and arg1.b of first item is false\n"); - err = TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsFalse_167(); + " ***** Test Step 167 : Send Test Command With List of Struct Argument and arg1.b of first item is true\n"); + err = TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsTrue_167(); break; case 168: ChipLogProgress(chipTool, - " ***** Test Step 168 : Send Test Command With List of Nested Struct List Argument and all fields b of elements of " - "arg1.d are true\n"); - err = TestSendTestCommandWithListOfNestedStructListArgumentAndAllFieldsBOfElementsOfArg1dAreTrue_168(); + " ***** Test Step 168 : Send Test Command With List of Struct Argument and arg1.b of first item is false\n"); + err = TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsFalse_168(); break; case 169: ChipLogProgress(chipTool, - " ***** Test Step 169 : Send Test Command With Nested Struct List Argument and some fields b of elements of arg1.d " - "are false\n"); - err = TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfElementsOfArg1dAreFalse_169(); + " ***** Test Step 169 : Send Test Command With List of Nested Struct List Argument and all fields b of elements of " + "arg1.d are true\n"); + err = TestSendTestCommandWithListOfNestedStructListArgumentAndAllFieldsBOfElementsOfArg1dAreTrue_169(); break; case 170: - ChipLogProgress( - chipTool, " ***** Test Step 170 : Write attribute LIST With List of INT8U and none of them is set to 0\n"); - err = TestWriteAttributeListWithListOfInt8uAndNoneOfThemIsSetTo0_170(); + ChipLogProgress(chipTool, + " ***** Test Step 170 : Send Test Command With Nested Struct List Argument and some fields b of elements of arg1.d " + "are false\n"); + err = TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfElementsOfArg1dAreFalse_170(); break; case 171: - ChipLogProgress(chipTool, " ***** Test Step 171 : Read attribute LIST With List of INT8U\n"); - err = TestReadAttributeListWithListOfInt8u_171(); + ChipLogProgress( + chipTool, " ***** Test Step 171 : Write attribute LIST With List of INT8U and none of them is set to 0\n"); + err = TestWriteAttributeListWithListOfInt8uAndNoneOfThemIsSetTo0_171(); break; case 172: - ChipLogProgress(chipTool, " ***** Test Step 172 : Write attribute LIST With List of OCTET_STRING\n"); - err = TestWriteAttributeListWithListOfOctetString_172(); + ChipLogProgress(chipTool, " ***** Test Step 172 : Read attribute LIST With List of INT8U\n"); + err = TestReadAttributeListWithListOfInt8u_172(); break; case 173: - ChipLogProgress(chipTool, " ***** Test Step 173 : Read attribute LIST With List of OCTET_STRING\n"); - err = TestReadAttributeListWithListOfOctetString_173(); + ChipLogProgress(chipTool, " ***** Test Step 173 : Write attribute LIST With List of OCTET_STRING\n"); + err = TestWriteAttributeListWithListOfOctetString_173(); break; case 174: - ChipLogProgress(chipTool, " ***** Test Step 174 : Write attribute LIST With List of LIST_STRUCT_OCTET_STRING\n"); - err = TestWriteAttributeListWithListOfListStructOctetString_174(); + ChipLogProgress(chipTool, " ***** Test Step 174 : Read attribute LIST With List of OCTET_STRING\n"); + err = TestReadAttributeListWithListOfOctetString_174(); break; case 175: - ChipLogProgress(chipTool, " ***** Test Step 175 : Read attribute LIST With List of LIST_STRUCT_OCTET_STRING\n"); - err = TestReadAttributeListWithListOfListStructOctetString_175(); + ChipLogProgress(chipTool, " ***** Test Step 175 : Write attribute LIST With List of LIST_STRUCT_OCTET_STRING\n"); + err = TestWriteAttributeListWithListOfListStructOctetString_175(); break; case 176: - ChipLogProgress(chipTool, " ***** Test Step 176 : Send Test Command with optional arg set.\n"); - err = TestSendTestCommandWithOptionalArgSet_176(); + ChipLogProgress(chipTool, " ***** Test Step 176 : Read attribute LIST With List of LIST_STRUCT_OCTET_STRING\n"); + err = TestReadAttributeListWithListOfListStructOctetString_176(); break; case 177: - ChipLogProgress(chipTool, " ***** Test Step 177 : Send Test Command without its optional arg.\n"); - err = TestSendTestCommandWithoutItsOptionalArg_177(); + ChipLogProgress(chipTool, " ***** Test Step 177 : Send Test Command with optional arg set.\n"); + err = TestSendTestCommandWithOptionalArgSet_177(); break; case 178: - ChipLogProgress(chipTool, " ***** Test Step 178 : Read list of structs containing nullables and optionals\n"); - err = TestReadListOfStructsContainingNullablesAndOptionals_178(); + ChipLogProgress(chipTool, " ***** Test Step 178 : Send Test Command without its optional arg.\n"); + err = TestSendTestCommandWithoutItsOptionalArg_178(); break; case 179: - ChipLogProgress(chipTool, " ***** Test Step 179 : Write list of structs containing nullables and optionals\n"); - err = TestWriteListOfStructsContainingNullablesAndOptionals_179(); + ChipLogProgress(chipTool, " ***** Test Step 179 : Read list of structs containing nullables and optionals\n"); + err = TestReadListOfStructsContainingNullablesAndOptionals_179(); break; case 180: - ChipLogProgress( - chipTool, " ***** Test Step 180 : Read list of structs containing nullables and optionals after writing\n"); - err = TestReadListOfStructsContainingNullablesAndOptionalsAfterWriting_180(); + ChipLogProgress(chipTool, " ***** Test Step 180 : Write list of structs containing nullables and optionals\n"); + err = TestWriteListOfStructsContainingNullablesAndOptionals_180(); break; case 181: - ChipLogProgress(chipTool, " ***** Test Step 181 : Write attribute NULLABLE_BOOLEAN null\n"); - err = TestWriteAttributeNullableBooleanNull_181(); + ChipLogProgress( + chipTool, " ***** Test Step 181 : Read list of structs containing nullables and optionals after writing\n"); + err = TestReadListOfStructsContainingNullablesAndOptionalsAfterWriting_181(); break; case 182: - ChipLogProgress(chipTool, " ***** Test Step 182 : Read attribute NULLABLE_BOOLEAN null\n"); - err = TestReadAttributeNullableBooleanNull_182(); + ChipLogProgress(chipTool, " ***** Test Step 182 : Write attribute NULLABLE_BOOLEAN null\n"); + err = TestWriteAttributeNullableBooleanNull_182(); break; case 183: - ChipLogProgress(chipTool, " ***** Test Step 183 : Write attribute NULLABLE_BOOLEAN True\n"); - err = TestWriteAttributeNullableBooleanTrue_183(); + ChipLogProgress(chipTool, " ***** Test Step 183 : Read attribute NULLABLE_BOOLEAN null\n"); + err = TestReadAttributeNullableBooleanNull_183(); break; case 184: - ChipLogProgress(chipTool, " ***** Test Step 184 : Read attribute NULLABLE_BOOLEAN True\n"); - err = TestReadAttributeNullableBooleanTrue_184(); + ChipLogProgress(chipTool, " ***** Test Step 184 : Write attribute NULLABLE_BOOLEAN True\n"); + err = TestWriteAttributeNullableBooleanTrue_184(); break; case 185: - ChipLogProgress(chipTool, " ***** Test Step 185 : Read attribute NULLABLE_BOOLEAN not null\n"); - err = TestReadAttributeNullableBooleanNotNull_185(); + ChipLogProgress(chipTool, " ***** Test Step 185 : Read attribute NULLABLE_BOOLEAN True\n"); + err = TestReadAttributeNullableBooleanTrue_185(); break; case 186: - ChipLogProgress(chipTool, " ***** Test Step 186 : Write attribute NULLABLE_BITMAP8 Max Value\n"); - err = TestWriteAttributeNullableBitmap8MaxValue_186(); + ChipLogProgress(chipTool, " ***** Test Step 186 : Read attribute NULLABLE_BOOLEAN not null\n"); + err = TestReadAttributeNullableBooleanNotNull_186(); break; case 187: - ChipLogProgress(chipTool, " ***** Test Step 187 : Read attribute NULLABLE_BITMAP8 Max Value\n"); - err = TestReadAttributeNullableBitmap8MaxValue_187(); + ChipLogProgress(chipTool, " ***** Test Step 187 : Write attribute NULLABLE_BITMAP8 Max Value\n"); + err = TestWriteAttributeNullableBitmap8MaxValue_187(); break; case 188: - ChipLogProgress(chipTool, " ***** Test Step 188 : Write attribute NULLABLE_BITMAP8 Invalid Value\n"); - err = TestWriteAttributeNullableBitmap8InvalidValue_188(); + ChipLogProgress(chipTool, " ***** Test Step 188 : Read attribute NULLABLE_BITMAP8 Max Value\n"); + err = TestReadAttributeNullableBitmap8MaxValue_188(); break; case 189: - ChipLogProgress(chipTool, " ***** Test Step 189 : Read attribute NULLABLE_BITMAP8 unchanged Value\n"); - err = TestReadAttributeNullableBitmap8UnchangedValue_189(); + ChipLogProgress(chipTool, " ***** Test Step 189 : Write attribute NULLABLE_BITMAP8 Invalid Value\n"); + err = TestWriteAttributeNullableBitmap8InvalidValue_189(); break; case 190: - ChipLogProgress(chipTool, " ***** Test Step 190 : Write attribute NULLABLE_BITMAP8 null Value\n"); - err = TestWriteAttributeNullableBitmap8NullValue_190(); + ChipLogProgress(chipTool, " ***** Test Step 190 : Read attribute NULLABLE_BITMAP8 unchanged Value\n"); + err = TestReadAttributeNullableBitmap8UnchangedValue_190(); break; case 191: - ChipLogProgress(chipTool, " ***** Test Step 191 : Read attribute NULLABLE_BITMAP8 null Value\n"); - err = TestReadAttributeNullableBitmap8NullValue_191(); + ChipLogProgress(chipTool, " ***** Test Step 191 : Write attribute NULLABLE_BITMAP8 null Value\n"); + err = TestWriteAttributeNullableBitmap8NullValue_191(); break; case 192: - ChipLogProgress(chipTool, " ***** Test Step 192 : Read attribute NULLABLE_BITMAP8 not 254 Value\n"); - err = TestReadAttributeNullableBitmap8Not254Value_192(); + ChipLogProgress(chipTool, " ***** Test Step 192 : Read attribute NULLABLE_BITMAP8 null Value\n"); + err = TestReadAttributeNullableBitmap8NullValue_192(); break; case 193: - ChipLogProgress(chipTool, " ***** Test Step 193 : Write attribute NULLABLE_BITMAP16 Max Value\n"); - err = TestWriteAttributeNullableBitmap16MaxValue_193(); + ChipLogProgress(chipTool, " ***** Test Step 193 : Read attribute NULLABLE_BITMAP8 not 254 Value\n"); + err = TestReadAttributeNullableBitmap8Not254Value_193(); break; case 194: - ChipLogProgress(chipTool, " ***** Test Step 194 : Read attribute NULLABLE_BITMAP16 Max Value\n"); - err = TestReadAttributeNullableBitmap16MaxValue_194(); + ChipLogProgress(chipTool, " ***** Test Step 194 : Write attribute NULLABLE_BITMAP16 Max Value\n"); + err = TestWriteAttributeNullableBitmap16MaxValue_194(); break; case 195: - ChipLogProgress(chipTool, " ***** Test Step 195 : Write attribute NULLABLE_BITMAP16 Invalid Value\n"); - err = TestWriteAttributeNullableBitmap16InvalidValue_195(); + ChipLogProgress(chipTool, " ***** Test Step 195 : Read attribute NULLABLE_BITMAP16 Max Value\n"); + err = TestReadAttributeNullableBitmap16MaxValue_195(); break; case 196: - ChipLogProgress(chipTool, " ***** Test Step 196 : Read attribute NULLABLE_BITMAP16 unchanged Value\n"); - err = TestReadAttributeNullableBitmap16UnchangedValue_196(); + ChipLogProgress(chipTool, " ***** Test Step 196 : Write attribute NULLABLE_BITMAP16 Invalid Value\n"); + err = TestWriteAttributeNullableBitmap16InvalidValue_196(); break; case 197: - ChipLogProgress(chipTool, " ***** Test Step 197 : Write attribute NULLABLE_BITMAP16 null Value\n"); - err = TestWriteAttributeNullableBitmap16NullValue_197(); + ChipLogProgress(chipTool, " ***** Test Step 197 : Read attribute NULLABLE_BITMAP16 unchanged Value\n"); + err = TestReadAttributeNullableBitmap16UnchangedValue_197(); break; case 198: - ChipLogProgress(chipTool, " ***** Test Step 198 : Read attribute NULLABLE_BITMAP16 null Value\n"); - err = TestReadAttributeNullableBitmap16NullValue_198(); + ChipLogProgress(chipTool, " ***** Test Step 198 : Write attribute NULLABLE_BITMAP16 null Value\n"); + err = TestWriteAttributeNullableBitmap16NullValue_198(); break; case 199: - ChipLogProgress(chipTool, " ***** Test Step 199 : Write attribute NULLABLE_BITMAP32 Max Value\n"); - err = TestWriteAttributeNullableBitmap32MaxValue_199(); + ChipLogProgress(chipTool, " ***** Test Step 199 : Read attribute NULLABLE_BITMAP16 null Value\n"); + err = TestReadAttributeNullableBitmap16NullValue_199(); break; case 200: - ChipLogProgress(chipTool, " ***** Test Step 200 : Read attribute NULLABLE_BITMAP32 Max Value\n"); - err = TestReadAttributeNullableBitmap32MaxValue_200(); + ChipLogProgress(chipTool, " ***** Test Step 200 : Write attribute NULLABLE_BITMAP32 Max Value\n"); + err = TestWriteAttributeNullableBitmap32MaxValue_200(); break; case 201: - ChipLogProgress(chipTool, " ***** Test Step 201 : Write attribute NULLABLE_BITMAP32 Invalid Value\n"); - err = TestWriteAttributeNullableBitmap32InvalidValue_201(); + ChipLogProgress(chipTool, " ***** Test Step 201 : Read attribute NULLABLE_BITMAP32 Max Value\n"); + err = TestReadAttributeNullableBitmap32MaxValue_201(); break; case 202: - ChipLogProgress(chipTool, " ***** Test Step 202 : Read attribute NULLABLE_BITMAP32 unchanged Value\n"); - err = TestReadAttributeNullableBitmap32UnchangedValue_202(); + ChipLogProgress(chipTool, " ***** Test Step 202 : Write attribute NULLABLE_BITMAP32 Invalid Value\n"); + err = TestWriteAttributeNullableBitmap32InvalidValue_202(); break; case 203: - ChipLogProgress(chipTool, " ***** Test Step 203 : Write attribute NULLABLE_BITMAP32 null Value\n"); - err = TestWriteAttributeNullableBitmap32NullValue_203(); + ChipLogProgress(chipTool, " ***** Test Step 203 : Read attribute NULLABLE_BITMAP32 unchanged Value\n"); + err = TestReadAttributeNullableBitmap32UnchangedValue_203(); break; case 204: - ChipLogProgress(chipTool, " ***** Test Step 204 : Read attribute NULLABLE_BITMAP32 null Value\n"); - err = TestReadAttributeNullableBitmap32NullValue_204(); + ChipLogProgress(chipTool, " ***** Test Step 204 : Write attribute NULLABLE_BITMAP32 null Value\n"); + err = TestWriteAttributeNullableBitmap32NullValue_204(); break; case 205: - ChipLogProgress(chipTool, " ***** Test Step 205 : Write attribute NULLABLE_BITMAP64 Max Value\n"); - err = TestWriteAttributeNullableBitmap64MaxValue_205(); + ChipLogProgress(chipTool, " ***** Test Step 205 : Read attribute NULLABLE_BITMAP32 null Value\n"); + err = TestReadAttributeNullableBitmap32NullValue_205(); break; case 206: - ChipLogProgress(chipTool, " ***** Test Step 206 : Read attribute NULLABLE_BITMAP64 Max Value\n"); - err = TestReadAttributeNullableBitmap64MaxValue_206(); + ChipLogProgress(chipTool, " ***** Test Step 206 : Write attribute NULLABLE_BITMAP64 Max Value\n"); + err = TestWriteAttributeNullableBitmap64MaxValue_206(); break; case 207: - ChipLogProgress(chipTool, " ***** Test Step 207 : Write attribute NULLABLE_BITMAP64 Invalid Value\n"); - err = TestWriteAttributeNullableBitmap64InvalidValue_207(); + ChipLogProgress(chipTool, " ***** Test Step 207 : Read attribute NULLABLE_BITMAP64 Max Value\n"); + err = TestReadAttributeNullableBitmap64MaxValue_207(); break; case 208: - ChipLogProgress(chipTool, " ***** Test Step 208 : Read attribute NULLABLE_BITMAP64 unchanged Value\n"); - err = TestReadAttributeNullableBitmap64UnchangedValue_208(); + ChipLogProgress(chipTool, " ***** Test Step 208 : Write attribute NULLABLE_BITMAP64 Invalid Value\n"); + err = TestWriteAttributeNullableBitmap64InvalidValue_208(); break; case 209: - ChipLogProgress(chipTool, " ***** Test Step 209 : Write attribute NULLABLE_BITMAP64 null Value\n"); - err = TestWriteAttributeNullableBitmap64NullValue_209(); + ChipLogProgress(chipTool, " ***** Test Step 209 : Read attribute NULLABLE_BITMAP64 unchanged Value\n"); + err = TestReadAttributeNullableBitmap64UnchangedValue_209(); break; case 210: - ChipLogProgress(chipTool, " ***** Test Step 210 : Read attribute NULLABLE_BITMAP64 null Value\n"); - err = TestReadAttributeNullableBitmap64NullValue_210(); + ChipLogProgress(chipTool, " ***** Test Step 210 : Write attribute NULLABLE_BITMAP64 null Value\n"); + err = TestWriteAttributeNullableBitmap64NullValue_210(); break; case 211: - ChipLogProgress(chipTool, " ***** Test Step 211 : Write attribute NULLABLE_INT8U Min Value\n"); - err = TestWriteAttributeNullableInt8uMinValue_211(); + ChipLogProgress(chipTool, " ***** Test Step 211 : Read attribute NULLABLE_BITMAP64 null Value\n"); + err = TestReadAttributeNullableBitmap64NullValue_211(); break; case 212: - ChipLogProgress(chipTool, " ***** Test Step 212 : Read attribute NULLABLE_INT8U Min Value\n"); - err = TestReadAttributeNullableInt8uMinValue_212(); + ChipLogProgress(chipTool, " ***** Test Step 212 : Write attribute NULLABLE_INT8U Min Value\n"); + err = TestWriteAttributeNullableInt8uMinValue_212(); break; case 213: - ChipLogProgress(chipTool, " ***** Test Step 213 : Write attribute NULLABLE_INT8U Max Value\n"); - err = TestWriteAttributeNullableInt8uMaxValue_213(); + ChipLogProgress(chipTool, " ***** Test Step 213 : Read attribute NULLABLE_INT8U Min Value\n"); + err = TestReadAttributeNullableInt8uMinValue_213(); break; case 214: - ChipLogProgress(chipTool, " ***** Test Step 214 : Read attribute NULLABLE_INT8U Max Value\n"); - err = TestReadAttributeNullableInt8uMaxValue_214(); + ChipLogProgress(chipTool, " ***** Test Step 214 : Write attribute NULLABLE_INT8U Max Value\n"); + err = TestWriteAttributeNullableInt8uMaxValue_214(); break; case 215: - ChipLogProgress(chipTool, " ***** Test Step 215 : Write attribute NULLABLE_INT8U Invalid Value\n"); - err = TestWriteAttributeNullableInt8uInvalidValue_215(); + ChipLogProgress(chipTool, " ***** Test Step 215 : Read attribute NULLABLE_INT8U Max Value\n"); + err = TestReadAttributeNullableInt8uMaxValue_215(); break; case 216: - ChipLogProgress(chipTool, " ***** Test Step 216 : Read attribute NULLABLE_INT8U unchanged Value\n"); - err = TestReadAttributeNullableInt8uUnchangedValue_216(); + ChipLogProgress(chipTool, " ***** Test Step 216 : Write attribute NULLABLE_INT8U Invalid Value\n"); + err = TestWriteAttributeNullableInt8uInvalidValue_216(); break; case 217: - ChipLogProgress(chipTool, " ***** Test Step 217 : Read attribute NULLABLE_INT8U unchanged Value with constraint\n"); - err = TestReadAttributeNullableInt8uUnchangedValueWithConstraint_217(); + ChipLogProgress(chipTool, " ***** Test Step 217 : Read attribute NULLABLE_INT8U unchanged Value\n"); + err = TestReadAttributeNullableInt8uUnchangedValue_217(); break; case 218: - ChipLogProgress(chipTool, " ***** Test Step 218 : Write attribute NULLABLE_INT8U null Value\n"); - err = TestWriteAttributeNullableInt8uNullValue_218(); + ChipLogProgress(chipTool, " ***** Test Step 218 : Read attribute NULLABLE_INT8U unchanged Value with constraint\n"); + err = TestReadAttributeNullableInt8uUnchangedValueWithConstraint_218(); break; case 219: - ChipLogProgress(chipTool, " ***** Test Step 219 : Read attribute NULLABLE_INT8U null Value\n"); - err = TestReadAttributeNullableInt8uNullValue_219(); + ChipLogProgress(chipTool, " ***** Test Step 219 : Write attribute NULLABLE_INT8U null Value\n"); + err = TestWriteAttributeNullableInt8uNullValue_219(); break; case 220: - ChipLogProgress(chipTool, " ***** Test Step 220 : Read attribute NULLABLE_INT8U null Value & range\n"); - err = TestReadAttributeNullableInt8uNullValueRange_220(); + ChipLogProgress(chipTool, " ***** Test Step 220 : Read attribute NULLABLE_INT8U null Value\n"); + err = TestReadAttributeNullableInt8uNullValue_220(); break; case 221: - ChipLogProgress(chipTool, " ***** Test Step 221 : Read attribute NULLABLE_INT8U null Value & not\n"); - err = TestReadAttributeNullableInt8uNullValueNot_221(); + ChipLogProgress(chipTool, " ***** Test Step 221 : Read attribute NULLABLE_INT8U null Value & range\n"); + err = TestReadAttributeNullableInt8uNullValueRange_221(); break; case 222: - ChipLogProgress(chipTool, " ***** Test Step 222 : Write attribute NULLABLE_INT8U Value\n"); - err = TestWriteAttributeNullableInt8uValue_222(); + ChipLogProgress(chipTool, " ***** Test Step 222 : Read attribute NULLABLE_INT8U null Value & not\n"); + err = TestReadAttributeNullableInt8uNullValueNot_222(); break; case 223: - ChipLogProgress(chipTool, " ***** Test Step 223 : Read attribute NULLABLE_INT8U Value in range\n"); - err = TestReadAttributeNullableInt8uValueInRange_223(); + ChipLogProgress(chipTool, " ***** Test Step 223 : Write attribute NULLABLE_INT8U Value\n"); + err = TestWriteAttributeNullableInt8uValue_223(); break; case 224: - ChipLogProgress(chipTool, " ***** Test Step 224 : Read attribute NULLABLE_INT8U notValue OK\n"); - err = TestReadAttributeNullableInt8uNotValueOk_224(); + ChipLogProgress(chipTool, " ***** Test Step 224 : Read attribute NULLABLE_INT8U Value in range\n"); + err = TestReadAttributeNullableInt8uValueInRange_224(); break; case 225: - ChipLogProgress(chipTool, " ***** Test Step 225 : Write attribute NULLABLE_INT16U Min Value\n"); - err = TestWriteAttributeNullableInt16uMinValue_225(); + ChipLogProgress(chipTool, " ***** Test Step 225 : Read attribute NULLABLE_INT8U notValue OK\n"); + err = TestReadAttributeNullableInt8uNotValueOk_225(); break; case 226: - ChipLogProgress(chipTool, " ***** Test Step 226 : Read attribute NULLABLE_INT16U Min Value\n"); - err = TestReadAttributeNullableInt16uMinValue_226(); + ChipLogProgress(chipTool, " ***** Test Step 226 : Write attribute NULLABLE_INT16U Min Value\n"); + err = TestWriteAttributeNullableInt16uMinValue_226(); break; case 227: - ChipLogProgress(chipTool, " ***** Test Step 227 : Write attribute NULLABLE_INT16U Max Value\n"); - err = TestWriteAttributeNullableInt16uMaxValue_227(); + ChipLogProgress(chipTool, " ***** Test Step 227 : Read attribute NULLABLE_INT16U Min Value\n"); + err = TestReadAttributeNullableInt16uMinValue_227(); break; case 228: - ChipLogProgress(chipTool, " ***** Test Step 228 : Read attribute NULLABLE_INT16U Max Value\n"); - err = TestReadAttributeNullableInt16uMaxValue_228(); + ChipLogProgress(chipTool, " ***** Test Step 228 : Write attribute NULLABLE_INT16U Max Value\n"); + err = TestWriteAttributeNullableInt16uMaxValue_228(); break; case 229: - ChipLogProgress(chipTool, " ***** Test Step 229 : Write attribute NULLABLE_INT16U Invalid Value\n"); - err = TestWriteAttributeNullableInt16uInvalidValue_229(); + ChipLogProgress(chipTool, " ***** Test Step 229 : Read attribute NULLABLE_INT16U Max Value\n"); + err = TestReadAttributeNullableInt16uMaxValue_229(); break; case 230: - ChipLogProgress(chipTool, " ***** Test Step 230 : Read attribute NULLABLE_INT16U unchanged Value\n"); - err = TestReadAttributeNullableInt16uUnchangedValue_230(); + ChipLogProgress(chipTool, " ***** Test Step 230 : Write attribute NULLABLE_INT16U Invalid Value\n"); + err = TestWriteAttributeNullableInt16uInvalidValue_230(); break; case 231: - ChipLogProgress(chipTool, " ***** Test Step 231 : Write attribute NULLABLE_INT16U null Value\n"); - err = TestWriteAttributeNullableInt16uNullValue_231(); + ChipLogProgress(chipTool, " ***** Test Step 231 : Read attribute NULLABLE_INT16U unchanged Value\n"); + err = TestReadAttributeNullableInt16uUnchangedValue_231(); break; case 232: - ChipLogProgress(chipTool, " ***** Test Step 232 : Read attribute NULLABLE_INT16U null Value\n"); - err = TestReadAttributeNullableInt16uNullValue_232(); + ChipLogProgress(chipTool, " ***** Test Step 232 : Write attribute NULLABLE_INT16U null Value\n"); + err = TestWriteAttributeNullableInt16uNullValue_232(); break; case 233: - ChipLogProgress(chipTool, " ***** Test Step 233 : Read attribute NULLABLE_INT16U null Value & range\n"); - err = TestReadAttributeNullableInt16uNullValueRange_233(); + ChipLogProgress(chipTool, " ***** Test Step 233 : Read attribute NULLABLE_INT16U null Value\n"); + err = TestReadAttributeNullableInt16uNullValue_233(); break; case 234: - ChipLogProgress(chipTool, " ***** Test Step 234 : Read attribute NULLABLE_INT16U null Value & not\n"); - err = TestReadAttributeNullableInt16uNullValueNot_234(); + ChipLogProgress(chipTool, " ***** Test Step 234 : Read attribute NULLABLE_INT16U null Value & range\n"); + err = TestReadAttributeNullableInt16uNullValueRange_234(); break; case 235: - ChipLogProgress(chipTool, " ***** Test Step 235 : Write attribute NULLABLE_INT16U Value\n"); - err = TestWriteAttributeNullableInt16uValue_235(); + ChipLogProgress(chipTool, " ***** Test Step 235 : Read attribute NULLABLE_INT16U null Value & not\n"); + err = TestReadAttributeNullableInt16uNullValueNot_235(); break; case 236: - ChipLogProgress(chipTool, " ***** Test Step 236 : Read attribute NULLABLE_INT16U Value in range\n"); - err = TestReadAttributeNullableInt16uValueInRange_236(); + ChipLogProgress(chipTool, " ***** Test Step 236 : Write attribute NULLABLE_INT16U Value\n"); + err = TestWriteAttributeNullableInt16uValue_236(); break; case 237: - ChipLogProgress(chipTool, " ***** Test Step 237 : Read attribute NULLABLE_INT16U notValue OK\n"); - err = TestReadAttributeNullableInt16uNotValueOk_237(); + ChipLogProgress(chipTool, " ***** Test Step 237 : Read attribute NULLABLE_INT16U Value in range\n"); + err = TestReadAttributeNullableInt16uValueInRange_237(); break; case 238: - ChipLogProgress(chipTool, " ***** Test Step 238 : Write attribute NULLABLE_INT32U Min Value\n"); - err = TestWriteAttributeNullableInt32uMinValue_238(); + ChipLogProgress(chipTool, " ***** Test Step 238 : Read attribute NULLABLE_INT16U notValue OK\n"); + err = TestReadAttributeNullableInt16uNotValueOk_238(); break; case 239: - ChipLogProgress(chipTool, " ***** Test Step 239 : Read attribute NULLABLE_INT32U Min Value\n"); - err = TestReadAttributeNullableInt32uMinValue_239(); + ChipLogProgress(chipTool, " ***** Test Step 239 : Write attribute NULLABLE_INT32U Min Value\n"); + err = TestWriteAttributeNullableInt32uMinValue_239(); break; case 240: - ChipLogProgress(chipTool, " ***** Test Step 240 : Write attribute NULLABLE_INT32U Max Value\n"); - err = TestWriteAttributeNullableInt32uMaxValue_240(); + ChipLogProgress(chipTool, " ***** Test Step 240 : Read attribute NULLABLE_INT32U Min Value\n"); + err = TestReadAttributeNullableInt32uMinValue_240(); break; case 241: - ChipLogProgress(chipTool, " ***** Test Step 241 : Read attribute NULLABLE_INT32U Max Value\n"); - err = TestReadAttributeNullableInt32uMaxValue_241(); + ChipLogProgress(chipTool, " ***** Test Step 241 : Write attribute NULLABLE_INT32U Max Value\n"); + err = TestWriteAttributeNullableInt32uMaxValue_241(); break; case 242: - ChipLogProgress(chipTool, " ***** Test Step 242 : Write attribute NULLABLE_INT32U Invalid Value\n"); - err = TestWriteAttributeNullableInt32uInvalidValue_242(); + ChipLogProgress(chipTool, " ***** Test Step 242 : Read attribute NULLABLE_INT32U Max Value\n"); + err = TestReadAttributeNullableInt32uMaxValue_242(); break; case 243: - ChipLogProgress(chipTool, " ***** Test Step 243 : Read attribute NULLABLE_INT32U unchanged Value\n"); - err = TestReadAttributeNullableInt32uUnchangedValue_243(); + ChipLogProgress(chipTool, " ***** Test Step 243 : Write attribute NULLABLE_INT32U Invalid Value\n"); + err = TestWriteAttributeNullableInt32uInvalidValue_243(); break; case 244: - ChipLogProgress(chipTool, " ***** Test Step 244 : Write attribute NULLABLE_INT32U null Value\n"); - err = TestWriteAttributeNullableInt32uNullValue_244(); + ChipLogProgress(chipTool, " ***** Test Step 244 : Read attribute NULLABLE_INT32U unchanged Value\n"); + err = TestReadAttributeNullableInt32uUnchangedValue_244(); break; case 245: - ChipLogProgress(chipTool, " ***** Test Step 245 : Read attribute NULLABLE_INT32U null Value\n"); - err = TestReadAttributeNullableInt32uNullValue_245(); + ChipLogProgress(chipTool, " ***** Test Step 245 : Write attribute NULLABLE_INT32U null Value\n"); + err = TestWriteAttributeNullableInt32uNullValue_245(); break; case 246: - ChipLogProgress(chipTool, " ***** Test Step 246 : Read attribute NULLABLE_INT32U null Value & range\n"); - err = TestReadAttributeNullableInt32uNullValueRange_246(); + ChipLogProgress(chipTool, " ***** Test Step 246 : Read attribute NULLABLE_INT32U null Value\n"); + err = TestReadAttributeNullableInt32uNullValue_246(); break; case 247: - ChipLogProgress(chipTool, " ***** Test Step 247 : Read attribute NULLABLE_INT32U null Value & not\n"); - err = TestReadAttributeNullableInt32uNullValueNot_247(); + ChipLogProgress(chipTool, " ***** Test Step 247 : Read attribute NULLABLE_INT32U null Value & range\n"); + err = TestReadAttributeNullableInt32uNullValueRange_247(); break; case 248: - ChipLogProgress(chipTool, " ***** Test Step 248 : Write attribute NULLABLE_INT32U Value\n"); - err = TestWriteAttributeNullableInt32uValue_248(); + ChipLogProgress(chipTool, " ***** Test Step 248 : Read attribute NULLABLE_INT32U null Value & not\n"); + err = TestReadAttributeNullableInt32uNullValueNot_248(); break; case 249: - ChipLogProgress(chipTool, " ***** Test Step 249 : Read attribute NULLABLE_INT32U Value in range\n"); - err = TestReadAttributeNullableInt32uValueInRange_249(); + ChipLogProgress(chipTool, " ***** Test Step 249 : Write attribute NULLABLE_INT32U Value\n"); + err = TestWriteAttributeNullableInt32uValue_249(); break; case 250: - ChipLogProgress(chipTool, " ***** Test Step 250 : Read attribute NULLABLE_INT32U notValue OK\n"); - err = TestReadAttributeNullableInt32uNotValueOk_250(); + ChipLogProgress(chipTool, " ***** Test Step 250 : Read attribute NULLABLE_INT32U Value in range\n"); + err = TestReadAttributeNullableInt32uValueInRange_250(); break; case 251: - ChipLogProgress(chipTool, " ***** Test Step 251 : Write attribute NULLABLE_INT64U Min Value\n"); - err = TestWriteAttributeNullableInt64uMinValue_251(); + ChipLogProgress(chipTool, " ***** Test Step 251 : Read attribute NULLABLE_INT32U notValue OK\n"); + err = TestReadAttributeNullableInt32uNotValueOk_251(); break; case 252: - ChipLogProgress(chipTool, " ***** Test Step 252 : Read attribute NULLABLE_INT64U Min Value\n"); - err = TestReadAttributeNullableInt64uMinValue_252(); + ChipLogProgress(chipTool, " ***** Test Step 252 : Write attribute NULLABLE_INT64U Min Value\n"); + err = TestWriteAttributeNullableInt64uMinValue_252(); break; case 253: - ChipLogProgress(chipTool, " ***** Test Step 253 : Write attribute NULLABLE_INT64U Max Value\n"); - err = TestWriteAttributeNullableInt64uMaxValue_253(); + ChipLogProgress(chipTool, " ***** Test Step 253 : Read attribute NULLABLE_INT64U Min Value\n"); + err = TestReadAttributeNullableInt64uMinValue_253(); break; case 254: - ChipLogProgress(chipTool, " ***** Test Step 254 : Read attribute NULLABLE_INT64U Max Value\n"); - err = TestReadAttributeNullableInt64uMaxValue_254(); + ChipLogProgress(chipTool, " ***** Test Step 254 : Write attribute NULLABLE_INT64U Max Value\n"); + err = TestWriteAttributeNullableInt64uMaxValue_254(); break; case 255: - ChipLogProgress(chipTool, " ***** Test Step 255 : Write attribute NULLABLE_INT64U Invalid Value\n"); - err = TestWriteAttributeNullableInt64uInvalidValue_255(); + ChipLogProgress(chipTool, " ***** Test Step 255 : Read attribute NULLABLE_INT64U Max Value\n"); + err = TestReadAttributeNullableInt64uMaxValue_255(); break; case 256: - ChipLogProgress(chipTool, " ***** Test Step 256 : Read attribute NULLABLE_INT64U unchanged Value\n"); - err = TestReadAttributeNullableInt64uUnchangedValue_256(); + ChipLogProgress(chipTool, " ***** Test Step 256 : Write attribute NULLABLE_INT64U Invalid Value\n"); + err = TestWriteAttributeNullableInt64uInvalidValue_256(); break; case 257: - ChipLogProgress(chipTool, " ***** Test Step 257 : Write attribute NULLABLE_INT64U null Value\n"); - err = TestWriteAttributeNullableInt64uNullValue_257(); + ChipLogProgress(chipTool, " ***** Test Step 257 : Read attribute NULLABLE_INT64U unchanged Value\n"); + err = TestReadAttributeNullableInt64uUnchangedValue_257(); break; case 258: - ChipLogProgress(chipTool, " ***** Test Step 258 : Read attribute NULLABLE_INT64U null Value\n"); - err = TestReadAttributeNullableInt64uNullValue_258(); + ChipLogProgress(chipTool, " ***** Test Step 258 : Write attribute NULLABLE_INT64U null Value\n"); + err = TestWriteAttributeNullableInt64uNullValue_258(); break; case 259: - ChipLogProgress(chipTool, " ***** Test Step 259 : Read attribute NULLABLE_INT64U null Value & range\n"); - err = TestReadAttributeNullableInt64uNullValueRange_259(); + ChipLogProgress(chipTool, " ***** Test Step 259 : Read attribute NULLABLE_INT64U null Value\n"); + err = TestReadAttributeNullableInt64uNullValue_259(); break; case 260: - ChipLogProgress(chipTool, " ***** Test Step 260 : Read attribute NULLABLE_INT64U null Value & not\n"); - err = TestReadAttributeNullableInt64uNullValueNot_260(); + ChipLogProgress(chipTool, " ***** Test Step 260 : Read attribute NULLABLE_INT64U null Value & range\n"); + err = TestReadAttributeNullableInt64uNullValueRange_260(); break; case 261: - ChipLogProgress(chipTool, " ***** Test Step 261 : Write attribute NULLABLE_INT64U Value\n"); - err = TestWriteAttributeNullableInt64uValue_261(); + ChipLogProgress(chipTool, " ***** Test Step 261 : Read attribute NULLABLE_INT64U null Value & not\n"); + err = TestReadAttributeNullableInt64uNullValueNot_261(); break; case 262: - ChipLogProgress(chipTool, " ***** Test Step 262 : Read attribute NULLABLE_INT64U Value in range\n"); - err = TestReadAttributeNullableInt64uValueInRange_262(); + ChipLogProgress(chipTool, " ***** Test Step 262 : Write attribute NULLABLE_INT64U Value\n"); + err = TestWriteAttributeNullableInt64uValue_262(); break; case 263: - ChipLogProgress(chipTool, " ***** Test Step 263 : Read attribute NULLABLE_INT64U notValue OK\n"); - err = TestReadAttributeNullableInt64uNotValueOk_263(); + ChipLogProgress(chipTool, " ***** Test Step 263 : Read attribute NULLABLE_INT64U Value in range\n"); + err = TestReadAttributeNullableInt64uValueInRange_263(); break; case 264: - ChipLogProgress(chipTool, " ***** Test Step 264 : Write attribute NULLABLE_INT8S Min Value\n"); - err = TestWriteAttributeNullableInt8sMinValue_264(); + ChipLogProgress(chipTool, " ***** Test Step 264 : Read attribute NULLABLE_INT64U notValue OK\n"); + err = TestReadAttributeNullableInt64uNotValueOk_264(); break; case 265: - ChipLogProgress(chipTool, " ***** Test Step 265 : Read attribute NULLABLE_INT8S Min Value\n"); - err = TestReadAttributeNullableInt8sMinValue_265(); + ChipLogProgress(chipTool, " ***** Test Step 265 : Write attribute NULLABLE_INT8S Min Value\n"); + err = TestWriteAttributeNullableInt8sMinValue_265(); break; case 266: - ChipLogProgress(chipTool, " ***** Test Step 266 : Write attribute NULLABLE_INT8S Invalid Value\n"); - err = TestWriteAttributeNullableInt8sInvalidValue_266(); + ChipLogProgress(chipTool, " ***** Test Step 266 : Read attribute NULLABLE_INT8S Min Value\n"); + err = TestReadAttributeNullableInt8sMinValue_266(); break; case 267: - ChipLogProgress(chipTool, " ***** Test Step 267 : Read attribute NULLABLE_INT8S unchanged Value\n"); - err = TestReadAttributeNullableInt8sUnchangedValue_267(); + ChipLogProgress(chipTool, " ***** Test Step 267 : Write attribute NULLABLE_INT8S Invalid Value\n"); + err = TestWriteAttributeNullableInt8sInvalidValue_267(); break; case 268: - ChipLogProgress(chipTool, " ***** Test Step 268 : Write attribute NULLABLE_INT8S null Value\n"); - err = TestWriteAttributeNullableInt8sNullValue_268(); + ChipLogProgress(chipTool, " ***** Test Step 268 : Read attribute NULLABLE_INT8S unchanged Value\n"); + err = TestReadAttributeNullableInt8sUnchangedValue_268(); break; case 269: - ChipLogProgress(chipTool, " ***** Test Step 269 : Read attribute NULLABLE_INT8S null Value\n"); - err = TestReadAttributeNullableInt8sNullValue_269(); + ChipLogProgress(chipTool, " ***** Test Step 269 : Write attribute NULLABLE_INT8S null Value\n"); + err = TestWriteAttributeNullableInt8sNullValue_269(); break; case 270: - ChipLogProgress(chipTool, " ***** Test Step 270 : Read attribute NULLABLE_INT8S null Value & range\n"); - err = TestReadAttributeNullableInt8sNullValueRange_270(); + ChipLogProgress(chipTool, " ***** Test Step 270 : Read attribute NULLABLE_INT8S null Value\n"); + err = TestReadAttributeNullableInt8sNullValue_270(); break; case 271: - ChipLogProgress(chipTool, " ***** Test Step 271 : Read attribute NULLABLE_INT8S null Value & not\n"); - err = TestReadAttributeNullableInt8sNullValueNot_271(); + ChipLogProgress(chipTool, " ***** Test Step 271 : Read attribute NULLABLE_INT8S null Value & range\n"); + err = TestReadAttributeNullableInt8sNullValueRange_271(); break; case 272: - ChipLogProgress(chipTool, " ***** Test Step 272 : Write attribute NULLABLE_INT8S Value\n"); - err = TestWriteAttributeNullableInt8sValue_272(); + ChipLogProgress(chipTool, " ***** Test Step 272 : Read attribute NULLABLE_INT8S null Value & not\n"); + err = TestReadAttributeNullableInt8sNullValueNot_272(); break; case 273: - ChipLogProgress(chipTool, " ***** Test Step 273 : Read attribute NULLABLE_INT8S Value in range\n"); - err = TestReadAttributeNullableInt8sValueInRange_273(); + ChipLogProgress(chipTool, " ***** Test Step 273 : Write attribute NULLABLE_INT8S Value\n"); + err = TestWriteAttributeNullableInt8sValue_273(); break; case 274: - ChipLogProgress(chipTool, " ***** Test Step 274 : Read attribute NULLABLE_INT8S notValue OK\n"); - err = TestReadAttributeNullableInt8sNotValueOk_274(); + ChipLogProgress(chipTool, " ***** Test Step 274 : Read attribute NULLABLE_INT8S Value in range\n"); + err = TestReadAttributeNullableInt8sValueInRange_274(); break; case 275: - ChipLogProgress(chipTool, " ***** Test Step 275 : Write attribute NULLABLE_INT16S Min Value\n"); - err = TestWriteAttributeNullableInt16sMinValue_275(); + ChipLogProgress(chipTool, " ***** Test Step 275 : Read attribute NULLABLE_INT8S notValue OK\n"); + err = TestReadAttributeNullableInt8sNotValueOk_275(); break; case 276: - ChipLogProgress(chipTool, " ***** Test Step 276 : Read attribute NULLABLE_INT16S Min Value\n"); - err = TestReadAttributeNullableInt16sMinValue_276(); + ChipLogProgress(chipTool, " ***** Test Step 276 : Write attribute NULLABLE_INT16S Min Value\n"); + err = TestWriteAttributeNullableInt16sMinValue_276(); break; case 277: - ChipLogProgress(chipTool, " ***** Test Step 277 : Write attribute NULLABLE_INT16S Invalid Value\n"); - err = TestWriteAttributeNullableInt16sInvalidValue_277(); + ChipLogProgress(chipTool, " ***** Test Step 277 : Read attribute NULLABLE_INT16S Min Value\n"); + err = TestReadAttributeNullableInt16sMinValue_277(); break; case 278: - ChipLogProgress(chipTool, " ***** Test Step 278 : Read attribute NULLABLE_INT16S unchanged Value\n"); - err = TestReadAttributeNullableInt16sUnchangedValue_278(); + ChipLogProgress(chipTool, " ***** Test Step 278 : Write attribute NULLABLE_INT16S Invalid Value\n"); + err = TestWriteAttributeNullableInt16sInvalidValue_278(); break; case 279: - ChipLogProgress(chipTool, " ***** Test Step 279 : Write attribute NULLABLE_INT16S null Value\n"); - err = TestWriteAttributeNullableInt16sNullValue_279(); + ChipLogProgress(chipTool, " ***** Test Step 279 : Read attribute NULLABLE_INT16S unchanged Value\n"); + err = TestReadAttributeNullableInt16sUnchangedValue_279(); break; case 280: - ChipLogProgress(chipTool, " ***** Test Step 280 : Read attribute NULLABLE_INT16S null Value\n"); - err = TestReadAttributeNullableInt16sNullValue_280(); + ChipLogProgress(chipTool, " ***** Test Step 280 : Write attribute NULLABLE_INT16S null Value\n"); + err = TestWriteAttributeNullableInt16sNullValue_280(); break; case 281: - ChipLogProgress(chipTool, " ***** Test Step 281 : Read attribute NULLABLE_INT16S null Value & range\n"); - err = TestReadAttributeNullableInt16sNullValueRange_281(); + ChipLogProgress(chipTool, " ***** Test Step 281 : Read attribute NULLABLE_INT16S null Value\n"); + err = TestReadAttributeNullableInt16sNullValue_281(); break; case 282: - ChipLogProgress(chipTool, " ***** Test Step 282 : Read attribute NULLABLE_INT16S null Value & not\n"); - err = TestReadAttributeNullableInt16sNullValueNot_282(); + ChipLogProgress(chipTool, " ***** Test Step 282 : Read attribute NULLABLE_INT16S null Value & range\n"); + err = TestReadAttributeNullableInt16sNullValueRange_282(); break; case 283: - ChipLogProgress(chipTool, " ***** Test Step 283 : Write attribute NULLABLE_INT16S Value\n"); - err = TestWriteAttributeNullableInt16sValue_283(); + ChipLogProgress(chipTool, " ***** Test Step 283 : Read attribute NULLABLE_INT16S null Value & not\n"); + err = TestReadAttributeNullableInt16sNullValueNot_283(); break; case 284: - ChipLogProgress(chipTool, " ***** Test Step 284 : Read attribute NULLABLE_INT16S Value in range\n"); - err = TestReadAttributeNullableInt16sValueInRange_284(); + ChipLogProgress(chipTool, " ***** Test Step 284 : Write attribute NULLABLE_INT16S Value\n"); + err = TestWriteAttributeNullableInt16sValue_284(); break; case 285: - ChipLogProgress(chipTool, " ***** Test Step 285 : Read attribute NULLABLE_INT16S notValue OK\n"); - err = TestReadAttributeNullableInt16sNotValueOk_285(); + ChipLogProgress(chipTool, " ***** Test Step 285 : Read attribute NULLABLE_INT16S Value in range\n"); + err = TestReadAttributeNullableInt16sValueInRange_285(); break; case 286: - ChipLogProgress(chipTool, " ***** Test Step 286 : Write attribute NULLABLE_INT32S Min Value\n"); - err = TestWriteAttributeNullableInt32sMinValue_286(); + ChipLogProgress(chipTool, " ***** Test Step 286 : Read attribute NULLABLE_INT16S notValue OK\n"); + err = TestReadAttributeNullableInt16sNotValueOk_286(); break; case 287: - ChipLogProgress(chipTool, " ***** Test Step 287 : Read attribute NULLABLE_INT32S Min Value\n"); - err = TestReadAttributeNullableInt32sMinValue_287(); + ChipLogProgress(chipTool, " ***** Test Step 287 : Write attribute NULLABLE_INT32S Min Value\n"); + err = TestWriteAttributeNullableInt32sMinValue_287(); break; case 288: - ChipLogProgress(chipTool, " ***** Test Step 288 : Write attribute NULLABLE_INT32S Invalid Value\n"); - err = TestWriteAttributeNullableInt32sInvalidValue_288(); + ChipLogProgress(chipTool, " ***** Test Step 288 : Read attribute NULLABLE_INT32S Min Value\n"); + err = TestReadAttributeNullableInt32sMinValue_288(); break; case 289: - ChipLogProgress(chipTool, " ***** Test Step 289 : Read attribute NULLABLE_INT32S unchanged Value\n"); - err = TestReadAttributeNullableInt32sUnchangedValue_289(); + ChipLogProgress(chipTool, " ***** Test Step 289 : Write attribute NULLABLE_INT32S Invalid Value\n"); + err = TestWriteAttributeNullableInt32sInvalidValue_289(); break; case 290: - ChipLogProgress(chipTool, " ***** Test Step 290 : Write attribute NULLABLE_INT32S null Value\n"); - err = TestWriteAttributeNullableInt32sNullValue_290(); + ChipLogProgress(chipTool, " ***** Test Step 290 : Read attribute NULLABLE_INT32S unchanged Value\n"); + err = TestReadAttributeNullableInt32sUnchangedValue_290(); break; case 291: - ChipLogProgress(chipTool, " ***** Test Step 291 : Read attribute NULLABLE_INT32S null Value\n"); - err = TestReadAttributeNullableInt32sNullValue_291(); + ChipLogProgress(chipTool, " ***** Test Step 291 : Write attribute NULLABLE_INT32S null Value\n"); + err = TestWriteAttributeNullableInt32sNullValue_291(); break; case 292: - ChipLogProgress(chipTool, " ***** Test Step 292 : Read attribute NULLABLE_INT32S null Value & range\n"); - err = TestReadAttributeNullableInt32sNullValueRange_292(); + ChipLogProgress(chipTool, " ***** Test Step 292 : Read attribute NULLABLE_INT32S null Value\n"); + err = TestReadAttributeNullableInt32sNullValue_292(); break; case 293: - ChipLogProgress(chipTool, " ***** Test Step 293 : Read attribute NULLABLE_INT32S null Value & not\n"); - err = TestReadAttributeNullableInt32sNullValueNot_293(); + ChipLogProgress(chipTool, " ***** Test Step 293 : Read attribute NULLABLE_INT32S null Value & range\n"); + err = TestReadAttributeNullableInt32sNullValueRange_293(); break; case 294: - ChipLogProgress(chipTool, " ***** Test Step 294 : Write attribute NULLABLE_INT32S Value\n"); - err = TestWriteAttributeNullableInt32sValue_294(); + ChipLogProgress(chipTool, " ***** Test Step 294 : Read attribute NULLABLE_INT32S null Value & not\n"); + err = TestReadAttributeNullableInt32sNullValueNot_294(); break; case 295: - ChipLogProgress(chipTool, " ***** Test Step 295 : Read attribute NULLABLE_INT32S Value in range\n"); - err = TestReadAttributeNullableInt32sValueInRange_295(); + ChipLogProgress(chipTool, " ***** Test Step 295 : Write attribute NULLABLE_INT32S Value\n"); + err = TestWriteAttributeNullableInt32sValue_295(); break; case 296: - ChipLogProgress(chipTool, " ***** Test Step 296 : Read attribute NULLABLE_INT32S notValue OK\n"); - err = TestReadAttributeNullableInt32sNotValueOk_296(); + ChipLogProgress(chipTool, " ***** Test Step 296 : Read attribute NULLABLE_INT32S Value in range\n"); + err = TestReadAttributeNullableInt32sValueInRange_296(); break; case 297: - ChipLogProgress(chipTool, " ***** Test Step 297 : Write attribute NULLABLE_INT64S Min Value\n"); - err = TestWriteAttributeNullableInt64sMinValue_297(); + ChipLogProgress(chipTool, " ***** Test Step 297 : Read attribute NULLABLE_INT32S notValue OK\n"); + err = TestReadAttributeNullableInt32sNotValueOk_297(); break; case 298: - ChipLogProgress(chipTool, " ***** Test Step 298 : Read attribute NULLABLE_INT64S Min Value\n"); - err = TestReadAttributeNullableInt64sMinValue_298(); + ChipLogProgress(chipTool, " ***** Test Step 298 : Write attribute NULLABLE_INT64S Min Value\n"); + err = TestWriteAttributeNullableInt64sMinValue_298(); break; case 299: - ChipLogProgress(chipTool, " ***** Test Step 299 : Write attribute NULLABLE_INT64S Invalid Value\n"); - err = TestWriteAttributeNullableInt64sInvalidValue_299(); + ChipLogProgress(chipTool, " ***** Test Step 299 : Read attribute NULLABLE_INT64S Min Value\n"); + err = TestReadAttributeNullableInt64sMinValue_299(); break; case 300: - ChipLogProgress(chipTool, " ***** Test Step 300 : Read attribute NULLABLE_INT64S unchanged Value\n"); - err = TestReadAttributeNullableInt64sUnchangedValue_300(); + ChipLogProgress(chipTool, " ***** Test Step 300 : Write attribute NULLABLE_INT64S Invalid Value\n"); + err = TestWriteAttributeNullableInt64sInvalidValue_300(); break; case 301: - ChipLogProgress(chipTool, " ***** Test Step 301 : Write attribute NULLABLE_INT64S null Value\n"); - err = TestWriteAttributeNullableInt64sNullValue_301(); + ChipLogProgress(chipTool, " ***** Test Step 301 : Read attribute NULLABLE_INT64S unchanged Value\n"); + err = TestReadAttributeNullableInt64sUnchangedValue_301(); break; case 302: - ChipLogProgress(chipTool, " ***** Test Step 302 : Read attribute NULLABLE_INT64S null Value\n"); - err = TestReadAttributeNullableInt64sNullValue_302(); + ChipLogProgress(chipTool, " ***** Test Step 302 : Write attribute NULLABLE_INT64S null Value\n"); + err = TestWriteAttributeNullableInt64sNullValue_302(); break; case 303: - ChipLogProgress(chipTool, " ***** Test Step 303 : Read attribute NULLABLE_INT64S null Value & range\n"); - err = TestReadAttributeNullableInt64sNullValueRange_303(); + ChipLogProgress(chipTool, " ***** Test Step 303 : Read attribute NULLABLE_INT64S null Value\n"); + err = TestReadAttributeNullableInt64sNullValue_303(); break; case 304: - ChipLogProgress(chipTool, " ***** Test Step 304 : Read attribute NULLABLE_INT64S null Value & not\n"); - err = TestReadAttributeNullableInt64sNullValueNot_304(); + ChipLogProgress(chipTool, " ***** Test Step 304 : Read attribute NULLABLE_INT64S null Value & range\n"); + err = TestReadAttributeNullableInt64sNullValueRange_304(); break; case 305: - ChipLogProgress(chipTool, " ***** Test Step 305 : Write attribute NULLABLE_INT64S Value\n"); - err = TestWriteAttributeNullableInt64sValue_305(); + ChipLogProgress(chipTool, " ***** Test Step 305 : Read attribute NULLABLE_INT64S null Value & not\n"); + err = TestReadAttributeNullableInt64sNullValueNot_305(); break; case 306: - ChipLogProgress(chipTool, " ***** Test Step 306 : Read attribute NULLABLE_INT64S Value in range\n"); - err = TestReadAttributeNullableInt64sValueInRange_306(); + ChipLogProgress(chipTool, " ***** Test Step 306 : Write attribute NULLABLE_INT64S Value\n"); + err = TestWriteAttributeNullableInt64sValue_306(); break; case 307: - ChipLogProgress(chipTool, " ***** Test Step 307 : Read attribute NULLABLE_INT64S notValue OK\n"); - err = TestReadAttributeNullableInt64sNotValueOk_307(); + ChipLogProgress(chipTool, " ***** Test Step 307 : Read attribute NULLABLE_INT64S Value in range\n"); + err = TestReadAttributeNullableInt64sValueInRange_307(); break; case 308: - ChipLogProgress(chipTool, " ***** Test Step 308 : Write attribute NULLABLE_SINGLE medium Value\n"); - err = TestWriteAttributeNullableSingleMediumValue_308(); + ChipLogProgress(chipTool, " ***** Test Step 308 : Read attribute NULLABLE_INT64S notValue OK\n"); + err = TestReadAttributeNullableInt64sNotValueOk_308(); break; case 309: - ChipLogProgress(chipTool, " ***** Test Step 309 : Read attribute NULLABLE_SINGLE medium Value\n"); - err = TestReadAttributeNullableSingleMediumValue_309(); + ChipLogProgress(chipTool, " ***** Test Step 309 : Write attribute NULLABLE_SINGLE medium Value\n"); + err = TestWriteAttributeNullableSingleMediumValue_309(); break; case 310: - ChipLogProgress(chipTool, " ***** Test Step 310 : Write attribute NULLABLE_SINGLE largest Value\n"); - err = TestWriteAttributeNullableSingleLargestValue_310(); + ChipLogProgress(chipTool, " ***** Test Step 310 : Read attribute NULLABLE_SINGLE medium Value\n"); + err = TestReadAttributeNullableSingleMediumValue_310(); break; case 311: - ChipLogProgress(chipTool, " ***** Test Step 311 : Read attribute NULLABLE_SINGLE largest Value\n"); - err = TestReadAttributeNullableSingleLargestValue_311(); + ChipLogProgress(chipTool, " ***** Test Step 311 : Write attribute NULLABLE_SINGLE largest Value\n"); + err = TestWriteAttributeNullableSingleLargestValue_311(); break; case 312: - ChipLogProgress(chipTool, " ***** Test Step 312 : Write attribute NULLABLE_SINGLE smallest Value\n"); - err = TestWriteAttributeNullableSingleSmallestValue_312(); + ChipLogProgress(chipTool, " ***** Test Step 312 : Read attribute NULLABLE_SINGLE largest Value\n"); + err = TestReadAttributeNullableSingleLargestValue_312(); break; case 313: - ChipLogProgress(chipTool, " ***** Test Step 313 : Read attribute NULLABLE_SINGLE smallest Value\n"); - err = TestReadAttributeNullableSingleSmallestValue_313(); + ChipLogProgress(chipTool, " ***** Test Step 313 : Write attribute NULLABLE_SINGLE smallest Value\n"); + err = TestWriteAttributeNullableSingleSmallestValue_313(); break; case 314: - ChipLogProgress(chipTool, " ***** Test Step 314 : Write attribute NULLABLE_SINGLE null Value\n"); - err = TestWriteAttributeNullableSingleNullValue_314(); + ChipLogProgress(chipTool, " ***** Test Step 314 : Read attribute NULLABLE_SINGLE smallest Value\n"); + err = TestReadAttributeNullableSingleSmallestValue_314(); break; case 315: - ChipLogProgress(chipTool, " ***** Test Step 315 : Read attribute NULLABLE_SINGLE null Value\n"); - err = TestReadAttributeNullableSingleNullValue_315(); + ChipLogProgress(chipTool, " ***** Test Step 315 : Write attribute NULLABLE_SINGLE null Value\n"); + err = TestWriteAttributeNullableSingleNullValue_315(); break; case 316: - ChipLogProgress(chipTool, " ***** Test Step 316 : Write attribute NULLABLE_SINGLE 0 Value\n"); - err = TestWriteAttributeNullableSingle0Value_316(); + ChipLogProgress(chipTool, " ***** Test Step 316 : Read attribute NULLABLE_SINGLE null Value\n"); + err = TestReadAttributeNullableSingleNullValue_316(); break; case 317: - ChipLogProgress(chipTool, " ***** Test Step 317 : Read attribute NULLABLE_SINGLE 0 Value\n"); - err = TestReadAttributeNullableSingle0Value_317(); + ChipLogProgress(chipTool, " ***** Test Step 317 : Write attribute NULLABLE_SINGLE 0 Value\n"); + err = TestWriteAttributeNullableSingle0Value_317(); break; case 318: - ChipLogProgress(chipTool, " ***** Test Step 318 : Write attribute NULLABLE_DOUBLE medium Value\n"); - err = TestWriteAttributeNullableDoubleMediumValue_318(); + ChipLogProgress(chipTool, " ***** Test Step 318 : Read attribute NULLABLE_SINGLE 0 Value\n"); + err = TestReadAttributeNullableSingle0Value_318(); break; case 319: - ChipLogProgress(chipTool, " ***** Test Step 319 : Read attribute NULLABLE_DOUBLE medium Value\n"); - err = TestReadAttributeNullableDoubleMediumValue_319(); + ChipLogProgress(chipTool, " ***** Test Step 319 : Write attribute NULLABLE_DOUBLE medium Value\n"); + err = TestWriteAttributeNullableDoubleMediumValue_319(); break; case 320: - ChipLogProgress(chipTool, " ***** Test Step 320 : Write attribute NULLABLE_DOUBLE largest Value\n"); - err = TestWriteAttributeNullableDoubleLargestValue_320(); + ChipLogProgress(chipTool, " ***** Test Step 320 : Read attribute NULLABLE_DOUBLE medium Value\n"); + err = TestReadAttributeNullableDoubleMediumValue_320(); break; case 321: - ChipLogProgress(chipTool, " ***** Test Step 321 : Read attribute NULLABLE_DOUBLE largest Value\n"); - err = TestReadAttributeNullableDoubleLargestValue_321(); + ChipLogProgress(chipTool, " ***** Test Step 321 : Write attribute NULLABLE_DOUBLE largest Value\n"); + err = TestWriteAttributeNullableDoubleLargestValue_321(); break; case 322: - ChipLogProgress(chipTool, " ***** Test Step 322 : Write attribute NULLABLE_DOUBLE smallest Value\n"); - err = TestWriteAttributeNullableDoubleSmallestValue_322(); + ChipLogProgress(chipTool, " ***** Test Step 322 : Read attribute NULLABLE_DOUBLE largest Value\n"); + err = TestReadAttributeNullableDoubleLargestValue_322(); break; case 323: - ChipLogProgress(chipTool, " ***** Test Step 323 : Read attribute NULLABLE_DOUBLE smallest Value\n"); - err = TestReadAttributeNullableDoubleSmallestValue_323(); + ChipLogProgress(chipTool, " ***** Test Step 323 : Write attribute NULLABLE_DOUBLE smallest Value\n"); + err = TestWriteAttributeNullableDoubleSmallestValue_323(); break; case 324: - ChipLogProgress(chipTool, " ***** Test Step 324 : Write attribute NULLABLE_DOUBLE null Value\n"); - err = TestWriteAttributeNullableDoubleNullValue_324(); + ChipLogProgress(chipTool, " ***** Test Step 324 : Read attribute NULLABLE_DOUBLE smallest Value\n"); + err = TestReadAttributeNullableDoubleSmallestValue_324(); break; case 325: - ChipLogProgress(chipTool, " ***** Test Step 325 : Read attribute NULLABLE_DOUBLE null Value\n"); - err = TestReadAttributeNullableDoubleNullValue_325(); + ChipLogProgress(chipTool, " ***** Test Step 325 : Write attribute NULLABLE_DOUBLE null Value\n"); + err = TestWriteAttributeNullableDoubleNullValue_325(); break; case 326: - ChipLogProgress(chipTool, " ***** Test Step 326 : Write attribute NULLABLE_DOUBLE 0 Value\n"); - err = TestWriteAttributeNullableDouble0Value_326(); + ChipLogProgress(chipTool, " ***** Test Step 326 : Read attribute NULLABLE_DOUBLE null Value\n"); + err = TestReadAttributeNullableDoubleNullValue_326(); break; case 327: - ChipLogProgress(chipTool, " ***** Test Step 327 : Read attribute NULLABLE_DOUBLE 0 Value\n"); - err = TestReadAttributeNullableDouble0Value_327(); + ChipLogProgress(chipTool, " ***** Test Step 327 : Write attribute NULLABLE_DOUBLE 0 Value\n"); + err = TestWriteAttributeNullableDouble0Value_327(); break; case 328: - ChipLogProgress(chipTool, " ***** Test Step 328 : Write attribute NULLABLE_ENUM8 Min Value\n"); - err = TestWriteAttributeNullableEnum8MinValue_328(); + ChipLogProgress(chipTool, " ***** Test Step 328 : Read attribute NULLABLE_DOUBLE 0 Value\n"); + err = TestReadAttributeNullableDouble0Value_328(); break; case 329: - ChipLogProgress(chipTool, " ***** Test Step 329 : Read attribute NULLABLE_ENUM8 Min Value\n"); - err = TestReadAttributeNullableEnum8MinValue_329(); + ChipLogProgress(chipTool, " ***** Test Step 329 : Write attribute NULLABLE_ENUM8 Min Value\n"); + err = TestWriteAttributeNullableEnum8MinValue_329(); break; case 330: - ChipLogProgress(chipTool, " ***** Test Step 330 : Write attribute NULLABLE_ENUM8 Max Value\n"); - err = TestWriteAttributeNullableEnum8MaxValue_330(); + ChipLogProgress(chipTool, " ***** Test Step 330 : Read attribute NULLABLE_ENUM8 Min Value\n"); + err = TestReadAttributeNullableEnum8MinValue_330(); break; case 331: - ChipLogProgress(chipTool, " ***** Test Step 331 : Read attribute NULLABLE_ENUM8 Max Value\n"); - err = TestReadAttributeNullableEnum8MaxValue_331(); + ChipLogProgress(chipTool, " ***** Test Step 331 : Write attribute NULLABLE_ENUM8 Max Value\n"); + err = TestWriteAttributeNullableEnum8MaxValue_331(); break; case 332: - ChipLogProgress(chipTool, " ***** Test Step 332 : Write attribute NULLABLE_ENUM8 Invalid Value\n"); - err = TestWriteAttributeNullableEnum8InvalidValue_332(); + ChipLogProgress(chipTool, " ***** Test Step 332 : Read attribute NULLABLE_ENUM8 Max Value\n"); + err = TestReadAttributeNullableEnum8MaxValue_332(); break; case 333: - ChipLogProgress(chipTool, " ***** Test Step 333 : Read attribute NULLABLE_ENUM8 unchanged Value\n"); - err = TestReadAttributeNullableEnum8UnchangedValue_333(); + ChipLogProgress(chipTool, " ***** Test Step 333 : Write attribute NULLABLE_ENUM8 Invalid Value\n"); + err = TestWriteAttributeNullableEnum8InvalidValue_333(); break; case 334: - ChipLogProgress(chipTool, " ***** Test Step 334 : Write attribute NULLABLE_ENUM8 null Value\n"); - err = TestWriteAttributeNullableEnum8NullValue_334(); + ChipLogProgress(chipTool, " ***** Test Step 334 : Read attribute NULLABLE_ENUM8 unchanged Value\n"); + err = TestReadAttributeNullableEnum8UnchangedValue_334(); break; case 335: - ChipLogProgress(chipTool, " ***** Test Step 335 : Read attribute NULLABLE_ENUM8 null Value\n"); - err = TestReadAttributeNullableEnum8NullValue_335(); + ChipLogProgress(chipTool, " ***** Test Step 335 : Write attribute NULLABLE_ENUM8 null Value\n"); + err = TestWriteAttributeNullableEnum8NullValue_335(); break; case 336: - ChipLogProgress(chipTool, " ***** Test Step 336 : Write attribute NULLABLE_ENUM16 Min Value\n"); - err = TestWriteAttributeNullableEnum16MinValue_336(); + ChipLogProgress(chipTool, " ***** Test Step 336 : Read attribute NULLABLE_ENUM8 null Value\n"); + err = TestReadAttributeNullableEnum8NullValue_336(); break; case 337: - ChipLogProgress(chipTool, " ***** Test Step 337 : Read attribute NULLABLE_ENUM16 Min Value\n"); - err = TestReadAttributeNullableEnum16MinValue_337(); + ChipLogProgress(chipTool, " ***** Test Step 337 : Write attribute NULLABLE_ENUM16 Min Value\n"); + err = TestWriteAttributeNullableEnum16MinValue_337(); break; case 338: - ChipLogProgress(chipTool, " ***** Test Step 338 : Write attribute NULLABLE_ENUM16 Max Value\n"); - err = TestWriteAttributeNullableEnum16MaxValue_338(); + ChipLogProgress(chipTool, " ***** Test Step 338 : Read attribute NULLABLE_ENUM16 Min Value\n"); + err = TestReadAttributeNullableEnum16MinValue_338(); break; case 339: - ChipLogProgress(chipTool, " ***** Test Step 339 : Read attribute NULLABLE_ENUM16 Max Value\n"); - err = TestReadAttributeNullableEnum16MaxValue_339(); + ChipLogProgress(chipTool, " ***** Test Step 339 : Write attribute NULLABLE_ENUM16 Max Value\n"); + err = TestWriteAttributeNullableEnum16MaxValue_339(); break; case 340: - ChipLogProgress(chipTool, " ***** Test Step 340 : Write attribute NULLABLE_ENUM16 Invalid Value\n"); - err = TestWriteAttributeNullableEnum16InvalidValue_340(); + ChipLogProgress(chipTool, " ***** Test Step 340 : Read attribute NULLABLE_ENUM16 Max Value\n"); + err = TestReadAttributeNullableEnum16MaxValue_340(); break; case 341: - ChipLogProgress(chipTool, " ***** Test Step 341 : Read attribute NULLABLE_ENUM16 unchanged Value\n"); - err = TestReadAttributeNullableEnum16UnchangedValue_341(); + ChipLogProgress(chipTool, " ***** Test Step 341 : Write attribute NULLABLE_ENUM16 Invalid Value\n"); + err = TestWriteAttributeNullableEnum16InvalidValue_341(); break; case 342: - ChipLogProgress(chipTool, " ***** Test Step 342 : Write attribute NULLABLE_ENUM16 null Value\n"); - err = TestWriteAttributeNullableEnum16NullValue_342(); + ChipLogProgress(chipTool, " ***** Test Step 342 : Read attribute NULLABLE_ENUM16 unchanged Value\n"); + err = TestReadAttributeNullableEnum16UnchangedValue_342(); break; case 343: - ChipLogProgress(chipTool, " ***** Test Step 343 : Read attribute NULLABLE_ENUM16 null Value\n"); - err = TestReadAttributeNullableEnum16NullValue_343(); + ChipLogProgress(chipTool, " ***** Test Step 343 : Write attribute NULLABLE_ENUM16 null Value\n"); + err = TestWriteAttributeNullableEnum16NullValue_343(); break; case 344: - ChipLogProgress(chipTool, " ***** Test Step 344 : Write attribute NULLABLE_SIMPLE_ENUM Min Value\n"); - err = TestWriteAttributeNullableSimpleEnumMinValue_344(); + ChipLogProgress(chipTool, " ***** Test Step 344 : Read attribute NULLABLE_ENUM16 null Value\n"); + err = TestReadAttributeNullableEnum16NullValue_344(); break; case 345: - ChipLogProgress(chipTool, " ***** Test Step 345 : Read attribute NULLABLE_SIMPLE_ENUM Min Value\n"); - err = TestReadAttributeNullableSimpleEnumMinValue_345(); + ChipLogProgress(chipTool, " ***** Test Step 345 : Write attribute NULLABLE_SIMPLE_ENUM Min Value\n"); + err = TestWriteAttributeNullableSimpleEnumMinValue_345(); break; case 346: - ChipLogProgress(chipTool, " ***** Test Step 346 : Write attribute NULLABLE_SIMPLE_ENUM Max Value\n"); - err = TestWriteAttributeNullableSimpleEnumMaxValue_346(); + ChipLogProgress(chipTool, " ***** Test Step 346 : Read attribute NULLABLE_SIMPLE_ENUM Min Value\n"); + err = TestReadAttributeNullableSimpleEnumMinValue_346(); break; case 347: - ChipLogProgress(chipTool, " ***** Test Step 347 : Read attribute NULLABLE_SIMPLE_ENUM Max Value\n"); - err = TestReadAttributeNullableSimpleEnumMaxValue_347(); + ChipLogProgress(chipTool, " ***** Test Step 347 : Write attribute NULLABLE_SIMPLE_ENUM Max Value\n"); + err = TestWriteAttributeNullableSimpleEnumMaxValue_347(); break; case 348: - ChipLogProgress(chipTool, " ***** Test Step 348 : Write attribute NULLABLE_SIMPLE_ENUM Invalid Value\n"); - err = TestWriteAttributeNullableSimpleEnumInvalidValue_348(); + ChipLogProgress(chipTool, " ***** Test Step 348 : Read attribute NULLABLE_SIMPLE_ENUM Max Value\n"); + err = TestReadAttributeNullableSimpleEnumMaxValue_348(); break; case 349: - ChipLogProgress(chipTool, " ***** Test Step 349 : Read attribute NULLABLE_SIMPLE_ENUM unchanged Value\n"); - err = TestReadAttributeNullableSimpleEnumUnchangedValue_349(); + ChipLogProgress(chipTool, " ***** Test Step 349 : Write attribute NULLABLE_SIMPLE_ENUM Invalid Value\n"); + err = TestWriteAttributeNullableSimpleEnumInvalidValue_349(); break; case 350: - ChipLogProgress(chipTool, " ***** Test Step 350 : Write attribute NULLABLE_SIMPLE_ENUM null Value\n"); - err = TestWriteAttributeNullableSimpleEnumNullValue_350(); + ChipLogProgress(chipTool, " ***** Test Step 350 : Read attribute NULLABLE_SIMPLE_ENUM unchanged Value\n"); + err = TestReadAttributeNullableSimpleEnumUnchangedValue_350(); break; case 351: - ChipLogProgress(chipTool, " ***** Test Step 351 : Read attribute NULLABLE_SIMPLE_ENUM null Value\n"); - err = TestReadAttributeNullableSimpleEnumNullValue_351(); + ChipLogProgress(chipTool, " ***** Test Step 351 : Write attribute NULLABLE_SIMPLE_ENUM null Value\n"); + err = TestWriteAttributeNullableSimpleEnumNullValue_351(); break; case 352: - ChipLogProgress(chipTool, " ***** Test Step 352 : Read attribute NULLABLE_SIMPLE_ENUM not 254 Value\n"); - err = TestReadAttributeNullableSimpleEnumNot254Value_352(); + ChipLogProgress(chipTool, " ***** Test Step 352 : Read attribute NULLABLE_SIMPLE_ENUM null Value\n"); + err = TestReadAttributeNullableSimpleEnumNullValue_352(); break; case 353: - ChipLogProgress(chipTool, " ***** Test Step 353 : Read attribute NULLABLE_OCTET_STRING Default Value\n"); - err = TestReadAttributeNullableOctetStringDefaultValue_353(); + ChipLogProgress(chipTool, " ***** Test Step 353 : Read attribute NULLABLE_SIMPLE_ENUM not 3 Value\n"); + err = TestReadAttributeNullableSimpleEnumNot3Value_353(); break; case 354: - ChipLogProgress(chipTool, " ***** Test Step 354 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_354(); + ChipLogProgress(chipTool, " ***** Test Step 354 : Read attribute NULLABLE_OCTET_STRING Default Value\n"); + err = TestReadAttributeNullableOctetStringDefaultValue_354(); break; case 355: - ChipLogProgress(chipTool, " ***** Test Step 355 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_355(); + ChipLogProgress(chipTool, " ***** Test Step 355 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_355(); break; case 356: - ChipLogProgress(chipTool, " ***** Test Step 356 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_356(); + ChipLogProgress(chipTool, " ***** Test Step 356 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_356(); break; case 357: - ChipLogProgress(chipTool, " ***** Test Step 357 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_357(); + ChipLogProgress(chipTool, " ***** Test Step 357 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_357(); break; case 358: - ChipLogProgress(chipTool, " ***** Test Step 358 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_358(); + ChipLogProgress(chipTool, " ***** Test Step 358 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_358(); break; case 359: - ChipLogProgress(chipTool, " ***** Test Step 359 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_359(); + ChipLogProgress(chipTool, " ***** Test Step 359 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_359(); break; case 360: - ChipLogProgress(chipTool, " ***** Test Step 360 : Read attribute NULLABLE_OCTET_STRING not TestValue\n"); - err = TestReadAttributeNullableOctetStringNotTestValue_360(); + ChipLogProgress(chipTool, " ***** Test Step 360 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_360(); break; case 361: - ChipLogProgress(chipTool, " ***** Test Step 361 : Read attribute NULLABLE_CHAR_STRING Default Value\n"); - err = TestReadAttributeNullableCharStringDefaultValue_361(); + ChipLogProgress(chipTool, " ***** Test Step 361 : Read attribute NULLABLE_OCTET_STRING not TestValue\n"); + err = TestReadAttributeNullableOctetStringNotTestValue_361(); break; case 362: - ChipLogProgress(chipTool, " ***** Test Step 362 : Write attribute NULLABLE_CHAR_STRING\n"); - err = TestWriteAttributeNullableCharString_362(); + ChipLogProgress(chipTool, " ***** Test Step 362 : Read attribute NULLABLE_CHAR_STRING Default Value\n"); + err = TestReadAttributeNullableCharStringDefaultValue_362(); break; case 363: - ChipLogProgress(chipTool, " ***** Test Step 363 : Read attribute NULLABLE_CHAR_STRING\n"); - err = TestReadAttributeNullableCharString_363(); + ChipLogProgress(chipTool, " ***** Test Step 363 : Write attribute NULLABLE_CHAR_STRING\n"); + err = TestWriteAttributeNullableCharString_363(); break; case 364: ChipLogProgress(chipTool, " ***** Test Step 364 : Read attribute NULLABLE_CHAR_STRING\n"); err = TestReadAttributeNullableCharString_364(); break; case 365: - ChipLogProgress(chipTool, " ***** Test Step 365 : Write attribute NULLABLE_CHAR_STRING - Value too long\n"); - err = TestWriteAttributeNullableCharStringValueTooLong_365(); + ChipLogProgress(chipTool, " ***** Test Step 365 : Read attribute NULLABLE_CHAR_STRING\n"); + err = TestReadAttributeNullableCharString_365(); break; case 366: - ChipLogProgress(chipTool, " ***** Test Step 366 : Read attribute NULLABLE_CHAR_STRING\n"); - err = TestReadAttributeNullableCharString_366(); + ChipLogProgress(chipTool, " ***** Test Step 366 : Write attribute NULLABLE_CHAR_STRING - Value too long\n"); + err = TestWriteAttributeNullableCharStringValueTooLong_366(); break; case 367: - ChipLogProgress(chipTool, " ***** Test Step 367 : Write attribute NULLABLE_CHAR_STRING - Empty\n"); - err = TestWriteAttributeNullableCharStringEmpty_367(); + ChipLogProgress(chipTool, " ***** Test Step 367 : Read attribute NULLABLE_CHAR_STRING\n"); + err = TestReadAttributeNullableCharString_367(); break; case 368: - ChipLogProgress(chipTool, " ***** Test Step 368 : Read attribute NULLABLE_CHAR_STRING\n"); - err = TestReadAttributeNullableCharString_368(); + ChipLogProgress(chipTool, " ***** Test Step 368 : Write attribute NULLABLE_CHAR_STRING - Empty\n"); + err = TestWriteAttributeNullableCharStringEmpty_368(); break; case 369: - ChipLogProgress(chipTool, " ***** Test Step 369 : Read attribute NULLABLE_CHAR_STRING not ☉T☉\n"); - err = TestReadAttributeNullableCharStringNott_369(); + ChipLogProgress(chipTool, " ***** Test Step 369 : Read attribute NULLABLE_CHAR_STRING\n"); + err = TestReadAttributeNullableCharString_369(); break; case 370: - ChipLogProgress(chipTool, " ***** Test Step 370 : Read attribute from nonexistent endpoint.\n"); - err = TestReadAttributeFromNonexistentEndpoint_370(); + ChipLogProgress(chipTool, " ***** Test Step 370 : Read attribute NULLABLE_CHAR_STRING not ☉T☉\n"); + err = TestReadAttributeNullableCharStringNott_370(); break; case 371: - ChipLogProgress(chipTool, " ***** Test Step 371 : Read attribute from nonexistent cluster.\n"); - err = TestReadAttributeFromNonexistentCluster_371(); + ChipLogProgress(chipTool, " ***** Test Step 371 : Read attribute from nonexistent endpoint.\n"); + err = TestReadAttributeFromNonexistentEndpoint_371(); break; case 372: - ChipLogProgress( - chipTool, " ***** Test Step 372 : Send a command that takes an optional parameter but do not set it.\n"); - err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_372(); + ChipLogProgress(chipTool, " ***** Test Step 372 : Read attribute from nonexistent cluster.\n"); + err = TestReadAttributeFromNonexistentCluster_372(); break; case 373: ChipLogProgress( @@ -64936,552 +64935,557 @@ class TestCluster : public TestCommandBridge { err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_373(); break; case 374: - ChipLogProgress(chipTool, " ***** Test Step 374 : Report: Subscribe to list attribute\n"); - err = TestReportSubscribeToListAttribute_374(); + ChipLogProgress( + chipTool, " ***** Test Step 374 : Send a command that takes an optional parameter but do not set it.\n"); + err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_374(); break; case 375: - ChipLogProgress(chipTool, " ***** Test Step 375 : Subscribe to list attribute\n"); - err = TestSubscribeToListAttribute_375(); + ChipLogProgress(chipTool, " ***** Test Step 375 : Report: Subscribe to list attribute\n"); + err = TestReportSubscribeToListAttribute_375(); break; case 376: - ChipLogProgress(chipTool, " ***** Test Step 376 : Write subscribed-to list attribute\n"); - err = TestWriteSubscribedToListAttribute_376(); + ChipLogProgress(chipTool, " ***** Test Step 376 : Subscribe to list attribute\n"); + err = TestSubscribeToListAttribute_376(); break; case 377: - ChipLogProgress(chipTool, " ***** Test Step 377 : Check for list attribute report\n"); - err = TestCheckForListAttributeReport_377(); + ChipLogProgress(chipTool, " ***** Test Step 377 : Write subscribed-to list attribute\n"); + err = TestWriteSubscribedToListAttribute_377(); break; case 378: - ChipLogProgress(chipTool, " ***** Test Step 378 : Read range-restricted unsigned 8-bit integer\n"); - err = TestReadRangeRestrictedUnsigned8BitInteger_378(); + ChipLogProgress(chipTool, " ***** Test Step 378 : Check for list attribute report\n"); + err = TestCheckForListAttributeReport_378(); break; case 379: - ChipLogProgress(chipTool, " ***** Test Step 379 : Write min value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_379(); + ChipLogProgress(chipTool, " ***** Test Step 379 : Read range-restricted unsigned 8-bit integer\n"); + err = TestReadRangeRestrictedUnsigned8BitInteger_379(); break; case 380: - ChipLogProgress( - chipTool, " ***** Test Step 380 : Write just-below-range value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_380(); + ChipLogProgress(chipTool, " ***** Test Step 380 : Write min value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_380(); break; case 381: ChipLogProgress( - chipTool, " ***** Test Step 381 : Write just-above-range value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_381(); + chipTool, " ***** Test Step 381 : Write just-below-range value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_381(); break; case 382: - ChipLogProgress(chipTool, " ***** Test Step 382 : Write max value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_382(); + ChipLogProgress( + chipTool, " ***** Test Step 382 : Write just-above-range value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_382(); break; case 383: - ChipLogProgress( - chipTool, " ***** Test Step 383 : Verify range-restricted unsigned 8-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_383(); + ChipLogProgress(chipTool, " ***** Test Step 383 : Write max value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_383(); break; case 384: ChipLogProgress( - chipTool, " ***** Test Step 384 : Write min valid value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_384(); + chipTool, " ***** Test Step 384 : Verify range-restricted unsigned 8-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_384(); break; case 385: ChipLogProgress( - chipTool, " ***** Test Step 385 : Verify range-restricted unsigned 8-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_385(); + chipTool, " ***** Test Step 385 : Write min valid value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_385(); break; case 386: ChipLogProgress( - chipTool, " ***** Test Step 386 : Write max valid value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_386(); + chipTool, " ***** Test Step 386 : Verify range-restricted unsigned 8-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_386(); break; case 387: ChipLogProgress( - chipTool, " ***** Test Step 387 : Verify range-restricted unsigned 8-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_387(); + chipTool, " ***** Test Step 387 : Write max valid value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_387(); break; case 388: ChipLogProgress( - chipTool, " ***** Test Step 388 : Write middle valid value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_388(); + chipTool, " ***** Test Step 388 : Verify range-restricted unsigned 8-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_388(); break; case 389: ChipLogProgress( - chipTool, " ***** Test Step 389 : Verify range-restricted unsigned 8-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_389(); + chipTool, " ***** Test Step 389 : Write middle valid value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_389(); break; case 390: - ChipLogProgress(chipTool, " ***** Test Step 390 : Read range-restricted unsigned 16-bit integer\n"); - err = TestReadRangeRestrictedUnsigned16BitInteger_390(); + ChipLogProgress( + chipTool, " ***** Test Step 390 : Verify range-restricted unsigned 8-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_390(); break; case 391: - ChipLogProgress(chipTool, " ***** Test Step 391 : Write min value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_391(); + ChipLogProgress(chipTool, " ***** Test Step 391 : Read range-restricted unsigned 16-bit integer\n"); + err = TestReadRangeRestrictedUnsigned16BitInteger_391(); break; case 392: - ChipLogProgress( - chipTool, " ***** Test Step 392 : Write just-below-range value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_392(); + ChipLogProgress(chipTool, " ***** Test Step 392 : Write min value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_392(); break; case 393: ChipLogProgress( - chipTool, " ***** Test Step 393 : Write just-above-range value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_393(); + chipTool, " ***** Test Step 393 : Write just-below-range value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_393(); break; case 394: - ChipLogProgress(chipTool, " ***** Test Step 394 : Write max value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_394(); + ChipLogProgress( + chipTool, " ***** Test Step 394 : Write just-above-range value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_394(); break; case 395: - ChipLogProgress( - chipTool, " ***** Test Step 395 : Verify range-restricted unsigned 16-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_395(); + ChipLogProgress(chipTool, " ***** Test Step 395 : Write max value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_395(); break; case 396: ChipLogProgress( - chipTool, " ***** Test Step 396 : Write min valid value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_396(); + chipTool, " ***** Test Step 396 : Verify range-restricted unsigned 16-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_396(); break; case 397: ChipLogProgress( - chipTool, " ***** Test Step 397 : Verify range-restricted unsigned 16-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_397(); + chipTool, " ***** Test Step 397 : Write min valid value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_397(); break; case 398: ChipLogProgress( - chipTool, " ***** Test Step 398 : Write max valid value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_398(); + chipTool, " ***** Test Step 398 : Verify range-restricted unsigned 16-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_398(); break; case 399: ChipLogProgress( - chipTool, " ***** Test Step 399 : Verify range-restricted unsigned 16-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_399(); + chipTool, " ***** Test Step 399 : Write max valid value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_399(); break; case 400: ChipLogProgress( - chipTool, " ***** Test Step 400 : Write middle valid value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_400(); + chipTool, " ***** Test Step 400 : Verify range-restricted unsigned 16-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_400(); break; case 401: ChipLogProgress( - chipTool, " ***** Test Step 401 : Verify range-restricted unsigned 16-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_401(); + chipTool, " ***** Test Step 401 : Write middle valid value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_401(); break; case 402: - ChipLogProgress(chipTool, " ***** Test Step 402 : Read range-restricted signed 8-bit integer\n"); - err = TestReadRangeRestrictedSigned8BitInteger_402(); + ChipLogProgress( + chipTool, " ***** Test Step 402 : Verify range-restricted unsigned 16-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_402(); break; case 403: - ChipLogProgress(chipTool, " ***** Test Step 403 : Write min value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedSigned8BitInteger_403(); + ChipLogProgress(chipTool, " ***** Test Step 403 : Read range-restricted signed 8-bit integer\n"); + err = TestReadRangeRestrictedSigned8BitInteger_403(); break; case 404: - ChipLogProgress( - chipTool, " ***** Test Step 404 : Write just-below-range value to a range-restricted signed 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_404(); + ChipLogProgress(chipTool, " ***** Test Step 404 : Write min value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedSigned8BitInteger_404(); break; case 405: ChipLogProgress( - chipTool, " ***** Test Step 405 : Write just-above-range value to a range-restricted signed 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_405(); + chipTool, " ***** Test Step 405 : Write just-below-range value to a range-restricted signed 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_405(); break; case 406: - ChipLogProgress(chipTool, " ***** Test Step 406 : Write max value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedSigned8BitInteger_406(); + ChipLogProgress( + chipTool, " ***** Test Step 406 : Write just-above-range value to a range-restricted signed 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_406(); break; case 407: - ChipLogProgress( - chipTool, " ***** Test Step 407 : Verify range-restricted signed 8-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_407(); + ChipLogProgress(chipTool, " ***** Test Step 407 : Write max value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedSigned8BitInteger_407(); break; case 408: - ChipLogProgress(chipTool, " ***** Test Step 408 : Write min valid value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_408(); + ChipLogProgress( + chipTool, " ***** Test Step 408 : Verify range-restricted signed 8-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_408(); break; case 409: - ChipLogProgress( - chipTool, " ***** Test Step 409 : Verify range-restricted signed 8-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_409(); + ChipLogProgress(chipTool, " ***** Test Step 409 : Write min valid value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_409(); break; case 410: - ChipLogProgress(chipTool, " ***** Test Step 410 : Write max valid value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_410(); + ChipLogProgress( + chipTool, " ***** Test Step 410 : Verify range-restricted signed 8-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_410(); break; case 411: - ChipLogProgress( - chipTool, " ***** Test Step 411 : Verify range-restricted signed 8-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_411(); + ChipLogProgress(chipTool, " ***** Test Step 411 : Write max valid value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_411(); break; case 412: ChipLogProgress( - chipTool, " ***** Test Step 412 : Write middle valid value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_412(); + chipTool, " ***** Test Step 412 : Verify range-restricted signed 8-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_412(); break; case 413: ChipLogProgress( - chipTool, " ***** Test Step 413 : Verify range-restricted signed 8-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_413(); + chipTool, " ***** Test Step 413 : Write middle valid value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_413(); break; case 414: - ChipLogProgress(chipTool, " ***** Test Step 414 : Read range-restricted signed 16-bit integer\n"); - err = TestReadRangeRestrictedSigned16BitInteger_414(); + ChipLogProgress( + chipTool, " ***** Test Step 414 : Verify range-restricted signed 8-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_414(); break; case 415: - ChipLogProgress(chipTool, " ***** Test Step 415 : Write min value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedSigned16BitInteger_415(); + ChipLogProgress(chipTool, " ***** Test Step 415 : Read range-restricted signed 16-bit integer\n"); + err = TestReadRangeRestrictedSigned16BitInteger_415(); break; case 416: - ChipLogProgress( - chipTool, " ***** Test Step 416 : Write just-below-range value to a range-restricted signed 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_416(); + ChipLogProgress(chipTool, " ***** Test Step 416 : Write min value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedSigned16BitInteger_416(); break; case 417: ChipLogProgress( - chipTool, " ***** Test Step 417 : Write just-above-range value to a range-restricted signed 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_417(); + chipTool, " ***** Test Step 417 : Write just-below-range value to a range-restricted signed 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_417(); break; case 418: - ChipLogProgress(chipTool, " ***** Test Step 418 : Write max value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedSigned16BitInteger_418(); + ChipLogProgress( + chipTool, " ***** Test Step 418 : Write just-above-range value to a range-restricted signed 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_418(); break; case 419: - ChipLogProgress( - chipTool, " ***** Test Step 419 : Verify range-restricted signed 16-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_419(); + ChipLogProgress(chipTool, " ***** Test Step 419 : Write max value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedSigned16BitInteger_419(); break; case 420: - ChipLogProgress(chipTool, " ***** Test Step 420 : Write min valid value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_420(); + ChipLogProgress( + chipTool, " ***** Test Step 420 : Verify range-restricted signed 16-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_420(); break; case 421: - ChipLogProgress( - chipTool, " ***** Test Step 421 : Verify range-restricted signed 16-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_421(); + ChipLogProgress(chipTool, " ***** Test Step 421 : Write min valid value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_421(); break; case 422: - ChipLogProgress(chipTool, " ***** Test Step 422 : Write max valid value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_422(); + ChipLogProgress( + chipTool, " ***** Test Step 422 : Verify range-restricted signed 16-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_422(); break; case 423: - ChipLogProgress( - chipTool, " ***** Test Step 423 : Verify range-restricted signed 16-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_423(); + ChipLogProgress(chipTool, " ***** Test Step 423 : Write max valid value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_423(); break; case 424: ChipLogProgress( - chipTool, " ***** Test Step 424 : Write middle valid value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_424(); + chipTool, " ***** Test Step 424 : Verify range-restricted signed 16-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_424(); break; case 425: ChipLogProgress( - chipTool, " ***** Test Step 425 : Verify range-restricted signed 16-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_425(); + chipTool, " ***** Test Step 425 : Write middle valid value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_425(); break; case 426: - ChipLogProgress(chipTool, " ***** Test Step 426 : Read nullable range-restricted unsigned 8-bit integer\n"); - err = TestReadNullableRangeRestrictedUnsigned8BitInteger_426(); + ChipLogProgress( + chipTool, " ***** Test Step 426 : Verify range-restricted signed 16-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_426(); break; case 427: - ChipLogProgress( - chipTool, " ***** Test Step 427 : Write min value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_427(); + ChipLogProgress(chipTool, " ***** Test Step 427 : Read nullable range-restricted unsigned 8-bit integer\n"); + err = TestReadNullableRangeRestrictedUnsigned8BitInteger_427(); break; case 428: - ChipLogProgress(chipTool, - " ***** Test Step 428 : Write just-below-range value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_428(); + ChipLogProgress( + chipTool, " ***** Test Step 428 : Write min value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_428(); break; case 429: ChipLogProgress(chipTool, - " ***** Test Step 429 : Write just-above-range value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_429(); + " ***** Test Step 429 : Write just-below-range value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_429(); break; case 430: - ChipLogProgress( - chipTool, " ***** Test Step 430 : Write max value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_430(); + ChipLogProgress(chipTool, + " ***** Test Step 430 : Write just-above-range value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_430(); break; case 431: ChipLogProgress( - chipTool, " ***** Test Step 431 : Verify nullable range-restricted unsigned 8-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_431(); + chipTool, " ***** Test Step 431 : Write max value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_431(); break; case 432: ChipLogProgress( - chipTool, " ***** Test Step 432 : Write min valid value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_432(); + chipTool, " ***** Test Step 432 : Verify nullable range-restricted unsigned 8-bit integer value has not changed\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_432(); break; case 433: ChipLogProgress( - chipTool, " ***** Test Step 433 : Verify nullable range-restricted unsigned 8-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_433(); + chipTool, " ***** Test Step 433 : Write min valid value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_433(); break; case 434: ChipLogProgress( - chipTool, " ***** Test Step 434 : Write max valid value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_434(); + chipTool, " ***** Test Step 434 : Verify nullable range-restricted unsigned 8-bit integer value is at min valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_434(); break; case 435: ChipLogProgress( - chipTool, " ***** Test Step 435 : Verify nullable range-restricted unsigned 8-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_435(); + chipTool, " ***** Test Step 435 : Write max valid value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_435(); break; case 436: - ChipLogProgress(chipTool, - " ***** Test Step 436 : Write middle valid value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_436(); + ChipLogProgress( + chipTool, " ***** Test Step 436 : Verify nullable range-restricted unsigned 8-bit integer value is at max valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_436(); break; case 437: - ChipLogProgress( - chipTool, " ***** Test Step 437 : Verify nullable range-restricted unsigned 8-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_437(); + ChipLogProgress(chipTool, + " ***** Test Step 437 : Write middle valid value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_437(); break; case 438: ChipLogProgress( - chipTool, " ***** Test Step 438 : Write null value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_438(); + chipTool, " ***** Test Step 438 : Verify nullable range-restricted unsigned 8-bit integer value is at mid valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_438(); break; case 439: ChipLogProgress( - chipTool, " ***** Test Step 439 : Verify nullable range-restricted unsigned 8-bit integer value is null\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_439(); + chipTool, " ***** Test Step 439 : Write null value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_439(); break; case 440: - ChipLogProgress(chipTool, " ***** Test Step 440 : Read nullable range-restricted unsigned 16-bit integer\n"); - err = TestReadNullableRangeRestrictedUnsigned16BitInteger_440(); + ChipLogProgress( + chipTool, " ***** Test Step 440 : Verify nullable range-restricted unsigned 8-bit integer value is null\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_440(); break; case 441: - ChipLogProgress( - chipTool, " ***** Test Step 441 : Write min value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_441(); + ChipLogProgress(chipTool, " ***** Test Step 441 : Read nullable range-restricted unsigned 16-bit integer\n"); + err = TestReadNullableRangeRestrictedUnsigned16BitInteger_441(); break; case 442: - ChipLogProgress(chipTool, - " ***** Test Step 442 : Write just-below-range value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_442(); + ChipLogProgress( + chipTool, " ***** Test Step 442 : Write min value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_442(); break; case 443: ChipLogProgress(chipTool, - " ***** Test Step 443 : Write just-above-range value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_443(); + " ***** Test Step 443 : Write just-below-range value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_443(); break; case 444: - ChipLogProgress( - chipTool, " ***** Test Step 444 : Write max value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_444(); + ChipLogProgress(chipTool, + " ***** Test Step 444 : Write just-above-range value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_444(); break; case 445: - ChipLogProgress(chipTool, - " ***** Test Step 445 : Verify nullable range-restricted unsigned 16-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_445(); + ChipLogProgress( + chipTool, " ***** Test Step 445 : Write max value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_445(); break; case 446: - ChipLogProgress( - chipTool, " ***** Test Step 446 : Write min valid value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_446(); + ChipLogProgress(chipTool, + " ***** Test Step 446 : Verify nullable range-restricted unsigned 16-bit integer value has not changed\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_446(); break; case 447: - ChipLogProgress(chipTool, - " ***** Test Step 447 : Verify nullable range-restricted unsigned 16-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_447(); + ChipLogProgress( + chipTool, " ***** Test Step 447 : Write min valid value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_447(); break; case 448: - ChipLogProgress( - chipTool, " ***** Test Step 448 : Write max valid value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_448(); + ChipLogProgress(chipTool, + " ***** Test Step 448 : Verify nullable range-restricted unsigned 16-bit integer value is at min valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_448(); break; case 449: - ChipLogProgress(chipTool, - " ***** Test Step 449 : Verify nullable range-restricted unsigned 16-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_449(); + ChipLogProgress( + chipTool, " ***** Test Step 449 : Write max valid value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_449(); break; case 450: ChipLogProgress(chipTool, - " ***** Test Step 450 : Write middle valid value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_450(); + " ***** Test Step 450 : Verify nullable range-restricted unsigned 16-bit integer value is at max valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_450(); break; case 451: ChipLogProgress(chipTool, - " ***** Test Step 451 : Verify nullable range-restricted unsigned 16-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_451(); + " ***** Test Step 451 : Write middle valid value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_451(); break; case 452: - ChipLogProgress( - chipTool, " ***** Test Step 452 : Write null value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_452(); + ChipLogProgress(chipTool, + " ***** Test Step 452 : Verify nullable range-restricted unsigned 16-bit integer value is at mid valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_452(); break; case 453: ChipLogProgress( - chipTool, " ***** Test Step 453 : Verify nullable range-restricted unsigned 16-bit integer value is null\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_453(); + chipTool, " ***** Test Step 453 : Write null value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_453(); break; case 454: - ChipLogProgress(chipTool, " ***** Test Step 454 : Read nullable range-restricted signed 8-bit integer\n"); - err = TestReadNullableRangeRestrictedSigned8BitInteger_454(); + ChipLogProgress( + chipTool, " ***** Test Step 454 : Verify nullable range-restricted unsigned 16-bit integer value is null\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_454(); break; case 455: - ChipLogProgress( - chipTool, " ***** Test Step 455 : Write min value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_455(); + ChipLogProgress(chipTool, " ***** Test Step 455 : Read nullable range-restricted signed 8-bit integer\n"); + err = TestReadNullableRangeRestrictedSigned8BitInteger_455(); break; case 456: - ChipLogProgress(chipTool, - " ***** Test Step 456 : Write just-below-range value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_456(); + ChipLogProgress( + chipTool, " ***** Test Step 456 : Write min value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_456(); break; case 457: ChipLogProgress(chipTool, - " ***** Test Step 457 : Write just-above-range value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_457(); + " ***** Test Step 457 : Write just-below-range value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_457(); break; case 458: - ChipLogProgress( - chipTool, " ***** Test Step 458 : Write max value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_458(); + ChipLogProgress(chipTool, + " ***** Test Step 458 : Write just-above-range value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_458(); break; case 459: ChipLogProgress( - chipTool, " ***** Test Step 459 : Verify nullable range-restricted signed 8-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_459(); + chipTool, " ***** Test Step 459 : Write max value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_459(); break; case 460: ChipLogProgress( - chipTool, " ***** Test Step 460 : Write min valid value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_460(); + chipTool, " ***** Test Step 460 : Verify nullable range-restricted signed 8-bit integer value has not changed\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_460(); break; case 461: ChipLogProgress( - chipTool, " ***** Test Step 461 : Verify nullable range-restricted signed 8-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_461(); + chipTool, " ***** Test Step 461 : Write min valid value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_461(); break; case 462: ChipLogProgress( - chipTool, " ***** Test Step 462 : Write max valid value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_462(); + chipTool, " ***** Test Step 462 : Verify nullable range-restricted signed 8-bit integer value is at min valid\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_462(); break; case 463: ChipLogProgress( - chipTool, " ***** Test Step 463 : Verify nullable range-restricted signed 8-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_463(); + chipTool, " ***** Test Step 463 : Write max valid value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_463(); break; case 464: ChipLogProgress( - chipTool, " ***** Test Step 464 : Write middle valid value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_464(); + chipTool, " ***** Test Step 464 : Verify nullable range-restricted signed 8-bit integer value is at max valid\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_464(); break; case 465: ChipLogProgress( - chipTool, " ***** Test Step 465 : Verify nullable range-restricted signed 8-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_465(); + chipTool, " ***** Test Step 465 : Write middle valid value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_465(); break; case 466: ChipLogProgress( - chipTool, " ***** Test Step 466 : Write null value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_466(); + chipTool, " ***** Test Step 466 : Verify nullable range-restricted signed 8-bit integer value is at mid valid\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_466(); break; case 467: ChipLogProgress( - chipTool, " ***** Test Step 467 : Verify nullable range-restricted signed 8-bit integer value is at null\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_467(); + chipTool, " ***** Test Step 467 : Write null value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_467(); break; case 468: - ChipLogProgress(chipTool, " ***** Test Step 468 : Read nullable range-restricted signed 16-bit integer\n"); - err = TestReadNullableRangeRestrictedSigned16BitInteger_468(); + ChipLogProgress( + chipTool, " ***** Test Step 468 : Verify nullable range-restricted signed 8-bit integer value is at null\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_468(); break; case 469: - ChipLogProgress( - chipTool, " ***** Test Step 469 : Write min value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_469(); + ChipLogProgress(chipTool, " ***** Test Step 469 : Read nullable range-restricted signed 16-bit integer\n"); + err = TestReadNullableRangeRestrictedSigned16BitInteger_469(); break; case 470: - ChipLogProgress(chipTool, - " ***** Test Step 470 : Write just-below-range value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_470(); + ChipLogProgress( + chipTool, " ***** Test Step 470 : Write min value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_470(); break; case 471: ChipLogProgress(chipTool, - " ***** Test Step 471 : Write just-above-range value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_471(); + " ***** Test Step 471 : Write just-below-range value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_471(); break; case 472: - ChipLogProgress( - chipTool, " ***** Test Step 472 : Write max value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_472(); + ChipLogProgress(chipTool, + " ***** Test Step 472 : Write just-above-range value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_472(); break; case 473: ChipLogProgress( - chipTool, " ***** Test Step 473 : Verify nullable range-restricted signed 16-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_473(); + chipTool, " ***** Test Step 473 : Write max value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_473(); break; case 474: ChipLogProgress( - chipTool, " ***** Test Step 474 : Write min valid value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_474(); + chipTool, " ***** Test Step 474 : Verify nullable range-restricted signed 16-bit integer value has not changed\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_474(); break; case 475: ChipLogProgress( - chipTool, " ***** Test Step 475 : Verify nullable range-restricted signed 16-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_475(); + chipTool, " ***** Test Step 475 : Write min valid value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_475(); break; case 476: ChipLogProgress( - chipTool, " ***** Test Step 476 : Write max valid value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_476(); + chipTool, " ***** Test Step 476 : Verify nullable range-restricted signed 16-bit integer value is at min valid\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_476(); break; case 477: ChipLogProgress( - chipTool, " ***** Test Step 477 : Verify nullable range-restricted signed 16-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_477(); + chipTool, " ***** Test Step 477 : Write max valid value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_477(); break; case 478: ChipLogProgress( - chipTool, " ***** Test Step 478 : Write middle valid value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_478(); + chipTool, " ***** Test Step 478 : Verify nullable range-restricted signed 16-bit integer value is at max valid\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_478(); break; case 479: ChipLogProgress( - chipTool, " ***** Test Step 479 : Verify nullable range-restricted signed 16-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_479(); + chipTool, " ***** Test Step 479 : Write middle valid value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_479(); break; case 480: ChipLogProgress( - chipTool, " ***** Test Step 480 : Write null value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_480(); + chipTool, " ***** Test Step 480 : Verify nullable range-restricted signed 16-bit integer value is at mid valid\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_480(); break; case 481: ChipLogProgress( - chipTool, " ***** Test Step 481 : Verify nullable range-restricted signed 16-bit integer value is null\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_481(); + chipTool, " ***** Test Step 481 : Write null value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_481(); break; case 482: - ChipLogProgress(chipTool, " ***** Test Step 482 : Write attribute that returns general status on write\n"); - err = TestWriteAttributeThatReturnsGeneralStatusOnWrite_482(); + ChipLogProgress( + chipTool, " ***** Test Step 482 : Verify nullable range-restricted signed 16-bit integer value is null\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_482(); break; case 483: - ChipLogProgress(chipTool, " ***** Test Step 483 : Write attribute that returns cluster-specific status on write\n"); - err = TestWriteAttributeThatReturnsClusterSpecificStatusOnWrite_483(); + ChipLogProgress(chipTool, " ***** Test Step 483 : Write attribute that returns general status on write\n"); + err = TestWriteAttributeThatReturnsGeneralStatusOnWrite_483(); break; case 484: - ChipLogProgress(chipTool, " ***** Test Step 484 : Read attribute that returns general status on read\n"); - err = TestReadAttributeThatReturnsGeneralStatusOnRead_484(); + ChipLogProgress(chipTool, " ***** Test Step 484 : Write attribute that returns cluster-specific status on write\n"); + err = TestWriteAttributeThatReturnsClusterSpecificStatusOnWrite_484(); break; case 485: - ChipLogProgress(chipTool, " ***** Test Step 485 : read attribute that returns cluster-specific status on read\n"); - err = TestReadAttributeThatReturnsClusterSpecificStatusOnRead_485(); + ChipLogProgress(chipTool, " ***** Test Step 485 : Read attribute that returns general status on read\n"); + err = TestReadAttributeThatReturnsGeneralStatusOnRead_485(); break; case 486: - ChipLogProgress(chipTool, " ***** Test Step 486 : read AcceptedCommandList attribute\n"); - err = TestReadAcceptedCommandListAttribute_486(); + ChipLogProgress(chipTool, " ***** Test Step 486 : read attribute that returns cluster-specific status on read\n"); + err = TestReadAttributeThatReturnsClusterSpecificStatusOnRead_486(); break; case 487: - ChipLogProgress(chipTool, " ***** Test Step 487 : read GeneratedCommandList attribute\n"); - err = TestReadGeneratedCommandListAttribute_487(); + ChipLogProgress(chipTool, " ***** Test Step 487 : read AcceptedCommandList attribute\n"); + err = TestReadAcceptedCommandListAttribute_487(); break; case 488: - ChipLogProgress(chipTool, " ***** Test Step 488 : Write struct-typed attribute\n"); - err = TestWriteStructTypedAttribute_488(); + ChipLogProgress(chipTool, " ***** Test Step 488 : read GeneratedCommandList attribute\n"); + err = TestReadGeneratedCommandListAttribute_488(); break; case 489: - ChipLogProgress(chipTool, " ***** Test Step 489 : Read struct-typed attribute\n"); - err = TestReadStructTypedAttribute_489(); + ChipLogProgress(chipTool, " ***** Test Step 489 : Write struct-typed attribute\n"); + err = TestWriteStructTypedAttribute_489(); + break; + case 490: + ChipLogProgress(chipTool, " ***** Test Step 490 : Read struct-typed attribute\n"); + err = TestReadStructTypedAttribute_490(); break; } @@ -66059,10 +66063,10 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 188: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 189: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 190: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66080,10 +66084,10 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 195: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 196: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 197: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66098,10 +66102,10 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 201: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 202: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 203: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66116,10 +66120,10 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 207: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 208: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 209: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66140,10 +66144,10 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 215: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 216: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 217: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66182,10 +66186,10 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 229: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 230: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 231: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66221,10 +66225,10 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 242: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 243: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 244: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66260,10 +66264,10 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 255: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 256: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 257: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66293,10 +66297,10 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 266: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 267: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 268: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66326,10 +66330,10 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 277: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 278: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 279: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66359,10 +66363,10 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 288: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 289: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 290: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66392,10 +66396,10 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 299: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 300: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 301: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66491,10 +66495,10 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 332: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 333: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 334: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66515,10 +66519,10 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 340: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 341: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 342: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66539,10 +66543,10 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 348: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 349: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 350: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66605,16 +66609,16 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 370: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_UNSUPPORTED_ENDPOINT)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 371: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_UNSUPPORTED_ENDPOINT)); break; case 372: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_INVALID_VALUE)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER)); break; case 373: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_INVALID_VALUE)); break; case 374: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66632,7 +66636,7 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 379: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 380: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); @@ -66644,7 +66648,7 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 383: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 384: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66668,7 +66672,7 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 391: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 392: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); @@ -66680,7 +66684,7 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 395: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 396: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66704,7 +66708,7 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 403: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 404: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); @@ -66716,7 +66720,7 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 407: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 408: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66740,7 +66744,7 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 415: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 416: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); @@ -66752,7 +66756,7 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 419: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 420: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66776,7 +66780,7 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 427: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 428: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); @@ -66788,7 +66792,7 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 431: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 432: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66818,7 +66822,7 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 441: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 442: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); @@ -66830,7 +66834,7 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 445: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 446: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66860,7 +66864,7 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 455: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 456: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); @@ -66872,7 +66876,7 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 459: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 460: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66902,7 +66906,7 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 469: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 470: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); @@ -66914,7 +66918,7 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 473: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); break; case 474: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66941,19 +66945,19 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 482: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_INVALID_DATA_TYPE)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; case 483: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_FAILURE)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_INVALID_DATA_TYPE)); break; case 484: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_INVALID_DATA_TYPE)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_FAILURE)); break; case 485: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_FAILURE)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_INVALID_DATA_TYPE)); break; case 486: - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_FAILURE)); break; case 487: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); @@ -66964,6 +66968,9 @@ class TestCluster : public TestCommandBridge { case 489: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); break; + case 490: + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); + break; } // Go on to the next test. @@ -66977,7 +66984,7 @@ class TestCluster : public TestCommandBridge { private: std::atomic_uint16_t mTestIndex; - const uint16_t mTestCount = 490; + const uint16_t mTestCount = 491; chip::Optional mNodeId; chip::Optional mCluster; @@ -70682,7 +70689,7 @@ class TestCluster : public TestCommandBridge { __auto_type * params = [[MTRTestClusterClusterTestEnumsRequestParams alloc] init]; params.arg1 = [NSNumber numberWithUnsignedShort:20003U]; - params.arg2 = [NSNumber numberWithUnsignedChar:101U]; + params.arg2 = [NSNumber numberWithUnsignedChar:1U]; [cluster testEnumsRequestWithParams:params completionHandler:^(MTRTestClusterClusterTestEnumsResponseParams * _Nullable values, NSError * _Nullable err) { @@ -70697,7 +70704,41 @@ class TestCluster : public TestCommandBridge { { id actualValue = values.arg2; - VerifyOrReturn(CheckValue("arg2", actualValue, 101U)); + VerifyOrReturn(CheckValue("arg2", actualValue, 1U)); + } + + NextTest(); + }]; + + return CHIP_NO_ERROR; + } + + CHIP_ERROR TestSendACommandWithAVendorIdAndInvalidEnum_155() + { + MTRBaseDevice * device = GetDevice("alpha"); + MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device + endpoint:1 + queue:mCallbackQueue]; + VerifyOrReturnError(cluster != nil, CHIP_ERROR_INCORRECT_STATE); + + __auto_type * params = [[MTRTestClusterClusterTestEnumsRequestParams alloc] init]; + params.arg1 = [NSNumber numberWithUnsignedShort:20003U]; + params.arg2 = [NSNumber numberWithUnsignedChar:101U]; + [cluster + testEnumsRequestWithParams:params + completionHandler:^(MTRTestClusterClusterTestEnumsResponseParams * _Nullable values, NSError * _Nullable err) { + NSLog(@"Send a command with a vendor_id and invalid enum Error: %@", err); + + VerifyOrReturn(CheckValue("status", err ? err.code : 0, 0)); + + { + id actualValue = values.arg1; + VerifyOrReturn(CheckValue("arg1", actualValue, 20003U)); + } + + { + id actualValue = values.arg2; + VerifyOrReturn(CheckValue("arg2", actualValue, 4U)); } NextTest(); @@ -70706,7 +70747,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendTestCommandWithStructArgumentAndArg1bIsTrue_155() + CHIP_ERROR TestSendTestCommandWithStructArgumentAndArg1bIsTrue_156() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -70743,7 +70784,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendTestCommandWithStructArgumentAndArg1bIsFalse_156() + CHIP_ERROR TestSendTestCommandWithStructArgumentAndArg1bIsFalse_157() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -70780,7 +70821,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendTestCommandWithNestedStructArgumentAndArg1cbIsTrue_157() + CHIP_ERROR TestSendTestCommandWithNestedStructArgumentAndArg1cbIsTrue_158() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -70828,7 +70869,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendTestCommandWithNestedStructArgumentArg1cbIsFalse_158() + CHIP_ERROR TestSendTestCommandWithNestedStructArgumentArg1cbIsFalse_159() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -70876,7 +70917,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendTestCommandWithNestedStructListArgumentAndAllFieldsBOfArg1dAreTrue_159() + CHIP_ERROR TestSendTestCommandWithNestedStructListArgumentAndAllFieldsBOfArg1dAreTrue_160() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -70970,7 +71011,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfArg1dAreFalse_160() + CHIP_ERROR TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfArg1dAreFalse_161() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71064,7 +71105,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendTestCommandWithStructArgumentAndSeeWhatWeGetBack_161() + CHIP_ERROR TestSendTestCommandWithStructArgumentAndSeeWhatWeGetBack_162() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71111,7 +71152,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendTestCommandWithListOfInt8uAndNoneOfThemIsSetTo0_162() + CHIP_ERROR TestSendTestCommandWithListOfInt8uAndNoneOfThemIsSetTo0_163() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71152,7 +71193,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendTestCommandWithListOfInt8uAndOneOfThemIsSetTo0_163() + CHIP_ERROR TestSendTestCommandWithListOfInt8uAndOneOfThemIsSetTo0_164() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71193,7 +71234,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendTestCommandWithListOfInt8uAndGetItReversed_164() + CHIP_ERROR TestSendTestCommandWithListOfInt8uAndGetItReversed_165() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71242,7 +71283,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendTestCommandWithEmptyListOfInt8uAndGetAnEmptyListBack_165() + CHIP_ERROR TestSendTestCommandWithEmptyListOfInt8uAndGetAnEmptyListBack_166() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71274,7 +71315,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsTrue_166() + CHIP_ERROR TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsTrue_167() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71327,7 +71368,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsFalse_167() + CHIP_ERROR TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsFalse_168() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71380,7 +71421,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendTestCommandWithListOfNestedStructListArgumentAndAllFieldsBOfElementsOfArg1dAreTrue_168() + CHIP_ERROR TestSendTestCommandWithListOfNestedStructListArgumentAndAllFieldsBOfElementsOfArg1dAreTrue_169() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71480,7 +71521,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfElementsOfArg1dAreFalse_169() + CHIP_ERROR TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfElementsOfArg1dAreFalse_170() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71580,7 +71621,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeListWithListOfInt8uAndNoneOfThemIsSetTo0_170() + CHIP_ERROR TestWriteAttributeListWithListOfInt8uAndNoneOfThemIsSetTo0_171() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71609,7 +71650,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeListWithListOfInt8u_171() + CHIP_ERROR TestReadAttributeListWithListOfInt8u_172() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71637,7 +71678,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeListWithListOfOctetString_172() + CHIP_ERROR TestWriteAttributeListWithListOfOctetString_173() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71666,7 +71707,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeListWithListOfOctetString_173() + CHIP_ERROR TestReadAttributeListWithListOfOctetString_174() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71694,7 +71735,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeListWithListOfListStructOctetString_174() + CHIP_ERROR TestWriteAttributeListWithListOfListStructOctetString_175() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71735,7 +71776,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeListWithListOfListStructOctetString_175() + CHIP_ERROR TestReadAttributeListWithListOfListStructOctetString_176() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71771,7 +71812,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendTestCommandWithOptionalArgSet_176() + CHIP_ERROR TestSendTestCommandWithOptionalArgSet_177() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71815,7 +71856,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendTestCommandWithoutItsOptionalArg_177() + CHIP_ERROR TestSendTestCommandWithoutItsOptionalArg_178() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71842,7 +71883,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadListOfStructsContainingNullablesAndOptionals_178() + CHIP_ERROR TestReadListOfStructsContainingNullablesAndOptionals_179() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71875,7 +71916,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteListOfStructsContainingNullablesAndOptionals_179() + CHIP_ERROR TestWriteListOfStructsContainingNullablesAndOptionals_180() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71913,7 +71954,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadListOfStructsContainingNullablesAndOptionalsAfterWriting_180() + CHIP_ERROR TestReadListOfStructsContainingNullablesAndOptionalsAfterWriting_181() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71953,7 +71994,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableBooleanNull_181() + CHIP_ERROR TestWriteAttributeNullableBooleanNull_182() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -71976,7 +72017,7 @@ class TestCluster : public TestCommandBridge { } NSNumber * _Nullable booValueNull; - CHIP_ERROR TestReadAttributeNullableBooleanNull_182() + CHIP_ERROR TestReadAttributeNullableBooleanNull_183() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72003,7 +72044,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableBooleanTrue_183() + CHIP_ERROR TestWriteAttributeNullableBooleanTrue_184() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72025,7 +72066,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableBooleanTrue_184() + CHIP_ERROR TestReadAttributeNullableBooleanTrue_185() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72050,7 +72091,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableBooleanNotNull_185() + CHIP_ERROR TestReadAttributeNullableBooleanNotNull_186() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72073,7 +72114,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableBitmap8MaxValue_186() + CHIP_ERROR TestWriteAttributeNullableBitmap8MaxValue_187() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72095,7 +72136,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableBitmap8MaxValue_187() + CHIP_ERROR TestReadAttributeNullableBitmap8MaxValue_188() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72120,7 +72161,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableBitmap8InvalidValue_188() + CHIP_ERROR TestWriteAttributeNullableBitmap8InvalidValue_189() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72143,7 +72184,7 @@ class TestCluster : public TestCommandBridge { } NSNumber * _Nullable nullableValue254; - CHIP_ERROR TestReadAttributeNullableBitmap8UnchangedValue_189() + CHIP_ERROR TestReadAttributeNullableBitmap8UnchangedValue_190() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72171,7 +72212,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableBitmap8NullValue_190() + CHIP_ERROR TestWriteAttributeNullableBitmap8NullValue_191() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72193,7 +72234,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableBitmap8NullValue_191() + CHIP_ERROR TestReadAttributeNullableBitmap8NullValue_192() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72217,7 +72258,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableBitmap8Not254Value_192() + CHIP_ERROR TestReadAttributeNullableBitmap8Not254Value_193() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72240,7 +72281,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableBitmap16MaxValue_193() + CHIP_ERROR TestWriteAttributeNullableBitmap16MaxValue_194() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72262,7 +72303,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableBitmap16MaxValue_194() + CHIP_ERROR TestReadAttributeNullableBitmap16MaxValue_195() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72287,7 +72328,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableBitmap16InvalidValue_195() + CHIP_ERROR TestWriteAttributeNullableBitmap16InvalidValue_196() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72309,7 +72350,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableBitmap16UnchangedValue_196() + CHIP_ERROR TestReadAttributeNullableBitmap16UnchangedValue_197() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72334,7 +72375,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableBitmap16NullValue_197() + CHIP_ERROR TestWriteAttributeNullableBitmap16NullValue_198() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72356,7 +72397,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableBitmap16NullValue_198() + CHIP_ERROR TestReadAttributeNullableBitmap16NullValue_199() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72380,7 +72421,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableBitmap32MaxValue_199() + CHIP_ERROR TestWriteAttributeNullableBitmap32MaxValue_200() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72402,7 +72443,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableBitmap32MaxValue_200() + CHIP_ERROR TestReadAttributeNullableBitmap32MaxValue_201() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72427,7 +72468,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableBitmap32InvalidValue_201() + CHIP_ERROR TestWriteAttributeNullableBitmap32InvalidValue_202() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72449,7 +72490,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableBitmap32UnchangedValue_202() + CHIP_ERROR TestReadAttributeNullableBitmap32UnchangedValue_203() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72474,7 +72515,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableBitmap32NullValue_203() + CHIP_ERROR TestWriteAttributeNullableBitmap32NullValue_204() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72496,7 +72537,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableBitmap32NullValue_204() + CHIP_ERROR TestReadAttributeNullableBitmap32NullValue_205() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72520,7 +72561,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableBitmap64MaxValue_205() + CHIP_ERROR TestWriteAttributeNullableBitmap64MaxValue_206() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72542,7 +72583,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableBitmap64MaxValue_206() + CHIP_ERROR TestReadAttributeNullableBitmap64MaxValue_207() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72567,7 +72608,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableBitmap64InvalidValue_207() + CHIP_ERROR TestWriteAttributeNullableBitmap64InvalidValue_208() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72589,7 +72630,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableBitmap64UnchangedValue_208() + CHIP_ERROR TestReadAttributeNullableBitmap64UnchangedValue_209() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72614,7 +72655,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableBitmap64NullValue_209() + CHIP_ERROR TestWriteAttributeNullableBitmap64NullValue_210() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72636,7 +72677,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableBitmap64NullValue_210() + CHIP_ERROR TestReadAttributeNullableBitmap64NullValue_211() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72660,7 +72701,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt8uMinValue_211() + CHIP_ERROR TestWriteAttributeNullableInt8uMinValue_212() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72682,7 +72723,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt8uMinValue_212() + CHIP_ERROR TestReadAttributeNullableInt8uMinValue_213() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72707,7 +72748,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt8uMaxValue_213() + CHIP_ERROR TestWriteAttributeNullableInt8uMaxValue_214() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72729,7 +72770,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt8uMaxValue_214() + CHIP_ERROR TestReadAttributeNullableInt8uMaxValue_215() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72754,7 +72795,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt8uInvalidValue_215() + CHIP_ERROR TestWriteAttributeNullableInt8uInvalidValue_216() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72775,7 +72816,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt8uUnchangedValue_216() + CHIP_ERROR TestReadAttributeNullableInt8uUnchangedValue_217() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72800,7 +72841,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt8uUnchangedValueWithConstraint_217() + CHIP_ERROR TestReadAttributeNullableInt8uUnchangedValueWithConstraint_218() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72823,7 +72864,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt8uNullValue_218() + CHIP_ERROR TestWriteAttributeNullableInt8uNullValue_219() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72845,7 +72886,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt8uNullValue_219() + CHIP_ERROR TestReadAttributeNullableInt8uNullValue_220() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72869,7 +72910,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt8uNullValueRange_220() + CHIP_ERROR TestReadAttributeNullableInt8uNullValueRange_221() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72894,7 +72935,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt8uNullValueNot_221() + CHIP_ERROR TestReadAttributeNullableInt8uNullValueNot_222() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72917,7 +72958,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt8uValue_222() + CHIP_ERROR TestWriteAttributeNullableInt8uValue_223() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72939,7 +72980,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt8uValueInRange_223() + CHIP_ERROR TestReadAttributeNullableInt8uValueInRange_224() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72964,7 +73005,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt8uNotValueOk_224() + CHIP_ERROR TestReadAttributeNullableInt8uNotValueOk_225() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -72987,7 +73028,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt16uMinValue_225() + CHIP_ERROR TestWriteAttributeNullableInt16uMinValue_226() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73009,7 +73050,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt16uMinValue_226() + CHIP_ERROR TestReadAttributeNullableInt16uMinValue_227() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73034,7 +73075,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt16uMaxValue_227() + CHIP_ERROR TestWriteAttributeNullableInt16uMaxValue_228() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73056,7 +73097,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt16uMaxValue_228() + CHIP_ERROR TestReadAttributeNullableInt16uMaxValue_229() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73081,7 +73122,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt16uInvalidValue_229() + CHIP_ERROR TestWriteAttributeNullableInt16uInvalidValue_230() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73103,7 +73144,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt16uUnchangedValue_230() + CHIP_ERROR TestReadAttributeNullableInt16uUnchangedValue_231() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73128,7 +73169,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt16uNullValue_231() + CHIP_ERROR TestWriteAttributeNullableInt16uNullValue_232() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73150,7 +73191,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt16uNullValue_232() + CHIP_ERROR TestReadAttributeNullableInt16uNullValue_233() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73174,7 +73215,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt16uNullValueRange_233() + CHIP_ERROR TestReadAttributeNullableInt16uNullValueRange_234() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73199,7 +73240,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt16uNullValueNot_234() + CHIP_ERROR TestReadAttributeNullableInt16uNullValueNot_235() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73222,7 +73263,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt16uValue_235() + CHIP_ERROR TestWriteAttributeNullableInt16uValue_236() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73244,7 +73285,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt16uValueInRange_236() + CHIP_ERROR TestReadAttributeNullableInt16uValueInRange_237() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73269,7 +73310,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt16uNotValueOk_237() + CHIP_ERROR TestReadAttributeNullableInt16uNotValueOk_238() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73292,7 +73333,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt32uMinValue_238() + CHIP_ERROR TestWriteAttributeNullableInt32uMinValue_239() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73314,7 +73355,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt32uMinValue_239() + CHIP_ERROR TestReadAttributeNullableInt32uMinValue_240() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73339,7 +73380,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt32uMaxValue_240() + CHIP_ERROR TestWriteAttributeNullableInt32uMaxValue_241() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73361,7 +73402,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt32uMaxValue_241() + CHIP_ERROR TestReadAttributeNullableInt32uMaxValue_242() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73386,7 +73427,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt32uInvalidValue_242() + CHIP_ERROR TestWriteAttributeNullableInt32uInvalidValue_243() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73408,7 +73449,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt32uUnchangedValue_243() + CHIP_ERROR TestReadAttributeNullableInt32uUnchangedValue_244() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73433,7 +73474,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt32uNullValue_244() + CHIP_ERROR TestWriteAttributeNullableInt32uNullValue_245() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73455,7 +73496,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt32uNullValue_245() + CHIP_ERROR TestReadAttributeNullableInt32uNullValue_246() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73479,7 +73520,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt32uNullValueRange_246() + CHIP_ERROR TestReadAttributeNullableInt32uNullValueRange_247() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73504,7 +73545,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt32uNullValueNot_247() + CHIP_ERROR TestReadAttributeNullableInt32uNullValueNot_248() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73527,7 +73568,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt32uValue_248() + CHIP_ERROR TestWriteAttributeNullableInt32uValue_249() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73549,7 +73590,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt32uValueInRange_249() + CHIP_ERROR TestReadAttributeNullableInt32uValueInRange_250() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73574,7 +73615,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt32uNotValueOk_250() + CHIP_ERROR TestReadAttributeNullableInt32uNotValueOk_251() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73597,7 +73638,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt64uMinValue_251() + CHIP_ERROR TestWriteAttributeNullableInt64uMinValue_252() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73619,7 +73660,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt64uMinValue_252() + CHIP_ERROR TestReadAttributeNullableInt64uMinValue_253() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73644,7 +73685,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt64uMaxValue_253() + CHIP_ERROR TestWriteAttributeNullableInt64uMaxValue_254() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73666,7 +73707,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt64uMaxValue_254() + CHIP_ERROR TestReadAttributeNullableInt64uMaxValue_255() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73691,7 +73732,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt64uInvalidValue_255() + CHIP_ERROR TestWriteAttributeNullableInt64uInvalidValue_256() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73713,7 +73754,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt64uUnchangedValue_256() + CHIP_ERROR TestReadAttributeNullableInt64uUnchangedValue_257() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73738,7 +73779,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt64uNullValue_257() + CHIP_ERROR TestWriteAttributeNullableInt64uNullValue_258() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73760,7 +73801,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt64uNullValue_258() + CHIP_ERROR TestReadAttributeNullableInt64uNullValue_259() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73784,7 +73825,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt64uNullValueRange_259() + CHIP_ERROR TestReadAttributeNullableInt64uNullValueRange_260() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73810,7 +73851,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt64uNullValueNot_260() + CHIP_ERROR TestReadAttributeNullableInt64uNullValueNot_261() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73833,7 +73874,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt64uValue_261() + CHIP_ERROR TestWriteAttributeNullableInt64uValue_262() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73855,7 +73896,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt64uValueInRange_262() + CHIP_ERROR TestReadAttributeNullableInt64uValueInRange_263() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73881,7 +73922,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt64uNotValueOk_263() + CHIP_ERROR TestReadAttributeNullableInt64uNotValueOk_264() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73904,7 +73945,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt8sMinValue_264() + CHIP_ERROR TestWriteAttributeNullableInt8sMinValue_265() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73926,7 +73967,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt8sMinValue_265() + CHIP_ERROR TestReadAttributeNullableInt8sMinValue_266() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73951,7 +73992,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt8sInvalidValue_266() + CHIP_ERROR TestWriteAttributeNullableInt8sInvalidValue_267() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73972,7 +74013,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt8sUnchangedValue_267() + CHIP_ERROR TestReadAttributeNullableInt8sUnchangedValue_268() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -73997,7 +74038,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt8sNullValue_268() + CHIP_ERROR TestWriteAttributeNullableInt8sNullValue_269() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74019,7 +74060,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt8sNullValue_269() + CHIP_ERROR TestReadAttributeNullableInt8sNullValue_270() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74043,7 +74084,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt8sNullValueRange_270() + CHIP_ERROR TestReadAttributeNullableInt8sNullValueRange_271() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74068,7 +74109,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt8sNullValueNot_271() + CHIP_ERROR TestReadAttributeNullableInt8sNullValueNot_272() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74091,7 +74132,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt8sValue_272() + CHIP_ERROR TestWriteAttributeNullableInt8sValue_273() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74113,7 +74154,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt8sValueInRange_273() + CHIP_ERROR TestReadAttributeNullableInt8sValueInRange_274() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74138,7 +74179,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt8sNotValueOk_274() + CHIP_ERROR TestReadAttributeNullableInt8sNotValueOk_275() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74161,7 +74202,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt16sMinValue_275() + CHIP_ERROR TestWriteAttributeNullableInt16sMinValue_276() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74183,7 +74224,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt16sMinValue_276() + CHIP_ERROR TestReadAttributeNullableInt16sMinValue_277() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74208,7 +74249,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt16sInvalidValue_277() + CHIP_ERROR TestWriteAttributeNullableInt16sInvalidValue_278() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74230,7 +74271,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt16sUnchangedValue_278() + CHIP_ERROR TestReadAttributeNullableInt16sUnchangedValue_279() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74255,7 +74296,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt16sNullValue_279() + CHIP_ERROR TestWriteAttributeNullableInt16sNullValue_280() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74277,7 +74318,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt16sNullValue_280() + CHIP_ERROR TestReadAttributeNullableInt16sNullValue_281() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74301,7 +74342,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt16sNullValueRange_281() + CHIP_ERROR TestReadAttributeNullableInt16sNullValueRange_282() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74326,7 +74367,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt16sNullValueNot_282() + CHIP_ERROR TestReadAttributeNullableInt16sNullValueNot_283() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74349,7 +74390,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt16sValue_283() + CHIP_ERROR TestWriteAttributeNullableInt16sValue_284() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74371,7 +74412,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt16sValueInRange_284() + CHIP_ERROR TestReadAttributeNullableInt16sValueInRange_285() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74396,7 +74437,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt16sNotValueOk_285() + CHIP_ERROR TestReadAttributeNullableInt16sNotValueOk_286() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74419,7 +74460,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt32sMinValue_286() + CHIP_ERROR TestWriteAttributeNullableInt32sMinValue_287() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74441,7 +74482,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt32sMinValue_287() + CHIP_ERROR TestReadAttributeNullableInt32sMinValue_288() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74466,7 +74507,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt32sInvalidValue_288() + CHIP_ERROR TestWriteAttributeNullableInt32sInvalidValue_289() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74488,7 +74529,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt32sUnchangedValue_289() + CHIP_ERROR TestReadAttributeNullableInt32sUnchangedValue_290() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74513,7 +74554,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt32sNullValue_290() + CHIP_ERROR TestWriteAttributeNullableInt32sNullValue_291() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74535,7 +74576,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt32sNullValue_291() + CHIP_ERROR TestReadAttributeNullableInt32sNullValue_292() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74559,7 +74600,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt32sNullValueRange_292() + CHIP_ERROR TestReadAttributeNullableInt32sNullValueRange_293() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74584,7 +74625,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt32sNullValueNot_293() + CHIP_ERROR TestReadAttributeNullableInt32sNullValueNot_294() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74607,7 +74648,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt32sValue_294() + CHIP_ERROR TestWriteAttributeNullableInt32sValue_295() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74629,7 +74670,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt32sValueInRange_295() + CHIP_ERROR TestReadAttributeNullableInt32sValueInRange_296() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74654,7 +74695,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt32sNotValueOk_296() + CHIP_ERROR TestReadAttributeNullableInt32sNotValueOk_297() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74677,7 +74718,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt64sMinValue_297() + CHIP_ERROR TestWriteAttributeNullableInt64sMinValue_298() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74699,7 +74740,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt64sMinValue_298() + CHIP_ERROR TestReadAttributeNullableInt64sMinValue_299() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74724,7 +74765,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt64sInvalidValue_299() + CHIP_ERROR TestWriteAttributeNullableInt64sInvalidValue_300() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74746,7 +74787,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt64sUnchangedValue_300() + CHIP_ERROR TestReadAttributeNullableInt64sUnchangedValue_301() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74771,7 +74812,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt64sNullValue_301() + CHIP_ERROR TestWriteAttributeNullableInt64sNullValue_302() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74793,7 +74834,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt64sNullValue_302() + CHIP_ERROR TestReadAttributeNullableInt64sNullValue_303() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74817,7 +74858,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt64sNullValueRange_303() + CHIP_ERROR TestReadAttributeNullableInt64sNullValueRange_304() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74842,7 +74883,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt64sNullValueNot_304() + CHIP_ERROR TestReadAttributeNullableInt64sNullValueNot_305() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74865,7 +74906,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableInt64sValue_305() + CHIP_ERROR TestWriteAttributeNullableInt64sValue_306() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74887,7 +74928,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt64sValueInRange_306() + CHIP_ERROR TestReadAttributeNullableInt64sValueInRange_307() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74912,7 +74953,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableInt64sNotValueOk_307() + CHIP_ERROR TestReadAttributeNullableInt64sNotValueOk_308() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74935,7 +74976,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableSingleMediumValue_308() + CHIP_ERROR TestWriteAttributeNullableSingleMediumValue_309() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74957,7 +74998,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableSingleMediumValue_309() + CHIP_ERROR TestReadAttributeNullableSingleMediumValue_310() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -74982,7 +75023,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableSingleLargestValue_310() + CHIP_ERROR TestWriteAttributeNullableSingleLargestValue_311() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75004,7 +75045,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableSingleLargestValue_311() + CHIP_ERROR TestReadAttributeNullableSingleLargestValue_312() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75029,7 +75070,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableSingleSmallestValue_312() + CHIP_ERROR TestWriteAttributeNullableSingleSmallestValue_313() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75051,7 +75092,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableSingleSmallestValue_313() + CHIP_ERROR TestReadAttributeNullableSingleSmallestValue_314() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75076,7 +75117,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableSingleNullValue_314() + CHIP_ERROR TestWriteAttributeNullableSingleNullValue_315() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75098,7 +75139,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableSingleNullValue_315() + CHIP_ERROR TestReadAttributeNullableSingleNullValue_316() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75122,7 +75163,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableSingle0Value_316() + CHIP_ERROR TestWriteAttributeNullableSingle0Value_317() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75144,7 +75185,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableSingle0Value_317() + CHIP_ERROR TestReadAttributeNullableSingle0Value_318() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75169,7 +75210,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableDoubleMediumValue_318() + CHIP_ERROR TestWriteAttributeNullableDoubleMediumValue_319() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75191,7 +75232,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableDoubleMediumValue_319() + CHIP_ERROR TestReadAttributeNullableDoubleMediumValue_320() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75216,7 +75257,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableDoubleLargestValue_320() + CHIP_ERROR TestWriteAttributeNullableDoubleLargestValue_321() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75238,7 +75279,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableDoubleLargestValue_321() + CHIP_ERROR TestReadAttributeNullableDoubleLargestValue_322() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75263,7 +75304,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableDoubleSmallestValue_322() + CHIP_ERROR TestWriteAttributeNullableDoubleSmallestValue_323() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75285,7 +75326,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableDoubleSmallestValue_323() + CHIP_ERROR TestReadAttributeNullableDoubleSmallestValue_324() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75310,7 +75351,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableDoubleNullValue_324() + CHIP_ERROR TestWriteAttributeNullableDoubleNullValue_325() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75332,7 +75373,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableDoubleNullValue_325() + CHIP_ERROR TestReadAttributeNullableDoubleNullValue_326() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75356,7 +75397,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableDouble0Value_326() + CHIP_ERROR TestWriteAttributeNullableDouble0Value_327() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75378,7 +75419,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableDouble0Value_327() + CHIP_ERROR TestReadAttributeNullableDouble0Value_328() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75403,7 +75444,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableEnum8MinValue_328() + CHIP_ERROR TestWriteAttributeNullableEnum8MinValue_329() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75425,7 +75466,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableEnum8MinValue_329() + CHIP_ERROR TestReadAttributeNullableEnum8MinValue_330() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75450,7 +75491,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableEnum8MaxValue_330() + CHIP_ERROR TestWriteAttributeNullableEnum8MaxValue_331() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75472,7 +75513,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableEnum8MaxValue_331() + CHIP_ERROR TestReadAttributeNullableEnum8MaxValue_332() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75497,7 +75538,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableEnum8InvalidValue_332() + CHIP_ERROR TestWriteAttributeNullableEnum8InvalidValue_333() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75518,7 +75559,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableEnum8UnchangedValue_333() + CHIP_ERROR TestReadAttributeNullableEnum8UnchangedValue_334() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75543,7 +75584,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableEnum8NullValue_334() + CHIP_ERROR TestWriteAttributeNullableEnum8NullValue_335() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75565,7 +75606,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableEnum8NullValue_335() + CHIP_ERROR TestReadAttributeNullableEnum8NullValue_336() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75589,7 +75630,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableEnum16MinValue_336() + CHIP_ERROR TestWriteAttributeNullableEnum16MinValue_337() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75611,7 +75652,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableEnum16MinValue_337() + CHIP_ERROR TestReadAttributeNullableEnum16MinValue_338() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75636,7 +75677,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableEnum16MaxValue_338() + CHIP_ERROR TestWriteAttributeNullableEnum16MaxValue_339() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75658,7 +75699,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableEnum16MaxValue_339() + CHIP_ERROR TestReadAttributeNullableEnum16MaxValue_340() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75683,7 +75724,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableEnum16InvalidValue_340() + CHIP_ERROR TestWriteAttributeNullableEnum16InvalidValue_341() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75705,7 +75746,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableEnum16UnchangedValue_341() + CHIP_ERROR TestReadAttributeNullableEnum16UnchangedValue_342() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75730,7 +75771,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableEnum16NullValue_342() + CHIP_ERROR TestWriteAttributeNullableEnum16NullValue_343() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75752,7 +75793,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableEnum16NullValue_343() + CHIP_ERROR TestReadAttributeNullableEnum16NullValue_344() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75776,7 +75817,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableSimpleEnumMinValue_344() + CHIP_ERROR TestWriteAttributeNullableSimpleEnumMinValue_345() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75798,7 +75839,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableSimpleEnumMinValue_345() + CHIP_ERROR TestReadAttributeNullableSimpleEnumMinValue_346() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75823,7 +75864,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableSimpleEnumMaxValue_346() + CHIP_ERROR TestWriteAttributeNullableSimpleEnumMaxValue_347() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75832,7 +75873,7 @@ class TestCluster : public TestCommandBridge { VerifyOrReturnError(cluster != nil, CHIP_ERROR_INCORRECT_STATE); id nullableEnumAttrArgument; - nullableEnumAttrArgument = [NSNumber numberWithUnsignedChar:254U]; + nullableEnumAttrArgument = [NSNumber numberWithUnsignedChar:3U]; [cluster writeAttributeNullableEnumAttrWithValue:nullableEnumAttrArgument completionHandler:^(NSError * _Nullable err) { NSLog(@"Write attribute NULLABLE_SIMPLE_ENUM Max Value Error: %@", err); @@ -75845,7 +75886,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableSimpleEnumMaxValue_347() + CHIP_ERROR TestReadAttributeNullableSimpleEnumMaxValue_348() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75861,7 +75902,7 @@ class TestCluster : public TestCommandBridge { { id actualValue = value; VerifyOrReturn(CheckValueNonNull("nullable_enum_attr", actualValue)); - VerifyOrReturn(CheckValue("nullable_enum_attr", actualValue, 254U)); + VerifyOrReturn(CheckValue("nullable_enum_attr", actualValue, 3U)); } NextTest(); @@ -75870,7 +75911,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableSimpleEnumInvalidValue_348() + CHIP_ERROR TestWriteAttributeNullableSimpleEnumInvalidValue_349() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75891,9 +75932,9 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - NSNumber * _Nullable nullableEnumAttr254; + NSNumber * _Nullable nullableEnumAttr3; - CHIP_ERROR TestReadAttributeNullableSimpleEnumUnchangedValue_349() + CHIP_ERROR TestReadAttributeNullableSimpleEnumUnchangedValue_350() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75909,10 +75950,10 @@ class TestCluster : public TestCommandBridge { { id actualValue = value; VerifyOrReturn(CheckValueNonNull("nullable_enum_attr", actualValue)); - VerifyOrReturn(CheckValue("nullable_enum_attr", actualValue, 254U)); + VerifyOrReturn(CheckValue("nullable_enum_attr", actualValue, 3U)); } { - nullableEnumAttr254 = value; + nullableEnumAttr3 = value; } NextTest(); @@ -75921,7 +75962,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableSimpleEnumNullValue_350() + CHIP_ERROR TestWriteAttributeNullableSimpleEnumNullValue_351() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75943,7 +75984,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableSimpleEnumNullValue_351() + CHIP_ERROR TestReadAttributeNullableSimpleEnumNullValue_352() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75967,7 +76008,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableSimpleEnumNot254Value_352() + CHIP_ERROR TestReadAttributeNullableSimpleEnumNot3Value_353() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -75976,13 +76017,13 @@ class TestCluster : public TestCommandBridge { VerifyOrReturnError(cluster != nil, CHIP_ERROR_INCORRECT_STATE); [cluster readAttributeNullableEnumAttrWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_SIMPLE_ENUM not 254 Value Error: %@", err); + NSLog(@"Read attribute NULLABLE_SIMPLE_ENUM not 3 Value Error: %@", err); VerifyOrReturn(CheckValue("status", err ? err.code : 0, 0)); if (value != nil) { } - VerifyOrReturn(CheckConstraintNotValue("nullableEnumAttr", value, nullableEnumAttr254)); + VerifyOrReturn(CheckConstraintNotValue("nullableEnumAttr", value, nullableEnumAttr3)); NextTest(); }]; @@ -75990,7 +76031,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableOctetStringDefaultValue_353() + CHIP_ERROR TestReadAttributeNullableOctetStringDefaultValue_354() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76016,7 +76057,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableOctetString_354() + CHIP_ERROR TestWriteAttributeNullableOctetString_355() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76039,7 +76080,7 @@ class TestCluster : public TestCommandBridge { } NSData * _Nullable nullableOctetStrTestValue; - CHIP_ERROR TestReadAttributeNullableOctetString_355() + CHIP_ERROR TestReadAttributeNullableOctetString_356() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76068,7 +76109,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableOctetString_356() + CHIP_ERROR TestWriteAttributeNullableOctetString_357() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76090,7 +76131,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableOctetString_357() + CHIP_ERROR TestReadAttributeNullableOctetString_358() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76114,7 +76155,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableOctetString_358() + CHIP_ERROR TestWriteAttributeNullableOctetString_359() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76136,7 +76177,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableOctetString_359() + CHIP_ERROR TestReadAttributeNullableOctetString_360() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76162,7 +76203,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableOctetStringNotTestValue_360() + CHIP_ERROR TestReadAttributeNullableOctetStringNotTestValue_361() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76185,7 +76226,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableCharStringDefaultValue_361() + CHIP_ERROR TestReadAttributeNullableCharStringDefaultValue_362() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76210,7 +76251,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableCharString_362() + CHIP_ERROR TestWriteAttributeNullableCharString_363() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76233,7 +76274,7 @@ class TestCluster : public TestCommandBridge { } NSString * _Nullable nullableCharStringSave; - CHIP_ERROR TestReadAttributeNullableCharString_363() + CHIP_ERROR TestReadAttributeNullableCharString_364() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76261,7 +76302,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableCharString_364() + CHIP_ERROR TestReadAttributeNullableCharString_365() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76290,7 +76331,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableCharStringValueTooLong_365() + CHIP_ERROR TestWriteAttributeNullableCharStringValueTooLong_366() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76312,7 +76353,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableCharString_366() + CHIP_ERROR TestReadAttributeNullableCharString_367() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76336,7 +76377,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeNullableCharStringEmpty_367() + CHIP_ERROR TestWriteAttributeNullableCharStringEmpty_368() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76358,7 +76399,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableCharString_368() + CHIP_ERROR TestReadAttributeNullableCharString_369() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76383,7 +76424,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeNullableCharStringNott_369() + CHIP_ERROR TestReadAttributeNullableCharStringNott_370() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76406,7 +76447,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeFromNonexistentEndpoint_370() + CHIP_ERROR TestReadAttributeFromNonexistentEndpoint_371() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76424,7 +76465,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeFromNonexistentCluster_371() + CHIP_ERROR TestReadAttributeFromNonexistentCluster_372() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76442,7 +76483,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_372() + CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_373() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76464,7 +76505,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_373() + CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_374() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76487,10 +76528,10 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - bool testSendClusterTestCluster_374_WaitForReport_Fulfilled = false; + bool testSendClusterTestCluster_375_WaitForReport_Fulfilled = false; ResponseHandler _Nullable test_TestCluster_list_int8u_Reported = nil; - CHIP_ERROR TestReportSubscribeToListAttribute_374() + CHIP_ERROR TestReportSubscribeToListAttribute_375() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76512,14 +76553,14 @@ class TestCluster : public TestCommandBridge { VerifyOrReturn(CheckValue("", actualValue[3], 4U)); } - testSendClusterTestCluster_374_WaitForReport_Fulfilled = true; + testSendClusterTestCluster_375_WaitForReport_Fulfilled = true; }; NextTest(); return CHIP_NO_ERROR; } - CHIP_ERROR TestSubscribeToListAttribute_375() + CHIP_ERROR TestSubscribeToListAttribute_376() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76535,7 +76576,7 @@ class TestCluster : public TestCommandBridge { params:params subscriptionEstablished:^{ VerifyOrReturn( - testSendClusterTestCluster_374_WaitForReport_Fulfilled, SetCommandExitStatus(CHIP_ERROR_INCORRECT_STATE)); + testSendClusterTestCluster_375_WaitForReport_Fulfilled, SetCommandExitStatus(CHIP_ERROR_INCORRECT_STATE)); NextTest(); } reportHandler:^(NSArray * _Nullable value, NSError * _Nullable err) { @@ -76552,7 +76593,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteSubscribedToListAttribute_376() + CHIP_ERROR TestWriteSubscribedToListAttribute_377() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76581,7 +76622,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestCheckForListAttributeReport_377() + CHIP_ERROR TestCheckForListAttributeReport_378() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76609,7 +76650,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadRangeRestrictedUnsigned8BitInteger_378() + CHIP_ERROR TestReadRangeRestrictedUnsigned8BitInteger_379() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76633,7 +76674,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_379() + CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_380() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76656,7 +76697,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_380() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_381() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76680,7 +76721,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_381() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_382() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76704,7 +76745,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_382() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_383() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76727,7 +76768,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_383() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_384() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76751,7 +76792,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_384() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_385() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76775,7 +76816,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_385() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_386() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76799,7 +76840,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_386() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_387() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76823,7 +76864,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_387() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_388() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76847,7 +76888,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_388() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_389() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76871,7 +76912,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_389() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_390() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76895,7 +76936,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadRangeRestrictedUnsigned16BitInteger_390() + CHIP_ERROR TestReadRangeRestrictedUnsigned16BitInteger_391() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76919,7 +76960,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_391() + CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_392() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76942,7 +76983,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_392() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_393() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76966,7 +77007,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_393() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_394() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -76990,7 +77031,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_394() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_395() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77013,7 +77054,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_395() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_396() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77037,7 +77078,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_396() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_397() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77061,7 +77102,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_397() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_398() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77085,7 +77126,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_398() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_399() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77109,7 +77150,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_399() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_400() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77133,7 +77174,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_400() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_401() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77158,7 +77199,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_401() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_402() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77182,7 +77223,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadRangeRestrictedSigned8BitInteger_402() + CHIP_ERROR TestReadRangeRestrictedSigned8BitInteger_403() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77206,7 +77247,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned8BitInteger_403() + CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned8BitInteger_404() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77228,7 +77269,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_404() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_405() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77253,7 +77294,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_405() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_406() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77278,7 +77319,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned8BitInteger_406() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned8BitInteger_407() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77300,7 +77341,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_407() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_408() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77324,7 +77365,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_408() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_409() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77347,7 +77388,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_409() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_410() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77371,7 +77412,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_410() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_411() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77394,7 +77435,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_411() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_412() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77418,7 +77459,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_412() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_413() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77442,7 +77483,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_413() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_414() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77466,7 +77507,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadRangeRestrictedSigned16BitInteger_414() + CHIP_ERROR TestReadRangeRestrictedSigned16BitInteger_415() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77490,7 +77531,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned16BitInteger_415() + CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned16BitInteger_416() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77513,7 +77554,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_416() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_417() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77537,7 +77578,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_417() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_418() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77561,7 +77602,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned16BitInteger_418() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned16BitInteger_419() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77584,7 +77625,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_419() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_420() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77608,7 +77649,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_420() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_421() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77632,7 +77673,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_421() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_422() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77656,7 +77697,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_422() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_423() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77680,7 +77721,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_423() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_424() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77704,7 +77745,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_424() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_425() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77728,7 +77769,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_425() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_426() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77752,7 +77793,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadNullableRangeRestrictedUnsigned8BitInteger_426() + CHIP_ERROR TestReadNullableRangeRestrictedUnsigned8BitInteger_427() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77778,7 +77819,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_427() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_428() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77802,7 +77843,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_428() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_429() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77826,7 +77867,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_429() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_430() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77850,7 +77891,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_430() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_431() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77874,7 +77915,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_431() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_432() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77900,7 +77941,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_432() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_433() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77924,7 +77965,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_433() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_434() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77950,7 +77991,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_434() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_435() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -77974,7 +78015,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_435() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_436() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78000,7 +78041,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_436() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_437() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78024,7 +78065,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_437() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_438() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78050,7 +78091,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_438() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_439() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78074,7 +78115,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_439() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_440() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78099,7 +78140,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadNullableRangeRestrictedUnsigned16BitInteger_440() + CHIP_ERROR TestReadNullableRangeRestrictedUnsigned16BitInteger_441() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78125,7 +78166,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_441() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_442() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78149,7 +78190,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_442() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_443() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78173,7 +78214,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_443() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_444() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78197,7 +78238,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_444() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_445() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78221,7 +78262,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_445() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_446() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78247,7 +78288,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_446() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_447() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78271,7 +78312,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_447() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_448() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78297,7 +78338,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_448() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_449() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78321,7 +78362,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_449() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_450() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78347,7 +78388,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_450() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_451() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78371,7 +78412,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_451() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_452() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78397,7 +78438,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_452() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_453() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78421,7 +78462,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_453() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_454() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78446,7 +78487,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadNullableRangeRestrictedSigned8BitInteger_454() + CHIP_ERROR TestReadNullableRangeRestrictedSigned8BitInteger_455() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78472,7 +78513,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_455() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_456() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78496,7 +78537,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_456() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_457() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78520,7 +78561,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_457() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_458() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78544,7 +78585,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_458() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_459() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78568,7 +78609,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_459() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_460() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78594,7 +78635,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_460() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_461() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78618,7 +78659,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_461() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_462() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78644,7 +78685,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_462() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_463() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78668,7 +78709,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_463() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_464() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78694,7 +78735,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_464() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_465() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78718,7 +78759,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_465() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_466() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78744,7 +78785,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_466() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_467() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78768,7 +78809,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_467() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_468() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78793,7 +78834,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadNullableRangeRestrictedSigned16BitInteger_468() + CHIP_ERROR TestReadNullableRangeRestrictedSigned16BitInteger_469() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78819,7 +78860,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_469() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_470() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78843,7 +78884,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_470() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_471() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78867,7 +78908,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_471() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_472() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78891,7 +78932,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_472() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_473() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78915,7 +78956,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_473() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_474() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78941,7 +78982,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_474() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_475() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78965,7 +79006,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_475() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_476() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -78991,7 +79032,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_476() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_477() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -79015,7 +79056,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_477() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_478() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -79041,7 +79082,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_478() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_479() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -79065,7 +79106,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_479() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_480() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -79091,7 +79132,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_480() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_481() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -79115,7 +79156,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_481() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_482() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -79140,7 +79181,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeThatReturnsGeneralStatusOnWrite_482() + CHIP_ERROR TestWriteAttributeThatReturnsGeneralStatusOnWrite_483() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -79162,7 +79203,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteAttributeThatReturnsClusterSpecificStatusOnWrite_483() + CHIP_ERROR TestWriteAttributeThatReturnsClusterSpecificStatusOnWrite_484() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -79184,7 +79225,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeThatReturnsGeneralStatusOnRead_484() + CHIP_ERROR TestReadAttributeThatReturnsGeneralStatusOnRead_485() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -79202,7 +79243,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAttributeThatReturnsClusterSpecificStatusOnRead_485() + CHIP_ERROR TestReadAttributeThatReturnsClusterSpecificStatusOnRead_486() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -79220,7 +79261,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadAcceptedCommandListAttribute_486() + CHIP_ERROR TestReadAcceptedCommandListAttribute_487() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -79262,7 +79303,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadGeneratedCommandListAttribute_487() + CHIP_ERROR TestReadGeneratedCommandListAttribute_488() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -79295,7 +79336,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestWriteStructTypedAttribute_488() + CHIP_ERROR TestWriteStructTypedAttribute_489() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device @@ -79326,7 +79367,7 @@ class TestCluster : public TestCommandBridge { return CHIP_NO_ERROR; } - CHIP_ERROR TestReadStructTypedAttribute_489() + CHIP_ERROR TestReadStructTypedAttribute_490() { MTRBaseDevice * device = GetDevice("alpha"); MTRBaseClusterTestCluster * cluster = [[MTRBaseClusterTestCluster alloc] initWithDevice:device