From 6ddd96b13422bc2776c42e49209e7d1b82ab5b42 Mon Sep 17 00:00:00 2001 From: Boris Zbarsky Date: Thu, 25 Nov 2021 02:25:11 -0500 Subject: [PATCH] Add support for float and double types. * Adds Encode and Decode support for float and double. * Adds support for float/double in various code generation type helpers (for chip-tool, java, darwin). * Adds float and double members to the SimpleStruct test struct. * Adds a command to send and receive a SimpleStruct, and a yaml test that does that. * Fixes chip-tool to handle BitFlags value checking correctly (since SimpleStruct has a BitFlags member). * Removes some code in ClustersHelper.js that failed for float/double types and whose output was completely unused. * Fixes templates for old-style commands and java that completely blew up on structs in a response command field to at least generate code successfully, though that code wouldn't work right if it ever ran. --- .../all-clusters-common/all-clusters-app.zap | 20 +- .../chip-tool/commands/tests/TestCommand.h | 7 + examples/chip-tool/templates/commands.zapt | 7 + .../partials/test_cluster_command_value.zapt | 2 +- .../partials/test_cluster_value_equals.zapt | 2 +- .../test-cluster-server.cpp | 21 + src/app/data-model/Decode.h | 6 + src/app/data-model/Encode.h | 6 + src/app/tests/suites/TestCluster.yaml | 71 + .../zap-templates/common/ClustersHelper.js | 70 +- src/app/zap-templates/common/override.js | 2 + .../im_command_handler_cluster_commands.zapt | 15 +- .../app/CHIPClientCallbacks-src.zapt | 14 +- src/app/zap-templates/templates/app/helper.js | 16 +- .../zcl/data-model/chip/test-cluster.xml | 19 + .../data_model/controller-clusters.zap | 18 +- .../templates/CHIPInvokeCallbacks-src.zapt | 2 +- .../java/templates/ClusterInfo-java.zapt | 9 +- src/controller/java/templates/helper.js | 12 + .../partials/command_callback_responses.zapt | 8 + .../java/zap-generated/CHIPCallbackTypes.h | 2 + .../java/zap-generated/CHIPClusters-JNI.cpp | 46 +- .../zap-generated/CHIPInvokeCallbacks.cpp | 58 + .../java/zap-generated/CHIPInvokeCallbacks.h | 15 + .../chip/devicecontroller/ChipClusters.java | 53 +- .../devicecontroller/ClusterInfoMapping.java | 116 +- .../python/chip/clusters/CHIPClusters.py | 18 + .../python/chip/clusters/Objects.py | 38 + src/darwin/Framework/CHIP/templates/helper.js | 4 + .../templates/partials/check_test_value.zapt | 9 +- .../CHIP/templates/partials/test_cluster.zapt | 2 +- .../CHIP/templates/partials/test_value.zapt | 2 +- .../CHIP/zap-generated/CHIPCallbackBridge.mm | 27 + .../CHIPCallbackBridge_internal.h | 15 + .../CHIP/zap-generated/CHIPClustersObjc.h | 3 + .../CHIP/zap-generated/CHIPClustersObjc.mm | 31 + .../zap-generated/CHIPCommandPayloadsObjc.h | 10 + .../zap-generated/CHIPCommandPayloadsObjc.mm | 22 + .../CHIP/zap-generated/CHIPStructsObjc.h | 2 + .../CHIP/zap-generated/CHIPStructsObjc.mm | 4 + .../zap-generated/CHIPTestClustersObjc.mm | 6 + .../Framework/CHIPTests/CHIPClustersTests.m | 421 ++- .../zap-generated/IMClusterCommandHandler.cpp | 9 + .../zap-generated/attribute-size.cpp | 4 +- .../app-common/zap-generated/af-structs.h | 2 + .../app-common/zap-generated/callback.h | 12 + .../zap-generated/cluster-objects.cpp | 76 + .../zap-generated/cluster-objects.h | 74 + .../app-common/zap-generated/command-id.h | 2 + .../app-common/zap-generated/ids/Commands.h | 8 + .../zap-generated/cluster/Commands.h | 66 + .../chip-tool/zap-generated/test/Commands.h | 3053 +++++++++-------- .../zap-generated/CHIPClientCallbacks.cpp | 15 + .../zap-generated/CHIPClientCallbacks.h | 1 + .../zap-generated/CHIPClusters.cpp | 69 +- .../zap-generated/CHIPClusters.h | 9 +- .../zap-generated/IMClusterCommandHandler.cpp | 59 + 57 files changed, 2879 insertions(+), 1811 deletions(-) diff --git a/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap b/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap index a7e623c0a39423..c982a6f1f92318 100644 --- a/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap +++ b/examples/all-clusters-app/all-clusters-common/all-clusters-app.zap @@ -32,7 +32,7 @@ "endpointTypes": [ { "name": "Anonymous Endpoint Type", - "deviceTypeName": "CHIP-All-Clusters-Server", + "deviceTypeName": "MA-all-clusters-app", "deviceTypeCode": 0, "deviceTypeProfileId": 259, "clusters": [ @@ -6812,7 +6812,7 @@ }, { "name": "Anonymous Endpoint Type", - "deviceTypeName": "CHIP-All-Clusters-Server", + "deviceTypeName": "MA-all-clusters-app", "deviceTypeCode": 0, "deviceTypeProfileId": 259, "clusters": [ @@ -15311,6 +15311,14 @@ "source": "client", "incoming": 1, "outgoing": 0 + }, + { + "name": "SimpleStructEchoRequest", + "code": 17, + "mfgCode": null, + "source": "client", + "incoming": 1, + "outgoing": 0 } ], "attributes": [ @@ -15378,6 +15386,14 @@ "source": "server", "incoming": 0, "outgoing": 1 + }, + { + "name": "SimpleStructResponse", + "code": 9, + "mfgCode": null, + "source": "server", + "incoming": 0, + "outgoing": 1 } ], "attributes": [ diff --git a/examples/chip-tool/commands/tests/TestCommand.h b/examples/chip-tool/commands/tests/TestCommand.h index ae1a28a915ef13..2f0b714847c5e8 100644 --- a/examples/chip-tool/commands/tests/TestCommand.h +++ b/examples/chip-tool/commands/tests/TestCommand.h @@ -24,6 +24,7 @@ #include #include #include +#include #include #include #include @@ -118,6 +119,12 @@ class TestCommand : public CHIPCommand return true; } + template + bool CheckValue(const char * itemName, chip::BitFlags current, U expected) + { + return CheckValue(itemName, current.Raw(), expected); + } + template ::value, int> = 0> bool CheckValue(const char * itemName, T current, U expected) { diff --git a/examples/chip-tool/templates/commands.zapt b/examples/chip-tool/templates/commands.zapt index f3421ffe5dfa0d..a9d05bbd323fe2 100644 --- a/examples/chip-tool/templates/commands.zapt +++ b/examples/chip-tool/templates/commands.zapt @@ -46,6 +46,13 @@ CHIP_ERROR LogValue(const char * label, size_t indent, X value) return CHIP_NO_ERROR; } +template ::value && !std::is_same>, bool>::value, int> = 0> +CHIP_ERROR LogValue(const char * label, size_t indent, X value) +{ + ChipLogProgress(chipTool, "%s%s: %s", IndentStr(indent).c_str(), label, std::to_string(value).c_str()); + return CHIP_NO_ERROR; +} + CHIP_ERROR LogValue(const char * label, size_t indent, bool value) { ChipLogProgress(chipTool, "%s%s: %s", IndentStr(indent).c_str(), label, value ? "TRUE" : "FALSE"); diff --git a/examples/chip-tool/templates/partials/test_cluster_command_value.zapt b/examples/chip-tool/templates/partials/test_cluster_command_value.zapt index e785c654dea935..147eb9a001d87f 100644 --- a/examples/chip-tool/templates/partials/test_cluster_command_value.zapt +++ b/examples/chip-tool/templates/partials/test_cluster_command_value.zapt @@ -39,7 +39,7 @@ {{#if_is_bitmap type}} static_cast<{{zapTypeToEncodableClusterObjectType type ns=ns}}>({{definedValue}}); {{else}} - {{definedValue}}{{asTypeLiteralSuffix type}}; + {{asTypedLiteral type definedValue}}; {{/if_is_bitmap}} {{/if_chip_enum}} {{/if_is_struct}} diff --git a/examples/chip-tool/templates/partials/test_cluster_value_equals.zapt b/examples/chip-tool/templates/partials/test_cluster_value_equals.zapt index 07d7343e4fa079..b73f954bde17c6 100644 --- a/examples/chip-tool/templates/partials/test_cluster_value_equals.zapt +++ b/examples/chip-tool/templates/partials/test_cluster_value_equals.zapt @@ -31,7 +31,7 @@ VerifyOrReturn(CheckValue {{~#if (isOctetString type)}}AsString("{{label}}", {{actual}}, chip::ByteSpan(chip::Uint8::from_const_char("{{octetStringEscapedForCLiteral expected}}"), {{expected.length}})) {{else if (isCharString type)}}AsString("{{label}}", {{actual}}, chip::CharSpan("{{expected}}", {{expected.length}})) - {{else}}<{{chipType}}>("{{label}}", {{actual}}, {{expected}}{{asTypeLiteralSuffix type}}) + {{else}}("{{label}}", {{actual}}, {{asTypedLiteral type expected}}) {{/if}} ); {{/if_is_struct}} diff --git a/src/app/clusters/test-cluster-server/test-cluster-server.cpp b/src/app/clusters/test-cluster-server/test-cluster-server.cpp index fe34de046e3691..6888a3481f5154 100644 --- a/src/app/clusters/test-cluster-server/test-cluster-server.cpp +++ b/src/app/clusters/test-cluster-server/test-cluster-server.cpp @@ -505,6 +505,27 @@ bool emberAfTestClusterClusterTestNullableOptionalRequestCallback( return true; } +bool emberAfTestClusterClusterSimpleStructEchoRequestCallback(CommandHandler * commandObj, const ConcreteCommandPath & commandPath, + const Commands::SimpleStructEchoRequest::DecodableType & commandData) +{ + Commands::SimpleStructResponse::Type response; + response.arg1.a = commandData.arg1.a; + response.arg1.b = commandData.arg1.b; + response.arg1.c = commandData.arg1.c; + response.arg1.d = commandData.arg1.d; + response.arg1.e = commandData.arg1.e; + response.arg1.f = commandData.arg1.f; + response.arg1.g = commandData.arg1.g; + response.arg1.h = commandData.arg1.h; + + CHIP_ERROR err = commandObj->AddResponseData(commandPath, response); + if (err != CHIP_NO_ERROR) + { + emberAfSendImmediateDefaultResponse(EMBER_ZCL_STATUS_FAILURE); + } + return true; +} + // ----------------------------------------------------------------------------- // Plugin initialization diff --git a/src/app/data-model/Decode.h b/src/app/data-model/Decode.h index 827a81425c06fc..f530dd31c1cd9f 100644 --- a/src/app/data-model/Decode.h +++ b/src/app/data-model/Decode.h @@ -37,6 +37,12 @@ CHIP_ERROR Decode(TLV::TLVReader & reader, X & x) return reader.Get(x); } +template ::value, int> = 0> +CHIP_ERROR Decode(TLV::TLVReader & reader, X & x) +{ + return reader.Get(x); +} + template ::value, int> = 0> CHIP_ERROR Decode(TLV::TLVReader & reader, X & x) { diff --git a/src/app/data-model/Encode.h b/src/app/data-model/Encode.h index 677934ae2e98a2..e78481b8344e7d 100644 --- a/src/app/data-model/Encode.h +++ b/src/app/data-model/Encode.h @@ -37,6 +37,12 @@ CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag, X x) return writer.Put(tag, x); } +template ::value, int> = 0> +CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag, X x) +{ + return writer.Put(tag, x); +} + template ::value, int> = 0> CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag, X x) { diff --git a/src/app/tests/suites/TestCluster.yaml b/src/app/tests/suites/TestCluster.yaml index cb3fe0bac77951..de7d2381bc44aa 100644 --- a/src/app/tests/suites/TestCluster.yaml +++ b/src/app/tests/suites/TestCluster.yaml @@ -874,6 +874,8 @@ tests: d: "octet_string", e: "char_string", f: 1, + g: 0, + h: 0, } response: values: @@ -893,6 +895,8 @@ tests: d: "octet_string", e: "char_string", f: 1, + g: 0, + h: 0, } response: values: @@ -918,6 +922,8 @@ tests: d: "octet_string", e: "char_string", f: 1, + g: 0, + h: 0, }, } response: @@ -943,6 +949,8 @@ tests: d: "octet_string", e: "char_string", f: 1, + g: 0, + h: 0, }, } response: @@ -970,6 +978,8 @@ tests: d: "octet_string", e: "char_string", f: 1, + g: 0, + h: 0, }, d: [ @@ -980,6 +990,8 @@ tests: d: "nested_octet_string", e: "nested_char_string", f: 1, + g: 0, + h: 0, }, { a: 2, @@ -988,6 +1000,8 @@ tests: d: "nested_octet_string", e: "nested_char_string", f: 1, + g: 0, + h: 0, }, ], e: [1, 2, 3], @@ -1024,6 +1038,8 @@ tests: d: "octet_string", e: "char_string", f: 1, + g: 0, + h: 0, }, d: [ @@ -1034,6 +1050,8 @@ tests: d: "nested_octet_string", e: "nested_char_string", f: 1, + g: 0, + h: 0, }, { a: 2, @@ -1042,6 +1060,8 @@ tests: d: "nested_octet_string", e: "nested_char_string", f: 1, + g: 0, + h: 0, }, ], e: [1, 2, 3], @@ -1058,6 +1078,37 @@ tests: - name: "value" value: false + - label: "Send Test Command With Struct Argument and see what we get back" + command: "SimpleStructEchoRequest" + arguments: + values: + - name: "arg1" + value: + { + a: 17, + b: false, + c: 2, + d: "octet_string", + e: "char_string", + f: 1, + g: 0.1, + h: 0.1, + } + response: + values: + - name: "arg1" + value: + { + a: 17, + b: false, + c: 2, + d: "octet_string", + e: "char_string", + f: 1, + g: 0.1, + h: 0.1, + } + # Tests for List - label: "Send Test Command With List of INT8U and none of them is set to 0" @@ -1121,6 +1172,8 @@ tests: d: "first_octet_string", e: "first_char_string", f: 1, + g: 0, + h: 0, }, { a: 1, @@ -1129,6 +1182,8 @@ tests: d: "second_octet_string", e: "second_char_string", f: 1, + g: 0, + h: 0, }, ] response: @@ -1152,6 +1207,8 @@ tests: d: "second_octet_string", e: "second_char_string", f: 1, + g: 0, + h: 0, }, { a: 0, @@ -1160,6 +1217,8 @@ tests: d: "first_octet_string", e: "first_char_string", f: 1, + g: 0, + h: 0, }, ] response: @@ -1188,6 +1247,8 @@ tests: d: "octet_string", e: "char_string", f: 1, + g: 0, + h: 0, }, d: [ @@ -1198,6 +1259,8 @@ tests: d: "nested_octet_string", e: "nested_char_string", f: 1, + g: 0, + h: 0, }, { a: 2, @@ -1206,6 +1269,8 @@ tests: d: "nested_octet_string", e: "nested_char_string", f: 1, + g: 0, + h: 0, }, ], e: [1, 2, 3], @@ -1244,6 +1309,8 @@ tests: d: "octet_string", e: "char_string", f: 1, + g: 0, + h: 0, }, d: [ @@ -1254,6 +1321,8 @@ tests: d: "nested_octet_string", e: "nested_char_string", f: 1, + g: 0, + h: 0, }, { a: 2, @@ -1262,6 +1331,8 @@ tests: d: "nested_octet_string", e: "nested_char_string", f: 1, + g: 0, + h: 0, }, ], e: [1, 2, 3], diff --git a/src/app/zap-templates/common/ClustersHelper.js b/src/app/zap-templates/common/ClustersHelper.js index 45aaca3c038508..e487a5ef29a822 100644 --- a/src/app/zap-templates/common/ClustersHelper.js +++ b/src/app/zap-templates/common/ClustersHelper.js @@ -151,54 +151,6 @@ function loadGlobalAttributes(packageId) // Load step 2 // -/** - * This method converts a ZCL type to the length expected for the - * BufferWriter.Put method. - * TODO - * Not all types are supported at the moment, so if there is any unsupported type - * that we are trying to convert, it will throw an error. - */ -function asPutLength(zclType) -{ - const type = ChipTypesHelper.asBasicType(zclType); - switch (type) { - case 'bool': - return '8'; - case 'int8_t': - case 'int16_t': - case 'int32_t': - case 'int64_t': - case 'uint8_t': - case 'uint16_t': - case 'uint32_t': - case 'uint64_t': - return type.replace(/[^0-9]/g, ''); - default: - throw error = 'asPutLength: Unhandled type: ' + zclType; - } -} - -function asPutCastType(zclType) -{ - const type = ChipTypesHelper.asBasicType(zclType); - switch (type) { - case 'bool': - return 'uint8_t'; - case 'int8_t': - case 'int16_t': - case 'int32_t': - case 'int64_t': - return 'u' + type; - case 'uint8_t': - case 'uint16_t': - case 'uint32_t': - case 'uint64_t': - return type; - default: - throw error = 'asPutCastType: Unhandled type: ' + zclType; - } -} - function asChipCallback(item) { if (StringHelper.isOctetString(item.type)) { @@ -332,13 +284,11 @@ function handleBasic(item, [ atomics, enums, bitmaps, structs ]) const atomic = getAtomic(atomics, itemType); if (atomic) { - item.name = item.name || item.label; - item.isStruct = false; - item.atomicTypeId = atomic.atomicId; - item.size = atomic.size; - item.chipType = atomic.chipType; - item.chipTypePutLength = asPutLength(atomic.chipType); - item.chipTypePutCastType = asPutCastType(atomic.chipType); + item.name = item.name || item.label; + item.isStruct = false; + item.atomicTypeId = atomic.atomicId; + item.size = atomic.size; + item.chipType = atomic.chipType; return true; } @@ -393,7 +343,10 @@ function enhancedCommands(commands, types) }); commands.forEach(command => { - command.isResponse = command.name.includes('Response'); + // Flag things ending in "Response" so we can filter out unused responses, + // but don't stomp on a true isResponse value if it's set already because + // some other command had this one as its response. + command.isResponse = command.isResponse || command.name.includes('Response'); command.isManufacturerSpecificCommand = !!this.mfgCode; command.hasSpecificResponse = !!command.response; @@ -404,6 +357,11 @@ function enhancedCommands(commands, types) // helper. But this one does not contains all the metadata informations added by // `enhancedItem`, so instead of using the one from ZAP, retrieve the enhanced version. command.response = commands.find(command => command.name == responseName); + // We might have failed to find a response if our configuration is weird + // in some way. + if (command.response) { + command.response.isResponse = true; + } } else { command.responseName = 'DefaultSuccess'; command.response = { arguments : [] }; diff --git a/src/app/zap-templates/common/override.js b/src/app/zap-templates/common/override.js index b7363a25b44cb5..4d85a223874f9b 100644 --- a/src/app/zap-templates/common/override.js +++ b/src/app/zap-templates/common/override.js @@ -22,6 +22,8 @@ function atomicType(arg) return 'bool'; case 'single': return 'float'; + case 'double': + return 'double'; case 'int40s': case 'int48s': case 'int56s': diff --git a/src/app/zap-templates/partials/im_command_handler_cluster_commands.zapt b/src/app/zap-templates/partials/im_command_handler_cluster_commands.zapt index c50679b7f7e3d7..3f7e5ec2f1375a 100644 --- a/src/app/zap-templates/partials/im_command_handler_cluster_commands.zapt +++ b/src/app/zap-templates/partials/im_command_handler_cluster_commands.zapt @@ -8,7 +8,15 @@ wasHandled = emberAf{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase na {{#if (zcl_command_arguments_count this.id)}} expectArgumentCount = {{ zcl_command_arguments_count this.id }}; {{#zcl_command_arguments}} -{{asUnderlyingZclType type}} {{asSymbol label}}; + {{#if isArray}} + {{asUnderlyingZclType type}} {{asSymbol label}}; + {{else}} + {{#if_is_struct type}} + {{zapTypeToDecodableClusterObjectType type ns=parent.parent.name}} {{asSymbol label}}; + {{else}} + {{asUnderlyingZclType type}} {{asSymbol label}}; + {{/if_is_struct}} + {{/if}} {{/zcl_command_arguments}} bool argExists[{{zcl_command_arguments_count this.id}}]; @@ -45,7 +53,12 @@ while ((TLVError = aDataTlv.Next()) == CHIP_NO_ERROR) // Just for compatibility, we will add array type support in IM later. TLVUnpackError = aDataTlv.GetDataPtr(const_cast({{asSymbol label}})); {{else}} + {{#if_is_struct type}} + // Not supported, just error out. + TLVUnpackError = CHIP_ERROR_UNEXPECTED_TLV_ELEMENT; + {{else}} TLVUnpackError = aDataTlv.Get({{asSymbol label}}); + {{/if_is_struct}} {{/if}} break; {{/zcl_command_arguments}} diff --git a/src/app/zap-templates/templates/app/CHIPClientCallbacks-src.zapt b/src/app/zap-templates/templates/app/CHIPClientCallbacks-src.zapt index a024c5ed3ea4c6..8469aa4b130c01 100644 --- a/src/app/zap-templates/templates/app/CHIPClientCallbacks-src.zapt +++ b/src/app/zap-templates/templates/app/CHIPClientCallbacks-src.zapt @@ -152,23 +152,29 @@ void {{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}ListAttribu {{#chip_client_clusters}} {{#chip_cluster_responses}} -bool emberAf{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Callback(EndpointId endpoint, app::CommandSender * commandObj{{#chip_cluster_response_arguments}}, {{asUnderlyingZclType type}} {{asSymbol label}}{{/chip_cluster_response_arguments}}) +bool emberAf{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Callback(EndpointId endpoint, app::CommandSender * commandObj{{#chip_cluster_response_arguments}}, {{#if isArray}}{{asUnderlyingZclType type}}{{else}}{{#if_is_struct type}}{{zapTypeToDecodableClusterObjectType type ns=parent.parent.name}}{{else}}{{asUnderlyingZclType type}}{{/if_is_struct}}{{/if}} {{asSymbol label}}{{/chip_cluster_response_arguments}}) { ChipLogProgress(Zcl, "{{asUpperCamelCase name}}:"); {{#chip_cluster_response_arguments}} - {{#if (isOctetString type)}} + {{#if isArray}} + ChipLogProgress(Zcl, " {{asSymbol label}}: {{asPrintFormat type}}", {{asSymbol label}}); + {{else if (isOctetString type)}} ChipLogProgress(Zcl, " {{asSymbol label}}: %zu", {{asSymbol label}}.size()); {{else if (isCharString type)}} ChipLogProgress(Zcl, " {{asSymbol label}}: %.*s", static_cast({{asSymbol label}}.size()), {{asSymbol label}}.data()); {{else}} - ChipLogProgress(Zcl, " {{asSymbol label}}: {{asPrintFormat type}}", {{asSymbol label}}); + {{#if_is_struct type}} + ChipLogProgress(Zcl, " {{asSymbol label}}: Not sure how to log struct {{type}}"); + {{else}} + ChipLogProgress(Zcl, " {{asSymbol label}}: {{asPrintFormat type}}", {{asSymbol label}}); + {{/if_is_struct}} {{/if}} {{/chip_cluster_response_arguments}} GET_CLUSTER_RESPONSE_CALLBACKS("{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Callback"); Callback::Callback<{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Callback> * cb = Callback::Callback<{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Callback>::FromCancelable(onSuccessCallback); - cb->mCall(cb->mContext{{#chip_cluster_response_arguments}}, {{asSymbol label}}{{/chip_cluster_response_arguments}}); + cb->mCall(cb->mContext{{#chip_cluster_response_arguments}}, {{#if isArray}}{{asSymbol label}}{{else}}{{#if_is_struct type}}{{asUnderlyingZclType type}}(){{else}}{{asSymbol label}}{{/if_is_struct}}{{/if}}{{/chip_cluster_response_arguments}}); return true; } diff --git a/src/app/zap-templates/templates/app/helper.js b/src/app/zap-templates/templates/app/helper.js index a15c43c3444bc0..a0c22cd2dee002 100644 --- a/src/app/zap-templates/templates/app/helper.js +++ b/src/app/zap-templates/templates/app/helper.js @@ -263,7 +263,7 @@ function asPrintFormat(type) return templateUtil.templatePromise(this.global, promise) } -function asTypeLiteralSuffix(type) +function asTypeLiteralSuffix(type, value) { function fn(pkgId) { @@ -281,6 +281,13 @@ function asTypeLiteralSuffix(type) return 'UL'; case 'uint64_t': return 'ULL'; + case 'float': + if (value == 0) { + // "0f" is not a valid value, so don't output that; just leave it + // as "0". + return ''; + } + return 'f'; default: return ''; } @@ -294,6 +301,12 @@ function asTypeLiteralSuffix(type) return templateUtil.templatePromise(this.global, promise) } +async function asTypedLiteral(type, value) +{ + let suffix = await asTypeLiteralSuffix.call(this, type, value); + return value + suffix; +} + function hasSpecificAttributes(options) { return this.count > kGlobalAttributes.length; @@ -511,6 +524,7 @@ exports.asReadType = asReadType; exports.chip_endpoint_generated_functions = chip_endpoint_generated_functions exports.chip_endpoint_cluster_list = chip_endpoint_cluster_list exports.asTypeLiteralSuffix = asTypeLiteralSuffix; +exports.asTypedLiteral = asTypedLiteral; exports.asLowerCamelCase = asLowerCamelCase; exports.asUpperCamelCase = asUpperCamelCase; exports.hasSpecificAttributes = hasSpecificAttributes; diff --git a/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml index cbbac09c60ad5f..cc7077484a7e70 100644 --- a/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml +++ b/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml @@ -45,6 +45,8 @@ limitations under the License. + + @@ -333,6 +335,15 @@ limitations under the License. array="true" optional="true"/> + + + Command that takes an argument which is a struct. The response echoes + the struct back. + + + + Simple response for TestWithResponse with a simple return value @@ -437,6 +448,14 @@ limitations under the License. + + + Command that returns a single argument which is a struct. The contents + of the struct depend on what we are responding to. + + + + Example test event diff --git a/src/controller/data_model/controller-clusters.zap b/src/controller/data_model/controller-clusters.zap index d3ba0db998e6a6..16561f3198789f 100644 --- a/src/controller/data_model/controller-clusters.zap +++ b/src/controller/data_model/controller-clusters.zap @@ -32,7 +32,7 @@ "endpointTypes": [ { "name": "Anonymous Endpoint Type", - "deviceTypeName": "CHIP-All-Clusters-Server", + "deviceTypeName": "MA-all-clusters-app", "deviceTypeCode": 0, "deviceTypeProfileId": 259, "clusters": [ @@ -11577,6 +11577,14 @@ "source": "client", "incoming": 0, "outgoing": 1 + }, + { + "name": "SimpleStructEchoRequest", + "code": 17, + "mfgCode": null, + "source": "client", + "incoming": 0, + "outgoing": 1 } ], "attributes": [ @@ -11652,6 +11660,14 @@ "source": "server", "incoming": 1, "outgoing": 0 + }, + { + "name": "SimpleStructResponse", + "code": 9, + "mfgCode": null, + "source": "server", + "incoming": 1, + "outgoing": 0 } ], "attributes": [ diff --git a/src/controller/java/templates/CHIPInvokeCallbacks-src.zapt b/src/controller/java/templates/CHIPInvokeCallbacks-src.zapt index ccac6c109095f0..3c8ab15c6dbc96 100644 --- a/src/controller/java/templates/CHIPInvokeCallbacks-src.zapt +++ b/src/controller/java/templates/CHIPInvokeCallbacks-src.zapt @@ -61,7 +61,7 @@ void CHIP{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase name}}Callbac // Java callback is allowed to be null, exit early if this is the case. VerifyOrReturn(javaCallbackRef != nullptr); - err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "({{#chip_cluster_response_arguments}}{{#if isArray}}{{else if isOptional}}Ljava/util/Optional;{{else if (isOctetString type)}}[B{{else if (isCharString type)}}Ljava/lang/String;{{else}}{{asJniSignature type true}}{{/if}}{{/chip_cluster_response_arguments}})V", &javaMethod); + err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "({{#chip_cluster_response_arguments}}{{#if isArray}}{{else}}{{#if_is_struct type}}{{else if isOptional}}Ljava/util/Optional;{{else if (isOctetString type)}}[B{{else if (isCharString type)}}Ljava/lang/String;{{else}}{{asJniSignature type true}}{{/if_is_struct}}{{/if}}{{/chip_cluster_response_arguments}})V", &javaMethod); VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err))); {{#chip_cluster_response_arguments}} diff --git a/src/controller/java/templates/ClusterInfo-java.zapt b/src/controller/java/templates/ClusterInfo-java.zapt index 7a44283ef52afa..6d6c37d83d49ed 100644 --- a/src/controller/java/templates/ClusterInfo-java.zapt +++ b/src/controller/java/templates/ClusterInfo-java.zapt @@ -170,8 +170,13 @@ public class ClusterInfoMapping { // {{asSymbol label}}: {{asUnderlyingZclType type}} // Conversion from this type to Java is not properly implemented yet {{else}} - CommandResponseInfo {{asSymbol label}}ResponseValue = new CommandResponseInfo("{{asSymbol label}}", "{{asJavaBasicType type}}"); - responseValues.put({{asSymbol label}}ResponseValue, {{asSymbol label}}); + {{#if_is_struct type}} + // {{asSymbol label}}: Struct {{type}} + // Conversion from this type to Java is not properly implemented yet + {{else}} + CommandResponseInfo {{asSymbol label}}ResponseValue = new CommandResponseInfo("{{asSymbol label}}", "{{asJavaBasicType type}}"); + responseValues.put({{asSymbol label}}ResponseValue, {{asSymbol label}}); + {{/if_is_struct}} {{/if}} {{/chip_cluster_response_arguments}} callback.onSuccess(responseValues); diff --git a/src/controller/java/templates/helper.js b/src/controller/java/templates/helper.js index e878e0f8eda196..84cefc0c82475b 100644 --- a/src/controller/java/templates/helper.js +++ b/src/controller/java/templates/helper.js @@ -41,6 +41,10 @@ function convertBasicCTypeToJavaType(cType) return 'long'; case 'bool': return 'boolean'; + case 'float': + return 'float'; + case 'double': + return 'double'; default: error = 'Unhandled type ' + cType; throw error; @@ -56,6 +60,10 @@ function convertBasicCTypeToJniType(cType) return 'jlong'; case 'boolean': return 'jboolean'; + case 'float': + return 'jfloat'; + case 'double': + return 'jdouble'; default: error = 'Unhandled type ' + cType; throw error; @@ -71,6 +79,10 @@ function convertBasicCTypeToJavaBoxedType(cType) return 'Long'; case 'boolean': return 'Boolean'; + case 'float': + return 'Float'; + case 'double': + return 'Double'; default: error = 'Unhandled type ' + cType; throw error; diff --git a/src/controller/java/templates/partials/command_callback_responses.zapt b/src/controller/java/templates/partials/command_callback_responses.zapt index 42ddde1188a644..920dd27a7d60ac 100644 --- a/src/controller/java/templates/partials/command_callback_responses.zapt +++ b/src/controller/java/templates/partials/command_callback_responses.zapt @@ -2,18 +2,26 @@ {{#if isNullable}} {{#unless isArray}} {{#unless isOptional}} + {{#if_is_struct type}} + {{else}} @Nullable + {{/if_is_struct}} {{/unless}} {{/unless}} {{/if}} {{#if isArray}} // {{asSymbol label}}: {{asUnderlyingZclType type}} // Conversion from this type to Java is not properly implemented yet +{{else}} +{{#if_is_struct type}} + // {{asSymbol label}}: Struct {{type}} + // Conversion from this type to Java is not properly implemented yet {{else if (isOctetString type)}} {{#if isOptional}}Optional<{{/if}}byte[]{{#if isOptional}}>{{/if}} {{asSymbol label}}{{#notLastSupportedCommandResponseType parent.arguments}},{{/notLastSupportedCommandResponseType}} {{else if (isShortString type)}} {{#if isOptional}}Optional<{{/if}}String{{#if isOptional}}>{{/if}} {{asSymbol label}}{{#notLastSupportedCommandResponseType parent.arguments}},{{/notLastSupportedCommandResponseType}} {{else}} {{#if isOptional}}Optional<{{/if}}{{asJavaBasicTypeForZclType type true}}{{#if isOptional}}>{{/if}} {{asSymbol label}}{{#notLastSupportedCommandResponseType parent.arguments}},{{/notLastSupportedCommandResponseType}} +{{/if_is_struct}} {{/if}} {{/chip_cluster_response_arguments}} \ No newline at end of file diff --git a/src/controller/java/zap-generated/CHIPCallbackTypes.h b/src/controller/java/zap-generated/CHIPCallbackTypes.h index 487f03d7902984..8be601d6d76b6c 100644 --- a/src/controller/java/zap-generated/CHIPCallbackTypes.h +++ b/src/controller/java/zap-generated/CHIPCallbackTypes.h @@ -863,6 +863,8 @@ typedef void (*CHIPTemperatureMeasurementClusterClusterRevisionAttributeCallback void *, chip::app::Clusters::TemperatureMeasurement::Attributes::ClusterRevision::TypeInfo::DecodableArgType); typedef void (*CHIPTestClusterClusterBooleanResponseCallbackType)( void *, const chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType &); +typedef void (*CHIPTestClusterClusterSimpleStructResponseCallbackType)( + void *, const chip::app::Clusters::TestCluster::Commands::SimpleStructResponse::DecodableType &); typedef void (*CHIPTestClusterClusterTestAddArgumentsResponseCallbackType)( void *, const chip::app::Clusters::TestCluster::Commands::TestAddArgumentsResponse::DecodableType &); typedef void (*CHIPTestClusterClusterTestEnumsResponseCallbackType)( diff --git a/src/controller/java/zap-generated/CHIPClusters-JNI.cpp b/src/controller/java/zap-generated/CHIPClusters-JNI.cpp index 77a09cf738e851..6856f592e17723 100644 --- a/src/controller/java/zap-generated/CHIPClusters-JNI.cpp +++ b/src/controller/java/zap-generated/CHIPClusters-JNI.cpp @@ -24217,6 +24217,48 @@ JNI_METHOD(jlong, TestClusterCluster, initWithDevice)(JNIEnv * env, jobject self return reinterpret_cast(cppCluster); } +JNI_METHOD(void, TestClusterCluster, simpleStructEchoRequest) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject a, jobject b, jobject c, jbyteArray d, jstring e, + jobject f, jobject g, jobject h) +{ + chip::DeviceLayer::StackLock lock; + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster; + + chip::app::Clusters::TestCluster::Commands::SimpleStructEchoRequest::Type request; + + request.arg1 = chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type(); + + std::unique_ptr + onSuccess(Platform::New(callback), + Platform::Delete); + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native callback", CHIP_ERROR_NO_MEMORY)); + VerifyOrReturn(onFailure.get() != nullptr, + AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native callback", CHIP_ERROR_NO_MEMORY)); + + cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error getting native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + + err = cppCluster->InvokeCommand(request, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn(err == CHIP_NO_ERROR, + AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error invoking command", + CHIP_ERROR_INCORRECT_STATE)); + + onSuccess.release(); + onFailure.release(); +} JNI_METHOD(void, TestClusterCluster, test)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; @@ -24418,7 +24460,7 @@ JNI_METHOD(void, TestClusterCluster, testListInt8UReverseRequest) } JNI_METHOD(void, TestClusterCluster, testListStructArgumentRequest) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject a, jobject b, jobject c, jbyteArray d, jstring e, - jobject f) + jobject f, jobject g, jobject h) { chip::DeviceLayer::StackLock lock; CHIP_ERROR err = CHIP_NO_ERROR; @@ -24580,7 +24622,7 @@ JNI_METHOD(void, TestClusterCluster, testSpecific)(JNIEnv * env, jobject self, j } JNI_METHOD(void, TestClusterCluster, testStructArgumentRequest) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject a, jobject b, jobject c, jbyteArray d, jstring e, - jobject f) + jobject f, jobject g, jobject h) { chip::DeviceLayer::StackLock lock; CHIP_ERROR err = CHIP_NO_ERROR; diff --git a/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp b/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp index 9b93807f128dee..dec9e05de1f730 100644 --- a/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp +++ b/src/controller/java/zap-generated/CHIPInvokeCallbacks.cpp @@ -4877,6 +4877,64 @@ void CHIPTestClusterClusterBooleanResponseCallback::CallbackFn( env->CallVoidMethod(javaCallbackRef, javaMethod, value); } +CHIPTestClusterClusterSimpleStructResponseCallback::CHIPTestClusterClusterSimpleStructResponseCallback(jobject javaCallback) : + Callback::Callback(CallbackFn, this) +{ + JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + return; + } + + javaCallbackRef = env->NewGlobalRef(javaCallback); + if (javaCallbackRef == nullptr) + { + ChipLogError(Zcl, "Could not create global reference for Java callback"); + } +} + +CHIPTestClusterClusterSimpleStructResponseCallback::~CHIPTestClusterClusterSimpleStructResponseCallback() +{ + JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +}; + +void CHIPTestClusterClusterSimpleStructResponseCallback::CallbackFn( + void * context, const chip::app::Clusters::TestCluster::Commands::SimpleStructResponse::DecodableType & dataResponse) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + jmethodID javaMethod; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Error invoking Java callback: no JNIEnv")); + + std::unique_ptr + cppCallback(reinterpret_cast(context), + chip::Platform::Delete); + VerifyOrReturn(cppCallback != nullptr, ChipLogError(Zcl, "Error invoking Java callback: failed to cast native callback")); + + javaCallbackRef = cppCallback->javaCallbackRef; + // Java callback is allowed to be null, exit early if this is the case. + VerifyOrReturn(javaCallbackRef != nullptr); + + err = JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "()V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Error invoking Java callback: %s", ErrorStr(err))); + + jobject arg1; + + arg1 = nullptr; /* Struct - conversion from this type to Java is not properly implemented yet */ + + env->CallVoidMethod(javaCallbackRef, javaMethod, arg1); +} CHIPTestClusterClusterTestAddArgumentsResponseCallback::CHIPTestClusterClusterTestAddArgumentsResponseCallback( jobject javaCallback) : Callback::Callback(CallbackFn, this) diff --git a/src/controller/java/zap-generated/CHIPInvokeCallbacks.h b/src/controller/java/zap-generated/CHIPInvokeCallbacks.h index ed66dbd7eee44e..d0cce3e299fa72 100644 --- a/src/controller/java/zap-generated/CHIPInvokeCallbacks.h +++ b/src/controller/java/zap-generated/CHIPInvokeCallbacks.h @@ -1061,6 +1061,21 @@ class CHIPTestClusterClusterBooleanResponseCallback : public Callback::Callback< jobject javaCallbackRef; }; +class CHIPTestClusterClusterSimpleStructResponseCallback + : public Callback::Callback +{ +public: + CHIPTestClusterClusterSimpleStructResponseCallback(jobject javaCallback); + + ~CHIPTestClusterClusterSimpleStructResponseCallback(); + + static void CallbackFn(void * context, + const chip::app::Clusters::TestCluster::Commands::SimpleStructResponse::DecodableType & data); + +private: + jobject javaCallbackRef; +}; + class CHIPTestClusterClusterTestAddArgumentsResponseCallback : public Callback::Callback { diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java index 63d1a5cfcaf45c..bba7968edb445f 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -10692,6 +10692,19 @@ public static long clusterId() { @Override public native long initWithDevice(long devicePtr, int endpointId); + public void simpleStructEchoRequest( + SimpleStructResponseCallback callback, + Integer a, + Boolean b, + Integer c, + byte[] d, + String e, + Integer f, + Float g, + Double h) { + simpleStructEchoRequest(chipClusterPtr, callback, a, b, c, d, e, f, g, h); + } + public void test(DefaultClusterCallback callback) { test(chipClusterPtr, callback); } @@ -10721,8 +10734,10 @@ public void testListStructArgumentRequest( Integer c, byte[] d, String e, - Integer f) { - testListStructArgumentRequest(chipClusterPtr, callback, a, b, c, d, e, f); + Integer f, + Float g, + Double h) { + testListStructArgumentRequest(chipClusterPtr, callback, a, b, c, d, e, f, g, h); } public void testNotHandled(DefaultClusterCallback callback) { @@ -10745,14 +10760,28 @@ public void testStructArgumentRequest( Integer c, byte[] d, String e, - Integer f) { - testStructArgumentRequest(chipClusterPtr, callback, a, b, c, d, e, f); + Integer f, + Float g, + Double h) { + testStructArgumentRequest(chipClusterPtr, callback, a, b, c, d, e, f, g, h); } public void testUnknownCommand(DefaultClusterCallback callback) { testUnknownCommand(chipClusterPtr, callback); } + private native void simpleStructEchoRequest( + long chipClusterPtr, + SimpleStructResponseCallback Callback, + Integer a, + Boolean b, + Integer c, + byte[] d, + String e, + Integer f, + Float g, + Double h); + private native void test(long chipClusterPtr, DefaultClusterCallback Callback); private native void testAddArguments( @@ -10775,7 +10804,9 @@ private native void testListStructArgumentRequest( Integer c, byte[] d, String e, - Integer f); + Integer f, + Float g, + Double h); private native void testNotHandled(long chipClusterPtr, DefaultClusterCallback Callback); @@ -10792,7 +10823,9 @@ private native void testStructArgumentRequest( Integer c, byte[] d, String e, - Integer f); + Integer f, + Float g, + Double h); private native void testUnknownCommand(long chipClusterPtr, DefaultClusterCallback Callback); @@ -10802,6 +10835,14 @@ public interface BooleanResponseCallback { void onError(Exception error); } + public interface SimpleStructResponseCallback { + void onSuccess( // arg1: Struct SimpleStruct + // Conversion from this type to Java is not properly implemented yet + ); + + void onError(Exception error); + } + public interface TestAddArgumentsResponseCallback { void onSuccess(Integer returnValue); diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java index fded96b79b4c06..672bf418bbe006 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java @@ -2810,6 +2810,32 @@ public void onError(Exception error) { } } + public static class DelegatedSimpleStructResponseCallback + implements ChipClusters.TestClusterCluster.SimpleStructResponseCallback, + DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess( // arg1: Struct SimpleStruct + // Conversion from this type to Java is not properly implemented yet + ) { + Map responseValues = new LinkedHashMap<>(); + // arg1: Struct SimpleStruct + // Conversion from this type to Java is not properly implemented yet + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + public static class DelegatedTestAddArgumentsResponseCallback implements ChipClusters.TestClusterCluster.TestAddArgumentsResponseCallback, DelegatedClusterCallback { @@ -7725,6 +7751,68 @@ public Map> getCommandMap() { new LinkedHashMap<>(); commandMap.put("temperatureMeasurement", temperatureMeasurementClusterInteractionInfoMap); Map testClusterClusterInteractionInfoMap = new LinkedHashMap<>(); + Map testClustersimpleStructEchoRequestCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClustersimpleStructEchoRequestaCommandParameterInfo = + new CommandParameterInfo("a", int.class); + testClustersimpleStructEchoRequestCommandParams.put( + "a", testClustersimpleStructEchoRequestaCommandParameterInfo); + + CommandParameterInfo testClustersimpleStructEchoRequestbCommandParameterInfo = + new CommandParameterInfo("b", boolean.class); + testClustersimpleStructEchoRequestCommandParams.put( + "b", testClustersimpleStructEchoRequestbCommandParameterInfo); + + CommandParameterInfo testClustersimpleStructEchoRequestcCommandParameterInfo = + new CommandParameterInfo("c", int.class); + testClustersimpleStructEchoRequestCommandParams.put( + "c", testClustersimpleStructEchoRequestcCommandParameterInfo); + + CommandParameterInfo testClustersimpleStructEchoRequestdCommandParameterInfo = + new CommandParameterInfo("d", byte[].class); + testClustersimpleStructEchoRequestCommandParams.put( + "d", testClustersimpleStructEchoRequestdCommandParameterInfo); + + CommandParameterInfo testClustersimpleStructEchoRequesteCommandParameterInfo = + new CommandParameterInfo("e", String.class); + testClustersimpleStructEchoRequestCommandParams.put( + "e", testClustersimpleStructEchoRequesteCommandParameterInfo); + + CommandParameterInfo testClustersimpleStructEchoRequestfCommandParameterInfo = + new CommandParameterInfo("f", int.class); + testClustersimpleStructEchoRequestCommandParams.put( + "f", testClustersimpleStructEchoRequestfCommandParameterInfo); + + CommandParameterInfo testClustersimpleStructEchoRequestgCommandParameterInfo = + new CommandParameterInfo("g", float.class); + testClustersimpleStructEchoRequestCommandParams.put( + "g", testClustersimpleStructEchoRequestgCommandParameterInfo); + + CommandParameterInfo testClustersimpleStructEchoRequesthCommandParameterInfo = + new CommandParameterInfo("h", double.class); + testClustersimpleStructEchoRequestCommandParams.put( + "h", testClustersimpleStructEchoRequesthCommandParameterInfo); + + // Populate commands + InteractionInfo testClustersimpleStructEchoRequestInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .simpleStructEchoRequest( + (ChipClusters.TestClusterCluster.SimpleStructResponseCallback) callback, + (Integer) commandArguments.get("a"), + (Boolean) commandArguments.get("b"), + (Integer) commandArguments.get("c"), + (byte[]) commandArguments.get("d"), + (String) commandArguments.get("e"), + (Integer) commandArguments.get("f"), + (Float) commandArguments.get("g"), + (Double) commandArguments.get("h")); + }, + () -> new DelegatedSimpleStructResponseCallback(), + testClustersimpleStructEchoRequestCommandParams); + testClusterClusterInteractionInfoMap.put( + "simpleStructEchoRequest", testClustersimpleStructEchoRequestInteractionInfo); Map testClustertestCommandParams = new LinkedHashMap(); // Populate commands @@ -7861,6 +7949,16 @@ public Map> getCommandMap() { testClustertestListStructArgumentRequestCommandParams.put( "f", testClustertestListStructArgumentRequestfCommandParameterInfo); + CommandParameterInfo testClustertestListStructArgumentRequestgCommandParameterInfo = + new CommandParameterInfo("g", float.class); + testClustertestListStructArgumentRequestCommandParams.put( + "g", testClustertestListStructArgumentRequestgCommandParameterInfo); + + CommandParameterInfo testClustertestListStructArgumentRequesthCommandParameterInfo = + new CommandParameterInfo("h", double.class); + testClustertestListStructArgumentRequestCommandParams.put( + "h", testClustertestListStructArgumentRequesthCommandParameterInfo); + // Populate commands InteractionInfo testClustertestListStructArgumentRequestInteractionInfo = new InteractionInfo( @@ -7873,7 +7971,9 @@ public Map> getCommandMap() { (Integer) commandArguments.get("c"), (byte[]) commandArguments.get("d"), (String) commandArguments.get("e"), - (Integer) commandArguments.get("f")); + (Integer) commandArguments.get("f"), + (Float) commandArguments.get("g"), + (Double) commandArguments.get("h")); }, () -> new DelegatedBooleanResponseCallback(), testClustertestListStructArgumentRequestCommandParams); @@ -7959,6 +8059,16 @@ public Map> getCommandMap() { testClustertestStructArgumentRequestCommandParams.put( "f", testClustertestStructArgumentRequestfCommandParameterInfo); + CommandParameterInfo testClustertestStructArgumentRequestgCommandParameterInfo = + new CommandParameterInfo("g", float.class); + testClustertestStructArgumentRequestCommandParams.put( + "g", testClustertestStructArgumentRequestgCommandParameterInfo); + + CommandParameterInfo testClustertestStructArgumentRequesthCommandParameterInfo = + new CommandParameterInfo("h", double.class); + testClustertestStructArgumentRequestCommandParams.put( + "h", testClustertestStructArgumentRequesthCommandParameterInfo); + // Populate commands InteractionInfo testClustertestStructArgumentRequestInteractionInfo = new InteractionInfo( @@ -7971,7 +8081,9 @@ public Map> getCommandMap() { (Integer) commandArguments.get("c"), (byte[]) commandArguments.get("d"), (String) commandArguments.get("e"), - (Integer) commandArguments.get("f")); + (Integer) commandArguments.get("f"), + (Float) commandArguments.get("g"), + (Double) commandArguments.get("h")); }, () -> new DelegatedBooleanResponseCallback(), testClustertestStructArgumentRequestCommandParams); diff --git a/src/controller/python/chip/clusters/CHIPClusters.py b/src/controller/python/chip/clusters/CHIPClusters.py index eeca55ba4bd640..58d8998e25cb5a 100644 --- a/src/controller/python/chip/clusters/CHIPClusters.py +++ b/src/controller/python/chip/clusters/CHIPClusters.py @@ -3637,6 +3637,20 @@ class ChipClusters: "clusterName": "TestCluster", "clusterId": 0x0000050F, "commands": { + 0x00000011: { + "commandId": 0x00000011, + "commandName": "SimpleStructEchoRequest", + "args": { + "a": "int", + "b": "bool", + "c": "int", + "d": "bytes", + "e": "str", + "f": "int", + "g": "", + "h": "", + }, + }, 0x00000000: { "commandId": 0x00000000, "commandName": "Test", @@ -3683,6 +3697,8 @@ class ChipClusters: "d": "bytes", "e": "str", "f": "int", + "g": "", + "h": "", }, }, 0x00000001: { @@ -3714,6 +3730,8 @@ class ChipClusters: "d": "bytes", "e": "str", "f": "int", + "g": "", + "h": "", }, }, 0x00000003: { diff --git a/src/controller/python/chip/clusters/Objects.py b/src/controller/python/chip/clusters/Objects.py index 101c6349e9675d..5968d3d2d95705 100644 --- a/src/controller/python/chip/clusters/Objects.py +++ b/src/controller/python/chip/clusters/Objects.py @@ -24260,6 +24260,10 @@ def descriptor(cls) -> ClusterObjectDescriptor: Label="e", Tag=4, Type=str), ClusterObjectFieldDescriptor( Label="f", Tag=5, Type=uint), + ClusterObjectFieldDescriptor( + Label="g", Tag=6, Type=float), + ClusterObjectFieldDescriptor( + Label="h", Tag=7, Type=float), ]) a: 'uint' = None @@ -24268,6 +24272,8 @@ def descriptor(cls) -> ClusterObjectDescriptor: d: 'bytes' = None e: 'str' = None f: 'uint' = None + g: 'float' = None + h: 'float' = None @dataclass class NullablesAndOptionalsStruct(ClusterObject): @@ -24804,6 +24810,22 @@ def descriptor(cls) -> ClusterObjectDescriptor: arg1: 'typing.List[TestCluster.Structs.SimpleStruct]' = None + @dataclass + class SimpleStructResponse(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x050F + command_id: typing.ClassVar[int] = 0x0009 + is_client: typing.ClassVar[bool] = False + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor( + Label="arg1", Tag=0, Type=TestCluster.Structs.SimpleStruct), + ]) + + arg1: 'TestCluster.Structs.SimpleStruct' = None + @dataclass class TestListInt8UArgumentRequest(ClusterCommand): cluster_id: typing.ClassVar[int] = 0x050F @@ -24952,6 +24974,22 @@ def descriptor(cls) -> ClusterObjectDescriptor: optionalList: 'typing.Optional[typing.List[TestCluster.Enums.SimpleEnum]]' = None nullableOptionalList: 'typing.Union[None, Nullable, typing.List[TestCluster.Enums.SimpleEnum]]' = None + @dataclass + class SimpleStructEchoRequest(ClusterCommand): + cluster_id: typing.ClassVar[int] = 0x050F + command_id: typing.ClassVar[int] = 0x0011 + is_client: typing.ClassVar[bool] = True + + @ChipUtility.classproperty + def descriptor(cls) -> ClusterObjectDescriptor: + return ClusterObjectDescriptor( + Fields=[ + ClusterObjectFieldDescriptor( + Label="arg1", Tag=0, Type=TestCluster.Structs.SimpleStruct), + ]) + + arg1: 'TestCluster.Structs.SimpleStruct' = None + class Attributes: @dataclass class Boolean(ClusterAttributeDescriptor): diff --git a/src/darwin/Framework/CHIP/templates/helper.js b/src/darwin/Framework/CHIP/templates/helper.js index 251a86060d57d4..1383e9f02231d4 100644 --- a/src/darwin/Framework/CHIP/templates/helper.js +++ b/src/darwin/Framework/CHIP/templates/helper.js @@ -99,6 +99,10 @@ function asObjectiveCNumberType(label, type, asLowerCased) return 'Int'; case 'int64_t': return 'LongLong'; + case 'float': + return 'Float'; + case 'double': + return 'Double'; default: error = label + ': Unhandled underlying type ' + zclType + ' for original type ' + type; throw error; diff --git a/src/darwin/Framework/CHIP/templates/partials/check_test_value.zapt b/src/darwin/Framework/CHIP/templates/partials/check_test_value.zapt index ffbb9fd1139e0e..20c1b3e00b5498 100644 --- a/src/darwin/Framework/CHIP/templates/partials/check_test_value.zapt +++ b/src/darwin/Framework/CHIP/templates/partials/check_test_value.zapt @@ -21,12 +21,7 @@ call. }} {{#zcl_struct_items_by_struct_name type}} {{#if (expectedValueHasProp ../expected (asLowerCamelCase label))}} - {{! TODO: This is a hack because right now some of our return values (attribute reads) are using NSDictionary for structs while others (commands) are using generated object types. Just support both for now. }} - if ([{{../actual}} isKindOfClass:[NSDictionary class]]) { - {{>check_test_value actual=(concat ../actual '[@"' (asStructPropertyName label) '"]') expected=(lookup ../expected (asLowerCamelCase label)) cluster=../cluster}} - } else { - {{>check_test_value actual=(concat "((CHIP" (asUpperCamelCase ../cluster) "Cluster" (asUpperCamelCase ../type) " *)" ../actual ")." (asStructPropertyName label)) expected=(lookup ../expected (asLowerCamelCase label)) cluster=../cluster}} - } + {{>check_test_value actual=(concat "((CHIP" (asUpperCamelCase ../cluster) "Cluster" (asUpperCamelCase ../type) " *)" ../actual ")." (asStructPropertyName label)) expected=(lookup ../expected (asLowerCamelCase label)) cluster=../cluster}} {{/if}} {{/zcl_struct_items_by_struct_name}} {{! Maybe we should add a check for properties in the expected object (other @@ -37,7 +32,7 @@ {{else if (isCharString type)}} XCTAssertTrue([{{actual}} isEqualToString:@"{{expected}}"]); {{else}} - XCTAssertEqual([{{actual}} {{asObjectiveCNumberType "" type true}}Value], {{expected}}{{asTypeLiteralSuffix type}}); + XCTAssertEqual([{{actual}} {{asObjectiveCNumberType "" type true}}Value], {{asTypedLiteral type expected}}); {{/if}} {{/if_is_struct}} {{/if}} diff --git a/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt b/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt index 1b3b6c48de4055..679251eb7fa688 100644 --- a/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt +++ b/src/darwin/Framework/CHIP/templates/partials/test_cluster.zapt @@ -45,7 +45,7 @@ bool testSendCluster{{parent.filename}}_{{asTestIndex index}}_{{asUpperCamelCase NSString * {{asLowerCamelCase name}}Argument= @"{{definedValue}}"; {{/if}} {{else}} - {{asObjectiveCBasicType type}} {{asLowerCamelCase name}}Argument = {{definedValue}}{{asTypeLiteralSuffix type}}; + {{asObjectiveCBasicType type}} {{asLowerCamelCase name}}Argument = {{asTypedLiteral type definedValue}}; {{/if}} {{/chip_tests_item_parameters}} [cluster subscribeAttribute{{asUpperCamelCase attribute}}WithMinInterval:minIntervalArgument diff --git a/src/darwin/Framework/CHIP/templates/partials/test_value.zapt b/src/darwin/Framework/CHIP/templates/partials/test_value.zapt index 28b88a3ea0ab30..637f578e4fff2f 100644 --- a/src/darwin/Framework/CHIP/templates/partials/test_value.zapt +++ b/src/darwin/Framework/CHIP/templates/partials/test_value.zapt @@ -29,6 +29,6 @@ {{else if (isOctetString type)}} {{target}} = [[NSData alloc] initWithBytes:"{{octetStringEscapedForCLiteral definedValue}}" length:{{definedValue.length}}]; {{else}} - {{target}} = [NSNumber numberWith{{asObjectiveCNumberType definedValue type false}}:{{definedValue}}{{asTypeLiteralSuffix type}}]; + {{target}} = [NSNumber numberWith{{asObjectiveCNumberType definedValue type false}}:{{asTypedLiteral type definedValue}}]; {{/if_is_struct}} {{/if}} diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm index 9a1f4a1212d216..038c2b7e6c0f8c 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm @@ -1002,6 +1002,8 @@ length:entry_0.nullableStruct.Value().e.size() encoding:NSUTF8StringEncoding]; newElement_0.nullableStruct.f = [NSNumber numberWithUnsignedChar:entry_0.nullableStruct.Value().f.Raw()]; + newElement_0.nullableStruct.g = [NSNumber numberWithFloat:entry_0.nullableStruct.Value().g]; + newElement_0.nullableStruct.h = [NSNumber numberWithDouble:entry_0.nullableStruct.Value().h]; } if (entry_0.optionalStruct.HasValue()) { newElement_0.optionalStruct = [CHIPTestClusterClusterSimpleStruct new]; @@ -1014,6 +1016,8 @@ length:entry_0.optionalStruct.Value().e.size() encoding:NSUTF8StringEncoding]; newElement_0.optionalStruct.f = [NSNumber numberWithUnsignedChar:entry_0.optionalStruct.Value().f.Raw()]; + newElement_0.optionalStruct.g = [NSNumber numberWithFloat:entry_0.optionalStruct.Value().g]; + newElement_0.optionalStruct.h = [NSNumber numberWithDouble:entry_0.optionalStruct.Value().h]; } else { newElement_0.optionalStruct = nil; } @@ -1036,6 +1040,9 @@ encoding:NSUTF8StringEncoding]; newElement_0.nullableOptionalStruct.f = [NSNumber numberWithUnsignedChar:entry_0.nullableOptionalStruct.Value().Value().f.Raw()]; + newElement_0.nullableOptionalStruct.g = [NSNumber numberWithFloat:entry_0.nullableOptionalStruct.Value().Value().g]; + newElement_0.nullableOptionalStruct.h = + [NSNumber numberWithDouble:entry_0.nullableOptionalStruct.Value().Value().h]; } } else { newElement_0.nullableOptionalStruct = nil; @@ -2628,6 +2635,26 @@ DispatchSuccess(context, response); }; +void CHIPTestClusterClusterSimpleStructResponseCallbackBridge::OnSuccessFn( + void * context, const chip::app::Clusters::TestCluster::Commands::SimpleStructResponse::DecodableType & data) +{ + auto * response = [CHIPTestClusterClusterSimpleStructResponseParams new]; + { + CHIPTestClusterClusterSimpleStruct * value; + value = [CHIPTestClusterClusterSimpleStruct new]; + value.a = [NSNumber numberWithUnsignedChar:data.arg1.a]; + value.b = [NSNumber numberWithBool:data.arg1.b]; + value.c = [NSNumber numberWithUnsignedChar:data.arg1.c]; + value.d = [NSData dataWithBytes:data.arg1.d.data() length:data.arg1.d.size()]; + value.e = [[NSString alloc] initWithBytes:data.arg1.e.data() length:data.arg1.e.size() encoding:NSUTF8StringEncoding]; + value.f = [NSNumber numberWithUnsignedChar:data.arg1.f.Raw()]; + value.g = [NSNumber numberWithFloat:data.arg1.g]; + value.h = [NSNumber numberWithDouble:data.arg1.h]; + response.arg1 = value; + } + DispatchSuccess(context, response); +}; + void CHIPTestClusterClusterTestAddArgumentsResponseCallbackBridge::OnSuccessFn( void * context, const chip::app::Clusters::TestCluster::Commands::TestAddArgumentsResponse::DecodableType & data) { diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h index cc0cf515030b83..1dd0641685f02d 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h @@ -173,6 +173,8 @@ typedef void (*CHIPTargetNavigatorClusterNavigateTargetResponseCallbackType)( void *, const chip::app::Clusters::TargetNavigator::Commands::NavigateTargetResponse::DecodableType &); typedef void (*CHIPTestClusterClusterBooleanResponseCallbackType)( void *, const chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType &); +typedef void (*CHIPTestClusterClusterSimpleStructResponseCallbackType)( + void *, const chip::app::Clusters::TestCluster::Commands::SimpleStructResponse::DecodableType &); typedef void (*CHIPTestClusterClusterTestAddArgumentsResponseCallbackType)( void *, const chip::app::Clusters::TestCluster::Commands::TestAddArgumentsResponse::DecodableType &); typedef void (*CHIPTestClusterClusterTestEnumsResponseCallbackType)( @@ -1775,6 +1777,19 @@ class CHIPTestClusterClusterBooleanResponseCallbackBridge const chip::app::Clusters::TestCluster::Commands::BooleanResponse::DecodableType & data); }; +class CHIPTestClusterClusterSimpleStructResponseCallbackBridge + : public CHIPCallbackBridge +{ +public: + CHIPTestClusterClusterSimpleStructResponseCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, + CHIPActionBlock action, bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, + keepAlive){}; + + static void OnSuccessFn(void * context, + const chip::app::Clusters::TestCluster::Commands::SimpleStructResponse::DecodableType & data); +}; + class CHIPTestClusterClusterTestAddArgumentsResponseCallbackBridge : public CHIPCallbackBridge { diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h index 87ed6b552fb625..99f67f66c8caba 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h @@ -3255,6 +3255,9 @@ NS_ASSUME_NONNULL_BEGIN */ @interface CHIPTestCluster : CHIPCluster +- (void)simpleStructEchoRequestWithParams:(CHIPTestClusterClusterSimpleStructEchoRequestParams *)params + completionHandler:(void (^)(CHIPTestClusterClusterSimpleStructResponseParams * _Nullable data, + NSError * _Nullable error))completionHandler; - (void)testWithCompletionHandler:(StatusCompletion)completionHandler; - (void)testAddArgumentsWithParams:(CHIPTestClusterClusterTestAddArgumentsParams *)params completionHandler:(void (^)(CHIPTestClusterClusterTestAddArgumentsResponseParams * _Nullable data, diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm index afe00a0ffdf0b0..79056f5aecd3b3 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm @@ -16259,6 +16259,33 @@ @implementation CHIPTestCluster return &_cppCluster; } +- (void)simpleStructEchoRequestWithParams:(CHIPTestClusterClusterSimpleStructEchoRequestParams *)params + completionHandler:(void (^)(CHIPTestClusterClusterSimpleStructResponseParams * _Nullable data, + NSError * _Nullable error))completionHandler +{ + ListFreer listFreer; + TestCluster::Commands::SimpleStructEchoRequest::Type request; + request.arg1.a = params.arg1.a.unsignedCharValue; + request.arg1.b = params.arg1.b.boolValue; + request.arg1.c = static_cast>(params.arg1.c.unsignedCharValue); + request.arg1.d = [self asByteSpan:params.arg1.d]; + request.arg1.e = [self asCharSpan:params.arg1.e]; + request.arg1.f = static_cast>(params.arg1.f.unsignedCharValue); + request.arg1.g = params.arg1.g.floatValue; + request.arg1.h = params.arg1.h.doubleValue; + + new CHIPTestClusterClusterSimpleStructResponseCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.InvokeCommand(request, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + - (void)testWithCompletionHandler:(StatusCompletion)completionHandler { ListFreer listFreer; @@ -16429,6 +16456,8 @@ - (void)testListStructArgumentRequestWithParams:(CHIPTestClusterClusterTestListS listHolder_0->mList[i].e = [self asCharSpan:element_0.e]; listHolder_0->mList[i].f = static_castmList[i].f)>>(element_0.f.unsignedCharValue); + listHolder_0->mList[i].g = element_0.g.floatValue; + listHolder_0->mList[i].h = element_0.h.doubleValue; } request.arg1 = ListType(listHolder_0->mList, params.arg1.count); } else { @@ -16525,6 +16554,8 @@ - (void)testStructArgumentRequestWithParams:(CHIPTestClusterClusterTestStructArg request.arg1.d = [self asByteSpan:params.arg1.d]; request.arg1.e = [self asCharSpan:params.arg1.e]; request.arg1.f = static_cast>(params.arg1.f.unsignedCharValue); + request.arg1.g = params.arg1.g.floatValue; + request.arg1.h = params.arg1.h.doubleValue; new CHIPTestClusterClusterBooleanResponseCallbackBridge( self.callbackQueue, diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPCommandPayloadsObjc.h b/src/darwin/Framework/CHIP/zap-generated/CHIPCommandPayloadsObjc.h index 8870393fe5d76c..b916ca9c0e6845 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPCommandPayloadsObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPCommandPayloadsObjc.h @@ -1874,6 +1874,11 @@ NS_ASSUME_NONNULL_BEGIN - (instancetype)init; @end +@interface CHIPTestClusterClusterSimpleStructResponseParams : NSObject +@property (strong, nonatomic) CHIPTestClusterClusterSimpleStruct * _Nonnull arg1; +- (instancetype)init; +@end + @interface CHIPTestClusterClusterTestListInt8UArgumentRequestParams : NSObject @property (strong, nonatomic) NSArray * _Nonnull arg1; - (instancetype)init; @@ -1921,6 +1926,11 @@ NS_ASSUME_NONNULL_BEGIN - (instancetype)init; @end +@interface CHIPTestClusterClusterSimpleStructEchoRequestParams : NSObject +@property (strong, nonatomic) CHIPTestClusterClusterSimpleStruct * _Nonnull arg1; +- (instancetype)init; +@end + @interface CHIPMessagingClusterDisplayMessageParams : NSObject @property (strong, nonatomic) NSNumber * _Nonnull messageId; @property (strong, nonatomic) NSNumber * _Nonnull messageControl; diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPCommandPayloadsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPCommandPayloadsObjc.mm index e5a482575a05cf..9c8314e88c718d 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPCommandPayloadsObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPCommandPayloadsObjc.mm @@ -3997,6 +3997,17 @@ - (instancetype)init } @end +@implementation CHIPTestClusterClusterSimpleStructResponseParams +- (instancetype)init +{ + if (self = [super init]) { + + _arg1 = [CHIPTestClusterClusterSimpleStruct new]; + } + return self; +} +@end + @implementation CHIPTestClusterClusterTestListInt8UArgumentRequestParams - (instancetype)init { @@ -4098,6 +4109,17 @@ - (instancetype)init } @end +@implementation CHIPTestClusterClusterSimpleStructEchoRequestParams +- (instancetype)init +{ + if (self = [super init]) { + + _arg1 = [CHIPTestClusterClusterSimpleStruct new]; + } + return self; +} +@end + @implementation CHIPMessagingClusterDisplayMessageParams - (instancetype)init { diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPStructsObjc.h b/src/darwin/Framework/CHIP/zap-generated/CHIPStructsObjc.h index 52d4ef27dd49d8..b7209a820d4919 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPStructsObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPStructsObjc.h @@ -313,6 +313,8 @@ NS_ASSUME_NONNULL_BEGIN @property (strong, nonatomic) NSData * _Nonnull d; @property (strong, nonatomic) NSString * _Nonnull e; @property (strong, nonatomic) NSNumber * _Nonnull f; +@property (strong, nonatomic) NSNumber * _Nonnull g; +@property (strong, nonatomic) NSNumber * _Nonnull h; - (instancetype)init; @end diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPStructsObjc.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPStructsObjc.mm index 652f6f1302549e..d3c825410595d8 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPStructsObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPStructsObjc.mm @@ -636,6 +636,10 @@ - (instancetype)init _e = @""; _f = @(0); + + _g = @(0); + + _h = @(0); } return self; } diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm index 6262114cd1c964..3ca97c020c54f4 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm @@ -6580,6 +6580,8 @@ new CHIPDefaultSuccessCallbackBridge( nonNullValue_2.e = [self asCharSpan:element_0.nullableStruct.e]; nonNullValue_2.f = static_cast>( element_0.nullableStruct.f.unsignedCharValue); + nonNullValue_2.g = element_0.nullableStruct.g.floatValue; + nonNullValue_2.h = element_0.nullableStruct.h.doubleValue; } if (element_0.optionalStruct != nil) { auto & definedValue_2 = listHolder_0->mList[i].optionalStruct.Emplace(); @@ -6591,6 +6593,8 @@ new CHIPDefaultSuccessCallbackBridge( definedValue_2.e = [self asCharSpan:element_0.optionalStruct.e]; definedValue_2.f = static_cast>( element_0.optionalStruct.f.unsignedCharValue); + definedValue_2.g = element_0.optionalStruct.g.floatValue; + definedValue_2.h = element_0.optionalStruct.h.doubleValue; } if (element_0.nullableOptionalStruct != nil) { auto & definedValue_2 = listHolder_0->mList[i].nullableOptionalStruct.Emplace(); @@ -6606,6 +6610,8 @@ new CHIPDefaultSuccessCallbackBridge( nonNullValue_3.e = [self asCharSpan:element_0.nullableOptionalStruct.e]; nonNullValue_3.f = static_cast>( element_0.nullableOptionalStruct.f.unsignedCharValue); + nonNullValue_3.g = element_0.nullableOptionalStruct.g.floatValue; + nonNullValue_3.h = element_0.nullableOptionalStruct.h.doubleValue; } } if (element_0.nullableList == nil) { diff --git a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m index 5a5cbfa9b1a623..f3b3ed3f94d196 100644 --- a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m +++ b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m @@ -21460,6 +21460,8 @@ - (void)testSendClusterTestCluster_000126_TestStructArgumentRequest ((CHIPTestClusterClusterSimpleStruct *) params.arg1).d = [[NSData alloc] initWithBytes:"octet_string" length:12]; ((CHIPTestClusterClusterSimpleStruct *) params.arg1).e = @"char_string"; ((CHIPTestClusterClusterSimpleStruct *) params.arg1).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) params.arg1).g = [NSNumber numberWithFloat:0]; + ((CHIPTestClusterClusterSimpleStruct *) params.arg1).h = [NSNumber numberWithDouble:0]; [cluster testStructArgumentRequestWithParams:params completionHandler:^( @@ -21496,6 +21498,8 @@ - (void)testSendClusterTestCluster_000127_TestStructArgumentRequest ((CHIPTestClusterClusterSimpleStruct *) params.arg1).d = [[NSData alloc] initWithBytes:"octet_string" length:12]; ((CHIPTestClusterClusterSimpleStruct *) params.arg1).e = @"char_string"; ((CHIPTestClusterClusterSimpleStruct *) params.arg1).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) params.arg1).g = [NSNumber numberWithFloat:0]; + ((CHIPTestClusterClusterSimpleStruct *) params.arg1).h = [NSNumber numberWithDouble:0]; [cluster testStructArgumentRequestWithParams:params completionHandler:^( @@ -21514,7 +21518,54 @@ - (void)testSendClusterTestCluster_000127_TestStructArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000128_TestListInt8UArgumentRequest +- (void)testSendClusterTestCluster_000128_SimpleStructEchoRequest +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"Send Test Command With Struct Argument and see what we get back"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + __auto_type * params = [[CHIPTestClusterClusterSimpleStructEchoRequestParams alloc] init]; + params.arg1 = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) params.arg1).a = [NSNumber numberWithUnsignedChar:17]; + ((CHIPTestClusterClusterSimpleStruct *) params.arg1).b = [NSNumber numberWithBool:false]; + ((CHIPTestClusterClusterSimpleStruct *) params.arg1).c = [NSNumber numberWithUnsignedChar:2]; + ((CHIPTestClusterClusterSimpleStruct *) params.arg1).d = [[NSData alloc] initWithBytes:"octet_string" length:12]; + ((CHIPTestClusterClusterSimpleStruct *) params.arg1).e = @"char_string"; + ((CHIPTestClusterClusterSimpleStruct *) params.arg1).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) params.arg1).g = [NSNumber numberWithFloat:0.1f]; + ((CHIPTestClusterClusterSimpleStruct *) params.arg1).h = [NSNumber numberWithDouble:0.1]; + + [cluster simpleStructEchoRequestWithParams:params + completionHandler:^( + CHIPTestClusterClusterSimpleStructResponseParams * _Nullable values, NSError * _Nullable err) { + NSLog(@"Send Test Command With Struct Argument and see what we get back Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = values.arg1; + XCTAssertEqual([((CHIPTestClusterClusterSimpleStruct *) actualValue).a unsignedCharValue], 17); + XCTAssertEqual([((CHIPTestClusterClusterSimpleStruct *) actualValue).b boolValue], false); + XCTAssertEqual([((CHIPTestClusterClusterSimpleStruct *) actualValue).c unsignedCharValue], 2); + XCTAssertTrue([((CHIPTestClusterClusterSimpleStruct *) actualValue).d + isEqualToData:[[NSData alloc] initWithBytes:"octet_string" length:12]]); + XCTAssertTrue( + [((CHIPTestClusterClusterSimpleStruct *) actualValue).e isEqualToString:@"char_string"]); + XCTAssertEqual([((CHIPTestClusterClusterSimpleStruct *) actualValue).f unsignedCharValue], 1); + XCTAssertEqual([((CHIPTestClusterClusterSimpleStruct *) actualValue).g floatValue], 0.1f); + XCTAssertEqual([((CHIPTestClusterClusterSimpleStruct *) actualValue).h doubleValue], 0.1); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000129_TestListInt8UArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With List of INT8U and none of them is set to 0"]; @@ -21555,7 +21606,7 @@ - (void)testSendClusterTestCluster_000128_TestListInt8UArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000129_TestListInt8UArgumentRequest +- (void)testSendClusterTestCluster_000130_TestListInt8UArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With List of INT8U and one of them is set to 0"]; @@ -21597,7 +21648,7 @@ - (void)testSendClusterTestCluster_000129_TestListInt8UArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000130_TestListInt8UReverseRequest +- (void)testSendClusterTestCluster_000131_TestListInt8UReverseRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With List of INT8U and get it reversed"]; @@ -21646,7 +21697,7 @@ - (void)testSendClusterTestCluster_000130_TestListInt8UReverseRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000131_TestListInt8UReverseRequest +- (void)testSendClusterTestCluster_000132_TestListInt8UReverseRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With empty List of INT8U and get an empty list back"]; @@ -21678,7 +21729,7 @@ - (void)testSendClusterTestCluster_000131_TestListInt8UReverseRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000132_TestListStructArgumentRequest +- (void)testSendClusterTestCluster_000133_TestListStructArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With List of Struct Argument and arg1.b of first item is true"]; @@ -21698,6 +21749,8 @@ - (void)testSendClusterTestCluster_000132_TestListStructArgumentRequest ((CHIPTestClusterClusterSimpleStruct *) temp[0]).d = [[NSData alloc] initWithBytes:"first_octet_string" length:18]; ((CHIPTestClusterClusterSimpleStruct *) temp[0]).e = @"first_char_string"; ((CHIPTestClusterClusterSimpleStruct *) temp[0]).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp[0]).g = [NSNumber numberWithFloat:0]; + ((CHIPTestClusterClusterSimpleStruct *) temp[0]).h = [NSNumber numberWithDouble:0]; temp[1] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; ((CHIPTestClusterClusterSimpleStruct *) temp[1]).a = [NSNumber numberWithUnsignedChar:1]; @@ -21706,6 +21759,8 @@ - (void)testSendClusterTestCluster_000132_TestListStructArgumentRequest ((CHIPTestClusterClusterSimpleStruct *) temp[1]).d = [[NSData alloc] initWithBytes:"second_octet_string" length:19]; ((CHIPTestClusterClusterSimpleStruct *) temp[1]).e = @"second_char_string"; ((CHIPTestClusterClusterSimpleStruct *) temp[1]).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp[1]).g = [NSNumber numberWithFloat:0]; + ((CHIPTestClusterClusterSimpleStruct *) temp[1]).h = [NSNumber numberWithDouble:0]; params.arg1 = temp; } @@ -21729,7 +21784,7 @@ - (void)testSendClusterTestCluster_000132_TestListStructArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000133_TestListStructArgumentRequest +- (void)testSendClusterTestCluster_000134_TestListStructArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With List of Struct Argument and arg1.b of first item is false"]; @@ -21749,6 +21804,8 @@ - (void)testSendClusterTestCluster_000133_TestListStructArgumentRequest ((CHIPTestClusterClusterSimpleStruct *) temp[0]).d = [[NSData alloc] initWithBytes:"second_octet_string" length:19]; ((CHIPTestClusterClusterSimpleStruct *) temp[0]).e = @"second_char_string"; ((CHIPTestClusterClusterSimpleStruct *) temp[0]).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp[0]).g = [NSNumber numberWithFloat:0]; + ((CHIPTestClusterClusterSimpleStruct *) temp[0]).h = [NSNumber numberWithDouble:0]; temp[1] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; ((CHIPTestClusterClusterSimpleStruct *) temp[1]).a = [NSNumber numberWithUnsignedChar:0]; @@ -21757,6 +21814,8 @@ - (void)testSendClusterTestCluster_000133_TestListStructArgumentRequest ((CHIPTestClusterClusterSimpleStruct *) temp[1]).d = [[NSData alloc] initWithBytes:"first_octet_string" length:18]; ((CHIPTestClusterClusterSimpleStruct *) temp[1]).e = @"first_char_string"; ((CHIPTestClusterClusterSimpleStruct *) temp[1]).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp[1]).g = [NSNumber numberWithFloat:0]; + ((CHIPTestClusterClusterSimpleStruct *) temp[1]).h = [NSNumber numberWithDouble:0]; params.arg1 = temp; } @@ -21780,7 +21839,7 @@ - (void)testSendClusterTestCluster_000133_TestListStructArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000134_WriteAttribute +- (void)testSendClusterTestCluster_000135_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute LIST With List of INT8U and none of them is set to 0"]; @@ -21810,7 +21869,7 @@ - (void)testSendClusterTestCluster_000134_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000135_ReadAttribute +- (void)testSendClusterTestCluster_000136_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST With List of INT8U"]; @@ -21838,7 +21897,7 @@ - (void)testSendClusterTestCluster_000135_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000136_WriteAttribute +- (void)testSendClusterTestCluster_000137_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute LIST With List of OCTET_STRING"]; @@ -21867,7 +21926,7 @@ - (void)testSendClusterTestCluster_000136_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000137_ReadAttribute +- (void)testSendClusterTestCluster_000138_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST With List of OCTET_STRING"]; @@ -21895,7 +21954,7 @@ - (void)testSendClusterTestCluster_000137_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000138_WriteAttribute +- (void)testSendClusterTestCluster_000139_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute LIST With List of LIST_STRUCT_OCTET_STRING"]; @@ -21937,7 +21996,7 @@ - (void)testSendClusterTestCluster_000138_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000139_ReadAttribute +- (void)testSendClusterTestCluster_000140_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST With List of LIST_STRUCT_OCTET_STRING"]; @@ -21955,54 +22014,22 @@ - (void)testSendClusterTestCluster_000139_ReadAttribute { id actualValue = value; XCTAssertEqual([actualValue count], 4); - if ([actualValue[0] isKindOfClass:[NSDictionary class]]) { - XCTAssertEqual([actualValue[0][@"fabricIndex"] unsignedLongLongValue], 0ULL); - } else { - XCTAssertEqual( - [((CHIPTestClusterClusterTestListStructOctet *) actualValue[0]).fabricIndex unsignedLongLongValue], 0ULL); - } - if ([actualValue[0] isKindOfClass:[NSDictionary class]]) { - XCTAssertTrue([actualValue[0][@"operationalCert"] isEqualToData:[[NSData alloc] initWithBytes:"Test0" length:5]]); - } else { - XCTAssertTrue([((CHIPTestClusterClusterTestListStructOctet *) actualValue[0]).operationalCert - isEqualToData:[[NSData alloc] initWithBytes:"Test0" length:5]]); - } - if ([actualValue[1] isKindOfClass:[NSDictionary class]]) { - XCTAssertEqual([actualValue[1][@"fabricIndex"] unsignedLongLongValue], 1ULL); - } else { - XCTAssertEqual( - [((CHIPTestClusterClusterTestListStructOctet *) actualValue[1]).fabricIndex unsignedLongLongValue], 1ULL); - } - if ([actualValue[1] isKindOfClass:[NSDictionary class]]) { - XCTAssertTrue([actualValue[1][@"operationalCert"] isEqualToData:[[NSData alloc] initWithBytes:"Test1" length:5]]); - } else { - XCTAssertTrue([((CHIPTestClusterClusterTestListStructOctet *) actualValue[1]).operationalCert - isEqualToData:[[NSData alloc] initWithBytes:"Test1" length:5]]); - } - if ([actualValue[2] isKindOfClass:[NSDictionary class]]) { - XCTAssertEqual([actualValue[2][@"fabricIndex"] unsignedLongLongValue], 2ULL); - } else { - XCTAssertEqual( - [((CHIPTestClusterClusterTestListStructOctet *) actualValue[2]).fabricIndex unsignedLongLongValue], 2ULL); - } - if ([actualValue[2] isKindOfClass:[NSDictionary class]]) { - XCTAssertTrue([actualValue[2][@"operationalCert"] isEqualToData:[[NSData alloc] initWithBytes:"Test2" length:5]]); - } else { - XCTAssertTrue([((CHIPTestClusterClusterTestListStructOctet *) actualValue[2]).operationalCert - isEqualToData:[[NSData alloc] initWithBytes:"Test2" length:5]]); - } - if ([actualValue[3] isKindOfClass:[NSDictionary class]]) { - XCTAssertEqual([actualValue[3][@"fabricIndex"] unsignedLongLongValue], 3ULL); - } else { - XCTAssertEqual( - [((CHIPTestClusterClusterTestListStructOctet *) actualValue[3]).fabricIndex unsignedLongLongValue], 3ULL); - } - if ([actualValue[3] isKindOfClass:[NSDictionary class]]) { - XCTAssertTrue([actualValue[3][@"operationalCert"] isEqualToData:[[NSData alloc] initWithBytes:"Test3" length:5]]); - } else { - XCTAssertTrue([((CHIPTestClusterClusterTestListStructOctet *) actualValue[3]).operationalCert - isEqualToData:[[NSData alloc] initWithBytes:"Test3" length:5]]); - } + XCTAssertEqual( + [((CHIPTestClusterClusterTestListStructOctet *) actualValue[0]).fabricIndex unsignedLongLongValue], 0ULL); + XCTAssertTrue([((CHIPTestClusterClusterTestListStructOctet *) actualValue[0]).operationalCert + isEqualToData:[[NSData alloc] initWithBytes:"Test0" length:5]]); + XCTAssertEqual( + [((CHIPTestClusterClusterTestListStructOctet *) actualValue[1]).fabricIndex unsignedLongLongValue], 1ULL); + XCTAssertTrue([((CHIPTestClusterClusterTestListStructOctet *) actualValue[1]).operationalCert + isEqualToData:[[NSData alloc] initWithBytes:"Test1" length:5]]); + XCTAssertEqual( + [((CHIPTestClusterClusterTestListStructOctet *) actualValue[2]).fabricIndex unsignedLongLongValue], 2ULL); + XCTAssertTrue([((CHIPTestClusterClusterTestListStructOctet *) actualValue[2]).operationalCert + isEqualToData:[[NSData alloc] initWithBytes:"Test2" length:5]]); + XCTAssertEqual( + [((CHIPTestClusterClusterTestListStructOctet *) actualValue[3]).fabricIndex unsignedLongLongValue], 3ULL); + XCTAssertTrue([((CHIPTestClusterClusterTestListStructOctet *) actualValue[3]).operationalCert + isEqualToData:[[NSData alloc] initWithBytes:"Test3" length:5]]); } [expectation fulfill]; @@ -22010,7 +22037,7 @@ - (void)testSendClusterTestCluster_000139_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000140_TestNullableOptionalRequest +- (void)testSendClusterTestCluster_000141_TestNullableOptionalRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command with optional arg set."]; @@ -22051,7 +22078,7 @@ - (void)testSendClusterTestCluster_000140_TestNullableOptionalRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000141_TestNullableOptionalRequest +- (void)testSendClusterTestCluster_000142_TestNullableOptionalRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command without its optional arg."]; @@ -22078,7 +22105,7 @@ - (void)testSendClusterTestCluster_000141_TestNullableOptionalRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000142_WriteAttribute +- (void)testSendClusterTestCluster_000143_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BOOLEAN null"]; @@ -22100,7 +22127,7 @@ - (void)testSendClusterTestCluster_000142_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000143_ReadAttribute +- (void)testSendClusterTestCluster_000144_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BOOLEAN null"]; @@ -22124,7 +22151,7 @@ - (void)testSendClusterTestCluster_000143_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000144_WriteAttribute +- (void)testSendClusterTestCluster_000145_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BOOLEAN True"]; @@ -22146,7 +22173,7 @@ - (void)testSendClusterTestCluster_000144_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000145_ReadAttribute +- (void)testSendClusterTestCluster_000146_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BOOLEAN True"]; @@ -22171,7 +22198,7 @@ - (void)testSendClusterTestCluster_000145_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000146_WriteAttribute +- (void)testSendClusterTestCluster_000147_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP8 Max Value"]; @@ -22193,7 +22220,7 @@ - (void)testSendClusterTestCluster_000146_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000147_ReadAttribute +- (void)testSendClusterTestCluster_000148_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP8 Max Value"]; @@ -22218,7 +22245,7 @@ - (void)testSendClusterTestCluster_000147_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000148_WriteAttribute +- (void)testSendClusterTestCluster_000149_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP8 Invalid Value"]; @@ -22239,7 +22266,7 @@ - (void)testSendClusterTestCluster_000148_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000149_ReadAttribute +- (void)testSendClusterTestCluster_000150_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP8 unchanged Value"]; @@ -22264,7 +22291,7 @@ - (void)testSendClusterTestCluster_000149_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000150_WriteAttribute +- (void)testSendClusterTestCluster_000151_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP8 null Value"]; @@ -22286,7 +22313,7 @@ - (void)testSendClusterTestCluster_000150_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000151_ReadAttribute +- (void)testSendClusterTestCluster_000152_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP8 null Value"]; @@ -22310,7 +22337,7 @@ - (void)testSendClusterTestCluster_000151_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000152_WriteAttribute +- (void)testSendClusterTestCluster_000153_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP16 Max Value"]; @@ -22332,7 +22359,7 @@ - (void)testSendClusterTestCluster_000152_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000153_ReadAttribute +- (void)testSendClusterTestCluster_000154_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP16 Max Value"]; @@ -22357,7 +22384,7 @@ - (void)testSendClusterTestCluster_000153_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000154_WriteAttribute +- (void)testSendClusterTestCluster_000155_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP16 Invalid Value"]; @@ -22378,7 +22405,7 @@ - (void)testSendClusterTestCluster_000154_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000155_ReadAttribute +- (void)testSendClusterTestCluster_000156_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP16 unchanged Value"]; @@ -22403,7 +22430,7 @@ - (void)testSendClusterTestCluster_000155_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000156_WriteAttribute +- (void)testSendClusterTestCluster_000157_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP16 null Value"]; @@ -22425,7 +22452,7 @@ - (void)testSendClusterTestCluster_000156_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000157_ReadAttribute +- (void)testSendClusterTestCluster_000158_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP16 null Value"]; @@ -22449,7 +22476,7 @@ - (void)testSendClusterTestCluster_000157_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000158_WriteAttribute +- (void)testSendClusterTestCluster_000159_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP32 Max Value"]; @@ -22471,7 +22498,7 @@ - (void)testSendClusterTestCluster_000158_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000159_ReadAttribute +- (void)testSendClusterTestCluster_000160_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP32 Max Value"]; @@ -22496,7 +22523,7 @@ - (void)testSendClusterTestCluster_000159_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000160_WriteAttribute +- (void)testSendClusterTestCluster_000161_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP32 Invalid Value"]; @@ -22517,7 +22544,7 @@ - (void)testSendClusterTestCluster_000160_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000161_ReadAttribute +- (void)testSendClusterTestCluster_000162_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP32 unchanged Value"]; @@ -22542,7 +22569,7 @@ - (void)testSendClusterTestCluster_000161_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000162_WriteAttribute +- (void)testSendClusterTestCluster_000163_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP32 null Value"]; @@ -22564,7 +22591,7 @@ - (void)testSendClusterTestCluster_000162_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000163_ReadAttribute +- (void)testSendClusterTestCluster_000164_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP32 null Value"]; @@ -22588,7 +22615,7 @@ - (void)testSendClusterTestCluster_000163_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000164_WriteAttribute +- (void)testSendClusterTestCluster_000165_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP64 Max Value"]; @@ -22610,7 +22637,7 @@ - (void)testSendClusterTestCluster_000164_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000165_ReadAttribute +- (void)testSendClusterTestCluster_000166_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP64 Max Value"]; @@ -22635,7 +22662,7 @@ - (void)testSendClusterTestCluster_000165_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000166_WriteAttribute +- (void)testSendClusterTestCluster_000167_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP64 Invalid Value"]; @@ -22656,7 +22683,7 @@ - (void)testSendClusterTestCluster_000166_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000167_ReadAttribute +- (void)testSendClusterTestCluster_000168_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP64 unchanged Value"]; @@ -22681,7 +22708,7 @@ - (void)testSendClusterTestCluster_000167_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000168_WriteAttribute +- (void)testSendClusterTestCluster_000169_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP64 null Value"]; @@ -22703,7 +22730,7 @@ - (void)testSendClusterTestCluster_000168_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000169_ReadAttribute +- (void)testSendClusterTestCluster_000170_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP64 null Value"]; @@ -22727,7 +22754,7 @@ - (void)testSendClusterTestCluster_000169_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000170_WriteAttribute +- (void)testSendClusterTestCluster_000171_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U Max Value"]; @@ -22749,7 +22776,7 @@ - (void)testSendClusterTestCluster_000170_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000171_ReadAttribute +- (void)testSendClusterTestCluster_000172_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U Max Value"]; @@ -22774,7 +22801,7 @@ - (void)testSendClusterTestCluster_000171_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000172_WriteAttribute +- (void)testSendClusterTestCluster_000173_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U Invalid Value"]; @@ -22795,7 +22822,7 @@ - (void)testSendClusterTestCluster_000172_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000173_ReadAttribute +- (void)testSendClusterTestCluster_000174_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U unchanged Value"]; @@ -22820,7 +22847,7 @@ - (void)testSendClusterTestCluster_000173_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000174_WriteAttribute +- (void)testSendClusterTestCluster_000175_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U null Value"]; @@ -22842,7 +22869,7 @@ - (void)testSendClusterTestCluster_000174_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000175_ReadAttribute +- (void)testSendClusterTestCluster_000176_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U null Value"]; @@ -22866,7 +22893,7 @@ - (void)testSendClusterTestCluster_000175_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000176_WriteAttribute +- (void)testSendClusterTestCluster_000177_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U Max Value"]; @@ -22888,7 +22915,7 @@ - (void)testSendClusterTestCluster_000176_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000177_ReadAttribute +- (void)testSendClusterTestCluster_000178_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U Max Value"]; @@ -22913,7 +22940,7 @@ - (void)testSendClusterTestCluster_000177_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000178_WriteAttribute +- (void)testSendClusterTestCluster_000179_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U Invalid Value"]; @@ -22934,7 +22961,7 @@ - (void)testSendClusterTestCluster_000178_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000179_ReadAttribute +- (void)testSendClusterTestCluster_000180_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U unchanged Value"]; @@ -22959,7 +22986,7 @@ - (void)testSendClusterTestCluster_000179_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000180_WriteAttribute +- (void)testSendClusterTestCluster_000181_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U null Value"]; @@ -22981,7 +23008,7 @@ - (void)testSendClusterTestCluster_000180_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000181_ReadAttribute +- (void)testSendClusterTestCluster_000182_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U null Value"]; @@ -23005,7 +23032,7 @@ - (void)testSendClusterTestCluster_000181_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000182_WriteAttribute +- (void)testSendClusterTestCluster_000183_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U Max Value"]; @@ -23027,7 +23054,7 @@ - (void)testSendClusterTestCluster_000182_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000183_ReadAttribute +- (void)testSendClusterTestCluster_000184_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U Max Value"]; @@ -23052,7 +23079,7 @@ - (void)testSendClusterTestCluster_000183_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000184_WriteAttribute +- (void)testSendClusterTestCluster_000185_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U Invalid Value"]; @@ -23073,7 +23100,7 @@ - (void)testSendClusterTestCluster_000184_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000185_ReadAttribute +- (void)testSendClusterTestCluster_000186_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U unchanged Value"]; @@ -23098,7 +23125,7 @@ - (void)testSendClusterTestCluster_000185_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000186_WriteAttribute +- (void)testSendClusterTestCluster_000187_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U null Value"]; @@ -23120,7 +23147,7 @@ - (void)testSendClusterTestCluster_000186_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000187_ReadAttribute +- (void)testSendClusterTestCluster_000188_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U null Value"]; @@ -23144,7 +23171,7 @@ - (void)testSendClusterTestCluster_000187_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000188_WriteAttribute +- (void)testSendClusterTestCluster_000189_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U Max Value"]; @@ -23166,7 +23193,7 @@ - (void)testSendClusterTestCluster_000188_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000189_ReadAttribute +- (void)testSendClusterTestCluster_000190_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U Max Value"]; @@ -23191,7 +23218,7 @@ - (void)testSendClusterTestCluster_000189_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000190_WriteAttribute +- (void)testSendClusterTestCluster_000191_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U Invalid Value"]; @@ -23212,7 +23239,7 @@ - (void)testSendClusterTestCluster_000190_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000191_ReadAttribute +- (void)testSendClusterTestCluster_000192_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U unchanged Value"]; @@ -23237,7 +23264,7 @@ - (void)testSendClusterTestCluster_000191_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000192_WriteAttribute +- (void)testSendClusterTestCluster_000193_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U null Value"]; @@ -23259,7 +23286,7 @@ - (void)testSendClusterTestCluster_000192_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000193_ReadAttribute +- (void)testSendClusterTestCluster_000194_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U null Value"]; @@ -23283,7 +23310,7 @@ - (void)testSendClusterTestCluster_000193_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000194_WriteAttribute +- (void)testSendClusterTestCluster_000195_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S Min Value"]; @@ -23305,7 +23332,7 @@ - (void)testSendClusterTestCluster_000194_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000195_ReadAttribute +- (void)testSendClusterTestCluster_000196_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S Min Value"]; @@ -23330,7 +23357,7 @@ - (void)testSendClusterTestCluster_000195_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000196_WriteAttribute +- (void)testSendClusterTestCluster_000197_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S Invalid Value"]; @@ -23351,7 +23378,7 @@ - (void)testSendClusterTestCluster_000196_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000197_ReadAttribute +- (void)testSendClusterTestCluster_000198_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S unchanged Value"]; @@ -23376,7 +23403,7 @@ - (void)testSendClusterTestCluster_000197_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000198_WriteAttribute +- (void)testSendClusterTestCluster_000199_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S null Value"]; @@ -23398,7 +23425,7 @@ - (void)testSendClusterTestCluster_000198_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000199_ReadAttribute +- (void)testSendClusterTestCluster_000200_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S null Value"]; @@ -23422,7 +23449,7 @@ - (void)testSendClusterTestCluster_000199_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000200_WriteAttribute +- (void)testSendClusterTestCluster_000201_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S Min Value"]; @@ -23444,7 +23471,7 @@ - (void)testSendClusterTestCluster_000200_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000201_ReadAttribute +- (void)testSendClusterTestCluster_000202_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S Min Value"]; @@ -23469,7 +23496,7 @@ - (void)testSendClusterTestCluster_000201_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000202_WriteAttribute +- (void)testSendClusterTestCluster_000203_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S Invalid Value"]; @@ -23490,7 +23517,7 @@ - (void)testSendClusterTestCluster_000202_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000203_ReadAttribute +- (void)testSendClusterTestCluster_000204_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S unchanged Value"]; @@ -23515,7 +23542,7 @@ - (void)testSendClusterTestCluster_000203_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000204_WriteAttribute +- (void)testSendClusterTestCluster_000205_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S null Value"]; @@ -23537,7 +23564,7 @@ - (void)testSendClusterTestCluster_000204_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000205_ReadAttribute +- (void)testSendClusterTestCluster_000206_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S null Value"]; @@ -23561,7 +23588,7 @@ - (void)testSendClusterTestCluster_000205_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000206_WriteAttribute +- (void)testSendClusterTestCluster_000207_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S Min Value"]; @@ -23583,7 +23610,7 @@ - (void)testSendClusterTestCluster_000206_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000207_ReadAttribute +- (void)testSendClusterTestCluster_000208_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S Min Value"]; @@ -23608,7 +23635,7 @@ - (void)testSendClusterTestCluster_000207_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000208_WriteAttribute +- (void)testSendClusterTestCluster_000209_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S Invalid Value"]; @@ -23629,7 +23656,7 @@ - (void)testSendClusterTestCluster_000208_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000209_ReadAttribute +- (void)testSendClusterTestCluster_000210_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S unchanged Value"]; @@ -23654,7 +23681,7 @@ - (void)testSendClusterTestCluster_000209_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000210_WriteAttribute +- (void)testSendClusterTestCluster_000211_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S null Value"]; @@ -23676,7 +23703,7 @@ - (void)testSendClusterTestCluster_000210_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000211_ReadAttribute +- (void)testSendClusterTestCluster_000212_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S null Value"]; @@ -23700,7 +23727,7 @@ - (void)testSendClusterTestCluster_000211_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000212_WriteAttribute +- (void)testSendClusterTestCluster_000213_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S Min Value"]; @@ -23722,7 +23749,7 @@ - (void)testSendClusterTestCluster_000212_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000213_ReadAttribute +- (void)testSendClusterTestCluster_000214_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S Min Value"]; @@ -23747,7 +23774,7 @@ - (void)testSendClusterTestCluster_000213_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000214_WriteAttribute +- (void)testSendClusterTestCluster_000215_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S Invalid Value"]; @@ -23768,7 +23795,7 @@ - (void)testSendClusterTestCluster_000214_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000215_ReadAttribute +- (void)testSendClusterTestCluster_000216_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S unchanged Value"]; @@ -23793,7 +23820,7 @@ - (void)testSendClusterTestCluster_000215_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000216_WriteAttribute +- (void)testSendClusterTestCluster_000217_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S null Value"]; @@ -23815,7 +23842,7 @@ - (void)testSendClusterTestCluster_000216_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000217_ReadAttribute +- (void)testSendClusterTestCluster_000218_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S null Value"]; @@ -23839,7 +23866,7 @@ - (void)testSendClusterTestCluster_000217_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000218_WriteAttribute +- (void)testSendClusterTestCluster_000219_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 Max Value"]; @@ -23861,7 +23888,7 @@ - (void)testSendClusterTestCluster_000218_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000219_ReadAttribute +- (void)testSendClusterTestCluster_000220_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 Max Value"]; @@ -23886,7 +23913,7 @@ - (void)testSendClusterTestCluster_000219_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000220_WriteAttribute +- (void)testSendClusterTestCluster_000221_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 Invalid Value"]; @@ -23907,7 +23934,7 @@ - (void)testSendClusterTestCluster_000220_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000221_ReadAttribute +- (void)testSendClusterTestCluster_000222_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 unchanged Value"]; @@ -23932,7 +23959,7 @@ - (void)testSendClusterTestCluster_000221_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000222_WriteAttribute +- (void)testSendClusterTestCluster_000223_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 null Value"]; @@ -23954,7 +23981,7 @@ - (void)testSendClusterTestCluster_000222_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000223_ReadAttribute +- (void)testSendClusterTestCluster_000224_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 null Value"]; @@ -23978,7 +24005,7 @@ - (void)testSendClusterTestCluster_000223_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000224_WriteAttribute +- (void)testSendClusterTestCluster_000225_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 Max Value"]; @@ -24000,7 +24027,7 @@ - (void)testSendClusterTestCluster_000224_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000225_ReadAttribute +- (void)testSendClusterTestCluster_000226_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 Max Value"]; @@ -24025,7 +24052,7 @@ - (void)testSendClusterTestCluster_000225_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000226_WriteAttribute +- (void)testSendClusterTestCluster_000227_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 Invalid Value"]; @@ -24046,7 +24073,7 @@ - (void)testSendClusterTestCluster_000226_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000227_ReadAttribute +- (void)testSendClusterTestCluster_000228_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 unchanged Value"]; @@ -24071,7 +24098,7 @@ - (void)testSendClusterTestCluster_000227_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000228_WriteAttribute +- (void)testSendClusterTestCluster_000229_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 null Value"]; @@ -24093,7 +24120,7 @@ - (void)testSendClusterTestCluster_000228_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000229_ReadAttribute +- (void)testSendClusterTestCluster_000230_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 null Value"]; @@ -24117,7 +24144,7 @@ - (void)testSendClusterTestCluster_000229_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000230_ReadAttribute +- (void)testSendClusterTestCluster_000231_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING Default Value"]; @@ -24142,7 +24169,7 @@ - (void)testSendClusterTestCluster_000230_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000231_WriteAttribute +- (void)testSendClusterTestCluster_000232_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_OCTET_STRING"]; @@ -24164,7 +24191,7 @@ - (void)testSendClusterTestCluster_000231_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000232_ReadAttribute +- (void)testSendClusterTestCluster_000233_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING"]; @@ -24189,7 +24216,7 @@ - (void)testSendClusterTestCluster_000232_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000233_WriteAttribute +- (void)testSendClusterTestCluster_000234_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_OCTET_STRING"]; @@ -24211,7 +24238,7 @@ - (void)testSendClusterTestCluster_000233_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000234_ReadAttribute +- (void)testSendClusterTestCluster_000235_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING"]; @@ -24235,7 +24262,7 @@ - (void)testSendClusterTestCluster_000234_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000235_WriteAttribute +- (void)testSendClusterTestCluster_000236_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_OCTET_STRING"]; @@ -24257,7 +24284,7 @@ - (void)testSendClusterTestCluster_000235_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000236_ReadAttribute +- (void)testSendClusterTestCluster_000237_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING"]; @@ -24282,7 +24309,7 @@ - (void)testSendClusterTestCluster_000236_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000237_ReadAttribute +- (void)testSendClusterTestCluster_000238_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING Default Value"]; @@ -24307,7 +24334,7 @@ - (void)testSendClusterTestCluster_000237_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000238_WriteAttribute +- (void)testSendClusterTestCluster_000239_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_CHAR_STRING"]; @@ -24329,7 +24356,7 @@ - (void)testSendClusterTestCluster_000238_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000239_WriteAttribute +- (void)testSendClusterTestCluster_000240_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_CHAR_STRING - Value too long"]; @@ -24351,7 +24378,7 @@ - (void)testSendClusterTestCluster_000239_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000240_ReadAttribute +- (void)testSendClusterTestCluster_000241_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING"]; @@ -24375,7 +24402,7 @@ - (void)testSendClusterTestCluster_000240_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000241_WriteAttribute +- (void)testSendClusterTestCluster_000242_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_CHAR_STRING - Empty"]; @@ -24397,7 +24424,7 @@ - (void)testSendClusterTestCluster_000241_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000242_ReadAttribute +- (void)testSendClusterTestCluster_000243_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING"]; @@ -24422,7 +24449,7 @@ - (void)testSendClusterTestCluster_000242_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000243_ReadAttribute +- (void)testSendClusterTestCluster_000244_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read nonexistent attribute."]; @@ -24562,16 +24589,8 @@ - (void)testSendClusterTestDescriptorCluster_000000_ReadAttribute { id actualValue = value; XCTAssertEqual([actualValue count], 1); - if ([actualValue[0] isKindOfClass:[NSDictionary class]]) { - XCTAssertEqual([actualValue[0][@"type"] unsignedIntValue], 0UL); - } else { - XCTAssertEqual([((CHIPDescriptorClusterDeviceType *) actualValue[0]).type unsignedIntValue], 0UL); - } - if ([actualValue[0] isKindOfClass:[NSDictionary class]]) { - XCTAssertEqual([actualValue[0][@"revision"] unsignedShortValue], 1U); - } else { - XCTAssertEqual([((CHIPDescriptorClusterDeviceType *) actualValue[0]).revision unsignedShortValue], 1U); - } + XCTAssertEqual([((CHIPDescriptorClusterDeviceType *) actualValue[0]).type unsignedIntValue], 0UL); + XCTAssertEqual([((CHIPDescriptorClusterDeviceType *) actualValue[0]).revision unsignedShortValue], 1U); } [expectation fulfill]; @@ -25447,51 +25466,15 @@ - (void)testSendClusterTestModeSelectCluster_000004_ReadAttribute { id actualValue = value; XCTAssertEqual([actualValue count], 3); - if ([actualValue[0] isKindOfClass:[NSDictionary class]]) { - XCTAssertTrue([actualValue[0][@"label"] isEqualToString:@"Black"]); - } else { - XCTAssertTrue([((CHIPModeSelectClusterModeOptionStruct *) actualValue[0]).label isEqualToString:@"Black"]); - } - if ([actualValue[0] isKindOfClass:[NSDictionary class]]) { - XCTAssertEqual([actualValue[0][@"mode"] unsignedCharValue], 0); - } else { - XCTAssertEqual([((CHIPModeSelectClusterModeOptionStruct *) actualValue[0]).mode unsignedCharValue], 0); - } - if ([actualValue[0] isKindOfClass:[NSDictionary class]]) { - XCTAssertEqual([actualValue[0][@"semanticTag"] unsignedIntValue], 0UL); - } else { - XCTAssertEqual([((CHIPModeSelectClusterModeOptionStruct *) actualValue[0]).semanticTag unsignedIntValue], 0UL); - } - if ([actualValue[1] isKindOfClass:[NSDictionary class]]) { - XCTAssertTrue([actualValue[1][@"label"] isEqualToString:@"Cappuccino"]); - } else { - XCTAssertTrue([((CHIPModeSelectClusterModeOptionStruct *) actualValue[1]).label isEqualToString:@"Cappuccino"]); - } - if ([actualValue[1] isKindOfClass:[NSDictionary class]]) { - XCTAssertEqual([actualValue[1][@"mode"] unsignedCharValue], 4); - } else { - XCTAssertEqual([((CHIPModeSelectClusterModeOptionStruct *) actualValue[1]).mode unsignedCharValue], 4); - } - if ([actualValue[1] isKindOfClass:[NSDictionary class]]) { - XCTAssertEqual([actualValue[1][@"semanticTag"] unsignedIntValue], 0UL); - } else { - XCTAssertEqual([((CHIPModeSelectClusterModeOptionStruct *) actualValue[1]).semanticTag unsignedIntValue], 0UL); - } - if ([actualValue[2] isKindOfClass:[NSDictionary class]]) { - XCTAssertTrue([actualValue[2][@"label"] isEqualToString:@"Espresso"]); - } else { - XCTAssertTrue([((CHIPModeSelectClusterModeOptionStruct *) actualValue[2]).label isEqualToString:@"Espresso"]); - } - if ([actualValue[2] isKindOfClass:[NSDictionary class]]) { - XCTAssertEqual([actualValue[2][@"mode"] unsignedCharValue], 7); - } else { - XCTAssertEqual([((CHIPModeSelectClusterModeOptionStruct *) actualValue[2]).mode unsignedCharValue], 7); - } - if ([actualValue[2] isKindOfClass:[NSDictionary class]]) { - XCTAssertEqual([actualValue[2][@"semanticTag"] unsignedIntValue], 0UL); - } else { - XCTAssertEqual([((CHIPModeSelectClusterModeOptionStruct *) actualValue[2]).semanticTag unsignedIntValue], 0UL); - } + XCTAssertTrue([((CHIPModeSelectClusterModeOptionStruct *) actualValue[0]).label isEqualToString:@"Black"]); + XCTAssertEqual([((CHIPModeSelectClusterModeOptionStruct *) actualValue[0]).mode unsignedCharValue], 0); + XCTAssertEqual([((CHIPModeSelectClusterModeOptionStruct *) actualValue[0]).semanticTag unsignedIntValue], 0UL); + XCTAssertTrue([((CHIPModeSelectClusterModeOptionStruct *) actualValue[1]).label isEqualToString:@"Cappuccino"]); + XCTAssertEqual([((CHIPModeSelectClusterModeOptionStruct *) actualValue[1]).mode unsignedCharValue], 4); + XCTAssertEqual([((CHIPModeSelectClusterModeOptionStruct *) actualValue[1]).semanticTag unsignedIntValue], 0UL); + XCTAssertTrue([((CHIPModeSelectClusterModeOptionStruct *) actualValue[2]).label isEqualToString:@"Espresso"]); + XCTAssertEqual([((CHIPModeSelectClusterModeOptionStruct *) actualValue[2]).mode unsignedCharValue], 7); + XCTAssertEqual([((CHIPModeSelectClusterModeOptionStruct *) actualValue[2]).semanticTag unsignedIntValue], 0UL); } [expectation fulfill]; diff --git a/zzz_generated/all-clusters-app/zap-generated/IMClusterCommandHandler.cpp b/zzz_generated/all-clusters-app/zap-generated/IMClusterCommandHandler.cpp index ae876292017256..9ba1d28f7dc082 100644 --- a/zzz_generated/all-clusters-app/zap-generated/IMClusterCommandHandler.cpp +++ b/zzz_generated/all-clusters-app/zap-generated/IMClusterCommandHandler.cpp @@ -1627,6 +1627,15 @@ void DispatchServerCommand(CommandHandler * apCommandObj, const ConcreteCommandP { switch (aCommandPath.mCommandId) { + case Commands::SimpleStructEchoRequest::Id: { + Commands::SimpleStructEchoRequest::DecodableType commandData; + TLVError = DataModel::Decode(aDataTlv, commandData); + if (TLVError == CHIP_NO_ERROR) + { + wasHandled = emberAfTestClusterClusterSimpleStructEchoRequestCallback(apCommandObj, aCommandPath, commandData); + } + break; + } case Commands::Test::Id: { Commands::Test::DecodableType commandData; TLVError = DataModel::Decode(aDataTlv, commandData); diff --git a/zzz_generated/all-clusters-app/zap-generated/attribute-size.cpp b/zzz_generated/all-clusters-app/zap-generated/attribute-size.cpp index 2cc27f9fa86272..53216da4432b3c 100644 --- a/zzz_generated/all-clusters-app/zap-generated/attribute-size.cpp +++ b/zzz_generated/all-clusters-app/zap-generated/attribute-size.cpp @@ -884,7 +884,7 @@ uint16_t emberAfCopyList(ClusterId clusterId, EmberAfAttributeMetadata * am, boo } case 0x0023: // list_nullables_and_optionals_struct { - entryLength = 39; + entryLength = 75; if (((index - 1) * entryLength) > (am->size - entryLength)) { ChipLogError(Zcl, "Index %" PRId32 " is invalid.", index); @@ -1327,7 +1327,7 @@ uint16_t emberAfAttributeValueListSize(ClusterId clusterId, AttributeId attribut break; case 0x0023: // list_nullables_and_optionals_struct // Struct _NullablesAndOptionalsStruct - entryLength = 39; + entryLength = 75; break; } break; diff --git a/zzz_generated/app-common/app-common/zap-generated/af-structs.h b/zzz_generated/app-common/app-common/zap-generated/af-structs.h index 6cac4edc1fc76c..c8956594092d85 100644 --- a/zzz_generated/app-common/app-common/zap-generated/af-structs.h +++ b/zzz_generated/app-common/app-common/zap-generated/af-structs.h @@ -37,6 +37,8 @@ typedef struct _SimpleStruct chip::ByteSpan d; chip::CharSpan e; uint8_t f; + float g; + double h; } SimpleStruct; // Struct for NullablesAndOptionalsStruct diff --git a/zzz_generated/app-common/app-common/zap-generated/callback.h b/zzz_generated/app-common/app-common/zap-generated/callback.h index 8d834d55c4f8ca..97142ef5988a65 100644 --- a/zzz_generated/app-common/app-common/zap-generated/callback.h +++ b/zzz_generated/app-common/app-common/zap-generated/callback.h @@ -14920,6 +14920,12 @@ bool emberAfTestClusterClusterBooleanResponseCallback(chip::EndpointId endpoint, bool emberAfTestClusterClusterTestListStructArgumentRequestCallback( chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, const chip::app::Clusters::TestCluster::Commands::TestListStructArgumentRequest::DecodableType & commandData); +/** + * @brief Test Cluster Cluster SimpleStructResponse Command callback (from server) + */ +bool emberAfTestClusterClusterSimpleStructResponseCallback( + chip::EndpointId endpoint, chip::app::CommandSender * commandObj, + chip::app::Clusters::TestCluster::Structs::SimpleStruct::DecodableType arg1); /** * @brief Test Cluster Cluster TestListInt8UArgumentRequest Command callback (from client) */ @@ -14962,6 +14968,12 @@ bool emberAfTestClusterClusterTestNullableOptionalRequestCallback( bool emberAfTestClusterClusterTestComplexNullableOptionalRequestCallback( chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, const chip::app::Clusters::TestCluster::Commands::TestComplexNullableOptionalRequest::DecodableType & commandData); +/** + * @brief Test Cluster Cluster SimpleStructEchoRequest Command callback (from client) + */ +bool emberAfTestClusterClusterSimpleStructEchoRequestCallback( + chip::app::CommandHandler * commandObj, const chip::app::ConcreteCommandPath & commandPath, + const chip::app::Clusters::TestCluster::Commands::SimpleStructEchoRequest::DecodableType & commandData); /** * @brief Messaging Cluster DisplayMessage Command callback (from server) */ diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp index 468d9b5c0b6899..f2861f9367c9fc 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.cpp @@ -16434,6 +16434,8 @@ CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kD)), d)); ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kE)), e)); ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kF)), f)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kG)), g)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kH)), h)); ReturnErrorOnFailure(writer.EndContainer(outer)); return CHIP_NO_ERROR; } @@ -16468,6 +16470,12 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) case to_underlying(Fields::kF): ReturnErrorOnFailure(DataModel::Decode(reader, f)); break; + case to_underlying(Fields::kG): + ReturnErrorOnFailure(DataModel::Decode(reader, g)); + break; + case to_underlying(Fields::kH): + ReturnErrorOnFailure(DataModel::Decode(reader, h)); + break; default: break; } @@ -17568,6 +17576,40 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) return CHIP_NO_ERROR; } } // namespace TestListStructArgumentRequest. +namespace SimpleStructResponse { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArg1)), arg1)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVType outer; + VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE); + ReturnErrorOnFailure(reader.EnterContainer(outer)); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG); + switch (TLV::TagNumFromTag(reader.GetTag())) + { + case to_underlying(Fields::kArg1): + ReturnErrorOnFailure(DataModel::Decode(reader, arg1)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace SimpleStructResponse. namespace TestListInt8UArgumentRequest { CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const { @@ -17858,6 +17900,40 @@ CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) return CHIP_NO_ERROR; } } // namespace TestComplexNullableOptionalRequest. +namespace SimpleStructEchoRequest { +CHIP_ERROR Type::Encode(TLV::TLVWriter & writer, TLV::Tag tag) const +{ + TLV::TLVType outer; + ReturnErrorOnFailure(writer.StartContainer(tag, TLV::kTLVType_Structure, outer)); + ReturnErrorOnFailure(DataModel::Encode(writer, TLV::ContextTag(to_underlying(Fields::kArg1)), arg1)); + ReturnErrorOnFailure(writer.EndContainer(outer)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR DecodableType::Decode(TLV::TLVReader & reader) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVType outer; + VerifyOrReturnError(TLV::kTLVType_Structure == reader.GetType(), CHIP_ERROR_WRONG_TLV_TYPE); + ReturnErrorOnFailure(reader.EnterContainer(outer)); + while ((err = reader.Next()) == CHIP_NO_ERROR) + { + VerifyOrReturnError(TLV::IsContextTag(reader.GetTag()), CHIP_ERROR_INVALID_TLV_TAG); + switch (TLV::TagNumFromTag(reader.GetTag())) + { + case to_underlying(Fields::kArg1): + ReturnErrorOnFailure(DataModel::Decode(reader, arg1)); + break; + default: + break; + } + } + + VerifyOrReturnError(err == CHIP_END_OF_TLV, err); + ReturnErrorOnFailure(reader.ExitContainer(outer)); + return CHIP_NO_ERROR; +} +} // namespace SimpleStructEchoRequest. } // namespace Commands namespace Events { diff --git a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h index 8bc9014e7dbccd..ad63fd0356e2e1 100644 --- a/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h +++ b/zzz_generated/app-common/app-common/zap-generated/cluster-objects.h @@ -27461,6 +27461,8 @@ enum class Fields kD = 3, kE = 4, kF = 5, + kG = 6, + kH = 7, }; struct Type @@ -27472,6 +27474,8 @@ struct Type chip::ByteSpan d; chip::CharSpan e; chip::BitFlags f; + float g; + double h; CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; CHIP_ERROR Decode(TLV::TLVReader & reader); @@ -27739,6 +27743,11 @@ struct Type; struct DecodableType; } // namespace TestListStructArgumentRequest +namespace SimpleStructResponse { +struct Type; +struct DecodableType; +} // namespace SimpleStructResponse + namespace TestListInt8UArgumentRequest { struct Type; struct DecodableType; @@ -27774,6 +27783,11 @@ struct Type; struct DecodableType; } // namespace TestComplexNullableOptionalRequest +namespace SimpleStructEchoRequest { +struct Type; +struct DecodableType; +} // namespace SimpleStructEchoRequest + } // namespace Commands namespace Commands { @@ -28457,6 +28471,36 @@ struct DecodableType CHIP_ERROR Decode(TLV::TLVReader & reader); }; }; // namespace TestListStructArgumentRequest +namespace SimpleStructResponse { +enum class Fields +{ + kArg1 = 0, +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::SimpleStructResponse::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + + Structs::SimpleStruct::Type arg1; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; + + using ResponseType = DataModel::NullObjectType; +}; + +struct DecodableType +{ +public: + static constexpr CommandId GetCommandId() { return Commands::SimpleStructResponse::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + + Structs::SimpleStruct::DecodableType arg1; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace SimpleStructResponse namespace TestListInt8UArgumentRequest { enum class Fields { @@ -28703,6 +28747,36 @@ struct DecodableType CHIP_ERROR Decode(TLV::TLVReader & reader); }; }; // namespace TestComplexNullableOptionalRequest +namespace SimpleStructEchoRequest { +enum class Fields +{ + kArg1 = 0, +}; + +struct Type +{ +public: + // Use GetCommandId instead of commandId directly to avoid naming conflict with CommandIdentification in ExecutionOfACommand + static constexpr CommandId GetCommandId() { return Commands::SimpleStructEchoRequest::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + + Structs::SimpleStruct::Type arg1; + + CHIP_ERROR Encode(TLV::TLVWriter & writer, TLV::Tag tag) const; + + using ResponseType = Clusters::TestCluster::Commands::SimpleStructResponse::DecodableType; +}; + +struct DecodableType +{ +public: + static constexpr CommandId GetCommandId() { return Commands::SimpleStructEchoRequest::Id; } + static constexpr ClusterId GetClusterId() { return Clusters::TestCluster::Id; } + + Structs::SimpleStruct::DecodableType arg1; + CHIP_ERROR Decode(TLV::TLVReader & reader); +}; +}; // namespace SimpleStructEchoRequest } // namespace Commands namespace Attributes { diff --git a/zzz_generated/app-common/app-common/zap-generated/command-id.h b/zzz_generated/app-common/app-common/zap-generated/command-id.h index c1967eb7d95af4..44c07c5da7569d 100644 --- a/zzz_generated/app-common/app-common/zap-generated/command-id.h +++ b/zzz_generated/app-common/app-common/zap-generated/command-id.h @@ -465,6 +465,7 @@ #define ZCL_TEST_NESTED_STRUCT_ARGUMENT_REQUEST_COMMAND_ID (0x08) #define ZCL_BOOLEAN_RESPONSE_COMMAND_ID (0x08) #define ZCL_TEST_LIST_STRUCT_ARGUMENT_REQUEST_COMMAND_ID (0x09) +#define ZCL_SIMPLE_STRUCT_RESPONSE_COMMAND_ID (0x09) #define ZCL_TEST_LIST_INT8_U_ARGUMENT_REQUEST_COMMAND_ID (0x0A) #define ZCL_TEST_NESTED_STRUCT_LIST_ARGUMENT_REQUEST_COMMAND_ID (0x0B) #define ZCL_TEST_LIST_NESTED_STRUCT_LIST_ARGUMENT_REQUEST_COMMAND_ID (0x0C) @@ -472,6 +473,7 @@ #define ZCL_TEST_ENUMS_REQUEST_COMMAND_ID (0x0E) #define ZCL_TEST_NULLABLE_OPTIONAL_REQUEST_COMMAND_ID (0x0F) #define ZCL_TEST_COMPLEX_NULLABLE_OPTIONAL_REQUEST_COMMAND_ID (0x10) +#define ZCL_SIMPLE_STRUCT_ECHO_REQUEST_COMMAND_ID (0x11) // Commands for cluster: Messaging #define ZCL_DISPLAY_MESSAGE_COMMAND_ID (0x00) diff --git a/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h b/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h index 51911eeac8d201..b2727639724342 100644 --- a/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h +++ b/zzz_generated/app-common/app-common/zap-generated/ids/Commands.h @@ -1672,6 +1672,10 @@ namespace TestListStructArgumentRequest { static constexpr CommandId Id = 0x00000009; } // namespace TestListStructArgumentRequest +namespace SimpleStructResponse { +static constexpr CommandId Id = 0x00000009; +} // namespace SimpleStructResponse + namespace TestListInt8UArgumentRequest { static constexpr CommandId Id = 0x0000000A; } // namespace TestListInt8UArgumentRequest @@ -1700,6 +1704,10 @@ namespace TestComplexNullableOptionalRequest { static constexpr CommandId Id = 0x00000010; } // namespace TestComplexNullableOptionalRequest +namespace SimpleStructEchoRequest { +static constexpr CommandId Id = 0x00000011; +} // namespace SimpleStructEchoRequest + } // namespace Commands } // namespace TestCluster diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h index 3915cf2a4a8d0c..69792c72bca3e2 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h @@ -148,6 +148,16 @@ CHIP_ERROR LogValue(const char * label, size_t indent, X value) return CHIP_NO_ERROR; } +template < + typename X, + typename std::enable_if_t< + std::is_floating_point::value && !std::is_same>, bool>::value, int> = 0> +CHIP_ERROR LogValue(const char * label, size_t indent, X value) +{ + ChipLogProgress(chipTool, "%s%s: %s", IndentStr(indent).c_str(), label, std::to_string(value).c_str()); + return CHIP_NO_ERROR; +} + CHIP_ERROR LogValue(const char * label, size_t indent, bool value) { ChipLogProgress(chipTool, "%s%s: %s", IndentStr(indent).c_str(), label, value ? "TRUE" : "FALSE"); @@ -1701,6 +1711,22 @@ CHIP_ERROR LogValue(const char * label, size_t indent, return err; } } + { + CHIP_ERROR err = LogValue("G", indent + 1, value.g); + if (err != CHIP_NO_ERROR) + { + ChipLogProgress(chipTool, "%sStruct truncated due to invalid value for 'G'", IndentStr(indent + 1).c_str()); + return err; + } + } + { + CHIP_ERROR err = LogValue("H", indent + 1, value.h); + if (err != CHIP_NO_ERROR) + { + ChipLogProgress(chipTool, "%sStruct truncated due to invalid value for 'H'", IndentStr(indent + 1).c_str()); + return err; + } + } ChipLogProgress(chipTool, "%s}", IndentStr(indent).c_str()); return CHIP_NO_ERROR; } @@ -3905,6 +3931,20 @@ OnTestClusterBooleanResponseSuccess(void * context, command->SetCommandExitStatus(err); }; +static void OnTestClusterSimpleStructResponseSuccess( + void * context, const chip::app::Clusters::TestCluster::Commands::SimpleStructResponse::DecodableType & data) +{ + ChipLogProgress(Zcl, "Received SimpleStructResponse:"); + CHIP_ERROR err = CHIP_NO_ERROR; + if (err == CHIP_NO_ERROR) + { + err = LogValue("arg1", 1, data.arg1); + } + + ModelCommand * command = static_cast(context); + command->SetCommandExitStatus(err); +}; + static void OnTestClusterTestAddArgumentsResponseSuccess( void * context, const chip::app::Clusters::TestCluster::Commands::TestAddArgumentsResponse::DecodableType & data) { @@ -36259,6 +36299,7 @@ class ReportTemperatureMeasurementClusterRevision : public ModelCommand | Cluster TestCluster | 0x050F | |------------------------------------------------------------------------------| | Commands: | | +| * SimpleStructEchoRequest | 0x11 | | * Test | 0x00 | | * TestAddArguments | 0x04 | | * TestEnumsRequest | 0x0E | @@ -36319,6 +36360,30 @@ class ReportTemperatureMeasurementClusterRevision : public ModelCommand | * ClusterRevision | 0xFFFD | \*----------------------------------------------------------------------------*/ +/* + * Command SimpleStructEchoRequest + */ +class TestClusterSimpleStructEchoRequest : public ModelCommand +{ +public: + TestClusterSimpleStructEchoRequest() : ModelCommand("simple-struct-echo-request") + { + // arg1 Struct parsing is not supported yet + ModelCommand::AddArguments(); + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x0000050F) command (0x00000011) on endpoint %" PRIu8, endpointId); + + return chip::Controller::InvokeCommand(device, this, OnTestClusterSimpleStructResponseSuccess, OnDefaultFailure, endpointId, + mRequest); + } + +private: + chip::app::Clusters::TestCluster::Commands::SimpleStructEchoRequest::Type mRequest; +}; + /* * Command Test */ @@ -54151,6 +54216,7 @@ void registerClusterTestCluster(Commands & commands) const char * clusterName = "TestCluster"; commands_list clusterCommands = { + make_unique(), // make_unique(), // make_unique(), // make_unique(), // diff --git a/zzz_generated/chip-tool/zap-generated/test/Commands.h b/zzz_generated/chip-tool/zap-generated/test/Commands.h index cc7cde12d321db..862103d70d16f1 100644 --- a/zzz_generated/chip-tool/zap-generated/test/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/test/Commands.h @@ -123,7 +123,7 @@ class Test_TC_BI_1_1 : public TestCommand void OnSuccessResponse_0(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 1U)); + VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 1U)); NextTest(); } @@ -158,7 +158,7 @@ class Test_TC_BI_1_1 : public TestCommand void OnSuccessResponse_2(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 1U)); + VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 1U)); NextTest(); } }; @@ -372,7 +372,7 @@ class Test_TC_BI_2_1 : public TestCommand void OnSuccessResponse_0(bool outOfService) { - VerifyOrReturn(CheckValue("outOfService", outOfService, 0)); + VerifyOrReturn(CheckValue("outOfService", outOfService, 0)); NextTest(); } @@ -425,7 +425,7 @@ class Test_TC_BI_2_1 : public TestCommand void OnSuccessResponse_3(bool outOfService) { - VerifyOrReturn(CheckValue("outOfService", outOfService, 0)); + VerifyOrReturn(CheckValue("outOfService", outOfService, 0)); NextTest(); } @@ -478,7 +478,7 @@ class Test_TC_BI_2_1 : public TestCommand void OnSuccessResponse_6(bool presentValue) { - VerifyOrReturn(CheckValue("presentValue", presentValue, 0)); + VerifyOrReturn(CheckValue("presentValue", presentValue, 0)); NextTest(); } @@ -496,7 +496,7 @@ class Test_TC_BI_2_1 : public TestCommand void OnSuccessResponse_7(uint8_t statusFlags) { - VerifyOrReturn(CheckValue("statusFlags", statusFlags, 0)); + VerifyOrReturn(CheckValue("statusFlags", statusFlags, 0)); NextTest(); } @@ -550,7 +550,7 @@ class Test_TC_BI_2_1 : public TestCommand void OnSuccessResponse_10(uint8_t statusFlags) { - VerifyOrReturn(CheckValue("statusFlags", statusFlags, 0)); + VerifyOrReturn(CheckValue("statusFlags", statusFlags, 0)); NextTest(); } }; @@ -728,7 +728,7 @@ class Test_TC_BI_2_2 : public TestCommand void OnSuccessResponse_0(bool presentValue) { - VerifyOrReturn(CheckValue("presentValue", presentValue, 0)); + VerifyOrReturn(CheckValue("presentValue", presentValue, 0)); NextTest(); } @@ -746,7 +746,7 @@ class Test_TC_BI_2_2 : public TestCommand void OnSuccessResponse_1(bool outOfService) { - VerifyOrReturn(CheckValue("outOfService", outOfService, 0)); + VerifyOrReturn(CheckValue("outOfService", outOfService, 0)); NextTest(); } @@ -764,7 +764,7 @@ class Test_TC_BI_2_2 : public TestCommand void OnSuccessResponse_2(uint8_t statusFlags) { - VerifyOrReturn(CheckValue("statusFlags", statusFlags, 0)); + VerifyOrReturn(CheckValue("statusFlags", statusFlags, 0)); NextTest(); } @@ -782,7 +782,7 @@ class Test_TC_BI_2_2 : public TestCommand void OnSuccessResponse_3(bool presentValue) { - VerifyOrReturn(CheckValue("presentValue", presentValue, 0)); + VerifyOrReturn(CheckValue("presentValue", presentValue, 0)); NextTest(); } @@ -800,7 +800,7 @@ class Test_TC_BI_2_2 : public TestCommand void OnSuccessResponse_4(bool outOfService) { - VerifyOrReturn(CheckValue("outOfService", outOfService, 0)); + VerifyOrReturn(CheckValue("outOfService", outOfService, 0)); NextTest(); } @@ -818,7 +818,7 @@ class Test_TC_BI_2_2 : public TestCommand void OnSuccessResponse_5(uint8_t statusFlags) { - VerifyOrReturn(CheckValue("statusFlags", statusFlags, 0)); + VerifyOrReturn(CheckValue("statusFlags", statusFlags, 0)); NextTest(); } @@ -836,7 +836,7 @@ class Test_TC_BI_2_2 : public TestCommand void OnSuccessResponse_6(uint8_t statusFlags) { - VerifyOrReturn(CheckValue("statusFlags", statusFlags, 0)); + VerifyOrReturn(CheckValue("statusFlags", statusFlags, 0)); NextTest(); } @@ -854,7 +854,7 @@ class Test_TC_BI_2_2 : public TestCommand void OnSuccessResponse_7(uint8_t statusFlags) { - VerifyOrReturn(CheckValue("statusFlags", statusFlags, 0)); + VerifyOrReturn(CheckValue("statusFlags", statusFlags, 0)); NextTest(); } }; @@ -960,7 +960,7 @@ class Test_TC_BOOL_1_1 : public TestCommand void OnSuccessResponse_0(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 1U)); + VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 1U)); NextTest(); } @@ -995,7 +995,7 @@ class Test_TC_BOOL_1_1 : public TestCommand void OnSuccessResponse_2(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 1U)); + VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 1U)); NextTest(); } }; @@ -1115,7 +1115,7 @@ class Test_TC_BOOL_2_1 : public TestCommand void OnSuccessResponse_0(bool stateValue) { - VerifyOrReturn(CheckValue("stateValue", stateValue, 0)); + VerifyOrReturn(CheckValue("stateValue", stateValue, 0)); NextTest(); } @@ -1168,7 +1168,7 @@ class Test_TC_BOOL_2_1 : public TestCommand void OnSuccessResponse_3(bool stateValue) { - VerifyOrReturn(CheckValue("stateValue", stateValue, 0)); + VerifyOrReturn(CheckValue("stateValue", stateValue, 0)); NextTest(); } }; @@ -3233,7 +3233,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_0(uint8_t currentHue) { - VerifyOrReturn(CheckValue("currentHue", currentHue, 0)); + VerifyOrReturn(CheckValue("currentHue", currentHue, 0)); NextTest(); } @@ -3287,7 +3287,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_3(uint8_t currentHue) { - VerifyOrReturn(CheckValue("currentHue", currentHue, 0)); + VerifyOrReturn(CheckValue("currentHue", currentHue, 0)); NextTest(); } @@ -3305,7 +3305,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_4(uint8_t currentSaturation) { - VerifyOrReturn(CheckValue("currentSaturation", currentSaturation, 0)); + VerifyOrReturn(CheckValue("currentSaturation", currentSaturation, 0)); NextTest(); } @@ -3359,7 +3359,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_7(uint8_t currentSaturation) { - VerifyOrReturn(CheckValue("currentSaturation", currentSaturation, 0)); + VerifyOrReturn(CheckValue("currentSaturation", currentSaturation, 0)); NextTest(); } @@ -3377,7 +3377,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_8(uint16_t currentX) { - VerifyOrReturn(CheckValue("currentX", currentX, 24939U)); + VerifyOrReturn(CheckValue("currentX", currentX, 24939U)); NextTest(); } @@ -3431,7 +3431,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_11(uint16_t currentX) { - VerifyOrReturn(CheckValue("currentX", currentX, 24939U)); + VerifyOrReturn(CheckValue("currentX", currentX, 24939U)); NextTest(); } @@ -3449,7 +3449,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_12(uint16_t currentY) { - VerifyOrReturn(CheckValue("currentY", currentY, 24701U)); + VerifyOrReturn(CheckValue("currentY", currentY, 24701U)); NextTest(); } @@ -3503,7 +3503,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_15(uint16_t currentY) { - VerifyOrReturn(CheckValue("currentY", currentY, 24701U)); + VerifyOrReturn(CheckValue("currentY", currentY, 24701U)); NextTest(); } @@ -3559,7 +3559,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_18(uint8_t colorControlOptions) { - VerifyOrReturn(CheckValue("colorControlOptions", colorControlOptions, 0)); + VerifyOrReturn(CheckValue("colorControlOptions", colorControlOptions, 0)); NextTest(); } @@ -3612,7 +3612,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_21(uint8_t colorControlOptions) { - VerifyOrReturn(CheckValue("colorControlOptions", colorControlOptions, 0)); + VerifyOrReturn(CheckValue("colorControlOptions", colorControlOptions, 0)); NextTest(); } @@ -3630,7 +3630,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_22(uint16_t enhancedCurrentHue) { - VerifyOrReturn(CheckValue("enhancedCurrentHue", enhancedCurrentHue, 0U)); + VerifyOrReturn(CheckValue("enhancedCurrentHue", enhancedCurrentHue, 0U)); NextTest(); } @@ -3683,7 +3683,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_25(uint16_t enhancedCurrentHue) { - VerifyOrReturn(CheckValue("enhancedCurrentHue", enhancedCurrentHue, 0U)); + VerifyOrReturn(CheckValue("enhancedCurrentHue", enhancedCurrentHue, 0U)); NextTest(); } @@ -3719,7 +3719,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_27(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); NextTest(); } @@ -3772,7 +3772,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_30(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); NextTest(); } @@ -3790,7 +3790,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_31(uint8_t colorLoopDirection) { - VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 0)); + VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 0)); NextTest(); } @@ -3843,7 +3843,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_34(uint8_t colorLoopDirection) { - VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 0)); + VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 0)); NextTest(); } @@ -3861,7 +3861,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_35(uint16_t colorLoopTime) { - VerifyOrReturn(CheckValue("colorLoopTime", colorLoopTime, 25U)); + VerifyOrReturn(CheckValue("colorLoopTime", colorLoopTime, 25U)); NextTest(); } @@ -3914,7 +3914,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_38(uint16_t colorLoopTime) { - VerifyOrReturn(CheckValue("colorLoopTime", colorLoopTime, 25U)); + VerifyOrReturn(CheckValue("colorLoopTime", colorLoopTime, 25U)); NextTest(); } @@ -3932,7 +3932,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_39(uint16_t colorLoopStartEnhancedHue) { - VerifyOrReturn(CheckValue("colorLoopStartEnhancedHue", colorLoopStartEnhancedHue, 8960U)); + VerifyOrReturn(CheckValue("colorLoopStartEnhancedHue", colorLoopStartEnhancedHue, 8960U)); NextTest(); } @@ -3985,7 +3985,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_42(uint16_t colorLoopStartEnhancedHue) { - VerifyOrReturn(CheckValue("colorLoopStartEnhancedHue", colorLoopStartEnhancedHue, 8960U)); + VerifyOrReturn(CheckValue("colorLoopStartEnhancedHue", colorLoopStartEnhancedHue, 8960U)); NextTest(); } @@ -4003,7 +4003,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_43(uint16_t colorLoopStoredEnhancedHue) { - VerifyOrReturn(CheckValue("colorLoopStoredEnhancedHue", colorLoopStoredEnhancedHue, 0U)); + VerifyOrReturn(CheckValue("colorLoopStoredEnhancedHue", colorLoopStoredEnhancedHue, 0U)); NextTest(); } @@ -4056,7 +4056,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_46(uint16_t colorLoopStoredEnhancedHue) { - VerifyOrReturn(CheckValue("colorLoopStoredEnhancedHue", colorLoopStoredEnhancedHue, 0U)); + VerifyOrReturn(CheckValue("colorLoopStoredEnhancedHue", colorLoopStoredEnhancedHue, 0U)); NextTest(); } @@ -4074,7 +4074,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_47(uint16_t colorCapabilities) { - VerifyOrReturn(CheckValue("colorCapabilities", colorCapabilities, 0U)); + VerifyOrReturn(CheckValue("colorCapabilities", colorCapabilities, 0U)); NextTest(); } @@ -4128,7 +4128,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_50(uint16_t colorCapabilities) { - VerifyOrReturn(CheckValue("colorCapabilities", colorCapabilities, 0U)); + VerifyOrReturn(CheckValue("colorCapabilities", colorCapabilities, 0U)); NextTest(); } @@ -4146,7 +4146,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_51(uint16_t colorTempPhysicalMin) { - VerifyOrReturn(CheckValue("colorTempPhysicalMin", colorTempPhysicalMin, 0U)); + VerifyOrReturn(CheckValue("colorTempPhysicalMin", colorTempPhysicalMin, 0U)); NextTest(); } @@ -4200,7 +4200,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_54(uint16_t colorTempPhysicalMin) { - VerifyOrReturn(CheckValue("colorTempPhysicalMin", colorTempPhysicalMin, 0U)); + VerifyOrReturn(CheckValue("colorTempPhysicalMin", colorTempPhysicalMin, 0U)); NextTest(); } @@ -4218,7 +4218,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_55(uint16_t colorTempPhysicalMax) { - VerifyOrReturn(CheckValue("colorTempPhysicalMax", colorTempPhysicalMax, 65279U)); + VerifyOrReturn(CheckValue("colorTempPhysicalMax", colorTempPhysicalMax, 65279U)); NextTest(); } @@ -4272,7 +4272,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_58(uint16_t colorTempPhysicalMax) { - VerifyOrReturn(CheckValue("colorTempPhysicalMax", colorTempPhysicalMax, 65279U)); + VerifyOrReturn(CheckValue("colorTempPhysicalMax", colorTempPhysicalMax, 65279U)); NextTest(); } @@ -4325,7 +4325,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_61(uint16_t coupleColorTempToLevelMinMireds) { - VerifyOrReturn(CheckValue("coupleColorTempToLevelMinMireds", coupleColorTempToLevelMinMireds, 0U)); + VerifyOrReturn(CheckValue("coupleColorTempToLevelMinMireds", coupleColorTempToLevelMinMireds, 0U)); NextTest(); } @@ -4379,7 +4379,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_64(uint16_t startUpColorTemperatureMireds) { - VerifyOrReturn(CheckValue("startUpColorTemperatureMireds", startUpColorTemperatureMireds, 0U)); + VerifyOrReturn(CheckValue("startUpColorTemperatureMireds", startUpColorTemperatureMireds, 0U)); NextTest(); } @@ -4397,7 +4397,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_65(uint16_t remainingTime) { - VerifyOrReturn(CheckValue("remainingTime", remainingTime, 0U)); + VerifyOrReturn(CheckValue("remainingTime", remainingTime, 0U)); NextTest(); } @@ -4451,7 +4451,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_68(uint16_t remainingTime) { - VerifyOrReturn(CheckValue("remainingTime", remainingTime, 0U)); + VerifyOrReturn(CheckValue("remainingTime", remainingTime, 0U)); NextTest(); } @@ -4505,7 +4505,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_71(uint8_t driftCompensation) { - VerifyOrReturn(CheckValue("driftCompensation", driftCompensation, 0)); + VerifyOrReturn(CheckValue("driftCompensation", driftCompensation, 0)); NextTest(); } @@ -4578,7 +4578,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_75(uint8_t numberOfPrimaries) { - VerifyOrReturn(CheckValue("numberOfPrimaries", numberOfPrimaries, 0)); + VerifyOrReturn(CheckValue("numberOfPrimaries", numberOfPrimaries, 0)); NextTest(); } @@ -4632,7 +4632,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_78(uint16_t primary1X) { - VerifyOrReturn(CheckValue("primary1X", primary1X, 0U)); + VerifyOrReturn(CheckValue("primary1X", primary1X, 0U)); NextTest(); } @@ -4686,7 +4686,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_81(uint16_t primary1Y) { - VerifyOrReturn(CheckValue("primary1Y", primary1Y, 0U)); + VerifyOrReturn(CheckValue("primary1Y", primary1Y, 0U)); NextTest(); } @@ -4758,7 +4758,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_85(uint16_t primary2X) { - VerifyOrReturn(CheckValue("primary2X", primary2X, 0U)); + VerifyOrReturn(CheckValue("primary2X", primary2X, 0U)); NextTest(); } @@ -4812,7 +4812,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_88(uint16_t primary2Y) { - VerifyOrReturn(CheckValue("primary2Y", primary2Y, 0U)); + VerifyOrReturn(CheckValue("primary2Y", primary2Y, 0U)); NextTest(); } @@ -4884,7 +4884,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_92(uint16_t primary3X) { - VerifyOrReturn(CheckValue("primary3X", primary3X, 0U)); + VerifyOrReturn(CheckValue("primary3X", primary3X, 0U)); NextTest(); } @@ -4938,7 +4938,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_95(uint16_t primary3Y) { - VerifyOrReturn(CheckValue("primary3Y", primary3Y, 0U)); + VerifyOrReturn(CheckValue("primary3Y", primary3Y, 0U)); NextTest(); } @@ -5010,7 +5010,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_99(uint16_t primary4X) { - VerifyOrReturn(CheckValue("primary4X", primary4X, 0U)); + VerifyOrReturn(CheckValue("primary4X", primary4X, 0U)); NextTest(); } @@ -5064,7 +5064,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_102(uint16_t primary4Y) { - VerifyOrReturn(CheckValue("primary4Y", primary4Y, 0U)); + VerifyOrReturn(CheckValue("primary4Y", primary4Y, 0U)); NextTest(); } @@ -5136,7 +5136,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_106(uint16_t primary5X) { - VerifyOrReturn(CheckValue("primary5X", primary5X, 0U)); + VerifyOrReturn(CheckValue("primary5X", primary5X, 0U)); NextTest(); } @@ -5190,7 +5190,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_109(uint16_t primary5Y) { - VerifyOrReturn(CheckValue("primary5Y", primary5Y, 0U)); + VerifyOrReturn(CheckValue("primary5Y", primary5Y, 0U)); NextTest(); } @@ -5262,7 +5262,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_113(uint16_t primary6X) { - VerifyOrReturn(CheckValue("primary6X", primary6X, 0U)); + VerifyOrReturn(CheckValue("primary6X", primary6X, 0U)); NextTest(); } @@ -5316,7 +5316,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_116(uint16_t primary6Y) { - VerifyOrReturn(CheckValue("primary6Y", primary6Y, 0U)); + VerifyOrReturn(CheckValue("primary6Y", primary6Y, 0U)); NextTest(); } @@ -5388,7 +5388,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_120(uint16_t whitePointX) { - VerifyOrReturn(CheckValue("whitePointX", whitePointX, 0U)); + VerifyOrReturn(CheckValue("whitePointX", whitePointX, 0U)); NextTest(); } @@ -5442,7 +5442,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_123(uint16_t whitePointY) { - VerifyOrReturn(CheckValue("whitePointY", whitePointY, 0U)); + VerifyOrReturn(CheckValue("whitePointY", whitePointY, 0U)); NextTest(); } @@ -5496,7 +5496,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_126(uint16_t colorPointRX) { - VerifyOrReturn(CheckValue("colorPointRX", colorPointRX, 0U)); + VerifyOrReturn(CheckValue("colorPointRX", colorPointRX, 0U)); NextTest(); } @@ -5550,7 +5550,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_129(uint16_t colorPointRY) { - VerifyOrReturn(CheckValue("colorPointRY", colorPointRY, 0U)); + VerifyOrReturn(CheckValue("colorPointRY", colorPointRY, 0U)); NextTest(); } @@ -5622,7 +5622,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_133(uint16_t colorPointGX) { - VerifyOrReturn(CheckValue("colorPointGX", colorPointGX, 0U)); + VerifyOrReturn(CheckValue("colorPointGX", colorPointGX, 0U)); NextTest(); } @@ -5676,7 +5676,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_136(uint16_t colorPointGY) { - VerifyOrReturn(CheckValue("colorPointGY", colorPointGY, 0U)); + VerifyOrReturn(CheckValue("colorPointGY", colorPointGY, 0U)); NextTest(); } @@ -5748,7 +5748,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_140(uint16_t colorPointBX) { - VerifyOrReturn(CheckValue("colorPointBX", colorPointBX, 0U)); + VerifyOrReturn(CheckValue("colorPointBX", colorPointBX, 0U)); NextTest(); } @@ -5802,7 +5802,7 @@ class Test_TC_CC_2_1 : public TestCommand void OnSuccessResponse_143(uint16_t colorPointBY) { - VerifyOrReturn(CheckValue("colorPointBY", colorPointBY, 0U)); + VerifyOrReturn(CheckValue("colorPointBY", colorPointBY, 0U)); NextTest(); } @@ -5961,7 +5961,7 @@ class Test_TC_CC_3_1 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -6114,7 +6114,7 @@ class Test_TC_CC_3_1 : public TestCommand void OnSuccessResponse_7(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -6255,7 +6255,7 @@ class Test_TC_CC_3_2 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -6404,7 +6404,7 @@ class Test_TC_CC_3_2 : public TestCommand void OnSuccessResponse_7(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -6537,7 +6537,7 @@ class Test_TC_CC_3_3 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -6634,7 +6634,7 @@ class Test_TC_CC_3_3 : public TestCommand void OnSuccessResponse_5(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -6763,7 +6763,7 @@ class Test_TC_CC_4_1 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -6831,7 +6831,7 @@ class Test_TC_CC_4_1 : public TestCommand void OnSuccessResponse_4(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -6964,7 +6964,7 @@ class Test_TC_CC_4_2 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -7059,7 +7059,7 @@ class Test_TC_CC_4_2 : public TestCommand void OnSuccessResponse_5(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -7192,7 +7192,7 @@ class Test_TC_CC_4_3 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -7289,7 +7289,7 @@ class Test_TC_CC_4_3 : public TestCommand void OnSuccessResponse_5(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -7418,7 +7418,7 @@ class Test_TC_CC_4_4 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -7487,7 +7487,7 @@ class Test_TC_CC_4_4 : public TestCommand void OnSuccessResponse_4(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -7616,7 +7616,7 @@ class Test_TC_CC_5_1 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -7685,7 +7685,7 @@ class Test_TC_CC_5_1 : public TestCommand void OnSuccessResponse_4(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -7818,7 +7818,7 @@ class Test_TC_CC_5_2 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -7911,7 +7911,7 @@ class Test_TC_CC_5_2 : public TestCommand void OnSuccessResponse_5(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -8040,7 +8040,7 @@ class Test_TC_CC_5_3 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -8109,7 +8109,7 @@ class Test_TC_CC_5_3 : public TestCommand void OnSuccessResponse_4(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -8238,7 +8238,7 @@ class Test_TC_CC_6_1 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -8306,7 +8306,7 @@ class Test_TC_CC_6_1 : public TestCommand void OnSuccessResponse_4(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -8443,7 +8443,7 @@ class Test_TC_CC_6_2 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -8571,7 +8571,7 @@ class Test_TC_CC_6_2 : public TestCommand void OnSuccessResponse_6(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -8704,7 +8704,7 @@ class Test_TC_CC_6_3 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -8805,7 +8805,7 @@ class Test_TC_CC_6_3 : public TestCommand void OnSuccessResponse_5(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -8949,7 +8949,7 @@ class Test_TC_CC_7_1 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -8995,7 +8995,7 @@ class Test_TC_CC_7_1 : public TestCommand void OnSuccessResponse_3(uint16_t remainingTime) { - VerifyOrReturn(CheckValue("remainingTime", remainingTime, 1U)); + VerifyOrReturn(CheckValue("remainingTime", remainingTime, 1U)); NextTest(); } @@ -9036,7 +9036,7 @@ class Test_TC_CC_7_1 : public TestCommand void OnSuccessResponse_5(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -9177,7 +9177,7 @@ class Test_TC_CC_7_2 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -9326,7 +9326,7 @@ class Test_TC_CC_7_2 : public TestCommand void OnSuccessResponse_7(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -9459,7 +9459,7 @@ class Test_TC_CC_7_3 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -9556,7 +9556,7 @@ class Test_TC_CC_7_3 : public TestCommand void OnSuccessResponse_5(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -9685,7 +9685,7 @@ class Test_TC_CC_7_4 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -9754,7 +9754,7 @@ class Test_TC_CC_7_4 : public TestCommand void OnSuccessResponse_4(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -10007,7 +10007,7 @@ class Test_TC_CC_8_1 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -10055,7 +10055,7 @@ class Test_TC_CC_8_1 : public TestCommand void OnSuccessResponse_3(uint8_t colorLoopDirection) { - VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 1)); + VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 1)); NextTest(); } @@ -10073,7 +10073,7 @@ class Test_TC_CC_8_1 : public TestCommand void OnSuccessResponse_4(uint16_t colorLoopTime) { - VerifyOrReturn(CheckValue("colorLoopTime", colorLoopTime, 100U)); + VerifyOrReturn(CheckValue("colorLoopTime", colorLoopTime, 100U)); NextTest(); } @@ -10091,7 +10091,7 @@ class Test_TC_CC_8_1 : public TestCommand void OnSuccessResponse_5(uint16_t colorLoopStartEnhancedHue) { - VerifyOrReturn(CheckValue("colorLoopStartEnhancedHue", colorLoopStartEnhancedHue, 500U)); + VerifyOrReturn(CheckValue("colorLoopStartEnhancedHue", colorLoopStartEnhancedHue, 500U)); NextTest(); } @@ -10109,7 +10109,7 @@ class Test_TC_CC_8_1 : public TestCommand void OnSuccessResponse_6(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); NextTest(); } @@ -10157,7 +10157,7 @@ class Test_TC_CC_8_1 : public TestCommand void OnSuccessResponse_8(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 1)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 1)); NextTest(); } @@ -10205,7 +10205,7 @@ class Test_TC_CC_8_1 : public TestCommand void OnSuccessResponse_10(uint8_t colorLoopDirection) { - VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 0)); + VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 0)); NextTest(); } @@ -10223,7 +10223,7 @@ class Test_TC_CC_8_1 : public TestCommand void OnSuccessResponse_11(uint16_t colorLoopTime) { - VerifyOrReturn(CheckValue("colorLoopTime", colorLoopTime, 3500U)); + VerifyOrReturn(CheckValue("colorLoopTime", colorLoopTime, 3500U)); NextTest(); } @@ -10271,7 +10271,7 @@ class Test_TC_CC_8_1 : public TestCommand void OnSuccessResponse_13(uint8_t colorLoopDirection) { - VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 1)); + VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 1)); NextTest(); } @@ -10312,7 +10312,7 @@ class Test_TC_CC_8_1 : public TestCommand void OnSuccessResponse_15(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -10715,7 +10715,7 @@ class Test_TC_CC_9_1 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -10763,7 +10763,7 @@ class Test_TC_CC_9_1 : public TestCommand void OnSuccessResponse_3(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); NextTest(); } @@ -10811,7 +10811,7 @@ class Test_TC_CC_9_1 : public TestCommand void OnSuccessResponse_5(uint8_t colorLoopDirection) { - VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 0)); + VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 0)); NextTest(); } @@ -10859,7 +10859,7 @@ class Test_TC_CC_9_1 : public TestCommand void OnSuccessResponse_7(uint16_t colorLoopTime) { - VerifyOrReturn(CheckValue("colorLoopTime", colorLoopTime, 30U)); + VerifyOrReturn(CheckValue("colorLoopTime", colorLoopTime, 30U)); NextTest(); } @@ -10907,7 +10907,7 @@ class Test_TC_CC_9_1 : public TestCommand void OnSuccessResponse_9(uint16_t colorLoopStartEnhancedHue) { - VerifyOrReturn(CheckValue("colorLoopStartEnhancedHue", colorLoopStartEnhancedHue, 160U)); + VerifyOrReturn(CheckValue("colorLoopStartEnhancedHue", colorLoopStartEnhancedHue, 160U)); NextTest(); } @@ -10955,7 +10955,7 @@ class Test_TC_CC_9_1 : public TestCommand void OnSuccessResponse_11(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 1)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 1)); NextTest(); } @@ -11003,7 +11003,7 @@ class Test_TC_CC_9_1 : public TestCommand void OnSuccessResponse_13(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); NextTest(); } @@ -11051,7 +11051,7 @@ class Test_TC_CC_9_1 : public TestCommand void OnSuccessResponse_15(uint8_t colorLoopDirection) { - VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 1)); + VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 1)); NextTest(); } @@ -11099,7 +11099,7 @@ class Test_TC_CC_9_1 : public TestCommand void OnSuccessResponse_17(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 1)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 1)); NextTest(); } @@ -11147,7 +11147,7 @@ class Test_TC_CC_9_1 : public TestCommand void OnSuccessResponse_19(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); NextTest(); } @@ -11195,7 +11195,7 @@ class Test_TC_CC_9_1 : public TestCommand void OnSuccessResponse_22(uint16_t enhancedCurrentHue) { - VerifyOrReturn(CheckValue("enhancedCurrentHue", enhancedCurrentHue, 40960U)); + VerifyOrReturn(CheckValue("enhancedCurrentHue", enhancedCurrentHue, 40960U)); NextTest(); } @@ -11243,7 +11243,7 @@ class Test_TC_CC_9_1 : public TestCommand void OnSuccessResponse_24(uint8_t colorLoopDirection) { - VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 0)); + VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 0)); NextTest(); } @@ -11291,7 +11291,7 @@ class Test_TC_CC_9_1 : public TestCommand void OnSuccessResponse_26(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 1)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 1)); NextTest(); } @@ -11339,7 +11339,7 @@ class Test_TC_CC_9_1 : public TestCommand void OnSuccessResponse_28(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); NextTest(); } @@ -11387,7 +11387,7 @@ class Test_TC_CC_9_1 : public TestCommand void OnSuccessResponse_30(uint8_t colorLoopDirection) { - VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 1)); + VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 1)); NextTest(); } @@ -11435,7 +11435,7 @@ class Test_TC_CC_9_1 : public TestCommand void OnSuccessResponse_32(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 1)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 1)); NextTest(); } @@ -11483,7 +11483,7 @@ class Test_TC_CC_9_1 : public TestCommand void OnSuccessResponse_34(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); NextTest(); } @@ -11731,7 +11731,7 @@ class Test_TC_CC_9_2 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -11779,7 +11779,7 @@ class Test_TC_CC_9_2 : public TestCommand void OnSuccessResponse_3(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); NextTest(); } @@ -11797,7 +11797,7 @@ class Test_TC_CC_9_2 : public TestCommand void OnSuccessResponse_4(uint8_t colorLoopDirection) { - VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 0)); + VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 0)); NextTest(); } @@ -11815,7 +11815,7 @@ class Test_TC_CC_9_2 : public TestCommand void OnSuccessResponse_5(uint16_t colorLoopTime) { - VerifyOrReturn(CheckValue("colorLoopTime", colorLoopTime, 30U)); + VerifyOrReturn(CheckValue("colorLoopTime", colorLoopTime, 30U)); NextTest(); } @@ -11833,7 +11833,7 @@ class Test_TC_CC_9_2 : public TestCommand void OnSuccessResponse_6(uint16_t colorLoopStartEnhancedHue) { - VerifyOrReturn(CheckValue("colorLoopStartEnhancedHue", colorLoopStartEnhancedHue, 160U)); + VerifyOrReturn(CheckValue("colorLoopStartEnhancedHue", colorLoopStartEnhancedHue, 160U)); NextTest(); } @@ -11881,7 +11881,7 @@ class Test_TC_CC_9_2 : public TestCommand void OnSuccessResponse_8(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 1)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 1)); NextTest(); } @@ -11929,7 +11929,7 @@ class Test_TC_CC_9_2 : public TestCommand void OnSuccessResponse_10(uint8_t colorLoopDirection) { - VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 1)); + VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 1)); NextTest(); } @@ -11977,7 +11977,7 @@ class Test_TC_CC_9_2 : public TestCommand void OnSuccessResponse_12(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); NextTest(); } @@ -12225,7 +12225,7 @@ class Test_TC_CC_9_3 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -12273,7 +12273,7 @@ class Test_TC_CC_9_3 : public TestCommand void OnSuccessResponse_3(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); NextTest(); } @@ -12291,7 +12291,7 @@ class Test_TC_CC_9_3 : public TestCommand void OnSuccessResponse_4(uint8_t colorLoopDirection) { - VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 0)); + VerifyOrReturn(CheckValue("colorLoopDirection", colorLoopDirection, 0)); NextTest(); } @@ -12309,7 +12309,7 @@ class Test_TC_CC_9_3 : public TestCommand void OnSuccessResponse_5(uint16_t colorLoopTime) { - VerifyOrReturn(CheckValue("colorLoopTime", colorLoopTime, 30U)); + VerifyOrReturn(CheckValue("colorLoopTime", colorLoopTime, 30U)); NextTest(); } @@ -12327,7 +12327,7 @@ class Test_TC_CC_9_3 : public TestCommand void OnSuccessResponse_6(uint16_t colorLoopStartEnhancedHue) { - VerifyOrReturn(CheckValue("colorLoopStartEnhancedHue", colorLoopStartEnhancedHue, 160U)); + VerifyOrReturn(CheckValue("colorLoopStartEnhancedHue", colorLoopStartEnhancedHue, 160U)); NextTest(); } @@ -12375,7 +12375,7 @@ class Test_TC_CC_9_3 : public TestCommand void OnSuccessResponse_8(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 1)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 1)); NextTest(); } @@ -12423,7 +12423,7 @@ class Test_TC_CC_9_3 : public TestCommand void OnSuccessResponse_10(uint16_t colorLoopTime) { - VerifyOrReturn(CheckValue("colorLoopTime", colorLoopTime, 60U)); + VerifyOrReturn(CheckValue("colorLoopTime", colorLoopTime, 60U)); NextTest(); } @@ -12471,7 +12471,7 @@ class Test_TC_CC_9_3 : public TestCommand void OnSuccessResponse_12(uint8_t colorLoopActive) { - VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); + VerifyOrReturn(CheckValue("colorLoopActive", colorLoopActive, 0)); NextTest(); } @@ -13388,7 +13388,7 @@ class Test_TC_DM_2_2 : public TestCommand void OnSuccessResponse_1(uint8_t supportedFabrics) { - VerifyOrReturn(CheckValue("supportedFabrics", supportedFabrics, 16)); + VerifyOrReturn(CheckValue("supportedFabrics", supportedFabrics, 16)); NextTest(); } @@ -13406,7 +13406,7 @@ class Test_TC_DM_2_2 : public TestCommand void OnSuccessResponse_2(uint8_t commissionedFabrics) { - VerifyOrReturn(CheckValue("commissionedFabrics", commissionedFabrics, 1)); + VerifyOrReturn(CheckValue("commissionedFabrics", commissionedFabrics, 1)); NextTest(); } @@ -13530,7 +13530,7 @@ class Test_TC_EMR_1_1 : public TestCommand void OnSuccessResponse_0(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 3U)); + VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 3U)); NextTest(); } @@ -13565,7 +13565,7 @@ class Test_TC_EMR_1_1 : public TestCommand void OnSuccessResponse_2(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 3U)); + VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 3U)); NextTest(); } }; @@ -14156,7 +14156,7 @@ class Test_TC_ILL_1_1 : public TestCommand void OnSuccessResponse_0(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 2U)); + VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 2U)); NextTest(); } @@ -14191,7 +14191,7 @@ class Test_TC_ILL_1_1 : public TestCommand void OnSuccessResponse_2(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 2U)); + VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 2U)); NextTest(); } }; @@ -14436,7 +14436,7 @@ class Test_TC_LVL_2_1 : public TestCommand void OnSuccessResponse_0(uint8_t currentLevel) { - VerifyOrReturn(CheckValue("currentLevel", currentLevel, 0)); + VerifyOrReturn(CheckValue("currentLevel", currentLevel, 0)); NextTest(); } @@ -14483,7 +14483,7 @@ class Test_TC_LVL_2_1 : public TestCommand void OnSuccessResponse_3(uint8_t currentLevel) { - VerifyOrReturn(CheckValue("currentLevel", currentLevel, 64)); + VerifyOrReturn(CheckValue("currentLevel", currentLevel, 64)); NextTest(); } @@ -14530,7 +14530,7 @@ class Test_TC_LVL_2_1 : public TestCommand void OnSuccessResponse_6(uint8_t currentLevel) { - VerifyOrReturn(CheckValue("currentLevel", currentLevel, 128)); + VerifyOrReturn(CheckValue("currentLevel", currentLevel, 128)); NextTest(); } @@ -14548,7 +14548,7 @@ class Test_TC_LVL_2_1 : public TestCommand void OnSuccessResponse_7(uint16_t onOffTransitionTime) { - VerifyOrReturn(CheckValue("onOffTransitionTime", onOffTransitionTime, 0U)); + VerifyOrReturn(CheckValue("onOffTransitionTime", onOffTransitionTime, 0U)); NextTest(); } @@ -14595,7 +14595,7 @@ class Test_TC_LVL_2_1 : public TestCommand void OnSuccessResponse_10(uint8_t currentLevel) { - VerifyOrReturn(CheckValue("currentLevel", currentLevel, 254)); + VerifyOrReturn(CheckValue("currentLevel", currentLevel, 254)); NextTest(); } @@ -14823,7 +14823,7 @@ class Test_TC_LVL_3_1 : public TestCommand void OnSuccessResponse_0(uint8_t currentLevel) { - VerifyOrReturn(CheckValue("currentLevel", currentLevel, 0)); + VerifyOrReturn(CheckValue("currentLevel", currentLevel, 0)); NextTest(); } @@ -14841,7 +14841,7 @@ class Test_TC_LVL_3_1 : public TestCommand void OnSuccessResponse_1(uint8_t maxLevel) { - VerifyOrReturn(CheckValue("maxLevel", maxLevel, 255)); + VerifyOrReturn(CheckValue("maxLevel", maxLevel, 255)); NextTest(); } @@ -14888,7 +14888,7 @@ class Test_TC_LVL_3_1 : public TestCommand void OnSuccessResponse_4(uint8_t currentLevel) { - VerifyOrReturn(CheckValue("currentLevel", currentLevel, 255)); + VerifyOrReturn(CheckValue("currentLevel", currentLevel, 255)); NextTest(); } @@ -14906,7 +14906,7 @@ class Test_TC_LVL_3_1 : public TestCommand void OnSuccessResponse_5(uint8_t minLevel) { - VerifyOrReturn(CheckValue("minLevel", minLevel, 0)); + VerifyOrReturn(CheckValue("minLevel", minLevel, 0)); NextTest(); } @@ -14953,7 +14953,7 @@ class Test_TC_LVL_3_1 : public TestCommand void OnSuccessResponse_8(uint8_t currentLevel) { - VerifyOrReturn(CheckValue("currentLevel", currentLevel, 0)); + VerifyOrReturn(CheckValue("currentLevel", currentLevel, 0)); NextTest(); } @@ -14988,7 +14988,7 @@ class Test_TC_LVL_3_1 : public TestCommand void OnSuccessResponse_10(uint8_t defaultMoveRate) { - VerifyOrReturn(CheckValue("defaultMoveRate", defaultMoveRate, 20)); + VerifyOrReturn(CheckValue("defaultMoveRate", defaultMoveRate, 20)); NextTest(); } @@ -15228,7 +15228,7 @@ class Test_TC_LVL_4_1 : public TestCommand void OnSuccessResponse_3(uint8_t currentLevel) { - VerifyOrReturn(CheckValue("currentLevel", currentLevel, 128)); + VerifyOrReturn(CheckValue("currentLevel", currentLevel, 128)); NextTest(); } @@ -15276,7 +15276,7 @@ class Test_TC_LVL_4_1 : public TestCommand void OnSuccessResponse_6(uint8_t currentLevel) { - VerifyOrReturn(CheckValue("currentLevel", currentLevel, 64)); + VerifyOrReturn(CheckValue("currentLevel", currentLevel, 64)); NextTest(); } @@ -15324,7 +15324,7 @@ class Test_TC_LVL_4_1 : public TestCommand void OnSuccessResponse_9(uint8_t currentLevel) { - VerifyOrReturn(CheckValue("currentLevel", currentLevel, 128)); + VerifyOrReturn(CheckValue("currentLevel", currentLevel, 128)); NextTest(); } @@ -16325,7 +16325,7 @@ class Test_TC_OCC_1_1 : public TestCommand void OnSuccessResponse_0(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 2U)); + VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 2U)); NextTest(); } @@ -16565,7 +16565,7 @@ class Test_TC_OCC_2_1 : public TestCommand void OnSuccessResponse_2(uint8_t occupancy) { - VerifyOrReturn(CheckValue("occupancy", occupancy, 0)); + VerifyOrReturn(CheckValue("occupancy", occupancy, 0)); NextTest(); } @@ -16619,7 +16619,7 @@ class Test_TC_OCC_2_1 : public TestCommand void OnSuccessResponse_5(uint8_t occupancySensorType) { - VerifyOrReturn(CheckValue("occupancySensorType", occupancySensorType, 0)); + VerifyOrReturn(CheckValue("occupancySensorType", occupancySensorType, 0)); NextTest(); } @@ -16674,7 +16674,7 @@ class Test_TC_OCC_2_1 : public TestCommand void OnSuccessResponse_8(uint8_t occupancySensorTypeBitmap) { - VerifyOrReturn(CheckValue("occupancySensorTypeBitmap", occupancySensorTypeBitmap, 1)); + VerifyOrReturn(CheckValue("occupancySensorTypeBitmap", occupancySensorTypeBitmap, 1)); NextTest(); } }; @@ -16931,7 +16931,7 @@ class Test_TC_OO_1_1 : public TestCommand void OnSuccessResponse_0(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 4U)); + VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 4U)); NextTest(); } @@ -16966,7 +16966,7 @@ class Test_TC_OO_1_1 : public TestCommand void OnSuccessResponse_2(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 4U)); + VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 4U)); NextTest(); } @@ -16984,7 +16984,7 @@ class Test_TC_OO_1_1 : public TestCommand void OnSuccessResponse_3(uint32_t featureMap) { - VerifyOrReturn(CheckValue("featureMap", featureMap, 0UL)); + VerifyOrReturn(CheckValue("featureMap", featureMap, 0UL)); NextTest(); } @@ -17019,7 +17019,7 @@ class Test_TC_OO_1_1 : public TestCommand void OnSuccessResponse_5(uint32_t featureMap) { - VerifyOrReturn(CheckValue("featureMap", featureMap, 0UL)); + VerifyOrReturn(CheckValue("featureMap", featureMap, 0UL)); NextTest(); } }; @@ -17244,7 +17244,7 @@ class Test_TC_OO_2_1 : public TestCommand void OnSuccessResponse_0(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } @@ -17262,7 +17262,7 @@ class Test_TC_OO_2_1 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } @@ -17280,7 +17280,7 @@ class Test_TC_OO_2_1 : public TestCommand void OnSuccessResponse_2(bool globalSceneControl) { - VerifyOrReturn(CheckValue("globalSceneControl", globalSceneControl, 1)); + VerifyOrReturn(CheckValue("globalSceneControl", globalSceneControl, 1)); NextTest(); } @@ -17298,7 +17298,7 @@ class Test_TC_OO_2_1 : public TestCommand void OnSuccessResponse_3(uint16_t onTime) { - VerifyOrReturn(CheckValue("onTime", onTime, 0U)); + VerifyOrReturn(CheckValue("onTime", onTime, 0U)); NextTest(); } @@ -17316,7 +17316,7 @@ class Test_TC_OO_2_1 : public TestCommand void OnSuccessResponse_4(uint16_t offWaitTime) { - VerifyOrReturn(CheckValue("offWaitTime", offWaitTime, 0U)); + VerifyOrReturn(CheckValue("offWaitTime", offWaitTime, 0U)); NextTest(); } @@ -17334,7 +17334,7 @@ class Test_TC_OO_2_1 : public TestCommand void OnSuccessResponse_5(uint8_t startUpOnOff) { - VerifyOrReturn(CheckValue("startUpOnOff", startUpOnOff, 0)); + VerifyOrReturn(CheckValue("startUpOnOff", startUpOnOff, 0)); NextTest(); } @@ -17403,7 +17403,7 @@ class Test_TC_OO_2_1 : public TestCommand void OnSuccessResponse_9(uint16_t onTime) { - VerifyOrReturn(CheckValue("onTime", onTime, 0U)); + VerifyOrReturn(CheckValue("onTime", onTime, 0U)); NextTest(); } @@ -17421,7 +17421,7 @@ class Test_TC_OO_2_1 : public TestCommand void OnSuccessResponse_10(uint16_t offWaitTime) { - VerifyOrReturn(CheckValue("offWaitTime", offWaitTime, 0U)); + VerifyOrReturn(CheckValue("offWaitTime", offWaitTime, 0U)); NextTest(); } @@ -17439,7 +17439,7 @@ class Test_TC_OO_2_1 : public TestCommand void OnSuccessResponse_11(uint8_t startUpOnOff) { - VerifyOrReturn(CheckValue("startUpOnOff", startUpOnOff, 0)); + VerifyOrReturn(CheckValue("startUpOnOff", startUpOnOff, 0)); NextTest(); } }; @@ -17654,7 +17654,7 @@ class Test_TC_OO_2_2 : public TestCommand void OnSuccessResponse_1(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } @@ -17695,7 +17695,7 @@ class Test_TC_OO_2_2 : public TestCommand void OnSuccessResponse_3(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -17736,7 +17736,7 @@ class Test_TC_OO_2_2 : public TestCommand void OnSuccessResponse_5(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } @@ -17777,7 +17777,7 @@ class Test_TC_OO_2_2 : public TestCommand void OnSuccessResponse_7(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -17818,7 +17818,7 @@ class Test_TC_OO_2_2 : public TestCommand void OnSuccessResponse_9(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } @@ -17859,7 +17859,7 @@ class Test_TC_OO_2_2 : public TestCommand void OnSuccessResponse_11(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -17900,7 +17900,7 @@ class Test_TC_OO_2_2 : public TestCommand void OnSuccessResponse_13(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } }; @@ -18505,7 +18505,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_2(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -18523,7 +18523,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_3(bool globalSceneControl) { - VerifyOrReturn(CheckValue("globalSceneControl", globalSceneControl, 1)); + VerifyOrReturn(CheckValue("globalSceneControl", globalSceneControl, 1)); NextTest(); } @@ -18566,7 +18566,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_6(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -18584,7 +18584,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_7(bool globalSceneControl) { - VerifyOrReturn(CheckValue("globalSceneControl", globalSceneControl, 1)); + VerifyOrReturn(CheckValue("globalSceneControl", globalSceneControl, 1)); NextTest(); } @@ -18627,7 +18627,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_10(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -18645,7 +18645,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_11(bool globalSceneControl) { - VerifyOrReturn(CheckValue("globalSceneControl", globalSceneControl, 1)); + VerifyOrReturn(CheckValue("globalSceneControl", globalSceneControl, 1)); NextTest(); } @@ -18663,7 +18663,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_12(uint16_t onTime) { - VerifyOrReturn(CheckValue("onTime", onTime, 0U)); + VerifyOrReturn(CheckValue("onTime", onTime, 0U)); NextTest(); } @@ -18681,7 +18681,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_13(uint16_t offWaitTime) { - VerifyOrReturn(CheckValue("offWaitTime", offWaitTime, 0U)); + VerifyOrReturn(CheckValue("offWaitTime", offWaitTime, 0U)); NextTest(); } @@ -18722,7 +18722,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_15(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -18740,7 +18740,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_16(uint16_t onTime) { - VerifyOrReturn(CheckValue("onTime", onTime, 0U)); + VerifyOrReturn(CheckValue("onTime", onTime, 0U)); NextTest(); } @@ -18758,7 +18758,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_17(uint16_t offWaitTime) { - VerifyOrReturn(CheckValue("offWaitTime", offWaitTime, 0U)); + VerifyOrReturn(CheckValue("offWaitTime", offWaitTime, 0U)); NextTest(); } @@ -18799,7 +18799,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_19(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } @@ -18817,7 +18817,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_20(uint16_t onTime) { - VerifyOrReturn(CheckValue("onTime", onTime, 0U)); + VerifyOrReturn(CheckValue("onTime", onTime, 0U)); NextTest(); } @@ -18835,7 +18835,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_21(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } @@ -18853,7 +18853,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_22(uint16_t onTime) { - VerifyOrReturn(CheckValue("onTime", onTime, 0U)); + VerifyOrReturn(CheckValue("onTime", onTime, 0U)); NextTest(); } @@ -18871,7 +18871,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_23(uint16_t offWaitTime) { - VerifyOrReturn(CheckValue("offWaitTime", offWaitTime, 0U)); + VerifyOrReturn(CheckValue("offWaitTime", offWaitTime, 0U)); NextTest(); } @@ -18912,7 +18912,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_25(uint16_t onTime) { - VerifyOrReturn(CheckValue("onTime", onTime, 0U)); + VerifyOrReturn(CheckValue("onTime", onTime, 0U)); NextTest(); } @@ -18930,7 +18930,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_26(uint16_t offWaitTime) { - VerifyOrReturn(CheckValue("offWaitTime", offWaitTime, 0U)); + VerifyOrReturn(CheckValue("offWaitTime", offWaitTime, 0U)); NextTest(); } @@ -18971,7 +18971,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_28(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } @@ -18989,7 +18989,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_29(uint16_t onTime) { - VerifyOrReturn(CheckValue("onTime", onTime, 0U)); + VerifyOrReturn(CheckValue("onTime", onTime, 0U)); NextTest(); } @@ -19007,7 +19007,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_30(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } @@ -19025,7 +19025,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_31(uint16_t onTime) { - VerifyOrReturn(CheckValue("onTime", onTime, 0U)); + VerifyOrReturn(CheckValue("onTime", onTime, 0U)); NextTest(); } @@ -19066,7 +19066,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_33(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 1)); + VerifyOrReturn(CheckValue("onOff", onOff, 1)); NextTest(); } @@ -19084,7 +19084,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_34(uint16_t onTime) { - VerifyOrReturn(CheckValue("onTime", onTime, 0U)); + VerifyOrReturn(CheckValue("onTime", onTime, 0U)); NextTest(); } @@ -19102,7 +19102,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_35(uint16_t offWaitTime) { - VerifyOrReturn(CheckValue("offWaitTime", offWaitTime, 0U)); + VerifyOrReturn(CheckValue("offWaitTime", offWaitTime, 0U)); NextTest(); } @@ -19143,7 +19143,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_37(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } @@ -19161,7 +19161,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_38(uint16_t onTime) { - VerifyOrReturn(CheckValue("onTime", onTime, 0U)); + VerifyOrReturn(CheckValue("onTime", onTime, 0U)); NextTest(); } @@ -19179,7 +19179,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_39(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } @@ -19197,7 +19197,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_40(uint16_t onTime) { - VerifyOrReturn(CheckValue("onTime", onTime, 0U)); + VerifyOrReturn(CheckValue("onTime", onTime, 0U)); NextTest(); } @@ -19215,7 +19215,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_41(uint16_t offWaitTime) { - VerifyOrReturn(CheckValue("offWaitTime", offWaitTime, 0U)); + VerifyOrReturn(CheckValue("offWaitTime", offWaitTime, 0U)); NextTest(); } @@ -19233,7 +19233,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_42(bool onOff) { - VerifyOrReturn(CheckValue("onOff", onOff, 0)); + VerifyOrReturn(CheckValue("onOff", onOff, 0)); NextTest(); } @@ -19251,7 +19251,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_43(uint16_t onTime) { - VerifyOrReturn(CheckValue("onTime", onTime, 0U)); + VerifyOrReturn(CheckValue("onTime", onTime, 0U)); NextTest(); } @@ -19269,7 +19269,7 @@ class Test_TC_OO_2_3 : public TestCommand void OnSuccessResponse_44(uint16_t offWaitTime) { - VerifyOrReturn(CheckValue("offWaitTime", offWaitTime, 0U)); + VerifyOrReturn(CheckValue("offWaitTime", offWaitTime, 0U)); NextTest(); } @@ -19412,7 +19412,7 @@ class Test_TC_PRS_1_1 : public TestCommand void OnSuccessResponse_0(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 2U)); + VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 2U)); NextTest(); } @@ -19465,7 +19465,7 @@ class Test_TC_PRS_1_1 : public TestCommand void OnSuccessResponse_3(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 2U)); + VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 2U)); NextTest(); } }; @@ -19683,7 +19683,7 @@ class Test_TC_PRS_2_1 : public TestCommand void OnSuccessResponse_2(int16_t measuredValue) { - VerifyOrReturn(CheckValue("measuredValue", measuredValue, 0)); + VerifyOrReturn(CheckValue("measuredValue", measuredValue, 0)); NextTest(); } @@ -19736,7 +19736,7 @@ class Test_TC_PRS_2_1 : public TestCommand void OnSuccessResponse_5(int16_t minMeasuredValue) { - VerifyOrReturn(CheckValue("minMeasuredValue", minMeasuredValue, 0)); + VerifyOrReturn(CheckValue("minMeasuredValue", minMeasuredValue, 0)); NextTest(); } @@ -19789,7 +19789,7 @@ class Test_TC_PRS_2_1 : public TestCommand void OnSuccessResponse_8(int16_t maxMeasuredValue) { - VerifyOrReturn(CheckValue("maxMeasuredValue", maxMeasuredValue, 0)); + VerifyOrReturn(CheckValue("maxMeasuredValue", maxMeasuredValue, 0)); NextTest(); } }; @@ -20413,7 +20413,7 @@ class Test_TC_PCC_2_3 : public TestCommand void OnSuccessResponse_1(uint8_t effectiveOperationMode) { - VerifyOrReturn(CheckValue("effectiveOperationMode", effectiveOperationMode, 0)); + VerifyOrReturn(CheckValue("effectiveOperationMode", effectiveOperationMode, 0)); NextTest(); } }; @@ -20821,7 +20821,7 @@ class Test_TC_TM_1_1 : public TestCommand void OnSuccessResponse_0(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 3U)); + VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 3U)); NextTest(); } @@ -20856,7 +20856,7 @@ class Test_TC_TM_1_1 : public TestCommand void OnSuccessResponse_2(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 3U)); + VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 3U)); NextTest(); } }; @@ -22047,7 +22047,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_1(int16_t absMinHeatSetpointLimit) { - VerifyOrReturn(CheckValue("absMinHeatSetpointLimit", absMinHeatSetpointLimit, 700)); + VerifyOrReturn(CheckValue("absMinHeatSetpointLimit", absMinHeatSetpointLimit, 700)); NextTest(); } @@ -22102,7 +22102,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_4(int16_t absMinHeatSetpointLimit) { - VerifyOrReturn(CheckValue("absMinHeatSetpointLimit", absMinHeatSetpointLimit, 700)); + VerifyOrReturn(CheckValue("absMinHeatSetpointLimit", absMinHeatSetpointLimit, 700)); NextTest(); } @@ -22120,7 +22120,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_5(int16_t absMaxHeatSetpointLimit) { - VerifyOrReturn(CheckValue("absMaxHeatSetpointLimit", absMaxHeatSetpointLimit, 3000)); + VerifyOrReturn(CheckValue("absMaxHeatSetpointLimit", absMaxHeatSetpointLimit, 3000)); NextTest(); } @@ -22175,7 +22175,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_8(int16_t absMaxHeatSetpointLimit) { - VerifyOrReturn(CheckValue("absMaxHeatSetpointLimit", absMaxHeatSetpointLimit, 3000)); + VerifyOrReturn(CheckValue("absMaxHeatSetpointLimit", absMaxHeatSetpointLimit, 3000)); NextTest(); } @@ -22193,7 +22193,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_9(int16_t absMinCoolSetpointLimit) { - VerifyOrReturn(CheckValue("absMinCoolSetpointLimit", absMinCoolSetpointLimit, 1600)); + VerifyOrReturn(CheckValue("absMinCoolSetpointLimit", absMinCoolSetpointLimit, 1600)); NextTest(); } @@ -22248,7 +22248,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_12(int16_t absMinCoolSetpointLimit) { - VerifyOrReturn(CheckValue("absMinCoolSetpointLimit", absMinCoolSetpointLimit, 1600)); + VerifyOrReturn(CheckValue("absMinCoolSetpointLimit", absMinCoolSetpointLimit, 1600)); NextTest(); } @@ -22266,7 +22266,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_13(int16_t absMaxCoolSetpointLimit) { - VerifyOrReturn(CheckValue("absMaxCoolSetpointLimit", absMaxCoolSetpointLimit, 3200)); + VerifyOrReturn(CheckValue("absMaxCoolSetpointLimit", absMaxCoolSetpointLimit, 3200)); NextTest(); } @@ -22321,7 +22321,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_16(int16_t absMaxCoolSetpointLimit) { - VerifyOrReturn(CheckValue("absMaxCoolSetpointLimit", absMaxCoolSetpointLimit, 3200)); + VerifyOrReturn(CheckValue("absMaxCoolSetpointLimit", absMaxCoolSetpointLimit, 3200)); NextTest(); } @@ -22339,7 +22339,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_17(int16_t occupiedCoolingSetpoint) { - VerifyOrReturn(CheckValue("occupiedCoolingSetpoint", occupiedCoolingSetpoint, 2600)); + VerifyOrReturn(CheckValue("occupiedCoolingSetpoint", occupiedCoolingSetpoint, 2600)); NextTest(); } @@ -22394,7 +22394,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_20(int16_t occupiedCoolingSetpoint) { - VerifyOrReturn(CheckValue("occupiedCoolingSetpoint", occupiedCoolingSetpoint, 2600)); + VerifyOrReturn(CheckValue("occupiedCoolingSetpoint", occupiedCoolingSetpoint, 2600)); NextTest(); } @@ -22412,7 +22412,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_21(int16_t occupiedHeatingSetpoint) { - VerifyOrReturn(CheckValue("occupiedHeatingSetpoint", occupiedHeatingSetpoint, 2000)); + VerifyOrReturn(CheckValue("occupiedHeatingSetpoint", occupiedHeatingSetpoint, 2000)); NextTest(); } @@ -22467,7 +22467,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_24(int16_t occupiedHeatingSetpoint) { - VerifyOrReturn(CheckValue("occupiedHeatingSetpoint", occupiedHeatingSetpoint, 2000)); + VerifyOrReturn(CheckValue("occupiedHeatingSetpoint", occupiedHeatingSetpoint, 2000)); NextTest(); } @@ -22485,7 +22485,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_25(int16_t minHeatSetpointLimit) { - VerifyOrReturn(CheckValue("minHeatSetpointLimit", minHeatSetpointLimit, 700)); + VerifyOrReturn(CheckValue("minHeatSetpointLimit", minHeatSetpointLimit, 700)); NextTest(); } @@ -22540,7 +22540,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_28(int16_t minHeatSetpointLimit) { - VerifyOrReturn(CheckValue("minHeatSetpointLimit", minHeatSetpointLimit, 700)); + VerifyOrReturn(CheckValue("minHeatSetpointLimit", minHeatSetpointLimit, 700)); NextTest(); } @@ -22558,7 +22558,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_29(int16_t maxHeatSetpointLimit) { - VerifyOrReturn(CheckValue("maxHeatSetpointLimit", maxHeatSetpointLimit, 3000)); + VerifyOrReturn(CheckValue("maxHeatSetpointLimit", maxHeatSetpointLimit, 3000)); NextTest(); } @@ -22613,7 +22613,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_32(int16_t maxHeatSetpointLimit) { - VerifyOrReturn(CheckValue("maxHeatSetpointLimit", maxHeatSetpointLimit, 3000)); + VerifyOrReturn(CheckValue("maxHeatSetpointLimit", maxHeatSetpointLimit, 3000)); NextTest(); } @@ -22631,7 +22631,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_33(int16_t minCoolSetpointLimit) { - VerifyOrReturn(CheckValue("minCoolSetpointLimit", minCoolSetpointLimit, 1600)); + VerifyOrReturn(CheckValue("minCoolSetpointLimit", minCoolSetpointLimit, 1600)); NextTest(); } @@ -22686,7 +22686,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_36(int16_t minCoolSetpointLimit) { - VerifyOrReturn(CheckValue("minCoolSetpointLimit", minCoolSetpointLimit, 1600)); + VerifyOrReturn(CheckValue("minCoolSetpointLimit", minCoolSetpointLimit, 1600)); NextTest(); } @@ -22704,7 +22704,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_37(int16_t maxCoolSetpointLimit) { - VerifyOrReturn(CheckValue("maxCoolSetpointLimit", maxCoolSetpointLimit, 3200)); + VerifyOrReturn(CheckValue("maxCoolSetpointLimit", maxCoolSetpointLimit, 3200)); NextTest(); } @@ -22759,7 +22759,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_40(int16_t maxCoolSetpointLimit) { - VerifyOrReturn(CheckValue("maxCoolSetpointLimit", maxCoolSetpointLimit, 3200)); + VerifyOrReturn(CheckValue("maxCoolSetpointLimit", maxCoolSetpointLimit, 3200)); NextTest(); } @@ -22777,7 +22777,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_41(uint8_t controlSequenceOfOperation) { - VerifyOrReturn(CheckValue("controlSequenceOfOperation", controlSequenceOfOperation, 4)); + VerifyOrReturn(CheckValue("controlSequenceOfOperation", controlSequenceOfOperation, 4)); NextTest(); } @@ -22831,7 +22831,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_44(uint8_t controlSequenceOfOperation) { - VerifyOrReturn(CheckValue("controlSequenceOfOperation", controlSequenceOfOperation, 4)); + VerifyOrReturn(CheckValue("controlSequenceOfOperation", controlSequenceOfOperation, 4)); NextTest(); } @@ -22849,7 +22849,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_45(uint8_t systemMode) { - VerifyOrReturn(CheckValue("systemMode", systemMode, 1)); + VerifyOrReturn(CheckValue("systemMode", systemMode, 1)); NextTest(); } @@ -22903,7 +22903,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_48(uint8_t systemMode) { - VerifyOrReturn(CheckValue("systemMode", systemMode, 1)); + VerifyOrReturn(CheckValue("systemMode", systemMode, 1)); NextTest(); } @@ -22921,7 +22921,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_49(int8_t minSetpointDeadBand) { - VerifyOrReturn(CheckValue("minSetpointDeadBand", minSetpointDeadBand, 25)); + VerifyOrReturn(CheckValue("minSetpointDeadBand", minSetpointDeadBand, 25)); NextTest(); } @@ -22975,7 +22975,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_52(int8_t minSetpointDeadBand) { - VerifyOrReturn(CheckValue("minSetpointDeadBand", minSetpointDeadBand, 25)); + VerifyOrReturn(CheckValue("minSetpointDeadBand", minSetpointDeadBand, 25)); NextTest(); } @@ -23029,7 +23029,7 @@ class Test_TC_TSTAT_2_1 : public TestCommand void OnSuccessResponse_55(uint8_t startOfWeek) { - VerifyOrReturn(CheckValue("startOfWeek", startOfWeek, 0)); + VerifyOrReturn(CheckValue("startOfWeek", startOfWeek, 0)); NextTest(); } @@ -23813,7 +23813,7 @@ class Test_TC_TSTAT_2_2 : public TestCommand void OnSuccessResponse_0(int16_t occupiedCoolingSetpoint) { - VerifyOrReturn(CheckValue("occupiedCoolingSetpoint", occupiedCoolingSetpoint, 2600)); + VerifyOrReturn(CheckValue("occupiedCoolingSetpoint", occupiedCoolingSetpoint, 2600)); NextTest(); } @@ -23848,7 +23848,7 @@ class Test_TC_TSTAT_2_2 : public TestCommand void OnSuccessResponse_2(int16_t occupiedCoolingSetpoint) { - VerifyOrReturn(CheckValue("occupiedCoolingSetpoint", occupiedCoolingSetpoint, 2000)); + VerifyOrReturn(CheckValue("occupiedCoolingSetpoint", occupiedCoolingSetpoint, 2000)); NextTest(); } @@ -23900,7 +23900,7 @@ class Test_TC_TSTAT_2_2 : public TestCommand void OnSuccessResponse_5(int16_t occupiedHeatingSetpoint) { - VerifyOrReturn(CheckValue("occupiedHeatingSetpoint", occupiedHeatingSetpoint, 2000)); + VerifyOrReturn(CheckValue("occupiedHeatingSetpoint", occupiedHeatingSetpoint, 2000)); NextTest(); } @@ -23935,7 +23935,7 @@ class Test_TC_TSTAT_2_2 : public TestCommand void OnSuccessResponse_7(int16_t occupiedHeatingSetpoint) { - VerifyOrReturn(CheckValue("occupiedHeatingSetpoint", occupiedHeatingSetpoint, 2100)); + VerifyOrReturn(CheckValue("occupiedHeatingSetpoint", occupiedHeatingSetpoint, 2100)); NextTest(); } @@ -23987,7 +23987,7 @@ class Test_TC_TSTAT_2_2 : public TestCommand void OnSuccessResponse_10(int16_t minHeatSetpointLimit) { - VerifyOrReturn(CheckValue("minHeatSetpointLimit", minHeatSetpointLimit, 700)); + VerifyOrReturn(CheckValue("minHeatSetpointLimit", minHeatSetpointLimit, 700)); NextTest(); } @@ -24022,7 +24022,7 @@ class Test_TC_TSTAT_2_2 : public TestCommand void OnSuccessResponse_12(int16_t minHeatSetpointLimit) { - VerifyOrReturn(CheckValue("minHeatSetpointLimit", minHeatSetpointLimit, 2000)); + VerifyOrReturn(CheckValue("minHeatSetpointLimit", minHeatSetpointLimit, 2000)); NextTest(); } @@ -24074,7 +24074,7 @@ class Test_TC_TSTAT_2_2 : public TestCommand void OnSuccessResponse_15(int16_t maxHeatSetpointLimit) { - VerifyOrReturn(CheckValue("maxHeatSetpointLimit", maxHeatSetpointLimit, 3000)); + VerifyOrReturn(CheckValue("maxHeatSetpointLimit", maxHeatSetpointLimit, 3000)); NextTest(); } @@ -24109,7 +24109,7 @@ class Test_TC_TSTAT_2_2 : public TestCommand void OnSuccessResponse_17(int16_t maxHeatSetpointLimit) { - VerifyOrReturn(CheckValue("maxHeatSetpointLimit", maxHeatSetpointLimit, 2000)); + VerifyOrReturn(CheckValue("maxHeatSetpointLimit", maxHeatSetpointLimit, 2000)); NextTest(); } @@ -24161,7 +24161,7 @@ class Test_TC_TSTAT_2_2 : public TestCommand void OnSuccessResponse_20(int16_t minCoolSetpointLimit) { - VerifyOrReturn(CheckValue("minCoolSetpointLimit", minCoolSetpointLimit, 1600)); + VerifyOrReturn(CheckValue("minCoolSetpointLimit", minCoolSetpointLimit, 1600)); NextTest(); } @@ -24196,7 +24196,7 @@ class Test_TC_TSTAT_2_2 : public TestCommand void OnSuccessResponse_22(int16_t minCoolSetpointLimit) { - VerifyOrReturn(CheckValue("minCoolSetpointLimit", minCoolSetpointLimit, 2000)); + VerifyOrReturn(CheckValue("minCoolSetpointLimit", minCoolSetpointLimit, 2000)); NextTest(); } @@ -24248,7 +24248,7 @@ class Test_TC_TSTAT_2_2 : public TestCommand void OnSuccessResponse_25(int16_t maxCoolSetpointLimit) { - VerifyOrReturn(CheckValue("maxCoolSetpointLimit", maxCoolSetpointLimit, 3200)); + VerifyOrReturn(CheckValue("maxCoolSetpointLimit", maxCoolSetpointLimit, 3200)); NextTest(); } @@ -24283,7 +24283,7 @@ class Test_TC_TSTAT_2_2 : public TestCommand void OnSuccessResponse_27(int16_t maxCoolSetpointLimit) { - VerifyOrReturn(CheckValue("maxCoolSetpointLimit", maxCoolSetpointLimit, 2000)); + VerifyOrReturn(CheckValue("maxCoolSetpointLimit", maxCoolSetpointLimit, 2000)); NextTest(); } @@ -24471,7 +24471,7 @@ class Test_TC_TSTAT_2_2 : public TestCommand void OnSuccessResponse_38(uint8_t controlSequenceOfOperation) { - VerifyOrReturn(CheckValue("controlSequenceOfOperation", controlSequenceOfOperation, 4)); + VerifyOrReturn(CheckValue("controlSequenceOfOperation", controlSequenceOfOperation, 4)); NextTest(); } @@ -24506,7 +24506,7 @@ class Test_TC_TSTAT_2_2 : public TestCommand void OnSuccessResponse_40(uint8_t controlSequenceOfOperation) { - VerifyOrReturn(CheckValue("controlSequenceOfOperation", controlSequenceOfOperation, 2)); + VerifyOrReturn(CheckValue("controlSequenceOfOperation", controlSequenceOfOperation, 2)); NextTest(); } @@ -24988,7 +24988,7 @@ class Test_TC_TSUIC_2_1 : public TestCommand void OnSuccessResponse_0(uint8_t temperatureDisplayMode) { - VerifyOrReturn(CheckValue("temperatureDisplayMode", temperatureDisplayMode, 0)); + VerifyOrReturn(CheckValue("temperatureDisplayMode", temperatureDisplayMode, 0)); NextTest(); } @@ -25044,7 +25044,7 @@ class Test_TC_TSUIC_2_1 : public TestCommand void OnSuccessResponse_3(uint8_t temperatureDisplayMode) { - VerifyOrReturn(CheckValue("temperatureDisplayMode", temperatureDisplayMode, 0)); + VerifyOrReturn(CheckValue("temperatureDisplayMode", temperatureDisplayMode, 0)); NextTest(); } @@ -25082,7 +25082,7 @@ class Test_TC_TSUIC_2_1 : public TestCommand void OnSuccessResponse_5(uint8_t keypadLockout) { - VerifyOrReturn(CheckValue("keypadLockout", keypadLockout, 0)); + VerifyOrReturn(CheckValue("keypadLockout", keypadLockout, 0)); NextTest(); } @@ -25138,7 +25138,7 @@ class Test_TC_TSUIC_2_1 : public TestCommand void OnSuccessResponse_8(uint8_t keypadLockout) { - VerifyOrReturn(CheckValue("keypadLockout", keypadLockout, 0)); + VerifyOrReturn(CheckValue("keypadLockout", keypadLockout, 0)); NextTest(); } @@ -25176,7 +25176,7 @@ class Test_TC_TSUIC_2_1 : public TestCommand void OnSuccessResponse_10(uint8_t scheduleProgrammingVisibility) { - VerifyOrReturn(CheckValue("scheduleProgrammingVisibility", scheduleProgrammingVisibility, 0)); + VerifyOrReturn(CheckValue("scheduleProgrammingVisibility", scheduleProgrammingVisibility, 0)); NextTest(); } @@ -25232,7 +25232,7 @@ class Test_TC_TSUIC_2_1 : public TestCommand void OnSuccessResponse_13(uint8_t scheduleProgrammingVisibility) { - VerifyOrReturn(CheckValue("scheduleProgrammingVisibility", scheduleProgrammingVisibility, 0)); + VerifyOrReturn(CheckValue("scheduleProgrammingVisibility", scheduleProgrammingVisibility, 0)); NextTest(); } @@ -25697,7 +25697,7 @@ class Test_TC_DIAGTH_1_1 : public TestCommand void OnSuccessResponse_0(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 1U)); + VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 1U)); NextTest(); } @@ -25732,7 +25732,7 @@ class Test_TC_DIAGTH_1_1 : public TestCommand void OnSuccessResponse_2(uint16_t clusterRevision) { - VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 1U)); + VerifyOrReturn(CheckValue("clusterRevision", clusterRevision, 1U)); NextTest(); } }; @@ -27028,7 +27028,7 @@ class Test_TC_WNCV_2_1 : public TestCommand void OnSuccessResponse_14(uint8_t mode) { - VerifyOrReturn(CheckValue("mode", mode, 8)); + VerifyOrReturn(CheckValue("mode", mode, 8)); NextTest(); } @@ -27893,7 +27893,7 @@ class Test_TC_WNCV_2_4 : public TestCommand void OnSuccessResponse_0(uint8_t type) { - VerifyOrReturn(CheckValue("type", type, 0)); + VerifyOrReturn(CheckValue("type", type, 0)); NextTest(); } @@ -28006,7 +28006,7 @@ class Test_TC_WNCV_2_5 : public TestCommand void OnSuccessResponse_0(uint8_t endProductType) { - VerifyOrReturn(CheckValue("endProductType", endProductType, 0)); + VerifyOrReturn(CheckValue("endProductType", endProductType, 0)); NextTest(); } @@ -28159,7 +28159,7 @@ class Test_TC_WNCV_3_1 : public TestCommand void OnSuccessResponse_2(uint8_t operationalStatus) { - VerifyOrReturn(CheckValue("operationalStatus", operationalStatus, 0)); + VerifyOrReturn(CheckValue("operationalStatus", operationalStatus, 0)); NextTest(); } }; @@ -28293,7 +28293,7 @@ class Test_TC_WNCV_3_2 : public TestCommand void OnSuccessResponse_2(uint8_t operationalStatus) { - VerifyOrReturn(CheckValue("operationalStatus", operationalStatus, 0)); + VerifyOrReturn(CheckValue("operationalStatus", operationalStatus, 0)); NextTest(); } }; @@ -28427,7 +28427,7 @@ class Test_TC_WNCV_3_3 : public TestCommand void OnSuccessResponse_2(uint8_t operationalStatus) { - VerifyOrReturn(CheckValue("operationalStatus", operationalStatus, 0)); + VerifyOrReturn(CheckValue("operationalStatus", operationalStatus, 0)); NextTest(); } }; @@ -28518,10 +28518,10 @@ class TV_TargetNavigatorCluster : public TestCommand { auto iter = targetNavigatorList.begin(); VerifyOrReturn(CheckNextListItemDecodes("targetNavigatorList", iter, 0)); - VerifyOrReturn(CheckValue<>("targetNavigatorList[0].identifier", iter.GetValue().identifier, 1)); + VerifyOrReturn(CheckValue("targetNavigatorList[0].identifier", iter.GetValue().identifier, 1)); VerifyOrReturn(CheckValueAsString("targetNavigatorList[0].name", iter.GetValue().name, chip::CharSpan("exampleName", 11))); VerifyOrReturn(CheckNextListItemDecodes("targetNavigatorList", iter, 1)); - VerifyOrReturn(CheckValue<>("targetNavigatorList[1].identifier", iter.GetValue().identifier, 2)); + VerifyOrReturn(CheckValue("targetNavigatorList[1].identifier", iter.GetValue().identifier, 2)); VerifyOrReturn(CheckValueAsString("targetNavigatorList[1].name", iter.GetValue().name, chip::CharSpan("exampleName", 11))); VerifyOrReturn(CheckNoMoreListItems("targetNavigatorList", iter, 2)); NextTest(); @@ -28643,16 +28643,16 @@ class TV_AudioOutputCluster : public TestCommand { auto iter = audioOutputList.begin(); VerifyOrReturn(CheckNextListItemDecodes("audioOutputList", iter, 0)); - VerifyOrReturn(CheckValue<>("audioOutputList[0].index", iter.GetValue().index, 1)); - VerifyOrReturn(CheckValue<>("audioOutputList[0].outputType", iter.GetValue().outputType, 0)); + VerifyOrReturn(CheckValue("audioOutputList[0].index", iter.GetValue().index, 1)); + VerifyOrReturn(CheckValue("audioOutputList[0].outputType", iter.GetValue().outputType, 0)); VerifyOrReturn(CheckValueAsString("audioOutputList[0].name", iter.GetValue().name, chip::CharSpan("exampleName", 11))); VerifyOrReturn(CheckNextListItemDecodes("audioOutputList", iter, 1)); - VerifyOrReturn(CheckValue<>("audioOutputList[1].index", iter.GetValue().index, 2)); - VerifyOrReturn(CheckValue<>("audioOutputList[1].outputType", iter.GetValue().outputType, 0)); + VerifyOrReturn(CheckValue("audioOutputList[1].index", iter.GetValue().index, 2)); + VerifyOrReturn(CheckValue("audioOutputList[1].outputType", iter.GetValue().outputType, 0)); VerifyOrReturn(CheckValueAsString("audioOutputList[1].name", iter.GetValue().name, chip::CharSpan("exampleName", 11))); VerifyOrReturn(CheckNextListItemDecodes("audioOutputList", iter, 2)); - VerifyOrReturn(CheckValue<>("audioOutputList[2].index", iter.GetValue().index, 3)); - VerifyOrReturn(CheckValue<>("audioOutputList[2].outputType", iter.GetValue().outputType, 0)); + VerifyOrReturn(CheckValue("audioOutputList[2].index", iter.GetValue().index, 3)); + VerifyOrReturn(CheckValue("audioOutputList[2].outputType", iter.GetValue().outputType, 0)); VerifyOrReturn(CheckValueAsString("audioOutputList[2].name", iter.GetValue().name, chip::CharSpan("exampleName", 11))); VerifyOrReturn(CheckNoMoreListItems("audioOutputList", iter, 3)); NextTest(); @@ -28817,9 +28817,9 @@ class TV_ApplicationLauncherCluster : public TestCommand { auto iter = applicationLauncherList.begin(); VerifyOrReturn(CheckNextListItemDecodes("applicationLauncherList", iter, 0)); - VerifyOrReturn(CheckValue("applicationLauncherList[0]", iter.GetValue(), 123U)); + VerifyOrReturn(CheckValue("applicationLauncherList[0]", iter.GetValue(), 123U)); VerifyOrReturn(CheckNextListItemDecodes("applicationLauncherList", iter, 1)); - VerifyOrReturn(CheckValue("applicationLauncherList[1]", iter.GetValue(), 456U)); + VerifyOrReturn(CheckValue("applicationLauncherList[1]", iter.GetValue(), 456U)); VerifyOrReturn(CheckNoMoreListItems("applicationLauncherList", iter, 2)); NextTest(); } @@ -28868,7 +28868,7 @@ class TV_ApplicationLauncherCluster : public TestCommand void OnSuccessResponse_2(uint8_t catalogVendorId) { - VerifyOrReturn(CheckValue("catalogVendorId", catalogVendorId, 0)); + VerifyOrReturn(CheckValue("catalogVendorId", catalogVendorId, 0)); NextTest(); } @@ -28886,7 +28886,7 @@ class TV_ApplicationLauncherCluster : public TestCommand void OnSuccessResponse_3(uint8_t applicationId) { - VerifyOrReturn(CheckValue("applicationId", applicationId, 0)); + VerifyOrReturn(CheckValue("applicationId", applicationId, 0)); NextTest(); } }; @@ -29283,7 +29283,7 @@ class TV_ApplicationBasicCluster : public TestCommand void OnSuccessResponse_1(uint16_t vendorId) { - VerifyOrReturn(CheckValue("vendorId", vendorId, 1U)); + VerifyOrReturn(CheckValue("vendorId", vendorId, 1U)); NextTest(); } @@ -29301,7 +29301,7 @@ class TV_ApplicationBasicCluster : public TestCommand void OnSuccessResponse_2(uint16_t productId) { - VerifyOrReturn(CheckValue("productId", productId, 1U)); + VerifyOrReturn(CheckValue("productId", productId, 1U)); NextTest(); } @@ -29319,7 +29319,7 @@ class TV_ApplicationBasicCluster : public TestCommand void OnSuccessResponse_3(uint16_t catalogVendorId) { - VerifyOrReturn(CheckValue("catalogVendorId", catalogVendorId, 1U)); + VerifyOrReturn(CheckValue("catalogVendorId", catalogVendorId, 1U)); NextTest(); } }; @@ -29438,7 +29438,7 @@ class TV_MediaPlaybackCluster : public TestCommand void OnSuccessResponse_0(chip::app::Clusters::MediaPlayback::MediaPlaybackStatus mediaPlaybackStatus) { - VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); + VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); NextTest(); } @@ -29465,7 +29465,7 @@ class TV_MediaPlaybackCluster : public TestCommand void OnSuccessResponse_1(chip::app::Clusters::MediaPlayback::MediaPlaybackStatus mediaPlaybackStatus) { - VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); + VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); NextTest(); } @@ -29492,7 +29492,7 @@ class TV_MediaPlaybackCluster : public TestCommand void OnSuccessResponse_2(chip::app::Clusters::MediaPlayback::MediaPlaybackStatus mediaPlaybackStatus) { - VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); + VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); NextTest(); } @@ -29519,7 +29519,7 @@ class TV_MediaPlaybackCluster : public TestCommand void OnSuccessResponse_3(chip::app::Clusters::MediaPlayback::MediaPlaybackStatus mediaPlaybackStatus) { - VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); + VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); NextTest(); } @@ -29546,7 +29546,7 @@ class TV_MediaPlaybackCluster : public TestCommand void OnSuccessResponse_4(chip::app::Clusters::MediaPlayback::MediaPlaybackStatus mediaPlaybackStatus) { - VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); + VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); NextTest(); } @@ -29573,7 +29573,7 @@ class TV_MediaPlaybackCluster : public TestCommand void OnSuccessResponse_5(chip::app::Clusters::MediaPlayback::MediaPlaybackStatus mediaPlaybackStatus) { - VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); + VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); NextTest(); } @@ -29600,7 +29600,7 @@ class TV_MediaPlaybackCluster : public TestCommand void OnSuccessResponse_6(chip::app::Clusters::MediaPlayback::MediaPlaybackStatus mediaPlaybackStatus) { - VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); + VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); NextTest(); } @@ -29627,7 +29627,7 @@ class TV_MediaPlaybackCluster : public TestCommand void OnSuccessResponse_7(chip::app::Clusters::MediaPlayback::MediaPlaybackStatus mediaPlaybackStatus) { - VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); + VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); NextTest(); } @@ -29655,7 +29655,7 @@ class TV_MediaPlaybackCluster : public TestCommand void OnSuccessResponse_8(chip::app::Clusters::MediaPlayback::MediaPlaybackStatus mediaPlaybackStatus) { - VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); + VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); NextTest(); } @@ -29683,7 +29683,7 @@ class TV_MediaPlaybackCluster : public TestCommand void OnSuccessResponse_9(chip::app::Clusters::MediaPlayback::MediaPlaybackStatus mediaPlaybackStatus) { - VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); + VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); NextTest(); } @@ -29711,7 +29711,7 @@ class TV_MediaPlaybackCluster : public TestCommand void OnSuccessResponse_10(chip::app::Clusters::MediaPlayback::MediaPlaybackStatus mediaPlaybackStatus) { - VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); + VerifyOrReturn(CheckValue("mediaPlaybackStatus", mediaPlaybackStatus, 0)); NextTest(); } }; @@ -29806,16 +29806,16 @@ class TV_TvChannelCluster : public TestCommand { auto iter = tvChannelList.begin(); VerifyOrReturn(CheckNextListItemDecodes("tvChannelList", iter, 0)); - VerifyOrReturn(CheckValue<>("tvChannelList[0].majorNumber", iter.GetValue().majorNumber, 1U)); - VerifyOrReturn(CheckValue<>("tvChannelList[0].minorNumber", iter.GetValue().minorNumber, 2U)); + VerifyOrReturn(CheckValue("tvChannelList[0].majorNumber", iter.GetValue().majorNumber, 1U)); + VerifyOrReturn(CheckValue("tvChannelList[0].minorNumber", iter.GetValue().minorNumber, 2U)); VerifyOrReturn(CheckValueAsString("tvChannelList[0].name", iter.GetValue().name, chip::CharSpan("exampleName", 11))); VerifyOrReturn( CheckValueAsString("tvChannelList[0].callSign", iter.GetValue().callSign, chip::CharSpan("exampleCSign", 12))); VerifyOrReturn(CheckValueAsString("tvChannelList[0].affiliateCallSign", iter.GetValue().affiliateCallSign, chip::CharSpan("exampleASign", 12))); VerifyOrReturn(CheckNextListItemDecodes("tvChannelList", iter, 1)); - VerifyOrReturn(CheckValue<>("tvChannelList[1].majorNumber", iter.GetValue().majorNumber, 2U)); - VerifyOrReturn(CheckValue<>("tvChannelList[1].minorNumber", iter.GetValue().minorNumber, 3U)); + VerifyOrReturn(CheckValue("tvChannelList[1].majorNumber", iter.GetValue().majorNumber, 2U)); + VerifyOrReturn(CheckValue("tvChannelList[1].minorNumber", iter.GetValue().minorNumber, 3U)); VerifyOrReturn(CheckValueAsString("tvChannelList[1].name", iter.GetValue().name, chip::CharSpan("exampleName", 11))); VerifyOrReturn( CheckValueAsString("tvChannelList[1].callSign", iter.GetValue().callSign, chip::CharSpan("exampleCSign", 12))); @@ -30062,14 +30062,14 @@ class TV_MediaInputCluster : public TestCommand { auto iter = mediaInputList.begin(); VerifyOrReturn(CheckNextListItemDecodes("mediaInputList", iter, 0)); - VerifyOrReturn(CheckValue<>("mediaInputList[0].index", iter.GetValue().index, 1)); - VerifyOrReturn(CheckValue<>("mediaInputList[0].inputType", iter.GetValue().inputType, 4)); + VerifyOrReturn(CheckValue("mediaInputList[0].index", iter.GetValue().index, 1)); + VerifyOrReturn(CheckValue("mediaInputList[0].inputType", iter.GetValue().inputType, 4)); VerifyOrReturn(CheckValueAsString("mediaInputList[0].name", iter.GetValue().name, chip::CharSpan("exampleName", 11))); VerifyOrReturn(CheckValueAsString("mediaInputList[0].description", iter.GetValue().description, chip::CharSpan("exampleDescription", 18))); VerifyOrReturn(CheckNextListItemDecodes("mediaInputList", iter, 1)); - VerifyOrReturn(CheckValue<>("mediaInputList[1].index", iter.GetValue().index, 2)); - VerifyOrReturn(CheckValue<>("mediaInputList[1].inputType", iter.GetValue().inputType, 4)); + VerifyOrReturn(CheckValue("mediaInputList[1].index", iter.GetValue().index, 2)); + VerifyOrReturn(CheckValue("mediaInputList[1].inputType", iter.GetValue().inputType, 4)); VerifyOrReturn(CheckValueAsString("mediaInputList[1].name", iter.GetValue().name, chip::CharSpan("exampleName", 11))); VerifyOrReturn(CheckValueAsString("mediaInputList[1].description", iter.GetValue().description, chip::CharSpan("exampleDescription", 18))); @@ -30115,7 +30115,7 @@ class TV_MediaInputCluster : public TestCommand void OnSuccessResponse_2(uint8_t currentMediaInput) { - VerifyOrReturn(CheckValue("currentMediaInput", currentMediaInput, 1)); + VerifyOrReturn(CheckValue("currentMediaInput", currentMediaInput, 1)); NextTest(); } @@ -30734,474 +30734,478 @@ class TestCluster : public TestCommand err = TestSendTestCommandWithStructArgumentAndArg1bIsFalse_127(); break; case 128: - ChipLogProgress(chipTool, " ***** Test Step 128 : Send Test Command With List of INT8U and none of them is set to 0\n"); - err = TestSendTestCommandWithListOfInt8uAndNoneOfThemIsSetTo0_128(); + ChipLogProgress(chipTool, " ***** Test Step 128 : Send Test Command With Struct Argument and see what we get back\n"); + err = TestSendTestCommandWithStructArgumentAndSeeWhatWeGetBack_128(); break; case 129: - ChipLogProgress(chipTool, " ***** Test Step 129 : Send Test Command With List of INT8U and one of them is set to 0\n"); - err = TestSendTestCommandWithListOfInt8uAndOneOfThemIsSetTo0_129(); + ChipLogProgress(chipTool, " ***** Test Step 129 : Send Test Command With List of INT8U and none of them is set to 0\n"); + err = TestSendTestCommandWithListOfInt8uAndNoneOfThemIsSetTo0_129(); break; case 130: - ChipLogProgress(chipTool, " ***** Test Step 130 : Send Test Command With List of INT8U and get it reversed\n"); - err = TestSendTestCommandWithListOfInt8uAndGetItReversed_130(); + ChipLogProgress(chipTool, " ***** Test Step 130 : Send Test Command With List of INT8U and one of them is set to 0\n"); + err = TestSendTestCommandWithListOfInt8uAndOneOfThemIsSetTo0_130(); break; case 131: - ChipLogProgress(chipTool, - " ***** Test Step 131 : Send Test Command With empty List of INT8U and get an empty list back\n"); - err = TestSendTestCommandWithEmptyListOfInt8uAndGetAnEmptyListBack_131(); + ChipLogProgress(chipTool, " ***** Test Step 131 : Send Test Command With List of INT8U and get it reversed\n"); + err = TestSendTestCommandWithListOfInt8uAndGetItReversed_131(); break; case 132: - ChipLogProgress( - chipTool, - " ***** Test Step 132 : Send Test Command With List of Struct Argument and arg1.b of first item is true\n"); - err = TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsTrue_132(); + ChipLogProgress(chipTool, + " ***** Test Step 132 : Send Test Command With empty List of INT8U and get an empty list back\n"); + err = TestSendTestCommandWithEmptyListOfInt8uAndGetAnEmptyListBack_132(); break; case 133: ChipLogProgress( chipTool, - " ***** Test Step 133 : Send Test Command With List of Struct Argument and arg1.b of first item is false\n"); - err = TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsFalse_133(); + " ***** Test Step 133 : Send Test Command With List of Struct Argument and arg1.b of first item is true\n"); + err = TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsTrue_133(); break; case 134: - ChipLogProgress(chipTool, - " ***** Test Step 134 : Write attribute LIST With List of INT8U and none of them is set to 0\n"); - err = TestWriteAttributeListWithListOfInt8uAndNoneOfThemIsSetTo0_134(); + ChipLogProgress( + chipTool, + " ***** Test Step 134 : Send Test Command With List of Struct Argument and arg1.b of first item is false\n"); + err = TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsFalse_134(); break; case 135: - ChipLogProgress(chipTool, " ***** Test Step 135 : Read attribute LIST With List of INT8U\n"); - err = TestReadAttributeListWithListOfInt8u_135(); + ChipLogProgress(chipTool, + " ***** Test Step 135 : Write attribute LIST With List of INT8U and none of them is set to 0\n"); + err = TestWriteAttributeListWithListOfInt8uAndNoneOfThemIsSetTo0_135(); break; case 136: - ChipLogProgress(chipTool, " ***** Test Step 136 : Write attribute LIST With List of OCTET_STRING\n"); - err = TestWriteAttributeListWithListOfOctetString_136(); + ChipLogProgress(chipTool, " ***** Test Step 136 : Read attribute LIST With List of INT8U\n"); + err = TestReadAttributeListWithListOfInt8u_136(); break; case 137: - ChipLogProgress(chipTool, " ***** Test Step 137 : Read attribute LIST With List of OCTET_STRING\n"); - err = TestReadAttributeListWithListOfOctetString_137(); + ChipLogProgress(chipTool, " ***** Test Step 137 : Write attribute LIST With List of OCTET_STRING\n"); + err = TestWriteAttributeListWithListOfOctetString_137(); break; case 138: - ChipLogProgress(chipTool, " ***** Test Step 138 : Write attribute LIST With List of LIST_STRUCT_OCTET_STRING\n"); - err = TestWriteAttributeListWithListOfListStructOctetString_138(); + ChipLogProgress(chipTool, " ***** Test Step 138 : Read attribute LIST With List of OCTET_STRING\n"); + err = TestReadAttributeListWithListOfOctetString_138(); break; case 139: - ChipLogProgress(chipTool, " ***** Test Step 139 : Read attribute LIST With List of LIST_STRUCT_OCTET_STRING\n"); - err = TestReadAttributeListWithListOfListStructOctetString_139(); + ChipLogProgress(chipTool, " ***** Test Step 139 : Write attribute LIST With List of LIST_STRUCT_OCTET_STRING\n"); + err = TestWriteAttributeListWithListOfListStructOctetString_139(); break; case 140: - ChipLogProgress(chipTool, " ***** Test Step 140 : Send Test Command with optional arg set.\n"); - err = TestSendTestCommandWithOptionalArgSet_140(); + ChipLogProgress(chipTool, " ***** Test Step 140 : Read attribute LIST With List of LIST_STRUCT_OCTET_STRING\n"); + err = TestReadAttributeListWithListOfListStructOctetString_140(); break; case 141: - ChipLogProgress(chipTool, " ***** Test Step 141 : Send Test Command without its optional arg.\n"); - err = TestSendTestCommandWithoutItsOptionalArg_141(); + ChipLogProgress(chipTool, " ***** Test Step 141 : Send Test Command with optional arg set.\n"); + err = TestSendTestCommandWithOptionalArgSet_141(); break; case 142: - ChipLogProgress(chipTool, " ***** Test Step 142 : Write attribute NULLABLE_BOOLEAN null\n"); - err = TestWriteAttributeNullableBooleanNull_142(); + ChipLogProgress(chipTool, " ***** Test Step 142 : Send Test Command without its optional arg.\n"); + err = TestSendTestCommandWithoutItsOptionalArg_142(); break; case 143: - ChipLogProgress(chipTool, " ***** Test Step 143 : Read attribute NULLABLE_BOOLEAN null\n"); - err = TestReadAttributeNullableBooleanNull_143(); + ChipLogProgress(chipTool, " ***** Test Step 143 : Write attribute NULLABLE_BOOLEAN null\n"); + err = TestWriteAttributeNullableBooleanNull_143(); break; case 144: - ChipLogProgress(chipTool, " ***** Test Step 144 : Write attribute NULLABLE_BOOLEAN True\n"); - err = TestWriteAttributeNullableBooleanTrue_144(); + ChipLogProgress(chipTool, " ***** Test Step 144 : Read attribute NULLABLE_BOOLEAN null\n"); + err = TestReadAttributeNullableBooleanNull_144(); break; case 145: - ChipLogProgress(chipTool, " ***** Test Step 145 : Read attribute NULLABLE_BOOLEAN True\n"); - err = TestReadAttributeNullableBooleanTrue_145(); + ChipLogProgress(chipTool, " ***** Test Step 145 : Write attribute NULLABLE_BOOLEAN True\n"); + err = TestWriteAttributeNullableBooleanTrue_145(); break; case 146: - ChipLogProgress(chipTool, " ***** Test Step 146 : Write attribute NULLABLE_BITMAP8 Max Value\n"); - err = TestWriteAttributeNullableBitmap8MaxValue_146(); + ChipLogProgress(chipTool, " ***** Test Step 146 : Read attribute NULLABLE_BOOLEAN True\n"); + err = TestReadAttributeNullableBooleanTrue_146(); break; case 147: - ChipLogProgress(chipTool, " ***** Test Step 147 : Read attribute NULLABLE_BITMAP8 Max Value\n"); - err = TestReadAttributeNullableBitmap8MaxValue_147(); + ChipLogProgress(chipTool, " ***** Test Step 147 : Write attribute NULLABLE_BITMAP8 Max Value\n"); + err = TestWriteAttributeNullableBitmap8MaxValue_147(); break; case 148: - ChipLogProgress(chipTool, " ***** Test Step 148 : Write attribute NULLABLE_BITMAP8 Invalid Value\n"); - err = TestWriteAttributeNullableBitmap8InvalidValue_148(); + ChipLogProgress(chipTool, " ***** Test Step 148 : Read attribute NULLABLE_BITMAP8 Max Value\n"); + err = TestReadAttributeNullableBitmap8MaxValue_148(); break; case 149: - ChipLogProgress(chipTool, " ***** Test Step 149 : Read attribute NULLABLE_BITMAP8 unchanged Value\n"); - err = TestReadAttributeNullableBitmap8UnchangedValue_149(); + ChipLogProgress(chipTool, " ***** Test Step 149 : Write attribute NULLABLE_BITMAP8 Invalid Value\n"); + err = TestWriteAttributeNullableBitmap8InvalidValue_149(); break; case 150: - ChipLogProgress(chipTool, " ***** Test Step 150 : Write attribute NULLABLE_BITMAP8 null Value\n"); - err = TestWriteAttributeNullableBitmap8NullValue_150(); + ChipLogProgress(chipTool, " ***** Test Step 150 : Read attribute NULLABLE_BITMAP8 unchanged Value\n"); + err = TestReadAttributeNullableBitmap8UnchangedValue_150(); break; case 151: - ChipLogProgress(chipTool, " ***** Test Step 151 : Read attribute NULLABLE_BITMAP8 null Value\n"); - err = TestReadAttributeNullableBitmap8NullValue_151(); + ChipLogProgress(chipTool, " ***** Test Step 151 : Write attribute NULLABLE_BITMAP8 null Value\n"); + err = TestWriteAttributeNullableBitmap8NullValue_151(); break; case 152: - ChipLogProgress(chipTool, " ***** Test Step 152 : Write attribute NULLABLE_BITMAP16 Max Value\n"); - err = TestWriteAttributeNullableBitmap16MaxValue_152(); + ChipLogProgress(chipTool, " ***** Test Step 152 : Read attribute NULLABLE_BITMAP8 null Value\n"); + err = TestReadAttributeNullableBitmap8NullValue_152(); break; case 153: - ChipLogProgress(chipTool, " ***** Test Step 153 : Read attribute NULLABLE_BITMAP16 Max Value\n"); - err = TestReadAttributeNullableBitmap16MaxValue_153(); + ChipLogProgress(chipTool, " ***** Test Step 153 : Write attribute NULLABLE_BITMAP16 Max Value\n"); + err = TestWriteAttributeNullableBitmap16MaxValue_153(); break; case 154: - ChipLogProgress(chipTool, " ***** Test Step 154 : Write attribute NULLABLE_BITMAP16 Invalid Value\n"); - err = TestWriteAttributeNullableBitmap16InvalidValue_154(); + ChipLogProgress(chipTool, " ***** Test Step 154 : Read attribute NULLABLE_BITMAP16 Max Value\n"); + err = TestReadAttributeNullableBitmap16MaxValue_154(); break; case 155: - ChipLogProgress(chipTool, " ***** Test Step 155 : Read attribute NULLABLE_BITMAP16 unchanged Value\n"); - err = TestReadAttributeNullableBitmap16UnchangedValue_155(); + ChipLogProgress(chipTool, " ***** Test Step 155 : Write attribute NULLABLE_BITMAP16 Invalid Value\n"); + err = TestWriteAttributeNullableBitmap16InvalidValue_155(); break; case 156: - ChipLogProgress(chipTool, " ***** Test Step 156 : Write attribute NULLABLE_BITMAP16 null Value\n"); - err = TestWriteAttributeNullableBitmap16NullValue_156(); + ChipLogProgress(chipTool, " ***** Test Step 156 : Read attribute NULLABLE_BITMAP16 unchanged Value\n"); + err = TestReadAttributeNullableBitmap16UnchangedValue_156(); break; case 157: - ChipLogProgress(chipTool, " ***** Test Step 157 : Read attribute NULLABLE_BITMAP16 null Value\n"); - err = TestReadAttributeNullableBitmap16NullValue_157(); + ChipLogProgress(chipTool, " ***** Test Step 157 : Write attribute NULLABLE_BITMAP16 null Value\n"); + err = TestWriteAttributeNullableBitmap16NullValue_157(); break; case 158: - ChipLogProgress(chipTool, " ***** Test Step 158 : Write attribute NULLABLE_BITMAP32 Max Value\n"); - err = TestWriteAttributeNullableBitmap32MaxValue_158(); + ChipLogProgress(chipTool, " ***** Test Step 158 : Read attribute NULLABLE_BITMAP16 null Value\n"); + err = TestReadAttributeNullableBitmap16NullValue_158(); break; case 159: - ChipLogProgress(chipTool, " ***** Test Step 159 : Read attribute NULLABLE_BITMAP32 Max Value\n"); - err = TestReadAttributeNullableBitmap32MaxValue_159(); + ChipLogProgress(chipTool, " ***** Test Step 159 : Write attribute NULLABLE_BITMAP32 Max Value\n"); + err = TestWriteAttributeNullableBitmap32MaxValue_159(); break; case 160: - ChipLogProgress(chipTool, " ***** Test Step 160 : Write attribute NULLABLE_BITMAP32 Invalid Value\n"); - err = TestWriteAttributeNullableBitmap32InvalidValue_160(); + ChipLogProgress(chipTool, " ***** Test Step 160 : Read attribute NULLABLE_BITMAP32 Max Value\n"); + err = TestReadAttributeNullableBitmap32MaxValue_160(); break; case 161: - ChipLogProgress(chipTool, " ***** Test Step 161 : Read attribute NULLABLE_BITMAP32 unchanged Value\n"); - err = TestReadAttributeNullableBitmap32UnchangedValue_161(); + ChipLogProgress(chipTool, " ***** Test Step 161 : Write attribute NULLABLE_BITMAP32 Invalid Value\n"); + err = TestWriteAttributeNullableBitmap32InvalidValue_161(); break; case 162: - ChipLogProgress(chipTool, " ***** Test Step 162 : Write attribute NULLABLE_BITMAP32 null Value\n"); - err = TestWriteAttributeNullableBitmap32NullValue_162(); + ChipLogProgress(chipTool, " ***** Test Step 162 : Read attribute NULLABLE_BITMAP32 unchanged Value\n"); + err = TestReadAttributeNullableBitmap32UnchangedValue_162(); break; case 163: - ChipLogProgress(chipTool, " ***** Test Step 163 : Read attribute NULLABLE_BITMAP32 null Value\n"); - err = TestReadAttributeNullableBitmap32NullValue_163(); + ChipLogProgress(chipTool, " ***** Test Step 163 : Write attribute NULLABLE_BITMAP32 null Value\n"); + err = TestWriteAttributeNullableBitmap32NullValue_163(); break; case 164: - ChipLogProgress(chipTool, " ***** Test Step 164 : Write attribute NULLABLE_BITMAP64 Max Value\n"); - err = TestWriteAttributeNullableBitmap64MaxValue_164(); + ChipLogProgress(chipTool, " ***** Test Step 164 : Read attribute NULLABLE_BITMAP32 null Value\n"); + err = TestReadAttributeNullableBitmap32NullValue_164(); break; case 165: - ChipLogProgress(chipTool, " ***** Test Step 165 : Read attribute NULLABLE_BITMAP64 Max Value\n"); - err = TestReadAttributeNullableBitmap64MaxValue_165(); + ChipLogProgress(chipTool, " ***** Test Step 165 : Write attribute NULLABLE_BITMAP64 Max Value\n"); + err = TestWriteAttributeNullableBitmap64MaxValue_165(); break; case 166: - ChipLogProgress(chipTool, " ***** Test Step 166 : Write attribute NULLABLE_BITMAP64 Invalid Value\n"); - err = TestWriteAttributeNullableBitmap64InvalidValue_166(); + ChipLogProgress(chipTool, " ***** Test Step 166 : Read attribute NULLABLE_BITMAP64 Max Value\n"); + err = TestReadAttributeNullableBitmap64MaxValue_166(); break; case 167: - ChipLogProgress(chipTool, " ***** Test Step 167 : Read attribute NULLABLE_BITMAP64 unchanged Value\n"); - err = TestReadAttributeNullableBitmap64UnchangedValue_167(); + ChipLogProgress(chipTool, " ***** Test Step 167 : Write attribute NULLABLE_BITMAP64 Invalid Value\n"); + err = TestWriteAttributeNullableBitmap64InvalidValue_167(); break; case 168: - ChipLogProgress(chipTool, " ***** Test Step 168 : Write attribute NULLABLE_BITMAP64 null Value\n"); - err = TestWriteAttributeNullableBitmap64NullValue_168(); + ChipLogProgress(chipTool, " ***** Test Step 168 : Read attribute NULLABLE_BITMAP64 unchanged Value\n"); + err = TestReadAttributeNullableBitmap64UnchangedValue_168(); break; case 169: - ChipLogProgress(chipTool, " ***** Test Step 169 : Read attribute NULLABLE_BITMAP64 null Value\n"); - err = TestReadAttributeNullableBitmap64NullValue_169(); + ChipLogProgress(chipTool, " ***** Test Step 169 : Write attribute NULLABLE_BITMAP64 null Value\n"); + err = TestWriteAttributeNullableBitmap64NullValue_169(); break; case 170: - ChipLogProgress(chipTool, " ***** Test Step 170 : Write attribute NULLABLE_INT8U Max Value\n"); - err = TestWriteAttributeNullableInt8uMaxValue_170(); + ChipLogProgress(chipTool, " ***** Test Step 170 : Read attribute NULLABLE_BITMAP64 null Value\n"); + err = TestReadAttributeNullableBitmap64NullValue_170(); break; case 171: - ChipLogProgress(chipTool, " ***** Test Step 171 : Read attribute NULLABLE_INT8U Max Value\n"); - err = TestReadAttributeNullableInt8uMaxValue_171(); + ChipLogProgress(chipTool, " ***** Test Step 171 : Write attribute NULLABLE_INT8U Max Value\n"); + err = TestWriteAttributeNullableInt8uMaxValue_171(); break; case 172: - ChipLogProgress(chipTool, " ***** Test Step 172 : Write attribute NULLABLE_INT8U Invalid Value\n"); - err = TestWriteAttributeNullableInt8uInvalidValue_172(); + ChipLogProgress(chipTool, " ***** Test Step 172 : Read attribute NULLABLE_INT8U Max Value\n"); + err = TestReadAttributeNullableInt8uMaxValue_172(); break; case 173: - ChipLogProgress(chipTool, " ***** Test Step 173 : Read attribute NULLABLE_INT8U unchanged Value\n"); - err = TestReadAttributeNullableInt8uUnchangedValue_173(); + ChipLogProgress(chipTool, " ***** Test Step 173 : Write attribute NULLABLE_INT8U Invalid Value\n"); + err = TestWriteAttributeNullableInt8uInvalidValue_173(); break; case 174: - ChipLogProgress(chipTool, " ***** Test Step 174 : Write attribute NULLABLE_INT8U null Value\n"); - err = TestWriteAttributeNullableInt8uNullValue_174(); + ChipLogProgress(chipTool, " ***** Test Step 174 : Read attribute NULLABLE_INT8U unchanged Value\n"); + err = TestReadAttributeNullableInt8uUnchangedValue_174(); break; case 175: - ChipLogProgress(chipTool, " ***** Test Step 175 : Read attribute NULLABLE_INT8U null Value\n"); - err = TestReadAttributeNullableInt8uNullValue_175(); + ChipLogProgress(chipTool, " ***** Test Step 175 : Write attribute NULLABLE_INT8U null Value\n"); + err = TestWriteAttributeNullableInt8uNullValue_175(); break; case 176: - ChipLogProgress(chipTool, " ***** Test Step 176 : Write attribute NULLABLE_INT16U Max Value\n"); - err = TestWriteAttributeNullableInt16uMaxValue_176(); + ChipLogProgress(chipTool, " ***** Test Step 176 : Read attribute NULLABLE_INT8U null Value\n"); + err = TestReadAttributeNullableInt8uNullValue_176(); break; case 177: - ChipLogProgress(chipTool, " ***** Test Step 177 : Read attribute NULLABLE_INT16U Max Value\n"); - err = TestReadAttributeNullableInt16uMaxValue_177(); + ChipLogProgress(chipTool, " ***** Test Step 177 : Write attribute NULLABLE_INT16U Max Value\n"); + err = TestWriteAttributeNullableInt16uMaxValue_177(); break; case 178: - ChipLogProgress(chipTool, " ***** Test Step 178 : Write attribute NULLABLE_INT16U Invalid Value\n"); - err = TestWriteAttributeNullableInt16uInvalidValue_178(); + ChipLogProgress(chipTool, " ***** Test Step 178 : Read attribute NULLABLE_INT16U Max Value\n"); + err = TestReadAttributeNullableInt16uMaxValue_178(); break; case 179: - ChipLogProgress(chipTool, " ***** Test Step 179 : Read attribute NULLABLE_INT16U unchanged Value\n"); - err = TestReadAttributeNullableInt16uUnchangedValue_179(); + ChipLogProgress(chipTool, " ***** Test Step 179 : Write attribute NULLABLE_INT16U Invalid Value\n"); + err = TestWriteAttributeNullableInt16uInvalidValue_179(); break; case 180: - ChipLogProgress(chipTool, " ***** Test Step 180 : Write attribute NULLABLE_INT16U null Value\n"); - err = TestWriteAttributeNullableInt16uNullValue_180(); + ChipLogProgress(chipTool, " ***** Test Step 180 : Read attribute NULLABLE_INT16U unchanged Value\n"); + err = TestReadAttributeNullableInt16uUnchangedValue_180(); break; case 181: - ChipLogProgress(chipTool, " ***** Test Step 181 : Read attribute NULLABLE_INT16U null Value\n"); - err = TestReadAttributeNullableInt16uNullValue_181(); + ChipLogProgress(chipTool, " ***** Test Step 181 : Write attribute NULLABLE_INT16U null Value\n"); + err = TestWriteAttributeNullableInt16uNullValue_181(); break; case 182: - ChipLogProgress(chipTool, " ***** Test Step 182 : Write attribute NULLABLE_INT32U Max Value\n"); - err = TestWriteAttributeNullableInt32uMaxValue_182(); + ChipLogProgress(chipTool, " ***** Test Step 182 : Read attribute NULLABLE_INT16U null Value\n"); + err = TestReadAttributeNullableInt16uNullValue_182(); break; case 183: - ChipLogProgress(chipTool, " ***** Test Step 183 : Read attribute NULLABLE_INT32U Max Value\n"); - err = TestReadAttributeNullableInt32uMaxValue_183(); + ChipLogProgress(chipTool, " ***** Test Step 183 : Write attribute NULLABLE_INT32U Max Value\n"); + err = TestWriteAttributeNullableInt32uMaxValue_183(); break; case 184: - ChipLogProgress(chipTool, " ***** Test Step 184 : Write attribute NULLABLE_INT32U Invalid Value\n"); - err = TestWriteAttributeNullableInt32uInvalidValue_184(); + ChipLogProgress(chipTool, " ***** Test Step 184 : Read attribute NULLABLE_INT32U Max Value\n"); + err = TestReadAttributeNullableInt32uMaxValue_184(); break; case 185: - ChipLogProgress(chipTool, " ***** Test Step 185 : Read attribute NULLABLE_INT32U unchanged Value\n"); - err = TestReadAttributeNullableInt32uUnchangedValue_185(); + ChipLogProgress(chipTool, " ***** Test Step 185 : Write attribute NULLABLE_INT32U Invalid Value\n"); + err = TestWriteAttributeNullableInt32uInvalidValue_185(); break; case 186: - ChipLogProgress(chipTool, " ***** Test Step 186 : Write attribute NULLABLE_INT32U null Value\n"); - err = TestWriteAttributeNullableInt32uNullValue_186(); + ChipLogProgress(chipTool, " ***** Test Step 186 : Read attribute NULLABLE_INT32U unchanged Value\n"); + err = TestReadAttributeNullableInt32uUnchangedValue_186(); break; case 187: - ChipLogProgress(chipTool, " ***** Test Step 187 : Read attribute NULLABLE_INT32U null Value\n"); - err = TestReadAttributeNullableInt32uNullValue_187(); + ChipLogProgress(chipTool, " ***** Test Step 187 : Write attribute NULLABLE_INT32U null Value\n"); + err = TestWriteAttributeNullableInt32uNullValue_187(); break; case 188: - ChipLogProgress(chipTool, " ***** Test Step 188 : Write attribute NULLABLE_INT64U Max Value\n"); - err = TestWriteAttributeNullableInt64uMaxValue_188(); + ChipLogProgress(chipTool, " ***** Test Step 188 : Read attribute NULLABLE_INT32U null Value\n"); + err = TestReadAttributeNullableInt32uNullValue_188(); break; case 189: - ChipLogProgress(chipTool, " ***** Test Step 189 : Read attribute NULLABLE_INT64U Max Value\n"); - err = TestReadAttributeNullableInt64uMaxValue_189(); + ChipLogProgress(chipTool, " ***** Test Step 189 : Write attribute NULLABLE_INT64U Max Value\n"); + err = TestWriteAttributeNullableInt64uMaxValue_189(); break; case 190: - ChipLogProgress(chipTool, " ***** Test Step 190 : Write attribute NULLABLE_INT64U Invalid Value\n"); - err = TestWriteAttributeNullableInt64uInvalidValue_190(); + ChipLogProgress(chipTool, " ***** Test Step 190 : Read attribute NULLABLE_INT64U Max Value\n"); + err = TestReadAttributeNullableInt64uMaxValue_190(); break; case 191: - ChipLogProgress(chipTool, " ***** Test Step 191 : Read attribute NULLABLE_INT64U unchanged Value\n"); - err = TestReadAttributeNullableInt64uUnchangedValue_191(); + ChipLogProgress(chipTool, " ***** Test Step 191 : Write attribute NULLABLE_INT64U Invalid Value\n"); + err = TestWriteAttributeNullableInt64uInvalidValue_191(); break; case 192: - ChipLogProgress(chipTool, " ***** Test Step 192 : Write attribute NULLABLE_INT64U null Value\n"); - err = TestWriteAttributeNullableInt64uNullValue_192(); + ChipLogProgress(chipTool, " ***** Test Step 192 : Read attribute NULLABLE_INT64U unchanged Value\n"); + err = TestReadAttributeNullableInt64uUnchangedValue_192(); break; case 193: - ChipLogProgress(chipTool, " ***** Test Step 193 : Read attribute NULLABLE_INT64U null Value\n"); - err = TestReadAttributeNullableInt64uNullValue_193(); + ChipLogProgress(chipTool, " ***** Test Step 193 : Write attribute NULLABLE_INT64U null Value\n"); + err = TestWriteAttributeNullableInt64uNullValue_193(); break; case 194: - ChipLogProgress(chipTool, " ***** Test Step 194 : Write attribute NULLABLE_INT8S Min Value\n"); - err = TestWriteAttributeNullableInt8sMinValue_194(); + ChipLogProgress(chipTool, " ***** Test Step 194 : Read attribute NULLABLE_INT64U null Value\n"); + err = TestReadAttributeNullableInt64uNullValue_194(); break; case 195: - ChipLogProgress(chipTool, " ***** Test Step 195 : Read attribute NULLABLE_INT8S Min Value\n"); - err = TestReadAttributeNullableInt8sMinValue_195(); + ChipLogProgress(chipTool, " ***** Test Step 195 : Write attribute NULLABLE_INT8S Min Value\n"); + err = TestWriteAttributeNullableInt8sMinValue_195(); break; case 196: - ChipLogProgress(chipTool, " ***** Test Step 196 : Write attribute NULLABLE_INT8S Invalid Value\n"); - err = TestWriteAttributeNullableInt8sInvalidValue_196(); + ChipLogProgress(chipTool, " ***** Test Step 196 : Read attribute NULLABLE_INT8S Min Value\n"); + err = TestReadAttributeNullableInt8sMinValue_196(); break; case 197: - ChipLogProgress(chipTool, " ***** Test Step 197 : Read attribute NULLABLE_INT8S unchanged Value\n"); - err = TestReadAttributeNullableInt8sUnchangedValue_197(); + ChipLogProgress(chipTool, " ***** Test Step 197 : Write attribute NULLABLE_INT8S Invalid Value\n"); + err = TestWriteAttributeNullableInt8sInvalidValue_197(); break; case 198: - ChipLogProgress(chipTool, " ***** Test Step 198 : Write attribute NULLABLE_INT8S null Value\n"); - err = TestWriteAttributeNullableInt8sNullValue_198(); + ChipLogProgress(chipTool, " ***** Test Step 198 : Read attribute NULLABLE_INT8S unchanged Value\n"); + err = TestReadAttributeNullableInt8sUnchangedValue_198(); break; case 199: - ChipLogProgress(chipTool, " ***** Test Step 199 : Read attribute NULLABLE_INT8S null Value\n"); - err = TestReadAttributeNullableInt8sNullValue_199(); + ChipLogProgress(chipTool, " ***** Test Step 199 : Write attribute NULLABLE_INT8S null Value\n"); + err = TestWriteAttributeNullableInt8sNullValue_199(); break; case 200: - ChipLogProgress(chipTool, " ***** Test Step 200 : Write attribute NULLABLE_INT16S Min Value\n"); - err = TestWriteAttributeNullableInt16sMinValue_200(); + ChipLogProgress(chipTool, " ***** Test Step 200 : Read attribute NULLABLE_INT8S null Value\n"); + err = TestReadAttributeNullableInt8sNullValue_200(); break; case 201: - ChipLogProgress(chipTool, " ***** Test Step 201 : Read attribute NULLABLE_INT16S Min Value\n"); - err = TestReadAttributeNullableInt16sMinValue_201(); + ChipLogProgress(chipTool, " ***** Test Step 201 : Write attribute NULLABLE_INT16S Min Value\n"); + err = TestWriteAttributeNullableInt16sMinValue_201(); break; case 202: - ChipLogProgress(chipTool, " ***** Test Step 202 : Write attribute NULLABLE_INT16S Invalid Value\n"); - err = TestWriteAttributeNullableInt16sInvalidValue_202(); + ChipLogProgress(chipTool, " ***** Test Step 202 : Read attribute NULLABLE_INT16S Min Value\n"); + err = TestReadAttributeNullableInt16sMinValue_202(); break; case 203: - ChipLogProgress(chipTool, " ***** Test Step 203 : Read attribute NULLABLE_INT16S unchanged Value\n"); - err = TestReadAttributeNullableInt16sUnchangedValue_203(); + ChipLogProgress(chipTool, " ***** Test Step 203 : Write attribute NULLABLE_INT16S Invalid Value\n"); + err = TestWriteAttributeNullableInt16sInvalidValue_203(); break; case 204: - ChipLogProgress(chipTool, " ***** Test Step 204 : Write attribute NULLABLE_INT16S null Value\n"); - err = TestWriteAttributeNullableInt16sNullValue_204(); + ChipLogProgress(chipTool, " ***** Test Step 204 : Read attribute NULLABLE_INT16S unchanged Value\n"); + err = TestReadAttributeNullableInt16sUnchangedValue_204(); break; case 205: - ChipLogProgress(chipTool, " ***** Test Step 205 : Read attribute NULLABLE_INT16S null Value\n"); - err = TestReadAttributeNullableInt16sNullValue_205(); + ChipLogProgress(chipTool, " ***** Test Step 205 : Write attribute NULLABLE_INT16S null Value\n"); + err = TestWriteAttributeNullableInt16sNullValue_205(); break; case 206: - ChipLogProgress(chipTool, " ***** Test Step 206 : Write attribute NULLABLE_INT32S Min Value\n"); - err = TestWriteAttributeNullableInt32sMinValue_206(); + ChipLogProgress(chipTool, " ***** Test Step 206 : Read attribute NULLABLE_INT16S null Value\n"); + err = TestReadAttributeNullableInt16sNullValue_206(); break; case 207: - ChipLogProgress(chipTool, " ***** Test Step 207 : Read attribute NULLABLE_INT32S Min Value\n"); - err = TestReadAttributeNullableInt32sMinValue_207(); + ChipLogProgress(chipTool, " ***** Test Step 207 : Write attribute NULLABLE_INT32S Min Value\n"); + err = TestWriteAttributeNullableInt32sMinValue_207(); break; case 208: - ChipLogProgress(chipTool, " ***** Test Step 208 : Write attribute NULLABLE_INT32S Invalid Value\n"); - err = TestWriteAttributeNullableInt32sInvalidValue_208(); + ChipLogProgress(chipTool, " ***** Test Step 208 : Read attribute NULLABLE_INT32S Min Value\n"); + err = TestReadAttributeNullableInt32sMinValue_208(); break; case 209: - ChipLogProgress(chipTool, " ***** Test Step 209 : Read attribute NULLABLE_INT32S unchanged Value\n"); - err = TestReadAttributeNullableInt32sUnchangedValue_209(); + ChipLogProgress(chipTool, " ***** Test Step 209 : Write attribute NULLABLE_INT32S Invalid Value\n"); + err = TestWriteAttributeNullableInt32sInvalidValue_209(); break; case 210: - ChipLogProgress(chipTool, " ***** Test Step 210 : Write attribute NULLABLE_INT32S null Value\n"); - err = TestWriteAttributeNullableInt32sNullValue_210(); + ChipLogProgress(chipTool, " ***** Test Step 210 : Read attribute NULLABLE_INT32S unchanged Value\n"); + err = TestReadAttributeNullableInt32sUnchangedValue_210(); break; case 211: - ChipLogProgress(chipTool, " ***** Test Step 211 : Read attribute NULLABLE_INT32S null Value\n"); - err = TestReadAttributeNullableInt32sNullValue_211(); + ChipLogProgress(chipTool, " ***** Test Step 211 : Write attribute NULLABLE_INT32S null Value\n"); + err = TestWriteAttributeNullableInt32sNullValue_211(); break; case 212: - ChipLogProgress(chipTool, " ***** Test Step 212 : Write attribute NULLABLE_INT64S Min Value\n"); - err = TestWriteAttributeNullableInt64sMinValue_212(); + ChipLogProgress(chipTool, " ***** Test Step 212 : Read attribute NULLABLE_INT32S null Value\n"); + err = TestReadAttributeNullableInt32sNullValue_212(); break; case 213: - ChipLogProgress(chipTool, " ***** Test Step 213 : Read attribute NULLABLE_INT64S Min Value\n"); - err = TestReadAttributeNullableInt64sMinValue_213(); + ChipLogProgress(chipTool, " ***** Test Step 213 : Write attribute NULLABLE_INT64S Min Value\n"); + err = TestWriteAttributeNullableInt64sMinValue_213(); break; case 214: - ChipLogProgress(chipTool, " ***** Test Step 214 : Write attribute NULLABLE_INT64S Invalid Value\n"); - err = TestWriteAttributeNullableInt64sInvalidValue_214(); + ChipLogProgress(chipTool, " ***** Test Step 214 : Read attribute NULLABLE_INT64S Min Value\n"); + err = TestReadAttributeNullableInt64sMinValue_214(); break; case 215: - ChipLogProgress(chipTool, " ***** Test Step 215 : Read attribute NULLABLE_INT64S unchanged Value\n"); - err = TestReadAttributeNullableInt64sUnchangedValue_215(); + ChipLogProgress(chipTool, " ***** Test Step 215 : Write attribute NULLABLE_INT64S Invalid Value\n"); + err = TestWriteAttributeNullableInt64sInvalidValue_215(); break; case 216: - ChipLogProgress(chipTool, " ***** Test Step 216 : Write attribute NULLABLE_INT64S null Value\n"); - err = TestWriteAttributeNullableInt64sNullValue_216(); + ChipLogProgress(chipTool, " ***** Test Step 216 : Read attribute NULLABLE_INT64S unchanged Value\n"); + err = TestReadAttributeNullableInt64sUnchangedValue_216(); break; case 217: - ChipLogProgress(chipTool, " ***** Test Step 217 : Read attribute NULLABLE_INT64S null Value\n"); - err = TestReadAttributeNullableInt64sNullValue_217(); + ChipLogProgress(chipTool, " ***** Test Step 217 : Write attribute NULLABLE_INT64S null Value\n"); + err = TestWriteAttributeNullableInt64sNullValue_217(); break; case 218: - ChipLogProgress(chipTool, " ***** Test Step 218 : Write attribute NULLABLE_ENUM8 Max Value\n"); - err = TestWriteAttributeNullableEnum8MaxValue_218(); + ChipLogProgress(chipTool, " ***** Test Step 218 : Read attribute NULLABLE_INT64S null Value\n"); + err = TestReadAttributeNullableInt64sNullValue_218(); break; case 219: - ChipLogProgress(chipTool, " ***** Test Step 219 : Read attribute NULLABLE_ENUM8 Max Value\n"); - err = TestReadAttributeNullableEnum8MaxValue_219(); + ChipLogProgress(chipTool, " ***** Test Step 219 : Write attribute NULLABLE_ENUM8 Max Value\n"); + err = TestWriteAttributeNullableEnum8MaxValue_219(); break; case 220: - ChipLogProgress(chipTool, " ***** Test Step 220 : Write attribute NULLABLE_ENUM8 Invalid Value\n"); - err = TestWriteAttributeNullableEnum8InvalidValue_220(); + ChipLogProgress(chipTool, " ***** Test Step 220 : Read attribute NULLABLE_ENUM8 Max Value\n"); + err = TestReadAttributeNullableEnum8MaxValue_220(); break; case 221: - ChipLogProgress(chipTool, " ***** Test Step 221 : Read attribute NULLABLE_ENUM8 unchanged Value\n"); - err = TestReadAttributeNullableEnum8UnchangedValue_221(); + ChipLogProgress(chipTool, " ***** Test Step 221 : Write attribute NULLABLE_ENUM8 Invalid Value\n"); + err = TestWriteAttributeNullableEnum8InvalidValue_221(); break; case 222: - ChipLogProgress(chipTool, " ***** Test Step 222 : Write attribute NULLABLE_ENUM8 null Value\n"); - err = TestWriteAttributeNullableEnum8NullValue_222(); + ChipLogProgress(chipTool, " ***** Test Step 222 : Read attribute NULLABLE_ENUM8 unchanged Value\n"); + err = TestReadAttributeNullableEnum8UnchangedValue_222(); break; case 223: - ChipLogProgress(chipTool, " ***** Test Step 223 : Read attribute NULLABLE_ENUM8 null Value\n"); - err = TestReadAttributeNullableEnum8NullValue_223(); + ChipLogProgress(chipTool, " ***** Test Step 223 : Write attribute NULLABLE_ENUM8 null Value\n"); + err = TestWriteAttributeNullableEnum8NullValue_223(); break; case 224: - ChipLogProgress(chipTool, " ***** Test Step 224 : Write attribute NULLABLE_ENUM16 Max Value\n"); - err = TestWriteAttributeNullableEnum16MaxValue_224(); + ChipLogProgress(chipTool, " ***** Test Step 224 : Read attribute NULLABLE_ENUM8 null Value\n"); + err = TestReadAttributeNullableEnum8NullValue_224(); break; case 225: - ChipLogProgress(chipTool, " ***** Test Step 225 : Read attribute NULLABLE_ENUM16 Max Value\n"); - err = TestReadAttributeNullableEnum16MaxValue_225(); + ChipLogProgress(chipTool, " ***** Test Step 225 : Write attribute NULLABLE_ENUM16 Max Value\n"); + err = TestWriteAttributeNullableEnum16MaxValue_225(); break; case 226: - ChipLogProgress(chipTool, " ***** Test Step 226 : Write attribute NULLABLE_ENUM16 Invalid Value\n"); - err = TestWriteAttributeNullableEnum16InvalidValue_226(); + ChipLogProgress(chipTool, " ***** Test Step 226 : Read attribute NULLABLE_ENUM16 Max Value\n"); + err = TestReadAttributeNullableEnum16MaxValue_226(); break; case 227: - ChipLogProgress(chipTool, " ***** Test Step 227 : Read attribute NULLABLE_ENUM16 unchanged Value\n"); - err = TestReadAttributeNullableEnum16UnchangedValue_227(); + ChipLogProgress(chipTool, " ***** Test Step 227 : Write attribute NULLABLE_ENUM16 Invalid Value\n"); + err = TestWriteAttributeNullableEnum16InvalidValue_227(); break; case 228: - ChipLogProgress(chipTool, " ***** Test Step 228 : Write attribute NULLABLE_ENUM16 null Value\n"); - err = TestWriteAttributeNullableEnum16NullValue_228(); + ChipLogProgress(chipTool, " ***** Test Step 228 : Read attribute NULLABLE_ENUM16 unchanged Value\n"); + err = TestReadAttributeNullableEnum16UnchangedValue_228(); break; case 229: - ChipLogProgress(chipTool, " ***** Test Step 229 : Read attribute NULLABLE_ENUM16 null Value\n"); - err = TestReadAttributeNullableEnum16NullValue_229(); + ChipLogProgress(chipTool, " ***** Test Step 229 : Write attribute NULLABLE_ENUM16 null Value\n"); + err = TestWriteAttributeNullableEnum16NullValue_229(); break; case 230: - ChipLogProgress(chipTool, " ***** Test Step 230 : Read attribute NULLABLE_OCTET_STRING Default Value\n"); - err = TestReadAttributeNullableOctetStringDefaultValue_230(); + ChipLogProgress(chipTool, " ***** Test Step 230 : Read attribute NULLABLE_ENUM16 null Value\n"); + err = TestReadAttributeNullableEnum16NullValue_230(); break; case 231: - ChipLogProgress(chipTool, " ***** Test Step 231 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_231(); + ChipLogProgress(chipTool, " ***** Test Step 231 : Read attribute NULLABLE_OCTET_STRING Default Value\n"); + err = TestReadAttributeNullableOctetStringDefaultValue_231(); break; case 232: - ChipLogProgress(chipTool, " ***** Test Step 232 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_232(); + ChipLogProgress(chipTool, " ***** Test Step 232 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_232(); break; case 233: - ChipLogProgress(chipTool, " ***** Test Step 233 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_233(); + ChipLogProgress(chipTool, " ***** Test Step 233 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_233(); break; case 234: - ChipLogProgress(chipTool, " ***** Test Step 234 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_234(); + ChipLogProgress(chipTool, " ***** Test Step 234 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_234(); break; case 235: - ChipLogProgress(chipTool, " ***** Test Step 235 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_235(); + ChipLogProgress(chipTool, " ***** Test Step 235 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_235(); break; case 236: - ChipLogProgress(chipTool, " ***** Test Step 236 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_236(); + ChipLogProgress(chipTool, " ***** Test Step 236 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_236(); break; case 237: - ChipLogProgress(chipTool, " ***** Test Step 237 : Read attribute NULLABLE_CHAR_STRING Default Value\n"); - err = TestReadAttributeNullableCharStringDefaultValue_237(); + ChipLogProgress(chipTool, " ***** Test Step 237 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_237(); break; case 238: - ChipLogProgress(chipTool, " ***** Test Step 238 : Write attribute NULLABLE_CHAR_STRING\n"); - err = TestWriteAttributeNullableCharString_238(); + ChipLogProgress(chipTool, " ***** Test Step 238 : Read attribute NULLABLE_CHAR_STRING Default Value\n"); + err = TestReadAttributeNullableCharStringDefaultValue_238(); break; case 239: - ChipLogProgress(chipTool, " ***** Test Step 239 : Write attribute NULLABLE_CHAR_STRING - Value too long\n"); - err = TestWriteAttributeNullableCharStringValueTooLong_239(); + ChipLogProgress(chipTool, " ***** Test Step 239 : Write attribute NULLABLE_CHAR_STRING\n"); + err = TestWriteAttributeNullableCharString_239(); break; case 240: - ChipLogProgress(chipTool, " ***** Test Step 240 : Read attribute NULLABLE_CHAR_STRING\n"); - err = TestReadAttributeNullableCharString_240(); + ChipLogProgress(chipTool, " ***** Test Step 240 : Write attribute NULLABLE_CHAR_STRING - Value too long\n"); + err = TestWriteAttributeNullableCharStringValueTooLong_240(); break; case 241: - ChipLogProgress(chipTool, " ***** Test Step 241 : Write attribute NULLABLE_CHAR_STRING - Empty\n"); - err = TestWriteAttributeNullableCharStringEmpty_241(); + ChipLogProgress(chipTool, " ***** Test Step 241 : Read attribute NULLABLE_CHAR_STRING\n"); + err = TestReadAttributeNullableCharString_241(); break; case 242: - ChipLogProgress(chipTool, " ***** Test Step 242 : Read attribute NULLABLE_CHAR_STRING\n"); - err = TestReadAttributeNullableCharString_242(); + ChipLogProgress(chipTool, " ***** Test Step 242 : Write attribute NULLABLE_CHAR_STRING - Empty\n"); + err = TestWriteAttributeNullableCharStringEmpty_242(); break; case 243: - ChipLogProgress(chipTool, " ***** Test Step 243 : Read nonexistent attribute.\n"); - err = TestReadNonexistentAttribute_243(); + ChipLogProgress(chipTool, " ***** Test Step 243 : Read attribute NULLABLE_CHAR_STRING\n"); + err = TestReadAttributeNullableCharString_243(); + break; + case 244: + ChipLogProgress(chipTool, " ***** Test Step 244 : Read nonexistent attribute.\n"); + err = TestReadNonexistentAttribute_244(); break; } @@ -31214,7 +31218,7 @@ class TestCluster : public TestCommand private: std::atomic_uint16_t mTestIndex; - const uint16_t mTestCount = 244; + const uint16_t mTestCount = 245; static void OnFailureCallback_5(void * context, EmberAfStatus status) { @@ -32250,816 +32254,806 @@ class TestCluster : public TestCommand static void OnSuccessCallback_124(void * context) { (static_cast(context))->OnSuccessResponse_124(); } - static void OnFailureCallback_134(void * context, EmberAfStatus status) - { - (static_cast(context))->OnFailureResponse_134(chip::to_underlying(status)); - } - - static void OnSuccessCallback_134(void * context) { (static_cast(context))->OnSuccessResponse_134(); } - static void OnFailureCallback_135(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_135(chip::to_underlying(status)); } - static void OnSuccessCallback_135(void * context, const chip::app::DataModel::DecodableList & listInt8u) - { - (static_cast(context))->OnSuccessResponse_135(listInt8u); - } + static void OnSuccessCallback_135(void * context) { (static_cast(context))->OnSuccessResponse_135(); } static void OnFailureCallback_136(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_136(chip::to_underlying(status)); } - static void OnSuccessCallback_136(void * context) { (static_cast(context))->OnSuccessResponse_136(); } + static void OnSuccessCallback_136(void * context, const chip::app::DataModel::DecodableList & listInt8u) + { + (static_cast(context))->OnSuccessResponse_136(listInt8u); + } static void OnFailureCallback_137(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_137(chip::to_underlying(status)); } - static void OnSuccessCallback_137(void * context, const chip::app::DataModel::DecodableList & listOctetString) - { - (static_cast(context))->OnSuccessResponse_137(listOctetString); - } + static void OnSuccessCallback_137(void * context) { (static_cast(context))->OnSuccessResponse_137(); } static void OnFailureCallback_138(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_138(chip::to_underlying(status)); } - static void OnSuccessCallback_138(void * context) { (static_cast(context))->OnSuccessResponse_138(); } + static void OnSuccessCallback_138(void * context, const chip::app::DataModel::DecodableList & listOctetString) + { + (static_cast(context))->OnSuccessResponse_138(listOctetString); + } static void OnFailureCallback_139(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_139(chip::to_underlying(status)); } - static void OnSuccessCallback_139( - void * context, - const chip::app::DataModel::DecodableList & - listStructOctetString) + static void OnSuccessCallback_139(void * context) { (static_cast(context))->OnSuccessResponse_139(); } + + static void OnFailureCallback_140(void * context, EmberAfStatus status) { - (static_cast(context))->OnSuccessResponse_139(listStructOctetString); + (static_cast(context))->OnFailureResponse_140(chip::to_underlying(status)); } - static void OnFailureCallback_142(void * context, EmberAfStatus status) + static void OnSuccessCallback_140( + void * context, + const chip::app::DataModel::DecodableList & + listStructOctetString) { - (static_cast(context))->OnFailureResponse_142(chip::to_underlying(status)); + (static_cast(context))->OnSuccessResponse_140(listStructOctetString); } - static void OnSuccessCallback_142(void * context) { (static_cast(context))->OnSuccessResponse_142(); } - static void OnFailureCallback_143(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_143(chip::to_underlying(status)); } - static void OnSuccessCallback_143(void * context, const chip::app::DataModel::Nullable & nullableBoolean) - { - (static_cast(context))->OnSuccessResponse_143(nullableBoolean); - } + static void OnSuccessCallback_143(void * context) { (static_cast(context))->OnSuccessResponse_143(); } static void OnFailureCallback_144(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_144(chip::to_underlying(status)); } - static void OnSuccessCallback_144(void * context) { (static_cast(context))->OnSuccessResponse_144(); } + static void OnSuccessCallback_144(void * context, const chip::app::DataModel::Nullable & nullableBoolean) + { + (static_cast(context))->OnSuccessResponse_144(nullableBoolean); + } static void OnFailureCallback_145(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_145(chip::to_underlying(status)); } - static void OnSuccessCallback_145(void * context, const chip::app::DataModel::Nullable & nullableBoolean) - { - (static_cast(context))->OnSuccessResponse_145(nullableBoolean); - } + static void OnSuccessCallback_145(void * context) { (static_cast(context))->OnSuccessResponse_145(); } static void OnFailureCallback_146(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_146(chip::to_underlying(status)); } - static void OnSuccessCallback_146(void * context) { (static_cast(context))->OnSuccessResponse_146(); } + static void OnSuccessCallback_146(void * context, const chip::app::DataModel::Nullable & nullableBoolean) + { + (static_cast(context))->OnSuccessResponse_146(nullableBoolean); + } static void OnFailureCallback_147(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_147(chip::to_underlying(status)); } - static void OnSuccessCallback_147(void * context, const chip::app::DataModel::Nullable & nullableBitmap8) - { - (static_cast(context))->OnSuccessResponse_147(nullableBitmap8); - } + static void OnSuccessCallback_147(void * context) { (static_cast(context))->OnSuccessResponse_147(); } static void OnFailureCallback_148(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_148(chip::to_underlying(status)); } - static void OnSuccessCallback_148(void * context) { (static_cast(context))->OnSuccessResponse_148(); } + static void OnSuccessCallback_148(void * context, const chip::app::DataModel::Nullable & nullableBitmap8) + { + (static_cast(context))->OnSuccessResponse_148(nullableBitmap8); + } static void OnFailureCallback_149(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_149(chip::to_underlying(status)); } - static void OnSuccessCallback_149(void * context, const chip::app::DataModel::Nullable & nullableBitmap8) - { - (static_cast(context))->OnSuccessResponse_149(nullableBitmap8); - } + static void OnSuccessCallback_149(void * context) { (static_cast(context))->OnSuccessResponse_149(); } static void OnFailureCallback_150(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_150(chip::to_underlying(status)); } - static void OnSuccessCallback_150(void * context) { (static_cast(context))->OnSuccessResponse_150(); } + static void OnSuccessCallback_150(void * context, const chip::app::DataModel::Nullable & nullableBitmap8) + { + (static_cast(context))->OnSuccessResponse_150(nullableBitmap8); + } static void OnFailureCallback_151(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_151(chip::to_underlying(status)); } - static void OnSuccessCallback_151(void * context, const chip::app::DataModel::Nullable & nullableBitmap8) - { - (static_cast(context))->OnSuccessResponse_151(nullableBitmap8); - } + static void OnSuccessCallback_151(void * context) { (static_cast(context))->OnSuccessResponse_151(); } static void OnFailureCallback_152(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_152(chip::to_underlying(status)); } - static void OnSuccessCallback_152(void * context) { (static_cast(context))->OnSuccessResponse_152(); } + static void OnSuccessCallback_152(void * context, const chip::app::DataModel::Nullable & nullableBitmap8) + { + (static_cast(context))->OnSuccessResponse_152(nullableBitmap8); + } static void OnFailureCallback_153(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_153(chip::to_underlying(status)); } - static void OnSuccessCallback_153(void * context, const chip::app::DataModel::Nullable & nullableBitmap16) - { - (static_cast(context))->OnSuccessResponse_153(nullableBitmap16); - } + static void OnSuccessCallback_153(void * context) { (static_cast(context))->OnSuccessResponse_153(); } static void OnFailureCallback_154(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_154(chip::to_underlying(status)); } - static void OnSuccessCallback_154(void * context) { (static_cast(context))->OnSuccessResponse_154(); } + static void OnSuccessCallback_154(void * context, const chip::app::DataModel::Nullable & nullableBitmap16) + { + (static_cast(context))->OnSuccessResponse_154(nullableBitmap16); + } static void OnFailureCallback_155(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_155(chip::to_underlying(status)); } - static void OnSuccessCallback_155(void * context, const chip::app::DataModel::Nullable & nullableBitmap16) - { - (static_cast(context))->OnSuccessResponse_155(nullableBitmap16); - } + static void OnSuccessCallback_155(void * context) { (static_cast(context))->OnSuccessResponse_155(); } static void OnFailureCallback_156(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_156(chip::to_underlying(status)); } - static void OnSuccessCallback_156(void * context) { (static_cast(context))->OnSuccessResponse_156(); } + static void OnSuccessCallback_156(void * context, const chip::app::DataModel::Nullable & nullableBitmap16) + { + (static_cast(context))->OnSuccessResponse_156(nullableBitmap16); + } static void OnFailureCallback_157(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_157(chip::to_underlying(status)); } - static void OnSuccessCallback_157(void * context, const chip::app::DataModel::Nullable & nullableBitmap16) - { - (static_cast(context))->OnSuccessResponse_157(nullableBitmap16); - } + static void OnSuccessCallback_157(void * context) { (static_cast(context))->OnSuccessResponse_157(); } static void OnFailureCallback_158(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_158(chip::to_underlying(status)); } - static void OnSuccessCallback_158(void * context) { (static_cast(context))->OnSuccessResponse_158(); } + static void OnSuccessCallback_158(void * context, const chip::app::DataModel::Nullable & nullableBitmap16) + { + (static_cast(context))->OnSuccessResponse_158(nullableBitmap16); + } static void OnFailureCallback_159(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_159(chip::to_underlying(status)); } - static void OnSuccessCallback_159(void * context, const chip::app::DataModel::Nullable & nullableBitmap32) - { - (static_cast(context))->OnSuccessResponse_159(nullableBitmap32); - } + static void OnSuccessCallback_159(void * context) { (static_cast(context))->OnSuccessResponse_159(); } static void OnFailureCallback_160(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_160(chip::to_underlying(status)); } - static void OnSuccessCallback_160(void * context) { (static_cast(context))->OnSuccessResponse_160(); } + static void OnSuccessCallback_160(void * context, const chip::app::DataModel::Nullable & nullableBitmap32) + { + (static_cast(context))->OnSuccessResponse_160(nullableBitmap32); + } static void OnFailureCallback_161(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_161(chip::to_underlying(status)); } - static void OnSuccessCallback_161(void * context, const chip::app::DataModel::Nullable & nullableBitmap32) - { - (static_cast(context))->OnSuccessResponse_161(nullableBitmap32); - } + static void OnSuccessCallback_161(void * context) { (static_cast(context))->OnSuccessResponse_161(); } static void OnFailureCallback_162(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_162(chip::to_underlying(status)); } - static void OnSuccessCallback_162(void * context) { (static_cast(context))->OnSuccessResponse_162(); } + static void OnSuccessCallback_162(void * context, const chip::app::DataModel::Nullable & nullableBitmap32) + { + (static_cast(context))->OnSuccessResponse_162(nullableBitmap32); + } static void OnFailureCallback_163(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_163(chip::to_underlying(status)); } - static void OnSuccessCallback_163(void * context, const chip::app::DataModel::Nullable & nullableBitmap32) - { - (static_cast(context))->OnSuccessResponse_163(nullableBitmap32); - } + static void OnSuccessCallback_163(void * context) { (static_cast(context))->OnSuccessResponse_163(); } static void OnFailureCallback_164(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_164(chip::to_underlying(status)); } - static void OnSuccessCallback_164(void * context) { (static_cast(context))->OnSuccessResponse_164(); } + static void OnSuccessCallback_164(void * context, const chip::app::DataModel::Nullable & nullableBitmap32) + { + (static_cast(context))->OnSuccessResponse_164(nullableBitmap32); + } static void OnFailureCallback_165(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_165(chip::to_underlying(status)); } - static void OnSuccessCallback_165(void * context, const chip::app::DataModel::Nullable & nullableBitmap64) - { - (static_cast(context))->OnSuccessResponse_165(nullableBitmap64); - } + static void OnSuccessCallback_165(void * context) { (static_cast(context))->OnSuccessResponse_165(); } static void OnFailureCallback_166(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_166(chip::to_underlying(status)); } - static void OnSuccessCallback_166(void * context) { (static_cast(context))->OnSuccessResponse_166(); } + static void OnSuccessCallback_166(void * context, const chip::app::DataModel::Nullable & nullableBitmap64) + { + (static_cast(context))->OnSuccessResponse_166(nullableBitmap64); + } static void OnFailureCallback_167(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_167(chip::to_underlying(status)); } - static void OnSuccessCallback_167(void * context, const chip::app::DataModel::Nullable & nullableBitmap64) - { - (static_cast(context))->OnSuccessResponse_167(nullableBitmap64); - } + static void OnSuccessCallback_167(void * context) { (static_cast(context))->OnSuccessResponse_167(); } static void OnFailureCallback_168(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_168(chip::to_underlying(status)); } - static void OnSuccessCallback_168(void * context) { (static_cast(context))->OnSuccessResponse_168(); } + static void OnSuccessCallback_168(void * context, const chip::app::DataModel::Nullable & nullableBitmap64) + { + (static_cast(context))->OnSuccessResponse_168(nullableBitmap64); + } static void OnFailureCallback_169(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_169(chip::to_underlying(status)); } - static void OnSuccessCallback_169(void * context, const chip::app::DataModel::Nullable & nullableBitmap64) - { - (static_cast(context))->OnSuccessResponse_169(nullableBitmap64); - } + static void OnSuccessCallback_169(void * context) { (static_cast(context))->OnSuccessResponse_169(); } static void OnFailureCallback_170(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_170(chip::to_underlying(status)); } - static void OnSuccessCallback_170(void * context) { (static_cast(context))->OnSuccessResponse_170(); } + static void OnSuccessCallback_170(void * context, const chip::app::DataModel::Nullable & nullableBitmap64) + { + (static_cast(context))->OnSuccessResponse_170(nullableBitmap64); + } static void OnFailureCallback_171(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_171(chip::to_underlying(status)); } - static void OnSuccessCallback_171(void * context, const chip::app::DataModel::Nullable & nullableInt8u) - { - (static_cast(context))->OnSuccessResponse_171(nullableInt8u); - } + static void OnSuccessCallback_171(void * context) { (static_cast(context))->OnSuccessResponse_171(); } static void OnFailureCallback_172(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_172(chip::to_underlying(status)); } - static void OnSuccessCallback_172(void * context) { (static_cast(context))->OnSuccessResponse_172(); } + static void OnSuccessCallback_172(void * context, const chip::app::DataModel::Nullable & nullableInt8u) + { + (static_cast(context))->OnSuccessResponse_172(nullableInt8u); + } static void OnFailureCallback_173(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_173(chip::to_underlying(status)); } - static void OnSuccessCallback_173(void * context, const chip::app::DataModel::Nullable & nullableInt8u) - { - (static_cast(context))->OnSuccessResponse_173(nullableInt8u); - } + static void OnSuccessCallback_173(void * context) { (static_cast(context))->OnSuccessResponse_173(); } static void OnFailureCallback_174(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_174(chip::to_underlying(status)); } - static void OnSuccessCallback_174(void * context) { (static_cast(context))->OnSuccessResponse_174(); } + static void OnSuccessCallback_174(void * context, const chip::app::DataModel::Nullable & nullableInt8u) + { + (static_cast(context))->OnSuccessResponse_174(nullableInt8u); + } static void OnFailureCallback_175(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_175(chip::to_underlying(status)); } - static void OnSuccessCallback_175(void * context, const chip::app::DataModel::Nullable & nullableInt8u) - { - (static_cast(context))->OnSuccessResponse_175(nullableInt8u); - } + static void OnSuccessCallback_175(void * context) { (static_cast(context))->OnSuccessResponse_175(); } static void OnFailureCallback_176(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_176(chip::to_underlying(status)); } - static void OnSuccessCallback_176(void * context) { (static_cast(context))->OnSuccessResponse_176(); } + static void OnSuccessCallback_176(void * context, const chip::app::DataModel::Nullable & nullableInt8u) + { + (static_cast(context))->OnSuccessResponse_176(nullableInt8u); + } static void OnFailureCallback_177(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_177(chip::to_underlying(status)); } - static void OnSuccessCallback_177(void * context, const chip::app::DataModel::Nullable & nullableInt16u) - { - (static_cast(context))->OnSuccessResponse_177(nullableInt16u); - } + static void OnSuccessCallback_177(void * context) { (static_cast(context))->OnSuccessResponse_177(); } static void OnFailureCallback_178(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_178(chip::to_underlying(status)); } - static void OnSuccessCallback_178(void * context) { (static_cast(context))->OnSuccessResponse_178(); } + static void OnSuccessCallback_178(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + { + (static_cast(context))->OnSuccessResponse_178(nullableInt16u); + } static void OnFailureCallback_179(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_179(chip::to_underlying(status)); } - static void OnSuccessCallback_179(void * context, const chip::app::DataModel::Nullable & nullableInt16u) - { - (static_cast(context))->OnSuccessResponse_179(nullableInt16u); - } + static void OnSuccessCallback_179(void * context) { (static_cast(context))->OnSuccessResponse_179(); } static void OnFailureCallback_180(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_180(chip::to_underlying(status)); } - static void OnSuccessCallback_180(void * context) { (static_cast(context))->OnSuccessResponse_180(); } + static void OnSuccessCallback_180(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + { + (static_cast(context))->OnSuccessResponse_180(nullableInt16u); + } static void OnFailureCallback_181(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_181(chip::to_underlying(status)); } - static void OnSuccessCallback_181(void * context, const chip::app::DataModel::Nullable & nullableInt16u) - { - (static_cast(context))->OnSuccessResponse_181(nullableInt16u); - } + static void OnSuccessCallback_181(void * context) { (static_cast(context))->OnSuccessResponse_181(); } static void OnFailureCallback_182(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_182(chip::to_underlying(status)); } - static void OnSuccessCallback_182(void * context) { (static_cast(context))->OnSuccessResponse_182(); } + static void OnSuccessCallback_182(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + { + (static_cast(context))->OnSuccessResponse_182(nullableInt16u); + } static void OnFailureCallback_183(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_183(chip::to_underlying(status)); } - static void OnSuccessCallback_183(void * context, const chip::app::DataModel::Nullable & nullableInt32u) - { - (static_cast(context))->OnSuccessResponse_183(nullableInt32u); - } + static void OnSuccessCallback_183(void * context) { (static_cast(context))->OnSuccessResponse_183(); } static void OnFailureCallback_184(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_184(chip::to_underlying(status)); } - static void OnSuccessCallback_184(void * context) { (static_cast(context))->OnSuccessResponse_184(); } + static void OnSuccessCallback_184(void * context, const chip::app::DataModel::Nullable & nullableInt32u) + { + (static_cast(context))->OnSuccessResponse_184(nullableInt32u); + } static void OnFailureCallback_185(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_185(chip::to_underlying(status)); } - static void OnSuccessCallback_185(void * context, const chip::app::DataModel::Nullable & nullableInt32u) - { - (static_cast(context))->OnSuccessResponse_185(nullableInt32u); - } + static void OnSuccessCallback_185(void * context) { (static_cast(context))->OnSuccessResponse_185(); } static void OnFailureCallback_186(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_186(chip::to_underlying(status)); } - static void OnSuccessCallback_186(void * context) { (static_cast(context))->OnSuccessResponse_186(); } + static void OnSuccessCallback_186(void * context, const chip::app::DataModel::Nullable & nullableInt32u) + { + (static_cast(context))->OnSuccessResponse_186(nullableInt32u); + } static void OnFailureCallback_187(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_187(chip::to_underlying(status)); } - static void OnSuccessCallback_187(void * context, const chip::app::DataModel::Nullable & nullableInt32u) - { - (static_cast(context))->OnSuccessResponse_187(nullableInt32u); - } + static void OnSuccessCallback_187(void * context) { (static_cast(context))->OnSuccessResponse_187(); } static void OnFailureCallback_188(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_188(chip::to_underlying(status)); } - static void OnSuccessCallback_188(void * context) { (static_cast(context))->OnSuccessResponse_188(); } + static void OnSuccessCallback_188(void * context, const chip::app::DataModel::Nullable & nullableInt32u) + { + (static_cast(context))->OnSuccessResponse_188(nullableInt32u); + } static void OnFailureCallback_189(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_189(chip::to_underlying(status)); } - static void OnSuccessCallback_189(void * context, const chip::app::DataModel::Nullable & nullableInt64u) - { - (static_cast(context))->OnSuccessResponse_189(nullableInt64u); - } + static void OnSuccessCallback_189(void * context) { (static_cast(context))->OnSuccessResponse_189(); } static void OnFailureCallback_190(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_190(chip::to_underlying(status)); } - static void OnSuccessCallback_190(void * context) { (static_cast(context))->OnSuccessResponse_190(); } + static void OnSuccessCallback_190(void * context, const chip::app::DataModel::Nullable & nullableInt64u) + { + (static_cast(context))->OnSuccessResponse_190(nullableInt64u); + } static void OnFailureCallback_191(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_191(chip::to_underlying(status)); } - static void OnSuccessCallback_191(void * context, const chip::app::DataModel::Nullable & nullableInt64u) - { - (static_cast(context))->OnSuccessResponse_191(nullableInt64u); - } + static void OnSuccessCallback_191(void * context) { (static_cast(context))->OnSuccessResponse_191(); } static void OnFailureCallback_192(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_192(chip::to_underlying(status)); } - static void OnSuccessCallback_192(void * context) { (static_cast(context))->OnSuccessResponse_192(); } + static void OnSuccessCallback_192(void * context, const chip::app::DataModel::Nullable & nullableInt64u) + { + (static_cast(context))->OnSuccessResponse_192(nullableInt64u); + } static void OnFailureCallback_193(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_193(chip::to_underlying(status)); } - static void OnSuccessCallback_193(void * context, const chip::app::DataModel::Nullable & nullableInt64u) - { - (static_cast(context))->OnSuccessResponse_193(nullableInt64u); - } + static void OnSuccessCallback_193(void * context) { (static_cast(context))->OnSuccessResponse_193(); } static void OnFailureCallback_194(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_194(chip::to_underlying(status)); } - static void OnSuccessCallback_194(void * context) { (static_cast(context))->OnSuccessResponse_194(); } + static void OnSuccessCallback_194(void * context, const chip::app::DataModel::Nullable & nullableInt64u) + { + (static_cast(context))->OnSuccessResponse_194(nullableInt64u); + } static void OnFailureCallback_195(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_195(chip::to_underlying(status)); } - static void OnSuccessCallback_195(void * context, const chip::app::DataModel::Nullable & nullableInt8s) - { - (static_cast(context))->OnSuccessResponse_195(nullableInt8s); - } + static void OnSuccessCallback_195(void * context) { (static_cast(context))->OnSuccessResponse_195(); } static void OnFailureCallback_196(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_196(chip::to_underlying(status)); } - static void OnSuccessCallback_196(void * context) { (static_cast(context))->OnSuccessResponse_196(); } + static void OnSuccessCallback_196(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + { + (static_cast(context))->OnSuccessResponse_196(nullableInt8s); + } static void OnFailureCallback_197(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_197(chip::to_underlying(status)); } - static void OnSuccessCallback_197(void * context, const chip::app::DataModel::Nullable & nullableInt8s) - { - (static_cast(context))->OnSuccessResponse_197(nullableInt8s); - } + static void OnSuccessCallback_197(void * context) { (static_cast(context))->OnSuccessResponse_197(); } static void OnFailureCallback_198(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_198(chip::to_underlying(status)); } - static void OnSuccessCallback_198(void * context) { (static_cast(context))->OnSuccessResponse_198(); } + static void OnSuccessCallback_198(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + { + (static_cast(context))->OnSuccessResponse_198(nullableInt8s); + } static void OnFailureCallback_199(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_199(chip::to_underlying(status)); } - static void OnSuccessCallback_199(void * context, const chip::app::DataModel::Nullable & nullableInt8s) - { - (static_cast(context))->OnSuccessResponse_199(nullableInt8s); - } + static void OnSuccessCallback_199(void * context) { (static_cast(context))->OnSuccessResponse_199(); } static void OnFailureCallback_200(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_200(chip::to_underlying(status)); } - static void OnSuccessCallback_200(void * context) { (static_cast(context))->OnSuccessResponse_200(); } + static void OnSuccessCallback_200(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + { + (static_cast(context))->OnSuccessResponse_200(nullableInt8s); + } static void OnFailureCallback_201(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_201(chip::to_underlying(status)); } - static void OnSuccessCallback_201(void * context, const chip::app::DataModel::Nullable & nullableInt16s) - { - (static_cast(context))->OnSuccessResponse_201(nullableInt16s); - } + static void OnSuccessCallback_201(void * context) { (static_cast(context))->OnSuccessResponse_201(); } static void OnFailureCallback_202(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_202(chip::to_underlying(status)); } - static void OnSuccessCallback_202(void * context) { (static_cast(context))->OnSuccessResponse_202(); } + static void OnSuccessCallback_202(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + { + (static_cast(context))->OnSuccessResponse_202(nullableInt16s); + } static void OnFailureCallback_203(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_203(chip::to_underlying(status)); } - static void OnSuccessCallback_203(void * context, const chip::app::DataModel::Nullable & nullableInt16s) - { - (static_cast(context))->OnSuccessResponse_203(nullableInt16s); - } + static void OnSuccessCallback_203(void * context) { (static_cast(context))->OnSuccessResponse_203(); } static void OnFailureCallback_204(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_204(chip::to_underlying(status)); } - static void OnSuccessCallback_204(void * context) { (static_cast(context))->OnSuccessResponse_204(); } + static void OnSuccessCallback_204(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + { + (static_cast(context))->OnSuccessResponse_204(nullableInt16s); + } static void OnFailureCallback_205(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_205(chip::to_underlying(status)); } - static void OnSuccessCallback_205(void * context, const chip::app::DataModel::Nullable & nullableInt16s) - { - (static_cast(context))->OnSuccessResponse_205(nullableInt16s); - } + static void OnSuccessCallback_205(void * context) { (static_cast(context))->OnSuccessResponse_205(); } static void OnFailureCallback_206(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_206(chip::to_underlying(status)); } - static void OnSuccessCallback_206(void * context) { (static_cast(context))->OnSuccessResponse_206(); } + static void OnSuccessCallback_206(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + { + (static_cast(context))->OnSuccessResponse_206(nullableInt16s); + } static void OnFailureCallback_207(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_207(chip::to_underlying(status)); } - static void OnSuccessCallback_207(void * context, const chip::app::DataModel::Nullable & nullableInt32s) - { - (static_cast(context))->OnSuccessResponse_207(nullableInt32s); - } + static void OnSuccessCallback_207(void * context) { (static_cast(context))->OnSuccessResponse_207(); } static void OnFailureCallback_208(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_208(chip::to_underlying(status)); } - static void OnSuccessCallback_208(void * context) { (static_cast(context))->OnSuccessResponse_208(); } + static void OnSuccessCallback_208(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + { + (static_cast(context))->OnSuccessResponse_208(nullableInt32s); + } static void OnFailureCallback_209(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_209(chip::to_underlying(status)); } - static void OnSuccessCallback_209(void * context, const chip::app::DataModel::Nullable & nullableInt32s) - { - (static_cast(context))->OnSuccessResponse_209(nullableInt32s); - } + static void OnSuccessCallback_209(void * context) { (static_cast(context))->OnSuccessResponse_209(); } static void OnFailureCallback_210(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_210(chip::to_underlying(status)); } - static void OnSuccessCallback_210(void * context) { (static_cast(context))->OnSuccessResponse_210(); } + static void OnSuccessCallback_210(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + { + (static_cast(context))->OnSuccessResponse_210(nullableInt32s); + } static void OnFailureCallback_211(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_211(chip::to_underlying(status)); } - static void OnSuccessCallback_211(void * context, const chip::app::DataModel::Nullable & nullableInt32s) - { - (static_cast(context))->OnSuccessResponse_211(nullableInt32s); - } + static void OnSuccessCallback_211(void * context) { (static_cast(context))->OnSuccessResponse_211(); } static void OnFailureCallback_212(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_212(chip::to_underlying(status)); } - static void OnSuccessCallback_212(void * context) { (static_cast(context))->OnSuccessResponse_212(); } + static void OnSuccessCallback_212(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + { + (static_cast(context))->OnSuccessResponse_212(nullableInt32s); + } static void OnFailureCallback_213(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_213(chip::to_underlying(status)); } - static void OnSuccessCallback_213(void * context, const chip::app::DataModel::Nullable & nullableInt64s) - { - (static_cast(context))->OnSuccessResponse_213(nullableInt64s); - } + static void OnSuccessCallback_213(void * context) { (static_cast(context))->OnSuccessResponse_213(); } static void OnFailureCallback_214(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_214(chip::to_underlying(status)); } - static void OnSuccessCallback_214(void * context) { (static_cast(context))->OnSuccessResponse_214(); } + static void OnSuccessCallback_214(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + { + (static_cast(context))->OnSuccessResponse_214(nullableInt64s); + } static void OnFailureCallback_215(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_215(chip::to_underlying(status)); } - static void OnSuccessCallback_215(void * context, const chip::app::DataModel::Nullable & nullableInt64s) - { - (static_cast(context))->OnSuccessResponse_215(nullableInt64s); - } + static void OnSuccessCallback_215(void * context) { (static_cast(context))->OnSuccessResponse_215(); } static void OnFailureCallback_216(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_216(chip::to_underlying(status)); } - static void OnSuccessCallback_216(void * context) { (static_cast(context))->OnSuccessResponse_216(); } + static void OnSuccessCallback_216(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + { + (static_cast(context))->OnSuccessResponse_216(nullableInt64s); + } static void OnFailureCallback_217(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_217(chip::to_underlying(status)); } - static void OnSuccessCallback_217(void * context, const chip::app::DataModel::Nullable & nullableInt64s) - { - (static_cast(context))->OnSuccessResponse_217(nullableInt64s); - } + static void OnSuccessCallback_217(void * context) { (static_cast(context))->OnSuccessResponse_217(); } static void OnFailureCallback_218(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_218(chip::to_underlying(status)); } - static void OnSuccessCallback_218(void * context) { (static_cast(context))->OnSuccessResponse_218(); } + static void OnSuccessCallback_218(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + { + (static_cast(context))->OnSuccessResponse_218(nullableInt64s); + } static void OnFailureCallback_219(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_219(chip::to_underlying(status)); } - static void OnSuccessCallback_219(void * context, const chip::app::DataModel::Nullable & nullableEnum8) - { - (static_cast(context))->OnSuccessResponse_219(nullableEnum8); - } + static void OnSuccessCallback_219(void * context) { (static_cast(context))->OnSuccessResponse_219(); } static void OnFailureCallback_220(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_220(chip::to_underlying(status)); } - static void OnSuccessCallback_220(void * context) { (static_cast(context))->OnSuccessResponse_220(); } + static void OnSuccessCallback_220(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + { + (static_cast(context))->OnSuccessResponse_220(nullableEnum8); + } static void OnFailureCallback_221(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_221(chip::to_underlying(status)); } - static void OnSuccessCallback_221(void * context, const chip::app::DataModel::Nullable & nullableEnum8) - { - (static_cast(context))->OnSuccessResponse_221(nullableEnum8); - } + static void OnSuccessCallback_221(void * context) { (static_cast(context))->OnSuccessResponse_221(); } static void OnFailureCallback_222(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_222(chip::to_underlying(status)); } - static void OnSuccessCallback_222(void * context) { (static_cast(context))->OnSuccessResponse_222(); } + static void OnSuccessCallback_222(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + { + (static_cast(context))->OnSuccessResponse_222(nullableEnum8); + } static void OnFailureCallback_223(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_223(chip::to_underlying(status)); } - static void OnSuccessCallback_223(void * context, const chip::app::DataModel::Nullable & nullableEnum8) - { - (static_cast(context))->OnSuccessResponse_223(nullableEnum8); - } + static void OnSuccessCallback_223(void * context) { (static_cast(context))->OnSuccessResponse_223(); } static void OnFailureCallback_224(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_224(chip::to_underlying(status)); } - static void OnSuccessCallback_224(void * context) { (static_cast(context))->OnSuccessResponse_224(); } + static void OnSuccessCallback_224(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + { + (static_cast(context))->OnSuccessResponse_224(nullableEnum8); + } static void OnFailureCallback_225(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_225(chip::to_underlying(status)); } - static void OnSuccessCallback_225(void * context, const chip::app::DataModel::Nullable & nullableEnum16) - { - (static_cast(context))->OnSuccessResponse_225(nullableEnum16); - } + static void OnSuccessCallback_225(void * context) { (static_cast(context))->OnSuccessResponse_225(); } static void OnFailureCallback_226(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_226(chip::to_underlying(status)); } - static void OnSuccessCallback_226(void * context) { (static_cast(context))->OnSuccessResponse_226(); } + static void OnSuccessCallback_226(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + { + (static_cast(context))->OnSuccessResponse_226(nullableEnum16); + } static void OnFailureCallback_227(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_227(chip::to_underlying(status)); } - static void OnSuccessCallback_227(void * context, const chip::app::DataModel::Nullable & nullableEnum16) - { - (static_cast(context))->OnSuccessResponse_227(nullableEnum16); - } + static void OnSuccessCallback_227(void * context) { (static_cast(context))->OnSuccessResponse_227(); } static void OnFailureCallback_228(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_228(chip::to_underlying(status)); } - static void OnSuccessCallback_228(void * context) { (static_cast(context))->OnSuccessResponse_228(); } + static void OnSuccessCallback_228(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + { + (static_cast(context))->OnSuccessResponse_228(nullableEnum16); + } static void OnFailureCallback_229(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_229(chip::to_underlying(status)); } - static void OnSuccessCallback_229(void * context, const chip::app::DataModel::Nullable & nullableEnum16) - { - (static_cast(context))->OnSuccessResponse_229(nullableEnum16); - } + static void OnSuccessCallback_229(void * context) { (static_cast(context))->OnSuccessResponse_229(); } static void OnFailureCallback_230(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_230(chip::to_underlying(status)); } - static void OnSuccessCallback_230(void * context, const chip::app::DataModel::Nullable & nullableOctetString) + static void OnSuccessCallback_230(void * context, const chip::app::DataModel::Nullable & nullableEnum16) { - (static_cast(context))->OnSuccessResponse_230(nullableOctetString); + (static_cast(context))->OnSuccessResponse_230(nullableEnum16); } static void OnFailureCallback_231(void * context, EmberAfStatus status) @@ -33067,60 +33061,60 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_231(chip::to_underlying(status)); } - static void OnSuccessCallback_231(void * context) { (static_cast(context))->OnSuccessResponse_231(); } + static void OnSuccessCallback_231(void * context, const chip::app::DataModel::Nullable & nullableOctetString) + { + (static_cast(context))->OnSuccessResponse_231(nullableOctetString); + } static void OnFailureCallback_232(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_232(chip::to_underlying(status)); } - static void OnSuccessCallback_232(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_232(nullableOctetString); - } + static void OnSuccessCallback_232(void * context) { (static_cast(context))->OnSuccessResponse_232(); } static void OnFailureCallback_233(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_233(chip::to_underlying(status)); } - static void OnSuccessCallback_233(void * context) { (static_cast(context))->OnSuccessResponse_233(); } + static void OnSuccessCallback_233(void * context, const chip::app::DataModel::Nullable & nullableOctetString) + { + (static_cast(context))->OnSuccessResponse_233(nullableOctetString); + } static void OnFailureCallback_234(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_234(chip::to_underlying(status)); } - static void OnSuccessCallback_234(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_234(nullableOctetString); - } + static void OnSuccessCallback_234(void * context) { (static_cast(context))->OnSuccessResponse_234(); } static void OnFailureCallback_235(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_235(chip::to_underlying(status)); } - static void OnSuccessCallback_235(void * context) { (static_cast(context))->OnSuccessResponse_235(); } + static void OnSuccessCallback_235(void * context, const chip::app::DataModel::Nullable & nullableOctetString) + { + (static_cast(context))->OnSuccessResponse_235(nullableOctetString); + } static void OnFailureCallback_236(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_236(chip::to_underlying(status)); } - static void OnSuccessCallback_236(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_236(nullableOctetString); - } + static void OnSuccessCallback_236(void * context) { (static_cast(context))->OnSuccessResponse_236(); } static void OnFailureCallback_237(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_237(chip::to_underlying(status)); } - static void OnSuccessCallback_237(void * context, const chip::app::DataModel::Nullable & nullableCharString) + static void OnSuccessCallback_237(void * context, const chip::app::DataModel::Nullable & nullableOctetString) { - (static_cast(context))->OnSuccessResponse_237(nullableCharString); + (static_cast(context))->OnSuccessResponse_237(nullableOctetString); } static void OnFailureCallback_238(void * context, EmberAfStatus status) @@ -33128,7 +33122,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_238(chip::to_underlying(status)); } - static void OnSuccessCallback_238(void * context) { (static_cast(context))->OnSuccessResponse_238(); } + static void OnSuccessCallback_238(void * context, const chip::app::DataModel::Nullable & nullableCharString) + { + (static_cast(context))->OnSuccessResponse_238(nullableCharString); + } static void OnFailureCallback_239(void * context, EmberAfStatus status) { @@ -33142,36 +33139,43 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_240(chip::to_underlying(status)); } - static void OnSuccessCallback_240(void * context, const chip::app::DataModel::Nullable & nullableCharString) - { - (static_cast(context))->OnSuccessResponse_240(nullableCharString); - } + static void OnSuccessCallback_240(void * context) { (static_cast(context))->OnSuccessResponse_240(); } static void OnFailureCallback_241(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_241(chip::to_underlying(status)); } - static void OnSuccessCallback_241(void * context) { (static_cast(context))->OnSuccessResponse_241(); } + static void OnSuccessCallback_241(void * context, const chip::app::DataModel::Nullable & nullableCharString) + { + (static_cast(context))->OnSuccessResponse_241(nullableCharString); + } static void OnFailureCallback_242(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_242(chip::to_underlying(status)); } - static void OnSuccessCallback_242(void * context, const chip::app::DataModel::Nullable & nullableCharString) - { - (static_cast(context))->OnSuccessResponse_242(nullableCharString); - } + static void OnSuccessCallback_242(void * context) { (static_cast(context))->OnSuccessResponse_242(); } static void OnFailureCallback_243(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_243(chip::to_underlying(status)); } - static void OnSuccessCallback_243(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnSuccessCallback_243(void * context, const chip::app::DataModel::Nullable & nullableCharString) + { + (static_cast(context))->OnSuccessResponse_243(nullableCharString); + } + + static void OnFailureCallback_244(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_244(chip::to_underlying(status)); + } + + static void OnSuccessCallback_244(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnSuccessResponse_243(listInt8u); + (static_cast(context))->OnSuccessResponse_244(listInt8u); } // @@ -33247,7 +33251,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_2(uint8_t returnValue) { - VerifyOrReturn(CheckValue("returnValue", returnValue, 7)); + VerifyOrReturn(CheckValue("returnValue", returnValue, 7)); NextTest(); } @@ -33276,7 +33280,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_3(uint8_t returnValue) { - VerifyOrReturn(CheckValue("returnValue", returnValue, 20)); + VerifyOrReturn(CheckValue("returnValue", returnValue, 20)); NextTest(); } @@ -33319,7 +33323,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_5(bool boolean) { - VerifyOrReturn(CheckValue("boolean", boolean, 0)); + VerifyOrReturn(CheckValue("boolean", boolean, 0)); NextTest(); } @@ -33354,7 +33358,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_7(bool boolean) { - VerifyOrReturn(CheckValue("boolean", boolean, 1)); + VerifyOrReturn(CheckValue("boolean", boolean, 1)); NextTest(); } @@ -33389,7 +33393,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_9(bool boolean) { - VerifyOrReturn(CheckValue("boolean", boolean, 0)); + VerifyOrReturn(CheckValue("boolean", boolean, 0)); NextTest(); } @@ -33407,7 +33411,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_10(uint8_t bitmap8) { - VerifyOrReturn(CheckValue("bitmap8", bitmap8, 0)); + VerifyOrReturn(CheckValue("bitmap8", bitmap8, 0)); NextTest(); } @@ -33442,7 +33446,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_12(uint8_t bitmap8) { - VerifyOrReturn(CheckValue("bitmap8", bitmap8, 255)); + VerifyOrReturn(CheckValue("bitmap8", bitmap8, 255)); NextTest(); } @@ -33477,7 +33481,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_14(uint8_t bitmap8) { - VerifyOrReturn(CheckValue("bitmap8", bitmap8, 0)); + VerifyOrReturn(CheckValue("bitmap8", bitmap8, 0)); NextTest(); } @@ -33495,7 +33499,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_15(uint16_t bitmap16) { - VerifyOrReturn(CheckValue("bitmap16", bitmap16, 0U)); + VerifyOrReturn(CheckValue("bitmap16", bitmap16, 0U)); NextTest(); } @@ -33530,7 +33534,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_17(uint16_t bitmap16) { - VerifyOrReturn(CheckValue("bitmap16", bitmap16, 65535U)); + VerifyOrReturn(CheckValue("bitmap16", bitmap16, 65535U)); NextTest(); } @@ -33565,7 +33569,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_19(uint16_t bitmap16) { - VerifyOrReturn(CheckValue("bitmap16", bitmap16, 0U)); + VerifyOrReturn(CheckValue("bitmap16", bitmap16, 0U)); NextTest(); } @@ -33583,7 +33587,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_20(uint32_t bitmap32) { - VerifyOrReturn(CheckValue("bitmap32", bitmap32, 0UL)); + VerifyOrReturn(CheckValue("bitmap32", bitmap32, 0UL)); NextTest(); } @@ -33618,7 +33622,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_22(uint32_t bitmap32) { - VerifyOrReturn(CheckValue("bitmap32", bitmap32, 4294967295UL)); + VerifyOrReturn(CheckValue("bitmap32", bitmap32, 4294967295UL)); NextTest(); } @@ -33653,7 +33657,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_24(uint32_t bitmap32) { - VerifyOrReturn(CheckValue("bitmap32", bitmap32, 0UL)); + VerifyOrReturn(CheckValue("bitmap32", bitmap32, 0UL)); NextTest(); } @@ -33671,7 +33675,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_25(uint64_t bitmap64) { - VerifyOrReturn(CheckValue("bitmap64", bitmap64, 0ULL)); + VerifyOrReturn(CheckValue("bitmap64", bitmap64, 0ULL)); NextTest(); } @@ -33706,7 +33710,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_27(uint64_t bitmap64) { - VerifyOrReturn(CheckValue("bitmap64", bitmap64, 18446744073709551615ULL)); + VerifyOrReturn(CheckValue("bitmap64", bitmap64, 18446744073709551615ULL)); NextTest(); } @@ -33741,7 +33745,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_29(uint64_t bitmap64) { - VerifyOrReturn(CheckValue("bitmap64", bitmap64, 0ULL)); + VerifyOrReturn(CheckValue("bitmap64", bitmap64, 0ULL)); NextTest(); } @@ -33759,7 +33763,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_30(uint8_t int8u) { - VerifyOrReturn(CheckValue("int8u", int8u, 0)); + VerifyOrReturn(CheckValue("int8u", int8u, 0)); NextTest(); } @@ -33794,7 +33798,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_32(uint8_t int8u) { - VerifyOrReturn(CheckValue("int8u", int8u, 255)); + VerifyOrReturn(CheckValue("int8u", int8u, 255)); NextTest(); } @@ -33829,7 +33833,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_34(uint8_t int8u) { - VerifyOrReturn(CheckValue("int8u", int8u, 0)); + VerifyOrReturn(CheckValue("int8u", int8u, 0)); NextTest(); } @@ -33847,7 +33851,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_35(uint16_t int16u) { - VerifyOrReturn(CheckValue("int16u", int16u, 0U)); + VerifyOrReturn(CheckValue("int16u", int16u, 0U)); NextTest(); } @@ -33882,7 +33886,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_37(uint16_t int16u) { - VerifyOrReturn(CheckValue("int16u", int16u, 65535U)); + VerifyOrReturn(CheckValue("int16u", int16u, 65535U)); NextTest(); } @@ -33917,7 +33921,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_39(uint16_t int16u) { - VerifyOrReturn(CheckValue("int16u", int16u, 0U)); + VerifyOrReturn(CheckValue("int16u", int16u, 0U)); NextTest(); } @@ -33935,7 +33939,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_40(uint32_t int32u) { - VerifyOrReturn(CheckValue("int32u", int32u, 0UL)); + VerifyOrReturn(CheckValue("int32u", int32u, 0UL)); NextTest(); } @@ -33970,7 +33974,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_42(uint32_t int32u) { - VerifyOrReturn(CheckValue("int32u", int32u, 4294967295UL)); + VerifyOrReturn(CheckValue("int32u", int32u, 4294967295UL)); NextTest(); } @@ -34005,7 +34009,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_44(uint32_t int32u) { - VerifyOrReturn(CheckValue("int32u", int32u, 0UL)); + VerifyOrReturn(CheckValue("int32u", int32u, 0UL)); NextTest(); } @@ -34023,7 +34027,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_45(uint64_t int64u) { - VerifyOrReturn(CheckValue("int64u", int64u, 0ULL)); + VerifyOrReturn(CheckValue("int64u", int64u, 0ULL)); NextTest(); } @@ -34058,7 +34062,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_47(uint64_t int64u) { - VerifyOrReturn(CheckValue("int64u", int64u, 18446744073709551615ULL)); + VerifyOrReturn(CheckValue("int64u", int64u, 18446744073709551615ULL)); NextTest(); } @@ -34093,7 +34097,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_49(uint64_t int64u) { - VerifyOrReturn(CheckValue("int64u", int64u, 0ULL)); + VerifyOrReturn(CheckValue("int64u", int64u, 0ULL)); NextTest(); } @@ -34111,7 +34115,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_50(int8_t int8s) { - VerifyOrReturn(CheckValue("int8s", int8s, 0)); + VerifyOrReturn(CheckValue("int8s", int8s, 0)); NextTest(); } @@ -34146,7 +34150,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_52(int8_t int8s) { - VerifyOrReturn(CheckValue("int8s", int8s, 127)); + VerifyOrReturn(CheckValue("int8s", int8s, 127)); NextTest(); } @@ -34181,7 +34185,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_54(int8_t int8s) { - VerifyOrReturn(CheckValue("int8s", int8s, -128)); + VerifyOrReturn(CheckValue("int8s", int8s, -128)); NextTest(); } @@ -34216,7 +34220,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_56(int8_t int8s) { - VerifyOrReturn(CheckValue("int8s", int8s, 0)); + VerifyOrReturn(CheckValue("int8s", int8s, 0)); NextTest(); } @@ -34234,7 +34238,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_57(int16_t int16s) { - VerifyOrReturn(CheckValue("int16s", int16s, 0)); + VerifyOrReturn(CheckValue("int16s", int16s, 0)); NextTest(); } @@ -34269,7 +34273,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_59(int16_t int16s) { - VerifyOrReturn(CheckValue("int16s", int16s, 32767)); + VerifyOrReturn(CheckValue("int16s", int16s, 32767)); NextTest(); } @@ -34304,7 +34308,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_61(int16_t int16s) { - VerifyOrReturn(CheckValue("int16s", int16s, -32768)); + VerifyOrReturn(CheckValue("int16s", int16s, -32768)); NextTest(); } @@ -34339,7 +34343,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_63(int16_t int16s) { - VerifyOrReturn(CheckValue("int16s", int16s, 0)); + VerifyOrReturn(CheckValue("int16s", int16s, 0)); NextTest(); } @@ -34357,7 +34361,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_64(int32_t int32s) { - VerifyOrReturn(CheckValue("int32s", int32s, 0L)); + VerifyOrReturn(CheckValue("int32s", int32s, 0L)); NextTest(); } @@ -34392,7 +34396,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_66(int32_t int32s) { - VerifyOrReturn(CheckValue("int32s", int32s, 2147483647L)); + VerifyOrReturn(CheckValue("int32s", int32s, 2147483647L)); NextTest(); } @@ -34427,7 +34431,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_68(int32_t int32s) { - VerifyOrReturn(CheckValue("int32s", int32s, -2147483648L)); + VerifyOrReturn(CheckValue("int32s", int32s, -2147483648L)); NextTest(); } @@ -34462,7 +34466,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_70(int32_t int32s) { - VerifyOrReturn(CheckValue("int32s", int32s, 0L)); + VerifyOrReturn(CheckValue("int32s", int32s, 0L)); NextTest(); } @@ -34480,7 +34484,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_71(int64_t int64s) { - VerifyOrReturn(CheckValue("int64s", int64s, 0LL)); + VerifyOrReturn(CheckValue("int64s", int64s, 0LL)); NextTest(); } @@ -34515,7 +34519,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_73(int64_t int64s) { - VerifyOrReturn(CheckValue("int64s", int64s, 9223372036854775807LL)); + VerifyOrReturn(CheckValue("int64s", int64s, 9223372036854775807LL)); NextTest(); } @@ -34550,7 +34554,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_75(int64_t int64s) { - VerifyOrReturn(CheckValue("int64s", int64s, -9223372036854775807LL)); + VerifyOrReturn(CheckValue("int64s", int64s, -9223372036854775807LL)); NextTest(); } @@ -34585,7 +34589,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_77(int64_t int64s) { - VerifyOrReturn(CheckValue("int64s", int64s, 0LL)); + VerifyOrReturn(CheckValue("int64s", int64s, 0LL)); NextTest(); } @@ -34603,7 +34607,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_78(uint8_t enum8) { - VerifyOrReturn(CheckValue("enum8", enum8, 0)); + VerifyOrReturn(CheckValue("enum8", enum8, 0)); NextTest(); } @@ -34638,7 +34642,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_80(uint8_t enum8) { - VerifyOrReturn(CheckValue("enum8", enum8, 255)); + VerifyOrReturn(CheckValue("enum8", enum8, 255)); NextTest(); } @@ -34673,7 +34677,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_82(uint8_t enum8) { - VerifyOrReturn(CheckValue("enum8", enum8, 0)); + VerifyOrReturn(CheckValue("enum8", enum8, 0)); NextTest(); } @@ -34691,7 +34695,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_83(uint16_t enum16) { - VerifyOrReturn(CheckValue("enum16", enum16, 0U)); + VerifyOrReturn(CheckValue("enum16", enum16, 0U)); NextTest(); } @@ -34726,7 +34730,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_85(uint16_t enum16) { - VerifyOrReturn(CheckValue("enum16", enum16, 65535U)); + VerifyOrReturn(CheckValue("enum16", enum16, 65535U)); NextTest(); } @@ -34761,7 +34765,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_87(uint16_t enum16) { - VerifyOrReturn(CheckValue("enum16", enum16, 0U)); + VerifyOrReturn(CheckValue("enum16", enum16, 0U)); NextTest(); } @@ -35153,7 +35157,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_108(uint64_t epochUs) { - VerifyOrReturn(CheckValue("epochUs", epochUs, 0ULL)); + VerifyOrReturn(CheckValue("epochUs", epochUs, 0ULL)); NextTest(); } @@ -35188,7 +35192,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_110(uint64_t epochUs) { - VerifyOrReturn(CheckValue("epochUs", epochUs, 18446744073709551615ULL)); + VerifyOrReturn(CheckValue("epochUs", epochUs, 18446744073709551615ULL)); NextTest(); } @@ -35223,7 +35227,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_112(uint64_t epochUs) { - VerifyOrReturn(CheckValue("epochUs", epochUs, 0ULL)); + VerifyOrReturn(CheckValue("epochUs", epochUs, 0ULL)); NextTest(); } @@ -35241,7 +35245,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_113(uint32_t epochS) { - VerifyOrReturn(CheckValue("epochS", epochS, 0UL)); + VerifyOrReturn(CheckValue("epochS", epochS, 0UL)); NextTest(); } @@ -35276,7 +35280,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_115(uint32_t epochS) { - VerifyOrReturn(CheckValue("epochS", epochS, 4294967295UL)); + VerifyOrReturn(CheckValue("epochS", epochS, 4294967295UL)); NextTest(); } @@ -35311,7 +35315,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_117(uint32_t epochS) { - VerifyOrReturn(CheckValue("epochS", epochS, 0UL)); + VerifyOrReturn(CheckValue("epochS", epochS, 0UL)); NextTest(); } @@ -35332,7 +35336,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_118(bool unsupported) { - VerifyOrReturn(CheckValue("unsupported", unsupported, 0)); + VerifyOrReturn(CheckValue("unsupported", unsupported, 0)); NextTest(); } @@ -35393,7 +35397,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_121(chip::VendorId vendorId) { - VerifyOrReturn(CheckValue("vendorId", vendorId, 0U)); + VerifyOrReturn(CheckValue("vendorId", vendorId, 0U)); NextTest(); } @@ -35428,7 +35432,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_123(chip::VendorId vendorId) { - VerifyOrReturn(CheckValue("vendorId", vendorId, 17U)); + VerifyOrReturn(CheckValue("vendorId", vendorId, 17U)); NextTest(); } @@ -35474,9 +35478,9 @@ class TestCluster : public TestCommand void OnSuccessResponse_125(chip::VendorId arg1, chip::app::Clusters::TestCluster::SimpleEnum arg2) { - VerifyOrReturn(CheckValue("arg1", arg1, 20003U)); + VerifyOrReturn(CheckValue("arg1", arg1, 20003U)); - VerifyOrReturn(CheckValue("arg2", arg2, 101)); + VerifyOrReturn(CheckValue("arg2", arg2, 101)); NextTest(); } @@ -35493,6 +35497,8 @@ class TestCluster : public TestCommand request.arg1.d = chip::ByteSpan(chip::Uint8::from_const_char("octet_stringgarbage: not in length on purpose"), 12); request.arg1.e = chip::Span("char_stringgarbage: not in length on purpose", 11); request.arg1.f = static_cast>(1); + request.arg1.g = 0; + request.arg1.h = 0; auto success = [](void * context, const typename RequestType::ResponseType & data) { (static_cast(context))->OnSuccessResponse_126(data.value); @@ -35510,7 +35516,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_126(bool value) { - VerifyOrReturn(CheckValue("value", value, true)); + VerifyOrReturn(CheckValue("value", value, true)); NextTest(); } @@ -35527,6 +35533,8 @@ class TestCluster : public TestCommand request.arg1.d = chip::ByteSpan(chip::Uint8::from_const_char("octet_stringgarbage: not in length on purpose"), 12); request.arg1.e = chip::Span("char_stringgarbage: not in length on purpose", 11); request.arg1.f = static_cast>(1); + request.arg1.g = 0; + request.arg1.h = 0; auto success = [](void * context, const typename RequestType::ResponseType & data) { (static_cast(context))->OnSuccessResponse_127(data.value); @@ -35544,11 +35552,54 @@ class TestCluster : public TestCommand void OnSuccessResponse_127(bool value) { - VerifyOrReturn(CheckValue("value", value, false)); + VerifyOrReturn(CheckValue("value", value, false)); + NextTest(); + } + + CHIP_ERROR TestSendTestCommandWithStructArgumentAndSeeWhatWeGetBack_128() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + using RequestType = chip::app::Clusters::TestCluster::Commands::SimpleStructEchoRequest::Type; + + RequestType request; + + request.arg1.a = 17; + request.arg1.b = false; + request.arg1.c = static_cast(2); + request.arg1.d = chip::ByteSpan(chip::Uint8::from_const_char("octet_stringgarbage: not in length on purpose"), 12); + request.arg1.e = chip::Span("char_stringgarbage: not in length on purpose", 11); + request.arg1.f = static_cast>(1); + request.arg1.g = 0.1f; + request.arg1.h = 0.1; + + auto success = [](void * context, const typename RequestType::ResponseType & data) { + (static_cast(context))->OnSuccessResponse_128(data.arg1); + }; + + auto failure = [](void * context, EmberAfStatus status) { + (static_cast(context))->OnFailureResponse_128(status); + }; + + ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevice, this, success, failure, endpoint, request)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_128(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_128(const chip::app::Clusters::TestCluster::Structs::SimpleStruct::DecodableType & arg1) + { + VerifyOrReturn(CheckValue("arg1.a", arg1.a, 17)); + VerifyOrReturn(CheckValue("arg1.b", arg1.b, false)); + VerifyOrReturn(CheckValue("arg1.c", arg1.c, 2)); + VerifyOrReturn(CheckValueAsString("arg1.d", arg1.d, chip::ByteSpan(chip::Uint8::from_const_char("octet_string"), 12))); + VerifyOrReturn(CheckValueAsString("arg1.e", arg1.e, chip::CharSpan("char_string", 11))); + VerifyOrReturn(CheckValue("arg1.f", arg1.f, 1)); + VerifyOrReturn(CheckValue("arg1.g", arg1.g, 0.1f)); + VerifyOrReturn(CheckValue("arg1.h", arg1.h, 0.1)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithListOfInt8uAndNoneOfThemIsSetTo0_128() + CHIP_ERROR TestSendTestCommandWithListOfInt8uAndNoneOfThemIsSetTo0_129() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListInt8UArgumentRequest::Type; @@ -35568,26 +35619,26 @@ class TestCluster : public TestCommand request.arg1 = arg1List; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_128(data.value); + (static_cast(context))->OnSuccessResponse_129(data.value); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_128(status); + (static_cast(context))->OnFailureResponse_129(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevice, this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_128(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_129(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_128(bool value) + void OnSuccessResponse_129(bool value) { - VerifyOrReturn(CheckValue("value", value, true)); + VerifyOrReturn(CheckValue("value", value, true)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithListOfInt8uAndOneOfThemIsSetTo0_129() + CHIP_ERROR TestSendTestCommandWithListOfInt8uAndOneOfThemIsSetTo0_130() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListInt8UArgumentRequest::Type; @@ -35608,26 +35659,26 @@ class TestCluster : public TestCommand request.arg1 = arg1List; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_129(data.value); + (static_cast(context))->OnSuccessResponse_130(data.value); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_129(status); + (static_cast(context))->OnFailureResponse_130(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevice, this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_129(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_130(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_129(bool value) + void OnSuccessResponse_130(bool value) { - VerifyOrReturn(CheckValue("value", value, false)); + VerifyOrReturn(CheckValue("value", value, false)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithListOfInt8uAndGetItReversed_130() + CHIP_ERROR TestSendTestCommandWithListOfInt8uAndGetItReversed_131() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListInt8UReverseRequest::Type; @@ -35647,45 +35698,45 @@ class TestCluster : public TestCommand request.arg1 = arg1List; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_130(data.arg1); + (static_cast(context))->OnSuccessResponse_131(data.arg1); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_130(status); + (static_cast(context))->OnFailureResponse_131(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevice, this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_130(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_131(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_130(const chip::app::DataModel::DecodableList & arg1) + void OnSuccessResponse_131(const chip::app::DataModel::DecodableList & arg1) { auto iter = arg1.begin(); VerifyOrReturn(CheckNextListItemDecodes("arg1", iter, 0)); - VerifyOrReturn(CheckValue("arg1[0]", iter.GetValue(), 9)); + VerifyOrReturn(CheckValue("arg1[0]", iter.GetValue(), 9)); VerifyOrReturn(CheckNextListItemDecodes("arg1", iter, 1)); - VerifyOrReturn(CheckValue("arg1[1]", iter.GetValue(), 8)); + VerifyOrReturn(CheckValue("arg1[1]", iter.GetValue(), 8)); VerifyOrReturn(CheckNextListItemDecodes("arg1", iter, 2)); - VerifyOrReturn(CheckValue("arg1[2]", iter.GetValue(), 7)); + VerifyOrReturn(CheckValue("arg1[2]", iter.GetValue(), 7)); VerifyOrReturn(CheckNextListItemDecodes("arg1", iter, 3)); - VerifyOrReturn(CheckValue("arg1[3]", iter.GetValue(), 6)); + VerifyOrReturn(CheckValue("arg1[3]", iter.GetValue(), 6)); VerifyOrReturn(CheckNextListItemDecodes("arg1", iter, 4)); - VerifyOrReturn(CheckValue("arg1[4]", iter.GetValue(), 5)); + VerifyOrReturn(CheckValue("arg1[4]", iter.GetValue(), 5)); VerifyOrReturn(CheckNextListItemDecodes("arg1", iter, 5)); - VerifyOrReturn(CheckValue("arg1[5]", iter.GetValue(), 4)); + VerifyOrReturn(CheckValue("arg1[5]", iter.GetValue(), 4)); VerifyOrReturn(CheckNextListItemDecodes("arg1", iter, 6)); - VerifyOrReturn(CheckValue("arg1[6]", iter.GetValue(), 3)); + VerifyOrReturn(CheckValue("arg1[6]", iter.GetValue(), 3)); VerifyOrReturn(CheckNextListItemDecodes("arg1", iter, 7)); - VerifyOrReturn(CheckValue("arg1[7]", iter.GetValue(), 2)); + VerifyOrReturn(CheckValue("arg1[7]", iter.GetValue(), 2)); VerifyOrReturn(CheckNextListItemDecodes("arg1", iter, 8)); - VerifyOrReturn(CheckValue("arg1[8]", iter.GetValue(), 1)); + VerifyOrReturn(CheckValue("arg1[8]", iter.GetValue(), 1)); VerifyOrReturn(CheckNoMoreListItems("arg1", iter, 9)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithEmptyListOfInt8uAndGetAnEmptyListBack_131() + CHIP_ERROR TestSendTestCommandWithEmptyListOfInt8uAndGetAnEmptyListBack_132() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListInt8UReverseRequest::Type; @@ -35695,27 +35746,27 @@ class TestCluster : public TestCommand request.arg1 = chip::app::DataModel::List(); auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_131(data.arg1); + (static_cast(context))->OnSuccessResponse_132(data.arg1); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_131(status); + (static_cast(context))->OnFailureResponse_132(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevice, this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_131(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_132(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_131(const chip::app::DataModel::DecodableList & arg1) + void OnSuccessResponse_132(const chip::app::DataModel::DecodableList & arg1) { auto iter = arg1.begin(); VerifyOrReturn(CheckNoMoreListItems("arg1", iter, 0)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsTrue_132() + CHIP_ERROR TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsTrue_133() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListStructArgumentRequest::Type; @@ -35730,6 +35781,8 @@ class TestCluster : public TestCommand arg1List[0].d = chip::ByteSpan(chip::Uint8::from_const_char("first_octet_stringgarbage: not in length on purpose"), 18); arg1List[0].e = chip::Span("first_char_stringgarbage: not in length on purpose", 17); arg1List[0].f = static_cast>(1); + arg1List[0].g = 0; + arg1List[0].h = 0; arg1List[1].a = 1; arg1List[1].b = true; @@ -35737,30 +35790,32 @@ class TestCluster : public TestCommand arg1List[1].d = chip::ByteSpan(chip::Uint8::from_const_char("second_octet_stringgarbage: not in length on purpose"), 19); arg1List[1].e = chip::Span("second_char_stringgarbage: not in length on purpose", 18); arg1List[1].f = static_cast>(1); + arg1List[1].g = 0; + arg1List[1].h = 0; request.arg1 = arg1List; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_132(data.value); + (static_cast(context))->OnSuccessResponse_133(data.value); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_132(status); + (static_cast(context))->OnFailureResponse_133(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevice, this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_132(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_133(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_132(bool value) + void OnSuccessResponse_133(bool value) { - VerifyOrReturn(CheckValue("value", value, true)); + VerifyOrReturn(CheckValue("value", value, true)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsFalse_133() + CHIP_ERROR TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsFalse_134() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListStructArgumentRequest::Type; @@ -35775,6 +35830,8 @@ class TestCluster : public TestCommand arg1List[0].d = chip::ByteSpan(chip::Uint8::from_const_char("second_octet_stringgarbage: not in length on purpose"), 19); arg1List[0].e = chip::Span("second_char_stringgarbage: not in length on purpose", 18); arg1List[0].f = static_cast>(1); + arg1List[0].g = 0; + arg1List[0].h = 0; arg1List[1].a = 0; arg1List[1].b = false; @@ -35782,30 +35839,32 @@ class TestCluster : public TestCommand arg1List[1].d = chip::ByteSpan(chip::Uint8::from_const_char("first_octet_stringgarbage: not in length on purpose"), 18); arg1List[1].e = chip::Span("first_char_stringgarbage: not in length on purpose", 17); arg1List[1].f = static_cast>(1); + arg1List[1].g = 0; + arg1List[1].h = 0; request.arg1 = arg1List; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_133(data.value); + (static_cast(context))->OnSuccessResponse_134(data.value); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_133(status); + (static_cast(context))->OnFailureResponse_134(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevice, this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_133(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_134(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_133(bool value) + void OnSuccessResponse_134(bool value) { - VerifyOrReturn(CheckValue("value", value, false)); + VerifyOrReturn(CheckValue("value", value, false)); NextTest(); } - CHIP_ERROR TestWriteAttributeListWithListOfInt8uAndNoneOfThemIsSetTo0_134() + CHIP_ERROR TestWriteAttributeListWithListOfInt8uAndNoneOfThemIsSetTo0_135() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -35821,41 +35880,41 @@ class TestCluster : public TestCommand listInt8uArgument = listInt8uList; return cluster.WriteAttribute( - listInt8uArgument, this, OnSuccessCallback_134, OnFailureCallback_134); + listInt8uArgument, this, OnSuccessCallback_135, OnFailureCallback_135); } - void OnFailureResponse_134(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_135(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_134() { NextTest(); } + void OnSuccessResponse_135() { NextTest(); } - CHIP_ERROR TestReadAttributeListWithListOfInt8u_135() + CHIP_ERROR TestReadAttributeListWithListOfInt8u_136() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_135, - OnFailureCallback_135); + return cluster.ReadAttribute(this, OnSuccessCallback_136, + OnFailureCallback_136); } - void OnFailureResponse_135(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_136(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_135(const chip::app::DataModel::DecodableList & listInt8u) + void OnSuccessResponse_136(const chip::app::DataModel::DecodableList & listInt8u) { auto iter = listInt8u.begin(); VerifyOrReturn(CheckNextListItemDecodes("listInt8u", iter, 0)); - VerifyOrReturn(CheckValue("listInt8u[0]", iter.GetValue(), 1)); + VerifyOrReturn(CheckValue("listInt8u[0]", iter.GetValue(), 1)); VerifyOrReturn(CheckNextListItemDecodes("listInt8u", iter, 1)); - VerifyOrReturn(CheckValue("listInt8u[1]", iter.GetValue(), 2)); + VerifyOrReturn(CheckValue("listInt8u[1]", iter.GetValue(), 2)); VerifyOrReturn(CheckNextListItemDecodes("listInt8u", iter, 2)); - VerifyOrReturn(CheckValue("listInt8u[2]", iter.GetValue(), 3)); + VerifyOrReturn(CheckValue("listInt8u[2]", iter.GetValue(), 3)); VerifyOrReturn(CheckNextListItemDecodes("listInt8u", iter, 3)); - VerifyOrReturn(CheckValue("listInt8u[3]", iter.GetValue(), 4)); + VerifyOrReturn(CheckValue("listInt8u[3]", iter.GetValue(), 4)); VerifyOrReturn(CheckNoMoreListItems("listInt8u", iter, 4)); NextTest(); } - CHIP_ERROR TestWriteAttributeListWithListOfOctetString_136() + CHIP_ERROR TestWriteAttributeListWithListOfOctetString_137() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -35871,26 +35930,26 @@ class TestCluster : public TestCommand listOctetStringArgument = listOctetStringList; return cluster.WriteAttribute( - listOctetStringArgument, this, OnSuccessCallback_136, OnFailureCallback_136); + listOctetStringArgument, this, OnSuccessCallback_137, OnFailureCallback_137); } - void OnFailureResponse_136(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_137(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_136() { NextTest(); } + void OnSuccessResponse_137() { NextTest(); } - CHIP_ERROR TestReadAttributeListWithListOfOctetString_137() + CHIP_ERROR TestReadAttributeListWithListOfOctetString_138() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_137, OnFailureCallback_137); + this, OnSuccessCallback_138, OnFailureCallback_138); } - void OnFailureResponse_137(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_138(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_137(const chip::app::DataModel::DecodableList & listOctetString) + void OnSuccessResponse_138(const chip::app::DataModel::DecodableList & listOctetString) { auto iter = listOctetString.begin(); VerifyOrReturn(CheckNextListItemDecodes("listOctetString", iter, 0)); @@ -35909,7 +35968,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeListWithListOfListStructOctetString_138() + CHIP_ERROR TestWriteAttributeListWithListOfListStructOctetString_139() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -35939,51 +35998,51 @@ class TestCluster : public TestCommand listStructOctetStringArgument = listStructOctetStringList; return cluster.WriteAttribute( - listStructOctetStringArgument, this, OnSuccessCallback_138, OnFailureCallback_138); + listStructOctetStringArgument, this, OnSuccessCallback_139, OnFailureCallback_139); } - void OnFailureResponse_138(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_139(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_138() { NextTest(); } + void OnSuccessResponse_139() { NextTest(); } - CHIP_ERROR TestReadAttributeListWithListOfListStructOctetString_139() + CHIP_ERROR TestReadAttributeListWithListOfListStructOctetString_140() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_139, OnFailureCallback_139); + this, OnSuccessCallback_140, OnFailureCallback_140); } - void OnFailureResponse_139(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_140(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_139( + void OnSuccessResponse_140( const chip::app::DataModel::DecodableList & listStructOctetString) { auto iter = listStructOctetString.begin(); VerifyOrReturn(CheckNextListItemDecodes("listStructOctetString", iter, 0)); - VerifyOrReturn(CheckValue<>("listStructOctetString[0].fabricIndex", iter.GetValue().fabricIndex, 0ULL)); + VerifyOrReturn(CheckValue("listStructOctetString[0].fabricIndex", iter.GetValue().fabricIndex, 0ULL)); VerifyOrReturn(CheckValueAsString("listStructOctetString[0].operationalCert", iter.GetValue().operationalCert, chip::ByteSpan(chip::Uint8::from_const_char("Test0"), 5))); VerifyOrReturn(CheckNextListItemDecodes("listStructOctetString", iter, 1)); - VerifyOrReturn(CheckValue<>("listStructOctetString[1].fabricIndex", iter.GetValue().fabricIndex, 1ULL)); + VerifyOrReturn(CheckValue("listStructOctetString[1].fabricIndex", iter.GetValue().fabricIndex, 1ULL)); VerifyOrReturn(CheckValueAsString("listStructOctetString[1].operationalCert", iter.GetValue().operationalCert, chip::ByteSpan(chip::Uint8::from_const_char("Test1"), 5))); VerifyOrReturn(CheckNextListItemDecodes("listStructOctetString", iter, 2)); - VerifyOrReturn(CheckValue<>("listStructOctetString[2].fabricIndex", iter.GetValue().fabricIndex, 2ULL)); + VerifyOrReturn(CheckValue("listStructOctetString[2].fabricIndex", iter.GetValue().fabricIndex, 2ULL)); VerifyOrReturn(CheckValueAsString("listStructOctetString[2].operationalCert", iter.GetValue().operationalCert, chip::ByteSpan(chip::Uint8::from_const_char("Test2"), 5))); VerifyOrReturn(CheckNextListItemDecodes("listStructOctetString", iter, 3)); - VerifyOrReturn(CheckValue<>("listStructOctetString[3].fabricIndex", iter.GetValue().fabricIndex, 3ULL)); + VerifyOrReturn(CheckValue("listStructOctetString[3].fabricIndex", iter.GetValue().fabricIndex, 3ULL)); VerifyOrReturn(CheckValueAsString("listStructOctetString[3].operationalCert", iter.GetValue().operationalCert, chip::ByteSpan(chip::Uint8::from_const_char("Test3"), 5))); VerifyOrReturn(CheckNoMoreListItems("listStructOctetString", iter, 4)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithOptionalArgSet_140() + CHIP_ERROR TestSendTestCommandWithOptionalArgSet_141() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestNullableOptionalRequest::Type; @@ -35993,37 +36052,37 @@ class TestCluster : public TestCommand auto success = [](void * context, const typename RequestType::ResponseType & data) { (static_cast(context)) - ->OnSuccessResponse_140(data.wasPresent, data.wasNull, data.value, data.originalValue); + ->OnSuccessResponse_141(data.wasPresent, data.wasNull, data.value, data.originalValue); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_140(status); + (static_cast(context))->OnFailureResponse_141(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevice, this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_140(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_141(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_140(bool wasPresent, const chip::Optional & wasNull, const chip::Optional & value, + void OnSuccessResponse_141(bool wasPresent, const chip::Optional & wasNull, const chip::Optional & value, const chip::Optional> & originalValue) { - VerifyOrReturn(CheckValue("wasPresent", wasPresent, true)); + VerifyOrReturn(CheckValue("wasPresent", wasPresent, true)); VerifyOrReturn(CheckValuePresent("wasNull", wasNull)); - VerifyOrReturn(CheckValue("wasNull.Value()", wasNull.Value(), false)); + VerifyOrReturn(CheckValue("wasNull.Value()", wasNull.Value(), false)); VerifyOrReturn(CheckValuePresent("value", value)); - VerifyOrReturn(CheckValue("value.Value()", value.Value(), 5)); + VerifyOrReturn(CheckValue("value.Value()", value.Value(), 5)); VerifyOrReturn(CheckValuePresent("originalValue", originalValue)); VerifyOrReturn(CheckValueNonNull("originalValue.Value()", originalValue.Value())); - VerifyOrReturn(CheckValue("originalValue.Value().Value()", originalValue.Value().Value(), 5)); + VerifyOrReturn(CheckValue("originalValue.Value().Value()", originalValue.Value().Value(), 5)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithoutItsOptionalArg_141() + CHIP_ERROR TestSendTestCommandWithoutItsOptionalArg_142() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestNullableOptionalRequest::Type; @@ -36032,28 +36091,28 @@ class TestCluster : public TestCommand auto success = [](void * context, const typename RequestType::ResponseType & data) { (static_cast(context)) - ->OnSuccessResponse_141(data.wasPresent, data.wasNull, data.value, data.originalValue); + ->OnSuccessResponse_142(data.wasPresent, data.wasNull, data.value, data.originalValue); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_141(status); + (static_cast(context))->OnFailureResponse_142(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevice, this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_141(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_142(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_141(bool wasPresent, const chip::Optional & wasNull, const chip::Optional & value, + void OnSuccessResponse_142(bool wasPresent, const chip::Optional & wasNull, const chip::Optional & value, const chip::Optional> & originalValue) { - VerifyOrReturn(CheckValue("wasPresent", wasPresent, false)); + VerifyOrReturn(CheckValue("wasPresent", wasPresent, false)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBooleanNull_142() + CHIP_ERROR TestWriteAttributeNullableBooleanNull_143() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36063,32 +36122,32 @@ class TestCluster : public TestCommand nullableBooleanArgument.SetNull(); return cluster.WriteAttribute( - nullableBooleanArgument, this, OnSuccessCallback_142, OnFailureCallback_142); + nullableBooleanArgument, this, OnSuccessCallback_143, OnFailureCallback_143); } - void OnFailureResponse_142(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_143(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_142() { NextTest(); } + void OnSuccessResponse_143() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBooleanNull_143() + CHIP_ERROR TestReadAttributeNullableBooleanNull_144() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_143, OnFailureCallback_143); + this, OnSuccessCallback_144, OnFailureCallback_144); } - void OnFailureResponse_143(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_144(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_143(const chip::app::DataModel::Nullable & nullableBoolean) + void OnSuccessResponse_144(const chip::app::DataModel::Nullable & nullableBoolean) { VerifyOrReturn(CheckValueNull("nullableBoolean", nullableBoolean)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBooleanTrue_144() + CHIP_ERROR TestWriteAttributeNullableBooleanTrue_145() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36098,33 +36157,33 @@ class TestCluster : public TestCommand nullableBooleanArgument.SetNonNull() = true; return cluster.WriteAttribute( - nullableBooleanArgument, this, OnSuccessCallback_144, OnFailureCallback_144); + nullableBooleanArgument, this, OnSuccessCallback_145, OnFailureCallback_145); } - void OnFailureResponse_144(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_145(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_144() { NextTest(); } + void OnSuccessResponse_145() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBooleanTrue_145() + CHIP_ERROR TestReadAttributeNullableBooleanTrue_146() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_145, OnFailureCallback_145); + this, OnSuccessCallback_146, OnFailureCallback_146); } - void OnFailureResponse_145(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_146(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_145(const chip::app::DataModel::Nullable & nullableBoolean) + void OnSuccessResponse_146(const chip::app::DataModel::Nullable & nullableBoolean) { VerifyOrReturn(CheckValueNonNull("nullableBoolean", nullableBoolean)); - VerifyOrReturn(CheckValue("nullableBoolean.Value()", nullableBoolean.Value(), true)); + VerifyOrReturn(CheckValue("nullableBoolean.Value()", nullableBoolean.Value(), true)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap8MaxValue_146() + CHIP_ERROR TestWriteAttributeNullableBitmap8MaxValue_147() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36134,33 +36193,33 @@ class TestCluster : public TestCommand nullableBitmap8Argument.SetNonNull() = 254; return cluster.WriteAttribute( - nullableBitmap8Argument, this, OnSuccessCallback_146, OnFailureCallback_146); + nullableBitmap8Argument, this, OnSuccessCallback_147, OnFailureCallback_147); } - void OnFailureResponse_146(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_147(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_146() { NextTest(); } + void OnSuccessResponse_147() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap8MaxValue_147() + CHIP_ERROR TestReadAttributeNullableBitmap8MaxValue_148() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_147, OnFailureCallback_147); + this, OnSuccessCallback_148, OnFailureCallback_148); } - void OnFailureResponse_147(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_148(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_147(const chip::app::DataModel::Nullable & nullableBitmap8) + void OnSuccessResponse_148(const chip::app::DataModel::Nullable & nullableBitmap8) { VerifyOrReturn(CheckValueNonNull("nullableBitmap8", nullableBitmap8)); - VerifyOrReturn(CheckValue("nullableBitmap8.Value()", nullableBitmap8.Value(), 254)); + VerifyOrReturn(CheckValue("nullableBitmap8.Value()", nullableBitmap8.Value(), 254)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap8InvalidValue_148() + CHIP_ERROR TestWriteAttributeNullableBitmap8InvalidValue_149() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36170,33 +36229,33 @@ class TestCluster : public TestCommand nullableBitmap8Argument.SetNonNull() = 255; return cluster.WriteAttribute( - nullableBitmap8Argument, this, OnSuccessCallback_148, OnFailureCallback_148); + nullableBitmap8Argument, this, OnSuccessCallback_149, OnFailureCallback_149); } - void OnFailureResponse_148(uint8_t status) { NextTest(); } + void OnFailureResponse_149(uint8_t status) { NextTest(); } - void OnSuccessResponse_148() { ThrowSuccessResponse(); } + void OnSuccessResponse_149() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableBitmap8UnchangedValue_149() + CHIP_ERROR TestReadAttributeNullableBitmap8UnchangedValue_150() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_149, OnFailureCallback_149); + this, OnSuccessCallback_150, OnFailureCallback_150); } - void OnFailureResponse_149(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_150(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_149(const chip::app::DataModel::Nullable & nullableBitmap8) + void OnSuccessResponse_150(const chip::app::DataModel::Nullable & nullableBitmap8) { VerifyOrReturn(CheckValueNonNull("nullableBitmap8", nullableBitmap8)); - VerifyOrReturn(CheckValue("nullableBitmap8.Value()", nullableBitmap8.Value(), 254)); + VerifyOrReturn(CheckValue("nullableBitmap8.Value()", nullableBitmap8.Value(), 254)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap8NullValue_150() + CHIP_ERROR TestWriteAttributeNullableBitmap8NullValue_151() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36206,32 +36265,32 @@ class TestCluster : public TestCommand nullableBitmap8Argument.SetNull(); return cluster.WriteAttribute( - nullableBitmap8Argument, this, OnSuccessCallback_150, OnFailureCallback_150); + nullableBitmap8Argument, this, OnSuccessCallback_151, OnFailureCallback_151); } - void OnFailureResponse_150(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_151(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_150() { NextTest(); } + void OnSuccessResponse_151() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap8NullValue_151() + CHIP_ERROR TestReadAttributeNullableBitmap8NullValue_152() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_151, OnFailureCallback_151); + this, OnSuccessCallback_152, OnFailureCallback_152); } - void OnFailureResponse_151(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_152(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_151(const chip::app::DataModel::Nullable & nullableBitmap8) + void OnSuccessResponse_152(const chip::app::DataModel::Nullable & nullableBitmap8) { VerifyOrReturn(CheckValueNull("nullableBitmap8", nullableBitmap8)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap16MaxValue_152() + CHIP_ERROR TestWriteAttributeNullableBitmap16MaxValue_153() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36241,33 +36300,33 @@ class TestCluster : public TestCommand nullableBitmap16Argument.SetNonNull() = 65534U; return cluster.WriteAttribute( - nullableBitmap16Argument, this, OnSuccessCallback_152, OnFailureCallback_152); + nullableBitmap16Argument, this, OnSuccessCallback_153, OnFailureCallback_153); } - void OnFailureResponse_152(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_153(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_152() { NextTest(); } + void OnSuccessResponse_153() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap16MaxValue_153() + CHIP_ERROR TestReadAttributeNullableBitmap16MaxValue_154() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_153, OnFailureCallback_153); + this, OnSuccessCallback_154, OnFailureCallback_154); } - void OnFailureResponse_153(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_154(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_153(const chip::app::DataModel::Nullable & nullableBitmap16) + void OnSuccessResponse_154(const chip::app::DataModel::Nullable & nullableBitmap16) { VerifyOrReturn(CheckValueNonNull("nullableBitmap16", nullableBitmap16)); - VerifyOrReturn(CheckValue("nullableBitmap16.Value()", nullableBitmap16.Value(), 65534U)); + VerifyOrReturn(CheckValue("nullableBitmap16.Value()", nullableBitmap16.Value(), 65534U)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap16InvalidValue_154() + CHIP_ERROR TestWriteAttributeNullableBitmap16InvalidValue_155() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36277,33 +36336,33 @@ class TestCluster : public TestCommand nullableBitmap16Argument.SetNonNull() = 65535U; return cluster.WriteAttribute( - nullableBitmap16Argument, this, OnSuccessCallback_154, OnFailureCallback_154); + nullableBitmap16Argument, this, OnSuccessCallback_155, OnFailureCallback_155); } - void OnFailureResponse_154(uint8_t status) { NextTest(); } + void OnFailureResponse_155(uint8_t status) { NextTest(); } - void OnSuccessResponse_154() { ThrowSuccessResponse(); } + void OnSuccessResponse_155() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableBitmap16UnchangedValue_155() + CHIP_ERROR TestReadAttributeNullableBitmap16UnchangedValue_156() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_155, OnFailureCallback_155); + this, OnSuccessCallback_156, OnFailureCallback_156); } - void OnFailureResponse_155(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_156(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_155(const chip::app::DataModel::Nullable & nullableBitmap16) + void OnSuccessResponse_156(const chip::app::DataModel::Nullable & nullableBitmap16) { VerifyOrReturn(CheckValueNonNull("nullableBitmap16", nullableBitmap16)); - VerifyOrReturn(CheckValue("nullableBitmap16.Value()", nullableBitmap16.Value(), 65534U)); + VerifyOrReturn(CheckValue("nullableBitmap16.Value()", nullableBitmap16.Value(), 65534U)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap16NullValue_156() + CHIP_ERROR TestWriteAttributeNullableBitmap16NullValue_157() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36313,32 +36372,32 @@ class TestCluster : public TestCommand nullableBitmap16Argument.SetNull(); return cluster.WriteAttribute( - nullableBitmap16Argument, this, OnSuccessCallback_156, OnFailureCallback_156); + nullableBitmap16Argument, this, OnSuccessCallback_157, OnFailureCallback_157); } - void OnFailureResponse_156(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_157(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_156() { NextTest(); } + void OnSuccessResponse_157() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap16NullValue_157() + CHIP_ERROR TestReadAttributeNullableBitmap16NullValue_158() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_157, OnFailureCallback_157); + this, OnSuccessCallback_158, OnFailureCallback_158); } - void OnFailureResponse_157(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_158(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_157(const chip::app::DataModel::Nullable & nullableBitmap16) + void OnSuccessResponse_158(const chip::app::DataModel::Nullable & nullableBitmap16) { VerifyOrReturn(CheckValueNull("nullableBitmap16", nullableBitmap16)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap32MaxValue_158() + CHIP_ERROR TestWriteAttributeNullableBitmap32MaxValue_159() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36348,33 +36407,33 @@ class TestCluster : public TestCommand nullableBitmap32Argument.SetNonNull() = 4294967294UL; return cluster.WriteAttribute( - nullableBitmap32Argument, this, OnSuccessCallback_158, OnFailureCallback_158); + nullableBitmap32Argument, this, OnSuccessCallback_159, OnFailureCallback_159); } - void OnFailureResponse_158(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_159(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_158() { NextTest(); } + void OnSuccessResponse_159() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap32MaxValue_159() + CHIP_ERROR TestReadAttributeNullableBitmap32MaxValue_160() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_159, OnFailureCallback_159); + this, OnSuccessCallback_160, OnFailureCallback_160); } - void OnFailureResponse_159(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_160(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_159(const chip::app::DataModel::Nullable & nullableBitmap32) + void OnSuccessResponse_160(const chip::app::DataModel::Nullable & nullableBitmap32) { VerifyOrReturn(CheckValueNonNull("nullableBitmap32", nullableBitmap32)); - VerifyOrReturn(CheckValue("nullableBitmap32.Value()", nullableBitmap32.Value(), 4294967294UL)); + VerifyOrReturn(CheckValue("nullableBitmap32.Value()", nullableBitmap32.Value(), 4294967294UL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap32InvalidValue_160() + CHIP_ERROR TestWriteAttributeNullableBitmap32InvalidValue_161() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36384,33 +36443,33 @@ class TestCluster : public TestCommand nullableBitmap32Argument.SetNonNull() = 4294967295UL; return cluster.WriteAttribute( - nullableBitmap32Argument, this, OnSuccessCallback_160, OnFailureCallback_160); + nullableBitmap32Argument, this, OnSuccessCallback_161, OnFailureCallback_161); } - void OnFailureResponse_160(uint8_t status) { NextTest(); } + void OnFailureResponse_161(uint8_t status) { NextTest(); } - void OnSuccessResponse_160() { ThrowSuccessResponse(); } + void OnSuccessResponse_161() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableBitmap32UnchangedValue_161() + CHIP_ERROR TestReadAttributeNullableBitmap32UnchangedValue_162() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_161, OnFailureCallback_161); + this, OnSuccessCallback_162, OnFailureCallback_162); } - void OnFailureResponse_161(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_162(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_161(const chip::app::DataModel::Nullable & nullableBitmap32) + void OnSuccessResponse_162(const chip::app::DataModel::Nullable & nullableBitmap32) { VerifyOrReturn(CheckValueNonNull("nullableBitmap32", nullableBitmap32)); - VerifyOrReturn(CheckValue("nullableBitmap32.Value()", nullableBitmap32.Value(), 4294967294UL)); + VerifyOrReturn(CheckValue("nullableBitmap32.Value()", nullableBitmap32.Value(), 4294967294UL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap32NullValue_162() + CHIP_ERROR TestWriteAttributeNullableBitmap32NullValue_163() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36420,32 +36479,32 @@ class TestCluster : public TestCommand nullableBitmap32Argument.SetNull(); return cluster.WriteAttribute( - nullableBitmap32Argument, this, OnSuccessCallback_162, OnFailureCallback_162); + nullableBitmap32Argument, this, OnSuccessCallback_163, OnFailureCallback_163); } - void OnFailureResponse_162(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_163(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_162() { NextTest(); } + void OnSuccessResponse_163() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap32NullValue_163() + CHIP_ERROR TestReadAttributeNullableBitmap32NullValue_164() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_163, OnFailureCallback_163); + this, OnSuccessCallback_164, OnFailureCallback_164); } - void OnFailureResponse_163(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_164(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_163(const chip::app::DataModel::Nullable & nullableBitmap32) + void OnSuccessResponse_164(const chip::app::DataModel::Nullable & nullableBitmap32) { VerifyOrReturn(CheckValueNull("nullableBitmap32", nullableBitmap32)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap64MaxValue_164() + CHIP_ERROR TestWriteAttributeNullableBitmap64MaxValue_165() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36455,33 +36514,33 @@ class TestCluster : public TestCommand nullableBitmap64Argument.SetNonNull() = 18446744073709551614ULL; return cluster.WriteAttribute( - nullableBitmap64Argument, this, OnSuccessCallback_164, OnFailureCallback_164); + nullableBitmap64Argument, this, OnSuccessCallback_165, OnFailureCallback_165); } - void OnFailureResponse_164(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_165(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_164() { NextTest(); } + void OnSuccessResponse_165() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap64MaxValue_165() + CHIP_ERROR TestReadAttributeNullableBitmap64MaxValue_166() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_165, OnFailureCallback_165); + this, OnSuccessCallback_166, OnFailureCallback_166); } - void OnFailureResponse_165(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_166(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_165(const chip::app::DataModel::Nullable & nullableBitmap64) + void OnSuccessResponse_166(const chip::app::DataModel::Nullable & nullableBitmap64) { VerifyOrReturn(CheckValueNonNull("nullableBitmap64", nullableBitmap64)); - VerifyOrReturn(CheckValue("nullableBitmap64.Value()", nullableBitmap64.Value(), 18446744073709551614ULL)); + VerifyOrReturn(CheckValue("nullableBitmap64.Value()", nullableBitmap64.Value(), 18446744073709551614ULL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap64InvalidValue_166() + CHIP_ERROR TestWriteAttributeNullableBitmap64InvalidValue_167() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36491,33 +36550,33 @@ class TestCluster : public TestCommand nullableBitmap64Argument.SetNonNull() = 18446744073709551615ULL; return cluster.WriteAttribute( - nullableBitmap64Argument, this, OnSuccessCallback_166, OnFailureCallback_166); + nullableBitmap64Argument, this, OnSuccessCallback_167, OnFailureCallback_167); } - void OnFailureResponse_166(uint8_t status) { NextTest(); } + void OnFailureResponse_167(uint8_t status) { NextTest(); } - void OnSuccessResponse_166() { ThrowSuccessResponse(); } + void OnSuccessResponse_167() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableBitmap64UnchangedValue_167() + CHIP_ERROR TestReadAttributeNullableBitmap64UnchangedValue_168() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_167, OnFailureCallback_167); + this, OnSuccessCallback_168, OnFailureCallback_168); } - void OnFailureResponse_167(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_168(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_167(const chip::app::DataModel::Nullable & nullableBitmap64) + void OnSuccessResponse_168(const chip::app::DataModel::Nullable & nullableBitmap64) { VerifyOrReturn(CheckValueNonNull("nullableBitmap64", nullableBitmap64)); - VerifyOrReturn(CheckValue("nullableBitmap64.Value()", nullableBitmap64.Value(), 18446744073709551614ULL)); + VerifyOrReturn(CheckValue("nullableBitmap64.Value()", nullableBitmap64.Value(), 18446744073709551614ULL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap64NullValue_168() + CHIP_ERROR TestWriteAttributeNullableBitmap64NullValue_169() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36527,32 +36586,32 @@ class TestCluster : public TestCommand nullableBitmap64Argument.SetNull(); return cluster.WriteAttribute( - nullableBitmap64Argument, this, OnSuccessCallback_168, OnFailureCallback_168); + nullableBitmap64Argument, this, OnSuccessCallback_169, OnFailureCallback_169); } - void OnFailureResponse_168(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_169(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_168() { NextTest(); } + void OnSuccessResponse_169() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap64NullValue_169() + CHIP_ERROR TestReadAttributeNullableBitmap64NullValue_170() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_169, OnFailureCallback_169); + this, OnSuccessCallback_170, OnFailureCallback_170); } - void OnFailureResponse_169(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_170(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_169(const chip::app::DataModel::Nullable & nullableBitmap64) + void OnSuccessResponse_170(const chip::app::DataModel::Nullable & nullableBitmap64) { VerifyOrReturn(CheckValueNull("nullableBitmap64", nullableBitmap64)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8uMaxValue_170() + CHIP_ERROR TestWriteAttributeNullableInt8uMaxValue_171() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36562,33 +36621,33 @@ class TestCluster : public TestCommand nullableInt8uArgument.SetNonNull() = 254; return cluster.WriteAttribute( - nullableInt8uArgument, this, OnSuccessCallback_170, OnFailureCallback_170); + nullableInt8uArgument, this, OnSuccessCallback_171, OnFailureCallback_171); } - void OnFailureResponse_170(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_171(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_170() { NextTest(); } + void OnSuccessResponse_171() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8uMaxValue_171() + CHIP_ERROR TestReadAttributeNullableInt8uMaxValue_172() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_171, OnFailureCallback_171); + this, OnSuccessCallback_172, OnFailureCallback_172); } - void OnFailureResponse_171(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_172(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_171(const chip::app::DataModel::Nullable & nullableInt8u) + void OnSuccessResponse_172(const chip::app::DataModel::Nullable & nullableInt8u) { VerifyOrReturn(CheckValueNonNull("nullableInt8u", nullableInt8u)); - VerifyOrReturn(CheckValue("nullableInt8u.Value()", nullableInt8u.Value(), 254)); + VerifyOrReturn(CheckValue("nullableInt8u.Value()", nullableInt8u.Value(), 254)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8uInvalidValue_172() + CHIP_ERROR TestWriteAttributeNullableInt8uInvalidValue_173() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36598,33 +36657,33 @@ class TestCluster : public TestCommand nullableInt8uArgument.SetNonNull() = 255; return cluster.WriteAttribute( - nullableInt8uArgument, this, OnSuccessCallback_172, OnFailureCallback_172); + nullableInt8uArgument, this, OnSuccessCallback_173, OnFailureCallback_173); } - void OnFailureResponse_172(uint8_t status) { NextTest(); } + void OnFailureResponse_173(uint8_t status) { NextTest(); } - void OnSuccessResponse_172() { ThrowSuccessResponse(); } + void OnSuccessResponse_173() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt8uUnchangedValue_173() + CHIP_ERROR TestReadAttributeNullableInt8uUnchangedValue_174() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_173, OnFailureCallback_173); + this, OnSuccessCallback_174, OnFailureCallback_174); } - void OnFailureResponse_173(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_174(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_173(const chip::app::DataModel::Nullable & nullableInt8u) + void OnSuccessResponse_174(const chip::app::DataModel::Nullable & nullableInt8u) { VerifyOrReturn(CheckValueNonNull("nullableInt8u", nullableInt8u)); - VerifyOrReturn(CheckValue("nullableInt8u.Value()", nullableInt8u.Value(), 254)); + VerifyOrReturn(CheckValue("nullableInt8u.Value()", nullableInt8u.Value(), 254)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8uNullValue_174() + CHIP_ERROR TestWriteAttributeNullableInt8uNullValue_175() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36634,32 +36693,32 @@ class TestCluster : public TestCommand nullableInt8uArgument.SetNull(); return cluster.WriteAttribute( - nullableInt8uArgument, this, OnSuccessCallback_174, OnFailureCallback_174); + nullableInt8uArgument, this, OnSuccessCallback_175, OnFailureCallback_175); } - void OnFailureResponse_174(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_175(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_174() { NextTest(); } + void OnSuccessResponse_175() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8uNullValue_175() + CHIP_ERROR TestReadAttributeNullableInt8uNullValue_176() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_175, OnFailureCallback_175); + this, OnSuccessCallback_176, OnFailureCallback_176); } - void OnFailureResponse_175(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_176(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_175(const chip::app::DataModel::Nullable & nullableInt8u) + void OnSuccessResponse_176(const chip::app::DataModel::Nullable & nullableInt8u) { VerifyOrReturn(CheckValueNull("nullableInt8u", nullableInt8u)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16uMaxValue_176() + CHIP_ERROR TestWriteAttributeNullableInt16uMaxValue_177() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36669,33 +36728,33 @@ class TestCluster : public TestCommand nullableInt16uArgument.SetNonNull() = 65534U; return cluster.WriteAttribute( - nullableInt16uArgument, this, OnSuccessCallback_176, OnFailureCallback_176); + nullableInt16uArgument, this, OnSuccessCallback_177, OnFailureCallback_177); } - void OnFailureResponse_176(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_177(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_176() { NextTest(); } + void OnSuccessResponse_177() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uMaxValue_177() + CHIP_ERROR TestReadAttributeNullableInt16uMaxValue_178() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_177, OnFailureCallback_177); + this, OnSuccessCallback_178, OnFailureCallback_178); } - void OnFailureResponse_177(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_178(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_177(const chip::app::DataModel::Nullable & nullableInt16u) + void OnSuccessResponse_178(const chip::app::DataModel::Nullable & nullableInt16u) { VerifyOrReturn(CheckValueNonNull("nullableInt16u", nullableInt16u)); - VerifyOrReturn(CheckValue("nullableInt16u.Value()", nullableInt16u.Value(), 65534U)); + VerifyOrReturn(CheckValue("nullableInt16u.Value()", nullableInt16u.Value(), 65534U)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16uInvalidValue_178() + CHIP_ERROR TestWriteAttributeNullableInt16uInvalidValue_179() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36705,33 +36764,33 @@ class TestCluster : public TestCommand nullableInt16uArgument.SetNonNull() = 65535U; return cluster.WriteAttribute( - nullableInt16uArgument, this, OnSuccessCallback_178, OnFailureCallback_178); + nullableInt16uArgument, this, OnSuccessCallback_179, OnFailureCallback_179); } - void OnFailureResponse_178(uint8_t status) { NextTest(); } + void OnFailureResponse_179(uint8_t status) { NextTest(); } - void OnSuccessResponse_178() { ThrowSuccessResponse(); } + void OnSuccessResponse_179() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt16uUnchangedValue_179() + CHIP_ERROR TestReadAttributeNullableInt16uUnchangedValue_180() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_179, OnFailureCallback_179); + this, OnSuccessCallback_180, OnFailureCallback_180); } - void OnFailureResponse_179(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_180(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_179(const chip::app::DataModel::Nullable & nullableInt16u) + void OnSuccessResponse_180(const chip::app::DataModel::Nullable & nullableInt16u) { VerifyOrReturn(CheckValueNonNull("nullableInt16u", nullableInt16u)); - VerifyOrReturn(CheckValue("nullableInt16u.Value()", nullableInt16u.Value(), 65534U)); + VerifyOrReturn(CheckValue("nullableInt16u.Value()", nullableInt16u.Value(), 65534U)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16uNullValue_180() + CHIP_ERROR TestWriteAttributeNullableInt16uNullValue_181() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36741,32 +36800,32 @@ class TestCluster : public TestCommand nullableInt16uArgument.SetNull(); return cluster.WriteAttribute( - nullableInt16uArgument, this, OnSuccessCallback_180, OnFailureCallback_180); + nullableInt16uArgument, this, OnSuccessCallback_181, OnFailureCallback_181); } - void OnFailureResponse_180(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_181(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_180() { NextTest(); } + void OnSuccessResponse_181() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uNullValue_181() + CHIP_ERROR TestReadAttributeNullableInt16uNullValue_182() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_181, OnFailureCallback_181); + this, OnSuccessCallback_182, OnFailureCallback_182); } - void OnFailureResponse_181(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_182(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_181(const chip::app::DataModel::Nullable & nullableInt16u) + void OnSuccessResponse_182(const chip::app::DataModel::Nullable & nullableInt16u) { VerifyOrReturn(CheckValueNull("nullableInt16u", nullableInt16u)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32uMaxValue_182() + CHIP_ERROR TestWriteAttributeNullableInt32uMaxValue_183() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36776,33 +36835,33 @@ class TestCluster : public TestCommand nullableInt32uArgument.SetNonNull() = 4294967294UL; return cluster.WriteAttribute( - nullableInt32uArgument, this, OnSuccessCallback_182, OnFailureCallback_182); + nullableInt32uArgument, this, OnSuccessCallback_183, OnFailureCallback_183); } - void OnFailureResponse_182(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_183(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_182() { NextTest(); } + void OnSuccessResponse_183() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32uMaxValue_183() + CHIP_ERROR TestReadAttributeNullableInt32uMaxValue_184() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_183, OnFailureCallback_183); + this, OnSuccessCallback_184, OnFailureCallback_184); } - void OnFailureResponse_183(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_184(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_183(const chip::app::DataModel::Nullable & nullableInt32u) + void OnSuccessResponse_184(const chip::app::DataModel::Nullable & nullableInt32u) { VerifyOrReturn(CheckValueNonNull("nullableInt32u", nullableInt32u)); - VerifyOrReturn(CheckValue("nullableInt32u.Value()", nullableInt32u.Value(), 4294967294UL)); + VerifyOrReturn(CheckValue("nullableInt32u.Value()", nullableInt32u.Value(), 4294967294UL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32uInvalidValue_184() + CHIP_ERROR TestWriteAttributeNullableInt32uInvalidValue_185() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36812,33 +36871,33 @@ class TestCluster : public TestCommand nullableInt32uArgument.SetNonNull() = 4294967295UL; return cluster.WriteAttribute( - nullableInt32uArgument, this, OnSuccessCallback_184, OnFailureCallback_184); + nullableInt32uArgument, this, OnSuccessCallback_185, OnFailureCallback_185); } - void OnFailureResponse_184(uint8_t status) { NextTest(); } + void OnFailureResponse_185(uint8_t status) { NextTest(); } - void OnSuccessResponse_184() { ThrowSuccessResponse(); } + void OnSuccessResponse_185() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt32uUnchangedValue_185() + CHIP_ERROR TestReadAttributeNullableInt32uUnchangedValue_186() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_185, OnFailureCallback_185); + this, OnSuccessCallback_186, OnFailureCallback_186); } - void OnFailureResponse_185(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_186(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_185(const chip::app::DataModel::Nullable & nullableInt32u) + void OnSuccessResponse_186(const chip::app::DataModel::Nullable & nullableInt32u) { VerifyOrReturn(CheckValueNonNull("nullableInt32u", nullableInt32u)); - VerifyOrReturn(CheckValue("nullableInt32u.Value()", nullableInt32u.Value(), 4294967294UL)); + VerifyOrReturn(CheckValue("nullableInt32u.Value()", nullableInt32u.Value(), 4294967294UL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32uNullValue_186() + CHIP_ERROR TestWriteAttributeNullableInt32uNullValue_187() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36848,32 +36907,32 @@ class TestCluster : public TestCommand nullableInt32uArgument.SetNull(); return cluster.WriteAttribute( - nullableInt32uArgument, this, OnSuccessCallback_186, OnFailureCallback_186); + nullableInt32uArgument, this, OnSuccessCallback_187, OnFailureCallback_187); } - void OnFailureResponse_186(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_187(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_186() { NextTest(); } + void OnSuccessResponse_187() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32uNullValue_187() + CHIP_ERROR TestReadAttributeNullableInt32uNullValue_188() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_187, OnFailureCallback_187); + this, OnSuccessCallback_188, OnFailureCallback_188); } - void OnFailureResponse_187(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_188(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_187(const chip::app::DataModel::Nullable & nullableInt32u) + void OnSuccessResponse_188(const chip::app::DataModel::Nullable & nullableInt32u) { VerifyOrReturn(CheckValueNull("nullableInt32u", nullableInt32u)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64uMaxValue_188() + CHIP_ERROR TestWriteAttributeNullableInt64uMaxValue_189() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36883,33 +36942,33 @@ class TestCluster : public TestCommand nullableInt64uArgument.SetNonNull() = 18446744073709551614ULL; return cluster.WriteAttribute( - nullableInt64uArgument, this, OnSuccessCallback_188, OnFailureCallback_188); + nullableInt64uArgument, this, OnSuccessCallback_189, OnFailureCallback_189); } - void OnFailureResponse_188(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_189(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_188() { NextTest(); } + void OnSuccessResponse_189() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64uMaxValue_189() + CHIP_ERROR TestReadAttributeNullableInt64uMaxValue_190() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_189, OnFailureCallback_189); + this, OnSuccessCallback_190, OnFailureCallback_190); } - void OnFailureResponse_189(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_190(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_189(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_190(const chip::app::DataModel::Nullable & nullableInt64u) { VerifyOrReturn(CheckValueNonNull("nullableInt64u", nullableInt64u)); - VerifyOrReturn(CheckValue("nullableInt64u.Value()", nullableInt64u.Value(), 18446744073709551614ULL)); + VerifyOrReturn(CheckValue("nullableInt64u.Value()", nullableInt64u.Value(), 18446744073709551614ULL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64uInvalidValue_190() + CHIP_ERROR TestWriteAttributeNullableInt64uInvalidValue_191() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36919,33 +36978,33 @@ class TestCluster : public TestCommand nullableInt64uArgument.SetNonNull() = 18446744073709551615ULL; return cluster.WriteAttribute( - nullableInt64uArgument, this, OnSuccessCallback_190, OnFailureCallback_190); + nullableInt64uArgument, this, OnSuccessCallback_191, OnFailureCallback_191); } - void OnFailureResponse_190(uint8_t status) { NextTest(); } + void OnFailureResponse_191(uint8_t status) { NextTest(); } - void OnSuccessResponse_190() { ThrowSuccessResponse(); } + void OnSuccessResponse_191() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt64uUnchangedValue_191() + CHIP_ERROR TestReadAttributeNullableInt64uUnchangedValue_192() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_191, OnFailureCallback_191); + this, OnSuccessCallback_192, OnFailureCallback_192); } - void OnFailureResponse_191(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_192(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_191(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_192(const chip::app::DataModel::Nullable & nullableInt64u) { VerifyOrReturn(CheckValueNonNull("nullableInt64u", nullableInt64u)); - VerifyOrReturn(CheckValue("nullableInt64u.Value()", nullableInt64u.Value(), 18446744073709551614ULL)); + VerifyOrReturn(CheckValue("nullableInt64u.Value()", nullableInt64u.Value(), 18446744073709551614ULL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64uNullValue_192() + CHIP_ERROR TestWriteAttributeNullableInt64uNullValue_193() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36955,32 +37014,32 @@ class TestCluster : public TestCommand nullableInt64uArgument.SetNull(); return cluster.WriteAttribute( - nullableInt64uArgument, this, OnSuccessCallback_192, OnFailureCallback_192); + nullableInt64uArgument, this, OnSuccessCallback_193, OnFailureCallback_193); } - void OnFailureResponse_192(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_193(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_192() { NextTest(); } + void OnSuccessResponse_193() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64uNullValue_193() + CHIP_ERROR TestReadAttributeNullableInt64uNullValue_194() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_193, OnFailureCallback_193); + this, OnSuccessCallback_194, OnFailureCallback_194); } - void OnFailureResponse_193(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_194(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_193(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_194(const chip::app::DataModel::Nullable & nullableInt64u) { VerifyOrReturn(CheckValueNull("nullableInt64u", nullableInt64u)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sMinValue_194() + CHIP_ERROR TestWriteAttributeNullableInt8sMinValue_195() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36990,33 +37049,33 @@ class TestCluster : public TestCommand nullableInt8sArgument.SetNonNull() = -127; return cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_194, OnFailureCallback_194); + nullableInt8sArgument, this, OnSuccessCallback_195, OnFailureCallback_195); } - void OnFailureResponse_194(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_195(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_194() { NextTest(); } + void OnSuccessResponse_195() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sMinValue_195() + CHIP_ERROR TestReadAttributeNullableInt8sMinValue_196() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_195, OnFailureCallback_195); + this, OnSuccessCallback_196, OnFailureCallback_196); } - void OnFailureResponse_195(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_196(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_195(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_196(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckValueNonNull("nullableInt8s", nullableInt8s)); - VerifyOrReturn(CheckValue("nullableInt8s.Value()", nullableInt8s.Value(), -127)); + VerifyOrReturn(CheckValue("nullableInt8s.Value()", nullableInt8s.Value(), -127)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sInvalidValue_196() + CHIP_ERROR TestWriteAttributeNullableInt8sInvalidValue_197() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37026,33 +37085,33 @@ class TestCluster : public TestCommand nullableInt8sArgument.SetNonNull() = -128; return cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_196, OnFailureCallback_196); + nullableInt8sArgument, this, OnSuccessCallback_197, OnFailureCallback_197); } - void OnFailureResponse_196(uint8_t status) { NextTest(); } + void OnFailureResponse_197(uint8_t status) { NextTest(); } - void OnSuccessResponse_196() { ThrowSuccessResponse(); } + void OnSuccessResponse_197() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt8sUnchangedValue_197() + CHIP_ERROR TestReadAttributeNullableInt8sUnchangedValue_198() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_197, OnFailureCallback_197); + this, OnSuccessCallback_198, OnFailureCallback_198); } - void OnFailureResponse_197(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_198(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_197(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_198(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckValueNonNull("nullableInt8s", nullableInt8s)); - VerifyOrReturn(CheckValue("nullableInt8s.Value()", nullableInt8s.Value(), -127)); + VerifyOrReturn(CheckValue("nullableInt8s.Value()", nullableInt8s.Value(), -127)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sNullValue_198() + CHIP_ERROR TestWriteAttributeNullableInt8sNullValue_199() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37062,32 +37121,32 @@ class TestCluster : public TestCommand nullableInt8sArgument.SetNull(); return cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_198, OnFailureCallback_198); + nullableInt8sArgument, this, OnSuccessCallback_199, OnFailureCallback_199); } - void OnFailureResponse_198(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_199(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_198() { NextTest(); } + void OnSuccessResponse_199() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sNullValue_199() + CHIP_ERROR TestReadAttributeNullableInt8sNullValue_200() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_199, OnFailureCallback_199); + this, OnSuccessCallback_200, OnFailureCallback_200); } - void OnFailureResponse_199(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_200(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_199(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_200(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckValueNull("nullableInt8s", nullableInt8s)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sMinValue_200() + CHIP_ERROR TestWriteAttributeNullableInt16sMinValue_201() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37097,33 +37156,33 @@ class TestCluster : public TestCommand nullableInt16sArgument.SetNonNull() = -32767; return cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_200, OnFailureCallback_200); + nullableInt16sArgument, this, OnSuccessCallback_201, OnFailureCallback_201); } - void OnFailureResponse_200(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_201(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_200() { NextTest(); } + void OnSuccessResponse_201() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sMinValue_201() + CHIP_ERROR TestReadAttributeNullableInt16sMinValue_202() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_201, OnFailureCallback_201); + this, OnSuccessCallback_202, OnFailureCallback_202); } - void OnFailureResponse_201(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_202(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_201(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_202(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckValueNonNull("nullableInt16s", nullableInt16s)); - VerifyOrReturn(CheckValue("nullableInt16s.Value()", nullableInt16s.Value(), -32767)); + VerifyOrReturn(CheckValue("nullableInt16s.Value()", nullableInt16s.Value(), -32767)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sInvalidValue_202() + CHIP_ERROR TestWriteAttributeNullableInt16sInvalidValue_203() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37133,33 +37192,33 @@ class TestCluster : public TestCommand nullableInt16sArgument.SetNonNull() = -32768; return cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_202, OnFailureCallback_202); + nullableInt16sArgument, this, OnSuccessCallback_203, OnFailureCallback_203); } - void OnFailureResponse_202(uint8_t status) { NextTest(); } + void OnFailureResponse_203(uint8_t status) { NextTest(); } - void OnSuccessResponse_202() { ThrowSuccessResponse(); } + void OnSuccessResponse_203() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt16sUnchangedValue_203() + CHIP_ERROR TestReadAttributeNullableInt16sUnchangedValue_204() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_203, OnFailureCallback_203); + this, OnSuccessCallback_204, OnFailureCallback_204); } - void OnFailureResponse_203(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_204(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_203(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_204(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckValueNonNull("nullableInt16s", nullableInt16s)); - VerifyOrReturn(CheckValue("nullableInt16s.Value()", nullableInt16s.Value(), -32767)); + VerifyOrReturn(CheckValue("nullableInt16s.Value()", nullableInt16s.Value(), -32767)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sNullValue_204() + CHIP_ERROR TestWriteAttributeNullableInt16sNullValue_205() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37169,32 +37228,32 @@ class TestCluster : public TestCommand nullableInt16sArgument.SetNull(); return cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_204, OnFailureCallback_204); + nullableInt16sArgument, this, OnSuccessCallback_205, OnFailureCallback_205); } - void OnFailureResponse_204(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_205(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_204() { NextTest(); } + void OnSuccessResponse_205() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sNullValue_205() + CHIP_ERROR TestReadAttributeNullableInt16sNullValue_206() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_205, OnFailureCallback_205); + this, OnSuccessCallback_206, OnFailureCallback_206); } - void OnFailureResponse_205(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_206(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_205(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_206(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckValueNull("nullableInt16s", nullableInt16s)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sMinValue_206() + CHIP_ERROR TestWriteAttributeNullableInt32sMinValue_207() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37204,33 +37263,33 @@ class TestCluster : public TestCommand nullableInt32sArgument.SetNonNull() = -2147483647L; return cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_206, OnFailureCallback_206); + nullableInt32sArgument, this, OnSuccessCallback_207, OnFailureCallback_207); } - void OnFailureResponse_206(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_207(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_206() { NextTest(); } + void OnSuccessResponse_207() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sMinValue_207() + CHIP_ERROR TestReadAttributeNullableInt32sMinValue_208() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_207, OnFailureCallback_207); + this, OnSuccessCallback_208, OnFailureCallback_208); } - void OnFailureResponse_207(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_208(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_207(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_208(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckValueNonNull("nullableInt32s", nullableInt32s)); - VerifyOrReturn(CheckValue("nullableInt32s.Value()", nullableInt32s.Value(), -2147483647L)); + VerifyOrReturn(CheckValue("nullableInt32s.Value()", nullableInt32s.Value(), -2147483647L)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sInvalidValue_208() + CHIP_ERROR TestWriteAttributeNullableInt32sInvalidValue_209() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37240,33 +37299,33 @@ class TestCluster : public TestCommand nullableInt32sArgument.SetNonNull() = -2147483648L; return cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_208, OnFailureCallback_208); + nullableInt32sArgument, this, OnSuccessCallback_209, OnFailureCallback_209); } - void OnFailureResponse_208(uint8_t status) { NextTest(); } + void OnFailureResponse_209(uint8_t status) { NextTest(); } - void OnSuccessResponse_208() { ThrowSuccessResponse(); } + void OnSuccessResponse_209() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt32sUnchangedValue_209() + CHIP_ERROR TestReadAttributeNullableInt32sUnchangedValue_210() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_209, OnFailureCallback_209); + this, OnSuccessCallback_210, OnFailureCallback_210); } - void OnFailureResponse_209(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_210(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_209(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_210(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckValueNonNull("nullableInt32s", nullableInt32s)); - VerifyOrReturn(CheckValue("nullableInt32s.Value()", nullableInt32s.Value(), -2147483647L)); + VerifyOrReturn(CheckValue("nullableInt32s.Value()", nullableInt32s.Value(), -2147483647L)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sNullValue_210() + CHIP_ERROR TestWriteAttributeNullableInt32sNullValue_211() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37276,32 +37335,32 @@ class TestCluster : public TestCommand nullableInt32sArgument.SetNull(); return cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_210, OnFailureCallback_210); + nullableInt32sArgument, this, OnSuccessCallback_211, OnFailureCallback_211); } - void OnFailureResponse_210(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_211(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_210() { NextTest(); } + void OnSuccessResponse_211() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sNullValue_211() + CHIP_ERROR TestReadAttributeNullableInt32sNullValue_212() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_211, OnFailureCallback_211); + this, OnSuccessCallback_212, OnFailureCallback_212); } - void OnFailureResponse_211(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_212(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_211(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_212(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckValueNull("nullableInt32s", nullableInt32s)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sMinValue_212() + CHIP_ERROR TestWriteAttributeNullableInt64sMinValue_213() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37311,33 +37370,33 @@ class TestCluster : public TestCommand nullableInt64sArgument.SetNonNull() = -9223372036854775807LL; return cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_212, OnFailureCallback_212); + nullableInt64sArgument, this, OnSuccessCallback_213, OnFailureCallback_213); } - void OnFailureResponse_212(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_213(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_212() { NextTest(); } + void OnSuccessResponse_213() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sMinValue_213() + CHIP_ERROR TestReadAttributeNullableInt64sMinValue_214() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_213, OnFailureCallback_213); + this, OnSuccessCallback_214, OnFailureCallback_214); } - void OnFailureResponse_213(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_214(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_213(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_214(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckValueNonNull("nullableInt64s", nullableInt64s)); - VerifyOrReturn(CheckValue("nullableInt64s.Value()", nullableInt64s.Value(), -9223372036854775807LL)); + VerifyOrReturn(CheckValue("nullableInt64s.Value()", nullableInt64s.Value(), -9223372036854775807LL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sInvalidValue_214() + CHIP_ERROR TestWriteAttributeNullableInt64sInvalidValue_215() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37347,33 +37406,33 @@ class TestCluster : public TestCommand nullableInt64sArgument.SetNonNull() = -9223372036854775807LL - 1LL; return cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_214, OnFailureCallback_214); + nullableInt64sArgument, this, OnSuccessCallback_215, OnFailureCallback_215); } - void OnFailureResponse_214(uint8_t status) { NextTest(); } + void OnFailureResponse_215(uint8_t status) { NextTest(); } - void OnSuccessResponse_214() { ThrowSuccessResponse(); } + void OnSuccessResponse_215() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt64sUnchangedValue_215() + CHIP_ERROR TestReadAttributeNullableInt64sUnchangedValue_216() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_215, OnFailureCallback_215); + this, OnSuccessCallback_216, OnFailureCallback_216); } - void OnFailureResponse_215(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_216(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_215(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_216(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckValueNonNull("nullableInt64s", nullableInt64s)); - VerifyOrReturn(CheckValue("nullableInt64s.Value()", nullableInt64s.Value(), -9223372036854775807LL)); + VerifyOrReturn(CheckValue("nullableInt64s.Value()", nullableInt64s.Value(), -9223372036854775807LL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sNullValue_216() + CHIP_ERROR TestWriteAttributeNullableInt64sNullValue_217() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37383,32 +37442,32 @@ class TestCluster : public TestCommand nullableInt64sArgument.SetNull(); return cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_216, OnFailureCallback_216); + nullableInt64sArgument, this, OnSuccessCallback_217, OnFailureCallback_217); } - void OnFailureResponse_216(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_217(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_216() { NextTest(); } + void OnSuccessResponse_217() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sNullValue_217() + CHIP_ERROR TestReadAttributeNullableInt64sNullValue_218() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_217, OnFailureCallback_217); + this, OnSuccessCallback_218, OnFailureCallback_218); } - void OnFailureResponse_217(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_218(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_217(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_218(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckValueNull("nullableInt64s", nullableInt64s)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8MaxValue_218() + CHIP_ERROR TestWriteAttributeNullableEnum8MaxValue_219() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37418,33 +37477,33 @@ class TestCluster : public TestCommand nullableEnum8Argument.SetNonNull() = static_cast(254); return cluster.WriteAttribute( - nullableEnum8Argument, this, OnSuccessCallback_218, OnFailureCallback_218); + nullableEnum8Argument, this, OnSuccessCallback_219, OnFailureCallback_219); } - void OnFailureResponse_218(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_219(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_218() { NextTest(); } + void OnSuccessResponse_219() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum8MaxValue_219() + CHIP_ERROR TestReadAttributeNullableEnum8MaxValue_220() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_219, OnFailureCallback_219); + this, OnSuccessCallback_220, OnFailureCallback_220); } - void OnFailureResponse_219(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_220(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_219(const chip::app::DataModel::Nullable & nullableEnum8) + void OnSuccessResponse_220(const chip::app::DataModel::Nullable & nullableEnum8) { VerifyOrReturn(CheckValueNonNull("nullableEnum8", nullableEnum8)); - VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 254)); + VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 254)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8InvalidValue_220() + CHIP_ERROR TestWriteAttributeNullableEnum8InvalidValue_221() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37454,33 +37513,33 @@ class TestCluster : public TestCommand nullableEnum8Argument.SetNonNull() = static_cast(255); return cluster.WriteAttribute( - nullableEnum8Argument, this, OnSuccessCallback_220, OnFailureCallback_220); + nullableEnum8Argument, this, OnSuccessCallback_221, OnFailureCallback_221); } - void OnFailureResponse_220(uint8_t status) { NextTest(); } + void OnFailureResponse_221(uint8_t status) { NextTest(); } - void OnSuccessResponse_220() { ThrowSuccessResponse(); } + void OnSuccessResponse_221() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableEnum8UnchangedValue_221() + CHIP_ERROR TestReadAttributeNullableEnum8UnchangedValue_222() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_221, OnFailureCallback_221); + this, OnSuccessCallback_222, OnFailureCallback_222); } - void OnFailureResponse_221(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_222(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_221(const chip::app::DataModel::Nullable & nullableEnum8) + void OnSuccessResponse_222(const chip::app::DataModel::Nullable & nullableEnum8) { VerifyOrReturn(CheckValueNonNull("nullableEnum8", nullableEnum8)); - VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 254)); + VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 254)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8NullValue_222() + CHIP_ERROR TestWriteAttributeNullableEnum8NullValue_223() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37490,32 +37549,32 @@ class TestCluster : public TestCommand nullableEnum8Argument.SetNull(); return cluster.WriteAttribute( - nullableEnum8Argument, this, OnSuccessCallback_222, OnFailureCallback_222); + nullableEnum8Argument, this, OnSuccessCallback_223, OnFailureCallback_223); } - void OnFailureResponse_222(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_223(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_222() { NextTest(); } + void OnSuccessResponse_223() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum8NullValue_223() + CHIP_ERROR TestReadAttributeNullableEnum8NullValue_224() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_223, OnFailureCallback_223); + this, OnSuccessCallback_224, OnFailureCallback_224); } - void OnFailureResponse_223(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_224(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_223(const chip::app::DataModel::Nullable & nullableEnum8) + void OnSuccessResponse_224(const chip::app::DataModel::Nullable & nullableEnum8) { VerifyOrReturn(CheckValueNull("nullableEnum8", nullableEnum8)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16MaxValue_224() + CHIP_ERROR TestWriteAttributeNullableEnum16MaxValue_225() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37525,33 +37584,33 @@ class TestCluster : public TestCommand nullableEnum16Argument.SetNonNull() = static_cast(65534); return cluster.WriteAttribute( - nullableEnum16Argument, this, OnSuccessCallback_224, OnFailureCallback_224); + nullableEnum16Argument, this, OnSuccessCallback_225, OnFailureCallback_225); } - void OnFailureResponse_224(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_225(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_224() { NextTest(); } + void OnSuccessResponse_225() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum16MaxValue_225() + CHIP_ERROR TestReadAttributeNullableEnum16MaxValue_226() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_225, OnFailureCallback_225); + this, OnSuccessCallback_226, OnFailureCallback_226); } - void OnFailureResponse_225(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_226(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_225(const chip::app::DataModel::Nullable & nullableEnum16) + void OnSuccessResponse_226(const chip::app::DataModel::Nullable & nullableEnum16) { VerifyOrReturn(CheckValueNonNull("nullableEnum16", nullableEnum16)); - VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 65534U)); + VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 65534U)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16InvalidValue_226() + CHIP_ERROR TestWriteAttributeNullableEnum16InvalidValue_227() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37561,33 +37620,33 @@ class TestCluster : public TestCommand nullableEnum16Argument.SetNonNull() = static_cast(65535); return cluster.WriteAttribute( - nullableEnum16Argument, this, OnSuccessCallback_226, OnFailureCallback_226); + nullableEnum16Argument, this, OnSuccessCallback_227, OnFailureCallback_227); } - void OnFailureResponse_226(uint8_t status) { NextTest(); } + void OnFailureResponse_227(uint8_t status) { NextTest(); } - void OnSuccessResponse_226() { ThrowSuccessResponse(); } + void OnSuccessResponse_227() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableEnum16UnchangedValue_227() + CHIP_ERROR TestReadAttributeNullableEnum16UnchangedValue_228() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_227, OnFailureCallback_227); + this, OnSuccessCallback_228, OnFailureCallback_228); } - void OnFailureResponse_227(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_228(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_227(const chip::app::DataModel::Nullable & nullableEnum16) + void OnSuccessResponse_228(const chip::app::DataModel::Nullable & nullableEnum16) { VerifyOrReturn(CheckValueNonNull("nullableEnum16", nullableEnum16)); - VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 65534U)); + VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 65534U)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16NullValue_228() + CHIP_ERROR TestWriteAttributeNullableEnum16NullValue_229() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37597,44 +37656,44 @@ class TestCluster : public TestCommand nullableEnum16Argument.SetNull(); return cluster.WriteAttribute( - nullableEnum16Argument, this, OnSuccessCallback_228, OnFailureCallback_228); + nullableEnum16Argument, this, OnSuccessCallback_229, OnFailureCallback_229); } - void OnFailureResponse_228(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_229(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_228() { NextTest(); } + void OnSuccessResponse_229() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum16NullValue_229() + CHIP_ERROR TestReadAttributeNullableEnum16NullValue_230() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_229, OnFailureCallback_229); + this, OnSuccessCallback_230, OnFailureCallback_230); } - void OnFailureResponse_229(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_230(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_229(const chip::app::DataModel::Nullable & nullableEnum16) + void OnSuccessResponse_230(const chip::app::DataModel::Nullable & nullableEnum16) { VerifyOrReturn(CheckValueNull("nullableEnum16", nullableEnum16)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetStringDefaultValue_230() + CHIP_ERROR TestReadAttributeNullableOctetStringDefaultValue_231() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_230, OnFailureCallback_230); + this, OnSuccessCallback_231, OnFailureCallback_231); } - void OnFailureResponse_230(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_231(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_230(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_231(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), @@ -37642,7 +37701,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableOctetString_231() + CHIP_ERROR TestWriteAttributeNullableOctetString_232() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37653,26 +37712,26 @@ class TestCluster : public TestCommand chip::ByteSpan(chip::Uint8::from_const_char("TestValuegarbage: not in length on purpose"), 9); return cluster.WriteAttribute( - nullableOctetStringArgument, this, OnSuccessCallback_231, OnFailureCallback_231); + nullableOctetStringArgument, this, OnSuccessCallback_232, OnFailureCallback_232); } - void OnFailureResponse_231(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_232(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_231() { NextTest(); } + void OnSuccessResponse_232() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetString_232() + CHIP_ERROR TestReadAttributeNullableOctetString_233() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_232, OnFailureCallback_232); + this, OnSuccessCallback_233, OnFailureCallback_233); } - void OnFailureResponse_232(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_233(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_232(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_233(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), @@ -37680,7 +37739,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableOctetString_233() + CHIP_ERROR TestWriteAttributeNullableOctetString_234() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37690,32 +37749,32 @@ class TestCluster : public TestCommand nullableOctetStringArgument.SetNull(); return cluster.WriteAttribute( - nullableOctetStringArgument, this, OnSuccessCallback_233, OnFailureCallback_233); + nullableOctetStringArgument, this, OnSuccessCallback_234, OnFailureCallback_234); } - void OnFailureResponse_233(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_234(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_233() { NextTest(); } + void OnSuccessResponse_234() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetString_234() + CHIP_ERROR TestReadAttributeNullableOctetString_235() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_234, OnFailureCallback_234); + this, OnSuccessCallback_235, OnFailureCallback_235); } - void OnFailureResponse_234(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_235(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_234(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_235(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNull("nullableOctetString", nullableOctetString)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableOctetString_235() + CHIP_ERROR TestWriteAttributeNullableOctetString_236() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37726,26 +37785,26 @@ class TestCluster : public TestCommand chip::ByteSpan(chip::Uint8::from_const_char("garbage: not in length on purpose"), 0); return cluster.WriteAttribute( - nullableOctetStringArgument, this, OnSuccessCallback_235, OnFailureCallback_235); + nullableOctetStringArgument, this, OnSuccessCallback_236, OnFailureCallback_236); } - void OnFailureResponse_235(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_236(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_235() { NextTest(); } + void OnSuccessResponse_236() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetString_236() + CHIP_ERROR TestReadAttributeNullableOctetString_237() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_236, OnFailureCallback_236); + this, OnSuccessCallback_237, OnFailureCallback_237); } - void OnFailureResponse_236(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_237(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_236(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_237(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), @@ -37753,26 +37812,26 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharStringDefaultValue_237() + CHIP_ERROR TestReadAttributeNullableCharStringDefaultValue_238() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_237, OnFailureCallback_237); + this, OnSuccessCallback_238, OnFailureCallback_238); } - void OnFailureResponse_237(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_238(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_237(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_238(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNonNull("nullableCharString", nullableCharString)); VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", nullableCharString.Value(), chip::CharSpan("", 0))); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableCharString_238() + CHIP_ERROR TestWriteAttributeNullableCharString_239() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37782,14 +37841,14 @@ class TestCluster : public TestCommand nullableCharStringArgument.SetNonNull() = chip::Span("☉T☉garbage: not in length on purpose", 3); return cluster.WriteAttribute( - nullableCharStringArgument, this, OnSuccessCallback_238, OnFailureCallback_238); + nullableCharStringArgument, this, OnSuccessCallback_239, OnFailureCallback_239); } - void OnFailureResponse_238(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_239(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_238() { NextTest(); } + void OnSuccessResponse_239() { NextTest(); } - CHIP_ERROR TestWriteAttributeNullableCharStringValueTooLong_239() + CHIP_ERROR TestWriteAttributeNullableCharStringValueTooLong_240() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37799,32 +37858,32 @@ class TestCluster : public TestCommand nullableCharStringArgument.SetNull(); return cluster.WriteAttribute( - nullableCharStringArgument, this, OnSuccessCallback_239, OnFailureCallback_239); + nullableCharStringArgument, this, OnSuccessCallback_240, OnFailureCallback_240); } - void OnFailureResponse_239(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_240(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_239() { NextTest(); } + void OnSuccessResponse_240() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharString_240() + CHIP_ERROR TestReadAttributeNullableCharString_241() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_240, OnFailureCallback_240); + this, OnSuccessCallback_241, OnFailureCallback_241); } - void OnFailureResponse_240(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_241(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_240(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_241(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNull("nullableCharString", nullableCharString)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableCharStringEmpty_241() + CHIP_ERROR TestWriteAttributeNullableCharStringEmpty_242() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37834,45 +37893,45 @@ class TestCluster : public TestCommand nullableCharStringArgument.SetNonNull() = chip::Span("garbage: not in length on purpose", 0); return cluster.WriteAttribute( - nullableCharStringArgument, this, OnSuccessCallback_241, OnFailureCallback_241); + nullableCharStringArgument, this, OnSuccessCallback_242, OnFailureCallback_242); } - void OnFailureResponse_241(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_242(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_241() { NextTest(); } + void OnSuccessResponse_242() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharString_242() + CHIP_ERROR TestReadAttributeNullableCharString_243() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_242, OnFailureCallback_242); + this, OnSuccessCallback_243, OnFailureCallback_243); } - void OnFailureResponse_242(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_243(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_242(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_243(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNonNull("nullableCharString", nullableCharString)); VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", nullableCharString.Value(), chip::CharSpan("", 0))); NextTest(); } - CHIP_ERROR TestReadNonexistentAttribute_243() + CHIP_ERROR TestReadNonexistentAttribute_244() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 200; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevice, endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_243, - OnFailureCallback_243); + return cluster.ReadAttribute(this, OnSuccessCallback_244, + OnFailureCallback_244); } - void OnFailureResponse_243(uint8_t status) { NextTest(); } + void OnFailureResponse_244(uint8_t status) { NextTest(); } - void OnSuccessResponse_243(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } + void OnSuccessResponse_244(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } }; class TestClusterComplexTypes : public TestCommand @@ -37952,10 +38011,10 @@ class TestClusterComplexTypes : public TestCommand void OnSuccessResponse_0(bool wasPresent, const chip::Optional & wasNull, const chip::Optional & value, const chip::Optional> & originalValue) { - VerifyOrReturn(CheckValue("wasPresent", wasPresent, true)); + VerifyOrReturn(CheckValue("wasPresent", wasPresent, true)); VerifyOrReturn(CheckValuePresent("wasNull", wasNull)); - VerifyOrReturn(CheckValue("wasNull.Value()", wasNull.Value(), true)); + VerifyOrReturn(CheckValue("wasNull.Value()", wasNull.Value(), true)); VerifyOrReturn(CheckValuePresent("originalValue", originalValue)); VerifyOrReturn(CheckValueNull("originalValue.Value()", originalValue.Value())); @@ -38365,8 +38424,8 @@ class TestDescriptorCluster : public TestCommand { auto iter = deviceList.begin(); VerifyOrReturn(CheckNextListItemDecodes("deviceList", iter, 0)); - VerifyOrReturn(CheckValue<>("deviceList[0].type", iter.GetValue().type, 0UL)); - VerifyOrReturn(CheckValue<>("deviceList[0].revision", iter.GetValue().revision, 1U)); + VerifyOrReturn(CheckValue("deviceList[0].type", iter.GetValue().type, 0UL)); + VerifyOrReturn(CheckValue("deviceList[0].revision", iter.GetValue().revision, 1U)); VerifyOrReturn(CheckNoMoreListItems("deviceList", iter, 1)); NextTest(); } @@ -38387,41 +38446,41 @@ class TestDescriptorCluster : public TestCommand { auto iter = serverList.begin(); VerifyOrReturn(CheckNextListItemDecodes("serverList", iter, 0)); - VerifyOrReturn(CheckValue("serverList[0]", iter.GetValue(), 3UL)); + VerifyOrReturn(CheckValue("serverList[0]", iter.GetValue(), 3UL)); VerifyOrReturn(CheckNextListItemDecodes("serverList", iter, 1)); - VerifyOrReturn(CheckValue("serverList[1]", iter.GetValue(), 29UL)); + VerifyOrReturn(CheckValue("serverList[1]", iter.GetValue(), 29UL)); VerifyOrReturn(CheckNextListItemDecodes("serverList", iter, 2)); - VerifyOrReturn(CheckValue("serverList[2]", iter.GetValue(), 40UL)); + VerifyOrReturn(CheckValue("serverList[2]", iter.GetValue(), 40UL)); VerifyOrReturn(CheckNextListItemDecodes("serverList", iter, 3)); - VerifyOrReturn(CheckValue("serverList[3]", iter.GetValue(), 41UL)); + VerifyOrReturn(CheckValue("serverList[3]", iter.GetValue(), 41UL)); VerifyOrReturn(CheckNextListItemDecodes("serverList", iter, 4)); - VerifyOrReturn(CheckValue("serverList[4]", iter.GetValue(), 42UL)); + VerifyOrReturn(CheckValue("serverList[4]", iter.GetValue(), 42UL)); VerifyOrReturn(CheckNextListItemDecodes("serverList", iter, 5)); - VerifyOrReturn(CheckValue("serverList[5]", iter.GetValue(), 48UL)); + VerifyOrReturn(CheckValue("serverList[5]", iter.GetValue(), 48UL)); VerifyOrReturn(CheckNextListItemDecodes("serverList", iter, 6)); - VerifyOrReturn(CheckValue("serverList[6]", iter.GetValue(), 49UL)); + VerifyOrReturn(CheckValue("serverList[6]", iter.GetValue(), 49UL)); VerifyOrReturn(CheckNextListItemDecodes("serverList", iter, 7)); - VerifyOrReturn(CheckValue("serverList[7]", iter.GetValue(), 50UL)); + VerifyOrReturn(CheckValue("serverList[7]", iter.GetValue(), 50UL)); VerifyOrReturn(CheckNextListItemDecodes("serverList", iter, 8)); - VerifyOrReturn(CheckValue("serverList[8]", iter.GetValue(), 51UL)); + VerifyOrReturn(CheckValue("serverList[8]", iter.GetValue(), 51UL)); VerifyOrReturn(CheckNextListItemDecodes("serverList", iter, 9)); - VerifyOrReturn(CheckValue("serverList[9]", iter.GetValue(), 52UL)); + VerifyOrReturn(CheckValue("serverList[9]", iter.GetValue(), 52UL)); VerifyOrReturn(CheckNextListItemDecodes("serverList", iter, 10)); - VerifyOrReturn(CheckValue("serverList[10]", iter.GetValue(), 53UL)); + VerifyOrReturn(CheckValue("serverList[10]", iter.GetValue(), 53UL)); VerifyOrReturn(CheckNextListItemDecodes("serverList", iter, 11)); - VerifyOrReturn(CheckValue("serverList[11]", iter.GetValue(), 54UL)); + VerifyOrReturn(CheckValue("serverList[11]", iter.GetValue(), 54UL)); VerifyOrReturn(CheckNextListItemDecodes("serverList", iter, 12)); - VerifyOrReturn(CheckValue("serverList[12]", iter.GetValue(), 55UL)); + VerifyOrReturn(CheckValue("serverList[12]", iter.GetValue(), 55UL)); VerifyOrReturn(CheckNextListItemDecodes("serverList", iter, 13)); - VerifyOrReturn(CheckValue("serverList[13]", iter.GetValue(), 60UL)); + VerifyOrReturn(CheckValue("serverList[13]", iter.GetValue(), 60UL)); VerifyOrReturn(CheckNextListItemDecodes("serverList", iter, 14)); - VerifyOrReturn(CheckValue("serverList[14]", iter.GetValue(), 62UL)); + VerifyOrReturn(CheckValue("serverList[14]", iter.GetValue(), 62UL)); VerifyOrReturn(CheckNextListItemDecodes("serverList", iter, 15)); - VerifyOrReturn(CheckValue("serverList[15]", iter.GetValue(), 1029UL)); + VerifyOrReturn(CheckValue("serverList[15]", iter.GetValue(), 1029UL)); VerifyOrReturn(CheckNextListItemDecodes("serverList", iter, 16)); - VerifyOrReturn(CheckValue("serverList[16]", iter.GetValue(), 61440UL)); + VerifyOrReturn(CheckValue("serverList[16]", iter.GetValue(), 61440UL)); VerifyOrReturn(CheckNextListItemDecodes("serverList", iter, 17)); - VerifyOrReturn(CheckValue("serverList[17]", iter.GetValue(), 61444UL)); + VerifyOrReturn(CheckValue("serverList[17]", iter.GetValue(), 61444UL)); VerifyOrReturn(CheckNoMoreListItems("serverList", iter, 18)); NextTest(); } @@ -38461,9 +38520,9 @@ class TestDescriptorCluster : public TestCommand { auto iter = partsList.begin(); VerifyOrReturn(CheckNextListItemDecodes("partsList", iter, 0)); - VerifyOrReturn(CheckValue("partsList[0]", iter.GetValue(), 1U)); + VerifyOrReturn(CheckValue("partsList[0]", iter.GetValue(), 1U)); VerifyOrReturn(CheckNextListItemDecodes("partsList", iter, 1)); - VerifyOrReturn(CheckValue("partsList[1]", iter.GetValue(), 2U)); + VerifyOrReturn(CheckValue("partsList[1]", iter.GetValue(), 2U)); VerifyOrReturn(CheckNoMoreListItems("partsList", iter, 2)); NextTest(); } @@ -38844,9 +38903,9 @@ class TestGroupsCluster : public TestCommand void OnSuccessResponse_0(uint8_t status, uint16_t groupId, chip::CharSpan groupName) { - VerifyOrReturn(CheckValue("status", status, 135)); + VerifyOrReturn(CheckValue("status", status, 135)); - VerifyOrReturn(CheckValue("groupId", groupId, 0U)); + VerifyOrReturn(CheckValue("groupId", groupId, 0U)); NextTest(); } @@ -38875,9 +38934,9 @@ class TestGroupsCluster : public TestCommand void OnSuccessResponse_1(uint8_t status, uint16_t groupId, chip::CharSpan groupName) { - VerifyOrReturn(CheckValue("status", status, 139)); + VerifyOrReturn(CheckValue("status", status, 139)); - VerifyOrReturn(CheckValue("groupId", groupId, 1U)); + VerifyOrReturn(CheckValue("groupId", groupId, 1U)); NextTest(); } @@ -38907,9 +38966,9 @@ class TestGroupsCluster : public TestCommand void OnSuccessResponse_2(uint8_t status, uint16_t groupId) { - VerifyOrReturn(CheckValue("status", status, 0)); + VerifyOrReturn(CheckValue("status", status, 0)); - VerifyOrReturn(CheckValue("groupId", groupId, 1U)); + VerifyOrReturn(CheckValue("groupId", groupId, 1U)); NextTest(); } @@ -38937,9 +38996,9 @@ class TestGroupsCluster : public TestCommand void OnSuccessResponse_3(uint8_t status, uint16_t groupId, chip::CharSpan groupName) { - VerifyOrReturn(CheckValue("status", status, 0)); + VerifyOrReturn(CheckValue("status", status, 0)); - VerifyOrReturn(CheckValue("groupId", groupId, 1U)); + VerifyOrReturn(CheckValue("groupId", groupId, 1U)); VerifyOrReturn(CheckValueAsString("groupName", groupName, chip::CharSpan("Group #1", 8))); NextTest(); @@ -38969,9 +39028,9 @@ class TestGroupsCluster : public TestCommand void OnSuccessResponse_4(uint8_t status, uint16_t groupId, chip::CharSpan groupName) { - VerifyOrReturn(CheckValue("status", status, 139)); + VerifyOrReturn(CheckValue("status", status, 139)); - VerifyOrReturn(CheckValue("groupId", groupId, 4369U)); + VerifyOrReturn(CheckValue("groupId", groupId, 4369U)); NextTest(); } @@ -39000,9 +39059,9 @@ class TestGroupsCluster : public TestCommand void OnSuccessResponse_5(uint8_t status, uint16_t groupId, chip::CharSpan groupName) { - VerifyOrReturn(CheckValue("status", status, 139)); + VerifyOrReturn(CheckValue("status", status, 139)); - VerifyOrReturn(CheckValue("groupId", groupId, 32767U)); + VerifyOrReturn(CheckValue("groupId", groupId, 32767U)); NextTest(); } @@ -39031,9 +39090,9 @@ class TestGroupsCluster : public TestCommand void OnSuccessResponse_6(uint8_t status, uint16_t groupId, chip::CharSpan groupName) { - VerifyOrReturn(CheckValue("status", status, 0)); + VerifyOrReturn(CheckValue("status", status, 0)); - VerifyOrReturn(CheckValue("groupId", groupId, 1U)); + VerifyOrReturn(CheckValue("groupId", groupId, 1U)); VerifyOrReturn(CheckValueAsString("groupName", groupName, chip::CharSpan("Group #1", 8))); NextTest(); @@ -39063,9 +39122,9 @@ class TestGroupsCluster : public TestCommand void OnSuccessResponse_7(uint8_t status, uint16_t groupId) { - VerifyOrReturn(CheckValue("status", status, 135)); + VerifyOrReturn(CheckValue("status", status, 135)); - VerifyOrReturn(CheckValue("groupId", groupId, 0U)); + VerifyOrReturn(CheckValue("groupId", groupId, 0U)); NextTest(); } @@ -39093,9 +39152,9 @@ class TestGroupsCluster : public TestCommand void OnSuccessResponse_8(uint8_t status, uint16_t groupId) { - VerifyOrReturn(CheckValue("status", status, 139)); + VerifyOrReturn(CheckValue("status", status, 139)); - VerifyOrReturn(CheckValue("groupId", groupId, 4U)); + VerifyOrReturn(CheckValue("groupId", groupId, 4U)); NextTest(); } @@ -39123,9 +39182,9 @@ class TestGroupsCluster : public TestCommand void OnSuccessResponse_9(uint8_t status, uint16_t groupId, chip::CharSpan groupName) { - VerifyOrReturn(CheckValue("status", status, 0)); + VerifyOrReturn(CheckValue("status", status, 0)); - VerifyOrReturn(CheckValue("groupId", groupId, 1U)); + VerifyOrReturn(CheckValue("groupId", groupId, 1U)); VerifyOrReturn(CheckValueAsString("groupName", groupName, chip::CharSpan("Group #1", 8))); NextTest(); @@ -39155,9 +39214,9 @@ class TestGroupsCluster : public TestCommand void OnSuccessResponse_10(uint8_t status, uint16_t groupId, chip::CharSpan groupName) { - VerifyOrReturn(CheckValue("status", status, 139)); + VerifyOrReturn(CheckValue("status", status, 139)); - VerifyOrReturn(CheckValue("groupId", groupId, 4369U)); + VerifyOrReturn(CheckValue("groupId", groupId, 4369U)); NextTest(); } @@ -39209,9 +39268,9 @@ class TestGroupsCluster : public TestCommand void OnSuccessResponse_12(uint8_t status, uint16_t groupId, chip::CharSpan groupName) { - VerifyOrReturn(CheckValue("status", status, 139)); + VerifyOrReturn(CheckValue("status", status, 139)); - VerifyOrReturn(CheckValue("groupId", groupId, 1U)); + VerifyOrReturn(CheckValue("groupId", groupId, 1U)); NextTest(); } @@ -39240,9 +39299,9 @@ class TestGroupsCluster : public TestCommand void OnSuccessResponse_13(uint8_t status, uint16_t groupId, chip::CharSpan groupName) { - VerifyOrReturn(CheckValue("status", status, 139)); + VerifyOrReturn(CheckValue("status", status, 139)); - VerifyOrReturn(CheckValue("groupId", groupId, 4369U)); + VerifyOrReturn(CheckValue("groupId", groupId, 4369U)); NextTest(); } @@ -39271,9 +39330,9 @@ class TestGroupsCluster : public TestCommand void OnSuccessResponse_14(uint8_t status, uint16_t groupId, chip::CharSpan groupName) { - VerifyOrReturn(CheckValue("status", status, 139)); + VerifyOrReturn(CheckValue("status", status, 139)); - VerifyOrReturn(CheckValue("groupId", groupId, 32767U)); + VerifyOrReturn(CheckValue("groupId", groupId, 32767U)); NextTest(); } @@ -39582,7 +39641,7 @@ class TestModeSelectCluster : public TestCommand void OnSuccessResponse_0(uint8_t currentMode) { - VerifyOrReturn(CheckValue("currentMode", currentMode, 0)); + VerifyOrReturn(CheckValue("currentMode", currentMode, 0)); NextTest(); } @@ -39600,7 +39659,7 @@ class TestModeSelectCluster : public TestCommand void OnSuccessResponse_1(uint8_t onMode) { - VerifyOrReturn(CheckValue("onMode", onMode, 0)); + VerifyOrReturn(CheckValue("onMode", onMode, 0)); NextTest(); } @@ -39618,7 +39677,7 @@ class TestModeSelectCluster : public TestCommand void OnSuccessResponse_2(uint8_t startUpMode) { - VerifyOrReturn(CheckValue("startUpMode", startUpMode, 0)); + VerifyOrReturn(CheckValue("startUpMode", startUpMode, 0)); NextTest(); } @@ -39659,16 +39718,16 @@ class TestModeSelectCluster : public TestCommand auto iter = supportedModes.begin(); VerifyOrReturn(CheckNextListItemDecodes("supportedModes", iter, 0)); VerifyOrReturn(CheckValueAsString("supportedModes[0].label", iter.GetValue().label, chip::CharSpan("Black", 5))); - VerifyOrReturn(CheckValue<>("supportedModes[0].mode", iter.GetValue().mode, 0)); - VerifyOrReturn(CheckValue<>("supportedModes[0].semanticTag", iter.GetValue().semanticTag, 0UL)); + VerifyOrReturn(CheckValue("supportedModes[0].mode", iter.GetValue().mode, 0)); + VerifyOrReturn(CheckValue("supportedModes[0].semanticTag", iter.GetValue().semanticTag, 0UL)); VerifyOrReturn(CheckNextListItemDecodes("supportedModes", iter, 1)); VerifyOrReturn(CheckValueAsString("supportedModes[1].label", iter.GetValue().label, chip::CharSpan("Cappuccino", 10))); - VerifyOrReturn(CheckValue<>("supportedModes[1].mode", iter.GetValue().mode, 4)); - VerifyOrReturn(CheckValue<>("supportedModes[1].semanticTag", iter.GetValue().semanticTag, 0UL)); + VerifyOrReturn(CheckValue("supportedModes[1].mode", iter.GetValue().mode, 4)); + VerifyOrReturn(CheckValue("supportedModes[1].semanticTag", iter.GetValue().semanticTag, 0UL)); VerifyOrReturn(CheckNextListItemDecodes("supportedModes", iter, 2)); VerifyOrReturn(CheckValueAsString("supportedModes[2].label", iter.GetValue().label, chip::CharSpan("Espresso", 8))); - VerifyOrReturn(CheckValue<>("supportedModes[2].mode", iter.GetValue().mode, 7)); - VerifyOrReturn(CheckValue<>("supportedModes[2].semanticTag", iter.GetValue().semanticTag, 0UL)); + VerifyOrReturn(CheckValue("supportedModes[2].mode", iter.GetValue().mode, 7)); + VerifyOrReturn(CheckValue("supportedModes[2].semanticTag", iter.GetValue().semanticTag, 0UL)); VerifyOrReturn(CheckNoMoreListItems("supportedModes", iter, 3)); NextTest(); } @@ -39711,7 +39770,7 @@ class TestModeSelectCluster : public TestCommand void OnSuccessResponse_6(uint8_t currentMode) { - VerifyOrReturn(CheckValue("currentMode", currentMode, 4)); + VerifyOrReturn(CheckValue("currentMode", currentMode, 4)); NextTest(); } @@ -40328,7 +40387,7 @@ class TestSubscribe_OnOff : public TestCommand VerifyOrReturn(mReceivedReport_1 == false, ChipLogError(chipTool, "Not Fatal: on report called more than once.")); mReceivedReport_1 = true; - VerifyOrReturn(CheckValue("onOff", onOff, false)); + VerifyOrReturn(CheckValue("onOff", onOff, false)); } CHIP_ERROR TestSubscribeOnOffAttribute_2() @@ -40394,7 +40453,7 @@ class TestSubscribe_OnOff : public TestCommand VerifyOrReturn(mReceivedReport_4 == false, ChipLogError(chipTool, "Not Fatal: on report called more than once.")); mReceivedReport_4 = true; - VerifyOrReturn(CheckValue("onOff", onOff, true)); + VerifyOrReturn(CheckValue("onOff", onOff, true)); NextTest(); } @@ -40437,7 +40496,7 @@ class TestSubscribe_OnOff : public TestCommand VerifyOrReturn(mReceivedReport_6 == false, ChipLogError(chipTool, "Not Fatal: on report called more than once.")); mReceivedReport_6 = true; - VerifyOrReturn(CheckValue("onOff", onOff, false)); + VerifyOrReturn(CheckValue("onOff", onOff, false)); NextTest(); } }; diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClientCallbacks.cpp b/zzz_generated/controller-clusters/zap-generated/CHIPClientCallbacks.cpp index 6ce687acc7ca5b..8c77edd9386c03 100644 --- a/zzz_generated/controller-clusters/zap-generated/CHIPClientCallbacks.cpp +++ b/zzz_generated/controller-clusters/zap-generated/CHIPClientCallbacks.cpp @@ -1967,6 +1967,21 @@ bool emberAfTestClusterClusterBooleanResponseCallback(EndpointId endpoint, app:: return true; } +bool emberAfTestClusterClusterSimpleStructResponseCallback( + EndpointId endpoint, app::CommandSender * commandObj, + chip::app::Clusters::TestCluster::Structs::SimpleStruct::DecodableType arg1) +{ + ChipLogProgress(Zcl, "SimpleStructResponse:"); + ChipLogProgress(Zcl, " arg1: Not sure how to log struct SimpleStruct"); + + GET_CLUSTER_RESPONSE_CALLBACKS("TestClusterClusterSimpleStructResponseCallback"); + + Callback::Callback * cb = + Callback::Callback::FromCancelable(onSuccessCallback); + cb->mCall(cb->mContext, SimpleStruct()); + return true; +} + bool emberAfTestClusterClusterTestAddArgumentsResponseCallback(EndpointId endpoint, app::CommandSender * commandObj, uint8_t returnValue) { diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClientCallbacks.h b/zzz_generated/controller-clusters/zap-generated/CHIPClientCallbacks.h index f67b8e2edaefc1..7878f809b2dad2 100644 --- a/zzz_generated/controller-clusters/zap-generated/CHIPClientCallbacks.h +++ b/zzz_generated/controller-clusters/zap-generated/CHIPClientCallbacks.h @@ -143,6 +143,7 @@ typedef void (*TvChannelClusterChangeChannelResponseCallback)(void * context, uint8_t ErrorType); typedef void (*TargetNavigatorClusterNavigateTargetResponseCallback)(void * context, uint8_t status, chip::CharSpan data); typedef void (*TestClusterClusterBooleanResponseCallback)(void * context, bool value); +typedef void (*TestClusterClusterSimpleStructResponseCallback)(void * context, SimpleStruct arg1); typedef void (*TestClusterClusterTestAddArgumentsResponseCallback)(void * context, uint8_t returnValue); typedef void (*TestClusterClusterTestEnumsResponseCallback)(void * context, chip::VendorId arg1, uint8_t arg2); typedef void (*TestClusterClusterTestListInt8UReverseResponseCallback)(void * context, diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp index 50082b2285f1d4..ef07e2f272e671 100644 --- a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp +++ b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp @@ -15665,6 +15665,63 @@ CHIP_ERROR TemperatureMeasurementCluster::ReportAttributeClusterRevision(Callbac } // TestCluster Cluster Commands +CHIP_ERROR TestClusterCluster::SimpleStructEchoRequest(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint8_t a, bool b, uint8_t c, + chip::ByteSpan d, chip::CharSpan e, uint8_t f, float g, double h) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + TLV::TLVWriter * writer = nullptr; + uint8_t argSeqNumber = 0; + + // Used when encoding non-empty command. Suppress error message when encoding empty commands. + (void) writer; + (void) argSeqNumber; + + VerifyOrReturnError(mDevice != nullptr, CHIP_ERROR_INCORRECT_STATE); + + app::CommandPathParams cmdParams = { mEndpoint, /* group id */ 0, mClusterId, + TestCluster::Commands::SimpleStructEchoRequest::Id, + (app::CommandPathFlags::kEndpointIdValid) }; + + CommandSenderHandle sender( + Platform::New(mDevice->GetInteractionModelDelegate(), mDevice->GetExchangeManager())); + + VerifyOrReturnError(sender != nullptr, CHIP_ERROR_NO_MEMORY); + + SuccessOrExit(err = sender->PrepareCommand(cmdParams)); + + VerifyOrExit((writer = sender->GetCommandDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); + // a: int8u + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), a)); + // b: boolean + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), b)); + // c: simpleEnum + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), c)); + // d: octetString + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), d)); + // e: charString + SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), e)); + // f: simpleBitmap + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), f)); + // g: single + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), g)); + // h: double + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), h)); + + SuccessOrExit(err = sender->FinishCommand()); + + // #6308: This is a temporary solution before we fully support IM on application side and should be replaced by IMDelegate. + mDevice->AddIMResponseHandler(sender.get(), onSuccessCallback, onFailureCallback); + + SuccessOrExit(err = mDevice->SendCommands(sender.get())); + + // We have successfully sent the command, and the callback handler will be responsible to free the object, release the object + // now. + sender.release(); +exit: + return err; +} + CHIP_ERROR TestClusterCluster::Test(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { CHIP_ERROR err = CHIP_NO_ERROR; @@ -15875,7 +15932,7 @@ CHIP_ERROR TestClusterCluster::TestListInt8UReverseRequest(Callback::Cancelable CHIP_ERROR TestClusterCluster::TestListStructArgumentRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t a, bool b, uint8_t c, - chip::ByteSpan d, chip::CharSpan e, uint8_t f) + chip::ByteSpan d, chip::CharSpan e, uint8_t f, float g, double h) { CHIP_ERROR err = CHIP_NO_ERROR; TLV::TLVWriter * writer = nullptr; @@ -15911,6 +15968,10 @@ CHIP_ERROR TestClusterCluster::TestListStructArgumentRequest(Callback::Cancelabl SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), e)); // f: simpleBitmap SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), f)); + // g: single + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), g)); + // h: double + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), h)); SuccessOrExit(err = sender->FinishCommand()); @@ -16046,7 +16107,7 @@ CHIP_ERROR TestClusterCluster::TestSpecific(Callback::Cancelable * onSuccessCall CHIP_ERROR TestClusterCluster::TestStructArgumentRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t a, bool b, uint8_t c, - chip::ByteSpan d, chip::CharSpan e, uint8_t f) + chip::ByteSpan d, chip::CharSpan e, uint8_t f, float g, double h) { CHIP_ERROR err = CHIP_NO_ERROR; TLV::TLVWriter * writer = nullptr; @@ -16082,6 +16143,10 @@ CHIP_ERROR TestClusterCluster::TestStructArgumentRequest(Callback::Cancelable * SuccessOrExit(err = writer->PutString(TLV::ContextTag(argSeqNumber++), e)); // f: simpleBitmap SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), f)); + // g: single + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), g)); + // h: double + SuccessOrExit(err = writer->Put(TLV::ContextTag(argSeqNumber++), h)); SuccessOrExit(err = sender->FinishCommand()); diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h index d15a9c0c24cc4e..061dbdb492f56c 100644 --- a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h +++ b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h @@ -2273,6 +2273,9 @@ class DLL_EXPORT TestClusterCluster : public ClusterBase ~TestClusterCluster() {} // Cluster Commands + CHIP_ERROR SimpleStructEchoRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint8_t a, bool b, uint8_t c, chip::ByteSpan d, chip::CharSpan e, uint8_t f, float g, + double h); CHIP_ERROR Test(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR TestAddArguments(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t arg1, uint8_t arg2); @@ -2283,13 +2286,15 @@ class DLL_EXPORT TestClusterCluster : public ClusterBase CHIP_ERROR TestListInt8UReverseRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t arg1); CHIP_ERROR TestListStructArgumentRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t a, bool b, uint8_t c, chip::ByteSpan d, chip::CharSpan e, uint8_t f); + uint8_t a, bool b, uint8_t c, chip::ByteSpan d, chip::CharSpan e, uint8_t f, float g, + double h); CHIP_ERROR TestNotHandled(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR TestNullableOptionalRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint8_t arg1); CHIP_ERROR TestSpecific(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR TestStructArgumentRequest(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, - uint8_t a, bool b, uint8_t c, chip::ByteSpan d, chip::CharSpan e, uint8_t f); + uint8_t a, bool b, uint8_t c, chip::ByteSpan d, chip::CharSpan e, uint8_t f, float g, + double h); CHIP_ERROR TestUnknownCommand(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); // Cluster Attributes diff --git a/zzz_generated/controller-clusters/zap-generated/IMClusterCommandHandler.cpp b/zzz_generated/controller-clusters/zap-generated/IMClusterCommandHandler.cpp index 7468f7bba6bbfa..988e34086a4a9c 100644 --- a/zzz_generated/controller-clusters/zap-generated/IMClusterCommandHandler.cpp +++ b/zzz_generated/controller-clusters/zap-generated/IMClusterCommandHandler.cpp @@ -5236,6 +5236,65 @@ void DispatchClientCommand(CommandSender * apCommandObj, const ConcreteCommandPa } break; } + case Commands::SimpleStructResponse::Id: { + expectArgumentCount = 1; + chip::app::Clusters::TestCluster::Structs::SimpleStruct::DecodableType arg1; + bool argExists[1]; + + memset(argExists, 0, sizeof argExists); + + while ((TLVError = aDataTlv.Next()) == CHIP_NO_ERROR) + { + // Since call to aDataTlv.Next() is CHIP_NO_ERROR, the read head always points to an element. + // Skip this element if it is not a ContextTag, not consider it as an error if other values are valid. + if (!TLV::IsContextTag(aDataTlv.GetTag())) + { + continue; + } + currentDecodeTagId = TLV::TagNumFromTag(aDataTlv.GetTag()); + if (currentDecodeTagId < 1) + { + if (argExists[currentDecodeTagId]) + { + ChipLogProgress(Zcl, "Duplicate TLV tag %" PRIx32, TLV::TagNumFromTag(aDataTlv.GetTag())); + TLVUnpackError = CHIP_ERROR_IM_MALFORMED_COMMAND_DATA_ELEMENT; + break; + } + else + { + argExists[currentDecodeTagId] = true; + validArgumentCount++; + } + } + switch (currentDecodeTagId) + { + case 0: + // Not supported, just error out. + TLVUnpackError = CHIP_ERROR_UNEXPECTED_TLV_ELEMENT; + break; + default: + // Unsupported tag, ignore it. + ChipLogProgress(Zcl, "Unknown TLV tag during processing."); + break; + } + if (CHIP_NO_ERROR != TLVUnpackError) + { + break; + } + } + + if (CHIP_END_OF_TLV == TLVError) + { + // CHIP_END_OF_TLV means we have iterated all items in the structure, which is not a real error. + TLVError = CHIP_NO_ERROR; + } + + if (CHIP_NO_ERROR == TLVError && CHIP_NO_ERROR == TLVUnpackError && 1 == validArgumentCount) + { + wasHandled = emberAfTestClusterClusterSimpleStructResponseCallback(aCommandPath.mEndpointId, apCommandObj, arg1); + } + break; + } case Commands::TestAddArgumentsResponse::Id: { expectArgumentCount = 1; uint8_t returnValue;