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..2a6ac5a1f3ed35 100644 --- a/src/app/zap-templates/templates/app/cluster-enums.zapt +++ b/src/app/zap-templates/templates/app/cluster-enums.zapt @@ -24,11 +24,13 @@ enum class {{asType label}} : {{asUnderlyingZclType name}} { {{#zcl_enum_items}} k{{asUpperCamelCase label}} = {{asHex value 2}}, {{/zcl_enum_items}} +// kUnknownEnumValue = {{first_unused_enum_value mode="first_unused"}}, }; {{#if (isWeaklyTypedEnum label)}} #else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM using {{asType label}} = EmberAf{{asType label}}; -#endif +static {{asType label}} __attribute__((unused)) k{{asType label}}kUnknownEnumValue = static_cast<{{asType label}}>({{first_unused_enum_value mode="first_unused"}}); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM {{/if}} {{/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..2bca6b715cf75d --- /dev/null +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-enums-check.h @@ -0,0 +1,2059 @@ +/* + * + * 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(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(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..a4d2fb55fc34cc 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 @@ -47,10 +47,13 @@ enum class IdentifyEffectIdentifier : uint8_t kChannelChange = 0x0B, kFinishEffect = 0xFE, kStopEffect = 0xFF, + // kUnknownEnumValue = 3, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using IdentifyEffectIdentifier = EmberAfIdentifyEffectIdentifier; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using IdentifyEffectIdentifier = EmberAfIdentifyEffectIdentifier; +static IdentifyEffectIdentifier __attribute__((unused)) kIdentifyEffectIdentifierkUnknownEnumValue = + static_cast(3); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -59,10 +62,13 @@ using IdentifyEffectIdentifier = EmberAfIdentifyEffectIdentifier; enum class IdentifyEffectVariant : uint8_t { kDefault = 0x00, + // kUnknownEnumValue = 1, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using IdentifyEffectVariant = EmberAfIdentifyEffectVariant; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using IdentifyEffectVariant = EmberAfIdentifyEffectVariant; +static IdentifyEffectVariant __attribute__((unused)) kIdentifyEffectVariantkUnknownEnumValue = + static_cast(1); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -76,10 +82,12 @@ enum class IdentifyIdentifyType : uint8_t kAudibleBeep = 0x03, kDisplay = 0x04, kActuator = 0x05, + // kUnknownEnumValue = 6, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using IdentifyIdentifyType = EmberAfIdentifyIdentifyType; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using IdentifyIdentifyType = EmberAfIdentifyIdentifyType; +static IdentifyIdentifyType __attribute__((unused)) kIdentifyIdentifyTypekUnknownEnumValue = static_cast(6); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM } // namespace Identify namespace Groups { @@ -111,10 +119,13 @@ enum class OnOffDelayedAllOffEffectVariant : uint8_t kFadeToOffIn0p8Seconds = 0x00, kNoFade = 0x01, k50PercentDimDownIn0p8SecondsThenFadeToOffIn12Seconds = 0x02, + // kUnknownEnumValue = 3, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using OnOffDelayedAllOffEffectVariant = EmberAfOnOffDelayedAllOffEffectVariant; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using OnOffDelayedAllOffEffectVariant = EmberAfOnOffDelayedAllOffEffectVariant; +static OnOffDelayedAllOffEffectVariant __attribute__((unused)) kOnOffDelayedAllOffEffectVariantkUnknownEnumValue = + static_cast(3); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -123,10 +134,13 @@ using OnOffDelayedAllOffEffectVariant = EmberAfOnOffDelayedAllOffEffectVariant; enum class OnOffDyingLightEffectVariant : uint8_t { k20PercenterDimUpIn0p5SecondsThenFadeToOffIn1Second = 0x00, + // kUnknownEnumValue = 1, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using OnOffDyingLightEffectVariant = EmberAfOnOffDyingLightEffectVariant; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using OnOffDyingLightEffectVariant = EmberAfOnOffDyingLightEffectVariant; +static OnOffDyingLightEffectVariant __attribute__((unused)) kOnOffDyingLightEffectVariantkUnknownEnumValue = + static_cast(1); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -136,10 +150,13 @@ enum class OnOffEffectIdentifier : uint8_t { kDelayedAllOff = 0x00, kDyingLight = 0x01, + // kUnknownEnumValue = 2, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using OnOffEffectIdentifier = EmberAfOnOffEffectIdentifier; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using OnOffEffectIdentifier = EmberAfOnOffEffectIdentifier; +static OnOffEffectIdentifier __attribute__((unused)) kOnOffEffectIdentifierkUnknownEnumValue = + static_cast(2); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Enum for OnOffStartUpOnOff enum class OnOffStartUpOnOff : uint8_t @@ -147,6 +164,7 @@ enum class OnOffStartUpOnOff : uint8_t kOff = 0x00, kOn = 0x01, kTogglePreviousOnOff = 0x02, + // kUnknownEnumValue = 3, }; // Bitmap for OnOffControl @@ -181,10 +199,12 @@ enum class MoveMode : uint8_t { kUp = 0x00, kDown = 0x01, + // kUnknownEnumValue = 2, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using MoveMode = EmberAfMoveMode; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using MoveMode = EmberAfMoveMode; +static MoveMode __attribute__((unused)) kMoveModekUnknownEnumValue = static_cast(2); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -194,10 +214,12 @@ enum class StepMode : uint8_t { kUp = 0x00, kDown = 0x01, + // kUnknownEnumValue = 2, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using StepMode = EmberAfStepMode; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using StepMode = EmberAfStepMode; +static StepMode __attribute__((unused)) kStepModekUnknownEnumValue = static_cast(2); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Bitmap for LevelControlFeature enum class LevelControlFeature : uint32_t @@ -293,6 +315,7 @@ enum class AuthMode : uint8_t kPase = 0x01, kCase = 0x02, kGroup = 0x03, + // kUnknownEnumValue = 0, }; // Enum for ChangeTypeEnum @@ -301,6 +324,7 @@ enum class ChangeTypeEnum : uint8_t kChanged = 0x00, kAdded = 0x01, kRemoved = 0x02, + // kUnknownEnumValue = 3, }; // Enum for Privilege @@ -311,6 +335,7 @@ enum class Privilege : uint8_t kOperate = 0x03, kManage = 0x04, kAdminister = 0x05, + // kUnknownEnumValue = 0, }; } // namespace AccessControl @@ -324,6 +349,7 @@ enum class ActionErrorEnum : uint8_t { kUnknown = 0x00, kInterrupted = 0x01, + // kUnknownEnumValue = 2, }; // Enum for ActionStateEnum @@ -333,6 +359,7 @@ enum class ActionStateEnum : uint8_t kActive = 0x01, kPaused = 0x02, kDisabled = 0x03, + // kUnknownEnumValue = 4, }; // Enum for ActionTypeEnum @@ -345,6 +372,7 @@ enum class ActionTypeEnum : uint8_t kException = 0x04, kNotification = 0x05, kAlarm = 0x06, + // kUnknownEnumValue = 7, }; // Enum for EndpointListTypeEnum @@ -353,6 +381,7 @@ enum class EndpointListTypeEnum : uint8_t kOther = 0x00, kRoom = 0x01, kZone = 0x02, + // kUnknownEnumValue = 3, }; // Bitmap for CommandBits @@ -384,6 +413,7 @@ enum class OTAApplyUpdateAction : uint8_t kProceed = 0x00, kAwaitNextAction = 0x01, kDiscontinue = 0x02, + // kUnknownEnumValue = 3, }; // Enum for OTADownloadProtocol @@ -393,6 +423,7 @@ enum class OTADownloadProtocol : uint8_t kBDXAsynchronous = 0x01, kHttps = 0x02, kVendorSpecific = 0x03, + // kUnknownEnumValue = 4, }; // Enum for OTAQueryStatus @@ -402,6 +433,7 @@ enum class OTAQueryStatus : uint8_t kBusy = 0x01, kNotAvailable = 0x02, kDownloadProtocolNotSupported = 0x03, + // kUnknownEnumValue = 4, }; } // namespace OtaSoftwareUpdateProvider @@ -413,6 +445,7 @@ enum class OTAAnnouncementReason : uint8_t kSimpleAnnouncement = 0x00, kUpdateAvailable = 0x01, kUrgentUpdateAvailable = 0x02, + // kUnknownEnumValue = 3, }; // Enum for OTAChangeReasonEnum @@ -423,6 +456,7 @@ enum class OTAChangeReasonEnum : uint8_t kFailure = 0x02, kTimeOut = 0x03, kDelayByProvider = 0x04, + // kUnknownEnumValue = 5, }; // Enum for OTAUpdateStateEnum @@ -437,6 +471,7 @@ enum class OTAUpdateStateEnum : uint8_t kDelayedOnApply = 0x06, kRollingBack = 0x07, kDelayedOnUserConsent = 0x08, + // kUnknownEnumValue = 9, }; } // namespace OtaSoftwareUpdateRequestor @@ -460,6 +495,7 @@ enum class CalendarType : uint8_t kKorean = 0x09, kPersian = 0x0A, kTaiwanese = 0x0B, + // kUnknownEnumValue = 12, }; // Enum for HourFormat @@ -467,6 +503,7 @@ enum class HourFormat : uint8_t { k12hr = 0x00, k24hr = 0x01, + // kUnknownEnumValue = 2, }; } // namespace TimeFormatLocalization @@ -478,6 +515,7 @@ enum class TempUnit : uint8_t kFahrenheit = 0x00, kCelsius = 0x01, kKelvin = 0x02, + // kUnknownEnumValue = 3, }; // Bitmap for UnitLocalizationFeature @@ -506,6 +544,7 @@ enum class BatChargeFault : uint8_t kChargerOverVoltage = 0x08, kChargerUnderVoltage = 0x09, kSafetyTimeout = 0x0A, + // kUnknownEnumValue = 11, }; // Enum for BatChargeLevel @@ -514,6 +553,7 @@ enum class BatChargeLevel : uint8_t kOk = 0x00, kWarning = 0x01, kCritical = 0x02, + // kUnknownEnumValue = 3, }; // Enum for BatChargeState @@ -523,6 +563,7 @@ enum class BatChargeState : uint8_t kIsCharging = 0x01, kIsAtFullCharge = 0x02, kIsNotCharging = 0x03, + // kUnknownEnumValue = 4, }; // Enum for BatFault @@ -531,6 +572,7 @@ enum class BatFault : uint8_t kUnspecfied = 0x00, kOverTemp = 0x01, kUnderTemp = 0x02, + // kUnknownEnumValue = 3, }; // Enum for BatReplaceability @@ -540,6 +582,7 @@ enum class BatReplaceability : uint8_t kNotReplaceable = 0x01, kUserReplaceable = 0x02, kFactoryReplaceable = 0x03, + // kUnknownEnumValue = 4, }; // Enum for PowerSourceStatus @@ -549,6 +592,7 @@ enum class PowerSourceStatus : uint8_t kActive = 0x01, kStandby = 0x02, kUnavailable = 0x03, + // kUnknownEnumValue = 4, }; // Enum for WiredCurrentType @@ -556,6 +600,7 @@ enum class WiredCurrentType : uint8_t { kAc = 0x00, kDc = 0x01, + // kUnknownEnumValue = 2, }; // Enum for WiredFault @@ -564,6 +609,7 @@ enum class WiredFault : uint8_t kUnspecfied = 0x00, kOverVoltage = 0x01, kUnderVoltage = 0x02, + // kUnknownEnumValue = 3, }; // Bitmap for PowerSourceFeature @@ -586,6 +632,7 @@ enum class CommissioningError : uint8_t kInvalidAuthentication = 0x02, kNoFailSafe = 0x03, kBusyWithOtherAdmin = 0x04, + // kUnknownEnumValue = 5, }; // Enum for RegulatoryLocationType @@ -594,6 +641,7 @@ enum class RegulatoryLocationType : uint8_t kIndoor = 0x00, kOutdoor = 0x01, kIndoorOutdoor = 0x02, + // kUnknownEnumValue = 3, }; } // namespace GeneralCommissioning @@ -615,6 +663,7 @@ enum class NetworkCommissioningStatus : uint8_t kIPV6Failed = 0x0A, kIPBindFailed = 0x0B, kUnknownError = 0x0C, + // kUnknownEnumValue = 13, }; // Enum for WiFiBand @@ -625,6 +674,7 @@ enum class WiFiBand : uint8_t k5g = 0x02, k6g = 0x03, k60g = 0x04, + // kUnknownEnumValue = 5, }; // Bitmap for NetworkCommissioningFeature @@ -654,6 +704,7 @@ enum class LogsIntent : uint8_t kEndUserSupport = 0x00, kNetworkDiag = 0x01, kCrashLogs = 0x02, + // kUnknownEnumValue = 3, }; // Enum for LogsStatus @@ -664,6 +715,7 @@ enum class LogsStatus : uint8_t kNoLogs = 0x02, kBusy = 0x03, kDenied = 0x04, + // kUnknownEnumValue = 5, }; // Enum for LogsTransferProtocol @@ -671,6 +723,7 @@ enum class LogsTransferProtocol : uint8_t { kResponsePayload = 0x00, kBdx = 0x01, + // kUnknownEnumValue = 2, }; } // namespace DiagnosticLogs @@ -686,6 +739,7 @@ enum class BootReasonType : uint8_t kHardwareWatchdogReset = 0x04, kSoftwareUpdateCompleted = 0x05, kSoftwareReset = 0x06, + // kUnknownEnumValue = 7, }; // Need to convert consumers to using the new enum classes, so we @@ -705,10 +759,12 @@ enum class HardwareFaultType : uint8_t kUserInterfaceFault = 0x08, kNonVolatileMemoryError = 0x09, kTamperDetected = 0x0A, + // kUnknownEnumValue = 11, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using HardwareFaultType = EmberAfHardwareFaultType; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using HardwareFaultType = EmberAfHardwareFaultType; +static HardwareFaultType __attribute__((unused)) kHardwareFaultTypekUnknownEnumValue = static_cast(11); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -721,10 +777,12 @@ enum class InterfaceType : uint8_t kEthernet = 0x02, kCellular = 0x03, kThread = 0x04, + // kUnknownEnumValue = 5, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using InterfaceType = EmberAfInterfaceType; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using InterfaceType = EmberAfInterfaceType; +static InterfaceType __attribute__((unused)) kInterfaceTypekUnknownEnumValue = static_cast(5); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -736,10 +794,12 @@ enum class NetworkFaultType : uint8_t kHardwareFailure = 0x01, kNetworkJammed = 0x02, kConnectionFailed = 0x03, + // kUnknownEnumValue = 4, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using NetworkFaultType = EmberAfNetworkFaultType; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using NetworkFaultType = EmberAfNetworkFaultType; +static NetworkFaultType __attribute__((unused)) kNetworkFaultTypekUnknownEnumValue = static_cast(4); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -754,10 +814,12 @@ enum class RadioFaultType : uint8_t kNFCFault = 0x04, kBLEFault = 0x05, kEthernetFault = 0x06, + // kUnknownEnumValue = 7, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using RadioFaultType = EmberAfRadioFaultType; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using RadioFaultType = EmberAfRadioFaultType; +static RadioFaultType __attribute__((unused)) kRadioFaultTypekUnknownEnumValue = static_cast(7); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM } // namespace GeneralDiagnostics namespace SoftwareDiagnostics { @@ -778,6 +840,7 @@ enum class NetworkFault : uint8_t kLinkDown = 0x01, kHardwareFailure = 0x02, kNetworkJammed = 0x03, + // kUnknownEnumValue = 4, }; // Need to convert consumers to using the new enum classes, so we @@ -793,16 +856,19 @@ enum class RoutingRole : uint8_t kReed = 0x04, kRouter = 0x05, kLeader = 0x06, + // kUnknownEnumValue = 7, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using RoutingRole = EmberAfRoutingRole; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using RoutingRole = EmberAfRoutingRole; +static RoutingRole __attribute__((unused)) kRoutingRolekUnknownEnumValue = static_cast(7); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Enum for ThreadConnectionStatus enum class ThreadConnectionStatus : uint8_t { kConnected = 0x00, kNotConnected = 0x01, + // kUnknownEnumValue = 2, }; // Bitmap for ThreadNetworkDiagnosticsFeature @@ -824,6 +890,7 @@ enum class AssociationFailureCause : uint8_t kAssociationFailed = 0x01, kAuthenticationFailed = 0x02, kSsidNotFound = 0x03, + // kUnknownEnumValue = 4, }; // Need to convert consumers to using the new enum classes, so we @@ -838,16 +905,19 @@ enum class SecurityType : uint8_t kWpa = 0x03, kWpa2 = 0x04, kWpa3 = 0x05, + // kUnknownEnumValue = 6, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using SecurityType = EmberAfSecurityType; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using SecurityType = EmberAfSecurityType; +static SecurityType __attribute__((unused)) kSecurityTypekUnknownEnumValue = static_cast(6); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Enum for WiFiConnectionStatus enum class WiFiConnectionStatus : uint8_t { kConnected = 0x00, kNotConnected = 0x01, + // kUnknownEnumValue = 2, }; // Need to convert consumers to using the new enum classes, so we @@ -862,10 +932,12 @@ enum class WiFiVersionType : uint8_t k80211n = 0x03, k80211ac = 0x04, k80211ax = 0x05, + // kUnknownEnumValue = 6, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using WiFiVersionType = EmberAfWiFiVersionType; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using WiFiVersionType = EmberAfWiFiVersionType; +static WiFiVersionType __attribute__((unused)) kWiFiVersionTypekUnknownEnumValue = static_cast(6); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM } // namespace WiFiNetworkDiagnostics namespace EthernetNetworkDiagnostics { @@ -886,10 +958,12 @@ enum class PHYRateType : uint8_t k100g = 0x07, k200g = 0x08, k400g = 0x09, + // kUnknownEnumValue = 10, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using PHYRateType = EmberAfPHYRateType; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using PHYRateType = EmberAfPHYRateType; +static PHYRateType __attribute__((unused)) kPHYRateTypekUnknownEnumValue = static_cast(10); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM } // namespace EthernetNetworkDiagnostics namespace TimeSynchronization { @@ -909,6 +983,7 @@ enum class CommissioningWindowStatus : uint8_t kWindowNotOpen = 0x00, kEnhancedWindowOpen = 0x01, kBasicWindowOpen = 0x02, + // kUnknownEnumValue = 3, }; // Need to convert consumers to using the new enum classes, so we @@ -920,10 +995,12 @@ enum class StatusCode : uint8_t kBusy = 0x01, kPAKEParameterError = 0x02, kWindowNotOpen = 0x03, + // kUnknownEnumValue = 0, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using StatusCode = EmberAfStatusCode; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using StatusCode = EmberAfStatusCode; +static StatusCode __attribute__((unused)) kStatusCodekUnknownEnumValue = static_cast(0); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM } // namespace AdministratorCommissioning namespace OperationalCredentials { @@ -942,6 +1019,7 @@ enum class OperationalCertStatus : uint8_t kFabricConflict = 0x09, kLabelConflict = 0x0A, kInvalidFabricIndex = 0x0B, + // kUnknownEnumValue = 7, }; } // namespace OperationalCredentials @@ -952,6 +1030,7 @@ enum class GroupKeySecurityPolicy : uint8_t { kTrustFirst = 0x00, kCacheAndSync = 0x01, + // kUnknownEnumValue = 2, }; } // namespace GroupKeyManagement @@ -998,6 +1077,7 @@ enum class DlAlarmCode : uint8_t kDoorForcedOpen = 0x06, kDoorAjar = 0x07, kForcedUser = 0x08, + // kUnknownEnumValue = 2, }; // Enum for DlCredentialRule @@ -1006,6 +1086,7 @@ enum class DlCredentialRule : uint8_t kSingle = 0x00, kDouble = 0x01, kTri = 0x02, + // kUnknownEnumValue = 3, }; // Enum for DlCredentialType @@ -1017,6 +1098,7 @@ enum class DlCredentialType : uint8_t kFingerprint = 0x03, kFingerVein = 0x04, kFace = 0x05, + // kUnknownEnumValue = 6, }; // Enum for DlDataOperationType @@ -1025,6 +1107,7 @@ enum class DlDataOperationType : uint8_t kAdd = 0x00, kClear = 0x01, kModify = 0x02, + // kUnknownEnumValue = 3, }; // Enum for DlDoorState @@ -1036,6 +1119,7 @@ enum class DlDoorState : uint8_t kDoorForcedOpen = 0x03, kDoorUnspecifiedError = 0x04, kDoorAjar = 0x05, + // kUnknownEnumValue = 6, }; // Enum for DlLockDataType @@ -1050,6 +1134,7 @@ enum class DlLockDataType : uint8_t kPin = 0x06, kRfid = 0x07, kFingerprint = 0x08, + // kUnknownEnumValue = 9, }; // Enum for DlLockOperationType @@ -1059,6 +1144,7 @@ enum class DlLockOperationType : uint8_t kUnlock = 0x01, kNonAccessUserEvent = 0x02, kForcedUserEvent = 0x03, + // kUnknownEnumValue = 4, }; // Enum for DlLockState @@ -1067,6 +1153,7 @@ enum class DlLockState : uint8_t kNotFullyLocked = 0x00, kLocked = 0x01, kUnlocked = 0x02, + // kUnknownEnumValue = 3, }; // Enum for DlLockType @@ -1083,6 +1170,7 @@ enum class DlLockType : uint8_t kInterconnectedLock = 0x08, kDeadLatch = 0x09, kDoorFurniture = 0x0A, + // kUnknownEnumValue = 11, }; // Enum for DlOperatingMode @@ -1093,6 +1181,7 @@ enum class DlOperatingMode : uint8_t kPrivacy = 0x02, kNoRemoteLockUnlock = 0x03, kPassage = 0x04, + // kUnknownEnumValue = 5, }; // Enum for DlOperationError @@ -1103,6 +1192,7 @@ enum class DlOperationError : uint8_t kDisabledUserDenied = 0x02, kRestricted = 0x03, kInsufficientBattery = 0x04, + // kUnknownEnumValue = 5, }; // Enum for DlOperationSource @@ -1118,6 +1208,7 @@ enum class DlOperationSource : uint8_t kRemote = 0x07, kRfid = 0x08, kBiometric = 0x09, + // kUnknownEnumValue = 10, }; // Enum for DlStatus @@ -1130,6 +1221,7 @@ enum class DlStatus : uint8_t kInvalidField = 0x85, kResourceExhausted = 0x89, kNotFound = 0x8B, + // kUnknownEnumValue = 4, }; // Enum for DlUserStatus @@ -1138,6 +1230,7 @@ enum class DlUserStatus : uint8_t kAvailable = 0x00, kOccupiedEnabled = 0x01, kOccupiedDisabled = 0x03, + // kUnknownEnumValue = 2, }; // Enum for DlUserType @@ -1153,6 +1246,7 @@ enum class DlUserType : uint8_t kExpiringUser = 0x07, kScheduleRestrictedUser = 0x08, kRemoteOnlyUser = 0x09, + // kUnknownEnumValue = 10, }; // Enum for DoorLockOperationEventCode @@ -1173,6 +1267,7 @@ enum class DoorLockOperationEventCode : uint8_t kScheduleUnlock = 0x0C, kManualLock = 0x0D, kManualUnlock = 0x0E, + // kUnknownEnumValue = 15, }; // Enum for DoorLockProgrammingEventCode @@ -1185,6 +1280,7 @@ enum class DoorLockProgrammingEventCode : uint8_t kPinChanged = 0x04, kIdAdded = 0x05, kIdDeleted = 0x06, + // kUnknownEnumValue = 7, }; // Enum for DoorLockSetPinOrIdStatus @@ -1194,6 +1290,7 @@ enum class DoorLockSetPinOrIdStatus : uint8_t kGeneralFailure = 0x01, kMemoryFull = 0x02, kDuplicateCodeError = 0x03, + // kUnknownEnumValue = 4, }; // Enum for DoorLockUserStatus @@ -1203,6 +1300,7 @@ enum class DoorLockUserStatus : uint8_t kOccupiedEnabled = 0x01, kOccupiedDisabled = 0x03, kNotSupported = 0xFF, + // kUnknownEnumValue = 2, }; // Enum for DoorLockUserType @@ -1214,6 +1312,7 @@ enum class DoorLockUserType : uint8_t kMasterUser = 0x03, kNonAccessUser = 0x04, kNotSupported = 0xFF, + // kUnknownEnumValue = 5, }; // Bitmap for DlCredentialRuleMask @@ -1415,6 +1514,7 @@ enum class EndProductType : uint8_t kSwingingShutter = 0x16, kSlidingShutter = 0x17, kUnknown = 0xFF, + // kUnknownEnumValue = 24, }; // Enum for Type @@ -1431,6 +1531,7 @@ enum class Type : uint8_t kTiltBlindLiftAndTilt = 0x08, kProjectorScreen = 0x09, kUnknown = 0xFF, + // kUnknownEnumValue = 10, }; // Bitmap for ConfigStatus @@ -1504,6 +1605,7 @@ enum class PumpControlMode : uint8_t kConstantFlow = 0x03, kConstantTemperature = 0x05, kAutomatic = 0x07, + // kUnknownEnumValue = 4, }; // Enum for PumpOperationMode @@ -1513,6 +1615,7 @@ enum class PumpOperationMode : uint8_t kMinimum = 0x01, kMaximum = 0x02, kLocal = 0x03, + // kUnknownEnumValue = 4, }; // Bitmap for PumpStatus @@ -1541,10 +1644,12 @@ enum class SetpointAdjustMode : uint8_t kHeatSetpoint = 0x00, kCoolSetpoint = 0x01, kHeatAndCoolSetpoints = 0x02, + // kUnknownEnumValue = 3, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using SetpointAdjustMode = EmberAfSetpointAdjustMode; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using SetpointAdjustMode = EmberAfSetpointAdjustMode; +static SetpointAdjustMode __attribute__((unused)) kSetpointAdjustModekUnknownEnumValue = static_cast(3); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Enum for ThermostatControlSequence enum class ThermostatControlSequence : uint8_t @@ -1555,6 +1660,7 @@ enum class ThermostatControlSequence : uint8_t kHeatingWithReheat = 0x03, kCoolingAndHeating = 0x04, kCoolingAndHeatingWithReheat = 0x05, + // kUnknownEnumValue = 6, }; // Enum for ThermostatRunningMode @@ -1563,6 +1669,7 @@ enum class ThermostatRunningMode : uint8_t kOff = 0x00, kCool = 0x03, kHeat = 0x04, + // kUnknownEnumValue = 1, }; // Enum for ThermostatSystemMode @@ -1575,6 +1682,7 @@ enum class ThermostatSystemMode : uint8_t kEmergencyHeating = 0x05, kPrecooling = 0x06, kFanOnly = 0x07, + // kUnknownEnumValue = 2, }; // Bitmap for DayOfWeek @@ -1620,6 +1728,7 @@ enum class FanModeSequenceType : uint8_t kOffLowHighAuto = 0x03, kOffOnAuto = 0x04, kOffOn = 0x05, + // kUnknownEnumValue = 6, }; // Enum for FanModeType @@ -1632,6 +1741,7 @@ enum class FanModeType : uint8_t kOn = 0x04, kAuto = 0x05, kSmart = 0x06, + // kUnknownEnumValue = 7, }; // Bitmap for FanControlFeature @@ -1683,10 +1793,12 @@ enum class ColorLoopAction : uint8_t kDeactivate = 0x00, kActivateFromColorLoopStartEnhancedHue = 0x01, kActivateFromEnhancedCurrentHue = 0x02, + // kUnknownEnumValue = 3, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using ColorLoopAction = EmberAfColorLoopAction; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using ColorLoopAction = EmberAfColorLoopAction; +static ColorLoopAction __attribute__((unused)) kColorLoopActionkUnknownEnumValue = static_cast(3); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -1696,10 +1808,12 @@ enum class ColorLoopDirection : uint8_t { kDecrementHue = 0x00, kIncrementHue = 0x01, + // kUnknownEnumValue = 2, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using ColorLoopDirection = EmberAfColorLoopDirection; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using ColorLoopDirection = EmberAfColorLoopDirection; +static ColorLoopDirection __attribute__((unused)) kColorLoopDirectionkUnknownEnumValue = static_cast(2); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -1710,10 +1824,12 @@ enum class ColorMode : uint8_t kCurrentHueAndCurrentSaturation = 0x00, kCurrentXAndCurrentY = 0x01, kColorTemperature = 0x02, + // kUnknownEnumValue = 3, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using ColorMode = EmberAfColorMode; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using ColorMode = EmberAfColorMode; +static ColorMode __attribute__((unused)) kColorModekUnknownEnumValue = static_cast(3); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -1725,10 +1841,12 @@ enum class HueDirection : uint8_t kLongestDistance = 0x01, kUp = 0x02, kDown = 0x03, + // kUnknownEnumValue = 4, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using HueDirection = EmberAfHueDirection; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using HueDirection = EmberAfHueDirection; +static HueDirection __attribute__((unused)) kHueDirectionkUnknownEnumValue = static_cast(4); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -1739,10 +1857,12 @@ enum class HueMoveMode : uint8_t kStop = 0x00, kUp = 0x01, kDown = 0x03, + // kUnknownEnumValue = 2, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using HueMoveMode = EmberAfHueMoveMode; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using HueMoveMode = EmberAfHueMoveMode; +static HueMoveMode __attribute__((unused)) kHueMoveModekUnknownEnumValue = static_cast(2); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -1752,10 +1872,12 @@ enum class HueStepMode : uint8_t { kUp = 0x01, kDown = 0x03, + // kUnknownEnumValue = 0, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using HueStepMode = EmberAfHueStepMode; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using HueStepMode = EmberAfHueStepMode; +static HueStepMode __attribute__((unused)) kHueStepModekUnknownEnumValue = static_cast(0); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -1766,10 +1888,12 @@ enum class SaturationMoveMode : uint8_t kStop = 0x00, kUp = 0x01, kDown = 0x03, + // kUnknownEnumValue = 2, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using SaturationMoveMode = EmberAfSaturationMoveMode; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using SaturationMoveMode = EmberAfSaturationMoveMode; +static SaturationMoveMode __attribute__((unused)) kSaturationMoveModekUnknownEnumValue = static_cast(2); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Need to convert consumers to using the new enum classes, so we // don't just have casts all over. @@ -1779,10 +1903,12 @@ enum class SaturationStepMode : uint8_t { kUp = 0x01, kDown = 0x03, + // kUnknownEnumValue = 0, }; -#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM -using SaturationStepMode = EmberAfSaturationStepMode; -#endif +#else // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM +using SaturationStepMode = EmberAfSaturationStepMode; +static SaturationStepMode __attribute__((unused)) kSaturationStepModekUnknownEnumValue = static_cast(0); +#endif // CHIP_USE_ENUM_CLASS_FOR_IM_ENUM // Bitmap for ColorCapabilities enum class ColorCapabilities : uint16_t @@ -1824,6 +1950,7 @@ enum class LightSensorType : uint8_t { kPhotodiode = 0x00, kCmos = 0x01, + // kUnknownEnumValue = 2, }; } // namespace IlluminanceMeasurement @@ -1949,12 +2076,14 @@ enum class ChannelStatusEnum : uint8_t kSuccess = 0x00, kMultipleMatches = 0x01, kNoMatches = 0x02, + // kUnknownEnumValue = 3, }; // Enum for LineupInfoTypeEnum enum class LineupInfoTypeEnum : uint8_t { kMso = 0x00, + // kUnknownEnumValue = 1, }; // Bitmap for ChannelFeature @@ -1973,6 +2102,7 @@ enum class TargetNavigatorStatusEnum : uint8_t kSuccess = 0x00, kTargetNotFound = 0x01, kNotAllowed = 0x02, + // kUnknownEnumValue = 3, }; } // namespace TargetNavigator @@ -1987,6 +2117,7 @@ enum class MediaPlaybackStatusEnum : uint8_t kNotActive = 0x03, kSpeedOutOfRange = 0x04, kSeekOutOfRange = 0x05, + // kUnknownEnumValue = 6, }; // Enum for PlaybackStateEnum @@ -1996,6 +2127,7 @@ enum class PlaybackStateEnum : uint8_t kPaused = 0x01, kNotPlaying = 0x02, kBuffering = 0x03, + // kUnknownEnumValue = 4, }; } // namespace MediaPlayback @@ -2016,6 +2148,7 @@ enum class InputTypeEnum : uint8_t kScart = 0x09, kUsb = 0x0A, kOther = 0x0B, + // kUnknownEnumValue = 12, }; // Bitmap for MediaInputFeature @@ -2119,6 +2252,7 @@ enum class CecKeyCode : uint8_t kF4Yellow = 0x74, kF5 = 0x75, kData = 0x76, + // kUnknownEnumValue = 14, }; // Enum for KeypadInputStatusEnum @@ -2127,6 +2261,7 @@ enum class KeypadInputStatusEnum : uint8_t kSuccess = 0x00, kUnsupportedKey = 0x01, kInvalidKeyInCurrentState = 0x02, + // kUnknownEnumValue = 3, }; // Bitmap for KeypadInputFeature @@ -2146,6 +2281,7 @@ enum class ContentLaunchStatusEnum : uint8_t kSuccess = 0x00, kUrlNotAvailable = 0x01, kAuthFailed = 0x02, + // kUnknownEnumValue = 3, }; // Enum for MetricTypeEnum @@ -2153,6 +2289,7 @@ enum class MetricTypeEnum : uint8_t { kPixels = 0x00, kPercentage = 0x01, + // kUnknownEnumValue = 2, }; // Enum for ParameterEnum @@ -2171,6 +2308,7 @@ enum class ParameterEnum : uint8_t kSport = 0x0A, kSportsTeam = 0x0B, kType = 0x0C, + // kUnknownEnumValue = 13, }; // Bitmap for ContentLauncherFeature @@ -2199,6 +2337,7 @@ enum class OutputTypeEnum : uint8_t kHeadphone = 0x03, kInternal = 0x04, kOther = 0x05, + // kUnknownEnumValue = 6, }; // Bitmap for AudioOutputFeature @@ -2216,6 +2355,7 @@ enum class ApplicationLauncherStatusEnum : uint8_t kSuccess = 0x00, kAppNotAvailable = 0x01, kSystemBusy = 0x02, + // kUnknownEnumValue = 3, }; // Bitmap for ApplicationLauncherFeature @@ -2234,6 +2374,7 @@ enum class ApplicationStatusEnum : uint8_t kActiveVisibleFocus = 0x01, kActiveHidden = 0x02, kActiveVisibleNotFocus = 0x03, + // kUnknownEnumValue = 4, }; } // namespace ApplicationBasic @@ -2289,6 +2430,7 @@ enum class SimpleEnum : uint8_t kValueA = 0x01, kValueB = 0x02, kValueC = 0x03, + // kUnknownEnumValue = 4, }; // Bitmap for Bitmap16MaskMap diff --git a/zzz_generated/chip-tool/zap-generated/test/Commands.h b/zzz_generated/chip-tool/zap-generated/test/Commands.h index 3b2a4cd864c03a..9c97cecba65453 100644 --- a/zzz_generated/chip-tool/zap-generated/test/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/test/Commands.h @@ -39953,7 +39953,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); @@ -39988,7 +39988,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; @@ -41031,10 +41031,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; @@ -41042,7 +41051,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; @@ -41050,7 +41059,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; @@ -41058,7 +41067,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; @@ -41066,7 +41075,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; @@ -41074,7 +41083,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; @@ -41082,7 +41091,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; @@ -41098,7 +41107,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; @@ -41106,7 +41115,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; @@ -41114,7 +41123,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; @@ -41143,7 +41152,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; @@ -41154,7 +41163,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; @@ -41162,7 +41171,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; @@ -41170,7 +41179,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; @@ -41178,7 +41187,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; @@ -41186,10 +41195,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; @@ -41208,10 +41217,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; @@ -41234,10 +41243,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 @@ -41265,7 +41274,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; @@ -41280,7 +41289,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; @@ -41288,7 +41297,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< @@ -41309,10 +41318,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< @@ -41346,10 +41355,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; @@ -41358,10 +41367,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; @@ -41370,7 +41379,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; @@ -41378,10 +41387,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; @@ -41390,10 +41399,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; @@ -41403,10 +41412,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; @@ -41414,7 +41423,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; @@ -41422,10 +41431,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; @@ -41434,10 +41443,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; @@ -41446,10 +41455,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; @@ -41457,10 +41466,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; @@ -41469,10 +41478,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; @@ -41481,10 +41490,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; @@ -41492,10 +41501,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; @@ -41504,10 +41513,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; @@ -41516,10 +41525,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; @@ -41527,10 +41536,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; @@ -41539,10 +41548,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; @@ -41551,10 +41560,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; @@ -41563,7 +41572,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; @@ -41571,10 +41580,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; @@ -41582,7 +41591,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; @@ -41591,7 +41600,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; @@ -41599,10 +41608,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; @@ -41611,7 +41620,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; @@ -41619,10 +41628,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; @@ -41631,10 +41640,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; @@ -41643,10 +41652,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; @@ -41655,10 +41664,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; @@ -41666,7 +41675,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; @@ -41675,7 +41684,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; @@ -41683,10 +41692,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; @@ -41695,7 +41704,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; @@ -41703,10 +41712,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; @@ -41715,10 +41724,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; @@ -41727,10 +41736,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; @@ -41739,10 +41748,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; @@ -41750,7 +41759,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; @@ -41759,7 +41768,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; @@ -41767,10 +41776,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; @@ -41779,7 +41788,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; @@ -41787,10 +41796,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; @@ -41799,10 +41808,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; @@ -41811,10 +41820,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; @@ -41823,10 +41832,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; @@ -41834,7 +41843,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; @@ -41843,7 +41852,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; @@ -41851,10 +41860,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; @@ -41863,7 +41872,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; @@ -41871,10 +41880,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; @@ -41883,10 +41892,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; @@ -41895,10 +41904,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; @@ -41906,7 +41915,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; @@ -41915,7 +41924,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; @@ -41923,10 +41932,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; @@ -41935,7 +41944,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; @@ -41943,10 +41952,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; @@ -41955,10 +41964,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; @@ -41967,10 +41976,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; @@ -41978,7 +41987,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; @@ -41987,7 +41996,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; @@ -41995,10 +42004,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; @@ -42007,7 +42016,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; @@ -42015,10 +42024,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; @@ -42027,10 +42036,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; @@ -42039,10 +42048,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; @@ -42050,7 +42059,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; @@ -42059,7 +42068,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; @@ -42067,10 +42076,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; @@ -42079,7 +42088,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; @@ -42087,10 +42096,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; @@ -42099,10 +42108,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; @@ -42111,10 +42120,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; @@ -42122,7 +42131,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; @@ -42131,7 +42140,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; @@ -42139,10 +42148,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; @@ -42151,7 +42160,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; @@ -42159,10 +42168,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; @@ -42171,10 +42180,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; @@ -42183,10 +42192,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; @@ -42195,10 +42204,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; @@ -42206,10 +42215,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; @@ -42218,10 +42227,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; @@ -42230,10 +42239,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; @@ -42242,10 +42251,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; @@ -42254,10 +42263,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; @@ -42265,10 +42274,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; @@ -42277,10 +42286,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; @@ -42289,10 +42298,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; @@ -42301,10 +42310,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; @@ -42313,10 +42322,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; @@ -42324,10 +42333,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; @@ -42336,10 +42345,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; @@ -42348,10 +42357,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; @@ -42360,10 +42369,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; @@ -42371,10 +42380,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; @@ -42383,35 +42392,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; @@ -42419,15 +42428,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; @@ -42437,10 +42446,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; @@ -42464,10 +42473,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; @@ -42475,10 +42484,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; @@ -42488,7 +42497,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; @@ -42496,7 +42505,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; @@ -42505,10 +42514,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; @@ -42531,7 +42540,7 @@ class TestClusterSuite : public TestCommand } } break; - case 364: + case 365: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42547,10 +42556,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; @@ -42558,10 +42567,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; @@ -42570,7 +42579,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; @@ -42578,19 +42587,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; @@ -42609,10 +42618,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; @@ -42632,7 +42641,7 @@ class TestClusterSuite : public TestCommand } shouldContinue = true; break; - case 377: + case 378: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { uint8_t value; @@ -42640,9 +42649,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; @@ -42653,6 +42659,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; @@ -42660,10 +42669,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; @@ -42671,10 +42680,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; @@ -42682,10 +42691,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; @@ -42693,7 +42702,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; @@ -42701,9 +42710,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; @@ -42714,6 +42720,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; @@ -42721,10 +42730,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; @@ -42732,10 +42741,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; @@ -42743,10 +42752,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; @@ -42754,7 +42763,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; @@ -42762,9 +42771,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; @@ -42775,6 +42781,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; @@ -42782,10 +42791,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; @@ -42793,10 +42802,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; @@ -42804,10 +42813,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; @@ -42815,7 +42824,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; @@ -42823,9 +42832,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; @@ -42836,6 +42842,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; @@ -42843,10 +42852,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; @@ -42854,10 +42863,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; @@ -42865,10 +42874,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; @@ -42876,7 +42885,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; @@ -42885,9 +42894,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; @@ -42898,6 +42904,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; @@ -42906,10 +42915,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; @@ -42918,10 +42927,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; @@ -42930,10 +42939,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; @@ -42942,10 +42951,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; @@ -42953,7 +42962,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; @@ -42962,9 +42971,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; @@ -42975,6 +42981,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; @@ -42983,10 +42992,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; @@ -42995,10 +43004,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; @@ -43007,10 +43016,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; @@ -43019,10 +43028,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; @@ -43030,7 +43039,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; @@ -43039,9 +43048,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; @@ -43052,6 +43058,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; @@ -43060,10 +43069,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; @@ -43072,10 +43081,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; @@ -43084,10 +43093,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; @@ -43096,10 +43105,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; @@ -43107,7 +43116,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; @@ -43116,9 +43125,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; @@ -43129,6 +43135,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; @@ -43137,10 +43146,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; @@ -43149,10 +43158,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; @@ -43161,10 +43170,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; @@ -43173,10 +43182,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; @@ -43184,19 +43193,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; @@ -43243,7 +43252,7 @@ class TestClusterSuite : public TestCommand } } break; - case 486: + case 487: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::DecodableList value; @@ -43272,10 +43281,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; @@ -44362,14 +44371,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; @@ -44387,8 +44407,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; @@ -44406,8 +44426,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; @@ -44428,8 +44448,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; @@ -44450,8 +44470,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; @@ -44529,8 +44549,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; @@ -44608,8 +44628,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; @@ -44627,8 +44647,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; @@ -44651,8 +44671,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; @@ -44676,8 +44696,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; @@ -44700,8 +44720,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; @@ -44711,8 +44731,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; @@ -44748,8 +44768,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; @@ -44785,8 +44805,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; @@ -44874,8 +44894,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; @@ -44962,8 +44982,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; @@ -44979,13 +44999,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; @@ -45001,13 +45021,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; @@ -45038,13 +45058,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(); @@ -45055,8 +45075,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, @@ -45064,13 +45084,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; @@ -45100,26 +45120,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(); @@ -45127,18 +45147,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(); @@ -45146,13 +45166,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(); @@ -45160,31 +45180,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(); @@ -45192,13 +45212,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(); @@ -45206,26 +45226,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(); @@ -45233,13 +45253,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(); @@ -45247,26 +45267,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(); @@ -45274,13 +45294,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(); @@ -45288,26 +45308,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(); @@ -45315,13 +45335,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(); @@ -45329,13 +45349,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(); @@ -45343,41 +45363,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(); @@ -45385,18 +45405,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(); @@ -45404,13 +45424,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(); @@ -45418,13 +45438,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(); @@ -45432,36 +45452,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(); @@ -45469,18 +45489,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(); @@ -45488,13 +45508,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(); @@ -45502,13 +45522,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(); @@ -45516,36 +45536,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(); @@ -45553,18 +45573,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(); @@ -45572,13 +45592,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(); @@ -45586,13 +45606,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(); @@ -45600,36 +45620,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(); @@ -45637,18 +45657,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(); @@ -45656,13 +45676,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(); @@ -45670,36 +45690,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(); @@ -45707,18 +45727,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(); @@ -45726,13 +45746,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(); @@ -45740,36 +45760,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(); @@ -45777,18 +45797,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(); @@ -45796,13 +45816,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(); @@ -45810,36 +45830,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(); @@ -45847,18 +45867,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(); @@ -45866,13 +45886,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(); @@ -45880,36 +45900,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(); @@ -45917,18 +45937,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(); @@ -45936,13 +45956,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(); @@ -45950,13 +45970,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(); @@ -45964,26 +45984,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(); @@ -45991,13 +46011,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(); @@ -46005,13 +46025,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(); @@ -46019,13 +46039,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(); @@ -46033,26 +46053,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(); @@ -46060,13 +46080,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(); @@ -46074,13 +46094,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(); @@ -46088,13 +46108,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(); @@ -46102,26 +46122,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(); @@ -46129,13 +46149,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(); @@ -46143,13 +46163,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(); @@ -46157,26 +46177,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(); @@ -46184,27 +46204,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(); @@ -46212,36 +46232,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(); @@ -46249,26 +46269,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(); @@ -46276,23 +46296,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(); @@ -46300,31 +46320,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(); @@ -46332,28 +46352,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, @@ -46361,8 +46381,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(); @@ -46372,13 +46392,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; @@ -46394,98 +46414,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; @@ -46493,8 +46513,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; @@ -46502,8 +46522,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; @@ -46511,8 +46531,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; @@ -46520,13 +46540,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; @@ -46534,13 +46554,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; @@ -46548,13 +46568,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; @@ -46562,99 +46582,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; @@ -46662,8 +46682,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; @@ -46671,8 +46691,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; @@ -46680,8 +46700,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; @@ -46689,13 +46709,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; @@ -46703,13 +46723,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; @@ -46717,13 +46737,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; @@ -46731,18 +46751,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(); @@ -46751,8 +46771,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(); @@ -46761,8 +46781,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(); @@ -46771,8 +46791,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(); @@ -46781,13 +46801,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(); @@ -46796,13 +46816,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(); @@ -46811,13 +46831,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(); @@ -46826,13 +46846,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(); @@ -46840,18 +46860,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(); @@ -46860,8 +46880,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(); @@ -46870,8 +46890,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(); @@ -46880,8 +46900,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(); @@ -46890,13 +46910,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(); @@ -46905,13 +46925,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(); @@ -46920,13 +46940,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(); @@ -46935,13 +46955,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(); @@ -46949,18 +46969,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(); @@ -46969,8 +46989,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(); @@ -46979,8 +46999,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(); @@ -46989,8 +47009,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(); @@ -46999,13 +47019,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(); @@ -47014,13 +47034,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(); @@ -47029,13 +47049,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(); @@ -47044,13 +47064,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(); @@ -47058,18 +47078,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(); @@ -47078,8 +47098,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(); @@ -47088,8 +47108,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(); @@ -47098,8 +47118,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(); @@ -47108,13 +47128,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(); @@ -47123,13 +47143,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(); @@ -47138,13 +47158,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(); @@ -47153,13 +47173,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(); @@ -47167,49 +47187,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; @@ -47225,8 +47245,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); } @@ -48311,7 +48331,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; @@ -48415,7 +48435,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/darwin-framework-tool/zap-generated/test/Commands.h b/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h index 1e13c669986dfd..2b2b8236d68b49 100644 --- a/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h +++ b/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h @@ -67513,890 +67513,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( @@ -68404,552 +68403,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; } @@ -69527,10 +69531,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)); @@ -69548,10 +69552,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)); @@ -69566,10 +69570,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)); @@ -69584,10 +69588,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)); @@ -69608,10 +69612,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)); @@ -69650,10 +69654,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)); @@ -69689,10 +69693,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)); @@ -69728,10 +69732,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)); @@ -69761,10 +69765,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)); @@ -69794,10 +69798,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)); @@ -69827,10 +69831,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)); @@ -69860,10 +69864,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)); @@ -69959,10 +69963,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)); @@ -69983,10 +69987,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)); @@ -70007,10 +70011,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)); @@ -70073,16 +70077,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)); @@ -70100,7 +70104,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)); @@ -70112,7 +70116,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)); @@ -70136,7 +70140,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)); @@ -70148,7 +70152,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)); @@ -70172,7 +70176,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)); @@ -70184,7 +70188,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)); @@ -70208,7 +70212,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)); @@ -70220,7 +70224,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)); @@ -70244,7 +70248,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)); @@ -70256,7 +70260,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)); @@ -70286,7 +70290,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)); @@ -70298,7 +70302,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)); @@ -70328,7 +70332,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)); @@ -70340,7 +70344,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)); @@ -70370,7 +70374,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)); @@ -70382,7 +70386,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)); @@ -70409,19 +70413,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)); @@ -70432,6 +70436,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. @@ -70445,7 +70452,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; @@ -74150,7 +74157,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) { @@ -74165,7 +74172,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(); @@ -74174,7 +74215,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 @@ -74211,7 +74252,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 @@ -74248,7 +74289,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 @@ -74296,7 +74337,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 @@ -74344,7 +74385,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 @@ -74438,7 +74479,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 @@ -74532,7 +74573,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 @@ -74579,7 +74620,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 @@ -74620,7 +74661,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 @@ -74661,7 +74702,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 @@ -74710,7 +74751,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 @@ -74742,7 +74783,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 @@ -74795,7 +74836,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 @@ -74848,7 +74889,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 @@ -74948,7 +74989,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 @@ -75048,7 +75089,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 @@ -75077,7 +75118,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 @@ -75105,7 +75146,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 @@ -75134,7 +75175,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 @@ -75162,7 +75203,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 @@ -75203,7 +75244,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 @@ -75239,7 +75280,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 @@ -75283,7 +75324,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 @@ -75310,7 +75351,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 @@ -75343,7 +75384,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 @@ -75381,7 +75422,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 @@ -75421,7 +75462,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 @@ -75444,7 +75485,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 @@ -75471,7 +75512,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 @@ -75493,7 +75534,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 @@ -75518,7 +75559,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 @@ -75541,7 +75582,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 @@ -75563,7 +75604,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 @@ -75588,7 +75629,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 @@ -75611,7 +75652,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 @@ -75639,7 +75680,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 @@ -75661,7 +75702,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 @@ -75685,7 +75726,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 @@ -75708,7 +75749,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 @@ -75730,7 +75771,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 @@ -75755,7 +75796,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 @@ -75777,7 +75818,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 @@ -75802,7 +75843,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 @@ -75824,7 +75865,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 @@ -75848,7 +75889,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 @@ -75870,7 +75911,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 @@ -75895,7 +75936,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 @@ -75917,7 +75958,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 @@ -75942,7 +75983,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 @@ -75964,7 +76005,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 @@ -75988,7 +76029,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 @@ -76010,7 +76051,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 @@ -76035,7 +76076,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 @@ -76057,7 +76098,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 @@ -76082,7 +76123,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 @@ -76104,7 +76145,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 @@ -76128,7 +76169,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 @@ -76150,7 +76191,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 @@ -76175,7 +76216,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 @@ -76197,7 +76238,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 @@ -76222,7 +76263,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 @@ -76243,7 +76284,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 @@ -76268,7 +76309,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 @@ -76291,7 +76332,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 @@ -76313,7 +76354,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 @@ -76337,7 +76378,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 @@ -76362,7 +76403,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 @@ -76385,7 +76426,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 @@ -76407,7 +76448,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 @@ -76432,7 +76473,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 @@ -76455,7 +76496,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 @@ -76477,7 +76518,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 @@ -76502,7 +76543,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 @@ -76524,7 +76565,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 @@ -76549,7 +76590,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 @@ -76571,7 +76612,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 @@ -76596,7 +76637,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 @@ -76618,7 +76659,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 @@ -76642,7 +76683,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 @@ -76667,7 +76708,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 @@ -76690,7 +76731,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 @@ -76712,7 +76753,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 @@ -76737,7 +76778,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 @@ -76760,7 +76801,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 @@ -76782,7 +76823,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 @@ -76807,7 +76848,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 @@ -76829,7 +76870,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 @@ -76854,7 +76895,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 @@ -76876,7 +76917,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 @@ -76901,7 +76942,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 @@ -76923,7 +76964,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 @@ -76947,7 +76988,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 @@ -76972,7 +77013,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 @@ -76995,7 +77036,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 @@ -77017,7 +77058,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 @@ -77042,7 +77083,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 @@ -77065,7 +77106,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 @@ -77087,7 +77128,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 @@ -77112,7 +77153,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 @@ -77134,7 +77175,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 @@ -77159,7 +77200,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 @@ -77181,7 +77222,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 @@ -77206,7 +77247,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 @@ -77228,7 +77269,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 @@ -77252,7 +77293,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 @@ -77278,7 +77319,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 @@ -77301,7 +77342,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 @@ -77323,7 +77364,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 @@ -77349,7 +77390,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 @@ -77372,7 +77413,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 @@ -77394,7 +77435,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 @@ -77419,7 +77460,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 @@ -77440,7 +77481,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 @@ -77465,7 +77506,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 @@ -77487,7 +77528,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 @@ -77511,7 +77552,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 @@ -77536,7 +77577,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 @@ -77559,7 +77600,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 @@ -77581,7 +77622,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 @@ -77606,7 +77647,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 @@ -77629,7 +77670,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 @@ -77651,7 +77692,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 @@ -77676,7 +77717,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 @@ -77698,7 +77739,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 @@ -77723,7 +77764,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 @@ -77745,7 +77786,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 @@ -77769,7 +77810,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 @@ -77794,7 +77835,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 @@ -77817,7 +77858,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 @@ -77839,7 +77880,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 @@ -77864,7 +77905,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 @@ -77887,7 +77928,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 @@ -77909,7 +77950,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 @@ -77934,7 +77975,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 @@ -77956,7 +77997,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 @@ -77981,7 +78022,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 @@ -78003,7 +78044,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 @@ -78027,7 +78068,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 @@ -78052,7 +78093,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 @@ -78075,7 +78116,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 @@ -78097,7 +78138,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 @@ -78122,7 +78163,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 @@ -78145,7 +78186,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 @@ -78167,7 +78208,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 @@ -78192,7 +78233,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 @@ -78214,7 +78255,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 @@ -78239,7 +78280,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 @@ -78261,7 +78302,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 @@ -78285,7 +78326,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 @@ -78310,7 +78351,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 @@ -78333,7 +78374,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 @@ -78355,7 +78396,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 @@ -78380,7 +78421,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 @@ -78403,7 +78444,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 @@ -78425,7 +78466,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 @@ -78450,7 +78491,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 @@ -78472,7 +78513,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 @@ -78497,7 +78538,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 @@ -78519,7 +78560,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 @@ -78544,7 +78585,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 @@ -78566,7 +78607,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 @@ -78590,7 +78631,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 @@ -78612,7 +78653,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 @@ -78637,7 +78678,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 @@ -78659,7 +78700,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 @@ -78684,7 +78725,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 @@ -78706,7 +78747,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 @@ -78731,7 +78772,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 @@ -78753,7 +78794,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 @@ -78778,7 +78819,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 @@ -78800,7 +78841,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 @@ -78824,7 +78865,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 @@ -78846,7 +78887,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 @@ -78871,7 +78912,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 @@ -78893,7 +78934,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 @@ -78918,7 +78959,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 @@ -78940,7 +78981,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 @@ -78965,7 +79006,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 @@ -78986,7 +79027,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 @@ -79011,7 +79052,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 @@ -79033,7 +79074,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 @@ -79057,7 +79098,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 @@ -79079,7 +79120,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 @@ -79104,7 +79145,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 @@ -79126,7 +79167,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 @@ -79151,7 +79192,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 @@ -79173,7 +79214,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 @@ -79198,7 +79239,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 @@ -79220,7 +79261,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 @@ -79244,7 +79285,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 @@ -79266,7 +79307,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 @@ -79291,7 +79332,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 @@ -79300,7 +79341,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); @@ -79313,7 +79354,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 @@ -79329,7 +79370,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(); @@ -79338,7 +79379,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 @@ -79359,9 +79400,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 @@ -79377,10 +79418,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(); @@ -79389,7 +79430,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 @@ -79411,7 +79452,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 @@ -79435,7 +79476,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 @@ -79444,13 +79485,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(); }]; @@ -79458,7 +79499,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 @@ -79484,7 +79525,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 @@ -79507,7 +79548,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 @@ -79536,7 +79577,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 @@ -79558,7 +79599,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 @@ -79582,7 +79623,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 @@ -79604,7 +79645,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 @@ -79630,7 +79671,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 @@ -79653,7 +79694,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 @@ -79678,7 +79719,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 @@ -79701,7 +79742,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 @@ -79729,7 +79770,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 @@ -79758,7 +79799,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 @@ -79780,7 +79821,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 @@ -79804,7 +79845,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 @@ -79826,7 +79867,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 @@ -79851,7 +79892,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 @@ -79874,7 +79915,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 @@ -79892,7 +79933,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 @@ -79910,7 +79951,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 @@ -79932,7 +79973,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 @@ -79955,10 +79996,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 @@ -79980,14 +80021,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 @@ -80003,7 +80044,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) { @@ -80020,7 +80061,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 @@ -80049,7 +80090,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 @@ -80077,7 +80118,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 @@ -80101,7 +80142,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 @@ -80124,7 +80165,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 @@ -80148,7 +80189,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 @@ -80172,7 +80213,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 @@ -80195,7 +80236,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 @@ -80219,7 +80260,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 @@ -80243,7 +80284,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 @@ -80267,7 +80308,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 @@ -80291,7 +80332,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 @@ -80315,7 +80356,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 @@ -80339,7 +80380,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 @@ -80363,7 +80404,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 @@ -80387,7 +80428,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 @@ -80410,7 +80451,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 @@ -80434,7 +80475,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 @@ -80458,7 +80499,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 @@ -80481,7 +80522,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 @@ -80505,7 +80546,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 @@ -80529,7 +80570,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 @@ -80553,7 +80594,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 @@ -80577,7 +80618,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 @@ -80601,7 +80642,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 @@ -80626,7 +80667,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 @@ -80650,7 +80691,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 @@ -80674,7 +80715,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 @@ -80696,7 +80737,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 @@ -80721,7 +80762,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 @@ -80746,7 +80787,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 @@ -80768,7 +80809,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 @@ -80792,7 +80833,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 @@ -80815,7 +80856,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 @@ -80839,7 +80880,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 @@ -80862,7 +80903,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 @@ -80886,7 +80927,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 @@ -80910,7 +80951,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 @@ -80934,7 +80975,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 @@ -80958,7 +80999,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 @@ -80981,7 +81022,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 @@ -81005,7 +81046,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 @@ -81029,7 +81070,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 @@ -81052,7 +81093,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 @@ -81076,7 +81117,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 @@ -81100,7 +81141,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 @@ -81124,7 +81165,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 @@ -81148,7 +81189,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 @@ -81172,7 +81213,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 @@ -81196,7 +81237,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 @@ -81220,7 +81261,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 @@ -81246,7 +81287,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 @@ -81270,7 +81311,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 @@ -81294,7 +81335,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 @@ -81318,7 +81359,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 @@ -81342,7 +81383,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 @@ -81368,7 +81409,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 @@ -81392,7 +81433,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 @@ -81418,7 +81459,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 @@ -81442,7 +81483,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 @@ -81468,7 +81509,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 @@ -81492,7 +81533,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 @@ -81518,7 +81559,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 @@ -81542,7 +81583,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 @@ -81567,7 +81608,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 @@ -81593,7 +81634,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 @@ -81617,7 +81658,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 @@ -81641,7 +81682,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 @@ -81665,7 +81706,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 @@ -81689,7 +81730,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 @@ -81715,7 +81756,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 @@ -81739,7 +81780,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 @@ -81765,7 +81806,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 @@ -81789,7 +81830,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 @@ -81815,7 +81856,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 @@ -81839,7 +81880,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 @@ -81865,7 +81906,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 @@ -81889,7 +81930,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 @@ -81914,7 +81955,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 @@ -81940,7 +81981,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 @@ -81964,7 +82005,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 @@ -81988,7 +82029,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 @@ -82012,7 +82053,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 @@ -82036,7 +82077,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 @@ -82062,7 +82103,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 @@ -82086,7 +82127,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 @@ -82112,7 +82153,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 @@ -82136,7 +82177,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 @@ -82162,7 +82203,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 @@ -82186,7 +82227,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 @@ -82212,7 +82253,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 @@ -82236,7 +82277,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 @@ -82261,7 +82302,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 @@ -82287,7 +82328,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 @@ -82311,7 +82352,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 @@ -82335,7 +82376,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 @@ -82359,7 +82400,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 @@ -82383,7 +82424,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 @@ -82409,7 +82450,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 @@ -82433,7 +82474,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 @@ -82459,7 +82500,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 @@ -82483,7 +82524,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 @@ -82509,7 +82550,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 @@ -82533,7 +82574,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 @@ -82559,7 +82600,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 @@ -82583,7 +82624,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 @@ -82608,7 +82649,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 @@ -82630,7 +82671,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 @@ -82652,7 +82693,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 @@ -82670,7 +82711,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 @@ -82688,7 +82729,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 @@ -82730,7 +82771,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 @@ -82763,7 +82804,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 @@ -82794,7 +82835,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