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/tests/suites/TestEvents.yaml b/src/app/tests/suites/TestEvents.yaml index 5b40c8bf9a888c..7c6592f32070bb 100644 --- a/src/app/tests/suites/TestEvents.yaml +++ b/src/app/tests/suites/TestEvents.yaml @@ -112,7 +112,7 @@ tests: - name: "arg1" value: 4 - name: "arg2" - value: 5 + value: 3 - name: "arg3" value: true response: @@ -126,4 +126,4 @@ tests: response: values: - name: "TestEvent" - value: { arg1: 4, arg2: 5, arg3: true } + value: { arg1: 4, arg2: 3, arg3: true } 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..fa547a3bfad8e8 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}} __attribute__((unused)) k{{asType label}}FirstUnusedEnumVal = static_cast<{{asType label}}>({{first_unused_enum_value mode="first_unused"}}); {{/zcl_enums}} {{#zcl_bitmaps}} diff --git a/src/platform/bouffalolab/BL602/args.gni b/src/platform/bouffalolab/BL602/args.gni index 8fe6c1a52b7de0..8cbed6f1ef1f19 100644 --- a/src/platform/bouffalolab/BL602/args.gni +++ b/src/platform/bouffalolab/BL602/args.gni @@ -37,7 +37,7 @@ chip_inet_config_enable_dns_resolver = false chip_inet_config_enable_tun_endpoint = false chip_inet_config_enable_tcp_endpoint = true chip_inet_config_enable_udp_endpoint = true - +chip_detail_logging = false pw_build_LINK_DEPS = [ "$dir_pw_assert:impl", "$dir_pw_log:impl", 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..acb56a0bd95e43 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,11 @@ 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 __attribute__((unused)) 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 +62,11 @@ 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 __attribute__((unused)) 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 +81,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 __attribute__((unused)) kIdentifyIdentifyTypeFirstUnusedEnumVal = static_cast(6); } // namespace Identify namespace Groups { @@ -112,9 +117,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 __attribute__((unused)) 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 +131,11 @@ 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 __attribute__((unused)) 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 +146,11 @@ 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 __attribute__((unused)) kOnOffEffectIdentifierFirstUnusedEnumVal = + static_cast(2); // Enum for OnOffStartUpOnOff enum class OnOffStartUpOnOff : uint8_t @@ -148,6 +159,7 @@ enum class OnOffStartUpOnOff : uint8_t kOn = 0x01, kTogglePreviousOnOff = 0x02, }; +static OnOffStartUpOnOff __attribute__((unused)) kOnOffStartUpOnOffFirstUnusedEnumVal = static_cast(3); // Bitmap for OnOffControl enum class OnOffControl : uint8_t @@ -182,9 +194,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 __attribute__((unused)) 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 +208,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 __attribute__((unused)) kStepModeFirstUnusedEnumVal = static_cast(2); // Bitmap for LevelControlFeature enum class LevelControlFeature : uint32_t @@ -241,6 +255,7 @@ enum class ApplianceStatus : uint8_t kSupercooling = 0x0E, kSuperheating = 0x0F, }; +static ApplianceStatus __attribute__((unused)) kApplianceStatusFirstUnusedEnumVal = static_cast(0); // Enum for CommandIdentification enum class CommandIdentification : uint8_t @@ -257,6 +272,8 @@ enum class CommandIdentification : uint8_t kEnableEnergyControl = 0x0A, kDisableEnergyControl = 0x0B, }; +static CommandIdentification __attribute__((unused)) kCommandIdentificationFirstUnusedEnumVal = + static_cast(0); // Enum for WarningEvent enum class WarningEvent : uint8_t @@ -267,6 +284,7 @@ enum class WarningEvent : uint8_t kWarning4OverallPowerBackBelowThePowerThresholdLevel = 0x03, kWarning5OverallPowerWillBePotentiallyAboveAvailablePowerLevelIfTheApplianceStarts = 0x04, }; +static WarningEvent __attribute__((unused)) kWarningEventFirstUnusedEnumVal = static_cast(5); // Bitmap for RemoteEnableFlagsAndDeviceStatus2 enum class RemoteEnableFlagsAndDeviceStatus2 : uint8_t @@ -294,6 +312,7 @@ enum class AuthMode : uint8_t kCase = 0x02, kGroup = 0x03, }; +static AuthMode __attribute__((unused)) kAuthModeFirstUnusedEnumVal = static_cast(0); // Enum for ChangeTypeEnum enum class ChangeTypeEnum : uint8_t @@ -302,6 +321,7 @@ enum class ChangeTypeEnum : uint8_t kAdded = 0x01, kRemoved = 0x02, }; +static ChangeTypeEnum __attribute__((unused)) kChangeTypeEnumFirstUnusedEnumVal = static_cast(3); // Enum for Privilege enum class Privilege : uint8_t @@ -312,6 +332,7 @@ enum class Privilege : uint8_t kManage = 0x04, kAdminister = 0x05, }; +static Privilege __attribute__((unused)) kPrivilegeFirstUnusedEnumVal = static_cast(0); } // namespace AccessControl namespace PollControl { @@ -325,6 +346,7 @@ enum class ActionErrorEnum : uint8_t kUnknown = 0x00, kInterrupted = 0x01, }; +static ActionErrorEnum __attribute__((unused)) kActionErrorEnumFirstUnusedEnumVal = static_cast(2); // Enum for ActionStateEnum enum class ActionStateEnum : uint8_t @@ -334,6 +356,7 @@ enum class ActionStateEnum : uint8_t kPaused = 0x02, kDisabled = 0x03, }; +static ActionStateEnum __attribute__((unused)) kActionStateEnumFirstUnusedEnumVal = static_cast(4); // Enum for ActionTypeEnum enum class ActionTypeEnum : uint8_t @@ -346,6 +369,7 @@ enum class ActionTypeEnum : uint8_t kNotification = 0x05, kAlarm = 0x06, }; +static ActionTypeEnum __attribute__((unused)) kActionTypeEnumFirstUnusedEnumVal = static_cast(7); // Enum for EndpointListTypeEnum enum class EndpointListTypeEnum : uint8_t @@ -354,6 +378,7 @@ enum class EndpointListTypeEnum : uint8_t kRoom = 0x01, kZone = 0x02, }; +static EndpointListTypeEnum __attribute__((unused)) kEndpointListTypeEnumFirstUnusedEnumVal = static_cast(3); // Bitmap for CommandBits enum class CommandBits : uint16_t @@ -385,6 +410,7 @@ enum class OTAApplyUpdateAction : uint8_t kAwaitNextAction = 0x01, kDiscontinue = 0x02, }; +static OTAApplyUpdateAction __attribute__((unused)) kOTAApplyUpdateActionFirstUnusedEnumVal = static_cast(3); // Enum for OTADownloadProtocol enum class OTADownloadProtocol : uint8_t @@ -394,6 +420,7 @@ enum class OTADownloadProtocol : uint8_t kHttps = 0x02, kVendorSpecific = 0x03, }; +static OTADownloadProtocol __attribute__((unused)) kOTADownloadProtocolFirstUnusedEnumVal = static_cast(4); // Enum for OTAQueryStatus enum class OTAQueryStatus : uint8_t @@ -403,6 +430,7 @@ enum class OTAQueryStatus : uint8_t kNotAvailable = 0x02, kDownloadProtocolNotSupported = 0x03, }; +static OTAQueryStatus __attribute__((unused)) kOTAQueryStatusFirstUnusedEnumVal = static_cast(4); } // namespace OtaSoftwareUpdateProvider namespace OtaSoftwareUpdateRequestor { @@ -414,6 +442,8 @@ enum class OTAAnnouncementReason : uint8_t kUpdateAvailable = 0x01, kUrgentUpdateAvailable = 0x02, }; +static OTAAnnouncementReason __attribute__((unused)) kOTAAnnouncementReasonFirstUnusedEnumVal = + static_cast(3); // Enum for OTAChangeReasonEnum enum class OTAChangeReasonEnum : uint8_t @@ -424,6 +454,7 @@ enum class OTAChangeReasonEnum : uint8_t kTimeOut = 0x03, kDelayByProvider = 0x04, }; +static OTAChangeReasonEnum __attribute__((unused)) kOTAChangeReasonEnumFirstUnusedEnumVal = static_cast(5); // Enum for OTAUpdateStateEnum enum class OTAUpdateStateEnum : uint8_t @@ -438,6 +469,7 @@ enum class OTAUpdateStateEnum : uint8_t kRollingBack = 0x07, kDelayedOnUserConsent = 0x08, }; +static OTAUpdateStateEnum __attribute__((unused)) kOTAUpdateStateEnumFirstUnusedEnumVal = static_cast(9); } // namespace OtaSoftwareUpdateRequestor namespace LocalizationConfiguration { @@ -461,6 +493,7 @@ enum class CalendarType : uint8_t kPersian = 0x0A, kTaiwanese = 0x0B, }; +static CalendarType __attribute__((unused)) kCalendarTypeFirstUnusedEnumVal = static_cast(12); // Enum for HourFormat enum class HourFormat : uint8_t @@ -468,6 +501,7 @@ enum class HourFormat : uint8_t k12hr = 0x00, k24hr = 0x01, }; +static HourFormat __attribute__((unused)) kHourFormatFirstUnusedEnumVal = static_cast(2); } // namespace TimeFormatLocalization namespace UnitLocalization { @@ -479,6 +513,7 @@ enum class TempUnit : uint8_t kCelsius = 0x01, kKelvin = 0x02, }; +static TempUnit __attribute__((unused)) kTempUnitFirstUnusedEnumVal = static_cast(3); // Bitmap for UnitLocalizationFeature enum class UnitLocalizationFeature : uint32_t @@ -507,6 +542,7 @@ enum class BatChargeFault : uint8_t kChargerUnderVoltage = 0x09, kSafetyTimeout = 0x0A, }; +static BatChargeFault __attribute__((unused)) kBatChargeFaultFirstUnusedEnumVal = static_cast(11); // Enum for BatChargeLevel enum class BatChargeLevel : uint8_t @@ -515,6 +551,7 @@ enum class BatChargeLevel : uint8_t kWarning = 0x01, kCritical = 0x02, }; +static BatChargeLevel __attribute__((unused)) kBatChargeLevelFirstUnusedEnumVal = static_cast(3); // Enum for BatChargeState enum class BatChargeState : uint8_t @@ -524,6 +561,7 @@ enum class BatChargeState : uint8_t kIsAtFullCharge = 0x02, kIsNotCharging = 0x03, }; +static BatChargeState __attribute__((unused)) kBatChargeStateFirstUnusedEnumVal = static_cast(4); // Enum for BatFault enum class BatFault : uint8_t @@ -532,6 +570,7 @@ enum class BatFault : uint8_t kOverTemp = 0x01, kUnderTemp = 0x02, }; +static BatFault __attribute__((unused)) kBatFaultFirstUnusedEnumVal = static_cast(3); // Enum for BatReplaceability enum class BatReplaceability : uint8_t @@ -541,6 +580,7 @@ enum class BatReplaceability : uint8_t kUserReplaceable = 0x02, kFactoryReplaceable = 0x03, }; +static BatReplaceability __attribute__((unused)) kBatReplaceabilityFirstUnusedEnumVal = static_cast(4); // Enum for PowerSourceStatus enum class PowerSourceStatus : uint8_t @@ -550,6 +590,7 @@ enum class PowerSourceStatus : uint8_t kStandby = 0x02, kUnavailable = 0x03, }; +static PowerSourceStatus __attribute__((unused)) kPowerSourceStatusFirstUnusedEnumVal = static_cast(4); // Enum for WiredCurrentType enum class WiredCurrentType : uint8_t @@ -557,6 +598,7 @@ enum class WiredCurrentType : uint8_t kAc = 0x00, kDc = 0x01, }; +static WiredCurrentType __attribute__((unused)) kWiredCurrentTypeFirstUnusedEnumVal = static_cast(2); // Enum for WiredFault enum class WiredFault : uint8_t @@ -565,6 +607,7 @@ enum class WiredFault : uint8_t kOverVoltage = 0x01, kUnderVoltage = 0x02, }; +static WiredFault __attribute__((unused)) kWiredFaultFirstUnusedEnumVal = static_cast(3); // Bitmap for PowerSourceFeature enum class PowerSourceFeature : uint32_t @@ -587,6 +630,7 @@ enum class CommissioningError : uint8_t kNoFailSafe = 0x03, kBusyWithOtherAdmin = 0x04, }; +static CommissioningError __attribute__((unused)) kCommissioningErrorFirstUnusedEnumVal = static_cast(5); // Enum for RegulatoryLocationType enum class RegulatoryLocationType : uint8_t @@ -595,6 +639,8 @@ enum class RegulatoryLocationType : uint8_t kOutdoor = 0x01, kIndoorOutdoor = 0x02, }; +static RegulatoryLocationType __attribute__((unused)) kRegulatoryLocationTypeFirstUnusedEnumVal = + static_cast(3); } // namespace GeneralCommissioning namespace NetworkCommissioning { @@ -616,6 +662,8 @@ enum class NetworkCommissioningStatus : uint8_t kIPBindFailed = 0x0B, kUnknownError = 0x0C, }; +static NetworkCommissioningStatus __attribute__((unused)) kNetworkCommissioningStatusFirstUnusedEnumVal = + static_cast(13); // Enum for WiFiBand enum class WiFiBand : uint8_t @@ -626,6 +674,7 @@ enum class WiFiBand : uint8_t k6g = 0x03, k60g = 0x04, }; +static WiFiBand __attribute__((unused)) kWiFiBandFirstUnusedEnumVal = static_cast(5); // Bitmap for NetworkCommissioningFeature enum class NetworkCommissioningFeature : uint32_t @@ -655,6 +704,7 @@ enum class LogsIntent : uint8_t kNetworkDiag = 0x01, kCrashLogs = 0x02, }; +static LogsIntent __attribute__((unused)) kLogsIntentFirstUnusedEnumVal = static_cast(3); // Enum for LogsStatus enum class LogsStatus : uint8_t @@ -665,6 +715,7 @@ enum class LogsStatus : uint8_t kBusy = 0x03, kDenied = 0x04, }; +static LogsStatus __attribute__((unused)) kLogsStatusFirstUnusedEnumVal = static_cast(5); // Enum for LogsTransferProtocol enum class LogsTransferProtocol : uint8_t @@ -672,6 +723,7 @@ enum class LogsTransferProtocol : uint8_t kResponsePayload = 0x00, kBdx = 0x01, }; +static LogsTransferProtocol __attribute__((unused)) kLogsTransferProtocolFirstUnusedEnumVal = static_cast(2); } // namespace DiagnosticLogs namespace GeneralDiagnostics { @@ -687,6 +739,7 @@ enum class BootReasonType : uint8_t kSoftwareUpdateCompleted = 0x05, kSoftwareReset = 0x06, }; +static BootReasonType __attribute__((unused)) 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 +759,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 __attribute__((unused)) 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 +776,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 __attribute__((unused)) 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 +792,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 __attribute__((unused)) 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 +811,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 __attribute__((unused)) kRadioFaultTypeFirstUnusedEnumVal = static_cast(7); } // namespace GeneralDiagnostics namespace SoftwareDiagnostics { @@ -779,6 +836,7 @@ enum class NetworkFault : uint8_t kHardwareFailure = 0x02, kNetworkJammed = 0x03, }; +static NetworkFault __attribute__((unused)) 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 +852,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 __attribute__((unused)) kRoutingRoleFirstUnusedEnumVal = static_cast(7); // Enum for ThreadConnectionStatus enum class ThreadConnectionStatus : uint8_t @@ -804,6 +863,8 @@ enum class ThreadConnectionStatus : uint8_t kConnected = 0x00, kNotConnected = 0x01, }; +static ThreadConnectionStatus __attribute__((unused)) kThreadConnectionStatusFirstUnusedEnumVal = + static_cast(2); // Bitmap for ThreadNetworkDiagnosticsFeature enum class ThreadNetworkDiagnosticsFeature : uint32_t @@ -825,6 +886,8 @@ enum class AssociationFailureCause : uint8_t kAuthenticationFailed = 0x02, kSsidNotFound = 0x03, }; +static AssociationFailureCause __attribute__((unused)) 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 +902,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 __attribute__((unused)) kSecurityTypeFirstUnusedEnumVal = static_cast(6); // Enum for WiFiConnectionStatus enum class WiFiConnectionStatus : uint8_t @@ -849,6 +913,7 @@ enum class WiFiConnectionStatus : uint8_t kConnected = 0x00, kNotConnected = 0x01, }; +static WiFiConnectionStatus __attribute__((unused)) 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 +928,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 __attribute__((unused)) kWiFiVersionTypeFirstUnusedEnumVal = static_cast(6); } // namespace WiFiNetworkDiagnostics namespace EthernetNetworkDiagnostics { @@ -887,9 +953,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 __attribute__((unused)) kPHYRateTypeFirstUnusedEnumVal = static_cast(10); } // namespace EthernetNetworkDiagnostics namespace TimeSynchronization { @@ -910,6 +977,8 @@ enum class CommissioningWindowStatus : uint8_t kEnhancedWindowOpen = 0x01, kBasicWindowOpen = 0x02, }; +static CommissioningWindowStatus __attribute__((unused)) 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 +990,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 __attribute__((unused)) kStatusCodeFirstUnusedEnumVal = static_cast(0); } // namespace AdministratorCommissioning namespace OperationalCredentials { @@ -943,6 +1013,8 @@ enum class OperationalCertStatus : uint8_t kLabelConflict = 0x0A, kInvalidFabricIndex = 0x0B, }; +static OperationalCertStatus __attribute__((unused)) kOperationalCertStatusFirstUnusedEnumVal = + static_cast(7); } // namespace OperationalCredentials namespace GroupKeyManagement { @@ -953,6 +1025,8 @@ enum class GroupKeySecurityPolicy : uint8_t kTrustFirst = 0x00, kCacheAndSync = 0x01, }; +static GroupKeySecurityPolicy __attribute__((unused)) kGroupKeySecurityPolicyFirstUnusedEnumVal = + static_cast(2); } // namespace GroupKeyManagement namespace FixedLabel { @@ -999,6 +1073,7 @@ enum class DlAlarmCode : uint8_t kDoorAjar = 0x07, kForcedUser = 0x08, }; +static DlAlarmCode __attribute__((unused)) kDlAlarmCodeFirstUnusedEnumVal = static_cast(2); // Enum for DlCredentialRule enum class DlCredentialRule : uint8_t @@ -1007,6 +1082,7 @@ enum class DlCredentialRule : uint8_t kDouble = 0x01, kTri = 0x02, }; +static DlCredentialRule __attribute__((unused)) kDlCredentialRuleFirstUnusedEnumVal = static_cast(3); // Enum for DlCredentialType enum class DlCredentialType : uint8_t @@ -1018,6 +1094,7 @@ enum class DlCredentialType : uint8_t kFingerVein = 0x04, kFace = 0x05, }; +static DlCredentialType __attribute__((unused)) kDlCredentialTypeFirstUnusedEnumVal = static_cast(6); // Enum for DlDataOperationType enum class DlDataOperationType : uint8_t @@ -1026,6 +1103,7 @@ enum class DlDataOperationType : uint8_t kClear = 0x01, kModify = 0x02, }; +static DlDataOperationType __attribute__((unused)) kDlDataOperationTypeFirstUnusedEnumVal = static_cast(3); // Enum for DlDoorState enum class DlDoorState : uint8_t @@ -1037,6 +1115,7 @@ enum class DlDoorState : uint8_t kDoorUnspecifiedError = 0x04, kDoorAjar = 0x05, }; +static DlDoorState __attribute__((unused)) kDlDoorStateFirstUnusedEnumVal = static_cast(6); // Enum for DlLockDataType enum class DlLockDataType : uint8_t @@ -1051,6 +1130,7 @@ enum class DlLockDataType : uint8_t kRfid = 0x07, kFingerprint = 0x08, }; +static DlLockDataType __attribute__((unused)) kDlLockDataTypeFirstUnusedEnumVal = static_cast(9); // Enum for DlLockOperationType enum class DlLockOperationType : uint8_t @@ -1060,6 +1140,7 @@ enum class DlLockOperationType : uint8_t kNonAccessUserEvent = 0x02, kForcedUserEvent = 0x03, }; +static DlLockOperationType __attribute__((unused)) kDlLockOperationTypeFirstUnusedEnumVal = static_cast(4); // Enum for DlLockState enum class DlLockState : uint8_t @@ -1068,6 +1149,7 @@ enum class DlLockState : uint8_t kLocked = 0x01, kUnlocked = 0x02, }; +static DlLockState __attribute__((unused)) kDlLockStateFirstUnusedEnumVal = static_cast(3); // Enum for DlLockType enum class DlLockType : uint8_t @@ -1084,6 +1166,7 @@ enum class DlLockType : uint8_t kDeadLatch = 0x09, kDoorFurniture = 0x0A, }; +static DlLockType __attribute__((unused)) kDlLockTypeFirstUnusedEnumVal = static_cast(11); // Enum for DlOperatingMode enum class DlOperatingMode : uint8_t @@ -1094,6 +1177,7 @@ enum class DlOperatingMode : uint8_t kNoRemoteLockUnlock = 0x03, kPassage = 0x04, }; +static DlOperatingMode __attribute__((unused)) kDlOperatingModeFirstUnusedEnumVal = static_cast(5); // Enum for DlOperationError enum class DlOperationError : uint8_t @@ -1104,6 +1188,7 @@ enum class DlOperationError : uint8_t kRestricted = 0x03, kInsufficientBattery = 0x04, }; +static DlOperationError __attribute__((unused)) kDlOperationErrorFirstUnusedEnumVal = static_cast(5); // Enum for DlOperationSource enum class DlOperationSource : uint8_t @@ -1119,6 +1204,7 @@ enum class DlOperationSource : uint8_t kRfid = 0x08, kBiometric = 0x09, }; +static DlOperationSource __attribute__((unused)) kDlOperationSourceFirstUnusedEnumVal = static_cast(10); // Enum for DlStatus enum class DlStatus : uint8_t @@ -1131,6 +1217,7 @@ enum class DlStatus : uint8_t kResourceExhausted = 0x89, kNotFound = 0x8B, }; +static DlStatus __attribute__((unused)) kDlStatusFirstUnusedEnumVal = static_cast(4); // Enum for DlUserStatus enum class DlUserStatus : uint8_t @@ -1139,6 +1226,7 @@ enum class DlUserStatus : uint8_t kOccupiedEnabled = 0x01, kOccupiedDisabled = 0x03, }; +static DlUserStatus __attribute__((unused)) kDlUserStatusFirstUnusedEnumVal = static_cast(2); // Enum for DlUserType enum class DlUserType : uint8_t @@ -1154,6 +1242,7 @@ enum class DlUserType : uint8_t kScheduleRestrictedUser = 0x08, kRemoteOnlyUser = 0x09, }; +static DlUserType __attribute__((unused)) kDlUserTypeFirstUnusedEnumVal = static_cast(10); // Enum for DoorLockOperationEventCode enum class DoorLockOperationEventCode : uint8_t @@ -1174,6 +1263,8 @@ enum class DoorLockOperationEventCode : uint8_t kManualLock = 0x0D, kManualUnlock = 0x0E, }; +static DoorLockOperationEventCode __attribute__((unused)) kDoorLockOperationEventCodeFirstUnusedEnumVal = + static_cast(15); // Enum for DoorLockProgrammingEventCode enum class DoorLockProgrammingEventCode : uint8_t @@ -1186,6 +1277,8 @@ enum class DoorLockProgrammingEventCode : uint8_t kIdAdded = 0x05, kIdDeleted = 0x06, }; +static DoorLockProgrammingEventCode __attribute__((unused)) kDoorLockProgrammingEventCodeFirstUnusedEnumVal = + static_cast(7); // Enum for DoorLockSetPinOrIdStatus enum class DoorLockSetPinOrIdStatus : uint8_t @@ -1195,6 +1288,8 @@ enum class DoorLockSetPinOrIdStatus : uint8_t kMemoryFull = 0x02, kDuplicateCodeError = 0x03, }; +static DoorLockSetPinOrIdStatus __attribute__((unused)) kDoorLockSetPinOrIdStatusFirstUnusedEnumVal = + static_cast(4); // Enum for DoorLockUserStatus enum class DoorLockUserStatus : uint8_t @@ -1204,6 +1299,7 @@ enum class DoorLockUserStatus : uint8_t kOccupiedDisabled = 0x03, kNotSupported = 0xFF, }; +static DoorLockUserStatus __attribute__((unused)) kDoorLockUserStatusFirstUnusedEnumVal = static_cast(2); // Enum for DoorLockUserType enum class DoorLockUserType : uint8_t @@ -1215,6 +1311,7 @@ enum class DoorLockUserType : uint8_t kNonAccessUser = 0x04, kNotSupported = 0xFF, }; +static DoorLockUserType __attribute__((unused)) kDoorLockUserTypeFirstUnusedEnumVal = static_cast(5); // Bitmap for DlCredentialRuleMask enum class DlCredentialRuleMask : uint8_t @@ -1416,6 +1513,7 @@ enum class EndProductType : uint8_t kSlidingShutter = 0x17, kUnknown = 0xFF, }; +static EndProductType __attribute__((unused)) kEndProductTypeFirstUnusedEnumVal = static_cast(24); // Enum for Type enum class Type : uint8_t @@ -1432,6 +1530,7 @@ enum class Type : uint8_t kProjectorScreen = 0x09, kUnknown = 0xFF, }; +static Type __attribute__((unused)) kTypeFirstUnusedEnumVal = static_cast(10); // Bitmap for ConfigStatus enum class ConfigStatus : uint8_t @@ -1505,6 +1604,7 @@ enum class PumpControlMode : uint8_t kConstantTemperature = 0x05, kAutomatic = 0x07, }; +static PumpControlMode __attribute__((unused)) kPumpControlModeFirstUnusedEnumVal = static_cast(4); // Enum for PumpOperationMode enum class PumpOperationMode : uint8_t @@ -1514,6 +1614,7 @@ enum class PumpOperationMode : uint8_t kMaximum = 0x02, kLocal = 0x03, }; +static PumpOperationMode __attribute__((unused)) kPumpOperationModeFirstUnusedEnumVal = static_cast(4); // Bitmap for PumpStatus enum class PumpStatus : uint16_t @@ -1542,9 +1643,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 __attribute__((unused)) kSetpointAdjustModeFirstUnusedEnumVal = static_cast(3); // Enum for ThermostatControlSequence enum class ThermostatControlSequence : uint8_t @@ -1556,6 +1658,8 @@ enum class ThermostatControlSequence : uint8_t kCoolingAndHeating = 0x04, kCoolingAndHeatingWithReheat = 0x05, }; +static ThermostatControlSequence __attribute__((unused)) kThermostatControlSequenceFirstUnusedEnumVal = + static_cast(6); // Enum for ThermostatRunningMode enum class ThermostatRunningMode : uint8_t @@ -1564,6 +1668,8 @@ enum class ThermostatRunningMode : uint8_t kCool = 0x03, kHeat = 0x04, }; +static ThermostatRunningMode __attribute__((unused)) kThermostatRunningModeFirstUnusedEnumVal = + static_cast(1); // Enum for ThermostatSystemMode enum class ThermostatSystemMode : uint8_t @@ -1576,6 +1682,7 @@ enum class ThermostatSystemMode : uint8_t kPrecooling = 0x06, kFanOnly = 0x07, }; +static ThermostatSystemMode __attribute__((unused)) kThermostatSystemModeFirstUnusedEnumVal = static_cast(2); // Bitmap for DayOfWeek enum class DayOfWeek : uint8_t @@ -1621,6 +1728,7 @@ enum class FanModeSequenceType : uint8_t kOffOnAuto = 0x04, kOffOn = 0x05, }; +static FanModeSequenceType __attribute__((unused)) kFanModeSequenceTypeFirstUnusedEnumVal = static_cast(6); // Enum for FanModeType enum class FanModeType : uint8_t @@ -1633,6 +1741,7 @@ enum class FanModeType : uint8_t kAuto = 0x05, kSmart = 0x06, }; +static FanModeType __attribute__((unused)) kFanModeTypeFirstUnusedEnumVal = static_cast(7); // Bitmap for FanControlFeature enum class FanControlFeature : uint32_t @@ -1684,9 +1793,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 __attribute__((unused)) 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 +1807,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 __attribute__((unused)) 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 +1822,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 __attribute__((unused)) 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 +1838,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 __attribute__((unused)) 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 +1853,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 __attribute__((unused)) 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 +1867,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 __attribute__((unused)) 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 +1882,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 __attribute__((unused)) 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 +1896,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 __attribute__((unused)) kSaturationStepModeFirstUnusedEnumVal = static_cast(0); // Bitmap for ColorCapabilities enum class ColorCapabilities : uint16_t @@ -1825,6 +1942,7 @@ enum class LightSensorType : uint8_t kPhotodiode = 0x00, kCmos = 0x01, }; +static LightSensorType __attribute__((unused)) kLightSensorTypeFirstUnusedEnumVal = static_cast(2); } // namespace IlluminanceMeasurement namespace TemperatureMeasurement { @@ -1950,12 +2068,14 @@ enum class ChannelStatusEnum : uint8_t kMultipleMatches = 0x01, kNoMatches = 0x02, }; +static ChannelStatusEnum __attribute__((unused)) kChannelStatusEnumFirstUnusedEnumVal = static_cast(3); // Enum for LineupInfoTypeEnum enum class LineupInfoTypeEnum : uint8_t { kMso = 0x00, }; +static LineupInfoTypeEnum __attribute__((unused)) kLineupInfoTypeEnumFirstUnusedEnumVal = static_cast(1); // Bitmap for ChannelFeature enum class ChannelFeature : uint32_t @@ -1974,6 +2094,8 @@ enum class TargetNavigatorStatusEnum : uint8_t kTargetNotFound = 0x01, kNotAllowed = 0x02, }; +static TargetNavigatorStatusEnum __attribute__((unused)) kTargetNavigatorStatusEnumFirstUnusedEnumVal = + static_cast(3); } // namespace TargetNavigator namespace MediaPlayback { @@ -1988,6 +2110,8 @@ enum class MediaPlaybackStatusEnum : uint8_t kSpeedOutOfRange = 0x04, kSeekOutOfRange = 0x05, }; +static MediaPlaybackStatusEnum __attribute__((unused)) kMediaPlaybackStatusEnumFirstUnusedEnumVal = + static_cast(6); // Enum for PlaybackStateEnum enum class PlaybackStateEnum : uint8_t @@ -1997,6 +2121,7 @@ enum class PlaybackStateEnum : uint8_t kNotPlaying = 0x02, kBuffering = 0x03, }; +static PlaybackStateEnum __attribute__((unused)) kPlaybackStateEnumFirstUnusedEnumVal = static_cast(4); } // namespace MediaPlayback namespace MediaInput { @@ -2017,6 +2142,7 @@ enum class InputTypeEnum : uint8_t kUsb = 0x0A, kOther = 0x0B, }; +static InputTypeEnum __attribute__((unused)) kInputTypeEnumFirstUnusedEnumVal = static_cast(12); // Bitmap for MediaInputFeature enum class MediaInputFeature : uint32_t @@ -2120,6 +2246,7 @@ enum class CecKeyCode : uint8_t kF5 = 0x75, kData = 0x76, }; +static CecKeyCode __attribute__((unused)) kCecKeyCodeFirstUnusedEnumVal = static_cast(14); // Enum for KeypadInputStatusEnum enum class KeypadInputStatusEnum : uint8_t @@ -2128,6 +2255,8 @@ enum class KeypadInputStatusEnum : uint8_t kUnsupportedKey = 0x01, kInvalidKeyInCurrentState = 0x02, }; +static KeypadInputStatusEnum __attribute__((unused)) kKeypadInputStatusEnumFirstUnusedEnumVal = + static_cast(3); // Bitmap for KeypadInputFeature enum class KeypadInputFeature : uint32_t @@ -2147,6 +2276,8 @@ enum class ContentLaunchStatusEnum : uint8_t kUrlNotAvailable = 0x01, kAuthFailed = 0x02, }; +static ContentLaunchStatusEnum __attribute__((unused)) kContentLaunchStatusEnumFirstUnusedEnumVal = + static_cast(3); // Enum for MetricTypeEnum enum class MetricTypeEnum : uint8_t @@ -2154,6 +2285,7 @@ enum class MetricTypeEnum : uint8_t kPixels = 0x00, kPercentage = 0x01, }; +static MetricTypeEnum __attribute__((unused)) kMetricTypeEnumFirstUnusedEnumVal = static_cast(2); // Enum for ParameterEnum enum class ParameterEnum : uint8_t @@ -2172,6 +2304,7 @@ enum class ParameterEnum : uint8_t kSportsTeam = 0x0B, kType = 0x0C, }; +static ParameterEnum __attribute__((unused)) kParameterEnumFirstUnusedEnumVal = static_cast(13); // Bitmap for ContentLauncherFeature enum class ContentLauncherFeature : uint32_t @@ -2200,6 +2333,7 @@ enum class OutputTypeEnum : uint8_t kInternal = 0x04, kOther = 0x05, }; +static OutputTypeEnum __attribute__((unused)) kOutputTypeEnumFirstUnusedEnumVal = static_cast(6); // Bitmap for AudioOutputFeature enum class AudioOutputFeature : uint32_t @@ -2217,6 +2351,8 @@ enum class ApplicationLauncherStatusEnum : uint8_t kAppNotAvailable = 0x01, kSystemBusy = 0x02, }; +static ApplicationLauncherStatusEnum __attribute__((unused)) kApplicationLauncherStatusEnumFirstUnusedEnumVal = + static_cast(3); // Bitmap for ApplicationLauncherFeature enum class ApplicationLauncherFeature : uint32_t @@ -2235,6 +2371,8 @@ enum class ApplicationStatusEnum : uint8_t kActiveHidden = 0x02, kActiveVisibleNotFocus = 0x03, }; +static ApplicationStatusEnum __attribute__((unused)) kApplicationStatusEnumFirstUnusedEnumVal = + static_cast(4); } // namespace ApplicationBasic namespace AccountLogin { @@ -2257,6 +2395,7 @@ enum class EventIdentification : uint8_t kSwitchingOff = 0x06, kWrongData = 0x07, }; +static EventIdentification __attribute__((unused)) kEventIdentificationFirstUnusedEnumVal = static_cast(0); // Bitmap for AlertCount enum class AlertCount : uint8_t @@ -2290,6 +2429,7 @@ enum class SimpleEnum : uint8_t kValueB = 0x02, kValueC = 0x03, }; +static SimpleEnum __attribute__((unused)) 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 c52a297ef267d6..5134e992694a68 100644 --- a/zzz_generated/chip-tool/zap-generated/test/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/test/Commands.h @@ -39060,7 +39060,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); @@ -39095,7 +39095,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; @@ -40138,10 +40138,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; @@ -40149,7 +40158,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; @@ -40157,7 +40166,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; @@ -40165,7 +40174,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; @@ -40173,7 +40182,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; @@ -40181,7 +40190,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; @@ -40189,7 +40198,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; @@ -40205,7 +40214,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; @@ -40213,7 +40222,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; @@ -40221,7 +40230,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; @@ -40250,7 +40259,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; @@ -40261,7 +40270,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; @@ -40269,7 +40278,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; @@ -40277,7 +40286,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; @@ -40285,7 +40294,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; @@ -40293,10 +40302,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; @@ -40315,10 +40324,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; @@ -40341,10 +40350,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 @@ -40372,7 +40381,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; @@ -40387,7 +40396,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; @@ -40395,7 +40404,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< @@ -40416,10 +40425,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< @@ -40453,10 +40462,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; @@ -40465,10 +40474,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; @@ -40477,7 +40486,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; @@ -40485,10 +40494,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; @@ -40497,10 +40506,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; @@ -40510,10 +40519,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; @@ -40521,7 +40530,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; @@ -40529,10 +40538,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; @@ -40541,10 +40550,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; @@ -40553,10 +40562,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; @@ -40564,10 +40573,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; @@ -40576,10 +40585,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; @@ -40588,10 +40597,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; @@ -40599,10 +40608,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; @@ -40611,10 +40620,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; @@ -40623,10 +40632,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; @@ -40634,10 +40643,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; @@ -40646,10 +40655,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; @@ -40658,10 +40667,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; @@ -40670,7 +40679,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; @@ -40678,10 +40687,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; @@ -40689,7 +40698,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; @@ -40698,7 +40707,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; @@ -40706,10 +40715,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; @@ -40718,7 +40727,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; @@ -40726,10 +40735,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; @@ -40738,10 +40747,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; @@ -40750,10 +40759,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; @@ -40762,10 +40771,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; @@ -40773,7 +40782,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; @@ -40782,7 +40791,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; @@ -40790,10 +40799,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; @@ -40802,7 +40811,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; @@ -40810,10 +40819,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; @@ -40822,10 +40831,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; @@ -40834,10 +40843,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; @@ -40846,10 +40855,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; @@ -40857,7 +40866,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; @@ -40866,7 +40875,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; @@ -40874,10 +40883,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; @@ -40886,7 +40895,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; @@ -40894,10 +40903,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; @@ -40906,10 +40915,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; @@ -40918,10 +40927,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; @@ -40930,10 +40939,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; @@ -40941,7 +40950,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; @@ -40950,7 +40959,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; @@ -40958,10 +40967,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; @@ -40970,7 +40979,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; @@ -40978,10 +40987,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; @@ -40990,10 +40999,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; @@ -41002,10 +41011,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; @@ -41013,7 +41022,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; @@ -41022,7 +41031,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; @@ -41030,10 +41039,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; @@ -41042,7 +41051,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; @@ -41050,10 +41059,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; @@ -41062,10 +41071,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; @@ -41074,10 +41083,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; @@ -41085,7 +41094,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; @@ -41094,7 +41103,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; @@ -41102,10 +41111,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; @@ -41114,7 +41123,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; @@ -41122,10 +41131,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; @@ -41134,10 +41143,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; @@ -41146,10 +41155,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; @@ -41157,7 +41166,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; @@ -41166,7 +41175,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; @@ -41174,10 +41183,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; @@ -41186,7 +41195,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; @@ -41194,10 +41203,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; @@ -41206,10 +41215,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; @@ -41218,10 +41227,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; @@ -41229,7 +41238,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; @@ -41238,7 +41247,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; @@ -41246,10 +41255,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; @@ -41258,7 +41267,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; @@ -41266,10 +41275,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; @@ -41278,10 +41287,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; @@ -41290,10 +41299,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; @@ -41302,10 +41311,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; @@ -41313,10 +41322,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; @@ -41325,10 +41334,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; @@ -41337,10 +41346,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; @@ -41349,10 +41358,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; @@ -41361,10 +41370,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; @@ -41372,10 +41381,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; @@ -41384,10 +41393,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; @@ -41396,10 +41405,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; @@ -41408,10 +41417,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; @@ -41420,10 +41429,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; @@ -41431,10 +41440,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; @@ -41443,10 +41452,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; @@ -41455,10 +41464,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; @@ -41467,10 +41476,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; @@ -41478,10 +41487,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; @@ -41490,35 +41499,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; @@ -41526,15 +41535,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; @@ -41544,10 +41553,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; @@ -41571,10 +41580,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; @@ -41582,10 +41591,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; @@ -41595,7 +41604,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; @@ -41603,7 +41612,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; @@ -41612,10 +41621,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; @@ -41638,7 +41647,7 @@ class TestClusterSuite : public TestCommand } } break; - case 364: + case 365: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -41654,10 +41663,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; @@ -41665,10 +41674,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; @@ -41677,7 +41686,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; @@ -41685,19 +41694,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; @@ -41716,10 +41725,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; @@ -41739,7 +41748,7 @@ class TestClusterSuite : public TestCommand } shouldContinue = true; break; - case 377: + case 378: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { uint8_t value; @@ -41747,9 +41756,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; @@ -41760,6 +41766,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; @@ -41767,10 +41776,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; @@ -41778,10 +41787,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; @@ -41789,10 +41798,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; @@ -41800,7 +41809,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; @@ -41808,9 +41817,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; @@ -41821,6 +41827,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; @@ -41828,10 +41837,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; @@ -41839,10 +41848,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; @@ -41850,10 +41859,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; @@ -41861,7 +41870,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; @@ -41869,9 +41878,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; @@ -41882,6 +41888,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; @@ -41889,10 +41898,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; @@ -41900,10 +41909,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; @@ -41911,10 +41920,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; @@ -41922,7 +41931,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; @@ -41930,9 +41939,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; @@ -41943,6 +41949,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; @@ -41950,10 +41959,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; @@ -41961,10 +41970,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; @@ -41972,10 +41981,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; @@ -41983,7 +41992,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; @@ -41992,9 +42001,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; @@ -42005,6 +42011,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; @@ -42013,10 +42022,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; @@ -42025,10 +42034,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; @@ -42037,10 +42046,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; @@ -42049,10 +42058,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; @@ -42060,7 +42069,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; @@ -42069,9 +42078,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; @@ -42082,6 +42088,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; @@ -42090,10 +42099,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; @@ -42102,10 +42111,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; @@ -42114,10 +42123,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; @@ -42126,10 +42135,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; @@ -42137,7 +42146,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; @@ -42146,9 +42155,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; @@ -42159,6 +42165,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; @@ -42167,10 +42176,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; @@ -42179,10 +42188,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; @@ -42191,10 +42200,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; @@ -42203,10 +42212,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; @@ -42214,7 +42223,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; @@ -42223,9 +42232,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; @@ -42236,6 +42242,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; @@ -42244,10 +42253,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; @@ -42256,10 +42265,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; @@ -42268,10 +42277,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; @@ -42280,10 +42289,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; @@ -42291,19 +42300,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; @@ -42350,7 +42359,7 @@ class TestClusterSuite : public TestCommand } } break; - case 486: + case 487: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::DecodableList value; @@ -42379,10 +42388,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; @@ -43469,14 +43478,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; @@ -43494,8 +43514,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; @@ -43513,8 +43533,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; @@ -43535,8 +43555,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; @@ -43557,8 +43577,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; @@ -43636,8 +43656,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; @@ -43715,8 +43735,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; @@ -43734,8 +43754,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; @@ -43758,8 +43778,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; @@ -43783,8 +43803,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; @@ -43807,8 +43827,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; @@ -43818,8 +43838,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; @@ -43855,8 +43875,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; @@ -43892,8 +43912,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; @@ -43981,8 +44001,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; @@ -44069,8 +44089,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; @@ -44086,13 +44106,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; @@ -44108,13 +44128,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; @@ -44145,13 +44165,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(); @@ -44162,8 +44182,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, @@ -44171,13 +44191,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; @@ -44207,26 +44227,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(); @@ -44234,18 +44254,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(); @@ -44253,13 +44273,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(); @@ -44267,31 +44287,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(); @@ -44299,13 +44319,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(); @@ -44313,26 +44333,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(); @@ -44340,13 +44360,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(); @@ -44354,26 +44374,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(); @@ -44381,13 +44401,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(); @@ -44395,26 +44415,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(); @@ -44422,13 +44442,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(); @@ -44436,13 +44456,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(); @@ -44450,41 +44470,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(); @@ -44492,18 +44512,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(); @@ -44511,13 +44531,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(); @@ -44525,13 +44545,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(); @@ -44539,36 +44559,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(); @@ -44576,18 +44596,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(); @@ -44595,13 +44615,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(); @@ -44609,13 +44629,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(); @@ -44623,36 +44643,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(); @@ -44660,18 +44680,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(); @@ -44679,13 +44699,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(); @@ -44693,13 +44713,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(); @@ -44707,36 +44727,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(); @@ -44744,18 +44764,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(); @@ -44763,13 +44783,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(); @@ -44777,36 +44797,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(); @@ -44814,18 +44834,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(); @@ -44833,13 +44853,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(); @@ -44847,36 +44867,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(); @@ -44884,18 +44904,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(); @@ -44903,13 +44923,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(); @@ -44917,36 +44937,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(); @@ -44954,18 +44974,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(); @@ -44973,13 +44993,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(); @@ -44987,36 +45007,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(); @@ -45024,18 +45044,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(); @@ -45043,13 +45063,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(); @@ -45057,13 +45077,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(); @@ -45071,26 +45091,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(); @@ -45098,13 +45118,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(); @@ -45112,13 +45132,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(); @@ -45126,13 +45146,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(); @@ -45140,26 +45160,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(); @@ -45167,13 +45187,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(); @@ -45181,13 +45201,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(); @@ -45195,13 +45215,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(); @@ -45209,26 +45229,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(); @@ -45236,13 +45256,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(); @@ -45250,13 +45270,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(); @@ -45264,26 +45284,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(); @@ -45291,27 +45311,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(); @@ -45319,36 +45339,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(); @@ -45356,26 +45376,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(); @@ -45383,23 +45403,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(); @@ -45407,31 +45427,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(); @@ -45439,28 +45459,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, @@ -45468,8 +45488,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(); @@ -45479,13 +45499,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; @@ -45501,98 +45521,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; @@ -45600,8 +45620,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; @@ -45609,8 +45629,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; @@ -45618,8 +45638,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; @@ -45627,13 +45647,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; @@ -45641,13 +45661,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; @@ -45655,13 +45675,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; @@ -45669,99 +45689,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; @@ -45769,8 +45789,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; @@ -45778,8 +45798,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; @@ -45787,8 +45807,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; @@ -45796,13 +45816,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; @@ -45810,13 +45830,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; @@ -45824,13 +45844,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; @@ -45838,18 +45858,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(); @@ -45858,8 +45878,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(); @@ -45868,8 +45888,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(); @@ -45878,8 +45898,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(); @@ -45888,13 +45908,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(); @@ -45903,13 +45923,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(); @@ -45918,13 +45938,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(); @@ -45933,13 +45953,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(); @@ -45947,18 +45967,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(); @@ -45967,8 +45987,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(); @@ -45977,8 +45997,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(); @@ -45987,8 +46007,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(); @@ -45997,13 +46017,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(); @@ -46012,13 +46032,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(); @@ -46027,13 +46047,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(); @@ -46042,13 +46062,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(); @@ -46056,18 +46076,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(); @@ -46076,8 +46096,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(); @@ -46086,8 +46106,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(); @@ -46096,8 +46116,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(); @@ -46106,13 +46126,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(); @@ -46121,13 +46141,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(); @@ -46136,13 +46156,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(); @@ -46151,13 +46171,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(); @@ -46165,18 +46185,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(); @@ -46185,8 +46205,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(); @@ -46195,8 +46215,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(); @@ -46205,8 +46225,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(); @@ -46215,13 +46235,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(); @@ -46230,13 +46250,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(); @@ -46245,13 +46265,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(); @@ -46260,13 +46280,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(); @@ -46274,49 +46294,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; @@ -46332,8 +46352,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); } @@ -47418,7 +47438,7 @@ class TestEventsSuite : public TestCommand chip::app::Clusters::TestCluster::Events::TestEvent::DecodableType value; VerifyOrReturn(CheckDecodeValue(chip::app::DataModel::Decode(*data, value))); VerifyOrReturn(CheckValue("testEvent.arg1", value.arg1, 4U)); - VerifyOrReturn(CheckValue("testEvent.arg2", value.arg2, 5U)); + VerifyOrReturn(CheckValue("testEvent.arg2", value.arg2, 3U)); VerifyOrReturn(CheckValue("testEvent.arg3", value.arg3, true)); } shouldContinue = true; @@ -47522,7 +47542,7 @@ class TestEventsSuite : public TestCommand ListFreer listFreer; chip::app::Clusters::TestCluster::Commands::TestEmitTestEventRequest::Type value; value.arg1 = 4U; - value.arg2 = static_cast(5); + value.arg2 = static_cast(3); value.arg3 = true; return SendCommand(kIdentityAlpha, GetEndpoint(1), TestCluster::Id, TestCluster::Commands::TestEmitTestEventRequest::Id, value, 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 2489e4e4229c8d..bcbf82b50dca4e 100644 --- a/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h +++ b/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h @@ -64149,890 +64149,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( @@ -65040,552 +65039,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; } @@ -66163,10 +66167,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)); @@ -66184,10 +66188,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)); @@ -66202,10 +66206,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)); @@ -66220,10 +66224,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)); @@ -66244,10 +66248,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)); @@ -66286,10 +66290,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)); @@ -66325,10 +66329,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)); @@ -66364,10 +66368,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)); @@ -66397,10 +66401,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)); @@ -66430,10 +66434,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)); @@ -66463,10 +66467,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)); @@ -66496,10 +66500,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)); @@ -66595,10 +66599,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)); @@ -66619,10 +66623,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)); @@ -66643,10 +66647,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)); @@ -66709,16 +66713,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)); @@ -66736,7 +66740,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)); @@ -66748,7 +66752,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)); @@ -66772,7 +66776,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)); @@ -66784,7 +66788,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)); @@ -66808,7 +66812,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)); @@ -66820,7 +66824,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)); @@ -66844,7 +66848,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)); @@ -66856,7 +66860,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)); @@ -66880,7 +66884,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)); @@ -66892,7 +66896,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)); @@ -66922,7 +66926,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)); @@ -66934,7 +66938,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)); @@ -66964,7 +66968,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)); @@ -66976,7 +66980,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)); @@ -67006,7 +67010,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)); @@ -67018,7 +67022,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)); @@ -67045,19 +67049,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)); @@ -67068,6 +67072,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. @@ -67081,7 +67088,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; @@ -70786,7 +70793,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) { @@ -70801,7 +70808,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(); @@ -70810,7 +70851,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 @@ -70847,7 +70888,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 @@ -70884,7 +70925,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 @@ -70932,7 +70973,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 @@ -70980,7 +71021,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 @@ -71074,7 +71115,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 @@ -71168,7 +71209,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 @@ -71215,7 +71256,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 @@ -71256,7 +71297,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 @@ -71297,7 +71338,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 @@ -71346,7 +71387,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 @@ -71378,7 +71419,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 @@ -71431,7 +71472,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 @@ -71484,7 +71525,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 @@ -71584,7 +71625,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 @@ -71684,7 +71725,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 @@ -71713,7 +71754,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 @@ -71741,7 +71782,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 @@ -71770,7 +71811,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 @@ -71798,7 +71839,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 @@ -71839,7 +71880,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 @@ -71875,7 +71916,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 @@ -71919,7 +71960,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 @@ -71946,7 +71987,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 @@ -71979,7 +72020,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 @@ -72017,7 +72058,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 @@ -72057,7 +72098,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 @@ -72080,7 +72121,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 @@ -72107,7 +72148,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 @@ -72129,7 +72170,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 @@ -72154,7 +72195,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 @@ -72177,7 +72218,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 @@ -72199,7 +72240,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 @@ -72224,7 +72265,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 @@ -72247,7 +72288,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 @@ -72275,7 +72316,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 @@ -72297,7 +72338,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 @@ -72321,7 +72362,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 @@ -72344,7 +72385,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 @@ -72366,7 +72407,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 @@ -72391,7 +72432,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 @@ -72413,7 +72454,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 @@ -72438,7 +72479,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 @@ -72460,7 +72501,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 @@ -72484,7 +72525,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 @@ -72506,7 +72547,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 @@ -72531,7 +72572,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 @@ -72553,7 +72594,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 @@ -72578,7 +72619,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 @@ -72600,7 +72641,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 @@ -72624,7 +72665,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 @@ -72646,7 +72687,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 @@ -72671,7 +72712,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 @@ -72693,7 +72734,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 @@ -72718,7 +72759,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 @@ -72740,7 +72781,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 @@ -72764,7 +72805,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 @@ -72786,7 +72827,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 @@ -72811,7 +72852,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 @@ -72833,7 +72874,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 @@ -72858,7 +72899,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 @@ -72879,7 +72920,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 @@ -72904,7 +72945,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 @@ -72927,7 +72968,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 @@ -72949,7 +72990,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 @@ -72973,7 +73014,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 @@ -72998,7 +73039,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 @@ -73021,7 +73062,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 @@ -73043,7 +73084,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 @@ -73068,7 +73109,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 @@ -73091,7 +73132,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 @@ -73113,7 +73154,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 @@ -73138,7 +73179,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 @@ -73160,7 +73201,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 @@ -73185,7 +73226,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 @@ -73207,7 +73248,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 @@ -73232,7 +73273,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 @@ -73254,7 +73295,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 @@ -73278,7 +73319,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 @@ -73303,7 +73344,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 @@ -73326,7 +73367,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 @@ -73348,7 +73389,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 @@ -73373,7 +73414,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 @@ -73396,7 +73437,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 @@ -73418,7 +73459,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 @@ -73443,7 +73484,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 @@ -73465,7 +73506,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 @@ -73490,7 +73531,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 @@ -73512,7 +73553,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 @@ -73537,7 +73578,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 @@ -73559,7 +73600,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 @@ -73583,7 +73624,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 @@ -73608,7 +73649,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 @@ -73631,7 +73672,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 @@ -73653,7 +73694,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 @@ -73678,7 +73719,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 @@ -73701,7 +73742,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 @@ -73723,7 +73764,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 @@ -73748,7 +73789,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 @@ -73770,7 +73811,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 @@ -73795,7 +73836,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 @@ -73817,7 +73858,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 @@ -73842,7 +73883,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 @@ -73864,7 +73905,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 @@ -73888,7 +73929,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 @@ -73914,7 +73955,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 @@ -73937,7 +73978,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 @@ -73959,7 +74000,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 @@ -73985,7 +74026,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 @@ -74008,7 +74049,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 @@ -74030,7 +74071,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 @@ -74055,7 +74096,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 @@ -74076,7 +74117,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 @@ -74101,7 +74142,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 @@ -74123,7 +74164,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 @@ -74147,7 +74188,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 @@ -74172,7 +74213,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 @@ -74195,7 +74236,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 @@ -74217,7 +74258,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 @@ -74242,7 +74283,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 @@ -74265,7 +74306,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 @@ -74287,7 +74328,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 @@ -74312,7 +74353,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 @@ -74334,7 +74375,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 @@ -74359,7 +74400,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 @@ -74381,7 +74422,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 @@ -74405,7 +74446,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 @@ -74430,7 +74471,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 @@ -74453,7 +74494,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 @@ -74475,7 +74516,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 @@ -74500,7 +74541,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 @@ -74523,7 +74564,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 @@ -74545,7 +74586,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 @@ -74570,7 +74611,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 @@ -74592,7 +74633,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 @@ -74617,7 +74658,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 @@ -74639,7 +74680,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 @@ -74663,7 +74704,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 @@ -74688,7 +74729,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 @@ -74711,7 +74752,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 @@ -74733,7 +74774,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 @@ -74758,7 +74799,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 @@ -74781,7 +74822,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 @@ -74803,7 +74844,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 @@ -74828,7 +74869,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 @@ -74850,7 +74891,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 @@ -74875,7 +74916,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 @@ -74897,7 +74938,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 @@ -74921,7 +74962,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 @@ -74946,7 +74987,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 @@ -74969,7 +75010,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 @@ -74991,7 +75032,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 @@ -75016,7 +75057,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 @@ -75039,7 +75080,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 @@ -75061,7 +75102,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 @@ -75086,7 +75127,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 @@ -75108,7 +75149,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 @@ -75133,7 +75174,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 @@ -75155,7 +75196,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 @@ -75180,7 +75221,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 @@ -75202,7 +75243,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 @@ -75226,7 +75267,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 @@ -75248,7 +75289,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 @@ -75273,7 +75314,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 @@ -75295,7 +75336,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 @@ -75320,7 +75361,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 @@ -75342,7 +75383,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 @@ -75367,7 +75408,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 @@ -75389,7 +75430,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 @@ -75414,7 +75455,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 @@ -75436,7 +75477,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 @@ -75460,7 +75501,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 @@ -75482,7 +75523,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 @@ -75507,7 +75548,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 @@ -75529,7 +75570,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 @@ -75554,7 +75595,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 @@ -75576,7 +75617,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 @@ -75601,7 +75642,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 @@ -75622,7 +75663,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 @@ -75647,7 +75688,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 @@ -75669,7 +75710,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 @@ -75693,7 +75734,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 @@ -75715,7 +75756,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 @@ -75740,7 +75781,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 @@ -75762,7 +75803,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 @@ -75787,7 +75828,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 @@ -75809,7 +75850,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 @@ -75834,7 +75875,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 @@ -75856,7 +75897,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 @@ -75880,7 +75921,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 @@ -75902,7 +75943,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 @@ -75927,7 +75968,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 @@ -75936,7 +75977,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); @@ -75949,7 +75990,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 @@ -75965,7 +76006,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(); @@ -75974,7 +76015,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 @@ -75995,9 +76036,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 @@ -76013,10 +76054,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(); @@ -76025,7 +76066,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 @@ -76047,7 +76088,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 @@ -76071,7 +76112,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 @@ -76080,13 +76121,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(); }]; @@ -76094,7 +76135,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 @@ -76120,7 +76161,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 @@ -76143,7 +76184,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 @@ -76172,7 +76213,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 @@ -76194,7 +76235,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 @@ -76218,7 +76259,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 @@ -76240,7 +76281,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 @@ -76266,7 +76307,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 @@ -76289,7 +76330,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 @@ -76314,7 +76355,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 @@ -76337,7 +76378,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 @@ -76365,7 +76406,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 @@ -76394,7 +76435,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 @@ -76416,7 +76457,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 @@ -76440,7 +76481,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 @@ -76462,7 +76503,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 @@ -76487,7 +76528,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 @@ -76510,7 +76551,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 @@ -76528,7 +76569,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 @@ -76546,7 +76587,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 @@ -76568,7 +76609,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 @@ -76591,10 +76632,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 @@ -76616,14 +76657,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 @@ -76639,7 +76680,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) { @@ -76656,7 +76697,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 @@ -76685,7 +76726,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 @@ -76713,7 +76754,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 @@ -76737,7 +76778,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 @@ -76760,7 +76801,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 @@ -76784,7 +76825,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 @@ -76808,7 +76849,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 @@ -76831,7 +76872,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 @@ -76855,7 +76896,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 @@ -76879,7 +76920,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 @@ -76903,7 +76944,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 @@ -76927,7 +76968,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 @@ -76951,7 +76992,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 @@ -76975,7 +77016,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 @@ -76999,7 +77040,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 @@ -77023,7 +77064,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 @@ -77046,7 +77087,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 @@ -77070,7 +77111,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 @@ -77094,7 +77135,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 @@ -77117,7 +77158,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 @@ -77141,7 +77182,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 @@ -77165,7 +77206,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 @@ -77189,7 +77230,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 @@ -77213,7 +77254,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 @@ -77237,7 +77278,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 @@ -77262,7 +77303,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 @@ -77286,7 +77327,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 @@ -77310,7 +77351,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 @@ -77332,7 +77373,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 @@ -77357,7 +77398,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 @@ -77382,7 +77423,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 @@ -77404,7 +77445,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 @@ -77428,7 +77469,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 @@ -77451,7 +77492,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 @@ -77475,7 +77516,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 @@ -77498,7 +77539,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 @@ -77522,7 +77563,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 @@ -77546,7 +77587,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 @@ -77570,7 +77611,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 @@ -77594,7 +77635,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 @@ -77617,7 +77658,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 @@ -77641,7 +77682,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 @@ -77665,7 +77706,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 @@ -77688,7 +77729,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 @@ -77712,7 +77753,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 @@ -77736,7 +77777,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 @@ -77760,7 +77801,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 @@ -77784,7 +77825,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 @@ -77808,7 +77849,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 @@ -77832,7 +77873,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 @@ -77856,7 +77897,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 @@ -77882,7 +77923,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 @@ -77906,7 +77947,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 @@ -77930,7 +77971,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 @@ -77954,7 +77995,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 @@ -77978,7 +78019,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 @@ -78004,7 +78045,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 @@ -78028,7 +78069,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 @@ -78054,7 +78095,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 @@ -78078,7 +78119,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 @@ -78104,7 +78145,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 @@ -78128,7 +78169,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 @@ -78154,7 +78195,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 @@ -78178,7 +78219,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 @@ -78203,7 +78244,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 @@ -78229,7 +78270,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 @@ -78253,7 +78294,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 @@ -78277,7 +78318,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 @@ -78301,7 +78342,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 @@ -78325,7 +78366,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 @@ -78351,7 +78392,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 @@ -78375,7 +78416,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 @@ -78401,7 +78442,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 @@ -78425,7 +78466,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 @@ -78451,7 +78492,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 @@ -78475,7 +78516,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 @@ -78501,7 +78542,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 @@ -78525,7 +78566,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 @@ -78550,7 +78591,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 @@ -78576,7 +78617,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 @@ -78600,7 +78641,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 @@ -78624,7 +78665,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 @@ -78648,7 +78689,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 @@ -78672,7 +78713,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 @@ -78698,7 +78739,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 @@ -78722,7 +78763,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 @@ -78748,7 +78789,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 @@ -78772,7 +78813,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 @@ -78798,7 +78839,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 @@ -78822,7 +78863,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 @@ -78848,7 +78889,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 @@ -78872,7 +78913,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 @@ -78897,7 +78938,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 @@ -78923,7 +78964,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 @@ -78947,7 +78988,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 @@ -78971,7 +79012,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 @@ -78995,7 +79036,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 @@ -79019,7 +79060,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 @@ -79045,7 +79086,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 @@ -79069,7 +79110,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 @@ -79095,7 +79136,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 @@ -79119,7 +79160,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 @@ -79145,7 +79186,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 @@ -79169,7 +79210,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 @@ -79195,7 +79236,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 @@ -79219,7 +79260,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 @@ -79244,7 +79285,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 @@ -79266,7 +79307,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 @@ -79288,7 +79329,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 @@ -79306,7 +79347,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 @@ -79324,7 +79365,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 @@ -79366,7 +79407,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 @@ -79399,7 +79440,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 @@ -79430,7 +79471,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