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 fdf1ad79108f79..2575895f38bbc9 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 @@ -41,10 +41,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. @@ -53,10 +56,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. @@ -70,10 +76,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 { @@ -105,10 +113,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. @@ -117,10 +128,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. @@ -130,10 +144,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 @@ -141,6 +158,7 @@ enum class OnOffStartUpOnOff : uint8_t kOff = 0x00, kOn = 0x01, kTogglePreviousOnOff = 0x02, + // kUnknownEnumValue = 3, }; // Bitmap for OnOffControl @@ -175,10 +193,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. @@ -188,10 +208,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 @@ -222,6 +244,7 @@ enum class AuthMode : uint8_t kPase = 0x01, kCase = 0x02, kGroup = 0x03, + // kUnknownEnumValue = 0, }; // Enum for ChangeTypeEnum @@ -230,6 +253,7 @@ enum class ChangeTypeEnum : uint8_t kChanged = 0x00, kAdded = 0x01, kRemoved = 0x02, + // kUnknownEnumValue = 3, }; // Enum for Privilege @@ -240,6 +264,7 @@ enum class Privilege : uint8_t kOperate = 0x03, kManage = 0x04, kAdminister = 0x05, + // kUnknownEnumValue = 0, }; } // namespace AccessControl @@ -250,6 +275,7 @@ enum class ActionErrorEnum : uint8_t { kUnknown = 0x00, kInterrupted = 0x01, + // kUnknownEnumValue = 2, }; // Enum for ActionStateEnum @@ -259,6 +285,7 @@ enum class ActionStateEnum : uint8_t kActive = 0x01, kPaused = 0x02, kDisabled = 0x03, + // kUnknownEnumValue = 4, }; // Enum for ActionTypeEnum @@ -271,6 +298,7 @@ enum class ActionTypeEnum : uint8_t kException = 0x04, kNotification = 0x05, kAlarm = 0x06, + // kUnknownEnumValue = 7, }; // Enum for EndpointListTypeEnum @@ -279,6 +307,7 @@ enum class EndpointListTypeEnum : uint8_t kOther = 0x00, kRoom = 0x01, kZone = 0x02, + // kUnknownEnumValue = 3, }; // Bitmap for CommandBits @@ -310,6 +339,7 @@ enum class OTAApplyUpdateAction : uint8_t kProceed = 0x00, kAwaitNextAction = 0x01, kDiscontinue = 0x02, + // kUnknownEnumValue = 3, }; // Enum for OTADownloadProtocol @@ -319,6 +349,7 @@ enum class OTADownloadProtocol : uint8_t kBDXAsynchronous = 0x01, kHttps = 0x02, kVendorSpecific = 0x03, + // kUnknownEnumValue = 4, }; // Enum for OTAQueryStatus @@ -328,6 +359,7 @@ enum class OTAQueryStatus : uint8_t kBusy = 0x01, kNotAvailable = 0x02, kDownloadProtocolNotSupported = 0x03, + // kUnknownEnumValue = 4, }; } // namespace OtaSoftwareUpdateProvider @@ -339,6 +371,7 @@ enum class OTAAnnouncementReason : uint8_t kSimpleAnnouncement = 0x00, kUpdateAvailable = 0x01, kUrgentUpdateAvailable = 0x02, + // kUnknownEnumValue = 3, }; // Enum for OTAChangeReasonEnum @@ -349,6 +382,7 @@ enum class OTAChangeReasonEnum : uint8_t kFailure = 0x02, kTimeOut = 0x03, kDelayByProvider = 0x04, + // kUnknownEnumValue = 5, }; // Enum for OTAUpdateStateEnum @@ -363,6 +397,7 @@ enum class OTAUpdateStateEnum : uint8_t kDelayedOnApply = 0x06, kRollingBack = 0x07, kDelayedOnUserConsent = 0x08, + // kUnknownEnumValue = 9, }; } // namespace OtaSoftwareUpdateRequestor @@ -386,6 +421,7 @@ enum class CalendarType : uint8_t kKorean = 0x09, kPersian = 0x0A, kTaiwanese = 0x0B, + // kUnknownEnumValue = 12, }; // Enum for HourFormat @@ -393,6 +429,7 @@ enum class HourFormat : uint8_t { k12hr = 0x00, k24hr = 0x01, + // kUnknownEnumValue = 2, }; } // namespace TimeFormatLocalization @@ -404,6 +441,7 @@ enum class TempUnit : uint8_t kFahrenheit = 0x00, kCelsius = 0x01, kKelvin = 0x02, + // kUnknownEnumValue = 3, }; // Bitmap for UnitLocalizationFeature @@ -432,6 +470,7 @@ enum class BatChargeFault : uint8_t kChargerOverVoltage = 0x08, kChargerUnderVoltage = 0x09, kSafetyTimeout = 0x0A, + // kUnknownEnumValue = 11, }; // Enum for BatChargeLevel @@ -440,6 +479,7 @@ enum class BatChargeLevel : uint8_t kOk = 0x00, kWarning = 0x01, kCritical = 0x02, + // kUnknownEnumValue = 3, }; // Enum for BatChargeState @@ -449,6 +489,7 @@ enum class BatChargeState : uint8_t kIsCharging = 0x01, kIsAtFullCharge = 0x02, kIsNotCharging = 0x03, + // kUnknownEnumValue = 4, }; // Enum for BatFault @@ -457,6 +498,7 @@ enum class BatFault : uint8_t kUnspecfied = 0x00, kOverTemp = 0x01, kUnderTemp = 0x02, + // kUnknownEnumValue = 3, }; // Enum for BatReplaceability @@ -466,6 +508,7 @@ enum class BatReplaceability : uint8_t kNotReplaceable = 0x01, kUserReplaceable = 0x02, kFactoryReplaceable = 0x03, + // kUnknownEnumValue = 4, }; // Enum for PowerSourceStatus @@ -475,6 +518,7 @@ enum class PowerSourceStatus : uint8_t kActive = 0x01, kStandby = 0x02, kUnavailable = 0x03, + // kUnknownEnumValue = 4, }; // Enum for WiredCurrentType @@ -482,6 +526,7 @@ enum class WiredCurrentType : uint8_t { kAc = 0x00, kDc = 0x01, + // kUnknownEnumValue = 2, }; // Enum for WiredFault @@ -490,6 +535,7 @@ enum class WiredFault : uint8_t kUnspecfied = 0x00, kOverVoltage = 0x01, kUnderVoltage = 0x02, + // kUnknownEnumValue = 3, }; // Bitmap for PowerSourceFeature @@ -512,6 +558,7 @@ enum class CommissioningError : uint8_t kInvalidAuthentication = 0x02, kNoFailSafe = 0x03, kBusyWithOtherAdmin = 0x04, + // kUnknownEnumValue = 5, }; // Enum for RegulatoryLocationType @@ -520,6 +567,7 @@ enum class RegulatoryLocationType : uint8_t kIndoor = 0x00, kOutdoor = 0x01, kIndoorOutdoor = 0x02, + // kUnknownEnumValue = 3, }; } // namespace GeneralCommissioning @@ -541,6 +589,7 @@ enum class NetworkCommissioningStatus : uint8_t kIPV6Failed = 0x0A, kIPBindFailed = 0x0B, kUnknownError = 0x0C, + // kUnknownEnumValue = 13, }; // Enum for WiFiBand @@ -551,6 +600,7 @@ enum class WiFiBand : uint8_t k5g = 0x02, k6g = 0x03, k60g = 0x04, + // kUnknownEnumValue = 5, }; // Bitmap for NetworkCommissioningFeature @@ -580,6 +630,7 @@ enum class LogsIntent : uint8_t kEndUserSupport = 0x00, kNetworkDiag = 0x01, kCrashLogs = 0x02, + // kUnknownEnumValue = 3, }; // Enum for LogsStatus @@ -590,6 +641,7 @@ enum class LogsStatus : uint8_t kNoLogs = 0x02, kBusy = 0x03, kDenied = 0x04, + // kUnknownEnumValue = 5, }; // Enum for LogsTransferProtocol @@ -597,6 +649,7 @@ enum class LogsTransferProtocol : uint8_t { kResponsePayload = 0x00, kBdx = 0x01, + // kUnknownEnumValue = 2, }; } // namespace DiagnosticLogs @@ -612,6 +665,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 @@ -631,10 +685,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. @@ -647,10 +703,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. @@ -662,10 +720,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. @@ -680,10 +740,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 { @@ -704,6 +766,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 @@ -719,16 +782,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 @@ -750,6 +816,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 @@ -764,16 +831,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 @@ -788,10 +858,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 { @@ -812,10 +884,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 { @@ -835,6 +909,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 @@ -846,10 +921,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 { @@ -868,6 +945,7 @@ enum class OperationalCertStatus : uint8_t kFabricConflict = 0x09, kLabelConflict = 0x0A, kInvalidFabricIndex = 0x0B, + // kUnknownEnumValue = 7, }; } // namespace OperationalCredentials @@ -878,6 +956,7 @@ enum class GroupKeySecurityPolicy : uint8_t { kTrustFirst = 0x00, kCacheAndSync = 0x01, + // kUnknownEnumValue = 2, }; } // namespace GroupKeyManagement @@ -921,6 +1000,7 @@ enum class DlAlarmCode : uint8_t kDoorForcedOpen = 0x06, kDoorAjar = 0x07, kForcedUser = 0x08, + // kUnknownEnumValue = 2, }; // Enum for DlCredentialRule @@ -929,6 +1009,7 @@ enum class DlCredentialRule : uint8_t kSingle = 0x00, kDouble = 0x01, kTri = 0x02, + // kUnknownEnumValue = 3, }; // Enum for DlCredentialType @@ -940,6 +1021,7 @@ enum class DlCredentialType : uint8_t kFingerprint = 0x03, kFingerVein = 0x04, kFace = 0x05, + // kUnknownEnumValue = 6, }; // Enum for DlDataOperationType @@ -948,6 +1030,7 @@ enum class DlDataOperationType : uint8_t kAdd = 0x00, kClear = 0x01, kModify = 0x02, + // kUnknownEnumValue = 3, }; // Enum for DlDoorState @@ -959,6 +1042,7 @@ enum class DlDoorState : uint8_t kDoorForcedOpen = 0x03, kDoorUnspecifiedError = 0x04, kDoorAjar = 0x05, + // kUnknownEnumValue = 6, }; // Enum for DlLockDataType @@ -973,6 +1057,7 @@ enum class DlLockDataType : uint8_t kPin = 0x06, kRfid = 0x07, kFingerprint = 0x08, + // kUnknownEnumValue = 9, }; // Enum for DlLockOperationType @@ -982,6 +1067,7 @@ enum class DlLockOperationType : uint8_t kUnlock = 0x01, kNonAccessUserEvent = 0x02, kForcedUserEvent = 0x03, + // kUnknownEnumValue = 4, }; // Enum for DlLockState @@ -990,6 +1076,7 @@ enum class DlLockState : uint8_t kNotFullyLocked = 0x00, kLocked = 0x01, kUnlocked = 0x02, + // kUnknownEnumValue = 3, }; // Enum for DlLockType @@ -1006,6 +1093,7 @@ enum class DlLockType : uint8_t kInterconnectedLock = 0x08, kDeadLatch = 0x09, kDoorFurniture = 0x0A, + // kUnknownEnumValue = 11, }; // Enum for DlOperatingMode @@ -1016,6 +1104,7 @@ enum class DlOperatingMode : uint8_t kPrivacy = 0x02, kNoRemoteLockUnlock = 0x03, kPassage = 0x04, + // kUnknownEnumValue = 5, }; // Enum for DlOperationError @@ -1026,6 +1115,7 @@ enum class DlOperationError : uint8_t kDisabledUserDenied = 0x02, kRestricted = 0x03, kInsufficientBattery = 0x04, + // kUnknownEnumValue = 5, }; // Enum for DlOperationSource @@ -1041,6 +1131,7 @@ enum class DlOperationSource : uint8_t kRemote = 0x07, kRfid = 0x08, kBiometric = 0x09, + // kUnknownEnumValue = 10, }; // Enum for DlStatus @@ -1053,6 +1144,7 @@ enum class DlStatus : uint8_t kInvalidField = 0x85, kResourceExhausted = 0x89, kNotFound = 0x8B, + // kUnknownEnumValue = 4, }; // Enum for DlUserStatus @@ -1061,6 +1153,7 @@ enum class DlUserStatus : uint8_t kAvailable = 0x00, kOccupiedEnabled = 0x01, kOccupiedDisabled = 0x03, + // kUnknownEnumValue = 2, }; // Enum for DlUserType @@ -1076,6 +1169,7 @@ enum class DlUserType : uint8_t kExpiringUser = 0x07, kScheduleRestrictedUser = 0x08, kRemoteOnlyUser = 0x09, + // kUnknownEnumValue = 10, }; // Enum for DoorLockOperationEventCode @@ -1096,6 +1190,7 @@ enum class DoorLockOperationEventCode : uint8_t kScheduleUnlock = 0x0C, kManualLock = 0x0D, kManualUnlock = 0x0E, + // kUnknownEnumValue = 15, }; // Enum for DoorLockProgrammingEventCode @@ -1108,6 +1203,7 @@ enum class DoorLockProgrammingEventCode : uint8_t kPinChanged = 0x04, kIdAdded = 0x05, kIdDeleted = 0x06, + // kUnknownEnumValue = 7, }; // Enum for DoorLockSetPinOrIdStatus @@ -1117,6 +1213,7 @@ enum class DoorLockSetPinOrIdStatus : uint8_t kGeneralFailure = 0x01, kMemoryFull = 0x02, kDuplicateCodeError = 0x03, + // kUnknownEnumValue = 4, }; // Enum for DoorLockUserStatus @@ -1126,6 +1223,7 @@ enum class DoorLockUserStatus : uint8_t kOccupiedEnabled = 0x01, kOccupiedDisabled = 0x03, kNotSupported = 0xFF, + // kUnknownEnumValue = 2, }; // Enum for DoorLockUserType @@ -1137,6 +1235,7 @@ enum class DoorLockUserType : uint8_t kMasterUser = 0x03, kNonAccessUser = 0x04, kNotSupported = 0xFF, + // kUnknownEnumValue = 5, }; // Bitmap for DlCredentialRuleMask @@ -1340,6 +1439,7 @@ enum class EndProductType : uint8_t kSwingingShutter = 0x16, kSlidingShutter = 0x17, kUnknown = 0xFF, + // kUnknownEnumValue = 24, }; // Enum for Type @@ -1356,6 +1456,7 @@ enum class Type : uint8_t kTiltBlindLiftAndTilt = 0x08, kProjectorScreen = 0x09, kUnknown = 0xFF, + // kUnknownEnumValue = 10, }; // Bitmap for ConfigStatus @@ -1429,6 +1530,7 @@ enum class PumpControlMode : uint8_t kConstantFlow = 0x03, kConstantTemperature = 0x05, kAutomatic = 0x07, + // kUnknownEnumValue = 4, }; // Enum for PumpOperationMode @@ -1438,6 +1540,7 @@ enum class PumpOperationMode : uint8_t kMinimum = 0x01, kMaximum = 0x02, kLocal = 0x03, + // kUnknownEnumValue = 4, }; // Bitmap for PumpStatus @@ -1466,10 +1569,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 @@ -1480,6 +1585,7 @@ enum class ThermostatControlSequence : uint8_t kHeatingWithReheat = 0x03, kCoolingAndHeating = 0x04, kCoolingAndHeatingWithReheat = 0x05, + // kUnknownEnumValue = 6, }; // Enum for ThermostatRunningMode @@ -1488,6 +1594,7 @@ enum class ThermostatRunningMode : uint8_t kOff = 0x00, kCool = 0x03, kHeat = 0x04, + // kUnknownEnumValue = 1, }; // Enum for ThermostatSystemMode @@ -1500,6 +1607,7 @@ enum class ThermostatSystemMode : uint8_t kEmergencyHeating = 0x05, kPrecooling = 0x06, kFanOnly = 0x07, + // kUnknownEnumValue = 2, }; // Bitmap for DayOfWeek @@ -1545,6 +1653,7 @@ enum class FanModeSequenceType : uint8_t kOffLowHighAuto = 0x03, kOffOnAuto = 0x04, kOffOn = 0x05, + // kUnknownEnumValue = 6, }; // Enum for FanModeType @@ -1557,6 +1666,7 @@ enum class FanModeType : uint8_t kOn = 0x04, kAuto = 0x05, kSmart = 0x06, + // kUnknownEnumValue = 7, }; // Bitmap for FanControlFeature @@ -1605,10 +1715,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. @@ -1618,10 +1730,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. @@ -1632,10 +1746,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. @@ -1647,10 +1763,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. @@ -1661,10 +1779,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. @@ -1674,10 +1794,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. @@ -1688,10 +1810,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. @@ -1701,10 +1825,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 @@ -1746,6 +1872,7 @@ enum class LightSensorType : uint8_t { kPhotodiode = 0x00, kCmos = 0x01, + // kUnknownEnumValue = 2, }; } // namespace IlluminanceMeasurement @@ -1781,12 +1908,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 @@ -1805,6 +1934,7 @@ enum class TargetNavigatorStatusEnum : uint8_t kSuccess = 0x00, kTargetNotFound = 0x01, kNotAllowed = 0x02, + // kUnknownEnumValue = 3, }; } // namespace TargetNavigator @@ -1819,6 +1949,7 @@ enum class MediaPlaybackStatusEnum : uint8_t kNotActive = 0x03, kSpeedOutOfRange = 0x04, kSeekOutOfRange = 0x05, + // kUnknownEnumValue = 6, }; // Enum for PlaybackStateEnum @@ -1828,6 +1959,7 @@ enum class PlaybackStateEnum : uint8_t kPaused = 0x01, kNotPlaying = 0x02, kBuffering = 0x03, + // kUnknownEnumValue = 4, }; } // namespace MediaPlayback @@ -1848,6 +1980,7 @@ enum class InputTypeEnum : uint8_t kScart = 0x09, kUsb = 0x0A, kOther = 0x0B, + // kUnknownEnumValue = 12, }; // Bitmap for MediaInputFeature @@ -1951,6 +2084,7 @@ enum class CecKeyCode : uint8_t kF4Yellow = 0x74, kF5 = 0x75, kData = 0x76, + // kUnknownEnumValue = 14, }; // Enum for KeypadInputStatusEnum @@ -1959,6 +2093,7 @@ enum class KeypadInputStatusEnum : uint8_t kSuccess = 0x00, kUnsupportedKey = 0x01, kInvalidKeyInCurrentState = 0x02, + // kUnknownEnumValue = 3, }; // Bitmap for KeypadInputFeature @@ -1978,6 +2113,7 @@ enum class ContentLaunchStatusEnum : uint8_t kSuccess = 0x00, kUrlNotAvailable = 0x01, kAuthFailed = 0x02, + // kUnknownEnumValue = 3, }; // Enum for MetricTypeEnum @@ -1985,6 +2121,7 @@ enum class MetricTypeEnum : uint8_t { kPixels = 0x00, kPercentage = 0x01, + // kUnknownEnumValue = 2, }; // Enum for ParameterEnum @@ -2003,6 +2140,7 @@ enum class ParameterEnum : uint8_t kSport = 0x0A, kSportsTeam = 0x0B, kType = 0x0C, + // kUnknownEnumValue = 13, }; // Bitmap for ContentLauncherFeature @@ -2031,6 +2169,7 @@ enum class OutputTypeEnum : uint8_t kHeadphone = 0x03, kInternal = 0x04, kOther = 0x05, + // kUnknownEnumValue = 6, }; // Bitmap for AudioOutputFeature @@ -2048,6 +2187,7 @@ enum class ApplicationLauncherStatusEnum : uint8_t kSuccess = 0x00, kAppNotAvailable = 0x01, kSystemBusy = 0x02, + // kUnknownEnumValue = 3, }; // Bitmap for ApplicationLauncherFeature @@ -2066,6 +2206,7 @@ enum class ApplicationStatusEnum : uint8_t kActiveVisibleFocus = 0x01, kActiveHidden = 0x02, kActiveVisibleNotFocus = 0x03, + // kUnknownEnumValue = 4, }; } // namespace ApplicationBasic @@ -2084,6 +2225,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 dd2dacc10db2ee..f9376a07e5e81e 100644 --- a/zzz_generated/chip-tool/zap-generated/test/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/test/Commands.h @@ -40248,7 +40248,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); @@ -40283,7 +40283,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; @@ -41326,10 +41326,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; @@ -41337,7 +41346,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; @@ -41345,7 +41354,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; @@ -41353,7 +41362,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; @@ -41361,7 +41370,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; @@ -41369,7 +41378,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; @@ -41377,7 +41386,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; @@ -41393,7 +41402,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; @@ -41401,7 +41410,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; @@ -41409,7 +41418,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; @@ -41438,7 +41447,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; @@ -41449,7 +41458,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; @@ -41457,7 +41466,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; @@ -41465,7 +41474,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; @@ -41473,7 +41482,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; @@ -41481,10 +41490,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; @@ -41503,10 +41512,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; @@ -41529,10 +41538,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 @@ -41560,7 +41569,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; @@ -41575,7 +41584,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; @@ -41583,7 +41592,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< @@ -41604,10 +41613,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< @@ -41641,10 +41650,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; @@ -41653,10 +41662,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; @@ -41665,7 +41674,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; @@ -41673,10 +41682,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; @@ -41685,10 +41694,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; @@ -41698,10 +41707,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; @@ -41709,7 +41718,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; @@ -41717,10 +41726,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; @@ -41729,10 +41738,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; @@ -41741,10 +41750,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; @@ -41752,10 +41761,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; @@ -41764,10 +41773,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; @@ -41776,10 +41785,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; @@ -41787,10 +41796,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; @@ -41799,10 +41808,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; @@ -41811,10 +41820,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; @@ -41822,10 +41831,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; @@ -41834,10 +41843,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; @@ -41846,10 +41855,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; @@ -41858,7 +41867,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; @@ -41866,10 +41875,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; @@ -41877,7 +41886,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; @@ -41886,7 +41895,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; @@ -41894,10 +41903,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; @@ -41906,7 +41915,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; @@ -41914,10 +41923,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; @@ -41926,10 +41935,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; @@ -41938,10 +41947,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; @@ -41950,10 +41959,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; @@ -41961,7 +41970,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; @@ -41970,7 +41979,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; @@ -41978,10 +41987,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; @@ -41990,7 +41999,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; @@ -41998,10 +42007,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; @@ -42010,10 +42019,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; @@ -42022,10 +42031,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; @@ -42034,10 +42043,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; @@ -42045,7 +42054,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; @@ -42054,7 +42063,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; @@ -42062,10 +42071,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; @@ -42074,7 +42083,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; @@ -42082,10 +42091,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; @@ -42094,10 +42103,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; @@ -42106,10 +42115,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; @@ -42118,10 +42127,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; @@ -42129,7 +42138,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; @@ -42138,7 +42147,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; @@ -42146,10 +42155,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; @@ -42158,7 +42167,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; @@ -42166,10 +42175,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; @@ -42178,10 +42187,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; @@ -42190,10 +42199,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; @@ -42201,7 +42210,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; @@ -42210,7 +42219,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; @@ -42218,10 +42227,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; @@ -42230,7 +42239,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; @@ -42238,10 +42247,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; @@ -42250,10 +42259,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; @@ -42262,10 +42271,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; @@ -42273,7 +42282,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; @@ -42282,7 +42291,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; @@ -42290,10 +42299,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; @@ -42302,7 +42311,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; @@ -42310,10 +42319,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; @@ -42322,10 +42331,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; @@ -42334,10 +42343,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; @@ -42345,7 +42354,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; @@ -42354,7 +42363,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; @@ -42362,10 +42371,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; @@ -42374,7 +42383,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; @@ -42382,10 +42391,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; @@ -42394,10 +42403,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; @@ -42406,10 +42415,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; @@ -42417,7 +42426,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; @@ -42426,7 +42435,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; @@ -42434,10 +42443,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; @@ -42446,7 +42455,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; @@ -42454,10 +42463,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; @@ -42466,10 +42475,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; @@ -42478,10 +42487,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; @@ -42490,10 +42499,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; @@ -42501,10 +42510,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; @@ -42513,10 +42522,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; @@ -42525,10 +42534,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; @@ -42537,10 +42546,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; @@ -42549,10 +42558,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; @@ -42560,10 +42569,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; @@ -42572,10 +42581,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; @@ -42584,10 +42593,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; @@ -42596,10 +42605,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; @@ -42608,10 +42617,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; @@ -42619,10 +42628,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; @@ -42631,10 +42640,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; @@ -42643,10 +42652,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; @@ -42655,10 +42664,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; @@ -42666,10 +42675,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; @@ -42678,35 +42687,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; @@ -42714,15 +42723,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; @@ -42732,10 +42741,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; @@ -42759,10 +42768,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; @@ -42770,10 +42779,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; @@ -42783,7 +42792,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; @@ -42791,7 +42800,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; @@ -42800,10 +42809,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; @@ -42826,7 +42835,7 @@ class TestClusterSuite : public TestCommand } } break; - case 364: + case 365: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::Nullable value; @@ -42842,10 +42851,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; @@ -42853,10 +42862,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; @@ -42865,7 +42874,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; @@ -42873,19 +42882,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; @@ -42904,10 +42913,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; @@ -42927,7 +42936,7 @@ class TestClusterSuite : public TestCommand } shouldContinue = true; break; - case 377: + case 378: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { uint8_t value; @@ -42935,9 +42944,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; @@ -42948,6 +42954,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; @@ -42955,10 +42964,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; @@ -42966,10 +42975,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; @@ -42977,10 +42986,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; @@ -42988,7 +42997,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; @@ -42996,9 +43005,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; @@ -43009,6 +43015,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; @@ -43016,10 +43025,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; @@ -43027,10 +43036,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; @@ -43038,10 +43047,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; @@ -43049,7 +43058,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; @@ -43057,9 +43066,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; @@ -43070,6 +43076,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; @@ -43077,10 +43086,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; @@ -43088,10 +43097,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; @@ -43099,10 +43108,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; @@ -43110,7 +43119,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; @@ -43118,9 +43127,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; @@ -43131,6 +43137,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; @@ -43138,10 +43147,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; @@ -43149,10 +43158,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; @@ -43160,10 +43169,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; @@ -43171,7 +43180,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; @@ -43180,9 +43189,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; @@ -43193,6 +43199,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; @@ -43201,10 +43210,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; @@ -43213,10 +43222,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; @@ -43225,10 +43234,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; @@ -43237,10 +43246,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; @@ -43248,7 +43257,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; @@ -43257,9 +43266,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; @@ -43270,6 +43276,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; @@ -43278,10 +43287,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; @@ -43290,10 +43299,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; @@ -43302,10 +43311,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; @@ -43314,10 +43323,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; @@ -43325,7 +43334,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; @@ -43334,9 +43343,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; @@ -43347,6 +43353,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; @@ -43355,10 +43364,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; @@ -43367,10 +43376,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; @@ -43379,10 +43388,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; @@ -43391,10 +43400,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; @@ -43402,7 +43411,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; @@ -43411,9 +43420,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; @@ -43424,6 +43430,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; @@ -43432,10 +43441,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; @@ -43444,10 +43453,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; @@ -43456,10 +43465,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; @@ -43468,10 +43477,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; @@ -43479,19 +43488,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; @@ -43538,7 +43547,7 @@ class TestClusterSuite : public TestCommand } } break; - case 486: + case 487: VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), 0)); { chip::app::DataModel::DecodableList value; @@ -43567,10 +43576,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; @@ -44657,14 +44666,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; @@ -44682,8 +44702,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; @@ -44701,8 +44721,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; @@ -44723,8 +44743,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; @@ -44745,8 +44765,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; @@ -44824,8 +44844,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; @@ -44903,8 +44923,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; @@ -44922,8 +44942,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; @@ -44946,8 +44966,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; @@ -44971,8 +44991,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; @@ -44995,8 +45015,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; @@ -45006,8 +45026,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; @@ -45043,8 +45063,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; @@ -45080,8 +45100,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; @@ -45169,8 +45189,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; @@ -45257,8 +45277,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; @@ -45274,13 +45294,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; @@ -45296,13 +45316,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; @@ -45333,13 +45353,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(); @@ -45350,8 +45370,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, @@ -45359,13 +45379,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; @@ -45395,26 +45415,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(); @@ -45422,18 +45442,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(); @@ -45441,13 +45461,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(); @@ -45455,31 +45475,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(); @@ -45487,13 +45507,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(); @@ -45501,26 +45521,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(); @@ -45528,13 +45548,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(); @@ -45542,26 +45562,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(); @@ -45569,13 +45589,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(); @@ -45583,26 +45603,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(); @@ -45610,13 +45630,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(); @@ -45624,13 +45644,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(); @@ -45638,41 +45658,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(); @@ -45680,18 +45700,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(); @@ -45699,13 +45719,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(); @@ -45713,13 +45733,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(); @@ -45727,36 +45747,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(); @@ -45764,18 +45784,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(); @@ -45783,13 +45803,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(); @@ -45797,13 +45817,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(); @@ -45811,36 +45831,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(); @@ -45848,18 +45868,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(); @@ -45867,13 +45887,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(); @@ -45881,13 +45901,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(); @@ -45895,36 +45915,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(); @@ -45932,18 +45952,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(); @@ -45951,13 +45971,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(); @@ -45965,36 +45985,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(); @@ -46002,18 +46022,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(); @@ -46021,13 +46041,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(); @@ -46035,36 +46055,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(); @@ -46072,18 +46092,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(); @@ -46091,13 +46111,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(); @@ -46105,36 +46125,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(); @@ -46142,18 +46162,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(); @@ -46161,13 +46181,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(); @@ -46175,36 +46195,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(); @@ -46212,18 +46232,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(); @@ -46231,13 +46251,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(); @@ -46245,13 +46265,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(); @@ -46259,26 +46279,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(); @@ -46286,13 +46306,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(); @@ -46300,13 +46320,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(); @@ -46314,13 +46334,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(); @@ -46328,26 +46348,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(); @@ -46355,13 +46375,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(); @@ -46369,13 +46389,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(); @@ -46383,13 +46403,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(); @@ -46397,26 +46417,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(); @@ -46424,13 +46444,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(); @@ -46438,13 +46458,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(); @@ -46452,26 +46472,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(); @@ -46479,27 +46499,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(); @@ -46507,36 +46527,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(); @@ -46544,26 +46564,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(); @@ -46571,23 +46591,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(); @@ -46595,31 +46615,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(); @@ -46627,28 +46647,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, @@ -46656,8 +46676,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(); @@ -46667,13 +46687,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; @@ -46689,98 +46709,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; @@ -46788,8 +46808,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; @@ -46797,8 +46817,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; @@ -46806,8 +46826,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; @@ -46815,13 +46835,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; @@ -46829,13 +46849,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; @@ -46843,13 +46863,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; @@ -46857,99 +46877,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; @@ -46957,8 +46977,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; @@ -46966,8 +46986,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; @@ -46975,8 +46995,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; @@ -46984,13 +47004,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; @@ -46998,13 +47018,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; @@ -47012,13 +47032,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; @@ -47026,18 +47046,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(); @@ -47046,8 +47066,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(); @@ -47056,8 +47076,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(); @@ -47066,8 +47086,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(); @@ -47076,13 +47096,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(); @@ -47091,13 +47111,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(); @@ -47106,13 +47126,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(); @@ -47121,13 +47141,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(); @@ -47135,18 +47155,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(); @@ -47155,8 +47175,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(); @@ -47165,8 +47185,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(); @@ -47175,8 +47195,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(); @@ -47185,13 +47205,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(); @@ -47200,13 +47220,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(); @@ -47215,13 +47235,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(); @@ -47230,13 +47250,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(); @@ -47244,18 +47264,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(); @@ -47264,8 +47284,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(); @@ -47274,8 +47294,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(); @@ -47284,8 +47304,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(); @@ -47294,13 +47314,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(); @@ -47309,13 +47329,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(); @@ -47324,13 +47344,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(); @@ -47339,13 +47359,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(); @@ -47353,18 +47373,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(); @@ -47373,8 +47393,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(); @@ -47383,8 +47403,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(); @@ -47393,8 +47413,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(); @@ -47403,13 +47423,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(); @@ -47418,13 +47438,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(); @@ -47433,13 +47453,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(); @@ -47448,13 +47468,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(); @@ -47462,49 +47482,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; @@ -47520,8 +47540,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); } @@ -48606,7 +48626,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; @@ -48710,7 +48730,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 cc5b86604ccaee..d70f315fb643d2 100644 --- a/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h +++ b/zzz_generated/darwin-framework-tool/zap-generated/test/Commands.h @@ -66755,890 +66755,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( @@ -67646,552 +67645,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; } @@ -68769,10 +68773,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)); @@ -68790,10 +68794,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)); @@ -68808,10 +68812,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)); @@ -68826,10 +68830,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)); @@ -68850,10 +68854,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)); @@ -68892,10 +68896,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)); @@ -68931,10 +68935,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)); @@ -68970,10 +68974,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)); @@ -69003,10 +69007,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)); @@ -69036,10 +69040,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)); @@ -69069,10 +69073,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)); @@ -69102,10 +69106,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)); @@ -69201,10 +69205,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)); @@ -69225,10 +69229,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)); @@ -69249,10 +69253,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)); @@ -69315,16 +69319,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)); @@ -69342,7 +69346,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)); @@ -69354,7 +69358,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)); @@ -69378,7 +69382,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)); @@ -69390,7 +69394,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)); @@ -69414,7 +69418,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)); @@ -69426,7 +69430,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)); @@ -69450,7 +69454,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)); @@ -69462,7 +69466,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)); @@ -69486,7 +69490,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)); @@ -69498,7 +69502,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)); @@ -69528,7 +69532,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)); @@ -69540,7 +69544,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)); @@ -69570,7 +69574,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)); @@ -69582,7 +69586,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)); @@ -69612,7 +69616,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)); @@ -69624,7 +69628,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)); @@ -69651,19 +69655,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)); @@ -69674,6 +69678,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. @@ -69687,7 +69694,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; @@ -73392,7 +73399,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) { @@ -73407,7 +73414,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(); @@ -73416,7 +73457,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 @@ -73453,7 +73494,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 @@ -73490,7 +73531,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 @@ -73538,7 +73579,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 @@ -73586,7 +73627,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 @@ -73680,7 +73721,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 @@ -73774,7 +73815,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 @@ -73821,7 +73862,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 @@ -73862,7 +73903,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 @@ -73903,7 +73944,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 @@ -73952,7 +73993,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 @@ -73984,7 +74025,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 @@ -74037,7 +74078,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 @@ -74090,7 +74131,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 @@ -74190,7 +74231,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 @@ -74290,7 +74331,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 @@ -74319,7 +74360,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 @@ -74347,7 +74388,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 @@ -74376,7 +74417,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 @@ -74404,7 +74445,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 @@ -74445,7 +74486,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 @@ -74481,7 +74522,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 @@ -74525,7 +74566,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 @@ -74552,7 +74593,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 @@ -74585,7 +74626,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 @@ -74623,7 +74664,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 @@ -74663,7 +74704,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 @@ -74686,7 +74727,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 @@ -74713,7 +74754,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 @@ -74735,7 +74776,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 @@ -74760,7 +74801,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 @@ -74783,7 +74824,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 @@ -74805,7 +74846,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 @@ -74830,7 +74871,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 @@ -74853,7 +74894,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 @@ -74881,7 +74922,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 @@ -74903,7 +74944,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 @@ -74927,7 +74968,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 @@ -74950,7 +74991,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 @@ -74972,7 +75013,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 @@ -74997,7 +75038,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 @@ -75019,7 +75060,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 @@ -75044,7 +75085,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 @@ -75066,7 +75107,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 @@ -75090,7 +75131,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 @@ -75112,7 +75153,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 @@ -75137,7 +75178,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 @@ -75159,7 +75200,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 @@ -75184,7 +75225,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 @@ -75206,7 +75247,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 @@ -75230,7 +75271,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 @@ -75252,7 +75293,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 @@ -75277,7 +75318,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 @@ -75299,7 +75340,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 @@ -75324,7 +75365,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 @@ -75346,7 +75387,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 @@ -75370,7 +75411,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 @@ -75392,7 +75433,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 @@ -75417,7 +75458,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 @@ -75439,7 +75480,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 @@ -75464,7 +75505,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 @@ -75485,7 +75526,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 @@ -75510,7 +75551,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 @@ -75533,7 +75574,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 @@ -75555,7 +75596,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 @@ -75579,7 +75620,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 @@ -75604,7 +75645,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 @@ -75627,7 +75668,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 @@ -75649,7 +75690,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 @@ -75674,7 +75715,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 @@ -75697,7 +75738,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 @@ -75719,7 +75760,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 @@ -75744,7 +75785,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 @@ -75766,7 +75807,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 @@ -75791,7 +75832,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 @@ -75813,7 +75854,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 @@ -75838,7 +75879,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 @@ -75860,7 +75901,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 @@ -75884,7 +75925,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 @@ -75909,7 +75950,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 @@ -75932,7 +75973,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 @@ -75954,7 +75995,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 @@ -75979,7 +76020,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 @@ -76002,7 +76043,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 @@ -76024,7 +76065,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 @@ -76049,7 +76090,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 @@ -76071,7 +76112,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 @@ -76096,7 +76137,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 @@ -76118,7 +76159,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 @@ -76143,7 +76184,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 @@ -76165,7 +76206,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 @@ -76189,7 +76230,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 @@ -76214,7 +76255,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 @@ -76237,7 +76278,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 @@ -76259,7 +76300,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 @@ -76284,7 +76325,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 @@ -76307,7 +76348,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 @@ -76329,7 +76370,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 @@ -76354,7 +76395,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 @@ -76376,7 +76417,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 @@ -76401,7 +76442,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 @@ -76423,7 +76464,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 @@ -76448,7 +76489,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 @@ -76470,7 +76511,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 @@ -76494,7 +76535,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 @@ -76520,7 +76561,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 @@ -76543,7 +76584,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 @@ -76565,7 +76606,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 @@ -76591,7 +76632,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 @@ -76614,7 +76655,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 @@ -76636,7 +76677,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 @@ -76661,7 +76702,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 @@ -76682,7 +76723,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 @@ -76707,7 +76748,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 @@ -76729,7 +76770,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 @@ -76753,7 +76794,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 @@ -76778,7 +76819,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 @@ -76801,7 +76842,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 @@ -76823,7 +76864,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 @@ -76848,7 +76889,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 @@ -76871,7 +76912,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 @@ -76893,7 +76934,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 @@ -76918,7 +76959,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 @@ -76940,7 +76981,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 @@ -76965,7 +77006,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 @@ -76987,7 +77028,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 @@ -77011,7 +77052,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 @@ -77036,7 +77077,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 @@ -77059,7 +77100,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 @@ -77081,7 +77122,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 @@ -77106,7 +77147,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 @@ -77129,7 +77170,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 @@ -77151,7 +77192,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 @@ -77176,7 +77217,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 @@ -77198,7 +77239,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 @@ -77223,7 +77264,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 @@ -77245,7 +77286,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 @@ -77269,7 +77310,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 @@ -77294,7 +77335,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 @@ -77317,7 +77358,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 @@ -77339,7 +77380,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 @@ -77364,7 +77405,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 @@ -77387,7 +77428,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 @@ -77409,7 +77450,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 @@ -77434,7 +77475,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 @@ -77456,7 +77497,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 @@ -77481,7 +77522,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 @@ -77503,7 +77544,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 @@ -77527,7 +77568,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 @@ -77552,7 +77593,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 @@ -77575,7 +77616,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 @@ -77597,7 +77638,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 @@ -77622,7 +77663,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 @@ -77645,7 +77686,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 @@ -77667,7 +77708,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 @@ -77692,7 +77733,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 @@ -77714,7 +77755,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 @@ -77739,7 +77780,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 @@ -77761,7 +77802,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 @@ -77786,7 +77827,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 @@ -77808,7 +77849,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 @@ -77832,7 +77873,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 @@ -77854,7 +77895,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 @@ -77879,7 +77920,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 @@ -77901,7 +77942,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 @@ -77926,7 +77967,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 @@ -77948,7 +77989,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 @@ -77973,7 +78014,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 @@ -77995,7 +78036,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 @@ -78020,7 +78061,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 @@ -78042,7 +78083,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 @@ -78066,7 +78107,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 @@ -78088,7 +78129,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 @@ -78113,7 +78154,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 @@ -78135,7 +78176,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 @@ -78160,7 +78201,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 @@ -78182,7 +78223,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 @@ -78207,7 +78248,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 @@ -78228,7 +78269,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 @@ -78253,7 +78294,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 @@ -78275,7 +78316,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 @@ -78299,7 +78340,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 @@ -78321,7 +78362,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 @@ -78346,7 +78387,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 @@ -78368,7 +78409,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 @@ -78393,7 +78434,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 @@ -78415,7 +78456,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 @@ -78440,7 +78481,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 @@ -78462,7 +78503,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 @@ -78486,7 +78527,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 @@ -78508,7 +78549,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 @@ -78533,7 +78574,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 @@ -78542,7 +78583,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); @@ -78555,7 +78596,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 @@ -78571,7 +78612,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(); @@ -78580,7 +78621,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 @@ -78601,9 +78642,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 @@ -78619,10 +78660,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(); @@ -78631,7 +78672,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 @@ -78653,7 +78694,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 @@ -78677,7 +78718,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 @@ -78686,13 +78727,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(); }]; @@ -78700,7 +78741,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 @@ -78726,7 +78767,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 @@ -78749,7 +78790,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 @@ -78778,7 +78819,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 @@ -78800,7 +78841,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 @@ -78824,7 +78865,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 @@ -78846,7 +78887,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 @@ -78872,7 +78913,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 @@ -78895,7 +78936,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 @@ -78920,7 +78961,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 @@ -78943,7 +78984,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 @@ -78971,7 +79012,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 @@ -79000,7 +79041,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 @@ -79022,7 +79063,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 @@ -79046,7 +79087,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 @@ -79068,7 +79109,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 @@ -79093,7 +79134,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 @@ -79116,7 +79157,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 @@ -79134,7 +79175,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 @@ -79152,7 +79193,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 @@ -79174,7 +79215,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 @@ -79197,10 +79238,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 @@ -79222,14 +79263,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 @@ -79245,7 +79286,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) { @@ -79262,7 +79303,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 @@ -79291,7 +79332,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 @@ -79319,7 +79360,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 @@ -79343,7 +79384,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 @@ -79366,7 +79407,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 @@ -79390,7 +79431,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 @@ -79414,7 +79455,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 @@ -79437,7 +79478,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 @@ -79461,7 +79502,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 @@ -79485,7 +79526,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 @@ -79509,7 +79550,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 @@ -79533,7 +79574,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 @@ -79557,7 +79598,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 @@ -79581,7 +79622,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 @@ -79605,7 +79646,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 @@ -79629,7 +79670,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 @@ -79652,7 +79693,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 @@ -79676,7 +79717,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 @@ -79700,7 +79741,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 @@ -79723,7 +79764,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 @@ -79747,7 +79788,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 @@ -79771,7 +79812,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 @@ -79795,7 +79836,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 @@ -79819,7 +79860,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 @@ -79843,7 +79884,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 @@ -79868,7 +79909,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 @@ -79892,7 +79933,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 @@ -79916,7 +79957,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 @@ -79938,7 +79979,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 @@ -79963,7 +80004,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 @@ -79988,7 +80029,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 @@ -80010,7 +80051,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 @@ -80034,7 +80075,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 @@ -80057,7 +80098,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 @@ -80081,7 +80122,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 @@ -80104,7 +80145,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 @@ -80128,7 +80169,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 @@ -80152,7 +80193,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 @@ -80176,7 +80217,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 @@ -80200,7 +80241,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 @@ -80223,7 +80264,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 @@ -80247,7 +80288,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 @@ -80271,7 +80312,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 @@ -80294,7 +80335,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 @@ -80318,7 +80359,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 @@ -80342,7 +80383,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 @@ -80366,7 +80407,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 @@ -80390,7 +80431,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 @@ -80414,7 +80455,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 @@ -80438,7 +80479,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 @@ -80462,7 +80503,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 @@ -80488,7 +80529,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 @@ -80512,7 +80553,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 @@ -80536,7 +80577,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 @@ -80560,7 +80601,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 @@ -80584,7 +80625,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 @@ -80610,7 +80651,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 @@ -80634,7 +80675,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 @@ -80660,7 +80701,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 @@ -80684,7 +80725,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 @@ -80710,7 +80751,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 @@ -80734,7 +80775,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 @@ -80760,7 +80801,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 @@ -80784,7 +80825,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 @@ -80809,7 +80850,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 @@ -80835,7 +80876,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 @@ -80859,7 +80900,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 @@ -80883,7 +80924,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 @@ -80907,7 +80948,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 @@ -80931,7 +80972,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 @@ -80957,7 +80998,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 @@ -80981,7 +81022,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 @@ -81007,7 +81048,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 @@ -81031,7 +81072,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 @@ -81057,7 +81098,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 @@ -81081,7 +81122,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 @@ -81107,7 +81148,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 @@ -81131,7 +81172,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 @@ -81156,7 +81197,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 @@ -81182,7 +81223,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 @@ -81206,7 +81247,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 @@ -81230,7 +81271,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 @@ -81254,7 +81295,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 @@ -81278,7 +81319,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 @@ -81304,7 +81345,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 @@ -81328,7 +81369,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 @@ -81354,7 +81395,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 @@ -81378,7 +81419,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 @@ -81404,7 +81445,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 @@ -81428,7 +81469,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 @@ -81454,7 +81495,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 @@ -81478,7 +81519,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 @@ -81503,7 +81544,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 @@ -81529,7 +81570,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 @@ -81553,7 +81594,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 @@ -81577,7 +81618,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 @@ -81601,7 +81642,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 @@ -81625,7 +81666,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 @@ -81651,7 +81692,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 @@ -81675,7 +81716,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 @@ -81701,7 +81742,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 @@ -81725,7 +81766,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 @@ -81751,7 +81792,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 @@ -81775,7 +81816,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 @@ -81801,7 +81842,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 @@ -81825,7 +81866,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 @@ -81850,7 +81891,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 @@ -81872,7 +81913,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 @@ -81894,7 +81935,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 @@ -81912,7 +81953,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 @@ -81930,7 +81971,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 @@ -81972,7 +82013,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 @@ -82005,7 +82046,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 @@ -82036,7 +82077,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