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 b92c5b11f55519..ffa190a61bb62a 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 @@ -15785,7 +15785,7 @@ "code": 23, "mfgCode": null, "side": "server", - "included": 0, + "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, @@ -15800,7 +15800,7 @@ "code": 24, "mfgCode": null, "side": "server", - "included": 0, + "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, @@ -16445,7 +16445,7 @@ "code": 32791, "mfgCode": null, "side": "server", - "included": 0, + "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, @@ -16460,7 +16460,7 @@ "code": 32792, "mfgCode": null, "side": "server", - "included": 0, + "included": 1, "storageOption": "RAM", "singleton": 0, "bounded": 0, diff --git a/examples/chip-tool/commands/common/Command.cpp b/examples/chip-tool/commands/common/Command.cpp index 6969e3962c33a9..00658fc9cf9168 100644 --- a/examples/chip-tool/commands/common/Command.cpp +++ b/examples/chip-tool/commands/common/Command.cpp @@ -357,6 +357,28 @@ bool Command::InitArgument(size_t argIndex, char * argValue) break; } + case ArgumentType::Float: { + if (arg.optional) + arg.value = &(static_cast *>(arg.value))->Emplace(); + float * value = static_cast(arg.value); + std::stringstream ss; + ss << argValue; + ss >> *value; + isValidArgument = (!ss.fail() && ss.eof()); + break; + } + + case ArgumentType::Double: { + if (arg.optional) + arg.value = &(static_cast *>(arg.value))->Emplace(); + double * value = static_cast(arg.value); + std::stringstream ss; + ss << argValue; + ss >> *value; + isValidArgument = (!ss.fail() && ss.eof()); + break; + } + case ArgumentType::Address: { if (arg.optional) arg.value = &(reinterpret_cast *>(arg.value))->Emplace(); @@ -429,6 +451,30 @@ size_t Command::AddArgument(const char * name, AddressWithInterface * out, bool return AddArgumentToList(std::move(arg)); } +size_t Command::AddArgument(const char * name, float min, float max, float * out, bool optional) +{ + Argument arg; + arg.type = ArgumentType::Float; + arg.name = name; + arg.value = reinterpret_cast(out); + arg.optional = optional; + // Ignore min/max for now; they're always +-Infinity anyway. + + return AddArgumentToList(std::move(arg)); +} + +size_t Command::AddArgument(const char * name, double min, double max, double * out, bool optional) +{ + Argument arg; + arg.type = ArgumentType::Double; + arg.name = name; + arg.value = reinterpret_cast(out); + arg.optional = optional; + // Ignore min/max for now; they're always +-Infinity anyway. + + return AddArgumentToList(std::move(arg)); +} + size_t Command::AddArgument(const char * name, int64_t min, uint64_t max, void * out, ArgumentType type, bool optional) { Argument arg; diff --git a/examples/chip-tool/commands/common/Command.h b/examples/chip-tool/commands/common/Command.h index 9cbac4ba0c6ade..876afbe33bf415 100644 --- a/examples/chip-tool/commands/common/Command.h +++ b/examples/chip-tool/commands/common/Command.h @@ -63,6 +63,8 @@ enum ArgumentType Number_int16, Number_int32, Number_int64, + Float, + Double, Boolean, String, CharString, @@ -153,6 +155,9 @@ class Command return AddArgument(name, min, max, reinterpret_cast(out), Number_uint64, optional); } + size_t AddArgument(const char * name, float min, float max, float * out, bool optional = false); + size_t AddArgument(const char * name, double min, double max, double * out, bool optional = false); + template ::value>> size_t AddArgument(const char * name, int64_t min, uint64_t max, T * out, bool optional = false) { diff --git a/examples/chip-tool/templates/commands.zapt b/examples/chip-tool/templates/commands.zapt index c13a406326e545..8902634914b524 100644 --- a/examples/chip-tool/templates/commands.zapt +++ b/examples/chip-tool/templates/commands.zapt @@ -309,6 +309,32 @@ static void OnInt64sAttributeResponse(void * context, int64_t value) command->SetCommandExitStatus(CHIP_NO_ERROR); } +static void OnFloatAttributeReport(void * context, float value) +{ + ChipLogProgress(chipTool, "Float attribute Response: %f", value); +} + +static void OnFloatAttributeResponse(void * context, float value) +{ + OnFloatAttributeReport(context, value); + + ModelCommand * command = static_cast(context); + command->SetCommandExitStatus(CHIP_NO_ERROR); +} + +static void OnDoubleAttributeReport(void * context, double value) +{ + ChipLogProgress(chipTool, "Double attribute Response: %f", value); +} + +static void OnDoubleAttributeResponse(void * context, double value) +{ + OnDoubleAttributeReport(context, value); + + ModelCommand * command = static_cast(context); + command->SetCommandExitStatus(CHIP_NO_ERROR); +} + static void OnOctetStringAttributeReport(void * context, const chip::ByteSpan value) { char buffer[CHIP_CONFIG_LOG_MESSAGE_MAX_SIZE]; diff --git a/examples/chip-tool/templates/helper.js b/examples/chip-tool/templates/helper.js index c5f1f0dcae7a4d..dc95273dc2a06e 100644 --- a/examples/chip-tool/templates/helper.js +++ b/examples/chip-tool/templates/helper.js @@ -50,7 +50,7 @@ function asTypeMinValue(type) return '0'; case 'float': case 'double': - return `-std::numeric_limits<${basicType}>::infinity`; + return `-std::numeric_limits<${basicType}>::infinity()`; default: error = 'asTypeMinValue: Unhandled underlying type ' + zclType + ' for original type ' + type; throw error; @@ -87,7 +87,7 @@ function asTypeMaxValue(type) return 'UINT' + parseInt(basicType.slice(4)) + '_MAX'; case 'float': case 'double': - return `std::numeric_limits<${basicType}>::infinity`; + return `std::numeric_limits<${basicType}>::infinity()`; default: return 'err'; error = 'asTypeMaxValue: Unhandled underlying type ' + zclType + ' for original type ' + type; diff --git a/examples/chip-tool/templates/tests-commands.zapt b/examples/chip-tool/templates/tests-commands.zapt index 65750d9d19314e..b517d1d2928760 100644 --- a/examples/chip-tool/templates/tests-commands.zapt +++ b/examples/chip-tool/templates/tests-commands.zapt @@ -4,6 +4,7 @@ #include #include +#include // For INFINITY class TestList : public Command { diff --git a/src/app/tests/suites/TestCluster.yaml b/src/app/tests/suites/TestCluster.yaml index f2e96583106049..4637cc60354832 100644 --- a/src/app/tests/suites/TestCluster.yaml +++ b/src/app/tests/suites/TestCluster.yaml @@ -526,6 +526,118 @@ tests: response: value: 0 + # Tests for float attribute + + - label: "Read attribute SINGLE Default Value" + command: "readAttribute" + attribute: "float_single" + response: + value: 0 + + - label: "Write attribute SINGLE medium Value" + command: "writeAttribute" + attribute: "float_single" + arguments: + value: 0.1 + + - label: "Read attribute SINGLE medium Value" + command: "readAttribute" + attribute: "float_single" + response: + value: 0.1 + + - label: "Write attribute SINGLE large Value" + command: "writeAttribute" + attribute: "float_single" + arguments: + value: 1.7e10 + + - label: "Read attribute SINGLE large Value" + command: "readAttribute" + attribute: "float_single" + response: + value: 1.7e10 + + - label: "Write attribute SINGLE small Value" + command: "writeAttribute" + attribute: "float_single" + arguments: + value: 1.7e-10 + + - label: "Read attribute SINGLE small Value" + command: "readAttribute" + attribute: "float_single" + response: + value: 1.7e-10 + + - label: "Write attribute SINGLE Default Value" + command: "writeAttribute" + attribute: "float_single" + arguments: + value: 0 + + - label: "Read attribute SINGLE Default Value" + command: "readAttribute" + attribute: "float_single" + response: + value: 0 + + # Tests for double attribute + + - label: "Read attribute DOUBLE Default Value" + command: "readAttribute" + attribute: "float_double" + response: + value: 0 + + - label: "Write attribute DOUBLE medium Value" + command: "writeAttribute" + attribute: "float_double" + arguments: + value: 0.1234567890123 + + - label: "Read attribute DOUBLE medium Value" + command: "readAttribute" + attribute: "float_double" + response: + value: 0.1234567890123 + + - label: "Write attribute DOUBLE large Value" + command: "writeAttribute" + attribute: "float_double" + arguments: + value: 1.7e200 + + - label: "Read attribute DOUBLE large Value" + command: "readAttribute" + attribute: "float_double" + response: + value: 1.7e200 + + - label: "Write attribute DOUBLE small Value" + command: "writeAttribute" + attribute: "float_double" + arguments: + value: 1.7e-200 + + - label: "Read attribute DOUBLE small Value" + command: "readAttribute" + attribute: "float_double" + response: + value: 1.7e-200 + + - label: "Write attribute DOUBLE Default Value" + command: "writeAttribute" + attribute: "float_double" + arguments: + value: 0 + + - label: "Read attribute DOUBLE Default Value" + command: "readAttribute" + attribute: "float_double" + response: + value: 0 + # Tests for Enum8 attribute - label: "Read attribute ENUM8 Default Value" @@ -1941,6 +2053,130 @@ tests: response: value: null + # Tests for float attribute + + - label: "Write attribute NULLABLE_SINGLE medium Value" + command: "writeAttribute" + attribute: "nullable_float_single" + arguments: + value: 0.1 + + - label: "Read attribute NULLABLE_SINGLE medium Value" + command: "readAttribute" + attribute: "nullable_float_single" + response: + value: 0.1 + + - label: "Write attribute NULLABLE_SINGLE largest Value" + command: "writeAttribute" + attribute: "nullable_float_single" + arguments: + value: Infinity + + - label: "Read attribute NULLABLE_SINGLE largest Value" + command: "readAttribute" + attribute: "nullable_float_single" + response: + value: Infinity + + - label: "Write attribute NULLABLE_SINGLE smallest Value" + command: "writeAttribute" + attribute: "nullable_float_single" + arguments: + value: -Infinity + + - label: "Read attribute NULLABLE_SINGLE smallest Value" + command: "readAttribute" + attribute: "nullable_float_single" + response: + value: -Infinity + + - label: "Write attribute NULLABLE_SINGLE null Value" + command: "writeAttribute" + attribute: "nullable_float_single" + arguments: + value: null + + - label: "Read attribute NULLABLE_SINGLE null Value" + command: "readAttribute" + attribute: "nullable_float_single" + response: + value: null + + - label: "Write attribute NULLABLE_SINGLE 0 Value" + command: "writeAttribute" + attribute: "nullable_float_single" + arguments: + value: 0 + + - label: "Read attribute NULLABLE_SINGLE 0 Value" + command: "readAttribute" + attribute: "nullable_float_single" + response: + value: 0 + + # Tests for double attribute + + - label: "Write attribute NULLABLE_DOUBLE medium Value" + command: "writeAttribute" + attribute: "nullable_float_double" + arguments: + value: 0.1234567890123 + + - label: "Read attribute NULLABLE_DOUBLE medium Value" + command: "readAttribute" + attribute: "nullable_float_double" + response: + value: 0.1234567890123 + + - label: "Write attribute NULLABLE_DOUBLE largest Value" + command: "writeAttribute" + attribute: "nullable_float_double" + arguments: + value: Infinity + + - label: "Read attribute NULLABLE_DOUBLE largest Value" + command: "readAttribute" + attribute: "nullable_float_double" + response: + value: Infinity + + - label: "Write attribute NULLABLE_DOUBLE smallest Value" + command: "writeAttribute" + attribute: "nullable_float_double" + arguments: + value: -Infinity + + - label: "Read attribute NULLABLE_DOUBLE smallest Value" + command: "readAttribute" + attribute: "nullable_float_double" + response: + value: -Infinity + + - label: "Write attribute NULLABLE_DOUBLE null Value" + command: "writeAttribute" + attribute: "nullable_float_double" + arguments: + value: null + + - label: "Read attribute NULLABLE_DOUBLE null Value" + command: "readAttribute" + attribute: "nullable_float_double" + response: + value: null + + - label: "Write attribute NULLABLE_DOUBLE 0 Value" + command: "writeAttribute" + attribute: "nullable_float_double" + arguments: + value: 0 + + - label: "Read attribute NULLABLE_DOUBLE 0 Value" + command: "readAttribute" + attribute: "nullable_float_double" + response: + value: 0 + # Tests for Enum8 attribute - label: "Write attribute NULLABLE_ENUM8 Max Value" diff --git a/src/app/util/attribute-storage-null-handling.h b/src/app/util/attribute-storage-null-handling.h index 935a54cccd26c1..35dc4378cd1a04 100644 --- a/src/app/util/attribute-storage-null-handling.h +++ b/src/app/util/attribute-storage-null-handling.h @@ -55,14 +55,49 @@ struct NumericAttributeTraits // interesting things here. static constexpr WorkingType StorageToWorking(StorageType storageValue) { return storageValue; } +private: + // We need to make sure we never look like we are assigning NaN to an + // integer, even in a not-reached branch. Without "if constexpr", the best + // we can do is these functions using enable_if. + template ::value, int> = 0> + static constexpr StorageType GetNullValue() + { + return std::numeric_limits::quiet_NaN(); + } + + template ::value, int> = 0> + static constexpr StorageType GetNullValue() + { + return std::is_signed::value ? std::numeric_limits::min() : std::numeric_limits::max(); + } + + template ::value, int> = 0> + static constexpr StorageType GetNullValue() + { + return GetNullValue>(); + } + +public: // The value reserved in the value space of StorageType to represent null, // for cases when we have a nullable value. This value must match the value // excluded from the valid value range in the spec, so that we don't confuse // valid values with null. - static constexpr StorageType kNullValue = - std::is_signed::value ? std::numeric_limits::min() : std::numeric_limits::max(); + static constexpr StorageType kNullValue = NumericAttributeTraits::GetNullValue(); - static constexpr bool IsNullValue(StorageType value) { return value == kNullValue; } + template ::value, int> = 0> + static constexpr bool IsNullValue(StorageType value) + { + return value == kNullValue; + } + + template ::value, int> = 0> + static constexpr bool IsNullValue(StorageType value) + { + // Trying to include math.h (to use isnan()) fails on EFR32, both when + // included as "cmath" and when included as "math.h". For lack of + // isnan(), just fall back on the NaN != NaN thing. + return value != value; + } static constexpr void SetNull(StorageType & value) { value = kNullValue; } diff --git a/src/app/util/ember-compatibility-functions.cpp b/src/app/util/ember-compatibility-functions.cpp index 8f3c54e6763d59..174eee20da1d56 100644 --- a/src/app/util/ember-compatibility-functions.cpp +++ b/src/app/util/ember-compatibility-functions.cpp @@ -397,6 +397,16 @@ CHIP_ERROR ReadSingleClusterData(FabricIndex aAccessingFabricIndex, const Concre ReturnErrorOnFailure(attributeBufferToNumericTlvData(*writer, isNullable)); break; } + case ZCL_SINGLE_ATTRIBUTE_TYPE: // 32-bit float + { + ReturnErrorOnFailure(attributeBufferToNumericTlvData(*writer, isNullable)); + break; + } + case ZCL_DOUBLE_ATTRIBUTE_TYPE: // 64-bit float + { + ReturnErrorOnFailure(attributeBufferToNumericTlvData(*writer, isNullable)); + break; + } case ZCL_CHAR_STRING_ATTRIBUTE_TYPE: // Char string { char * actualData = reinterpret_cast(attributeData + 1); @@ -640,6 +650,10 @@ CHIP_ERROR prepareWriteData(const EmberAfAttributeMetadata * metadata, TLV::TLVR } case ZCL_INT64S_ATTRIBUTE_TYPE: // Signed 64-bit integer return numericTlvDataToAttributeBuffer(aReader, isNullable, dataLen); + case ZCL_SINGLE_ATTRIBUTE_TYPE: // 32-bit float + return numericTlvDataToAttributeBuffer(aReader, isNullable, dataLen); + case ZCL_DOUBLE_ATTRIBUTE_TYPE: // 64-bit float + return numericTlvDataToAttributeBuffer(aReader, isNullable, dataLen); case ZCL_OCTET_STRING_ATTRIBUTE_TYPE: // Octet string case ZCL_CHAR_STRING_ATTRIBUTE_TYPE: // Char string return stringTlvDataToAttributeBuffer(aReader, expectedType == ZCL_OCTET_STRING_ATTRIBUTE_TYPE, isNullable, diff --git a/src/app/util/im-client-callbacks.h b/src/app/util/im-client-callbacks.h index f677f8d9b51cc7..2a8ffb6eb58be0 100644 --- a/src/app/util/im-client-callbacks.h +++ b/src/app/util/im-client-callbacks.h @@ -58,6 +58,10 @@ typedef void (*Int64uAttributeCallback)(void * context, uint64_t value); typedef void (*NullableInt64uAttributeCallback)(void * context, const chip::app::DataModel::Nullable & value); typedef void (*Int64sAttributeCallback)(void * context, int64_t value); typedef void (*NullableInt64sAttributeCallback)(void * context, const chip::app::DataModel::Nullable & value); +typedef void (*FloatAttributeCallback)(void * context, float value); +typedef void (*NullableFloatAttributeCallback)(void * context, const chip::app::DataModel::Nullable & value); +typedef void (*DoubleAttributeCallback)(void * context, double value); +typedef void (*NullableDoubleAttributeCallback)(void * context, const chip::app::DataModel::Nullable & value); typedef void (*OctetStringAttributeCallback)(void * context, const chip::ByteSpan value); typedef void (*NullableOctetStringAttributeCallback)(void * context, const chip::app::DataModel::Nullable & value); typedef void (*CharStringAttributeCallback)(void * context, const chip::CharSpan value); diff --git a/src/app/zap-templates/common/ClustersHelper.js b/src/app/zap-templates/common/ClustersHelper.js index a3a3b903edf2e2..939d5cc14c7d1e 100644 --- a/src/app/zap-templates/common/ClustersHelper.js +++ b/src/app/zap-templates/common/ClustersHelper.js @@ -184,7 +184,10 @@ function asChipCallback(item) return { name : 'Int' + basicType.replace(/[^0-9]/g, '') + 'u', type : basicType }; case 'bool': return { name : 'Boolean', type : 'bool' }; - // TODO: Add float and double + case 'float': + return { name : 'Float', type : 'float' }; + case 'double': + return { name : 'Double', type : 'double' }; default: return { name : 'Unsupported', type : null }; } diff --git a/src/app/zap-templates/templates/app/helper.js b/src/app/zap-templates/templates/app/helper.js index a91c31ef708d66..6af4162840ae55 100644 --- a/src/app/zap-templates/templates/app/helper.js +++ b/src/app/zap-templates/templates/app/helper.js @@ -283,13 +283,26 @@ function asTypedLiteral(value, type) case 'uint64_t': return value + (valueIsANumber ? 'ULL' : ''); case 'float': - if (!valueIsANumber || value == 0) { - // "0f" is not a valid value, so don't output that; just leave it - // as "0". + if (!valueIsANumber) { return value; } + if (value == Infinity || value == -Infinity) { + return `${(value < 0) ? '-' : ''}INFINITY` + } + // If the number looks like an integer, append ".0" to the end; + // otherwise adding an "f" suffix makes compilers complain. + value = value.toString(); + if (value.match(/^[0-9]+$/)) { + value = value + ".0"; + } return value + 'f'; default: + if (!valueIsANumber) { + return value; + } + if (value == Infinity || value == -Infinity) { + return `${(value < 0) ? '-' : ''}INFINITY` + } return value; } }) diff --git a/src/controller/java/templates/ChipClusters-java.zapt b/src/controller/java/templates/ChipClusters-java.zapt index 798201818ae322..298b64052546a1 100644 --- a/src/controller/java/templates/ChipClusters-java.zapt +++ b/src/controller/java/templates/ChipClusters-java.zapt @@ -42,6 +42,16 @@ public class ChipClusters { void onError(Exception error); } + public interface FloatAttributeCallback { + void onSuccess(float value); + void onError(Exception error); + } + + public interface DoubleAttributeCallback { + void onSuccess(double value); + void onError(Exception error); + } + public static abstract class BaseChipCluster { protected long chipClusterPtr; diff --git a/src/controller/java/templates/ClusterInfo-java.zapt b/src/controller/java/templates/ClusterInfo-java.zapt index e3d42f80092542..3d8e8908566c5f 100644 --- a/src/controller/java/templates/ClusterInfo-java.zapt +++ b/src/controller/java/templates/ClusterInfo-java.zapt @@ -133,6 +133,50 @@ public class ClusterInfoMapping { } } + public static class DelegatedFloatAttributeCallback implements ChipClusters.FloatAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(float value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo setupPINResponseValue = new CommandResponseInfo("value", "float"); + responseValues.put(setupPINResponseValue, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedDoubleAttributeCallback implements ChipClusters.DoubleAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(double value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo setupPINResponseValue = new CommandResponseInfo("value", "double"); + responseValues.put(setupPINResponseValue, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + public static class DelegatedDefaultClusterCallback implements DefaultClusterCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; diff --git a/src/controller/java/zap-generated/CHIPClusters-JNI.cpp b/src/controller/java/zap-generated/CHIPClusters-JNI.cpp index cae8e832822180..cc1aeb019c1f8d 100644 --- a/src/controller/java/zap-generated/CHIPClusters-JNI.cpp +++ b/src/controller/java/zap-generated/CHIPClusters-JNI.cpp @@ -27000,6 +27000,190 @@ JNI_METHOD(void, TestClusterCluster, reportEnum16Attribute)(JNIEnv * env, jobjec onReport.release(); } +JNI_METHOD(void, TestClusterCluster, writeFloatSingleAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::FloatSingle::TypeInfo; + TypeInfo::Type cppValue; + + cppValue = static_cast(chip::JniReferences::GetInstance().FloatToPrimitive(value)); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeFloatSingleAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeFloatSingle(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportFloatSingleAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeFloatSingle(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeFloatDoubleAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::FloatDouble::TypeInfo; + TypeInfo::Type cppValue; + + cppValue = static_cast(chip::JniReferences::GetInstance().DoubleToPrimitive(value)); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeFloatDoubleAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeFloatDouble(onSuccess->Cancel(), onFailure->Cancel(), static_cast(minInterval), + static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportFloatDoubleAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeFloatDouble(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + JNI_METHOD(void, TestClusterCluster, writeOctetStringAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jbyteArray value) { @@ -30380,6 +30564,202 @@ JNI_METHOD(void, TestClusterCluster, reportNullableEnum16Attribute)(JNIEnv * env onReport.release(); } +JNI_METHOD(void, TestClusterCluster, writeNullableFloatSingleAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableFloatSingle::TypeInfo; + TypeInfo::Type cppValue; + + float valueValue; + if (value != nullptr) + { + valueValue = chip::JniReferences::GetInstance().FloatToPrimitive(value); + } + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeNullableFloatSingleAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeNullableFloatSingle(onSuccess->Cancel(), onFailure->Cancel(), + static_cast(minInterval), static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportNullableFloatSingleAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeNullableFloatSingle(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + +JNI_METHOD(void, TestClusterCluster, writeNullableFloatDoubleAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableFloatDouble::TypeInfo; + TypeInfo::Type cppValue; + + double valueValue; + if (value != nullptr) + { + valueValue = chip::JniReferences::GetInstance().DoubleToPrimitive(value); + } + cppValue = value == nullptr ? chip::app::DataModel::Nullable() : chip::app::DataModel::Nullable(valueValue); + + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} +JNI_METHOD(void, TestClusterCluster, subscribeNullableFloatDoubleAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jint minInterval, jint maxInterval) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onSuccess( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + Platform::New(callback), Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->SubscribeAttributeNullableFloatDouble(onSuccess->Cancel(), onFailure->Cancel(), + static_cast(minInterval), static_cast(maxInterval)); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error subscribing to attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, reportNullableFloatDoubleAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + std::unique_ptr onReport( + Platform::New(callback, true), Platform::Delete); + VerifyOrReturn(onReport.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native report callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + err = cppCluster->ReportAttributeNullableFloatDouble(onReport->Cancel()); + VerifyOrReturn(err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error registering for attribute reporting", err)); + + onReport.release(); +} + JNI_METHOD(void, TestClusterCluster, writeNullableOctetStringAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jbyteArray value) { diff --git a/src/controller/java/zap-generated/CHIPClustersRead-JNI.cpp b/src/controller/java/zap-generated/CHIPClustersRead-JNI.cpp index e46546233074e4..a56018df943fb9 100644 --- a/src/controller/java/zap-generated/CHIPClustersRead-JNI.cpp +++ b/src/controller/java/zap-generated/CHIPClustersRead-JNI.cpp @@ -12368,6 +12368,74 @@ JNI_METHOD(void, TestClusterCluster, readEnum16Attribute)(JNIEnv * env, jobject onFailure.release(); } +JNI_METHOD(void, TestClusterCluster, readFloatSingleAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::FloatSingle::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readFloatDoubleAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::FloatDouble::TypeInfo; + std::unique_ptr onSuccess( + chip::Platform::New(callback, false), chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = + chip::Callback::Callback::FromCancelable(onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + JNI_METHOD(void, TestClusterCluster, readOctetStringAttribute)(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { chip::DeviceLayer::StackLock lock; @@ -13769,6 +13837,80 @@ JNI_METHOD(void, TestClusterCluster, readNullableEnum16Attribute)(JNIEnv * env, onFailure.release(); } +JNI_METHOD(void, TestClusterCluster, readNullableFloatSingleAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableFloatSingle::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable( + onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + +JNI_METHOD(void, TestClusterCluster, readNullableFloatDoubleAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) +{ + chip::DeviceLayer::StackLock lock; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::NullableFloatDouble::TypeInfo; + std::unique_ptr + onSuccess(chip::Platform::New(callback, false), + chip::Platform::Delete); + VerifyOrReturn(onSuccess.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native success callback", CHIP_ERROR_NO_MEMORY)); + + std::unique_ptr onFailure( + chip::Platform::New(callback), chip::Platform::Delete); + VerifyOrReturn(onFailure.get() != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Error creating native failure callback", CHIP_ERROR_NO_MEMORY)); + + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Controller::TestClusterCluster * cppCluster = reinterpret_cast(clusterPtr); + VerifyOrReturn(cppCluster != nullptr, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException( + env, callback, "Could not get native cluster", CHIP_ERROR_INCORRECT_STATE)); + + auto successFn = chip::Callback::Callback::FromCancelable( + onSuccess->Cancel()); + auto failureFn = chip::Callback::Callback::FromCancelable(onFailure->Cancel()); + err = cppCluster->ReadAttribute(onSuccess->mContext, successFn->mCall, failureFn->mCall); + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error reading attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + JNI_METHOD(void, TestClusterCluster, readNullableOctetStringAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback) { diff --git a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp index 859131159632c4..fa6ab851e57427 100644 --- a/src/controller/java/zap-generated/CHIPReadCallbacks.cpp +++ b/src/controller/java/zap-generated/CHIPReadCallbacks.cpp @@ -127,6 +127,104 @@ void CHIPCharStringAttributeCallback::CallbackFn(void * context, const chip::Cha env->CallVoidMethod(javaCallbackRef, javaMethod, valueStr.jniValue()); } +CHIPDoubleAttributeCallback::CHIPDoubleAttributeCallback(jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) +{ + JNIEnv * env = chip::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"); + } +} + +CHIPDoubleAttributeCallback::~CHIPDoubleAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPDoubleAttributeCallback::CallbackFn(void * context, double value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + jobject javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogDetail(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(D)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess method")); + env->CallVoidMethod(javaCallbackRef, javaMethod, static_cast(value)); +} + +CHIPFloatAttributeCallback::CHIPFloatAttributeCallback(jobject javaCallback, bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) +{ + JNIEnv * env = chip::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"); + } +} + +CHIPFloatAttributeCallback::~CHIPFloatAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPFloatAttributeCallback::CallbackFn(void * context, float value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + jobject javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogDetail(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(F)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess method")); + env->CallVoidMethod(javaCallbackRef, javaMethod, static_cast(value)); +} + CHIPInt8sAttributeCallback::CHIPInt8sAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), keepAlive(keepAlive) { @@ -6388,6 +6486,128 @@ void CHIPTestClusterNullableEnum16AttributeCallback::CallbackFn(void * context, env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); } +CHIPTestClusterNullableFloatSingleAttributeCallback::CHIPTestClusterNullableFloatSingleAttributeCallback(jobject javaCallback, + bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::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"); + } +} + +CHIPTestClusterNullableFloatSingleAttributeCallback::~CHIPTestClusterNullableFloatSingleAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPTestClusterNullableFloatSingleAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Float;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + + std::string javaValueClassName = "java/lang/Float"; + std::string javaValueCtorSignature = "(F)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + +CHIPTestClusterNullableFloatDoubleAttributeCallback::CHIPTestClusterNullableFloatDoubleAttributeCallback(jobject javaCallback, + bool keepAlive) : + chip::Callback::Callback(CallbackFn, this), + keepAlive(keepAlive) +{ + JNIEnv * env = chip::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"); + } +} + +CHIPTestClusterNullableFloatDoubleAttributeCallback::~CHIPTestClusterNullableFloatDoubleAttributeCallback() +{ + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + if (env == nullptr) + { + ChipLogError(Zcl, "Could not delete global reference for Java callback"); + return; + } + env->DeleteGlobalRef(javaCallbackRef); +} + +void CHIPTestClusterNullableFloatDoubleAttributeCallback::CallbackFn(void * context, + const chip::app::DataModel::Nullable & value) +{ + chip::DeviceLayer::StackUnlock unlock; + CHIP_ERROR err = CHIP_NO_ERROR; + JNIEnv * env = chip::JniReferences::GetInstance().GetEnvForCurrentThread(); + jobject javaCallbackRef; + + VerifyOrReturn(env != nullptr, ChipLogError(Zcl, "Could not get JNI env")); + std::unique_ptr cppCallback( + reinterpret_cast(context), maybeDestroy); + + // It's valid for javaCallbackRef to be nullptr if the Java code passed in a null callback. + javaCallbackRef = cppCallback.get()->javaCallbackRef; + VerifyOrReturn(javaCallbackRef != nullptr, + ChipLogProgress(Zcl, "Early return from attribute callback since Java callback is null")); + + jmethodID javaMethod; + err = chip::JniReferences::GetInstance().FindMethod(env, javaCallbackRef, "onSuccess", "(Ljava/lang/Double;)V", &javaMethod); + VerifyOrReturn(err == CHIP_NO_ERROR, ChipLogError(Zcl, "Could not find onSuccess() method")); + + jobject javaValue; + + std::string javaValueClassName = "java/lang/Double"; + std::string javaValueCtorSignature = "(D)V"; + chip::JniReferences::GetInstance().CreateBoxedObject(javaValueClassName.c_str(), javaValueCtorSignature.c_str(), + value.Value(), javaValue); + + env->CallVoidMethod(javaCallbackRef, javaMethod, javaValue); +} + CHIPTestClusterNullableOctetStringAttributeCallback::CHIPTestClusterNullableOctetStringAttributeCallback(jobject javaCallback, bool keepAlive) : chip::Callback::Callback(CallbackFn, this), diff --git a/src/controller/java/zap-generated/CHIPReadCallbacks.h b/src/controller/java/zap-generated/CHIPReadCallbacks.h index df5d0d16359ef3..a01f24fd5149c9 100644 --- a/src/controller/java/zap-generated/CHIPReadCallbacks.h +++ b/src/controller/java/zap-generated/CHIPReadCallbacks.h @@ -61,6 +61,50 @@ class CHIPCharStringAttributeCallback : public chip::Callback::Callback +{ +public: + CHIPDoubleAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPDoubleAttributeCallback(); + + static void maybeDestroy(CHIPDoubleAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, double value); + +private: + jobject javaCallbackRef; + bool keepAlive; +}; +class CHIPFloatAttributeCallback : public chip::Callback::Callback +{ +public: + CHIPFloatAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPFloatAttributeCallback(); + + static void maybeDestroy(CHIPFloatAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, float value); + private: jobject javaCallbackRef; bool keepAlive; @@ -1869,6 +1913,54 @@ class CHIPTestClusterNullableEnum16AttributeCallback bool keepAlive; }; +class CHIPTestClusterNullableFloatSingleAttributeCallback + : public chip::Callback::Callback +{ +public: + CHIPTestClusterNullableFloatSingleAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPTestClusterNullableFloatSingleAttributeCallback(); + + static void maybeDestroy(CHIPTestClusterNullableFloatSingleAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, const chip::app::DataModel::Nullable & value); + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + +class CHIPTestClusterNullableFloatDoubleAttributeCallback + : public chip::Callback::Callback +{ +public: + CHIPTestClusterNullableFloatDoubleAttributeCallback(jobject javaCallback, bool keepAlive = false); + + ~CHIPTestClusterNullableFloatDoubleAttributeCallback(); + + static void maybeDestroy(CHIPTestClusterNullableFloatDoubleAttributeCallback * callback) + { + if (!callback->keepAlive) + { + callback->Cancel(); + chip::Platform::Delete(callback); + } + } + + static void CallbackFn(void * context, const chip::app::DataModel::Nullable & value); + +private: + jobject javaCallbackRef; + bool keepAlive; +}; + class CHIPTestClusterNullableOctetStringAttributeCallback : public chip::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 c15336b359c1f3..7c2fd5d8021211 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -64,6 +64,18 @@ public interface BooleanAttributeCallback { void onError(Exception error); } + public interface FloatAttributeCallback { + void onSuccess(float value); + + void onError(Exception error); + } + + public interface DoubleAttributeCallback { + void onSuccess(double value); + + void onError(Exception error); + } + public abstract static class BaseChipCluster { protected long chipClusterPtr; @@ -11200,6 +11212,18 @@ public interface NullableEnum16AttributeCallback { void onError(Exception ex); } + public interface NullableFloatSingleAttributeCallback { + void onSuccess(@Nullable Float value); + + void onError(Exception ex); + } + + public interface NullableFloatDoubleAttributeCallback { + void onSuccess(@Nullable Double value); + + void onError(Exception ex); + } + public interface NullableOctetStringAttributeCallback { void onSuccess(@Nullable byte[] value); @@ -11627,6 +11651,40 @@ public void reportEnum16Attribute(IntegerAttributeCallback callback) { reportEnum16Attribute(chipClusterPtr, callback); } + public void readFloatSingleAttribute(FloatAttributeCallback callback) { + readFloatSingleAttribute(chipClusterPtr, callback); + } + + public void writeFloatSingleAttribute(DefaultClusterCallback callback, Float value) { + writeFloatSingleAttribute(chipClusterPtr, callback, value); + } + + public void subscribeFloatSingleAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeFloatSingleAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportFloatSingleAttribute(FloatAttributeCallback callback) { + reportFloatSingleAttribute(chipClusterPtr, callback); + } + + public void readFloatDoubleAttribute(DoubleAttributeCallback callback) { + readFloatDoubleAttribute(chipClusterPtr, callback); + } + + public void writeFloatDoubleAttribute(DefaultClusterCallback callback, Double value) { + writeFloatDoubleAttribute(chipClusterPtr, callback, value); + } + + public void subscribeFloatDoubleAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeFloatDoubleAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportFloatDoubleAttribute(DoubleAttributeCallback callback) { + reportFloatDoubleAttribute(chipClusterPtr, callback); + } + public void readOctetStringAttribute(OctetStringAttributeCallback callback) { readOctetStringAttribute(chipClusterPtr, callback); } @@ -12273,6 +12331,42 @@ public void reportNullableEnum16Attribute(IntegerAttributeCallback callback) { reportNullableEnum16Attribute(chipClusterPtr, callback); } + public void readNullableFloatSingleAttribute(NullableFloatSingleAttributeCallback callback) { + readNullableFloatSingleAttribute(chipClusterPtr, callback); + } + + public void writeNullableFloatSingleAttribute( + DefaultClusterCallback callback, @Nullable Float value) { + writeNullableFloatSingleAttribute(chipClusterPtr, callback, value); + } + + public void subscribeNullableFloatSingleAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeNullableFloatSingleAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportNullableFloatSingleAttribute(FloatAttributeCallback callback) { + reportNullableFloatSingleAttribute(chipClusterPtr, callback); + } + + public void readNullableFloatDoubleAttribute(NullableFloatDoubleAttributeCallback callback) { + readNullableFloatDoubleAttribute(chipClusterPtr, callback); + } + + public void writeNullableFloatDoubleAttribute( + DefaultClusterCallback callback, @Nullable Double value) { + writeNullableFloatDoubleAttribute(chipClusterPtr, callback, value); + } + + public void subscribeNullableFloatDoubleAttribute( + DefaultClusterCallback callback, int minInterval, int maxInterval) { + subscribeNullableFloatDoubleAttribute(chipClusterPtr, callback, minInterval, maxInterval); + } + + public void reportNullableFloatDoubleAttribute(DoubleAttributeCallback callback) { + reportNullableFloatDoubleAttribute(chipClusterPtr, callback); + } + public void readNullableOctetStringAttribute(NullableOctetStringAttributeCallback callback) { readNullableOctetStringAttribute(chipClusterPtr, callback); } @@ -12646,6 +12740,30 @@ private native void subscribeEnum16Attribute( private native void reportEnum16Attribute( long chipClusterPtr, IntegerAttributeCallback callback); + private native void readFloatSingleAttribute( + long chipClusterPtr, FloatAttributeCallback callback); + + private native void writeFloatSingleAttribute( + long chipClusterPtr, DefaultClusterCallback callback, Float value); + + private native void subscribeFloatSingleAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportFloatSingleAttribute( + long chipClusterPtr, FloatAttributeCallback callback); + + private native void readFloatDoubleAttribute( + long chipClusterPtr, DoubleAttributeCallback callback); + + private native void writeFloatDoubleAttribute( + long chipClusterPtr, DefaultClusterCallback callback, Double value); + + private native void subscribeFloatDoubleAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportFloatDoubleAttribute( + long chipClusterPtr, DoubleAttributeCallback callback); + private native void readOctetStringAttribute( long chipClusterPtr, OctetStringAttributeCallback callback); @@ -13080,6 +13198,30 @@ private native void subscribeNullableEnum16Attribute( private native void reportNullableEnum16Attribute( long chipClusterPtr, IntegerAttributeCallback callback); + private native void readNullableFloatSingleAttribute( + long chipClusterPtr, NullableFloatSingleAttributeCallback callback); + + private native void writeNullableFloatSingleAttribute( + long chipClusterPtr, DefaultClusterCallback callback, @Nullable Float value); + + private native void subscribeNullableFloatSingleAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportNullableFloatSingleAttribute( + long chipClusterPtr, FloatAttributeCallback callback); + + private native void readNullableFloatDoubleAttribute( + long chipClusterPtr, NullableFloatDoubleAttributeCallback callback); + + private native void writeNullableFloatDoubleAttribute( + long chipClusterPtr, DefaultClusterCallback callback, @Nullable Double value); + + private native void subscribeNullableFloatDoubleAttribute( + long chipClusterPtr, DefaultClusterCallback callback, int minInterval, int maxInterval); + + private native void reportNullableFloatDoubleAttribute( + long chipClusterPtr, DoubleAttributeCallback callback); + private native void readNullableOctetStringAttribute( long chipClusterPtr, NullableOctetStringAttributeCallback callback); diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java index b0f3728268b031..25ee693622aaca 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterInfoMapping.java @@ -151,6 +151,52 @@ public void onError(Exception error) { } } + public static class DelegatedFloatAttributeCallback + implements ChipClusters.FloatAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(float value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo setupPINResponseValue = new CommandResponseInfo("value", "float"); + responseValues.put(setupPINResponseValue, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + + public static class DelegatedDoubleAttributeCallback + implements ChipClusters.DoubleAttributeCallback, DelegatedClusterCallback { + private ClusterCommandCallback callback; + + @Override + public void setCallbackDelegate(ClusterCommandCallback callback) { + this.callback = callback; + } + + @Override + public void onSuccess(double value) { + Map responseValues = new LinkedHashMap<>(); + CommandResponseInfo setupPINResponseValue = new CommandResponseInfo("value", "double"); + responseValues.put(setupPINResponseValue, value); + callback.onSuccess(responseValues); + } + + @Override + public void onError(Exception error) { + callback.onFailure(error); + } + } + public static class DelegatedDefaultClusterCallback implements DefaultClusterCallback, DelegatedClusterCallback { private ClusterCommandCallback callback; diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java index 60e9946791c5c0..24af84505a3a21 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterReadMapping.java @@ -4587,6 +4587,30 @@ public Map> getReadAttributeMap() { readTestClusterEnum16CommandParams); readTestClusterInteractionInfo.put( "readEnum16Attribute", readTestClusterEnum16AttributeInteractionInfo); + Map readTestClusterFloatSingleCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readFloatSingleAttribute((ChipClusters.FloatAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readTestClusterFloatSingleCommandParams); + readTestClusterInteractionInfo.put( + "readFloatSingleAttribute", readTestClusterFloatSingleAttributeInteractionInfo); + Map readTestClusterFloatDoubleCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readFloatDoubleAttribute((ChipClusters.DoubleAttributeCallback) callback); + }, + () -> new ClusterInfoMapping.DelegatedDoubleAttributeCallback(), + readTestClusterFloatDoubleCommandParams); + readTestClusterInteractionInfo.put( + "readFloatDoubleAttribute", readTestClusterFloatDoubleAttributeInteractionInfo); Map readTestClusterOctetStringCommandParams = new LinkedHashMap(); InteractionInfo readTestClusterOctetStringAttributeInteractionInfo = @@ -5110,6 +5134,36 @@ public Map> getReadAttributeMap() { readTestClusterNullableEnum16CommandParams); readTestClusterInteractionInfo.put( "readNullableEnum16Attribute", readTestClusterNullableEnum16AttributeInteractionInfo); + Map readTestClusterNullableFloatSingleCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableFloatSingleAttribute( + (ChipClusters.TestClusterCluster.NullableFloatSingleAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedFloatAttributeCallback(), + readTestClusterNullableFloatSingleCommandParams); + readTestClusterInteractionInfo.put( + "readNullableFloatSingleAttribute", + readTestClusterNullableFloatSingleAttributeInteractionInfo); + Map readTestClusterNullableFloatDoubleCommandParams = + new LinkedHashMap(); + InteractionInfo readTestClusterNullableFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .readNullableFloatDoubleAttribute( + (ChipClusters.TestClusterCluster.NullableFloatDoubleAttributeCallback) + callback); + }, + () -> new ClusterInfoMapping.DelegatedDoubleAttributeCallback(), + readTestClusterNullableFloatDoubleCommandParams); + readTestClusterInteractionInfo.put( + "readNullableFloatDoubleAttribute", + readTestClusterNullableFloatDoubleAttributeInteractionInfo); Map readTestClusterNullableOctetStringCommandParams = new LinkedHashMap(); InteractionInfo readTestClusterNullableOctetStringAttributeInteractionInfo = diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java index fb248904f593a8..d535b15affa632 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ClusterWriteMapping.java @@ -1165,6 +1165,40 @@ public Map> getWriteAttributeMap() { writeTestClusterEnum16CommandParams); writeTestClusterInteractionInfo.put( "writeEnum16Attribute", writeTestClusterEnum16AttributeInteractionInfo); + Map writeTestClusterFloatSingleCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterfloatSingleCommandParameterInfo = + new CommandParameterInfo("value", float.class); + writeTestClusterFloatSingleCommandParams.put( + "value", testClusterfloatSingleCommandParameterInfo); + InteractionInfo writeTestClusterFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeFloatSingleAttribute( + (DefaultClusterCallback) callback, (Float) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterFloatSingleCommandParams); + writeTestClusterInteractionInfo.put( + "writeFloatSingleAttribute", writeTestClusterFloatSingleAttributeInteractionInfo); + Map writeTestClusterFloatDoubleCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusterfloatDoubleCommandParameterInfo = + new CommandParameterInfo("value", double.class); + writeTestClusterFloatDoubleCommandParams.put( + "value", testClusterfloatDoubleCommandParameterInfo); + InteractionInfo writeTestClusterFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeFloatDoubleAttribute( + (DefaultClusterCallback) callback, (Double) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterFloatDoubleCommandParams); + writeTestClusterInteractionInfo.put( + "writeFloatDoubleAttribute", writeTestClusterFloatDoubleAttributeInteractionInfo); Map writeTestClusterOctetStringCommandParams = new LinkedHashMap(); CommandParameterInfo testClusteroctetStringCommandParameterInfo = @@ -1778,6 +1812,42 @@ public Map> getWriteAttributeMap() { writeTestClusterNullableEnum16CommandParams); writeTestClusterInteractionInfo.put( "writeNullableEnum16Attribute", writeTestClusterNullableEnum16AttributeInteractionInfo); + Map writeTestClusterNullableFloatSingleCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableFloatSingleCommandParameterInfo = + new CommandParameterInfo("value", float.class); + writeTestClusterNullableFloatSingleCommandParams.put( + "value", testClusternullableFloatSingleCommandParameterInfo); + InteractionInfo writeTestClusterNullableFloatSingleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableFloatSingleAttribute( + (DefaultClusterCallback) callback, (Float) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableFloatSingleCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableFloatSingleAttribute", + writeTestClusterNullableFloatSingleAttributeInteractionInfo); + Map writeTestClusterNullableFloatDoubleCommandParams = + new LinkedHashMap(); + CommandParameterInfo testClusternullableFloatDoubleCommandParameterInfo = + new CommandParameterInfo("value", double.class); + writeTestClusterNullableFloatDoubleCommandParams.put( + "value", testClusternullableFloatDoubleCommandParameterInfo); + InteractionInfo writeTestClusterNullableFloatDoubleAttributeInteractionInfo = + new InteractionInfo( + (cluster, callback, commandArguments) -> { + ((ChipClusters.TestClusterCluster) cluster) + .writeNullableFloatDoubleAttribute( + (DefaultClusterCallback) callback, (Double) commandArguments.get("value")); + }, + () -> new ClusterInfoMapping.DelegatedDefaultClusterCallback(), + writeTestClusterNullableFloatDoubleCommandParams); + writeTestClusterInteractionInfo.put( + "writeNullableFloatDoubleAttribute", + writeTestClusterNullableFloatDoubleAttributeInteractionInfo); Map writeTestClusterNullableOctetStringCommandParams = new LinkedHashMap(); CommandParameterInfo testClusternullableOctetStringCommandParameterInfo = diff --git a/src/darwin/Framework/CHIP/templates/CHIPCallbackBridge-src.zapt b/src/darwin/Framework/CHIP/templates/CHIPCallbackBridge-src.zapt index 25db00bf195547..afaeeaa0d7faa8 100644 --- a/src/darwin/Framework/CHIP/templates/CHIPCallbackBridge-src.zapt +++ b/src/darwin/Framework/CHIP/templates/CHIPCallbackBridge-src.zapt @@ -31,6 +31,10 @@ {{#>CHIPCallbackBridge type="Int64u" isNullable=true ns="chip"}}NullableInt64uAttributeCallback{{/CHIPCallbackBridge}} {{#>CHIPCallbackBridge type="Int64s" isNullable=false ns="chip"}}Int64sAttributeCallback{{/CHIPCallbackBridge}} {{#>CHIPCallbackBridge type="Int64s" isNullable=true ns="chip"}}NullableInt64sAttributeCallback{{/CHIPCallbackBridge}} +{{#>CHIPCallbackBridge type="Single" isNullable=false ns="chip"}}FloatAttributeCallback{{/CHIPCallbackBridge}} +{{#>CHIPCallbackBridge type="Single" isNullable=true ns="chip"}}NullableFloatAttributeCallback{{/CHIPCallbackBridge}} +{{#>CHIPCallbackBridge type="Double" isNullable=false ns="chip"}}DoubleAttributeCallback{{/CHIPCallbackBridge}} +{{#>CHIPCallbackBridge type="Double" isNullable=true ns="chip"}}NullableDoubleAttributeCallback{{/CHIPCallbackBridge}} {{#>CHIPCallbackBridge type="vendor_id" isNullable=false ns="chip"}}VendorIdAttributeCallback{{/CHIPCallbackBridge}} {{#>CHIPCallbackBridge type="vendor_id" isNullable=true ns="chip"}}NullableVendorIdAttributeCallback{{/CHIPCallbackBridge}} diff --git a/src/darwin/Framework/CHIP/templates/CHIPCallbackBridge_internal.zapt b/src/darwin/Framework/CHIP/templates/CHIPCallbackBridge_internal.zapt index 98d7d01432bc23..49f6f24bd9881c 100644 --- a/src/darwin/Framework/CHIP/templates/CHIPCallbackBridge_internal.zapt +++ b/src/darwin/Framework/CHIP/templates/CHIPCallbackBridge_internal.zapt @@ -45,6 +45,10 @@ typedef void (*CHIP{{asUpperCamelCase parent.name}}Cluster{{asUpperCamelCase nam {{#>CHIPCallbackBridge header="1" type="Int64u" isNullable=true ns="chip"}}NullableInt64uAttributeCallback{{/CHIPCallbackBridge}} {{#>CHIPCallbackBridge header="1" type="Int64s" isNullable=false ns="chip"}}Int64sAttributeCallback{{/CHIPCallbackBridge}} {{#>CHIPCallbackBridge header="1" type="Int64s" isNullable=true ns="chip"}}NullableInt64sAttributeCallback{{/CHIPCallbackBridge}} +{{#>CHIPCallbackBridge header="1" type="Single" isNullable=false ns="chip"}}FloatAttributeCallback{{/CHIPCallbackBridge}} +{{#>CHIPCallbackBridge header="1" type="Single" isNullable=true ns="chip"}}NullableFloatAttributeCallback{{/CHIPCallbackBridge}} +{{#>CHIPCallbackBridge header="1" type="Double" isNullable=false ns="chip"}}DoubleAttributeCallback{{/CHIPCallbackBridge}} +{{#>CHIPCallbackBridge header="1" type="Double" isNullable=true ns="chip"}}NullableDoubleAttributeCallback{{/CHIPCallbackBridge}} {{#>CHIPCallbackBridge header="1" type="vendor_id" isNullable=false ns="chip"}}VendorIdAttributeCallback{{/CHIPCallbackBridge}} {{#>CHIPCallbackBridge header="1" type="vendor_id" isNullable=true ns="chip"}}NullableVendorIdAttributeCallback{{/CHIPCallbackBridge}} diff --git a/src/darwin/Framework/CHIP/templates/clusters-tests.zapt b/src/darwin/Framework/CHIP/templates/clusters-tests.zapt index a06e488525695a..1a00316efad506 100644 --- a/src/darwin/Framework/CHIP/templates/clusters-tests.zapt +++ b/src/darwin/Framework/CHIP/templates/clusters-tests.zapt @@ -11,6 +11,8 @@ #import +#import // For INFINITY + // system dependencies #import diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm index b806fb35b098b6..d5f788acf59967 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge.mm @@ -230,6 +230,42 @@ DispatchSuccess(context, objCValue); }; +void CHIPFloatAttributeCallbackBridge::OnSuccessFn(void * context, float value) +{ + NSNumber * _Nonnull objCValue; + objCValue = [NSNumber numberWithFloat:value]; + DispatchSuccess(context, objCValue); +}; + +void CHIPNullableFloatAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) +{ + NSNumber * _Nullable objCValue; + if (value.IsNull()) { + objCValue = nil; + } else { + objCValue = [NSNumber numberWithFloat:value.Value()]; + } + DispatchSuccess(context, objCValue); +}; + +void CHIPDoubleAttributeCallbackBridge::OnSuccessFn(void * context, double value) +{ + NSNumber * _Nonnull objCValue; + objCValue = [NSNumber numberWithDouble:value]; + DispatchSuccess(context, objCValue); +}; + +void CHIPNullableDoubleAttributeCallbackBridge::OnSuccessFn(void * context, const chip::app::DataModel::Nullable & value) +{ + NSNumber * _Nullable objCValue; + if (value.IsNull()) { + objCValue = nil; + } else { + objCValue = [NSNumber numberWithDouble:value.Value()]; + } + DispatchSuccess(context, objCValue); +}; + void CHIPVendorIdAttributeCallbackBridge::OnSuccessFn(void * context, chip::VendorId value) { NSNumber * _Nonnull objCValue; diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h index 1dd0641685f02d..eb40c41448cad6 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPCallbackBridge_internal.h @@ -426,6 +426,46 @@ class CHIPNullableInt64sAttributeCallbackBridge : public CHIPCallbackBridge & value); }; +class CHIPFloatAttributeCallbackBridge : public CHIPCallbackBridge +{ +public: + CHIPFloatAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, keepAlive){}; + + static void OnSuccessFn(void * context, float value); +}; + +class CHIPNullableFloatAttributeCallbackBridge : public CHIPCallbackBridge +{ +public: + CHIPNullableFloatAttributeCallbackBridge(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::DataModel::Nullable & value); +}; + +class CHIPDoubleAttributeCallbackBridge : public CHIPCallbackBridge +{ +public: + CHIPDoubleAttributeCallbackBridge(dispatch_queue_t queue, ResponseHandler handler, CHIPActionBlock action, + bool keepAlive = false) : + CHIPCallbackBridge(queue, handler, action, OnSuccessFn, keepAlive){}; + + static void OnSuccessFn(void * context, double value); +}; + +class CHIPNullableDoubleAttributeCallbackBridge : public CHIPCallbackBridge +{ +public: + CHIPNullableDoubleAttributeCallbackBridge(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::DataModel::Nullable & value); +}; + class CHIPVendorIdAttributeCallbackBridge : public CHIPCallbackBridge { public: diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h index 337efc716dc0d7..735640ef78714e 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h @@ -3469,6 +3469,24 @@ NS_ASSUME_NONNULL_BEGIN responseHandler:(ResponseHandler)responseHandler; - (void)reportAttributeEnum16WithResponseHandler:(void (^)(NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; +- (void)readAttributeFloatSingleWithCompletionHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)writeAttributeFloatSingleWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeFloatSingleWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeFloatSingleWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + +- (void)readAttributeFloatDoubleWithCompletionHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)writeAttributeFloatDoubleWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeFloatDoubleWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeFloatDoubleWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; + - (void)readAttributeOctetStringWithCompletionHandler:(void (^)( NSData * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeOctetStringWithValue:(NSData * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; @@ -3804,6 +3822,26 @@ NS_ASSUME_NONNULL_BEGIN - (void)reportAttributeNullableEnum16WithResponseHandler:(void (^)( NSNumber * _Nullable value, NSError * _Nullable error))responseHandler; +- (void)readAttributeNullableFloatSingleWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler; +- (void)writeAttributeNullableFloatSingleWithValue:(NSNumber * _Nullable)value + completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeNullableFloatSingleWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeNullableFloatSingleWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler; + +- (void)readAttributeNullableFloatDoubleWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler; +- (void)writeAttributeNullableFloatDoubleWithValue:(NSNumber * _Nullable)value + completionHandler:(StatusCompletion)completionHandler; +- (void)subscribeAttributeNullableFloatDoubleWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler; +- (void)reportAttributeNullableFloatDoubleWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler; + - (void)readAttributeNullableOctetStringWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler; - (void)writeAttributeNullableOctetStringWithValue:(NSData * _Nullable)value completionHandler:(StatusCompletion)completionHandler; diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm index ca03b0c61d2739..e19fe0337c8027 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm @@ -18246,6 +18246,120 @@ new CHIPInt16uAttributeCallbackBridge( true); } +- (void)readAttributeFloatSingleWithCompletionHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +{ + new CHIPFloatAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::FloatSingle::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeFloatSingleWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::FloatSingle::TypeInfo; + TypeInfo::Type cppValue; + cppValue = value.floatValue; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeFloatSingleWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPFloatAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeFloatSingle(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeFloatSingleWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +{ + new CHIPFloatAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeFloatSingle(success); + }, + true); +} + +- (void)readAttributeFloatDoubleWithCompletionHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))completionHandler +{ + new CHIPDoubleAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::FloatDouble::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeFloatDoubleWithValue:(NSNumber * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::FloatDouble::TypeInfo; + TypeInfo::Type cppValue; + cppValue = value.doubleValue; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeFloatDoubleWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPDoubleAttributeCallbackBridge(self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeFloatDouble(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeFloatDoubleWithResponseHandler:(void (^)( + NSNumber * _Nullable value, NSError * _Nullable error))responseHandler +{ + new CHIPDoubleAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeFloatDouble(success); + }, + true); +} + - (void)readAttributeOctetStringWithCompletionHandler:(void (^)( NSData * _Nullable value, NSError * _Nullable error))completionHandler { @@ -20591,6 +20705,132 @@ new CHIPNullableInt16uAttributeCallbackBridge( true); } +- (void)readAttributeNullableFloatSingleWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPNullableFloatAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::NullableFloatSingle::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeNullableFloatSingleWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::NullableFloatSingle::TypeInfo; + TypeInfo::Type cppValue; + if (value == nil) { + cppValue.SetNull(); + } else { + auto & nonNullValue_0 = cppValue.SetNonNull(); + nonNullValue_0 = value.floatValue; + } + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeNullableFloatSingleWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPNullableFloatAttributeCallbackBridge( + self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeNullableFloatSingle(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeNullableFloatSingleWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler +{ + new CHIPNullableFloatAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeNullableFloatSingle(success); + }, + true); +} + +- (void)readAttributeNullableFloatDoubleWithCompletionHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))completionHandler +{ + new CHIPNullableDoubleAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + completionHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + using TypeInfo = TestCluster::Attributes::NullableFloatDouble::TypeInfo; + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.ReadAttribute(successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)writeAttributeNullableFloatDoubleWithValue:(NSNumber * _Nullable)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable ignored) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::NullableFloatDouble::TypeInfo; + TypeInfo::Type cppValue; + if (value == nil) { + cppValue.SetNull(); + } else { + auto & nonNullValue_0 = cppValue.SetNonNull(); + nonNullValue_0 = value.doubleValue; + } + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + +- (void)subscribeAttributeNullableFloatDoubleWithMinInterval:(uint16_t)minInterval + maxInterval:(uint16_t)maxInterval + responseHandler:(ResponseHandler)responseHandler +{ + new CHIPNullableDoubleAttributeCallbackBridge( + self.callbackQueue, responseHandler, ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.SubscribeAttributeNullableFloatDouble(success, failure, minInterval, maxInterval); + }); +} + +- (void)reportAttributeNullableFloatDoubleWithResponseHandler:(void (^)(NSNumber * _Nullable value, + NSError * _Nullable error))responseHandler +{ + new CHIPNullableDoubleAttributeCallbackBridge( + self.callbackQueue, + ^(NSError * _Nullable error, id _Nullable value) { + responseHandler(value, error); + }, + ^(Cancelable * success, Cancelable * failure) { + return self.cppCluster.ReportAttributeNullableFloatDouble(success); + }, + true); +} + - (void)readAttributeNullableOctetStringWithCompletionHandler:(void (^)(NSData * _Nullable value, NSError * _Nullable error))completionHandler { diff --git a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m index 7ec418553a7618..d94a295c811eac 100644 --- a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m +++ b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m @@ -28,6 +28,8 @@ #import +#import // For INFINITY + // system dependencies #import @@ -21103,21 +21105,21 @@ - (void)testSendClusterTestCluster_000078_ReadAttribute } - (void)testSendClusterTestCluster_000079_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute ENUM8 Default Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute SINGLE Default Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeEnum8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute ENUM8 Default Value Error: %@", err); + [cluster readAttributeFloatSingleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute SINGLE Default Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertEqual([actualValue unsignedCharValue], 0); + XCTAssertEqual([actualValue floatValue], 0.0f); } [expectation fulfill]; @@ -21127,43 +21129,43 @@ - (void)testSendClusterTestCluster_000079_ReadAttribute } - (void)testSendClusterTestCluster_000080_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute ENUM8 Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute SINGLE medium Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id enum8Argument; - enum8Argument = [NSNumber numberWithUnsignedChar:255]; - [cluster writeAttributeEnum8WithValue:enum8Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute ENUM8 Max Value Error: %@", err); + id floatSingleArgument; + floatSingleArgument = [NSNumber numberWithFloat:0.1f]; + [cluster writeAttributeFloatSingleWithValue:floatSingleArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute SINGLE medium Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } - (void)testSendClusterTestCluster_000081_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute ENUM8 Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute SINGLE medium Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeEnum8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute ENUM8 Max Value Error: %@", err); + [cluster readAttributeFloatSingleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute SINGLE medium Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertEqual([actualValue unsignedCharValue], 255); + XCTAssertEqual([actualValue floatValue], 0.1f); } [expectation fulfill]; @@ -21173,67 +21175,43 @@ - (void)testSendClusterTestCluster_000081_ReadAttribute } - (void)testSendClusterTestCluster_000082_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute ENUM8 Min Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute SINGLE large Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id enum8Argument; - enum8Argument = [NSNumber numberWithUnsignedChar:0]; - [cluster writeAttributeEnum8WithValue:enum8Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute ENUM8 Min Value Error: %@", err); + id floatSingleArgument; + floatSingleArgument = [NSNumber numberWithFloat:17000000000.0f]; + [cluster writeAttributeFloatSingleWithValue:floatSingleArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute SINGLE large Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } - (void)testSendClusterTestCluster_000083_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute ENUM8 Min Value"]; - - CHIPDevice * device = GetConnectedDevice(); - dispatch_queue_t queue = dispatch_get_main_queue(); - CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; - XCTAssertNotNil(cluster); - - [cluster readAttributeEnum8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute ENUM8 Min Value Error: %@", err); - - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - - { - id actualValue = value; - XCTAssertEqual([actualValue unsignedCharValue], 0); - } - - [expectation fulfill]; - }]; - - [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; -} -- (void)testSendClusterTestCluster_000084_ReadAttribute -{ - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute ENUM16 Default Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute SINGLE large Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeEnum16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute ENUM16 Default Value Error: %@", err); + [cluster readAttributeFloatSingleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute SINGLE large Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertEqual([actualValue unsignedShortValue], 0U); + XCTAssertEqual([actualValue floatValue], 17000000000.0f); } [expectation fulfill]; @@ -21241,45 +21219,45 @@ - (void)testSendClusterTestCluster_000084_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000085_WriteAttribute +- (void)testSendClusterTestCluster_000084_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute ENUM16 Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute SINGLE small Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id enum16Argument; - enum16Argument = [NSNumber numberWithUnsignedShort:65535U]; - [cluster writeAttributeEnum16WithValue:enum16Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute ENUM16 Max Value Error: %@", err); + id floatSingleArgument; + floatSingleArgument = [NSNumber numberWithFloat:1.7e-10f]; + [cluster writeAttributeFloatSingleWithValue:floatSingleArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute SINGLE small Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000086_ReadAttribute +- (void)testSendClusterTestCluster_000085_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute ENUM16 Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute SINGLE small Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeEnum16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute ENUM16 Max Value Error: %@", err); + [cluster readAttributeFloatSingleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute SINGLE small Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertEqual([actualValue unsignedShortValue], 65535U); + XCTAssertEqual([actualValue floatValue], 1.7e-10f); } [expectation fulfill]; @@ -21287,45 +21265,45 @@ - (void)testSendClusterTestCluster_000086_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000087_WriteAttribute +- (void)testSendClusterTestCluster_000086_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute ENUM16 Min Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute SINGLE Default Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id enum16Argument; - enum16Argument = [NSNumber numberWithUnsignedShort:0U]; - [cluster writeAttributeEnum16WithValue:enum16Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute ENUM16 Min Value Error: %@", err); + id floatSingleArgument; + floatSingleArgument = [NSNumber numberWithFloat:0.0f]; + [cluster writeAttributeFloatSingleWithValue:floatSingleArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute SINGLE Default Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000088_ReadAttribute +- (void)testSendClusterTestCluster_000087_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute ENUM16 Min Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute SINGLE Default Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeEnum16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute ENUM16 Min Value Error: %@", err); + [cluster readAttributeFloatSingleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute SINGLE Default Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertEqual([actualValue unsignedShortValue], 0U); + XCTAssertEqual([actualValue floatValue], 0.0f); } [expectation fulfill]; @@ -21333,23 +21311,23 @@ - (void)testSendClusterTestCluster_000088_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000089_ReadAttribute +- (void)testSendClusterTestCluster_000088_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute OCTET_STRING Default Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute DOUBLE Default Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeOctetStringWithCompletionHandler:^(NSData * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute OCTET_STRING Default Value Error: %@", err); + [cluster readAttributeFloatDoubleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute DOUBLE Default Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertTrue([actualValue isEqualToData:[[NSData alloc] initWithBytes:"" length:0]]); + XCTAssertEqual([actualValue doubleValue], 0); } [expectation fulfill]; @@ -21357,20 +21335,20 @@ - (void)testSendClusterTestCluster_000089_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000090_WriteAttribute +- (void)testSendClusterTestCluster_000089_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute OCTET_STRING with embedded null"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute DOUBLE medium Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id octetStringArgument; - octetStringArgument = [[NSData alloc] initWithBytes:"Tes\x00ti\x00ng" length:9]; - [cluster writeAttributeOctetStringWithValue:octetStringArgument + id floatDoubleArgument; + floatDoubleArgument = [NSNumber numberWithDouble:0.1234567890123]; + [cluster writeAttributeFloatDoubleWithValue:floatDoubleArgument completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute OCTET_STRING with embedded null Error: %@", err); + NSLog(@"Write attribute DOUBLE medium Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -21379,23 +21357,23 @@ - (void)testSendClusterTestCluster_000090_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000091_ReadAttribute +- (void)testSendClusterTestCluster_000090_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute OCTET_STRING with embedded null"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute DOUBLE medium Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeOctetStringWithCompletionHandler:^(NSData * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute OCTET_STRING with embedded null Error: %@", err); + [cluster readAttributeFloatDoubleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute DOUBLE medium Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertTrue([actualValue isEqualToData:[[NSData alloc] initWithBytes:"Tes\x00ti\x00ng" length:9]]); + XCTAssertEqual([actualValue doubleValue], 0.1234567890123); } [expectation fulfill]; @@ -21403,20 +21381,20 @@ - (void)testSendClusterTestCluster_000091_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000092_WriteAttribute +- (void)testSendClusterTestCluster_000091_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute OCTET_STRING"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute DOUBLE large Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id octetStringArgument; - octetStringArgument = [[NSData alloc] initWithBytes:"TestValue" length:9]; - [cluster writeAttributeOctetStringWithValue:octetStringArgument + id floatDoubleArgument; + floatDoubleArgument = [NSNumber numberWithDouble:1.7e+200]; + [cluster writeAttributeFloatDoubleWithValue:floatDoubleArgument completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute OCTET_STRING Error: %@", err); + NSLog(@"Write attribute DOUBLE large Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -21425,23 +21403,23 @@ - (void)testSendClusterTestCluster_000092_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000093_ReadAttribute +- (void)testSendClusterTestCluster_000092_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute OCTET_STRING"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute DOUBLE large Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeOctetStringWithCompletionHandler:^(NSData * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute OCTET_STRING Error: %@", err); + [cluster readAttributeFloatDoubleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute DOUBLE large Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertTrue([actualValue isEqualToData:[[NSData alloc] initWithBytes:"TestValue" length:9]]); + XCTAssertEqual([actualValue doubleValue], 1.7e+200); } [expectation fulfill]; @@ -21449,44 +21427,45 @@ - (void)testSendClusterTestCluster_000093_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000094_WriteAttribute +- (void)testSendClusterTestCluster_000093_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute OCTET_STRING"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute DOUBLE small Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id octetStringArgument; - octetStringArgument = [[NSData alloc] initWithBytes:"TestValueLongerThan10" length:21]; - [cluster writeAttributeOctetStringWithValue:octetStringArgument + id floatDoubleArgument; + floatDoubleArgument = [NSNumber numberWithDouble:1.7e-200]; + [cluster writeAttributeFloatDoubleWithValue:floatDoubleArgument completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute OCTET_STRING Error: %@", err); + NSLog(@"Write attribute DOUBLE small Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); [expectation fulfill]; }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000095_ReadAttribute +- (void)testSendClusterTestCluster_000094_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute OCTET_STRING"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute DOUBLE small Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeOctetStringWithCompletionHandler:^(NSData * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute OCTET_STRING Error: %@", err); + [cluster readAttributeFloatDoubleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute DOUBLE small Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertTrue([actualValue isEqualToData:[[NSData alloc] initWithBytes:"TestValue" length:9]]); + XCTAssertEqual([actualValue doubleValue], 1.7e-200); } [expectation fulfill]; @@ -21494,20 +21473,20 @@ - (void)testSendClusterTestCluster_000095_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000096_WriteAttribute +- (void)testSendClusterTestCluster_000095_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute OCTET_STRING"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute DOUBLE Default Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id octetStringArgument; - octetStringArgument = [[NSData alloc] initWithBytes:"" length:0]; - [cluster writeAttributeOctetStringWithValue:octetStringArgument + id floatDoubleArgument; + floatDoubleArgument = [NSNumber numberWithDouble:0]; + [cluster writeAttributeFloatDoubleWithValue:floatDoubleArgument completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute OCTET_STRING Error: %@", err); + NSLog(@"Write attribute DOUBLE Default Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -21516,23 +21495,23 @@ - (void)testSendClusterTestCluster_000096_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000097_ReadAttribute +- (void)testSendClusterTestCluster_000096_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LONG_OCTET_STRING Default Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute DOUBLE Default Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeLongOctetStringWithCompletionHandler:^(NSData * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute LONG_OCTET_STRING Default Value Error: %@", err); + [cluster readAttributeFloatDoubleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute DOUBLE Default Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertTrue([actualValue isEqualToData:[[NSData alloc] initWithBytes:"" length:0]]); + XCTAssertEqual([actualValue doubleValue], 0); } [expectation fulfill]; @@ -21540,55 +21519,23 @@ - (void)testSendClusterTestCluster_000097_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000098_WriteAttribute -{ - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute LONG_OCTET_STRING"]; - - CHIPDevice * device = GetConnectedDevice(); - dispatch_queue_t queue = dispatch_get_main_queue(); - CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; - XCTAssertNotNil(cluster); - - id longOctetStringArgument; - longOctetStringArgument = [[NSData alloc] - initWithBytes:"111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" - "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" - "111111111111111111111111111111111111111111111111111111111111111111111111111111111111" - length:300]; - [cluster writeAttributeLongOctetStringWithValue:longOctetStringArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute LONG_OCTET_STRING Error: %@", err); - - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - - [expectation fulfill]; - }]; - - [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; -} -- (void)testSendClusterTestCluster_000099_ReadAttribute +- (void)testSendClusterTestCluster_000097_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LONG_OCTET_STRING"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute ENUM8 Default Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeLongOctetStringWithCompletionHandler:^(NSData * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute LONG_OCTET_STRING Error: %@", err); + [cluster readAttributeEnum8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute ENUM8 Default Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertTrue([actualValue - isEqualToData:[[NSData alloc] - initWithBytes:"1111111111111111111111111111111111111111111111111111111111111111111111111111111111" - "1111111111111111111111111111111111111111111111111111111111111111111111111111111111" - "1111111111111111111111111111111111111111111111111111111111111111111111111111111111" - "111111111111111111111111111111111111111111111111111111" - length:300]]); + XCTAssertEqual([actualValue unsignedCharValue], 0); } [expectation fulfill]; @@ -21596,45 +21543,45 @@ - (void)testSendClusterTestCluster_000099_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000100_WriteAttribute +- (void)testSendClusterTestCluster_000098_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute LONG_OCTET_STRING"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute ENUM8 Max Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id longOctetStringArgument; - longOctetStringArgument = [[NSData alloc] initWithBytes:"" length:0]; - [cluster writeAttributeLongOctetStringWithValue:longOctetStringArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute LONG_OCTET_STRING Error: %@", err); + id enum8Argument; + enum8Argument = [NSNumber numberWithUnsignedChar:255]; + [cluster writeAttributeEnum8WithValue:enum8Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute ENUM8 Max Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000101_ReadAttribute +- (void)testSendClusterTestCluster_000099_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute CHAR_STRING Default Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute ENUM8 Max Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeCharStringWithCompletionHandler:^(NSString * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute CHAR_STRING Default Value Error: %@", err); + [cluster readAttributeEnum8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute ENUM8 Max Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertTrue([actualValue isEqualToString:@""]); + XCTAssertEqual([actualValue unsignedCharValue], 255); } [expectation fulfill]; @@ -21642,45 +21589,45 @@ - (void)testSendClusterTestCluster_000101_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000102_WriteAttribute +- (void)testSendClusterTestCluster_000100_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute CHAR_STRING"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute ENUM8 Min Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id charStringArgument; - charStringArgument = @"☉T☉"; - [cluster writeAttributeCharStringWithValue:charStringArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute CHAR_STRING Error: %@", err); + id enum8Argument; + enum8Argument = [NSNumber numberWithUnsignedChar:0]; + [cluster writeAttributeEnum8WithValue:enum8Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute ENUM8 Min Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000103_ReadAttribute +- (void)testSendClusterTestCluster_000101_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute CHAR_STRING"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute ENUM8 Min Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeCharStringWithCompletionHandler:^(NSString * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute CHAR_STRING Error: %@", err); + [cluster readAttributeEnum8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute ENUM8 Min Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertTrue([actualValue isEqualToString:@"☉T☉"]); + XCTAssertEqual([actualValue unsignedCharValue], 0); } [expectation fulfill]; @@ -21688,44 +21635,23 @@ - (void)testSendClusterTestCluster_000103_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000104_WriteAttribute +- (void)testSendClusterTestCluster_000102_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute CHAR_STRING - Value too long"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute ENUM16 Default Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id charStringArgument; - charStringArgument = @"☉TestValueLongerThan10☉"; - [cluster writeAttributeCharStringWithValue:charStringArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute CHAR_STRING - Value too long Error: %@", err); + [cluster readAttributeEnum16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute ENUM16 Default Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); - [expectation fulfill]; - }]; - - [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; -} -- (void)testSendClusterTestCluster_000105_ReadAttribute -{ - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute CHAR_STRING"]; - - CHIPDevice * device = GetConnectedDevice(); - dispatch_queue_t queue = dispatch_get_main_queue(); - CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; - XCTAssertNotNil(cluster); - - [cluster readAttributeCharStringWithCompletionHandler:^(NSString * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute CHAR_STRING Error: %@", err); - - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertTrue([actualValue isEqualToString:@"☉T☉"]); + XCTAssertEqual([actualValue unsignedShortValue], 0U); } [expectation fulfill]; @@ -21733,45 +21659,45 @@ - (void)testSendClusterTestCluster_000105_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000106_WriteAttribute +- (void)testSendClusterTestCluster_000103_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute CHAR_STRING - Empty"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute ENUM16 Max Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id charStringArgument; - charStringArgument = @""; - [cluster writeAttributeCharStringWithValue:charStringArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute CHAR_STRING - Empty Error: %@", err); + id enum16Argument; + enum16Argument = [NSNumber numberWithUnsignedShort:65535U]; + [cluster writeAttributeEnum16WithValue:enum16Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute ENUM16 Max Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000107_ReadAttribute +- (void)testSendClusterTestCluster_000104_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LONG_CHAR_STRING Default Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute ENUM16 Max Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeLongCharStringWithCompletionHandler:^(NSString * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute LONG_CHAR_STRING Default Value Error: %@", err); + [cluster readAttributeEnum16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute ENUM16 Max Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertTrue([actualValue isEqualToString:@""]); + XCTAssertEqual([actualValue unsignedShortValue], 65535U); } [expectation fulfill]; @@ -21779,52 +21705,45 @@ - (void)testSendClusterTestCluster_000107_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000108_WriteAttribute +- (void)testSendClusterTestCluster_000105_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute LONG_CHAR_STRING"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute ENUM16 Min Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id longCharStringArgument; - longCharStringArgument - = @"☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉" - @"☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉" - @"☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉"; - [cluster writeAttributeLongCharStringWithValue:longCharStringArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute LONG_CHAR_STRING Error: %@", err); + id enum16Argument; + enum16Argument = [NSNumber numberWithUnsignedShort:0U]; + [cluster writeAttributeEnum16WithValue:enum16Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute ENUM16 Min Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000109_ReadAttribute +- (void)testSendClusterTestCluster_000106_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LONG_CHAR_STRING"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute ENUM16 Min Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeLongCharStringWithCompletionHandler:^(NSString * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute LONG_CHAR_STRING Error: %@", err); + [cluster readAttributeEnum16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute ENUM16 Min Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertTrue([actualValue - isEqualToString: - @"☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉" - @"☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉" - @"☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉"]); + XCTAssertEqual([actualValue unsignedShortValue], 0U); } [expectation fulfill]; @@ -21832,45 +21751,23 @@ - (void)testSendClusterTestCluster_000109_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000110_WriteAttribute -{ - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute LONG_CHAR_STRING"]; - - CHIPDevice * device = GetConnectedDevice(); - dispatch_queue_t queue = dispatch_get_main_queue(); - CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; - XCTAssertNotNil(cluster); - - id longCharStringArgument; - longCharStringArgument = @""; - [cluster writeAttributeLongCharStringWithValue:longCharStringArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute LONG_CHAR_STRING Error: %@", err); - - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - - [expectation fulfill]; - }]; - - [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; -} -- (void)testSendClusterTestCluster_000111_ReadAttribute +- (void)testSendClusterTestCluster_000107_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_US Default Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute OCTET_STRING Default Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeEpochUsWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute EPOCH_US Default Value Error: %@", err); + [cluster readAttributeOctetStringWithCompletionHandler:^(NSData * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute OCTET_STRING Default Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertEqual([actualValue unsignedLongLongValue], 0ULL); + XCTAssertTrue([actualValue isEqualToData:[[NSData alloc] initWithBytes:"" length:0]]); } [expectation fulfill]; @@ -21878,45 +21775,45 @@ - (void)testSendClusterTestCluster_000111_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000112_WriteAttribute +- (void)testSendClusterTestCluster_000108_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_US Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute OCTET_STRING with embedded null"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id epochUsArgument; - epochUsArgument = [NSNumber numberWithUnsignedLongLong:18446744073709551615ULL]; - [cluster writeAttributeEpochUsWithValue:epochUsArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute EPOCH_US Max Value Error: %@", err); + id octetStringArgument; + octetStringArgument = [[NSData alloc] initWithBytes:"Tes\x00ti\x00ng" length:9]; + [cluster writeAttributeOctetStringWithValue:octetStringArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute OCTET_STRING with embedded null Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000113_ReadAttribute +- (void)testSendClusterTestCluster_000109_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_US Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute OCTET_STRING with embedded null"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeEpochUsWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute EPOCH_US Max Value Error: %@", err); + [cluster readAttributeOctetStringWithCompletionHandler:^(NSData * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute OCTET_STRING with embedded null Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertEqual([actualValue unsignedLongLongValue], 18446744073709551615ULL); + XCTAssertTrue([actualValue isEqualToData:[[NSData alloc] initWithBytes:"Tes\x00ti\x00ng" length:9]]); } [expectation fulfill]; @@ -21924,45 +21821,45 @@ - (void)testSendClusterTestCluster_000113_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000114_WriteAttribute +- (void)testSendClusterTestCluster_000110_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_US Min Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute OCTET_STRING"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id epochUsArgument; - epochUsArgument = [NSNumber numberWithUnsignedLongLong:0ULL]; - [cluster writeAttributeEpochUsWithValue:epochUsArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute EPOCH_US Min Value Error: %@", err); + id octetStringArgument; + octetStringArgument = [[NSData alloc] initWithBytes:"TestValue" length:9]; + [cluster writeAttributeOctetStringWithValue:octetStringArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute OCTET_STRING Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000115_ReadAttribute +- (void)testSendClusterTestCluster_000111_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_US Min Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute OCTET_STRING"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeEpochUsWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute EPOCH_US Min Value Error: %@", err); + [cluster readAttributeOctetStringWithCompletionHandler:^(NSData * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute OCTET_STRING Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertEqual([actualValue unsignedLongLongValue], 0ULL); + XCTAssertTrue([actualValue isEqualToData:[[NSData alloc] initWithBytes:"TestValue" length:9]]); } [expectation fulfill]; @@ -21970,23 +21867,44 @@ - (void)testSendClusterTestCluster_000115_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000116_ReadAttribute +- (void)testSendClusterTestCluster_000112_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_S Default Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute OCTET_STRING"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeEpochSWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute EPOCH_S Default Value Error: %@", err); + id octetStringArgument; + octetStringArgument = [[NSData alloc] initWithBytes:"TestValueLongerThan10" length:21]; + [cluster writeAttributeOctetStringWithValue:octetStringArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute OCTET_STRING Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000113_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute OCTET_STRING"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeOctetStringWithCompletionHandler:^(NSData * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute OCTET_STRING Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertEqual([actualValue unsignedIntValue], 0UL); + XCTAssertTrue([actualValue isEqualToData:[[NSData alloc] initWithBytes:"TestValue" length:9]]); } [expectation fulfill]; @@ -21994,45 +21912,45 @@ - (void)testSendClusterTestCluster_000116_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000117_WriteAttribute +- (void)testSendClusterTestCluster_000114_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_S Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute OCTET_STRING"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id epochSArgument; - epochSArgument = [NSNumber numberWithUnsignedInt:4294967295UL]; - [cluster writeAttributeEpochSWithValue:epochSArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute EPOCH_S Max Value Error: %@", err); + id octetStringArgument; + octetStringArgument = [[NSData alloc] initWithBytes:"" length:0]; + [cluster writeAttributeOctetStringWithValue:octetStringArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute OCTET_STRING Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000118_ReadAttribute +- (void)testSendClusterTestCluster_000115_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_S Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LONG_OCTET_STRING Default Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeEpochSWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute EPOCH_S Max Value Error: %@", err); + [cluster readAttributeLongOctetStringWithCompletionHandler:^(NSData * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute LONG_OCTET_STRING Default Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertEqual([actualValue unsignedIntValue], 4294967295UL); + XCTAssertTrue([actualValue isEqualToData:[[NSData alloc] initWithBytes:"" length:0]]); } [expectation fulfill]; @@ -22040,45 +21958,55 @@ - (void)testSendClusterTestCluster_000118_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000119_WriteAttribute +- (void)testSendClusterTestCluster_000116_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_S Min Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute LONG_OCTET_STRING"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id epochSArgument; - epochSArgument = [NSNumber numberWithUnsignedInt:0UL]; - [cluster writeAttributeEpochSWithValue:epochSArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute EPOCH_S Min Value Error: %@", err); + id longOctetStringArgument; + longOctetStringArgument = [[NSData alloc] + initWithBytes:"111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" + "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111" + "111111111111111111111111111111111111111111111111111111111111111111111111111111111111" + length:300]; + [cluster writeAttributeLongOctetStringWithValue:longOctetStringArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute LONG_OCTET_STRING Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000120_ReadAttribute +- (void)testSendClusterTestCluster_000117_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_S Min Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LONG_OCTET_STRING"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeEpochSWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute EPOCH_S Min Value Error: %@", err); + [cluster readAttributeLongOctetStringWithCompletionHandler:^(NSData * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute LONG_OCTET_STRING Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertEqual([actualValue unsignedIntValue], 0UL); + XCTAssertTrue([actualValue + isEqualToData:[[NSData alloc] + initWithBytes:"1111111111111111111111111111111111111111111111111111111111111111111111111111111111" + "1111111111111111111111111111111111111111111111111111111111111111111111111111111111" + "1111111111111111111111111111111111111111111111111111111111111111111111111111111111" + "111111111111111111111111111111111111111111111111111111" + length:300]]); } [expectation fulfill]; @@ -22086,28 +22014,45 @@ - (void)testSendClusterTestCluster_000120_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000121_ReadAttribute +- (void)testSendClusterTestCluster_000118_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute UNSUPPORTED"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute LONG_OCTET_STRING"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeUnsupportedWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute UNSUPPORTED Error: %@", err); + id longOctetStringArgument; + longOctetStringArgument = [[NSData alloc] initWithBytes:"" length:0]; + [cluster writeAttributeLongOctetStringWithValue:longOctetStringArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute LONG_OCTET_STRING Error: %@", err); - if (err.code == CHIPErrorCodeUnsupportedAttribute) { - [expectation fulfill]; - return; - } + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000119_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute CHAR_STRING Default Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeCharStringWithCompletionHandler:^(NSString * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute CHAR_STRING Default Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertEqual([actualValue boolValue], 0); + XCTAssertTrue([actualValue isEqualToString:@""]); } [expectation fulfill]; @@ -22115,86 +22060,90 @@ - (void)testSendClusterTestCluster_000121_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000122_WriteAttribute +- (void)testSendClusterTestCluster_000120_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Writeattribute UNSUPPORTED"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute CHAR_STRING"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id unsupportedArgument; - unsupportedArgument = [NSNumber numberWithBool:0]; - [cluster writeAttributeUnsupportedWithValue:unsupportedArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Writeattribute UNSUPPORTED Error: %@", err); - - if (err.code == CHIPErrorCodeUnsupportedAttribute) { - [expectation fulfill]; - return; - } + id charStringArgument; + charStringArgument = @"☉T☉"; + [cluster writeAttributeCharStringWithValue:charStringArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute CHAR_STRING Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000123_Test +- (void)testSendClusterTestCluster_000121_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command to unsupported endpoint"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute CHAR_STRING"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); - CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:200 queue:queue]; + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster testWithCompletionHandler:^(NSError * _Nullable err) { - NSLog(@"Send Test Command to unsupported endpoint Error: %@", err); + [cluster readAttributeCharStringWithCompletionHandler:^(NSString * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute CHAR_STRING Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertTrue([actualValue isEqualToString:@"☉T☉"]); + } - XCTAssertNotEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); [expectation fulfill]; }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000124_Test +- (void)testSendClusterTestCluster_000122_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command to unsupported cluster"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute CHAR_STRING - Value too long"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); - CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:0 queue:queue]; + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster testWithCompletionHandler:^(NSError * _Nullable err) { - NSLog(@"Send Test Command to unsupported cluster Error: %@", err); + id charStringArgument; + charStringArgument = @"☉TestValueLongerThan10☉"; + [cluster writeAttributeCharStringWithValue:charStringArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute CHAR_STRING - Value too long Error: %@", err); - XCTAssertNotEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000125_ReadAttribute +- (void)testSendClusterTestCluster_000123_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute vendor_id Default Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute CHAR_STRING"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeVendorIdWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute vendor_id Default Value Error: %@", err); + [cluster readAttributeCharStringWithCompletionHandler:^(NSString * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute CHAR_STRING Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertEqual([actualValue unsignedShortValue], 0U); + XCTAssertTrue([actualValue isEqualToString:@"☉T☉"]); } [expectation fulfill]; @@ -22202,45 +22151,45 @@ - (void)testSendClusterTestCluster_000125_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000126_WriteAttribute +- (void)testSendClusterTestCluster_000124_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute vendor_id"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute CHAR_STRING - Empty"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id vendorIdArgument; - vendorIdArgument = [NSNumber numberWithUnsignedShort:17U]; - [cluster writeAttributeVendorIdWithValue:vendorIdArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute vendor_id Error: %@", err); + id charStringArgument; + charStringArgument = @""; + [cluster writeAttributeCharStringWithValue:charStringArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute CHAR_STRING - Empty Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000127_ReadAttribute +- (void)testSendClusterTestCluster_000125_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute vendor_id"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LONG_CHAR_STRING Default Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeVendorIdWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute vendor_id Error: %@", err); + [cluster readAttributeLongCharStringWithCompletionHandler:^(NSString * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute LONG_CHAR_STRING Default Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertEqual([actualValue unsignedShortValue], 17U); + XCTAssertTrue([actualValue isEqualToString:@""]); } [expectation fulfill]; @@ -22248,859 +22197,1328 @@ - (void)testSendClusterTestCluster_000127_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000128_WriteAttribute +- (void)testSendClusterTestCluster_000126_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Restore attribute vendor_id"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute LONG_CHAR_STRING"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id vendorIdArgument; - vendorIdArgument = [NSNumber numberWithUnsignedShort:0U]; - [cluster writeAttributeVendorIdWithValue:vendorIdArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Restore attribute vendor_id Error: %@", err); + id longCharStringArgument; + longCharStringArgument + = @"☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉" + @"☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉" + @"☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉"; + [cluster writeAttributeLongCharStringWithValue:longCharStringArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute LONG_CHAR_STRING Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000129_TestEnumsRequest +- (void)testSendClusterTestCluster_000127_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Send a command with a vendor_id and enum"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LONG_CHAR_STRING"]; 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 = [[CHIPTestClusterClusterTestEnumsRequestParams alloc] init]; - params.arg1 = [NSNumber numberWithUnsignedShort:20003U]; - params.arg2 = [NSNumber numberWithUnsignedChar:101]; - [cluster - testEnumsRequestWithParams:params - completionHandler:^(CHIPTestClusterClusterTestEnumsResponseParams * _Nullable values, NSError * _Nullable err) { - NSLog(@"Send a command with a vendor_id and enum Error: %@", err); + [cluster readAttributeLongCharStringWithCompletionHandler:^(NSString * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute LONG_CHAR_STRING Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - { - id actualValue = values.arg1; - XCTAssertEqual([actualValue unsignedShortValue], 20003U); - } - { - id actualValue = values.arg2; - XCTAssertEqual([actualValue unsignedCharValue], 101); - } + { + id actualValue = value; + XCTAssertTrue([actualValue + isEqualToString: + @"☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉" + @"☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉" + @"☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉☉"]); + } - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000130_TestStructArgumentRequest +- (void)testSendClusterTestCluster_000128_WriteAttribute { - XCTestExpectation * expectation = - [self expectationWithDescription:@"Send Test Command With Struct Argument and arg1.b is true"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute LONG_CHAR_STRING"]; 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 = [[CHIPTestClusterClusterTestStructArgumentRequestParams alloc] init]; - params.arg1 = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) params.arg1).a = [NSNumber numberWithUnsignedChar:0]; - ((CHIPTestClusterClusterSimpleStruct *) params.arg1).b = [NSNumber numberWithBool:true]; - ((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]; - ((CHIPTestClusterClusterSimpleStruct *) params.arg1).h = [NSNumber numberWithDouble:0]; - - [cluster testStructArgumentRequestWithParams:params - completionHandler:^( - CHIPTestClusterClusterBooleanResponseParams * _Nullable values, NSError * _Nullable err) { - NSLog(@"Send Test Command With Struct Argument and arg1.b is true Error: %@", err); - - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + id longCharStringArgument; + longCharStringArgument = @""; + [cluster writeAttributeLongCharStringWithValue:longCharStringArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute LONG_CHAR_STRING Error: %@", err); - { - id actualValue = values.value; - XCTAssertEqual([actualValue boolValue], true); - } + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000131_TestStructArgumentRequest +- (void)testSendClusterTestCluster_000129_ReadAttribute { - XCTestExpectation * expectation = - [self expectationWithDescription:@"Send Test Command With Struct Argument and arg1.b is false"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_US Default Value"]; 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 = [[CHIPTestClusterClusterTestStructArgumentRequestParams alloc] init]; - params.arg1 = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) params.arg1).a = [NSNumber numberWithUnsignedChar:0]; - ((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]; - ((CHIPTestClusterClusterSimpleStruct *) params.arg1).h = [NSNumber numberWithDouble:0]; + [cluster readAttributeEpochUsWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute EPOCH_US Default Value Error: %@", err); - [cluster testStructArgumentRequestWithParams:params - completionHandler:^( - CHIPTestClusterClusterBooleanResponseParams * _Nullable values, NSError * _Nullable err) { - NSLog(@"Send Test Command With Struct Argument and arg1.b is false Error: %@", err); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + { + id actualValue = value; + XCTAssertEqual([actualValue unsignedLongLongValue], 0ULL); + } - { - id actualValue = values.value; - XCTAssertEqual([actualValue boolValue], false); - } - - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000132_TestNestedStructArgumentRequest +- (void)testSendClusterTestCluster_000130_WriteAttribute { - XCTestExpectation * expectation = - [self expectationWithDescription:@"Send Test Command With Nested Struct Argument and arg1.c.b is true"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_US Max Value"]; 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 = [[CHIPTestClusterClusterTestNestedStructArgumentRequestParams alloc] init]; - params.arg1 = [[CHIPTestClusterClusterNestedStruct alloc] init]; - ((CHIPTestClusterClusterNestedStruct *) params.arg1).a = [NSNumber numberWithUnsignedChar:0]; - ((CHIPTestClusterClusterNestedStruct *) params.arg1).b = [NSNumber numberWithBool:true]; - ((CHIPTestClusterClusterNestedStruct *) params.arg1).c = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).a = - [NSNumber numberWithUnsignedChar:0]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).b = - [NSNumber numberWithBool:true]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).c = - [NSNumber numberWithUnsignedChar:2]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).d = - [[NSData alloc] initWithBytes:"octet_string" length:12]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).e = @"char_string"; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).f = - [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).g = - [NSNumber numberWithFloat:0]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).h = - [NSNumber numberWithDouble:0]; + id epochUsArgument; + epochUsArgument = [NSNumber numberWithUnsignedLongLong:18446744073709551615ULL]; + [cluster writeAttributeEpochUsWithValue:epochUsArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute EPOCH_US Max Value Error: %@", err); - [cluster - testNestedStructArgumentRequestWithParams:params - completionHandler:^( - CHIPTestClusterClusterBooleanResponseParams * _Nullable values, NSError * _Nullable err) { - NSLog(@"Send Test Command With Nested Struct Argument and arg1.c.b is true Error: %@", err); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + [expectation fulfill]; + }]; - { - id actualValue = values.value; - XCTAssertEqual([actualValue boolValue], true); - } + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000131_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_US Max Value"]; - [expectation fulfill]; - }]; + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeEpochUsWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute EPOCH_US Max Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertEqual([actualValue unsignedLongLongValue], 18446744073709551615ULL); + } + + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000133_TestNestedStructArgumentRequest +- (void)testSendClusterTestCluster_000132_WriteAttribute { - XCTestExpectation * expectation = - [self expectationWithDescription:@"Send Test Command With Nested Struct Argument arg1.c.b is false"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_US Min Value"]; 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 = [[CHIPTestClusterClusterTestNestedStructArgumentRequestParams alloc] init]; - params.arg1 = [[CHIPTestClusterClusterNestedStruct alloc] init]; - ((CHIPTestClusterClusterNestedStruct *) params.arg1).a = [NSNumber numberWithUnsignedChar:0]; - ((CHIPTestClusterClusterNestedStruct *) params.arg1).b = [NSNumber numberWithBool:true]; - ((CHIPTestClusterClusterNestedStruct *) params.arg1).c = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).a = - [NSNumber numberWithUnsignedChar:0]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).b = - [NSNumber numberWithBool:false]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).c = - [NSNumber numberWithUnsignedChar:2]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).d = - [[NSData alloc] initWithBytes:"octet_string" length:12]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).e = @"char_string"; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).f = - [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).g = - [NSNumber numberWithFloat:0]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).h = - [NSNumber numberWithDouble:0]; + id epochUsArgument; + epochUsArgument = [NSNumber numberWithUnsignedLongLong:0ULL]; + [cluster writeAttributeEpochUsWithValue:epochUsArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute EPOCH_US Min Value Error: %@", err); - [cluster testNestedStructArgumentRequestWithParams:params - completionHandler:^( - CHIPTestClusterClusterBooleanResponseParams * _Nullable values, NSError * _Nullable err) { - NSLog(@"Send Test Command With Nested Struct Argument arg1.c.b is false Error: %@", err); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + [expectation fulfill]; + }]; - { - id actualValue = values.value; - XCTAssertEqual([actualValue boolValue], false); - } + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000133_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_US Min Value"]; - [expectation fulfill]; - }]; + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeEpochUsWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute EPOCH_US Min Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertEqual([actualValue unsignedLongLongValue], 0ULL); + } + + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000134_TestNestedStructListArgumentRequest +- (void)testSendClusterTestCluster_000134_ReadAttribute { - XCTestExpectation * expectation = - [self expectationWithDescription:@"Send Test Command With Nested Struct List Argument and all fields b of arg1.d are true"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_S Default Value"]; 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 = [[CHIPTestClusterClusterTestNestedStructListArgumentRequestParams alloc] init]; - params.arg1 = [[CHIPTestClusterClusterNestedStructList alloc] init]; - ((CHIPTestClusterClusterNestedStructList *) params.arg1).a = [NSNumber numberWithUnsignedChar:0]; - ((CHIPTestClusterClusterNestedStructList *) params.arg1).b = [NSNumber numberWithBool:true]; - ((CHIPTestClusterClusterNestedStructList *) params.arg1).c = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).a = - [NSNumber numberWithUnsignedChar:0]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).b = - [NSNumber numberWithBool:true]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).c = - [NSNumber numberWithUnsignedChar:2]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).d = - [[NSData alloc] initWithBytes:"octet_string" length:12]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).e = @"char_string"; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).f = - [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).g = - [NSNumber numberWithFloat:0]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).h = - [NSNumber numberWithDouble:0]; + [cluster readAttributeEpochSWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute EPOCH_S Default Value Error: %@", err); - { - NSMutableArray * temp_1 = [[NSMutableArray alloc] init]; - temp_1[0] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).a = [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).b = [NSNumber numberWithBool:true]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).c = [NSNumber numberWithUnsignedChar:3]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).d = [[NSData alloc] initWithBytes:"nested_octet_string" length:19]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).e = @"nested_char_string"; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).f = [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).g = [NSNumber numberWithFloat:0]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).h = [NSNumber numberWithDouble:0]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - temp_1[1] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).a = [NSNumber numberWithUnsignedChar:2]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).b = [NSNumber numberWithBool:true]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).c = [NSNumber numberWithUnsignedChar:3]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).d = [[NSData alloc] initWithBytes:"nested_octet_string" length:19]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).e = @"nested_char_string"; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).f = [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).g = [NSNumber numberWithFloat:0]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).h = [NSNumber numberWithDouble:0]; + { + id actualValue = value; + XCTAssertEqual([actualValue unsignedIntValue], 0UL); + } - ((CHIPTestClusterClusterNestedStructList *) params.arg1).d = temp_1; - } - { - NSMutableArray * temp_1 = [[NSMutableArray alloc] init]; - temp_1[0] = [NSNumber numberWithUnsignedInt:1UL]; - temp_1[1] = [NSNumber numberWithUnsignedInt:2UL]; - temp_1[2] = [NSNumber numberWithUnsignedInt:3UL]; - ((CHIPTestClusterClusterNestedStructList *) params.arg1).e = temp_1; - } - { - NSMutableArray * temp_1 = [[NSMutableArray alloc] init]; - temp_1[0] = [[NSData alloc] initWithBytes:"octet_string_1" length:14]; - temp_1[1] = [[NSData alloc] initWithBytes:"octect_string_2" length:15]; - temp_1[2] = [[NSData alloc] initWithBytes:"octet_string_3" length:14]; - ((CHIPTestClusterClusterNestedStructList *) params.arg1).f = temp_1; - } - { - NSMutableArray * temp_1 = [[NSMutableArray alloc] init]; - temp_1[0] = [NSNumber numberWithUnsignedChar:0]; - temp_1[1] = [NSNumber numberWithUnsignedChar:255]; - ((CHIPTestClusterClusterNestedStructList *) params.arg1).g = temp_1; - } + [expectation fulfill]; + }]; - [cluster testNestedStructListArgumentRequestWithParams:params - completionHandler:^(CHIPTestClusterClusterBooleanResponseParams * _Nullable values, - NSError * _Nullable err) { - NSLog(@"Send Test Command With Nested Struct List Argument and all fields b of arg1.d " - @"are true Error: %@", - err); + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000135_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_S Max Value"]; - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); - { - id actualValue = values.value; - XCTAssertEqual([actualValue boolValue], true); - } + id epochSArgument; + epochSArgument = [NSNumber numberWithUnsignedInt:4294967295UL]; + [cluster writeAttributeEpochSWithValue:epochSArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute EPOCH_S Max Value Error: %@", err); - [expectation fulfill]; - }]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000135_TestNestedStructListArgumentRequest +- (void)testSendClusterTestCluster_000136_ReadAttribute { - XCTestExpectation * expectation = [self - expectationWithDescription:@"Send Test Command With Nested Struct List Argument and some fields b of arg1.d are false"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_S Max Value"]; 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 = [[CHIPTestClusterClusterTestNestedStructListArgumentRequestParams alloc] init]; - params.arg1 = [[CHIPTestClusterClusterNestedStructList alloc] init]; - ((CHIPTestClusterClusterNestedStructList *) params.arg1).a = [NSNumber numberWithUnsignedChar:0]; - ((CHIPTestClusterClusterNestedStructList *) params.arg1).b = [NSNumber numberWithBool:true]; - ((CHIPTestClusterClusterNestedStructList *) params.arg1).c = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).a = - [NSNumber numberWithUnsignedChar:0]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).b = - [NSNumber numberWithBool:true]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).c = - [NSNumber numberWithUnsignedChar:2]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).d = - [[NSData alloc] initWithBytes:"octet_string" length:12]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).e = @"char_string"; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).f = - [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).g = - [NSNumber numberWithFloat:0]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).h = - [NSNumber numberWithDouble:0]; + [cluster readAttributeEpochSWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute EPOCH_S Max Value Error: %@", err); - { - NSMutableArray * temp_1 = [[NSMutableArray alloc] init]; - temp_1[0] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).a = [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).b = [NSNumber numberWithBool:true]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).c = [NSNumber numberWithUnsignedChar:3]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).d = [[NSData alloc] initWithBytes:"nested_octet_string" length:19]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).e = @"nested_char_string"; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).f = [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).g = [NSNumber numberWithFloat:0]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).h = [NSNumber numberWithDouble:0]; - - temp_1[1] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).a = [NSNumber numberWithUnsignedChar:2]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).b = [NSNumber numberWithBool:false]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).c = [NSNumber numberWithUnsignedChar:3]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).d = [[NSData alloc] initWithBytes:"nested_octet_string" length:19]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).e = @"nested_char_string"; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).f = [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).g = [NSNumber numberWithFloat:0]; - ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).h = [NSNumber numberWithDouble:0]; - - ((CHIPTestClusterClusterNestedStructList *) params.arg1).d = temp_1; - } - { - NSMutableArray * temp_1 = [[NSMutableArray alloc] init]; - temp_1[0] = [NSNumber numberWithUnsignedInt:1UL]; - temp_1[1] = [NSNumber numberWithUnsignedInt:2UL]; - temp_1[2] = [NSNumber numberWithUnsignedInt:3UL]; - ((CHIPTestClusterClusterNestedStructList *) params.arg1).e = temp_1; - } - { - NSMutableArray * temp_1 = [[NSMutableArray alloc] init]; - temp_1[0] = [[NSData alloc] initWithBytes:"octet_string_1" length:14]; - temp_1[1] = [[NSData alloc] initWithBytes:"octect_string_2" length:15]; - temp_1[2] = [[NSData alloc] initWithBytes:"octet_string_3" length:14]; - ((CHIPTestClusterClusterNestedStructList *) params.arg1).f = temp_1; - } - { - NSMutableArray * temp_1 = [[NSMutableArray alloc] init]; - temp_1[0] = [NSNumber numberWithUnsignedChar:0]; - temp_1[1] = [NSNumber numberWithUnsignedChar:255]; - ((CHIPTestClusterClusterNestedStructList *) params.arg1).g = temp_1; - } - - [cluster testNestedStructListArgumentRequestWithParams:params - completionHandler:^(CHIPTestClusterClusterBooleanResponseParams * _Nullable values, - NSError * _Nullable err) { - NSLog(@"Send Test Command With Nested Struct List Argument and some fields b of " - @"arg1.d are false Error: %@", - err); - - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - { - id actualValue = values.value; - XCTAssertEqual([actualValue boolValue], false); - } + { + id actualValue = value; + XCTAssertEqual([actualValue unsignedIntValue], 4294967295UL); + } - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000136_SimpleStructEchoRequest +- (void)testSendClusterTestCluster_000137_WriteAttribute { - XCTestExpectation * expectation = - [self expectationWithDescription:@"Send Test Command With Struct Argument and see what we get back"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_S Min Value"]; 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 epochSArgument; + epochSArgument = [NSNumber numberWithUnsignedInt:0UL]; + [cluster writeAttributeEpochSWithValue:epochSArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute EPOCH_S Min Value Error: %@", err); - { - 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); - } + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000137_TestListInt8UArgumentRequest +- (void)testSendClusterTestCluster_000138_ReadAttribute { - XCTestExpectation * expectation = - [self expectationWithDescription:@"Send Test Command With List of INT8U and none of them is set to 0"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_S Min Value"]; 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 = [[CHIPTestClusterClusterTestListInt8UArgumentRequestParams alloc] init]; - { - NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; - temp_0[0] = [NSNumber numberWithUnsignedChar:1]; - temp_0[1] = [NSNumber numberWithUnsignedChar:2]; - temp_0[2] = [NSNumber numberWithUnsignedChar:3]; - temp_0[3] = [NSNumber numberWithUnsignedChar:4]; - temp_0[4] = [NSNumber numberWithUnsignedChar:5]; - temp_0[5] = [NSNumber numberWithUnsignedChar:6]; - temp_0[6] = [NSNumber numberWithUnsignedChar:7]; - temp_0[7] = [NSNumber numberWithUnsignedChar:8]; - temp_0[8] = [NSNumber numberWithUnsignedChar:9]; - params.arg1 = temp_0; - } - [cluster testListInt8UArgumentRequestWithParams:params - completionHandler:^( - CHIPTestClusterClusterBooleanResponseParams * _Nullable values, NSError * _Nullable err) { - NSLog(@"Send Test Command With List of INT8U and none of them is set to 0 Error: %@", err); + [cluster readAttributeEpochSWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute EPOCH_S Min Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - { - id actualValue = values.value; - XCTAssertEqual([actualValue boolValue], true); - } + { + id actualValue = value; + XCTAssertEqual([actualValue unsignedIntValue], 0UL); + } - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000138_TestListInt8UArgumentRequest +- (void)testSendClusterTestCluster_000139_ReadAttribute { - XCTestExpectation * expectation = - [self expectationWithDescription:@"Send Test Command With List of INT8U and one of them is set to 0"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute UNSUPPORTED"]; 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 = [[CHIPTestClusterClusterTestListInt8UArgumentRequestParams alloc] init]; - { - NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; - temp_0[0] = [NSNumber numberWithUnsignedChar:1]; - temp_0[1] = [NSNumber numberWithUnsignedChar:2]; - temp_0[2] = [NSNumber numberWithUnsignedChar:3]; - temp_0[3] = [NSNumber numberWithUnsignedChar:4]; - temp_0[4] = [NSNumber numberWithUnsignedChar:5]; - temp_0[5] = [NSNumber numberWithUnsignedChar:6]; - temp_0[6] = [NSNumber numberWithUnsignedChar:7]; - temp_0[7] = [NSNumber numberWithUnsignedChar:8]; - temp_0[8] = [NSNumber numberWithUnsignedChar:9]; - temp_0[9] = [NSNumber numberWithUnsignedChar:0]; - params.arg1 = temp_0; - } - [cluster testListInt8UArgumentRequestWithParams:params - completionHandler:^( - CHIPTestClusterClusterBooleanResponseParams * _Nullable values, NSError * _Nullable err) { - NSLog(@"Send Test Command With List of INT8U and one of them is set to 0 Error: %@", err); + [cluster readAttributeUnsupportedWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute UNSUPPORTED Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + if (err.code == CHIPErrorCodeUnsupportedAttribute) { + [expectation fulfill]; + return; + } - { - id actualValue = values.value; - XCTAssertEqual([actualValue boolValue], false); - } + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + { + id actualValue = value; + XCTAssertEqual([actualValue boolValue], 0); + } + + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000139_TestListInt8UReverseRequest +- (void)testSendClusterTestCluster_000140_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With List of INT8U and get it reversed"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Writeattribute UNSUPPORTED"]; 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 = [[CHIPTestClusterClusterTestListInt8UReverseRequestParams alloc] init]; - { - NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; - temp_0[0] = [NSNumber numberWithUnsignedChar:1]; - temp_0[1] = [NSNumber numberWithUnsignedChar:2]; - temp_0[2] = [NSNumber numberWithUnsignedChar:3]; - temp_0[3] = [NSNumber numberWithUnsignedChar:4]; - temp_0[4] = [NSNumber numberWithUnsignedChar:5]; - temp_0[5] = [NSNumber numberWithUnsignedChar:6]; - temp_0[6] = [NSNumber numberWithUnsignedChar:7]; - temp_0[7] = [NSNumber numberWithUnsignedChar:8]; - temp_0[8] = [NSNumber numberWithUnsignedChar:9]; - params.arg1 = temp_0; - } - [cluster testListInt8UReverseRequestWithParams:params - completionHandler:^(CHIPTestClusterClusterTestListInt8UReverseResponseParams * _Nullable values, - NSError * _Nullable err) { - NSLog(@"Send Test Command With List of INT8U and get it reversed Error: %@", err); + id unsupportedArgument; + unsupportedArgument = [NSNumber numberWithBool:0]; + [cluster writeAttributeUnsupportedWithValue:unsupportedArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Writeattribute UNSUPPORTED Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + if (err.code == CHIPErrorCodeUnsupportedAttribute) { + [expectation fulfill]; + return; + } - { - id actualValue = values.arg1; - XCTAssertEqual([actualValue count], 9); - XCTAssertEqual([actualValue[0] unsignedCharValue], 9); - XCTAssertEqual([actualValue[1] unsignedCharValue], 8); - XCTAssertEqual([actualValue[2] unsignedCharValue], 7); - XCTAssertEqual([actualValue[3] unsignedCharValue], 6); - XCTAssertEqual([actualValue[4] unsignedCharValue], 5); - XCTAssertEqual([actualValue[5] unsignedCharValue], 4); - XCTAssertEqual([actualValue[6] unsignedCharValue], 3); - XCTAssertEqual([actualValue[7] unsignedCharValue], 2); - XCTAssertEqual([actualValue[8] unsignedCharValue], 1); - } + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000140_TestListInt8UReverseRequest +- (void)testSendClusterTestCluster_000141_Test { - XCTestExpectation * expectation = - [self expectationWithDescription:@"Send Test Command With empty List of INT8U and get an empty list back"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command to unsupported endpoint"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); - CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:200 queue:queue]; XCTAssertNotNil(cluster); - __auto_type * params = [[CHIPTestClusterClusterTestListInt8UReverseRequestParams alloc] init]; - { - NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; - params.arg1 = temp_0; - } - [cluster testListInt8UReverseRequestWithParams:params - completionHandler:^(CHIPTestClusterClusterTestListInt8UReverseResponseParams * _Nullable values, - NSError * _Nullable err) { - NSLog(@"Send Test Command With empty List of INT8U and get an empty list back Error: %@", err); + [cluster testWithCompletionHandler:^(NSError * _Nullable err) { + NSLog(@"Send Test Command to unsupported endpoint Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertNotEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + [expectation fulfill]; + }]; - { - id actualValue = values.arg1; - XCTAssertEqual([actualValue count], 0); - } + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000142_Test +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command to unsupported cluster"]; - [expectation fulfill]; - }]; + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:0 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster testWithCompletionHandler:^(NSError * _Nullable err) { + NSLog(@"Send Test Command to unsupported cluster Error: %@", err); + + XCTAssertNotEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000141_TestListStructArgumentRequest +- (void)testSendClusterTestCluster_000143_ReadAttribute { - XCTestExpectation * expectation = - [self expectationWithDescription:@"Send Test Command With List of Struct Argument and arg1.b of first item is true"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute vendor_id Default Value"]; 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 = [[CHIPTestClusterClusterTestListStructArgumentRequestParams alloc] init]; - { - NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; - temp_0[0] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).a = [NSNumber numberWithUnsignedChar:0]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).b = [NSNumber numberWithBool:true]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).c = [NSNumber numberWithUnsignedChar:2]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).d = [[NSData alloc] initWithBytes:"first_octet_string" length:18]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).e = @"first_char_string"; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).f = [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).g = [NSNumber numberWithFloat:0]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).h = [NSNumber numberWithDouble:0]; - - temp_0[1] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).a = [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).b = [NSNumber numberWithBool:true]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).c = [NSNumber numberWithUnsignedChar:3]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).d = [[NSData alloc] initWithBytes:"second_octet_string" length:19]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).e = @"second_char_string"; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).f = [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).g = [NSNumber numberWithFloat:0]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).h = [NSNumber numberWithDouble:0]; - - params.arg1 = temp_0; - } - [cluster - testListStructArgumentRequestWithParams:params - completionHandler:^( - CHIPTestClusterClusterBooleanResponseParams * _Nullable values, NSError * _Nullable err) { - NSLog( - @"Send Test Command With List of Struct Argument and arg1.b of first item is true Error: %@", - err); + [cluster readAttributeVendorIdWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute vendor_id Default Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - { - id actualValue = values.value; - XCTAssertEqual([actualValue boolValue], true); - } + { + id actualValue = value; + XCTAssertEqual([actualValue unsignedShortValue], 0U); + } - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000142_TestListStructArgumentRequest +- (void)testSendClusterTestCluster_000144_WriteAttribute { - XCTestExpectation * expectation = - [self expectationWithDescription:@"Send Test Command With List of Struct Argument and arg1.b of first item is false"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute vendor_id"]; 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 = [[CHIPTestClusterClusterTestListStructArgumentRequestParams alloc] init]; - { - NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; - temp_0[0] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).a = [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).b = [NSNumber numberWithBool:true]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).c = [NSNumber numberWithUnsignedChar:3]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).d = [[NSData alloc] initWithBytes:"second_octet_string" length:19]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).e = @"second_char_string"; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).f = [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).g = [NSNumber numberWithFloat:0]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).h = [NSNumber numberWithDouble:0]; + id vendorIdArgument; + vendorIdArgument = [NSNumber numberWithUnsignedShort:17U]; + [cluster writeAttributeVendorIdWithValue:vendorIdArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute vendor_id Error: %@", err); - temp_0[1] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).a = [NSNumber numberWithUnsignedChar:0]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).b = [NSNumber numberWithBool:false]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).c = [NSNumber numberWithUnsignedChar:2]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).d = [[NSData alloc] initWithBytes:"first_octet_string" length:18]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).e = @"first_char_string"; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).f = [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).g = [NSNumber numberWithFloat:0]; - ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).h = [NSNumber numberWithDouble:0]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - params.arg1 = temp_0; - } - [cluster - testListStructArgumentRequestWithParams:params - completionHandler:^( - CHIPTestClusterClusterBooleanResponseParams * _Nullable values, NSError * _Nullable err) { - NSLog( - @"Send Test Command With List of Struct Argument and arg1.b of first item is false Error: %@", - err); + [expectation fulfill]; + }]; - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000145_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute vendor_id"]; - { - id actualValue = values.value; - XCTAssertEqual([actualValue boolValue], false); - } + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); - [expectation fulfill]; - }]; + [cluster readAttributeVendorIdWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute vendor_id Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertEqual([actualValue unsignedShortValue], 17U); + } + + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000143_TestListNestedStructListArgumentRequest +- (void)testSendClusterTestCluster_000146_WriteAttribute { - XCTestExpectation * expectation = - [self expectationWithDescription: - @"Send Test Command With List of Nested Struct List Argument and all fields b of elements of arg1.d are true"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Restore attribute vendor_id"]; 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 = [[CHIPTestClusterClusterTestListNestedStructListArgumentRequestParams alloc] init]; - { - NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; - temp_0[0] = [[CHIPTestClusterClusterNestedStructList alloc] init]; - ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).a = [NSNumber numberWithUnsignedChar:0]; - ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).b = [NSNumber numberWithBool:true]; - ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).a = - [NSNumber numberWithUnsignedChar:0]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).b = - [NSNumber numberWithBool:true]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).c = - [NSNumber numberWithUnsignedChar:2]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).d = - [[NSData alloc] initWithBytes:"octet_string" length:12]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).e = @"char_string"; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).f = - [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).g = - [NSNumber numberWithFloat:0]; - ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).h = - [NSNumber numberWithDouble:0]; + id vendorIdArgument; + vendorIdArgument = [NSNumber numberWithUnsignedShort:0U]; + [cluster writeAttributeVendorIdWithValue:vendorIdArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Restore attribute vendor_id Error: %@", err); - { - NSMutableArray * temp_2 = [[NSMutableArray alloc] init]; - temp_2[0] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).a = [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).b = [NSNumber numberWithBool:true]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).c = [NSNumber numberWithUnsignedChar:3]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).d = [[NSData alloc] initWithBytes:"nested_octet_string" length:19]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).e = @"nested_char_string"; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).f = [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).g = [NSNumber numberWithFloat:0]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).h = [NSNumber numberWithDouble:0]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - temp_2[1] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).a = [NSNumber numberWithUnsignedChar:2]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).b = [NSNumber numberWithBool:true]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).c = [NSNumber numberWithUnsignedChar:3]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).d = [[NSData alloc] initWithBytes:"nested_octet_string" length:19]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).e = @"nested_char_string"; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).f = [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).g = [NSNumber numberWithFloat:0]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).h = [NSNumber numberWithDouble:0]; + [expectation fulfill]; + }]; - ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).d = temp_2; - } - { - NSMutableArray * temp_2 = [[NSMutableArray alloc] init]; - temp_2[0] = [NSNumber numberWithUnsignedInt:1UL]; - temp_2[1] = [NSNumber numberWithUnsignedInt:2UL]; - temp_2[2] = [NSNumber numberWithUnsignedInt:3UL]; - ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).e = temp_2; - } - { - NSMutableArray * temp_2 = [[NSMutableArray alloc] init]; - temp_2[0] = [[NSData alloc] initWithBytes:"octet_string_1" length:14]; - temp_2[1] = [[NSData alloc] initWithBytes:"octect_string_2" length:15]; - temp_2[2] = [[NSData alloc] initWithBytes:"octet_string_3" length:14]; - ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).f = temp_2; - } - { - NSMutableArray * temp_2 = [[NSMutableArray alloc] init]; - temp_2[0] = [NSNumber numberWithUnsignedChar:0]; - temp_2[1] = [NSNumber numberWithUnsignedChar:255]; - ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).g = temp_2; - } + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000147_TestEnumsRequest +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Send a command with a vendor_id and enum"]; - params.arg1 = temp_0; - } - [cluster testListNestedStructListArgumentRequestWithParams:params - completionHandler:^(CHIPTestClusterClusterBooleanResponseParams * _Nullable values, - NSError * _Nullable err) { - NSLog(@"Send Test Command With List of Nested Struct List Argument and all fields " - @"b of elements of arg1.d are true Error: %@", - err); + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + __auto_type * params = [[CHIPTestClusterClusterTestEnumsRequestParams alloc] init]; + params.arg1 = [NSNumber numberWithUnsignedShort:20003U]; + params.arg2 = [NSNumber numberWithUnsignedChar:101]; + [cluster + testEnumsRequestWithParams:params + completionHandler:^(CHIPTestClusterClusterTestEnumsResponseParams * _Nullable values, NSError * _Nullable err) { + NSLog(@"Send a command with a vendor_id and enum Error: %@", err); - { - id actualValue = values.value; - XCTAssertEqual([actualValue boolValue], true); - } + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + { + id actualValue = values.arg1; + XCTAssertEqual([actualValue unsignedShortValue], 20003U); + } + { + id actualValue = values.arg2; + XCTAssertEqual([actualValue unsignedCharValue], 101); + } + + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000144_TestListNestedStructListArgumentRequest +- (void)testSendClusterTestCluster_000148_TestStructArgumentRequest { XCTestExpectation * expectation = - [self expectationWithDescription: - @"Send Test Command With Nested Struct List Argument and some fields b of elements of arg1.d are false"]; + [self expectationWithDescription:@"Send Test Command With Struct Argument and arg1.b is true"]; 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 = [[CHIPTestClusterClusterTestListNestedStructListArgumentRequestParams alloc] init]; - { - NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; + __auto_type * params = [[CHIPTestClusterClusterTestStructArgumentRequestParams alloc] init]; + params.arg1 = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) params.arg1).a = [NSNumber numberWithUnsignedChar:0]; + ((CHIPTestClusterClusterSimpleStruct *) params.arg1).b = [NSNumber numberWithBool:true]; + ((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.0f]; + ((CHIPTestClusterClusterSimpleStruct *) params.arg1).h = [NSNumber numberWithDouble:0]; + + [cluster testStructArgumentRequestWithParams:params + completionHandler:^( + CHIPTestClusterClusterBooleanResponseParams * _Nullable values, NSError * _Nullable err) { + NSLog(@"Send Test Command With Struct Argument and arg1.b is true Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = values.value; + XCTAssertEqual([actualValue boolValue], true); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000149_TestStructArgumentRequest +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"Send Test Command With Struct Argument and arg1.b is false"]; + + 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 = [[CHIPTestClusterClusterTestStructArgumentRequestParams alloc] init]; + params.arg1 = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) params.arg1).a = [NSNumber numberWithUnsignedChar:0]; + ((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.0f]; + ((CHIPTestClusterClusterSimpleStruct *) params.arg1).h = [NSNumber numberWithDouble:0]; + + [cluster testStructArgumentRequestWithParams:params + completionHandler:^( + CHIPTestClusterClusterBooleanResponseParams * _Nullable values, NSError * _Nullable err) { + NSLog(@"Send Test Command With Struct Argument and arg1.b is false Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = values.value; + XCTAssertEqual([actualValue boolValue], false); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000150_TestNestedStructArgumentRequest +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"Send Test Command With Nested Struct Argument and arg1.c.b is true"]; + + 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 = [[CHIPTestClusterClusterTestNestedStructArgumentRequestParams alloc] init]; + params.arg1 = [[CHIPTestClusterClusterNestedStruct alloc] init]; + ((CHIPTestClusterClusterNestedStruct *) params.arg1).a = [NSNumber numberWithUnsignedChar:0]; + ((CHIPTestClusterClusterNestedStruct *) params.arg1).b = [NSNumber numberWithBool:true]; + ((CHIPTestClusterClusterNestedStruct *) params.arg1).c = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).a = + [NSNumber numberWithUnsignedChar:0]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).b = + [NSNumber numberWithBool:true]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).c = + [NSNumber numberWithUnsignedChar:2]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).d = + [[NSData alloc] initWithBytes:"octet_string" length:12]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).e = @"char_string"; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).f = + [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).g = + [NSNumber numberWithFloat:0.0f]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).h = + [NSNumber numberWithDouble:0]; + + [cluster + testNestedStructArgumentRequestWithParams:params + completionHandler:^( + CHIPTestClusterClusterBooleanResponseParams * _Nullable values, NSError * _Nullable err) { + NSLog(@"Send Test Command With Nested Struct Argument and arg1.c.b is true Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = values.value; + XCTAssertEqual([actualValue boolValue], true); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000151_TestNestedStructArgumentRequest +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"Send Test Command With Nested Struct Argument arg1.c.b is false"]; + + 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 = [[CHIPTestClusterClusterTestNestedStructArgumentRequestParams alloc] init]; + params.arg1 = [[CHIPTestClusterClusterNestedStruct alloc] init]; + ((CHIPTestClusterClusterNestedStruct *) params.arg1).a = [NSNumber numberWithUnsignedChar:0]; + ((CHIPTestClusterClusterNestedStruct *) params.arg1).b = [NSNumber numberWithBool:true]; + ((CHIPTestClusterClusterNestedStruct *) params.arg1).c = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).a = + [NSNumber numberWithUnsignedChar:0]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).b = + [NSNumber numberWithBool:false]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).c = + [NSNumber numberWithUnsignedChar:2]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).d = + [[NSData alloc] initWithBytes:"octet_string" length:12]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).e = @"char_string"; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).f = + [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).g = + [NSNumber numberWithFloat:0.0f]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStruct *) params.arg1).c).h = + [NSNumber numberWithDouble:0]; + + [cluster testNestedStructArgumentRequestWithParams:params + completionHandler:^( + CHIPTestClusterClusterBooleanResponseParams * _Nullable values, NSError * _Nullable err) { + NSLog(@"Send Test Command With Nested Struct Argument arg1.c.b is false Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = values.value; + XCTAssertEqual([actualValue boolValue], false); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000152_TestNestedStructListArgumentRequest +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"Send Test Command With Nested Struct List Argument and all fields b of arg1.d are true"]; + + 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 = [[CHIPTestClusterClusterTestNestedStructListArgumentRequestParams alloc] init]; + params.arg1 = [[CHIPTestClusterClusterNestedStructList alloc] init]; + ((CHIPTestClusterClusterNestedStructList *) params.arg1).a = [NSNumber numberWithUnsignedChar:0]; + ((CHIPTestClusterClusterNestedStructList *) params.arg1).b = [NSNumber numberWithBool:true]; + ((CHIPTestClusterClusterNestedStructList *) params.arg1).c = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).a = + [NSNumber numberWithUnsignedChar:0]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).b = + [NSNumber numberWithBool:true]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).c = + [NSNumber numberWithUnsignedChar:2]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).d = + [[NSData alloc] initWithBytes:"octet_string" length:12]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).e = @"char_string"; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).f = + [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).g = + [NSNumber numberWithFloat:0.0f]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).h = + [NSNumber numberWithDouble:0]; + + { + NSMutableArray * temp_1 = [[NSMutableArray alloc] init]; + temp_1[0] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).a = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).b = [NSNumber numberWithBool:true]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).c = [NSNumber numberWithUnsignedChar:3]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).d = [[NSData alloc] initWithBytes:"nested_octet_string" length:19]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).e = @"nested_char_string"; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).g = [NSNumber numberWithFloat:0.0f]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).h = [NSNumber numberWithDouble:0]; + + temp_1[1] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).a = [NSNumber numberWithUnsignedChar:2]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).b = [NSNumber numberWithBool:true]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).c = [NSNumber numberWithUnsignedChar:3]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).d = [[NSData alloc] initWithBytes:"nested_octet_string" length:19]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).e = @"nested_char_string"; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).g = [NSNumber numberWithFloat:0.0f]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).h = [NSNumber numberWithDouble:0]; + + ((CHIPTestClusterClusterNestedStructList *) params.arg1).d = temp_1; + } + { + NSMutableArray * temp_1 = [[NSMutableArray alloc] init]; + temp_1[0] = [NSNumber numberWithUnsignedInt:1UL]; + temp_1[1] = [NSNumber numberWithUnsignedInt:2UL]; + temp_1[2] = [NSNumber numberWithUnsignedInt:3UL]; + ((CHIPTestClusterClusterNestedStructList *) params.arg1).e = temp_1; + } + { + NSMutableArray * temp_1 = [[NSMutableArray alloc] init]; + temp_1[0] = [[NSData alloc] initWithBytes:"octet_string_1" length:14]; + temp_1[1] = [[NSData alloc] initWithBytes:"octect_string_2" length:15]; + temp_1[2] = [[NSData alloc] initWithBytes:"octet_string_3" length:14]; + ((CHIPTestClusterClusterNestedStructList *) params.arg1).f = temp_1; + } + { + NSMutableArray * temp_1 = [[NSMutableArray alloc] init]; + temp_1[0] = [NSNumber numberWithUnsignedChar:0]; + temp_1[1] = [NSNumber numberWithUnsignedChar:255]; + ((CHIPTestClusterClusterNestedStructList *) params.arg1).g = temp_1; + } + + [cluster testNestedStructListArgumentRequestWithParams:params + completionHandler:^(CHIPTestClusterClusterBooleanResponseParams * _Nullable values, + NSError * _Nullable err) { + NSLog(@"Send Test Command With Nested Struct List Argument and all fields b of arg1.d " + @"are true Error: %@", + err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = values.value; + XCTAssertEqual([actualValue boolValue], true); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000153_TestNestedStructListArgumentRequest +{ + XCTestExpectation * expectation = [self + expectationWithDescription:@"Send Test Command With Nested Struct List Argument and some fields b of arg1.d are false"]; + + 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 = [[CHIPTestClusterClusterTestNestedStructListArgumentRequestParams alloc] init]; + params.arg1 = [[CHIPTestClusterClusterNestedStructList alloc] init]; + ((CHIPTestClusterClusterNestedStructList *) params.arg1).a = [NSNumber numberWithUnsignedChar:0]; + ((CHIPTestClusterClusterNestedStructList *) params.arg1).b = [NSNumber numberWithBool:true]; + ((CHIPTestClusterClusterNestedStructList *) params.arg1).c = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).a = + [NSNumber numberWithUnsignedChar:0]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).b = + [NSNumber numberWithBool:true]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).c = + [NSNumber numberWithUnsignedChar:2]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).d = + [[NSData alloc] initWithBytes:"octet_string" length:12]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).e = @"char_string"; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).f = + [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).g = + [NSNumber numberWithFloat:0.0f]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) params.arg1).c).h = + [NSNumber numberWithDouble:0]; + + { + NSMutableArray * temp_1 = [[NSMutableArray alloc] init]; + temp_1[0] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).a = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).b = [NSNumber numberWithBool:true]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).c = [NSNumber numberWithUnsignedChar:3]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).d = [[NSData alloc] initWithBytes:"nested_octet_string" length:19]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).e = @"nested_char_string"; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).g = [NSNumber numberWithFloat:0.0f]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[0]).h = [NSNumber numberWithDouble:0]; + + temp_1[1] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).a = [NSNumber numberWithUnsignedChar:2]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).b = [NSNumber numberWithBool:false]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).c = [NSNumber numberWithUnsignedChar:3]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).d = [[NSData alloc] initWithBytes:"nested_octet_string" length:19]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).e = @"nested_char_string"; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).g = [NSNumber numberWithFloat:0.0f]; + ((CHIPTestClusterClusterSimpleStruct *) temp_1[1]).h = [NSNumber numberWithDouble:0]; + + ((CHIPTestClusterClusterNestedStructList *) params.arg1).d = temp_1; + } + { + NSMutableArray * temp_1 = [[NSMutableArray alloc] init]; + temp_1[0] = [NSNumber numberWithUnsignedInt:1UL]; + temp_1[1] = [NSNumber numberWithUnsignedInt:2UL]; + temp_1[2] = [NSNumber numberWithUnsignedInt:3UL]; + ((CHIPTestClusterClusterNestedStructList *) params.arg1).e = temp_1; + } + { + NSMutableArray * temp_1 = [[NSMutableArray alloc] init]; + temp_1[0] = [[NSData alloc] initWithBytes:"octet_string_1" length:14]; + temp_1[1] = [[NSData alloc] initWithBytes:"octect_string_2" length:15]; + temp_1[2] = [[NSData alloc] initWithBytes:"octet_string_3" length:14]; + ((CHIPTestClusterClusterNestedStructList *) params.arg1).f = temp_1; + } + { + NSMutableArray * temp_1 = [[NSMutableArray alloc] init]; + temp_1[0] = [NSNumber numberWithUnsignedChar:0]; + temp_1[1] = [NSNumber numberWithUnsignedChar:255]; + ((CHIPTestClusterClusterNestedStructList *) params.arg1).g = temp_1; + } + + [cluster testNestedStructListArgumentRequestWithParams:params + completionHandler:^(CHIPTestClusterClusterBooleanResponseParams * _Nullable values, + NSError * _Nullable err) { + NSLog(@"Send Test Command With Nested Struct List Argument and some fields b of " + @"arg1.d are false Error: %@", + err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = values.value; + XCTAssertEqual([actualValue boolValue], false); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000154_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_000155_TestListInt8UArgumentRequest +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"Send Test Command With List of INT8U and none of them is set to 0"]; + + 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 = [[CHIPTestClusterClusterTestListInt8UArgumentRequestParams alloc] init]; + { + NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; + temp_0[0] = [NSNumber numberWithUnsignedChar:1]; + temp_0[1] = [NSNumber numberWithUnsignedChar:2]; + temp_0[2] = [NSNumber numberWithUnsignedChar:3]; + temp_0[3] = [NSNumber numberWithUnsignedChar:4]; + temp_0[4] = [NSNumber numberWithUnsignedChar:5]; + temp_0[5] = [NSNumber numberWithUnsignedChar:6]; + temp_0[6] = [NSNumber numberWithUnsignedChar:7]; + temp_0[7] = [NSNumber numberWithUnsignedChar:8]; + temp_0[8] = [NSNumber numberWithUnsignedChar:9]; + params.arg1 = temp_0; + } + [cluster testListInt8UArgumentRequestWithParams:params + completionHandler:^( + CHIPTestClusterClusterBooleanResponseParams * _Nullable values, NSError * _Nullable err) { + NSLog(@"Send Test Command With List of INT8U and none of them is set to 0 Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = values.value; + XCTAssertEqual([actualValue boolValue], true); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000156_TestListInt8UArgumentRequest +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"Send Test Command With List of INT8U and one of them is set to 0"]; + + 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 = [[CHIPTestClusterClusterTestListInt8UArgumentRequestParams alloc] init]; + { + NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; + temp_0[0] = [NSNumber numberWithUnsignedChar:1]; + temp_0[1] = [NSNumber numberWithUnsignedChar:2]; + temp_0[2] = [NSNumber numberWithUnsignedChar:3]; + temp_0[3] = [NSNumber numberWithUnsignedChar:4]; + temp_0[4] = [NSNumber numberWithUnsignedChar:5]; + temp_0[5] = [NSNumber numberWithUnsignedChar:6]; + temp_0[6] = [NSNumber numberWithUnsignedChar:7]; + temp_0[7] = [NSNumber numberWithUnsignedChar:8]; + temp_0[8] = [NSNumber numberWithUnsignedChar:9]; + temp_0[9] = [NSNumber numberWithUnsignedChar:0]; + params.arg1 = temp_0; + } + [cluster testListInt8UArgumentRequestWithParams:params + completionHandler:^( + CHIPTestClusterClusterBooleanResponseParams * _Nullable values, NSError * _Nullable err) { + NSLog(@"Send Test Command With List of INT8U and one of them is set to 0 Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = values.value; + XCTAssertEqual([actualValue boolValue], false); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000157_TestListInt8UReverseRequest +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With List of INT8U and get it reversed"]; + + 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 = [[CHIPTestClusterClusterTestListInt8UReverseRequestParams alloc] init]; + { + NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; + temp_0[0] = [NSNumber numberWithUnsignedChar:1]; + temp_0[1] = [NSNumber numberWithUnsignedChar:2]; + temp_0[2] = [NSNumber numberWithUnsignedChar:3]; + temp_0[3] = [NSNumber numberWithUnsignedChar:4]; + temp_0[4] = [NSNumber numberWithUnsignedChar:5]; + temp_0[5] = [NSNumber numberWithUnsignedChar:6]; + temp_0[6] = [NSNumber numberWithUnsignedChar:7]; + temp_0[7] = [NSNumber numberWithUnsignedChar:8]; + temp_0[8] = [NSNumber numberWithUnsignedChar:9]; + params.arg1 = temp_0; + } + [cluster testListInt8UReverseRequestWithParams:params + completionHandler:^(CHIPTestClusterClusterTestListInt8UReverseResponseParams * _Nullable values, + NSError * _Nullable err) { + NSLog(@"Send Test Command With List of INT8U and get it reversed Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = values.arg1; + XCTAssertEqual([actualValue count], 9); + XCTAssertEqual([actualValue[0] unsignedCharValue], 9); + XCTAssertEqual([actualValue[1] unsignedCharValue], 8); + XCTAssertEqual([actualValue[2] unsignedCharValue], 7); + XCTAssertEqual([actualValue[3] unsignedCharValue], 6); + XCTAssertEqual([actualValue[4] unsignedCharValue], 5); + XCTAssertEqual([actualValue[5] unsignedCharValue], 4); + XCTAssertEqual([actualValue[6] unsignedCharValue], 3); + XCTAssertEqual([actualValue[7] unsignedCharValue], 2); + XCTAssertEqual([actualValue[8] unsignedCharValue], 1); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000158_TestListInt8UReverseRequest +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"Send Test Command With empty List of INT8U and get an empty list 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 = [[CHIPTestClusterClusterTestListInt8UReverseRequestParams alloc] init]; + { + NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; + params.arg1 = temp_0; + } + [cluster testListInt8UReverseRequestWithParams:params + completionHandler:^(CHIPTestClusterClusterTestListInt8UReverseResponseParams * _Nullable values, + NSError * _Nullable err) { + NSLog(@"Send Test Command With empty List of INT8U and get an empty list back Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = values.arg1; + XCTAssertEqual([actualValue count], 0); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000159_TestListStructArgumentRequest +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"Send Test Command With List of Struct Argument and arg1.b of first item is true"]; + + 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 = [[CHIPTestClusterClusterTestListStructArgumentRequestParams alloc] init]; + { + NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; + temp_0[0] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).a = [NSNumber numberWithUnsignedChar:0]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).b = [NSNumber numberWithBool:true]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).c = [NSNumber numberWithUnsignedChar:2]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).d = [[NSData alloc] initWithBytes:"first_octet_string" length:18]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).e = @"first_char_string"; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).g = [NSNumber numberWithFloat:0.0f]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).h = [NSNumber numberWithDouble:0]; + + temp_0[1] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).a = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).b = [NSNumber numberWithBool:true]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).c = [NSNumber numberWithUnsignedChar:3]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).d = [[NSData alloc] initWithBytes:"second_octet_string" length:19]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).e = @"second_char_string"; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).g = [NSNumber numberWithFloat:0.0f]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).h = [NSNumber numberWithDouble:0]; + + params.arg1 = temp_0; + } + [cluster + testListStructArgumentRequestWithParams:params + completionHandler:^( + CHIPTestClusterClusterBooleanResponseParams * _Nullable values, NSError * _Nullable err) { + NSLog( + @"Send Test Command With List of Struct Argument and arg1.b of first item is true Error: %@", + err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = values.value; + XCTAssertEqual([actualValue boolValue], true); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000160_TestListStructArgumentRequest +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"Send Test Command With List of Struct Argument and arg1.b of first item is false"]; + + 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 = [[CHIPTestClusterClusterTestListStructArgumentRequestParams alloc] init]; + { + NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; + temp_0[0] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).a = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).b = [NSNumber numberWithBool:true]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).c = [NSNumber numberWithUnsignedChar:3]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).d = [[NSData alloc] initWithBytes:"second_octet_string" length:19]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).e = @"second_char_string"; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).g = [NSNumber numberWithFloat:0.0f]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[0]).h = [NSNumber numberWithDouble:0]; + + temp_0[1] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).a = [NSNumber numberWithUnsignedChar:0]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).b = [NSNumber numberWithBool:false]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).c = [NSNumber numberWithUnsignedChar:2]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).d = [[NSData alloc] initWithBytes:"first_octet_string" length:18]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).e = @"first_char_string"; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).g = [NSNumber numberWithFloat:0.0f]; + ((CHIPTestClusterClusterSimpleStruct *) temp_0[1]).h = [NSNumber numberWithDouble:0]; + + params.arg1 = temp_0; + } + [cluster + testListStructArgumentRequestWithParams:params + completionHandler:^( + CHIPTestClusterClusterBooleanResponseParams * _Nullable values, NSError * _Nullable err) { + NSLog( + @"Send Test Command With List of Struct Argument and arg1.b of first item is false Error: %@", + err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = values.value; + XCTAssertEqual([actualValue boolValue], false); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000161_TestListNestedStructListArgumentRequest +{ + XCTestExpectation * expectation = + [self expectationWithDescription: + @"Send Test Command With List of Nested Struct List Argument and all fields b of elements of arg1.d are true"]; + + 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 = [[CHIPTestClusterClusterTestListNestedStructListArgumentRequestParams alloc] init]; + { + NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; + temp_0[0] = [[CHIPTestClusterClusterNestedStructList alloc] init]; + ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).a = [NSNumber numberWithUnsignedChar:0]; + ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).b = [NSNumber numberWithBool:true]; + ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).a = + [NSNumber numberWithUnsignedChar:0]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).b = + [NSNumber numberWithBool:true]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).c = + [NSNumber numberWithUnsignedChar:2]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).d = + [[NSData alloc] initWithBytes:"octet_string" length:12]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).e = @"char_string"; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).f = + [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).g = + [NSNumber numberWithFloat:0.0f]; + ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).h = + [NSNumber numberWithDouble:0]; + + { + NSMutableArray * temp_2 = [[NSMutableArray alloc] init]; + temp_2[0] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).a = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).b = [NSNumber numberWithBool:true]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).c = [NSNumber numberWithUnsignedChar:3]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).d = [[NSData alloc] initWithBytes:"nested_octet_string" length:19]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).e = @"nested_char_string"; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).g = [NSNumber numberWithFloat:0.0f]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).h = [NSNumber numberWithDouble:0]; + + temp_2[1] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).a = [NSNumber numberWithUnsignedChar:2]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).b = [NSNumber numberWithBool:true]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).c = [NSNumber numberWithUnsignedChar:3]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).d = [[NSData alloc] initWithBytes:"nested_octet_string" length:19]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).e = @"nested_char_string"; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).g = [NSNumber numberWithFloat:0.0f]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).h = [NSNumber numberWithDouble:0]; + + ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).d = temp_2; + } + { + NSMutableArray * temp_2 = [[NSMutableArray alloc] init]; + temp_2[0] = [NSNumber numberWithUnsignedInt:1UL]; + temp_2[1] = [NSNumber numberWithUnsignedInt:2UL]; + temp_2[2] = [NSNumber numberWithUnsignedInt:3UL]; + ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).e = temp_2; + } + { + NSMutableArray * temp_2 = [[NSMutableArray alloc] init]; + temp_2[0] = [[NSData alloc] initWithBytes:"octet_string_1" length:14]; + temp_2[1] = [[NSData alloc] initWithBytes:"octect_string_2" length:15]; + temp_2[2] = [[NSData alloc] initWithBytes:"octet_string_3" length:14]; + ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).f = temp_2; + } + { + NSMutableArray * temp_2 = [[NSMutableArray alloc] init]; + temp_2[0] = [NSNumber numberWithUnsignedChar:0]; + temp_2[1] = [NSNumber numberWithUnsignedChar:255]; + ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).g = temp_2; + } + + params.arg1 = temp_0; + } + [cluster testListNestedStructListArgumentRequestWithParams:params + completionHandler:^(CHIPTestClusterClusterBooleanResponseParams * _Nullable values, + NSError * _Nullable err) { + NSLog(@"Send Test Command With List of Nested Struct List Argument and all fields " + @"b of elements of arg1.d are true Error: %@", + err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = values.value; + XCTAssertEqual([actualValue boolValue], true); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000162_TestListNestedStructListArgumentRequest +{ + XCTestExpectation * expectation = + [self expectationWithDescription: + @"Send Test Command With Nested Struct List Argument and some fields b of elements of arg1.d are false"]; + + 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 = [[CHIPTestClusterClusterTestListNestedStructListArgumentRequestParams alloc] init]; + { + NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; temp_0[0] = [[CHIPTestClusterClusterNestedStructList alloc] init]; ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).a = [NSNumber numberWithUnsignedChar:0]; ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).b = [NSNumber numberWithBool:true]; @@ -23117,127 +23535,615 @@ - (void)testSendClusterTestCluster_000144_TestListNestedStructListArgumentReques ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).f = [NSNumber numberWithUnsignedChar:1]; ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).g = - [NSNumber numberWithFloat:0]; + [NSNumber numberWithFloat:0.0f]; ((CHIPTestClusterClusterSimpleStruct *) ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).c).h = [NSNumber numberWithDouble:0]; - { - NSMutableArray * temp_2 = [[NSMutableArray alloc] init]; - temp_2[0] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).a = [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).b = [NSNumber numberWithBool:true]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).c = [NSNumber numberWithUnsignedChar:3]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).d = [[NSData alloc] initWithBytes:"nested_octet_string" length:19]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).e = @"nested_char_string"; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).f = [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).g = [NSNumber numberWithFloat:0]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).h = [NSNumber numberWithDouble:0]; + { + NSMutableArray * temp_2 = [[NSMutableArray alloc] init]; + temp_2[0] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).a = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).b = [NSNumber numberWithBool:true]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).c = [NSNumber numberWithUnsignedChar:3]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).d = [[NSData alloc] initWithBytes:"nested_octet_string" length:19]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).e = @"nested_char_string"; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).g = [NSNumber numberWithFloat:0.0f]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[0]).h = [NSNumber numberWithDouble:0]; + + temp_2[1] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).a = [NSNumber numberWithUnsignedChar:2]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).b = [NSNumber numberWithBool:false]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).c = [NSNumber numberWithUnsignedChar:3]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).d = [[NSData alloc] initWithBytes:"nested_octet_string" length:19]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).e = @"nested_char_string"; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).f = [NSNumber numberWithUnsignedChar:1]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).g = [NSNumber numberWithFloat:0.0f]; + ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).h = [NSNumber numberWithDouble:0]; + + ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).d = temp_2; + } + { + NSMutableArray * temp_2 = [[NSMutableArray alloc] init]; + temp_2[0] = [NSNumber numberWithUnsignedInt:1UL]; + temp_2[1] = [NSNumber numberWithUnsignedInt:2UL]; + temp_2[2] = [NSNumber numberWithUnsignedInt:3UL]; + ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).e = temp_2; + } + { + NSMutableArray * temp_2 = [[NSMutableArray alloc] init]; + temp_2[0] = [[NSData alloc] initWithBytes:"octet_string_1" length:14]; + temp_2[1] = [[NSData alloc] initWithBytes:"octect_string_2" length:15]; + temp_2[2] = [[NSData alloc] initWithBytes:"octet_string_3" length:14]; + ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).f = temp_2; + } + { + NSMutableArray * temp_2 = [[NSMutableArray alloc] init]; + temp_2[0] = [NSNumber numberWithUnsignedChar:0]; + temp_2[1] = [NSNumber numberWithUnsignedChar:255]; + ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).g = temp_2; + } + + params.arg1 = temp_0; + } + [cluster testListNestedStructListArgumentRequestWithParams:params + completionHandler:^(CHIPTestClusterClusterBooleanResponseParams * _Nullable values, + NSError * _Nullable err) { + NSLog(@"Send Test Command With Nested Struct List Argument and some fields b of " + @"elements of arg1.d are false Error: %@", + err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = values.value; + XCTAssertEqual([actualValue boolValue], false); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000163_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"Write attribute LIST With List of INT8U and none of them is set to 0"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id listInt8uArgument; + { + NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; + temp_0[0] = [NSNumber numberWithUnsignedChar:1]; + temp_0[1] = [NSNumber numberWithUnsignedChar:2]; + temp_0[2] = [NSNumber numberWithUnsignedChar:3]; + temp_0[3] = [NSNumber numberWithUnsignedChar:4]; + listInt8uArgument = temp_0; + } + [cluster writeAttributeListInt8uWithValue:listInt8uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute LIST With List of INT8U and none of them is set to 0 Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000164_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST With List of INT8U"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeListInt8uWithCompletionHandler:^(NSArray * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute LIST With List of INT8U Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertEqual([actualValue count], 4); + XCTAssertEqual([actualValue[0] unsignedCharValue], 1); + XCTAssertEqual([actualValue[1] unsignedCharValue], 2); + XCTAssertEqual([actualValue[2] unsignedCharValue], 3); + XCTAssertEqual([actualValue[3] unsignedCharValue], 4); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000165_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute LIST With List of OCTET_STRING"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id listOctetStringArgument; + { + NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; + temp_0[0] = [[NSData alloc] initWithBytes:"Test0" length:5]; + temp_0[1] = [[NSData alloc] initWithBytes:"Test1" length:5]; + temp_0[2] = [[NSData alloc] initWithBytes:"Test2" length:5]; + temp_0[3] = [[NSData alloc] initWithBytes:"Test3" length:5]; + listOctetStringArgument = temp_0; + } + [cluster writeAttributeListOctetStringWithValue:listOctetStringArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute LIST With List of OCTET_STRING Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000166_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST With List of OCTET_STRING"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeListOctetStringWithCompletionHandler:^(NSArray * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute LIST With List of OCTET_STRING Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertEqual([actualValue count], 4); + XCTAssertTrue([actualValue[0] isEqualToData:[[NSData alloc] initWithBytes:"Test0" length:5]]); + XCTAssertTrue([actualValue[1] isEqualToData:[[NSData alloc] initWithBytes:"Test1" length:5]]); + XCTAssertTrue([actualValue[2] isEqualToData:[[NSData alloc] initWithBytes:"Test2" length:5]]); + XCTAssertTrue([actualValue[3] isEqualToData:[[NSData alloc] initWithBytes:"Test3" length:5]]); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000167_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"Write attribute LIST With List of LIST_STRUCT_OCTET_STRING"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id listStructOctetStringArgument; + { + NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; + temp_0[0] = [[CHIPTestClusterClusterTestListStructOctet alloc] init]; + ((CHIPTestClusterClusterTestListStructOctet *) temp_0[0]).fabricIndex = [NSNumber numberWithUnsignedLongLong:0ULL]; + ((CHIPTestClusterClusterTestListStructOctet *) temp_0[0]).operationalCert = [[NSData alloc] initWithBytes:"Test0" length:5]; + + temp_0[1] = [[CHIPTestClusterClusterTestListStructOctet alloc] init]; + ((CHIPTestClusterClusterTestListStructOctet *) temp_0[1]).fabricIndex = [NSNumber numberWithUnsignedLongLong:1ULL]; + ((CHIPTestClusterClusterTestListStructOctet *) temp_0[1]).operationalCert = [[NSData alloc] initWithBytes:"Test1" length:5]; + + temp_0[2] = [[CHIPTestClusterClusterTestListStructOctet alloc] init]; + ((CHIPTestClusterClusterTestListStructOctet *) temp_0[2]).fabricIndex = [NSNumber numberWithUnsignedLongLong:2ULL]; + ((CHIPTestClusterClusterTestListStructOctet *) temp_0[2]).operationalCert = [[NSData alloc] initWithBytes:"Test2" length:5]; + + temp_0[3] = [[CHIPTestClusterClusterTestListStructOctet alloc] init]; + ((CHIPTestClusterClusterTestListStructOctet *) temp_0[3]).fabricIndex = [NSNumber numberWithUnsignedLongLong:3ULL]; + ((CHIPTestClusterClusterTestListStructOctet *) temp_0[3]).operationalCert = [[NSData alloc] initWithBytes:"Test3" length:5]; + + listStructOctetStringArgument = temp_0; + } + [cluster writeAttributeListStructOctetStringWithValue:listStructOctetStringArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute LIST With List of LIST_STRUCT_OCTET_STRING Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000168_ReadAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"Read attribute LIST With List of LIST_STRUCT_OCTET_STRING"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeListStructOctetStringWithCompletionHandler:^(NSArray * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute LIST With List of LIST_STRUCT_OCTET_STRING Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertEqual([actualValue count], 4); + 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]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000169_TestNullableOptionalRequest +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command with optional arg set."]; + + 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 = [[CHIPTestClusterClusterTestNullableOptionalRequestParams alloc] init]; + params.arg1 = [NSNumber numberWithUnsignedChar:5]; + [cluster testNullableOptionalRequestWithParams:params + completionHandler:^(CHIPTestClusterClusterTestNullableOptionalResponseParams * _Nullable values, + NSError * _Nullable err) { + NSLog(@"Send Test Command with optional arg set. Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = values.wasPresent; + XCTAssertEqual([actualValue boolValue], true); + } + { + id actualValue = values.wasNull; + XCTAssertEqual([actualValue boolValue], false); + } + { + id actualValue = values.value; + XCTAssertEqual([actualValue unsignedCharValue], 5); + } + { + id actualValue = values.originalValue; + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue unsignedCharValue], 5); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000170_TestNullableOptionalRequest +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command without its optional arg."]; + + 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 = [[CHIPTestClusterClusterTestNullableOptionalRequestParams alloc] init]; + [cluster testNullableOptionalRequestWithParams:params + completionHandler:^(CHIPTestClusterClusterTestNullableOptionalResponseParams * _Nullable values, + NSError * _Nullable err) { + NSLog(@"Send Test Command without its optional arg. Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = values.wasPresent; + XCTAssertEqual([actualValue boolValue], false); + } - temp_2[1] = [[CHIPTestClusterClusterSimpleStruct alloc] init]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).a = [NSNumber numberWithUnsignedChar:2]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).b = [NSNumber numberWithBool:false]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).c = [NSNumber numberWithUnsignedChar:3]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).d = [[NSData alloc] initWithBytes:"nested_octet_string" length:19]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).e = @"nested_char_string"; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).f = [NSNumber numberWithUnsignedChar:1]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).g = [NSNumber numberWithFloat:0]; - ((CHIPTestClusterClusterSimpleStruct *) temp_2[1]).h = [NSNumber numberWithDouble:0]; + [expectation fulfill]; + }]; - ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).d = temp_2; + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000171_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BOOLEAN null"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id nullableBooleanArgument; + nullableBooleanArgument = nil; + [cluster writeAttributeNullableBooleanWithValue:nullableBooleanArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_BOOLEAN null Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000172_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BOOLEAN null"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableBooleanWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_BOOLEAN null Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertTrue(actualValue == nil); } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000173_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BOOLEAN True"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id nullableBooleanArgument; + nullableBooleanArgument = [NSNumber numberWithBool:true]; + [cluster writeAttributeNullableBooleanWithValue:nullableBooleanArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_BOOLEAN True Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000174_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BOOLEAN True"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableBooleanWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_BOOLEAN True Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + { - NSMutableArray * temp_2 = [[NSMutableArray alloc] init]; - temp_2[0] = [NSNumber numberWithUnsignedInt:1UL]; - temp_2[1] = [NSNumber numberWithUnsignedInt:2UL]; - temp_2[2] = [NSNumber numberWithUnsignedInt:3UL]; - ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).e = temp_2; + id actualValue = value; + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue boolValue], true); } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000175_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP8 Max Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id nullableBitmap8Argument; + nullableBitmap8Argument = [NSNumber numberWithUnsignedChar:254]; + [cluster writeAttributeNullableBitmap8WithValue:nullableBitmap8Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_BITMAP8 Max Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000176_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP8 Max Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableBitmap8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_BITMAP8 Max Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + { - NSMutableArray * temp_2 = [[NSMutableArray alloc] init]; - temp_2[0] = [[NSData alloc] initWithBytes:"octet_string_1" length:14]; - temp_2[1] = [[NSData alloc] initWithBytes:"octect_string_2" length:15]; - temp_2[2] = [[NSData alloc] initWithBytes:"octet_string_3" length:14]; - ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).f = temp_2; + id actualValue = value; + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue unsignedCharValue], 254); } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000177_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP8 Invalid Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id nullableBitmap8Argument; + nullableBitmap8Argument = [NSNumber numberWithUnsignedChar:255]; + [cluster + writeAttributeNullableBitmap8WithValue:nullableBitmap8Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_BITMAP8 Invalid Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000178_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP8 unchanged Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableBitmap8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_BITMAP8 unchanged Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + { - NSMutableArray * temp_2 = [[NSMutableArray alloc] init]; - temp_2[0] = [NSNumber numberWithUnsignedChar:0]; - temp_2[1] = [NSNumber numberWithUnsignedChar:255]; - ((CHIPTestClusterClusterNestedStructList *) temp_0[0]).g = temp_2; + id actualValue = value; + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue unsignedCharValue], 254); } - params.arg1 = temp_0; - } - [cluster testListNestedStructListArgumentRequestWithParams:params - completionHandler:^(CHIPTestClusterClusterBooleanResponseParams * _Nullable values, - NSError * _Nullable err) { - NSLog(@"Send Test Command With Nested Struct List Argument and some fields b of " - @"elements of arg1.d are false Error: %@", - err); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000179_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP8 null Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id nullableBitmap8Argument; + nullableBitmap8Argument = nil; + [cluster writeAttributeNullableBitmap8WithValue:nullableBitmap8Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_BITMAP8 null Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000180_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP8 null Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + [cluster readAttributeNullableBitmap8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_BITMAP8 null Value Error: %@", err); - { - id actualValue = values.value; - XCTAssertEqual([actualValue boolValue], false); - } + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + { + id actualValue = value; + XCTAssertTrue(actualValue == nil); + } + + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000145_WriteAttribute +- (void)testSendClusterTestCluster_000181_WriteAttribute { - XCTestExpectation * expectation = - [self expectationWithDescription:@"Write attribute LIST With List of INT8U and none of them is set to 0"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP16 Max Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id listInt8uArgument; - { - NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; - temp_0[0] = [NSNumber numberWithUnsignedChar:1]; - temp_0[1] = [NSNumber numberWithUnsignedChar:2]; - temp_0[2] = [NSNumber numberWithUnsignedChar:3]; - temp_0[3] = [NSNumber numberWithUnsignedChar:4]; - listInt8uArgument = temp_0; - } - [cluster writeAttributeListInt8uWithValue:listInt8uArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute LIST With List of INT8U and none of them is set to 0 Error: %@", err); + id nullableBitmap16Argument; + nullableBitmap16Argument = [NSNumber numberWithUnsignedShort:65534U]; + [cluster writeAttributeNullableBitmap16WithValue:nullableBitmap16Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_BITMAP16 Max Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000146_ReadAttribute +- (void)testSendClusterTestCluster_000182_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST With List of INT8U"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP16 Max Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeListInt8uWithCompletionHandler:^(NSArray * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute LIST With List of INT8U Error: %@", err); + [cluster readAttributeNullableBitmap16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_BITMAP16 Max Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertEqual([actualValue count], 4); - XCTAssertEqual([actualValue[0] unsignedCharValue], 1); - XCTAssertEqual([actualValue[1] unsignedCharValue], 2); - XCTAssertEqual([actualValue[2] unsignedCharValue], 3); - XCTAssertEqual([actualValue[3] unsignedCharValue], 4); + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue unsignedShortValue], 65534U); } [expectation fulfill]; @@ -23245,56 +24151,46 @@ - (void)testSendClusterTestCluster_000146_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000147_WriteAttribute +- (void)testSendClusterTestCluster_000183_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute LIST With List of OCTET_STRING"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP16 Invalid Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id listOctetStringArgument; - { - NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; - temp_0[0] = [[NSData alloc] initWithBytes:"Test0" length:5]; - temp_0[1] = [[NSData alloc] initWithBytes:"Test1" length:5]; - temp_0[2] = [[NSData alloc] initWithBytes:"Test2" length:5]; - temp_0[3] = [[NSData alloc] initWithBytes:"Test3" length:5]; - listOctetStringArgument = temp_0; - } - [cluster writeAttributeListOctetStringWithValue:listOctetStringArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute LIST With List of OCTET_STRING Error: %@", err); - - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + id nullableBitmap16Argument; + nullableBitmap16Argument = [NSNumber numberWithUnsignedShort:65535U]; + [cluster + writeAttributeNullableBitmap16WithValue:nullableBitmap16Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_BITMAP16 Invalid Value Error: %@", err); - [expectation fulfill]; - }]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000148_ReadAttribute +- (void)testSendClusterTestCluster_000184_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST With List of OCTET_STRING"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP16 unchanged Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeListOctetStringWithCompletionHandler:^(NSArray * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute LIST With List of OCTET_STRING Error: %@", err); + [cluster readAttributeNullableBitmap16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_BITMAP16 unchanged Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertEqual([actualValue count], 4); - XCTAssertTrue([actualValue[0] isEqualToData:[[NSData alloc] initWithBytes:"Test0" length:5]]); - XCTAssertTrue([actualValue[1] isEqualToData:[[NSData alloc] initWithBytes:"Test1" length:5]]); - XCTAssertTrue([actualValue[2] isEqualToData:[[NSData alloc] initWithBytes:"Test2" length:5]]); - XCTAssertTrue([actualValue[3] isEqualToData:[[NSData alloc] initWithBytes:"Test3" length:5]]); + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue unsignedShortValue], 65534U); } [expectation fulfill]; @@ -23302,82 +24198,45 @@ - (void)testSendClusterTestCluster_000148_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000149_WriteAttribute +- (void)testSendClusterTestCluster_000185_WriteAttribute { - XCTestExpectation * expectation = - [self expectationWithDescription:@"Write attribute LIST With List of LIST_STRUCT_OCTET_STRING"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP16 null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id listStructOctetStringArgument; - { - NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; - temp_0[0] = [[CHIPTestClusterClusterTestListStructOctet alloc] init]; - ((CHIPTestClusterClusterTestListStructOctet *) temp_0[0]).fabricIndex = [NSNumber numberWithUnsignedLongLong:0ULL]; - ((CHIPTestClusterClusterTestListStructOctet *) temp_0[0]).operationalCert = [[NSData alloc] initWithBytes:"Test0" length:5]; - - temp_0[1] = [[CHIPTestClusterClusterTestListStructOctet alloc] init]; - ((CHIPTestClusterClusterTestListStructOctet *) temp_0[1]).fabricIndex = [NSNumber numberWithUnsignedLongLong:1ULL]; - ((CHIPTestClusterClusterTestListStructOctet *) temp_0[1]).operationalCert = [[NSData alloc] initWithBytes:"Test1" length:5]; - - temp_0[2] = [[CHIPTestClusterClusterTestListStructOctet alloc] init]; - ((CHIPTestClusterClusterTestListStructOctet *) temp_0[2]).fabricIndex = [NSNumber numberWithUnsignedLongLong:2ULL]; - ((CHIPTestClusterClusterTestListStructOctet *) temp_0[2]).operationalCert = [[NSData alloc] initWithBytes:"Test2" length:5]; - - temp_0[3] = [[CHIPTestClusterClusterTestListStructOctet alloc] init]; - ((CHIPTestClusterClusterTestListStructOctet *) temp_0[3]).fabricIndex = [NSNumber numberWithUnsignedLongLong:3ULL]; - ((CHIPTestClusterClusterTestListStructOctet *) temp_0[3]).operationalCert = [[NSData alloc] initWithBytes:"Test3" length:5]; - - listStructOctetStringArgument = temp_0; - } - [cluster writeAttributeListStructOctetStringWithValue:listStructOctetStringArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute LIST With List of LIST_STRUCT_OCTET_STRING Error: %@", err); + id nullableBitmap16Argument; + nullableBitmap16Argument = nil; + [cluster writeAttributeNullableBitmap16WithValue:nullableBitmap16Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_BITMAP16 null Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000150_ReadAttribute +- (void)testSendClusterTestCluster_000186_ReadAttribute { - XCTestExpectation * expectation = - [self expectationWithDescription:@"Read attribute LIST With List of LIST_STRUCT_OCTET_STRING"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP16 null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeListStructOctetStringWithCompletionHandler:^(NSArray * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute LIST With List of LIST_STRUCT_OCTET_STRING Error: %@", err); + [cluster readAttributeNullableBitmap16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_BITMAP16 null Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertEqual([actualValue count], 4); - 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]]); + XCTAssertTrue(actualValue == nil); } [expectation fulfill]; @@ -23385,113 +24244,93 @@ - (void)testSendClusterTestCluster_000150_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000151_TestNullableOptionalRequest +- (void)testSendClusterTestCluster_000187_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command with optional arg set."]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP32 Max Value"]; 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 = [[CHIPTestClusterClusterTestNullableOptionalRequestParams alloc] init]; - params.arg1 = [NSNumber numberWithUnsignedChar:5]; - [cluster testNullableOptionalRequestWithParams:params - completionHandler:^(CHIPTestClusterClusterTestNullableOptionalResponseParams * _Nullable values, - NSError * _Nullable err) { - NSLog(@"Send Test Command with optional arg set. Error: %@", err); - - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + id nullableBitmap32Argument; + nullableBitmap32Argument = [NSNumber numberWithUnsignedInt:4294967294UL]; + [cluster writeAttributeNullableBitmap32WithValue:nullableBitmap32Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_BITMAP32 Max Value Error: %@", err); - { - id actualValue = values.wasPresent; - XCTAssertEqual([actualValue boolValue], true); - } - { - id actualValue = values.wasNull; - XCTAssertEqual([actualValue boolValue], false); - } - { - id actualValue = values.value; - XCTAssertEqual([actualValue unsignedCharValue], 5); - } - { - id actualValue = values.originalValue; - XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedCharValue], 5); - } + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000152_TestNullableOptionalRequest +- (void)testSendClusterTestCluster_000188_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command without its optional arg."]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP32 Max Value"]; 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 = [[CHIPTestClusterClusterTestNullableOptionalRequestParams alloc] init]; - [cluster testNullableOptionalRequestWithParams:params - completionHandler:^(CHIPTestClusterClusterTestNullableOptionalResponseParams * _Nullable values, - NSError * _Nullable err) { - NSLog(@"Send Test Command without its optional arg. Error: %@", err); + [cluster readAttributeNullableBitmap32WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_BITMAP32 Max Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - { - id actualValue = values.wasPresent; - XCTAssertEqual([actualValue boolValue], false); - } + { + id actualValue = value; + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue unsignedIntValue], 4294967294UL); + } - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000153_WriteAttribute +- (void)testSendClusterTestCluster_000189_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BOOLEAN null"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP32 Invalid Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableBooleanArgument; - nullableBooleanArgument = nil; - [cluster writeAttributeNullableBooleanWithValue:nullableBooleanArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_BOOLEAN null Error: %@", err); - - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + id nullableBitmap32Argument; + nullableBitmap32Argument = [NSNumber numberWithUnsignedInt:4294967295UL]; + [cluster + writeAttributeNullableBitmap32WithValue:nullableBitmap32Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_BITMAP32 Invalid Value Error: %@", err); - [expectation fulfill]; - }]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000154_ReadAttribute +- (void)testSendClusterTestCluster_000190_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BOOLEAN null"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP32 unchanged Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableBooleanWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_BOOLEAN null Error: %@", err); + [cluster readAttributeNullableBitmap32WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_BITMAP32 unchanged Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertTrue(actualValue == nil); + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue unsignedIntValue], 4294967294UL); } [expectation fulfill]; @@ -23499,46 +24338,45 @@ - (void)testSendClusterTestCluster_000154_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000155_WriteAttribute +- (void)testSendClusterTestCluster_000191_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BOOLEAN True"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP32 null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableBooleanArgument; - nullableBooleanArgument = [NSNumber numberWithBool:true]; - [cluster writeAttributeNullableBooleanWithValue:nullableBooleanArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_BOOLEAN True Error: %@", err); + id nullableBitmap32Argument; + nullableBitmap32Argument = nil; + [cluster writeAttributeNullableBitmap32WithValue:nullableBitmap32Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_BITMAP32 null Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000156_ReadAttribute +- (void)testSendClusterTestCluster_000192_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BOOLEAN True"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP32 null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableBooleanWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_BOOLEAN True Error: %@", err); + [cluster readAttributeNullableBitmap32WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_BITMAP32 null Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue boolValue], true); + XCTAssertTrue(actualValue == nil); } [expectation fulfill]; @@ -23546,46 +24384,46 @@ - (void)testSendClusterTestCluster_000156_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000157_WriteAttribute +- (void)testSendClusterTestCluster_000193_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP8 Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP64 Max Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableBitmap8Argument; - nullableBitmap8Argument = [NSNumber numberWithUnsignedChar:254]; - [cluster writeAttributeNullableBitmap8WithValue:nullableBitmap8Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_BITMAP8 Max Value Error: %@", err); + id nullableBitmap64Argument; + nullableBitmap64Argument = [NSNumber numberWithUnsignedLongLong:18446744073709551614ULL]; + [cluster writeAttributeNullableBitmap64WithValue:nullableBitmap64Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_BITMAP64 Max Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000158_ReadAttribute +- (void)testSendClusterTestCluster_000194_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP8 Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP64 Max Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableBitmap8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_BITMAP8 Max Value Error: %@", err); + [cluster readAttributeNullableBitmap64WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_BITMAP64 Max Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedCharValue], 254); + XCTAssertEqual([actualValue unsignedLongLongValue], 18446744073709551614ULL); } [expectation fulfill]; @@ -23593,46 +24431,46 @@ - (void)testSendClusterTestCluster_000158_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000159_WriteAttribute +- (void)testSendClusterTestCluster_000195_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP8 Invalid Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP64 Invalid Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableBitmap8Argument; - nullableBitmap8Argument = [NSNumber numberWithUnsignedChar:255]; + id nullableBitmap64Argument; + nullableBitmap64Argument = [NSNumber numberWithUnsignedLongLong:18446744073709551615ULL]; [cluster - writeAttributeNullableBitmap8WithValue:nullableBitmap8Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_BITMAP8 Invalid Value Error: %@", err); + writeAttributeNullableBitmap64WithValue:nullableBitmap64Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_BITMAP64 Invalid Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); - [expectation fulfill]; - }]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000160_ReadAttribute +- (void)testSendClusterTestCluster_000196_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP8 unchanged Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP64 unchanged Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableBitmap8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_BITMAP8 unchanged Value Error: %@", err); + [cluster readAttributeNullableBitmap64WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_BITMAP64 unchanged Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedCharValue], 254); + XCTAssertEqual([actualValue unsignedLongLongValue], 18446744073709551614ULL); } [expectation fulfill]; @@ -23640,39 +24478,39 @@ - (void)testSendClusterTestCluster_000160_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000161_WriteAttribute +- (void)testSendClusterTestCluster_000197_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP8 null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP64 null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableBitmap8Argument; - nullableBitmap8Argument = nil; - [cluster writeAttributeNullableBitmap8WithValue:nullableBitmap8Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_BITMAP8 null Value Error: %@", err); + id nullableBitmap64Argument; + nullableBitmap64Argument = nil; + [cluster writeAttributeNullableBitmap64WithValue:nullableBitmap64Argument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_BITMAP64 null Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000162_ReadAttribute +- (void)testSendClusterTestCluster_000198_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP8 null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP64 null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableBitmap8WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_BITMAP8 null Value Error: %@", err); + [cluster readAttributeNullableBitmap64WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_BITMAP64 null Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -23686,46 +24524,46 @@ - (void)testSendClusterTestCluster_000162_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000163_WriteAttribute +- (void)testSendClusterTestCluster_000199_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP16 Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U Max Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableBitmap16Argument; - nullableBitmap16Argument = [NSNumber numberWithUnsignedShort:65534U]; - [cluster writeAttributeNullableBitmap16WithValue:nullableBitmap16Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_BITMAP16 Max Value Error: %@", err); + id nullableInt8uArgument; + nullableInt8uArgument = [NSNumber numberWithUnsignedChar:254]; + [cluster writeAttributeNullableInt8uWithValue:nullableInt8uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT8U Max Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000164_ReadAttribute +- (void)testSendClusterTestCluster_000200_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP16 Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U Max Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableBitmap16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_BITMAP16 Max Value Error: %@", err); + [cluster readAttributeNullableInt8uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT8U Max Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedShortValue], 65534U); + XCTAssertEqual([actualValue unsignedCharValue], 254); } [expectation fulfill]; @@ -23733,46 +24571,45 @@ - (void)testSendClusterTestCluster_000164_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000165_WriteAttribute +- (void)testSendClusterTestCluster_000201_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP16 Invalid Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U Invalid Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableBitmap16Argument; - nullableBitmap16Argument = [NSNumber numberWithUnsignedShort:65535U]; - [cluster - writeAttributeNullableBitmap16WithValue:nullableBitmap16Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_BITMAP16 Invalid Value Error: %@", err); + id nullableInt8uArgument; + nullableInt8uArgument = [NSNumber numberWithUnsignedChar:255]; + [cluster writeAttributeNullableInt8uWithValue:nullableInt8uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT8U Invalid Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); - [expectation fulfill]; - }]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000166_ReadAttribute +- (void)testSendClusterTestCluster_000202_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP16 unchanged Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U unchanged Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableBitmap16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_BITMAP16 unchanged Value Error: %@", err); + [cluster readAttributeNullableInt8uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT8U unchanged Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedShortValue], 65534U); + XCTAssertEqual([actualValue unsignedCharValue], 254); } [expectation fulfill]; @@ -23780,39 +24617,39 @@ - (void)testSendClusterTestCluster_000166_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000167_WriteAttribute +- (void)testSendClusterTestCluster_000203_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP16 null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableBitmap16Argument; - nullableBitmap16Argument = nil; - [cluster writeAttributeNullableBitmap16WithValue:nullableBitmap16Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_BITMAP16 null Value Error: %@", err); + id nullableInt8uArgument; + nullableInt8uArgument = nil; + [cluster writeAttributeNullableInt8uWithValue:nullableInt8uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT8U null Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000168_ReadAttribute +- (void)testSendClusterTestCluster_000204_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP16 null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableBitmap16WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_BITMAP16 null Value Error: %@", err); + [cluster readAttributeNullableInt8uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT8U null Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -23826,46 +24663,46 @@ - (void)testSendClusterTestCluster_000168_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000169_WriteAttribute +- (void)testSendClusterTestCluster_000205_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP32 Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U Max Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableBitmap32Argument; - nullableBitmap32Argument = [NSNumber numberWithUnsignedInt:4294967294UL]; - [cluster writeAttributeNullableBitmap32WithValue:nullableBitmap32Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_BITMAP32 Max Value Error: %@", err); + id nullableInt16uArgument; + nullableInt16uArgument = [NSNumber numberWithUnsignedShort:65534U]; + [cluster writeAttributeNullableInt16uWithValue:nullableInt16uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT16U Max Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000170_ReadAttribute +- (void)testSendClusterTestCluster_000206_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP32 Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U Max Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableBitmap32WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_BITMAP32 Max Value Error: %@", err); + [cluster readAttributeNullableInt16uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT16U Max Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedIntValue], 4294967294UL); + XCTAssertEqual([actualValue unsignedShortValue], 65534U); } [expectation fulfill]; @@ -23873,46 +24710,46 @@ - (void)testSendClusterTestCluster_000170_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000171_WriteAttribute +- (void)testSendClusterTestCluster_000207_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP32 Invalid Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U Invalid Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableBitmap32Argument; - nullableBitmap32Argument = [NSNumber numberWithUnsignedInt:4294967295UL]; + id nullableInt16uArgument; + nullableInt16uArgument = [NSNumber numberWithUnsignedShort:65535U]; [cluster - writeAttributeNullableBitmap32WithValue:nullableBitmap32Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_BITMAP32 Invalid Value Error: %@", err); + writeAttributeNullableInt16uWithValue:nullableInt16uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT16U Invalid Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); - [expectation fulfill]; - }]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000172_ReadAttribute +- (void)testSendClusterTestCluster_000208_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP32 unchanged Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U unchanged Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableBitmap32WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_BITMAP32 unchanged Value Error: %@", err); + [cluster readAttributeNullableInt16uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT16U unchanged Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedIntValue], 4294967294UL); + XCTAssertEqual([actualValue unsignedShortValue], 65534U); } [expectation fulfill]; @@ -23920,39 +24757,39 @@ - (void)testSendClusterTestCluster_000172_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000173_WriteAttribute +- (void)testSendClusterTestCluster_000209_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP32 null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableBitmap32Argument; - nullableBitmap32Argument = nil; - [cluster writeAttributeNullableBitmap32WithValue:nullableBitmap32Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_BITMAP32 null Value Error: %@", err); + id nullableInt16uArgument; + nullableInt16uArgument = nil; + [cluster writeAttributeNullableInt16uWithValue:nullableInt16uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT16U null Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000174_ReadAttribute +- (void)testSendClusterTestCluster_000210_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP32 null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableBitmap32WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_BITMAP32 null Value Error: %@", err); + [cluster readAttributeNullableInt16uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT16U null Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -23966,46 +24803,46 @@ - (void)testSendClusterTestCluster_000174_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000175_WriteAttribute +- (void)testSendClusterTestCluster_000211_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP64 Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U Max Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableBitmap64Argument; - nullableBitmap64Argument = [NSNumber numberWithUnsignedLongLong:18446744073709551614ULL]; - [cluster writeAttributeNullableBitmap64WithValue:nullableBitmap64Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_BITMAP64 Max Value Error: %@", err); + id nullableInt32uArgument; + nullableInt32uArgument = [NSNumber numberWithUnsignedInt:4294967294UL]; + [cluster writeAttributeNullableInt32uWithValue:nullableInt32uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT32U Max Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000176_ReadAttribute +- (void)testSendClusterTestCluster_000212_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP64 Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U Max Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableBitmap64WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_BITMAP64 Max Value Error: %@", err); + [cluster readAttributeNullableInt32uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT32U Max Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedLongLongValue], 18446744073709551614ULL); + XCTAssertEqual([actualValue unsignedIntValue], 4294967294UL); } [expectation fulfill]; @@ -24013,46 +24850,46 @@ - (void)testSendClusterTestCluster_000176_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000177_WriteAttribute +- (void)testSendClusterTestCluster_000213_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP64 Invalid Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U Invalid Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableBitmap64Argument; - nullableBitmap64Argument = [NSNumber numberWithUnsignedLongLong:18446744073709551615ULL]; + id nullableInt32uArgument; + nullableInt32uArgument = [NSNumber numberWithUnsignedInt:4294967295UL]; [cluster - writeAttributeNullableBitmap64WithValue:nullableBitmap64Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_BITMAP64 Invalid Value Error: %@", err); + writeAttributeNullableInt32uWithValue:nullableInt32uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT32U Invalid Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); - [expectation fulfill]; - }]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000178_ReadAttribute +- (void)testSendClusterTestCluster_000214_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP64 unchanged Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U unchanged Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableBitmap64WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_BITMAP64 unchanged Value Error: %@", err); + [cluster readAttributeNullableInt32uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT32U unchanged Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedLongLongValue], 18446744073709551614ULL); + XCTAssertEqual([actualValue unsignedIntValue], 4294967294UL); } [expectation fulfill]; @@ -24060,39 +24897,39 @@ - (void)testSendClusterTestCluster_000178_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000179_WriteAttribute +- (void)testSendClusterTestCluster_000215_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP64 null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableBitmap64Argument; - nullableBitmap64Argument = nil; - [cluster writeAttributeNullableBitmap64WithValue:nullableBitmap64Argument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_BITMAP64 null Value Error: %@", err); + id nullableInt32uArgument; + nullableInt32uArgument = nil; + [cluster writeAttributeNullableInt32uWithValue:nullableInt32uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT32U null Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000180_ReadAttribute +- (void)testSendClusterTestCluster_000216_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP64 null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableBitmap64WithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_BITMAP64 null Value Error: %@", err); + [cluster readAttributeNullableInt32uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT32U null Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -24106,46 +24943,46 @@ - (void)testSendClusterTestCluster_000180_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000181_WriteAttribute +- (void)testSendClusterTestCluster_000217_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U Max Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt8uArgument; - nullableInt8uArgument = [NSNumber numberWithUnsignedChar:254]; - [cluster writeAttributeNullableInt8uWithValue:nullableInt8uArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT8U Max Value Error: %@", err); + id nullableInt64uArgument; + nullableInt64uArgument = [NSNumber numberWithUnsignedLongLong:18446744073709551614ULL]; + [cluster writeAttributeNullableInt64uWithValue:nullableInt64uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT64U Max Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000182_ReadAttribute +- (void)testSendClusterTestCluster_000218_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U Max Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt8uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT8U Max Value Error: %@", err); + [cluster readAttributeNullableInt64uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT64U Max Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedCharValue], 254); + XCTAssertEqual([actualValue unsignedLongLongValue], 18446744073709551614ULL); } [expectation fulfill]; @@ -24153,45 +24990,46 @@ - (void)testSendClusterTestCluster_000182_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000183_WriteAttribute +- (void)testSendClusterTestCluster_000219_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U Invalid Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U Invalid Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt8uArgument; - nullableInt8uArgument = [NSNumber numberWithUnsignedChar:255]; - [cluster writeAttributeNullableInt8uWithValue:nullableInt8uArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT8U Invalid Value Error: %@", err); + id nullableInt64uArgument; + nullableInt64uArgument = [NSNumber numberWithUnsignedLongLong:18446744073709551615ULL]; + [cluster + writeAttributeNullableInt64uWithValue:nullableInt64uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT64U Invalid Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); - [expectation fulfill]; - }]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000184_ReadAttribute +- (void)testSendClusterTestCluster_000220_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U unchanged Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U unchanged Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt8uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT8U unchanged Value Error: %@", err); + [cluster readAttributeNullableInt64uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT64U unchanged Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedCharValue], 254); + XCTAssertEqual([actualValue unsignedLongLongValue], 18446744073709551614ULL); } [expectation fulfill]; @@ -24199,39 +25037,39 @@ - (void)testSendClusterTestCluster_000184_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000185_WriteAttribute +- (void)testSendClusterTestCluster_000221_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt8uArgument; - nullableInt8uArgument = nil; - [cluster writeAttributeNullableInt8uWithValue:nullableInt8uArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT8U null Value Error: %@", err); + id nullableInt64uArgument; + nullableInt64uArgument = nil; + [cluster writeAttributeNullableInt64uWithValue:nullableInt64uArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT64U null Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000186_ReadAttribute +- (void)testSendClusterTestCluster_000222_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt8uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT8U null Value Error: %@", err); + [cluster readAttributeNullableInt64uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT64U null Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -24245,46 +25083,46 @@ - (void)testSendClusterTestCluster_000186_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000187_WriteAttribute +- (void)testSendClusterTestCluster_000223_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S Min Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt16uArgument; - nullableInt16uArgument = [NSNumber numberWithUnsignedShort:65534U]; - [cluster writeAttributeNullableInt16uWithValue:nullableInt16uArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT16U Max Value Error: %@", err); + id nullableInt8sArgument; + nullableInt8sArgument = [NSNumber numberWithChar:-127]; + [cluster writeAttributeNullableInt8sWithValue:nullableInt8sArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT8S Min Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000188_ReadAttribute +- (void)testSendClusterTestCluster_000224_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S Min Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt16uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT16U Max Value Error: %@", err); + [cluster readAttributeNullableInt8sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT8S Min Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedShortValue], 65534U); + XCTAssertEqual([actualValue charValue], -127); } [expectation fulfill]; @@ -24292,46 +25130,45 @@ - (void)testSendClusterTestCluster_000188_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000189_WriteAttribute +- (void)testSendClusterTestCluster_000225_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U Invalid Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S Invalid Value"]; CHIPDevice * device = GetConnectedDevice(); - dispatch_queue_t queue = dispatch_get_main_queue(); - CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; - XCTAssertNotNil(cluster); - - id nullableInt16uArgument; - nullableInt16uArgument = [NSNumber numberWithUnsignedShort:65535U]; - [cluster - writeAttributeNullableInt16uWithValue:nullableInt16uArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT16U Invalid Value Error: %@", err); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); - [expectation fulfill]; - }]; + id nullableInt8sArgument; + nullableInt8sArgument = [NSNumber numberWithChar:-128]; + [cluster writeAttributeNullableInt8sWithValue:nullableInt8sArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT8S Invalid Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000190_ReadAttribute +- (void)testSendClusterTestCluster_000226_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U unchanged Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S unchanged Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt16uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT16U unchanged Value Error: %@", err); + [cluster readAttributeNullableInt8sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT8S unchanged Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedShortValue], 65534U); + XCTAssertEqual([actualValue charValue], -127); } [expectation fulfill]; @@ -24339,39 +25176,39 @@ - (void)testSendClusterTestCluster_000190_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000191_WriteAttribute +- (void)testSendClusterTestCluster_000227_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt16uArgument; - nullableInt16uArgument = nil; - [cluster writeAttributeNullableInt16uWithValue:nullableInt16uArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT16U null Value Error: %@", err); + id nullableInt8sArgument; + nullableInt8sArgument = nil; + [cluster writeAttributeNullableInt8sWithValue:nullableInt8sArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT8S null Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000192_ReadAttribute +- (void)testSendClusterTestCluster_000228_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt16uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT16U null Value Error: %@", err); + [cluster readAttributeNullableInt8sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT8S null Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -24385,20 +25222,20 @@ - (void)testSendClusterTestCluster_000192_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000193_WriteAttribute +- (void)testSendClusterTestCluster_000229_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S Min Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt32uArgument; - nullableInt32uArgument = [NSNumber numberWithUnsignedInt:4294967294UL]; - [cluster writeAttributeNullableInt32uWithValue:nullableInt32uArgument + id nullableInt16sArgument; + nullableInt16sArgument = [NSNumber numberWithShort:-32767]; + [cluster writeAttributeNullableInt16sWithValue:nullableInt16sArgument completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT32U Max Value Error: %@", err); + NSLog(@"Write attribute NULLABLE_INT16S Min Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -24407,24 +25244,24 @@ - (void)testSendClusterTestCluster_000193_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000194_ReadAttribute +- (void)testSendClusterTestCluster_000230_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S Min Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt32uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT32U Max Value Error: %@", err); + [cluster readAttributeNullableInt16sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT16S Min Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedIntValue], 4294967294UL); + XCTAssertEqual([actualValue shortValue], -32767); } [expectation fulfill]; @@ -24432,21 +25269,21 @@ - (void)testSendClusterTestCluster_000194_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000195_WriteAttribute +- (void)testSendClusterTestCluster_000231_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U Invalid Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S Invalid Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt32uArgument; - nullableInt32uArgument = [NSNumber numberWithUnsignedInt:4294967295UL]; + id nullableInt16sArgument; + nullableInt16sArgument = [NSNumber numberWithShort:-32768]; [cluster - writeAttributeNullableInt32uWithValue:nullableInt32uArgument + writeAttributeNullableInt16sWithValue:nullableInt16sArgument completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT32U Invalid Value Error: %@", err); + NSLog(@"Write attribute NULLABLE_INT16S Invalid Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); [expectation fulfill]; @@ -24454,24 +25291,24 @@ - (void)testSendClusterTestCluster_000195_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000196_ReadAttribute +- (void)testSendClusterTestCluster_000232_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U unchanged Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S unchanged Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt32uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT32U unchanged Value Error: %@", err); + [cluster readAttributeNullableInt16sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT16S unchanged Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedIntValue], 4294967294UL); + XCTAssertEqual([actualValue shortValue], -32767); } [expectation fulfill]; @@ -24479,20 +25316,20 @@ - (void)testSendClusterTestCluster_000196_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000197_WriteAttribute +- (void)testSendClusterTestCluster_000233_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt32uArgument; - nullableInt32uArgument = nil; - [cluster writeAttributeNullableInt32uWithValue:nullableInt32uArgument + id nullableInt16sArgument; + nullableInt16sArgument = nil; + [cluster writeAttributeNullableInt16sWithValue:nullableInt16sArgument completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT32U null Value Error: %@", err); + NSLog(@"Write attribute NULLABLE_INT16S null Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -24501,17 +25338,17 @@ - (void)testSendClusterTestCluster_000197_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000198_ReadAttribute +- (void)testSendClusterTestCluster_000234_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt32uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT32U null Value Error: %@", err); + [cluster readAttributeNullableInt16sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT16S null Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -24525,20 +25362,20 @@ - (void)testSendClusterTestCluster_000198_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000199_WriteAttribute +- (void)testSendClusterTestCluster_000235_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S Min Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt64uArgument; - nullableInt64uArgument = [NSNumber numberWithUnsignedLongLong:18446744073709551614ULL]; - [cluster writeAttributeNullableInt64uWithValue:nullableInt64uArgument + id nullableInt32sArgument; + nullableInt32sArgument = [NSNumber numberWithInt:-2147483647L]; + [cluster writeAttributeNullableInt32sWithValue:nullableInt32sArgument completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT64U Max Value Error: %@", err); + NSLog(@"Write attribute NULLABLE_INT32S Min Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -24547,24 +25384,24 @@ - (void)testSendClusterTestCluster_000199_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000200_ReadAttribute +- (void)testSendClusterTestCluster_000236_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U Max Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S Min Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt64uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT64U Max Value Error: %@", err); + [cluster readAttributeNullableInt32sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT32S Min Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedLongLongValue], 18446744073709551614ULL); + XCTAssertEqual([actualValue intValue], -2147483647L); } [expectation fulfill]; @@ -24572,21 +25409,21 @@ - (void)testSendClusterTestCluster_000200_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000201_WriteAttribute +- (void)testSendClusterTestCluster_000237_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U Invalid Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S Invalid Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt64uArgument; - nullableInt64uArgument = [NSNumber numberWithUnsignedLongLong:18446744073709551615ULL]; + id nullableInt32sArgument; + nullableInt32sArgument = [NSNumber numberWithInt:-2147483648L]; [cluster - writeAttributeNullableInt64uWithValue:nullableInt64uArgument + writeAttributeNullableInt32sWithValue:nullableInt32sArgument completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT64U Invalid Value Error: %@", err); + NSLog(@"Write attribute NULLABLE_INT32S Invalid Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); [expectation fulfill]; @@ -24594,24 +25431,24 @@ - (void)testSendClusterTestCluster_000201_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000202_ReadAttribute +- (void)testSendClusterTestCluster_000238_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U unchanged Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S unchanged Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt64uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT64U unchanged Value Error: %@", err); + [cluster readAttributeNullableInt32sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT32S unchanged Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue unsignedLongLongValue], 18446744073709551614ULL); + XCTAssertEqual([actualValue intValue], -2147483647L); } [expectation fulfill]; @@ -24619,20 +25456,20 @@ - (void)testSendClusterTestCluster_000202_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000203_WriteAttribute +- (void)testSendClusterTestCluster_000239_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt64uArgument; - nullableInt64uArgument = nil; - [cluster writeAttributeNullableInt64uWithValue:nullableInt64uArgument + id nullableInt32sArgument; + nullableInt32sArgument = nil; + [cluster writeAttributeNullableInt32sWithValue:nullableInt32sArgument completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT64U null Value Error: %@", err); + NSLog(@"Write attribute NULLABLE_INT32S null Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -24641,17 +25478,17 @@ - (void)testSendClusterTestCluster_000203_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000204_ReadAttribute +- (void)testSendClusterTestCluster_000240_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt64uWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT64U null Value Error: %@", err); + [cluster readAttributeNullableInt32sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT32S null Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -24665,46 +25502,46 @@ - (void)testSendClusterTestCluster_000204_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000205_WriteAttribute +- (void)testSendClusterTestCluster_000241_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S Min Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S Min Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt8sArgument; - nullableInt8sArgument = [NSNumber numberWithChar:-127]; - [cluster writeAttributeNullableInt8sWithValue:nullableInt8sArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT8S Min Value Error: %@", err); + id nullableInt64sArgument; + nullableInt64sArgument = [NSNumber numberWithLongLong:-9223372036854775807LL]; + [cluster writeAttributeNullableInt64sWithValue:nullableInt64sArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT64S Min Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000206_ReadAttribute +- (void)testSendClusterTestCluster_000242_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S Min Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S Min Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt8sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT8S Min Value Error: %@", err); + [cluster readAttributeNullableInt64sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT64S Min Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue charValue], -127); + XCTAssertEqual([actualValue longLongValue], -9223372036854775807LL); } [expectation fulfill]; @@ -24712,45 +25549,92 @@ - (void)testSendClusterTestCluster_000206_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000207_WriteAttribute +- (void)testSendClusterTestCluster_000243_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S Invalid Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S Invalid Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id nullableInt64sArgument; + nullableInt64sArgument = [NSNumber numberWithLongLong:-9223372036854775807LL - 1]; + [cluster + writeAttributeNullableInt64sWithValue:nullableInt64sArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT64S Invalid Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000244_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S unchanged Value"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeNullableInt64sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT64S unchanged Value Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue longLongValue], -9223372036854775807LL); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000245_WriteAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt8sArgument; - nullableInt8sArgument = [NSNumber numberWithChar:-128]; - [cluster writeAttributeNullableInt8sWithValue:nullableInt8sArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT8S Invalid Value Error: %@", err); + id nullableInt64sArgument; + nullableInt64sArgument = nil; + [cluster writeAttributeNullableInt64sWithValue:nullableInt64sArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_INT64S null Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); - [expectation fulfill]; - }]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000208_ReadAttribute +- (void)testSendClusterTestCluster_000246_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S unchanged Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt8sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT8S unchanged Value Error: %@", err); + [cluster readAttributeNullableInt64sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_INT64S null Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue charValue], -127); + XCTAssertTrue(actualValue == nil); } [expectation fulfill]; @@ -24758,45 +25642,46 @@ - (void)testSendClusterTestCluster_000208_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000209_WriteAttribute +- (void)testSendClusterTestCluster_000247_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE medium Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt8sArgument; - nullableInt8sArgument = nil; - [cluster writeAttributeNullableInt8sWithValue:nullableInt8sArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT8S null Value Error: %@", err); + id nullableFloatSingleArgument; + nullableFloatSingleArgument = [NSNumber numberWithFloat:0.1f]; + [cluster writeAttributeNullableFloatSingleWithValue:nullableFloatSingleArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_SINGLE medium Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000210_ReadAttribute +- (void)testSendClusterTestCluster_000248_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE medium Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt8sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT8S null Value Error: %@", err); + [cluster readAttributeNullableFloatSingleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_SINGLE medium Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertTrue(actualValue == nil); + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue floatValue], 0.1f); } [expectation fulfill]; @@ -24804,46 +25689,46 @@ - (void)testSendClusterTestCluster_000210_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000211_WriteAttribute +- (void)testSendClusterTestCluster_000249_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S Min Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE largest Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt16sArgument; - nullableInt16sArgument = [NSNumber numberWithShort:-32767]; - [cluster writeAttributeNullableInt16sWithValue:nullableInt16sArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT16S Min Value Error: %@", err); + id nullableFloatSingleArgument; + nullableFloatSingleArgument = [NSNumber numberWithFloat:INFINITY]; + [cluster writeAttributeNullableFloatSingleWithValue:nullableFloatSingleArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_SINGLE largest Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000212_ReadAttribute +- (void)testSendClusterTestCluster_000250_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S Min Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE largest Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt16sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT16S Min Value Error: %@", err); + [cluster readAttributeNullableFloatSingleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_SINGLE largest Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue shortValue], -32767); + XCTAssertEqual([actualValue floatValue], INFINITY); } [expectation fulfill]; @@ -24851,46 +25736,46 @@ - (void)testSendClusterTestCluster_000212_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000213_WriteAttribute +- (void)testSendClusterTestCluster_000251_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S Invalid Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE smallest Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt16sArgument; - nullableInt16sArgument = [NSNumber numberWithShort:-32768]; - [cluster - writeAttributeNullableInt16sWithValue:nullableInt16sArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT16S Invalid Value Error: %@", err); + id nullableFloatSingleArgument; + nullableFloatSingleArgument = [NSNumber numberWithFloat:-INFINITY]; + [cluster writeAttributeNullableFloatSingleWithValue:nullableFloatSingleArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_SINGLE smallest Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); - [expectation fulfill]; - }]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000214_ReadAttribute +- (void)testSendClusterTestCluster_000252_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S unchanged Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE smallest Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt16sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT16S unchanged Value Error: %@", err); + [cluster readAttributeNullableFloatSingleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_SINGLE smallest Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue shortValue], -32767); + XCTAssertEqual([actualValue floatValue], -INFINITY); } [expectation fulfill]; @@ -24898,39 +25783,39 @@ - (void)testSendClusterTestCluster_000214_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000215_WriteAttribute +- (void)testSendClusterTestCluster_000253_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt16sArgument; - nullableInt16sArgument = nil; - [cluster writeAttributeNullableInt16sWithValue:nullableInt16sArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT16S null Value Error: %@", err); + id nullableFloatSingleArgument; + nullableFloatSingleArgument = nil; + [cluster writeAttributeNullableFloatSingleWithValue:nullableFloatSingleArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_SINGLE null Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000216_ReadAttribute +- (void)testSendClusterTestCluster_000254_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt16sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT16S null Value Error: %@", err); + [cluster readAttributeNullableFloatSingleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_SINGLE null Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -24944,46 +25829,46 @@ - (void)testSendClusterTestCluster_000216_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000217_WriteAttribute +- (void)testSendClusterTestCluster_000255_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S Min Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE 0 Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt32sArgument; - nullableInt32sArgument = [NSNumber numberWithInt:-2147483647L]; - [cluster writeAttributeNullableInt32sWithValue:nullableInt32sArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT32S Min Value Error: %@", err); + id nullableFloatSingleArgument; + nullableFloatSingleArgument = [NSNumber numberWithFloat:0.0f]; + [cluster writeAttributeNullableFloatSingleWithValue:nullableFloatSingleArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_SINGLE 0 Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000218_ReadAttribute +- (void)testSendClusterTestCluster_000256_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S Min Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE 0 Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt32sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT32S Min Value Error: %@", err); + [cluster readAttributeNullableFloatSingleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_SINGLE 0 Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue intValue], -2147483647L); + XCTAssertEqual([actualValue floatValue], 0.0f); } [expectation fulfill]; @@ -24991,46 +25876,46 @@ - (void)testSendClusterTestCluster_000218_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000219_WriteAttribute +- (void)testSendClusterTestCluster_000257_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S Invalid Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE medium Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt32sArgument; - nullableInt32sArgument = [NSNumber numberWithInt:-2147483648L]; - [cluster - writeAttributeNullableInt32sWithValue:nullableInt32sArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT32S Invalid Value Error: %@", err); + id nullableFloatDoubleArgument; + nullableFloatDoubleArgument = [NSNumber numberWithDouble:0.1234567890123]; + [cluster writeAttributeNullableFloatDoubleWithValue:nullableFloatDoubleArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_DOUBLE medium Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); - [expectation fulfill]; - }]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000220_ReadAttribute +- (void)testSendClusterTestCluster_000258_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S unchanged Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE medium Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt32sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT32S unchanged Value Error: %@", err); + [cluster readAttributeNullableFloatDoubleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_DOUBLE medium Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue intValue], -2147483647L); + XCTAssertEqual([actualValue doubleValue], 0.1234567890123); } [expectation fulfill]; @@ -25038,45 +25923,46 @@ - (void)testSendClusterTestCluster_000220_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000221_WriteAttribute +- (void)testSendClusterTestCluster_000259_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE largest Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt32sArgument; - nullableInt32sArgument = nil; - [cluster writeAttributeNullableInt32sWithValue:nullableInt32sArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT32S null Value Error: %@", err); + id nullableFloatDoubleArgument; + nullableFloatDoubleArgument = [NSNumber numberWithDouble:INFINITY]; + [cluster writeAttributeNullableFloatDoubleWithValue:nullableFloatDoubleArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_DOUBLE largest Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000222_ReadAttribute +- (void)testSendClusterTestCluster_000260_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE largest Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt32sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT32S null Value Error: %@", err); + [cluster readAttributeNullableFloatDoubleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_DOUBLE largest Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertTrue(actualValue == nil); + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue doubleValue], INFINITY); } [expectation fulfill]; @@ -25084,46 +25970,46 @@ - (void)testSendClusterTestCluster_000222_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000223_WriteAttribute +- (void)testSendClusterTestCluster_000261_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S Min Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE smallest Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt64sArgument; - nullableInt64sArgument = [NSNumber numberWithLongLong:-9223372036854775807LL]; - [cluster writeAttributeNullableInt64sWithValue:nullableInt64sArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT64S Min Value Error: %@", err); + id nullableFloatDoubleArgument; + nullableFloatDoubleArgument = [NSNumber numberWithDouble:-INFINITY]; + [cluster writeAttributeNullableFloatDoubleWithValue:nullableFloatDoubleArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_DOUBLE smallest Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000224_ReadAttribute +- (void)testSendClusterTestCluster_000262_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S Min Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE smallest Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt64sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT64S Min Value Error: %@", err); + [cluster readAttributeNullableFloatDoubleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_DOUBLE smallest Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue longLongValue], -9223372036854775807LL); + XCTAssertEqual([actualValue doubleValue], -INFINITY); } [expectation fulfill]; @@ -25131,46 +26017,45 @@ - (void)testSendClusterTestCluster_000224_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000225_WriteAttribute +- (void)testSendClusterTestCluster_000263_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S Invalid Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt64sArgument; - nullableInt64sArgument = [NSNumber numberWithLongLong:-9223372036854775807LL - 1]; - [cluster - writeAttributeNullableInt64sWithValue:nullableInt64sArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT64S Invalid Value Error: %@", err); + id nullableFloatDoubleArgument; + nullableFloatDoubleArgument = nil; + [cluster writeAttributeNullableFloatDoubleWithValue:nullableFloatDoubleArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_DOUBLE null Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], EMBER_ZCL_STATUS_CONSTRAINT_ERROR); - [expectation fulfill]; - }]; + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000226_ReadAttribute +- (void)testSendClusterTestCluster_000264_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S unchanged Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE null Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt64sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT64S unchanged Value Error: %@", err); + [cluster readAttributeNullableFloatDoubleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_DOUBLE null Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertFalse(actualValue == nil); - XCTAssertEqual([actualValue longLongValue], -9223372036854775807LL); + XCTAssertTrue(actualValue == nil); } [expectation fulfill]; @@ -25178,45 +26063,46 @@ - (void)testSendClusterTestCluster_000226_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000227_WriteAttribute +- (void)testSendClusterTestCluster_000265_WriteAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE 0 Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - id nullableInt64sArgument; - nullableInt64sArgument = nil; - [cluster writeAttributeNullableInt64sWithValue:nullableInt64sArgument - completionHandler:^(NSError * _Nullable err) { - NSLog(@"Write attribute NULLABLE_INT64S null Value Error: %@", err); + id nullableFloatDoubleArgument; + nullableFloatDoubleArgument = [NSNumber numberWithDouble:0]; + [cluster writeAttributeNullableFloatDoubleWithValue:nullableFloatDoubleArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute NULLABLE_DOUBLE 0 Value Error: %@", err); - XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); - [expectation fulfill]; - }]; + [expectation fulfill]; + }]; [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000228_ReadAttribute +- (void)testSendClusterTestCluster_000266_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S null Value"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE 0 Value"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; XCTAssertNotNil(cluster); - [cluster readAttributeNullableInt64sWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute NULLABLE_INT64S null Value Error: %@", err); + [cluster readAttributeNullableFloatDoubleWithCompletionHandler:^(NSNumber * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute NULLABLE_DOUBLE 0 Value Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); { id actualValue = value; - XCTAssertTrue(actualValue == nil); + XCTAssertFalse(actualValue == nil); + XCTAssertEqual([actualValue doubleValue], 0); } [expectation fulfill]; @@ -25224,7 +26110,7 @@ - (void)testSendClusterTestCluster_000228_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000229_WriteAttribute +- (void)testSendClusterTestCluster_000267_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 Max Value"]; @@ -25246,7 +26132,7 @@ - (void)testSendClusterTestCluster_000229_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000230_ReadAttribute +- (void)testSendClusterTestCluster_000268_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 Max Value"]; @@ -25271,7 +26157,7 @@ - (void)testSendClusterTestCluster_000230_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000231_WriteAttribute +- (void)testSendClusterTestCluster_000269_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 Invalid Value"]; @@ -25292,7 +26178,7 @@ - (void)testSendClusterTestCluster_000231_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000232_ReadAttribute +- (void)testSendClusterTestCluster_000270_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 unchanged Value"]; @@ -25317,7 +26203,7 @@ - (void)testSendClusterTestCluster_000232_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000233_WriteAttribute +- (void)testSendClusterTestCluster_000271_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 null Value"]; @@ -25339,7 +26225,7 @@ - (void)testSendClusterTestCluster_000233_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000234_ReadAttribute +- (void)testSendClusterTestCluster_000272_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 null Value"]; @@ -25363,7 +26249,7 @@ - (void)testSendClusterTestCluster_000234_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000235_WriteAttribute +- (void)testSendClusterTestCluster_000273_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 Max Value"]; @@ -25385,7 +26271,7 @@ - (void)testSendClusterTestCluster_000235_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000236_ReadAttribute +- (void)testSendClusterTestCluster_000274_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 Max Value"]; @@ -25410,7 +26296,7 @@ - (void)testSendClusterTestCluster_000236_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000237_WriteAttribute +- (void)testSendClusterTestCluster_000275_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 Invalid Value"]; @@ -25432,7 +26318,7 @@ - (void)testSendClusterTestCluster_000237_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000238_ReadAttribute +- (void)testSendClusterTestCluster_000276_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 unchanged Value"]; @@ -25457,7 +26343,7 @@ - (void)testSendClusterTestCluster_000238_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000239_WriteAttribute +- (void)testSendClusterTestCluster_000277_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 null Value"]; @@ -25479,7 +26365,7 @@ - (void)testSendClusterTestCluster_000239_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000240_ReadAttribute +- (void)testSendClusterTestCluster_000278_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 null Value"]; @@ -25503,7 +26389,7 @@ - (void)testSendClusterTestCluster_000240_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000241_ReadAttribute +- (void)testSendClusterTestCluster_000279_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING Default Value"]; @@ -25528,7 +26414,7 @@ - (void)testSendClusterTestCluster_000241_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000242_WriteAttribute +- (void)testSendClusterTestCluster_000280_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_OCTET_STRING"]; @@ -25550,7 +26436,7 @@ - (void)testSendClusterTestCluster_000242_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000243_ReadAttribute +- (void)testSendClusterTestCluster_000281_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING"]; @@ -25575,7 +26461,7 @@ - (void)testSendClusterTestCluster_000243_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000244_WriteAttribute +- (void)testSendClusterTestCluster_000282_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_OCTET_STRING"]; @@ -25597,7 +26483,7 @@ - (void)testSendClusterTestCluster_000244_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000245_ReadAttribute +- (void)testSendClusterTestCluster_000283_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING"]; @@ -25621,7 +26507,7 @@ - (void)testSendClusterTestCluster_000245_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000246_WriteAttribute +- (void)testSendClusterTestCluster_000284_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_OCTET_STRING"]; @@ -25643,7 +26529,7 @@ - (void)testSendClusterTestCluster_000246_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000247_ReadAttribute +- (void)testSendClusterTestCluster_000285_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING"]; @@ -25668,7 +26554,7 @@ - (void)testSendClusterTestCluster_000247_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000248_ReadAttribute +- (void)testSendClusterTestCluster_000286_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING Default Value"]; @@ -25693,7 +26579,7 @@ - (void)testSendClusterTestCluster_000248_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000249_WriteAttribute +- (void)testSendClusterTestCluster_000287_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_CHAR_STRING"]; @@ -25715,7 +26601,7 @@ - (void)testSendClusterTestCluster_000249_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000250_ReadAttribute +- (void)testSendClusterTestCluster_000288_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING"]; @@ -25740,7 +26626,7 @@ - (void)testSendClusterTestCluster_000250_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000251_WriteAttribute +- (void)testSendClusterTestCluster_000289_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_CHAR_STRING - Value too long"]; @@ -25762,7 +26648,7 @@ - (void)testSendClusterTestCluster_000251_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000252_ReadAttribute +- (void)testSendClusterTestCluster_000290_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING"]; @@ -25786,7 +26672,7 @@ - (void)testSendClusterTestCluster_000252_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000253_WriteAttribute +- (void)testSendClusterTestCluster_000291_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_CHAR_STRING - Empty"]; @@ -25808,7 +26694,7 @@ - (void)testSendClusterTestCluster_000253_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000254_ReadAttribute +- (void)testSendClusterTestCluster_000292_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING"]; @@ -25833,7 +26719,7 @@ - (void)testSendClusterTestCluster_000254_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000255_ReadAttribute +- (void)testSendClusterTestCluster_000293_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute from nonexistent endpoint."]; @@ -25851,7 +26737,7 @@ - (void)testSendClusterTestCluster_000255_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000256_ReadAttribute +- (void)testSendClusterTestCluster_000294_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute from nonexistent cluster."]; diff --git a/src/lib/support/JniReferences.cpp b/src/lib/support/JniReferences.cpp index 6fd6d89955c808..5247f1b4f3ac00 100644 --- a/src/lib/support/JniReferences.cpp +++ b/src/lib/support/JniReferences.cpp @@ -253,4 +253,26 @@ jboolean JniReferences::BooleanToPrimitive(jobject boxedBoolean) return env->CallBooleanMethod(boxedBoolean, valueMethod); } +jfloat JniReferences::FloatToPrimitive(jobject boxedFloat) +{ + JNIEnv * env = GetEnvForCurrentThread(); + jclass boxedTypeCls; + chip::JniReferences::GetInstance().GetClassRef(env, "java/lang/Float", boxedTypeCls); + chip::JniClass jniClass(boxedTypeCls); + + jmethodID valueMethod = env->GetMethodID(boxedTypeCls, "floatValue", "()F"); + return env->CallFloatMethod(boxedFloat, valueMethod); +} + +jdouble JniReferences::DoubleToPrimitive(jobject boxedDouble) +{ + JNIEnv * env = GetEnvForCurrentThread(); + jclass boxedTypeCls; + chip::JniReferences::GetInstance().GetClassRef(env, "java/lang/Double", boxedTypeCls); + chip::JniClass jniClass(boxedTypeCls); + + jmethodID valueMethod = env->GetMethodID(boxedTypeCls, "doubleValue", "()D"); + return env->CallDoubleMethod(boxedDouble, valueMethod); +} + } // namespace chip diff --git a/src/lib/support/JniReferences.h b/src/lib/support/JniReferences.h index 32a8e6d497d35f..52c23a95175085 100644 --- a/src/lib/support/JniReferences.h +++ b/src/lib/support/JniReferences.h @@ -102,6 +102,16 @@ class JniReferences */ jboolean BooleanToPrimitive(jobject boxedObject); + /** + * Get a primitive jfloat from the Java boxed type Float, using floatValue(). + */ + jfloat FloatToPrimitive(jobject boxedObject); + + /** + * Get a primitive jfloat from the Java boxed type Double, using doubleValue(). + */ + jdouble DoubleToPrimitive(jobject boxedObject); + /** * Creates a boxed type (e.g. java.lang.Integer) based on the the class name ("java/lang/Integer"), constructor JNI signature * ("(I)V"), and value. diff --git a/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h b/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h index 605aa704cf11b5..1c689d871a4f0f 100644 --- a/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h +++ b/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h @@ -572,65 +572,77 @@ /* 3347 - int64s, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3355 - epoch_us, */ \ + /* 3355 - float_single, */ \ + 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3359 - float_double, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3367 - epoch_us, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3363 - epoch_s, */ \ + /* 3375 - epoch_s, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3367 - nullable_bitmap32, */ \ + /* 3379 - nullable_bitmap32, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3371 - nullable_bitmap64, */ \ + /* 3383 - nullable_bitmap64, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3379 - nullable_int24u, */ \ + /* 3391 - nullable_int24u, */ \ 0x00, 0x00, 0x00, \ \ - /* 3382 - nullable_int32u, */ \ + /* 3394 - nullable_int32u, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3386 - nullable_int40u, */ \ + /* 3398 - nullable_int40u, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3391 - nullable_int48u, */ \ + /* 3403 - nullable_int48u, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3397 - nullable_int56u, */ \ + /* 3409 - nullable_int56u, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3404 - nullable_int64u, */ \ + /* 3416 - nullable_int64u, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3412 - nullable_int24s, */ \ + /* 3424 - nullable_int24s, */ \ 0x00, 0x00, 0x00, \ \ - /* 3415 - nullable_int32s, */ \ + /* 3427 - nullable_int32s, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3419 - nullable_int40s, */ \ + /* 3431 - nullable_int40s, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3424 - nullable_int48s, */ \ + /* 3436 - nullable_int48s, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3430 - nullable_int56s, */ \ + /* 3442 - nullable_int56s, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3437 - nullable_int64s, */ \ + /* 3449 - nullable_int64s, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3457 - nullable_float_single, */ \ + 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3461 - nullable_float_double, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ /* Endpoint: 1, Cluster: Electrical Measurement (server), big-endian */ \ \ - /* 3445 - measurement type, */ \ + /* 3469 - measurement type, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3449 - total active power, */ \ + /* 3473 - total active power, */ \ 0x00, 0x00, 0x00, 0x00, \ \ /* Endpoint: 2, Cluster: On/Off (server), big-endian */ \ \ - /* 3453 - FeatureMap, */ \ + /* 3477 - FeatureMap, */ \ 0x00, 0x00, 0x00, 0x00, \ } @@ -1183,71 +1195,83 @@ /* 3347 - int64s, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3355 - epoch_us, */ \ + /* 3355 - float_single, */ \ + 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3359 - float_double, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3367 - epoch_us, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3363 - epoch_s, */ \ + /* 3375 - epoch_s, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3367 - nullable_bitmap32, */ \ + /* 3379 - nullable_bitmap32, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3371 - nullable_bitmap64, */ \ + /* 3383 - nullable_bitmap64, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3379 - nullable_int24u, */ \ + /* 3391 - nullable_int24u, */ \ 0x00, 0x00, 0x00, \ \ - /* 3382 - nullable_int32u, */ \ + /* 3394 - nullable_int32u, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3386 - nullable_int40u, */ \ + /* 3398 - nullable_int40u, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3391 - nullable_int48u, */ \ + /* 3403 - nullable_int48u, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3397 - nullable_int56u, */ \ + /* 3409 - nullable_int56u, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3404 - nullable_int64u, */ \ + /* 3416 - nullable_int64u, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3412 - nullable_int24s, */ \ + /* 3424 - nullable_int24s, */ \ 0x00, 0x00, 0x00, \ \ - /* 3415 - nullable_int32s, */ \ + /* 3427 - nullable_int32s, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3419 - nullable_int40s, */ \ + /* 3431 - nullable_int40s, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3424 - nullable_int48s, */ \ + /* 3436 - nullable_int48s, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3430 - nullable_int56s, */ \ + /* 3442 - nullable_int56s, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ - /* 3437 - nullable_int64s, */ \ + /* 3449 - nullable_int64s, */ \ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3457 - nullable_float_single, */ \ + 0x00, 0x00, 0x00, 0x00, \ + \ + /* 3461 - nullable_float_double, */ \ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \ \ /* Endpoint: 1, Cluster: Electrical Measurement (server), little-endian */ \ \ - /* 3445 - measurement type, */ \ + /* 3469 - measurement type, */ \ 0x00, 0x00, 0x00, 0x00, \ \ - /* 3449 - total active power, */ \ + /* 3473 - total active power, */ \ 0x00, 0x00, 0x00, 0x00, \ \ /* Endpoint: 2, Cluster: On/Off (server), little-endian */ \ \ - /* 3453 - FeatureMap, */ \ + /* 3477 - FeatureMap, */ \ 0x00, 0x00, 0x00, 0x00, \ } #endif // BIGENDIAN_CPU -#define GENERATED_DEFAULTS_COUNT (135) +#define GENERATED_DEFAULTS_COUNT (139) #define ZAP_TYPE(type) ZCL_##type##_ATTRIBUTE_TYPE #define ZAP_LONG_DEFAULTS_INDEX(index) \ @@ -1334,7 +1358,7 @@ #define ZAP_ATTRIBUTE_MASK(mask) ATTRIBUTE_MASK_##mask // This is an array of EmberAfAttributeMetadata structures. -#define GENERATED_ATTRIBUTE_COUNT 559 +#define GENERATED_ATTRIBUTE_COUNT 563 #define GENERATED_ATTRIBUTES \ { \ \ @@ -1982,6 +2006,8 @@ { 0x0014, ZAP_TYPE(INT64S), 8, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3347) }, /* int64s */ \ { 0x0015, ZAP_TYPE(ENUM8), 1, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* enum8 */ \ { 0x0016, ZAP_TYPE(ENUM16), 2, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* enum16 */ \ + { 0x0017, ZAP_TYPE(SINGLE), 4, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3355) }, /* float_single */ \ + { 0x0018, ZAP_TYPE(DOUBLE), 8, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3359) }, /* float_double */ \ { 0x0019, ZAP_TYPE(OCTET_STRING), 11, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_EMPTY_DEFAULT() }, /* octet_string */ \ { 0x001A, ZAP_TYPE(ARRAY), 0, ZAP_ATTRIBUTE_MASK(EXTERNAL_STORAGE) | ZAP_ATTRIBUTE_MASK(WRITABLE), \ ZAP_EMPTY_DEFAULT() }, /* list_int8u */ \ @@ -1994,8 +2020,8 @@ { 0x001E, ZAP_TYPE(CHAR_STRING), 11, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_EMPTY_DEFAULT() }, /* char_string */ \ { 0x001F, ZAP_TYPE(LONG_CHAR_STRING), 1002, ZAP_ATTRIBUTE_MASK(WRITABLE), \ ZAP_EMPTY_DEFAULT() }, /* long_char_string */ \ - { 0x0020, ZAP_TYPE(EPOCH_US), 8, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3355) }, /* epoch_us */ \ - { 0x0021, ZAP_TYPE(EPOCH_S), 4, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3363) }, /* epoch_s */ \ + { 0x0020, ZAP_TYPE(EPOCH_US), 8, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3367) }, /* epoch_us */ \ + { 0x0021, ZAP_TYPE(EPOCH_S), 4, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_LONG_DEFAULTS_INDEX(3375) }, /* epoch_s */ \ { 0x0022, ZAP_TYPE(VENDOR_ID), 2, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_EMPTY_DEFAULT() }, /* vendor_id */ \ { 0x0023, ZAP_TYPE(ARRAY), 0, ZAP_ATTRIBUTE_MASK(EXTERNAL_STORAGE), \ ZAP_EMPTY_DEFAULT() }, /* list_nullables_and_optionals_struct */ \ @@ -2019,45 +2045,49 @@ { 0x8002, ZAP_TYPE(BITMAP16), 2, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ ZAP_SIMPLE_DEFAULT(0) }, /* nullable_bitmap16 */ \ { 0x8003, ZAP_TYPE(BITMAP32), 4, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3367) }, /* nullable_bitmap32 */ \ + ZAP_LONG_DEFAULTS_INDEX(3379) }, /* nullable_bitmap32 */ \ { 0x8004, ZAP_TYPE(BITMAP64), 8, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3371) }, /* nullable_bitmap64 */ \ + ZAP_LONG_DEFAULTS_INDEX(3383) }, /* nullable_bitmap64 */ \ { 0x8005, ZAP_TYPE(INT8U), 1, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ ZAP_SIMPLE_DEFAULT(0) }, /* nullable_int8u */ \ { 0x8006, ZAP_TYPE(INT16U), 2, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ ZAP_SIMPLE_DEFAULT(0) }, /* nullable_int16u */ \ { 0x8007, ZAP_TYPE(INT24U), 3, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3379) }, /* nullable_int24u */ \ + ZAP_LONG_DEFAULTS_INDEX(3391) }, /* nullable_int24u */ \ { 0x8008, ZAP_TYPE(INT32U), 4, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3382) }, /* nullable_int32u */ \ + ZAP_LONG_DEFAULTS_INDEX(3394) }, /* nullable_int32u */ \ { 0x8009, ZAP_TYPE(INT40U), 5, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3386) }, /* nullable_int40u */ \ + ZAP_LONG_DEFAULTS_INDEX(3398) }, /* nullable_int40u */ \ { 0x800A, ZAP_TYPE(INT48U), 6, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3391) }, /* nullable_int48u */ \ + ZAP_LONG_DEFAULTS_INDEX(3403) }, /* nullable_int48u */ \ { 0x800B, ZAP_TYPE(INT56U), 7, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3397) }, /* nullable_int56u */ \ + ZAP_LONG_DEFAULTS_INDEX(3409) }, /* nullable_int56u */ \ { 0x800C, ZAP_TYPE(INT64U), 8, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3404) }, /* nullable_int64u */ \ + ZAP_LONG_DEFAULTS_INDEX(3416) }, /* nullable_int64u */ \ { 0x800D, ZAP_TYPE(INT8S), 1, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ ZAP_SIMPLE_DEFAULT(0) }, /* nullable_int8s */ \ { 0x800E, ZAP_TYPE(INT16S), 2, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ ZAP_SIMPLE_DEFAULT(0) }, /* nullable_int16s */ \ { 0x800F, ZAP_TYPE(INT24S), 3, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3412) }, /* nullable_int24s */ \ + ZAP_LONG_DEFAULTS_INDEX(3424) }, /* nullable_int24s */ \ { 0x8010, ZAP_TYPE(INT32S), 4, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3415) }, /* nullable_int32s */ \ + ZAP_LONG_DEFAULTS_INDEX(3427) }, /* nullable_int32s */ \ { 0x8011, ZAP_TYPE(INT40S), 5, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3419) }, /* nullable_int40s */ \ + ZAP_LONG_DEFAULTS_INDEX(3431) }, /* nullable_int40s */ \ { 0x8012, ZAP_TYPE(INT48S), 6, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3424) }, /* nullable_int48s */ \ + ZAP_LONG_DEFAULTS_INDEX(3436) }, /* nullable_int48s */ \ { 0x8013, ZAP_TYPE(INT56S), 7, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3430) }, /* nullable_int56s */ \ + ZAP_LONG_DEFAULTS_INDEX(3442) }, /* nullable_int56s */ \ { 0x8014, ZAP_TYPE(INT64S), 8, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ - ZAP_LONG_DEFAULTS_INDEX(3437) }, /* nullable_int64s */ \ + ZAP_LONG_DEFAULTS_INDEX(3449) }, /* nullable_int64s */ \ { 0x8015, ZAP_TYPE(ENUM8), 1, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ ZAP_SIMPLE_DEFAULT(0) }, /* nullable_enum8 */ \ { 0x8016, ZAP_TYPE(ENUM16), 2, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ ZAP_SIMPLE_DEFAULT(0) }, /* nullable_enum16 */ \ + { 0x8017, ZAP_TYPE(SINGLE), 4, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ + ZAP_LONG_DEFAULTS_INDEX(3457) }, /* nullable_float_single */ \ + { 0x8018, ZAP_TYPE(DOUBLE), 8, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ + ZAP_LONG_DEFAULTS_INDEX(3461) }, /* nullable_float_double */ \ { 0x8019, ZAP_TYPE(OCTET_STRING), 11, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ ZAP_EMPTY_DEFAULT() }, /* nullable_octet_string */ \ { 0x801E, ZAP_TYPE(CHAR_STRING), 11, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(NULLABLE), \ @@ -2082,8 +2112,8 @@ { 0xFFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x0001) }, /* ClusterRevision */ \ \ /* Endpoint: 1, Cluster: Electrical Measurement (server) */ \ - { 0x0000, ZAP_TYPE(BITMAP32), 4, 0, ZAP_LONG_DEFAULTS_INDEX(3445) }, /* measurement type */ \ - { 0x0304, ZAP_TYPE(INT32S), 4, 0, ZAP_LONG_DEFAULTS_INDEX(3449) }, /* total active power */ \ + { 0x0000, ZAP_TYPE(BITMAP32), 4, 0, ZAP_LONG_DEFAULTS_INDEX(3469) }, /* measurement type */ \ + { 0x0304, ZAP_TYPE(INT32S), 4, 0, ZAP_LONG_DEFAULTS_INDEX(3473) }, /* total active power */ \ { 0x0505, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0xffff) }, /* rms voltage */ \ { 0x0506, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x8000) }, /* rms voltage min */ \ { 0x0507, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(0x8000) }, /* rms voltage max */ \ @@ -2104,7 +2134,7 @@ { 0x4001, ZAP_TYPE(INT16U), 2, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* OnTime */ \ { 0x4002, ZAP_TYPE(INT16U), 2, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_SIMPLE_DEFAULT(0) }, /* OffWaitTime */ \ { 0x4003, ZAP_TYPE(ENUM8), 1, ZAP_ATTRIBUTE_MASK(WRITABLE), ZAP_EMPTY_DEFAULT() }, /* StartUpOnOff */ \ - { 0xFFFC, ZAP_TYPE(BITMAP32), 4, 0, ZAP_LONG_DEFAULTS_INDEX(3453) }, /* FeatureMap */ \ + { 0xFFFC, ZAP_TYPE(BITMAP32), 4, 0, ZAP_LONG_DEFAULTS_INDEX(3477) }, /* FeatureMap */ \ { 0xFFFD, ZAP_TYPE(INT16U), 2, 0, ZAP_SIMPLE_DEFAULT(4) }, /* ClusterRevision */ \ \ /* Endpoint: 2, Cluster: Descriptor (server) */ \ @@ -2393,25 +2423,25 @@ 0x050E, ZAP_ATTRIBUTE_INDEX(456), 1, 2, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 1, Cluster: Account Login (server) */ \ { \ - 0x050F, ZAP_ATTRIBUTE_INDEX(457), 73, 2261, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x050F, ZAP_ATTRIBUTE_INDEX(457), 77, 2285, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 1, Cluster: Test Cluster (server) */ \ { \ - 0x0B04, ZAP_ATTRIBUTE_INDEX(530), 12, 28, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x0B04, ZAP_ATTRIBUTE_INDEX(534), 12, 28, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 1, Cluster: Electrical Measurement (server) */ \ { \ - 0xF000, ZAP_ATTRIBUTE_INDEX(542), 1, 2, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0xF000, ZAP_ATTRIBUTE_INDEX(546), 1, 2, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 1, Cluster: Binding (server) */ \ { 0x0006, \ - ZAP_ATTRIBUTE_INDEX(543), \ + ZAP_ATTRIBUTE_INDEX(547), \ 7, \ 13, \ ZAP_CLUSTER_MASK(SERVER) | ZAP_CLUSTER_MASK(INIT_FUNCTION), \ chipFuncArrayOnOffServer }, /* Endpoint: 2, Cluster: On/Off (server) */ \ { \ - 0x001D, ZAP_ATTRIBUTE_INDEX(550), 5, 0, ZAP_CLUSTER_MASK(SERVER), NULL \ + 0x001D, ZAP_ATTRIBUTE_INDEX(554), 5, 0, ZAP_CLUSTER_MASK(SERVER), NULL \ }, /* Endpoint: 2, Cluster: Descriptor (server) */ \ { 0x0406, \ - ZAP_ATTRIBUTE_INDEX(555), \ + ZAP_ATTRIBUTE_INDEX(559), \ 4, \ 5, \ ZAP_CLUSTER_MASK(SERVER) | ZAP_CLUSTER_MASK(INIT_FUNCTION), \ @@ -2423,7 +2453,7 @@ // This is an array of EmberAfEndpointType structures. #define GENERATED_ENDPOINT_TYPES \ { \ - { ZAP_CLUSTER_INDEX(0), 18, 1921 }, { ZAP_CLUSTER_INDEX(18), 44, 6011 }, { ZAP_CLUSTER_INDEX(62), 3, 18 }, \ + { ZAP_CLUSTER_INDEX(0), 18, 1921 }, { ZAP_CLUSTER_INDEX(18), 44, 6035 }, { ZAP_CLUSTER_INDEX(62), 3, 18 }, \ } // Largest attribute size is needed for various buffers @@ -2433,7 +2463,7 @@ #define ATTRIBUTE_SINGLETONS_SIZE (1333) // Total size of attribute storage -#define ATTRIBUTE_MAX_SIZE (7950) +#define ATTRIBUTE_MAX_SIZE (7974) // Number of fixed endpoints #define FIXED_ENDPOINT_COUNT (3) diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h index 506aeb761ac233..9a800a5409d3c2 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h @@ -2229,6 +2229,32 @@ static void OnInt64sAttributeResponse(void * context, int64_t value) command->SetCommandExitStatus(CHIP_NO_ERROR); } +static void OnFloatAttributeReport(void * context, float value) +{ + ChipLogProgress(chipTool, "Float attribute Response: %f", value); +} + +static void OnFloatAttributeResponse(void * context, float value) +{ + OnFloatAttributeReport(context, value); + + ModelCommand * command = static_cast(context); + command->SetCommandExitStatus(CHIP_NO_ERROR); +} + +static void OnDoubleAttributeReport(void * context, double value) +{ + ChipLogProgress(chipTool, "Double attribute Response: %f", value); +} + +static void OnDoubleAttributeResponse(void * context, double value) +{ + OnDoubleAttributeReport(context, value); + + ModelCommand * command = static_cast(context); + command->SetCommandExitStatus(CHIP_NO_ERROR); +} + static void OnOctetStringAttributeReport(void * context, const chip::ByteSpan value) { char buffer[CHIP_CONFIG_LOG_MESSAGE_MAX_SIZE]; @@ -39588,6 +39614,244 @@ class ReportTestClusterEnum16 : public ModelCommand bool mWait; }; +/* + * Attribute FloatSingle + */ +class ReadTestClusterFloatSingle : public ModelCommand +{ +public: + ReadTestClusterFloatSingle() : ModelCommand("read") + { + AddArgument("attr-name", "float-single"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterFloatSingle() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeFloatSingle(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnFloatAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterFloatSingle : public ModelCommand +{ +public: + WriteTestClusterFloatSingle() : ModelCommand("write") + { + AddArgument("attr-name", "float-single"); + AddArgument("attr-value", -std::numeric_limits::infinity(), std::numeric_limits::infinity(), &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterFloatSingle() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeFloatSingle(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + float mValue; +}; + +class ReportTestClusterFloatSingle : public ModelCommand +{ +public: + ReportTestClusterFloatSingle() : ModelCommand("report") + { + AddArgument("attr-name", "float-single"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterFloatSingle() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeFloatSingle(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeFloatSingle(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnFloatAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute FloatDouble + */ +class ReadTestClusterFloatDouble : public ModelCommand +{ +public: + ReadTestClusterFloatDouble() : ModelCommand("read") + { + AddArgument("attr-name", "float-double"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterFloatDouble() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeFloatDouble(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDoubleAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterFloatDouble : public ModelCommand +{ +public: + WriteTestClusterFloatDouble() : ModelCommand("write") + { + AddArgument("attr-name", "float-double"); + AddArgument("attr-value", -std::numeric_limits::infinity(), std::numeric_limits::infinity(), &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterFloatDouble() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeFloatDouble(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + double mValue; +}; + +class ReportTestClusterFloatDouble : public ModelCommand +{ +public: + ReportTestClusterFloatDouble() : ModelCommand("report") + { + AddArgument("attr-name", "float-double"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterFloatDouble() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeFloatDouble(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeFloatDouble(successCallback, onFailureCallback->Cancel(), mMinInterval, mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnDoubleAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + /* * Attribute OctetString */ @@ -43963,6 +44227,246 @@ class ReportTestClusterNullableEnum16 : public ModelCommand bool mWait; }; +/* + * Attribute NullableFloatSingle + */ +class ReadTestClusterNullableFloatSingle : public ModelCommand +{ +public: + ReadTestClusterNullableFloatSingle() : ModelCommand("read") + { + AddArgument("attr-name", "nullable-float-single"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterNullableFloatSingle() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeNullableFloatSingle(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnFloatAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterNullableFloatSingle : public ModelCommand +{ +public: + WriteTestClusterNullableFloatSingle() : ModelCommand("write") + { + AddArgument("attr-name", "nullable-float-single"); + AddArgument("attr-value", -std::numeric_limits::infinity(), std::numeric_limits::infinity(), &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterNullableFloatSingle() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeNullableFloatSingle(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + float mValue; +}; + +class ReportTestClusterNullableFloatSingle : public ModelCommand +{ +public: + ReportTestClusterNullableFloatSingle() : ModelCommand("report") + { + AddArgument("attr-name", "nullable-float-single"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterNullableFloatSingle() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeNullableFloatSingle(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeNullableFloatSingle(successCallback, onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnFloatAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + +/* + * Attribute NullableFloatDouble + */ +class ReadTestClusterNullableFloatDouble : public ModelCommand +{ +public: + ReadTestClusterNullableFloatDouble() : ModelCommand("read") + { + AddArgument("attr-name", "nullable-float-double"); + ModelCommand::AddArguments(); + } + + ~ReadTestClusterNullableFloatDouble() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x00) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.ReadAttributeNullableFloatDouble(onSuccessCallback->Cancel(), onFailureCallback->Cancel()); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDoubleAttributeResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); +}; + +class WriteTestClusterNullableFloatDouble : public ModelCommand +{ +public: + WriteTestClusterNullableFloatDouble() : ModelCommand("write") + { + AddArgument("attr-name", "nullable-float-double"); + AddArgument("attr-value", -std::numeric_limits::infinity(), std::numeric_limits::infinity(), &mValue); + ModelCommand::AddArguments(); + } + + ~WriteTestClusterNullableFloatDouble() + { + delete onSuccessCallback; + delete onFailureCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x01) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + return cluster.WriteAttributeNullableFloatDouble(onSuccessCallback->Cancel(), onFailureCallback->Cancel(), mValue); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + double mValue; +}; + +class ReportTestClusterNullableFloatDouble : public ModelCommand +{ +public: + ReportTestClusterNullableFloatDouble() : ModelCommand("report") + { + AddArgument("attr-name", "nullable-float-double"); + AddArgument("min-interval", 0, UINT16_MAX, &mMinInterval); + AddArgument("max-interval", 0, UINT16_MAX, &mMaxInterval); + AddArgument("wait", 0, 1, &mWait); + ModelCommand::AddArguments(); + } + + ~ReportTestClusterNullableFloatDouble() + { + delete onSuccessCallback; + delete onSuccessCallbackWithoutExit; + delete onFailureCallback; + delete onReportCallback; + } + + CHIP_ERROR SendCommand(ChipDevice * device, uint8_t endpointId) override + { + ChipLogProgress(chipTool, "Sending cluster (0x050F) command (0x06) on endpoint %" PRIu8, endpointId); + + chip::Controller::TestClusterCluster cluster; + cluster.Associate(device, endpointId); + + ReturnErrorOnFailure(cluster.ReportAttributeNullableFloatDouble(onReportCallback->Cancel())); + + chip::Callback::Cancelable * successCallback = mWait ? onSuccessCallbackWithoutExit->Cancel() : onSuccessCallback->Cancel(); + return cluster.SubscribeAttributeNullableFloatDouble(successCallback, onFailureCallback->Cancel(), mMinInterval, + mMaxInterval); + } + + chip::System::Clock::Timeout GetWaitDuration() const override + { + return chip::System::Clock::Seconds16(mWait ? UINT16_MAX : 10); + } + +private: + chip::Callback::Callback * onSuccessCallback = + new chip::Callback::Callback(OnDefaultSuccessResponse, this); + chip::Callback::Callback * onSuccessCallbackWithoutExit = + new chip::Callback::Callback(OnDefaultSuccessResponseWithoutExit, this); + chip::Callback::Callback * onFailureCallback = + new chip::Callback::Callback(OnDefaultFailureResponse, this); + chip::Callback::Callback * onReportCallback = + new chip::Callback::Callback(OnDoubleAttributeReport, this); + uint16_t mMinInterval; + uint16_t mMaxInterval; + bool mWait; +}; + /* * Attribute NullableOctetString */ @@ -57456,6 +57960,12 @@ void registerClusterTestCluster(Commands & commands) make_unique(), // make_unique(), // make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // make_unique(), // make_unique(), // make_unique(), // @@ -57567,6 +58077,12 @@ void registerClusterTestCluster(Commands & commands) make_unique(), // make_unique(), // make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // + make_unique(), // make_unique(), // make_unique(), // make_unique(), // diff --git a/zzz_generated/chip-tool/zap-generated/reporting/Commands.h b/zzz_generated/chip-tool/zap-generated/reporting/Commands.h index 22ecf7b59fabff..60f7842582e1c6 100644 --- a/zzz_generated/chip-tool/zap-generated/reporting/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/reporting/Commands.h @@ -348,6 +348,8 @@ class Listen : public ReportingCommand delete onReportTestClusterInt64sCallback; delete onReportTestClusterEnum8Callback; delete onReportTestClusterEnum16Callback; + delete onReportTestClusterFloatSingleCallback; + delete onReportTestClusterFloatDoubleCallback; delete onReportTestClusterOctetStringCallback; delete onReportTestClusterLongOctetStringCallback; delete onReportTestClusterCharStringCallback; @@ -383,6 +385,8 @@ class Listen : public ReportingCommand delete onReportTestClusterNullableInt64sCallback; delete onReportTestClusterNullableEnum8Callback; delete onReportTestClusterNullableEnum16Callback; + delete onReportTestClusterNullableFloatSingleCallback; + delete onReportTestClusterNullableFloatDoubleCallback; delete onReportTestClusterNullableOctetStringCallback; delete onReportTestClusterNullableCharStringCallback; delete onReportTestClusterNullableRangeRestrictedInt8uCallback; @@ -1306,6 +1310,10 @@ class Listen : public ReportingCommand BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0016, onReportTestClusterEnum16Callback->Cancel(), BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0017, onReportTestClusterFloatSingleCallback->Cancel(), + BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0018, onReportTestClusterFloatDoubleCallback->Cancel(), + BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x0019, onReportTestClusterOctetStringCallback->Cancel(), BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x001D, onReportTestClusterLongOctetStringCallback->Cancel(), @@ -1380,6 +1388,12 @@ class Listen : public ReportingCommand BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8016, onReportTestClusterNullableEnum16Callback->Cancel(), BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8017, + onReportTestClusterNullableFloatSingleCallback->Cancel(), + BasicAttributeFilter); + callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8018, + onReportTestClusterNullableFloatDoubleCallback->Cancel(), + BasicAttributeFilter); callbacksMgr.AddReportCallback(remoteId, endpointId, 0x050F, 0x8019, onReportTestClusterNullableOctetStringCallback->Cancel(), BasicAttributeFilter); @@ -2410,6 +2424,10 @@ class Listen : public ReportingCommand new chip::Callback::Callback(OnInt8uAttributeResponse, this); chip::Callback::Callback * onReportTestClusterEnum16Callback = new chip::Callback::Callback(OnInt16uAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterFloatSingleCallback = + new chip::Callback::Callback(OnFloatAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterFloatDoubleCallback = + new chip::Callback::Callback(OnDoubleAttributeResponse, this); chip::Callback::Callback * onReportTestClusterOctetStringCallback = new chip::Callback::Callback(OnOctetStringAttributeResponse, this); chip::Callback::Callback * onReportTestClusterLongOctetStringCallback = @@ -2480,6 +2498,10 @@ class Listen : public ReportingCommand new chip::Callback::Callback(OnInt8uAttributeResponse, this); chip::Callback::Callback * onReportTestClusterNullableEnum16Callback = new chip::Callback::Callback(OnInt16uAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterNullableFloatSingleCallback = + new chip::Callback::Callback(OnFloatAttributeResponse, this); + chip::Callback::Callback * onReportTestClusterNullableFloatDoubleCallback = + new chip::Callback::Callback(OnDoubleAttributeResponse, this); chip::Callback::Callback * onReportTestClusterNullableOctetStringCallback = new chip::Callback::Callback(OnOctetStringAttributeResponse, this); chip::Callback::Callback * onReportTestClusterNullableCharStringCallback = diff --git a/zzz_generated/chip-tool/zap-generated/test/Commands.h b/zzz_generated/chip-tool/zap-generated/test/Commands.h index 4dc3e7f81dd9c1..928ed6f5b590db 100644 --- a/zzz_generated/chip-tool/zap-generated/test/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/test/Commands.h @@ -21,6 +21,7 @@ #include #include +#include // For INFINITY class TestList : public Command { @@ -32546,731 +32547,883 @@ class TestCluster : public TestCommand err = TestReadAttributeInt64sDefaultValue_78(); break; case 79: - ChipLogProgress(chipTool, " ***** Test Step 79 : Read attribute ENUM8 Default Value\n"); - err = TestReadAttributeEnum8DefaultValue_79(); + ChipLogProgress(chipTool, " ***** Test Step 79 : Read attribute SINGLE Default Value\n"); + err = TestReadAttributeSingleDefaultValue_79(); break; case 80: - ChipLogProgress(chipTool, " ***** Test Step 80 : Write attribute ENUM8 Max Value\n"); - err = TestWriteAttributeEnum8MaxValue_80(); + ChipLogProgress(chipTool, " ***** Test Step 80 : Write attribute SINGLE medium Value\n"); + err = TestWriteAttributeSingleMediumValue_80(); break; case 81: - ChipLogProgress(chipTool, " ***** Test Step 81 : Read attribute ENUM8 Max Value\n"); - err = TestReadAttributeEnum8MaxValue_81(); + ChipLogProgress(chipTool, " ***** Test Step 81 : Read attribute SINGLE medium Value\n"); + err = TestReadAttributeSingleMediumValue_81(); break; case 82: - ChipLogProgress(chipTool, " ***** Test Step 82 : Write attribute ENUM8 Min Value\n"); - err = TestWriteAttributeEnum8MinValue_82(); + ChipLogProgress(chipTool, " ***** Test Step 82 : Write attribute SINGLE large Value\n"); + err = TestWriteAttributeSingleLargeValue_82(); break; case 83: - ChipLogProgress(chipTool, " ***** Test Step 83 : Read attribute ENUM8 Min Value\n"); - err = TestReadAttributeEnum8MinValue_83(); + ChipLogProgress(chipTool, " ***** Test Step 83 : Read attribute SINGLE large Value\n"); + err = TestReadAttributeSingleLargeValue_83(); break; case 84: - ChipLogProgress(chipTool, " ***** Test Step 84 : Read attribute ENUM16 Default Value\n"); - err = TestReadAttributeEnum16DefaultValue_84(); + ChipLogProgress(chipTool, " ***** Test Step 84 : Write attribute SINGLE small Value\n"); + err = TestWriteAttributeSingleSmallValue_84(); break; case 85: - ChipLogProgress(chipTool, " ***** Test Step 85 : Write attribute ENUM16 Max Value\n"); - err = TestWriteAttributeEnum16MaxValue_85(); + ChipLogProgress(chipTool, " ***** Test Step 85 : Read attribute SINGLE small Value\n"); + err = TestReadAttributeSingleSmallValue_85(); break; case 86: - ChipLogProgress(chipTool, " ***** Test Step 86 : Read attribute ENUM16 Max Value\n"); - err = TestReadAttributeEnum16MaxValue_86(); + ChipLogProgress(chipTool, " ***** Test Step 86 : Write attribute SINGLE Default Value\n"); + err = TestWriteAttributeSingleDefaultValue_86(); break; case 87: - ChipLogProgress(chipTool, " ***** Test Step 87 : Write attribute ENUM16 Min Value\n"); - err = TestWriteAttributeEnum16MinValue_87(); + ChipLogProgress(chipTool, " ***** Test Step 87 : Read attribute SINGLE Default Value\n"); + err = TestReadAttributeSingleDefaultValue_87(); break; case 88: - ChipLogProgress(chipTool, " ***** Test Step 88 : Read attribute ENUM16 Min Value\n"); - err = TestReadAttributeEnum16MinValue_88(); + ChipLogProgress(chipTool, " ***** Test Step 88 : Read attribute DOUBLE Default Value\n"); + err = TestReadAttributeDoubleDefaultValue_88(); break; case 89: - ChipLogProgress(chipTool, " ***** Test Step 89 : Read attribute OCTET_STRING Default Value\n"); - err = TestReadAttributeOctetStringDefaultValue_89(); + ChipLogProgress(chipTool, " ***** Test Step 89 : Write attribute DOUBLE medium Value\n"); + err = TestWriteAttributeDoubleMediumValue_89(); break; case 90: - ChipLogProgress(chipTool, " ***** Test Step 90 : Write attribute OCTET_STRING with embedded null\n"); - err = TestWriteAttributeOctetStringWithEmbeddedNull_90(); + ChipLogProgress(chipTool, " ***** Test Step 90 : Read attribute DOUBLE medium Value\n"); + err = TestReadAttributeDoubleMediumValue_90(); break; case 91: - ChipLogProgress(chipTool, " ***** Test Step 91 : Read attribute OCTET_STRING with embedded null\n"); - err = TestReadAttributeOctetStringWithEmbeddedNull_91(); + ChipLogProgress(chipTool, " ***** Test Step 91 : Write attribute DOUBLE large Value\n"); + err = TestWriteAttributeDoubleLargeValue_91(); break; case 92: - ChipLogProgress(chipTool, " ***** Test Step 92 : Write attribute OCTET_STRING\n"); - err = TestWriteAttributeOctetString_92(); + ChipLogProgress(chipTool, " ***** Test Step 92 : Read attribute DOUBLE large Value\n"); + err = TestReadAttributeDoubleLargeValue_92(); break; case 93: - ChipLogProgress(chipTool, " ***** Test Step 93 : Read attribute OCTET_STRING\n"); - err = TestReadAttributeOctetString_93(); + ChipLogProgress(chipTool, " ***** Test Step 93 : Write attribute DOUBLE small Value\n"); + err = TestWriteAttributeDoubleSmallValue_93(); break; case 94: - ChipLogProgress(chipTool, " ***** Test Step 94 : Write attribute OCTET_STRING\n"); - err = TestWriteAttributeOctetString_94(); + ChipLogProgress(chipTool, " ***** Test Step 94 : Read attribute DOUBLE small Value\n"); + err = TestReadAttributeDoubleSmallValue_94(); break; case 95: - ChipLogProgress(chipTool, " ***** Test Step 95 : Read attribute OCTET_STRING\n"); - err = TestReadAttributeOctetString_95(); + ChipLogProgress(chipTool, " ***** Test Step 95 : Write attribute DOUBLE Default Value\n"); + err = TestWriteAttributeDoubleDefaultValue_95(); break; case 96: - ChipLogProgress(chipTool, " ***** Test Step 96 : Write attribute OCTET_STRING\n"); - err = TestWriteAttributeOctetString_96(); + ChipLogProgress(chipTool, " ***** Test Step 96 : Read attribute DOUBLE Default Value\n"); + err = TestReadAttributeDoubleDefaultValue_96(); break; case 97: - ChipLogProgress(chipTool, " ***** Test Step 97 : Read attribute LONG_OCTET_STRING Default Value\n"); - err = TestReadAttributeLongOctetStringDefaultValue_97(); + ChipLogProgress(chipTool, " ***** Test Step 97 : Read attribute ENUM8 Default Value\n"); + err = TestReadAttributeEnum8DefaultValue_97(); break; case 98: - ChipLogProgress(chipTool, " ***** Test Step 98 : Write attribute LONG_OCTET_STRING\n"); - err = TestWriteAttributeLongOctetString_98(); + ChipLogProgress(chipTool, " ***** Test Step 98 : Write attribute ENUM8 Max Value\n"); + err = TestWriteAttributeEnum8MaxValue_98(); break; case 99: - ChipLogProgress(chipTool, " ***** Test Step 99 : Read attribute LONG_OCTET_STRING\n"); - err = TestReadAttributeLongOctetString_99(); + ChipLogProgress(chipTool, " ***** Test Step 99 : Read attribute ENUM8 Max Value\n"); + err = TestReadAttributeEnum8MaxValue_99(); break; case 100: - ChipLogProgress(chipTool, " ***** Test Step 100 : Write attribute LONG_OCTET_STRING\n"); - err = TestWriteAttributeLongOctetString_100(); + ChipLogProgress(chipTool, " ***** Test Step 100 : Write attribute ENUM8 Min Value\n"); + err = TestWriteAttributeEnum8MinValue_100(); break; case 101: - ChipLogProgress(chipTool, " ***** Test Step 101 : Read attribute CHAR_STRING Default Value\n"); - err = TestReadAttributeCharStringDefaultValue_101(); + ChipLogProgress(chipTool, " ***** Test Step 101 : Read attribute ENUM8 Min Value\n"); + err = TestReadAttributeEnum8MinValue_101(); break; case 102: - ChipLogProgress(chipTool, " ***** Test Step 102 : Write attribute CHAR_STRING\n"); - err = TestWriteAttributeCharString_102(); + ChipLogProgress(chipTool, " ***** Test Step 102 : Read attribute ENUM16 Default Value\n"); + err = TestReadAttributeEnum16DefaultValue_102(); break; case 103: - ChipLogProgress(chipTool, " ***** Test Step 103 : Read attribute CHAR_STRING\n"); - err = TestReadAttributeCharString_103(); + ChipLogProgress(chipTool, " ***** Test Step 103 : Write attribute ENUM16 Max Value\n"); + err = TestWriteAttributeEnum16MaxValue_103(); break; case 104: - ChipLogProgress(chipTool, " ***** Test Step 104 : Write attribute CHAR_STRING - Value too long\n"); - err = TestWriteAttributeCharStringValueTooLong_104(); + ChipLogProgress(chipTool, " ***** Test Step 104 : Read attribute ENUM16 Max Value\n"); + err = TestReadAttributeEnum16MaxValue_104(); break; case 105: - ChipLogProgress(chipTool, " ***** Test Step 105 : Read attribute CHAR_STRING\n"); - err = TestReadAttributeCharString_105(); + ChipLogProgress(chipTool, " ***** Test Step 105 : Write attribute ENUM16 Min Value\n"); + err = TestWriteAttributeEnum16MinValue_105(); break; case 106: - ChipLogProgress(chipTool, " ***** Test Step 106 : Write attribute CHAR_STRING - Empty\n"); - err = TestWriteAttributeCharStringEmpty_106(); + ChipLogProgress(chipTool, " ***** Test Step 106 : Read attribute ENUM16 Min Value\n"); + err = TestReadAttributeEnum16MinValue_106(); break; case 107: - ChipLogProgress(chipTool, " ***** Test Step 107 : Read attribute LONG_CHAR_STRING Default Value\n"); - err = TestReadAttributeLongCharStringDefaultValue_107(); + ChipLogProgress(chipTool, " ***** Test Step 107 : Read attribute OCTET_STRING Default Value\n"); + err = TestReadAttributeOctetStringDefaultValue_107(); break; case 108: - ChipLogProgress(chipTool, " ***** Test Step 108 : Write attribute LONG_CHAR_STRING\n"); - err = TestWriteAttributeLongCharString_108(); + ChipLogProgress(chipTool, " ***** Test Step 108 : Write attribute OCTET_STRING with embedded null\n"); + err = TestWriteAttributeOctetStringWithEmbeddedNull_108(); break; case 109: - ChipLogProgress(chipTool, " ***** Test Step 109 : Read attribute LONG_CHAR_STRING\n"); - err = TestReadAttributeLongCharString_109(); + ChipLogProgress(chipTool, " ***** Test Step 109 : Read attribute OCTET_STRING with embedded null\n"); + err = TestReadAttributeOctetStringWithEmbeddedNull_109(); break; case 110: - ChipLogProgress(chipTool, " ***** Test Step 110 : Write attribute LONG_CHAR_STRING\n"); - err = TestWriteAttributeLongCharString_110(); + ChipLogProgress(chipTool, " ***** Test Step 110 : Write attribute OCTET_STRING\n"); + err = TestWriteAttributeOctetString_110(); break; case 111: - ChipLogProgress(chipTool, " ***** Test Step 111 : Read attribute EPOCH_US Default Value\n"); - err = TestReadAttributeEpochUsDefaultValue_111(); + ChipLogProgress(chipTool, " ***** Test Step 111 : Read attribute OCTET_STRING\n"); + err = TestReadAttributeOctetString_111(); break; case 112: - ChipLogProgress(chipTool, " ***** Test Step 112 : Write attribute EPOCH_US Max Value\n"); - err = TestWriteAttributeEpochUsMaxValue_112(); + ChipLogProgress(chipTool, " ***** Test Step 112 : Write attribute OCTET_STRING\n"); + err = TestWriteAttributeOctetString_112(); break; case 113: - ChipLogProgress(chipTool, " ***** Test Step 113 : Read attribute EPOCH_US Max Value\n"); - err = TestReadAttributeEpochUsMaxValue_113(); + ChipLogProgress(chipTool, " ***** Test Step 113 : Read attribute OCTET_STRING\n"); + err = TestReadAttributeOctetString_113(); break; case 114: - ChipLogProgress(chipTool, " ***** Test Step 114 : Write attribute EPOCH_US Min Value\n"); - err = TestWriteAttributeEpochUsMinValue_114(); + ChipLogProgress(chipTool, " ***** Test Step 114 : Write attribute OCTET_STRING\n"); + err = TestWriteAttributeOctetString_114(); break; case 115: - ChipLogProgress(chipTool, " ***** Test Step 115 : Read attribute EPOCH_US Min Value\n"); - err = TestReadAttributeEpochUsMinValue_115(); + ChipLogProgress(chipTool, " ***** Test Step 115 : Read attribute LONG_OCTET_STRING Default Value\n"); + err = TestReadAttributeLongOctetStringDefaultValue_115(); break; case 116: - ChipLogProgress(chipTool, " ***** Test Step 116 : Read attribute EPOCH_S Default Value\n"); - err = TestReadAttributeEpochSDefaultValue_116(); + ChipLogProgress(chipTool, " ***** Test Step 116 : Write attribute LONG_OCTET_STRING\n"); + err = TestWriteAttributeLongOctetString_116(); break; case 117: - ChipLogProgress(chipTool, " ***** Test Step 117 : Write attribute EPOCH_S Max Value\n"); - err = TestWriteAttributeEpochSMaxValue_117(); + ChipLogProgress(chipTool, " ***** Test Step 117 : Read attribute LONG_OCTET_STRING\n"); + err = TestReadAttributeLongOctetString_117(); break; case 118: - ChipLogProgress(chipTool, " ***** Test Step 118 : Read attribute EPOCH_S Max Value\n"); - err = TestReadAttributeEpochSMaxValue_118(); + ChipLogProgress(chipTool, " ***** Test Step 118 : Write attribute LONG_OCTET_STRING\n"); + err = TestWriteAttributeLongOctetString_118(); break; case 119: - ChipLogProgress(chipTool, " ***** Test Step 119 : Write attribute EPOCH_S Min Value\n"); - err = TestWriteAttributeEpochSMinValue_119(); + ChipLogProgress(chipTool, " ***** Test Step 119 : Read attribute CHAR_STRING Default Value\n"); + err = TestReadAttributeCharStringDefaultValue_119(); break; case 120: - ChipLogProgress(chipTool, " ***** Test Step 120 : Read attribute EPOCH_S Min Value\n"); - err = TestReadAttributeEpochSMinValue_120(); + ChipLogProgress(chipTool, " ***** Test Step 120 : Write attribute CHAR_STRING\n"); + err = TestWriteAttributeCharString_120(); break; case 121: - ChipLogProgress(chipTool, " ***** Test Step 121 : Read attribute UNSUPPORTED\n"); - err = TestReadAttributeUnsupported_121(); + ChipLogProgress(chipTool, " ***** Test Step 121 : Read attribute CHAR_STRING\n"); + err = TestReadAttributeCharString_121(); break; case 122: - ChipLogProgress(chipTool, " ***** Test Step 122 : Writeattribute UNSUPPORTED\n"); - err = TestWriteattributeUnsupported_122(); + ChipLogProgress(chipTool, " ***** Test Step 122 : Write attribute CHAR_STRING - Value too long\n"); + err = TestWriteAttributeCharStringValueTooLong_122(); break; case 123: - ChipLogProgress(chipTool, " ***** Test Step 123 : Send Test Command to unsupported endpoint\n"); - err = TestSendTestCommandToUnsupportedEndpoint_123(); + ChipLogProgress(chipTool, " ***** Test Step 123 : Read attribute CHAR_STRING\n"); + err = TestReadAttributeCharString_123(); break; case 124: - ChipLogProgress(chipTool, " ***** Test Step 124 : Send Test Command to unsupported cluster\n"); - err = TestSendTestCommandToUnsupportedCluster_124(); + ChipLogProgress(chipTool, " ***** Test Step 124 : Write attribute CHAR_STRING - Empty\n"); + err = TestWriteAttributeCharStringEmpty_124(); break; case 125: - ChipLogProgress(chipTool, " ***** Test Step 125 : Read attribute vendor_id Default Value\n"); - err = TestReadAttributeVendorIdDefaultValue_125(); + ChipLogProgress(chipTool, " ***** Test Step 125 : Read attribute LONG_CHAR_STRING Default Value\n"); + err = TestReadAttributeLongCharStringDefaultValue_125(); break; case 126: - ChipLogProgress(chipTool, " ***** Test Step 126 : Write attribute vendor_id\n"); - err = TestWriteAttributeVendorId_126(); + ChipLogProgress(chipTool, " ***** Test Step 126 : Write attribute LONG_CHAR_STRING\n"); + err = TestWriteAttributeLongCharString_126(); break; case 127: - ChipLogProgress(chipTool, " ***** Test Step 127 : Read attribute vendor_id\n"); - err = TestReadAttributeVendorId_127(); + ChipLogProgress(chipTool, " ***** Test Step 127 : Read attribute LONG_CHAR_STRING\n"); + err = TestReadAttributeLongCharString_127(); break; case 128: - ChipLogProgress(chipTool, " ***** Test Step 128 : Restore attribute vendor_id\n"); - err = TestRestoreAttributeVendorId_128(); + ChipLogProgress(chipTool, " ***** Test Step 128 : Write attribute LONG_CHAR_STRING\n"); + err = TestWriteAttributeLongCharString_128(); break; case 129: - ChipLogProgress(chipTool, " ***** Test Step 129 : Send a command with a vendor_id and enum\n"); - err = TestSendACommandWithAVendorIdAndEnum_129(); + ChipLogProgress(chipTool, " ***** Test Step 129 : Read attribute EPOCH_US Default Value\n"); + err = TestReadAttributeEpochUsDefaultValue_129(); break; case 130: - ChipLogProgress(chipTool, " ***** Test Step 130 : Send Test Command With Struct Argument and arg1.b is true\n"); - err = TestSendTestCommandWithStructArgumentAndArg1bIsTrue_130(); + ChipLogProgress(chipTool, " ***** Test Step 130 : Write attribute EPOCH_US Max Value\n"); + err = TestWriteAttributeEpochUsMaxValue_130(); break; case 131: - ChipLogProgress(chipTool, " ***** Test Step 131 : Send Test Command With Struct Argument and arg1.b is false\n"); - err = TestSendTestCommandWithStructArgumentAndArg1bIsFalse_131(); + ChipLogProgress(chipTool, " ***** Test Step 131 : Read attribute EPOCH_US Max Value\n"); + err = TestReadAttributeEpochUsMaxValue_131(); break; case 132: - ChipLogProgress(chipTool, - " ***** Test Step 132 : Send Test Command With Nested Struct Argument and arg1.c.b is true\n"); - err = TestSendTestCommandWithNestedStructArgumentAndArg1cbIsTrue_132(); + ChipLogProgress(chipTool, " ***** Test Step 132 : Write attribute EPOCH_US Min Value\n"); + err = TestWriteAttributeEpochUsMinValue_132(); break; case 133: - ChipLogProgress(chipTool, " ***** Test Step 133 : Send Test Command With Nested Struct Argument arg1.c.b is false\n"); - err = TestSendTestCommandWithNestedStructArgumentArg1cbIsFalse_133(); + ChipLogProgress(chipTool, " ***** Test Step 133 : Read attribute EPOCH_US Min Value\n"); + err = TestReadAttributeEpochUsMinValue_133(); break; case 134: - ChipLogProgress( - chipTool, - " ***** Test Step 134 : Send Test Command With Nested Struct List Argument and all fields b of arg1.d are true\n"); - err = TestSendTestCommandWithNestedStructListArgumentAndAllFieldsBOfArg1dAreTrue_134(); + ChipLogProgress(chipTool, " ***** Test Step 134 : Read attribute EPOCH_S Default Value\n"); + err = TestReadAttributeEpochSDefaultValue_134(); break; case 135: - ChipLogProgress(chipTool, - " ***** Test Step 135 : Send Test Command With Nested Struct List Argument and some fields b of arg1.d " - "are false\n"); - err = TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfArg1dAreFalse_135(); + ChipLogProgress(chipTool, " ***** Test Step 135 : Write attribute EPOCH_S Max Value\n"); + err = TestWriteAttributeEpochSMaxValue_135(); break; case 136: - ChipLogProgress(chipTool, " ***** Test Step 136 : Send Test Command With Struct Argument and see what we get back\n"); - err = TestSendTestCommandWithStructArgumentAndSeeWhatWeGetBack_136(); + ChipLogProgress(chipTool, " ***** Test Step 136 : Read attribute EPOCH_S Max Value\n"); + err = TestReadAttributeEpochSMaxValue_136(); break; case 137: - ChipLogProgress(chipTool, " ***** Test Step 137 : Send Test Command With List of INT8U and none of them is set to 0\n"); - err = TestSendTestCommandWithListOfInt8uAndNoneOfThemIsSetTo0_137(); + ChipLogProgress(chipTool, " ***** Test Step 137 : Write attribute EPOCH_S Min Value\n"); + err = TestWriteAttributeEpochSMinValue_137(); break; case 138: - ChipLogProgress(chipTool, " ***** Test Step 138 : Send Test Command With List of INT8U and one of them is set to 0\n"); - err = TestSendTestCommandWithListOfInt8uAndOneOfThemIsSetTo0_138(); + ChipLogProgress(chipTool, " ***** Test Step 138 : Read attribute EPOCH_S Min Value\n"); + err = TestReadAttributeEpochSMinValue_138(); break; case 139: - ChipLogProgress(chipTool, " ***** Test Step 139 : Send Test Command With List of INT8U and get it reversed\n"); - err = TestSendTestCommandWithListOfInt8uAndGetItReversed_139(); + ChipLogProgress(chipTool, " ***** Test Step 139 : Read attribute UNSUPPORTED\n"); + err = TestReadAttributeUnsupported_139(); break; case 140: - ChipLogProgress(chipTool, - " ***** Test Step 140 : Send Test Command With empty List of INT8U and get an empty list back\n"); - err = TestSendTestCommandWithEmptyListOfInt8uAndGetAnEmptyListBack_140(); + ChipLogProgress(chipTool, " ***** Test Step 140 : Writeattribute UNSUPPORTED\n"); + err = TestWriteattributeUnsupported_140(); break; case 141: - ChipLogProgress( - chipTool, - " ***** Test Step 141 : Send Test Command With List of Struct Argument and arg1.b of first item is true\n"); - err = TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsTrue_141(); + ChipLogProgress(chipTool, " ***** Test Step 141 : Send Test Command to unsupported endpoint\n"); + err = TestSendTestCommandToUnsupportedEndpoint_141(); break; case 142: - ChipLogProgress( - chipTool, - " ***** Test Step 142 : Send Test Command With List of Struct Argument and arg1.b of first item is false\n"); - err = TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsFalse_142(); + ChipLogProgress(chipTool, " ***** Test Step 142 : Send Test Command to unsupported cluster\n"); + err = TestSendTestCommandToUnsupportedCluster_142(); break; case 143: - ChipLogProgress(chipTool, - " ***** Test Step 143 : Send Test Command With List of Nested Struct List Argument and all fields b of " - "elements of arg1.d are true\n"); - err = TestSendTestCommandWithListOfNestedStructListArgumentAndAllFieldsBOfElementsOfArg1dAreTrue_143(); + ChipLogProgress(chipTool, " ***** Test Step 143 : Read attribute vendor_id Default Value\n"); + err = TestReadAttributeVendorIdDefaultValue_143(); break; case 144: - ChipLogProgress(chipTool, - " ***** Test Step 144 : Send Test Command With Nested Struct List Argument and some fields b of " - "elements of arg1.d are false\n"); - err = TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfElementsOfArg1dAreFalse_144(); + ChipLogProgress(chipTool, " ***** Test Step 144 : Write attribute vendor_id\n"); + err = TestWriteAttributeVendorId_144(); break; case 145: - ChipLogProgress(chipTool, - " ***** Test Step 145 : Write attribute LIST With List of INT8U and none of them is set to 0\n"); - err = TestWriteAttributeListWithListOfInt8uAndNoneOfThemIsSetTo0_145(); + ChipLogProgress(chipTool, " ***** Test Step 145 : Read attribute vendor_id\n"); + err = TestReadAttributeVendorId_145(); break; case 146: - ChipLogProgress(chipTool, " ***** Test Step 146 : Read attribute LIST With List of INT8U\n"); - err = TestReadAttributeListWithListOfInt8u_146(); + ChipLogProgress(chipTool, " ***** Test Step 146 : Restore attribute vendor_id\n"); + err = TestRestoreAttributeVendorId_146(); break; case 147: - ChipLogProgress(chipTool, " ***** Test Step 147 : Write attribute LIST With List of OCTET_STRING\n"); - err = TestWriteAttributeListWithListOfOctetString_147(); + ChipLogProgress(chipTool, " ***** Test Step 147 : Send a command with a vendor_id and enum\n"); + err = TestSendACommandWithAVendorIdAndEnum_147(); break; case 148: - ChipLogProgress(chipTool, " ***** Test Step 148 : Read attribute LIST With List of OCTET_STRING\n"); - err = TestReadAttributeListWithListOfOctetString_148(); + ChipLogProgress(chipTool, " ***** Test Step 148 : Send Test Command With Struct Argument and arg1.b is true\n"); + err = TestSendTestCommandWithStructArgumentAndArg1bIsTrue_148(); break; case 149: - ChipLogProgress(chipTool, " ***** Test Step 149 : Write attribute LIST With List of LIST_STRUCT_OCTET_STRING\n"); - err = TestWriteAttributeListWithListOfListStructOctetString_149(); + ChipLogProgress(chipTool, " ***** Test Step 149 : Send Test Command With Struct Argument and arg1.b is false\n"); + err = TestSendTestCommandWithStructArgumentAndArg1bIsFalse_149(); break; case 150: - ChipLogProgress(chipTool, " ***** Test Step 150 : Read attribute LIST With List of LIST_STRUCT_OCTET_STRING\n"); - err = TestReadAttributeListWithListOfListStructOctetString_150(); + ChipLogProgress(chipTool, + " ***** Test Step 150 : Send Test Command With Nested Struct Argument and arg1.c.b is true\n"); + err = TestSendTestCommandWithNestedStructArgumentAndArg1cbIsTrue_150(); break; case 151: - ChipLogProgress(chipTool, " ***** Test Step 151 : Send Test Command with optional arg set.\n"); - err = TestSendTestCommandWithOptionalArgSet_151(); + ChipLogProgress(chipTool, " ***** Test Step 151 : Send Test Command With Nested Struct Argument arg1.c.b is false\n"); + err = TestSendTestCommandWithNestedStructArgumentArg1cbIsFalse_151(); break; case 152: - ChipLogProgress(chipTool, " ***** Test Step 152 : Send Test Command without its optional arg.\n"); - err = TestSendTestCommandWithoutItsOptionalArg_152(); + ChipLogProgress( + chipTool, + " ***** Test Step 152 : Send Test Command With Nested Struct List Argument and all fields b of arg1.d are true\n"); + err = TestSendTestCommandWithNestedStructListArgumentAndAllFieldsBOfArg1dAreTrue_152(); break; case 153: - ChipLogProgress(chipTool, " ***** Test Step 153 : Write attribute NULLABLE_BOOLEAN null\n"); - err = TestWriteAttributeNullableBooleanNull_153(); + ChipLogProgress(chipTool, + " ***** Test Step 153 : Send Test Command With Nested Struct List Argument and some fields b of arg1.d " + "are false\n"); + err = TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfArg1dAreFalse_153(); break; case 154: - ChipLogProgress(chipTool, " ***** Test Step 154 : Read attribute NULLABLE_BOOLEAN null\n"); - err = TestReadAttributeNullableBooleanNull_154(); + ChipLogProgress(chipTool, " ***** Test Step 154 : Send Test Command With Struct Argument and see what we get back\n"); + err = TestSendTestCommandWithStructArgumentAndSeeWhatWeGetBack_154(); break; case 155: - ChipLogProgress(chipTool, " ***** Test Step 155 : Write attribute NULLABLE_BOOLEAN True\n"); - err = TestWriteAttributeNullableBooleanTrue_155(); + ChipLogProgress(chipTool, " ***** Test Step 155 : Send Test Command With List of INT8U and none of them is set to 0\n"); + err = TestSendTestCommandWithListOfInt8uAndNoneOfThemIsSetTo0_155(); break; case 156: - ChipLogProgress(chipTool, " ***** Test Step 156 : Read attribute NULLABLE_BOOLEAN True\n"); - err = TestReadAttributeNullableBooleanTrue_156(); + ChipLogProgress(chipTool, " ***** Test Step 156 : Send Test Command With List of INT8U and one of them is set to 0\n"); + err = TestSendTestCommandWithListOfInt8uAndOneOfThemIsSetTo0_156(); break; case 157: - ChipLogProgress(chipTool, " ***** Test Step 157 : Write attribute NULLABLE_BITMAP8 Max Value\n"); - err = TestWriteAttributeNullableBitmap8MaxValue_157(); + ChipLogProgress(chipTool, " ***** Test Step 157 : Send Test Command With List of INT8U and get it reversed\n"); + err = TestSendTestCommandWithListOfInt8uAndGetItReversed_157(); break; case 158: - ChipLogProgress(chipTool, " ***** Test Step 158 : Read attribute NULLABLE_BITMAP8 Max Value\n"); - err = TestReadAttributeNullableBitmap8MaxValue_158(); + ChipLogProgress(chipTool, + " ***** Test Step 158 : Send Test Command With empty List of INT8U and get an empty list back\n"); + err = TestSendTestCommandWithEmptyListOfInt8uAndGetAnEmptyListBack_158(); break; case 159: - ChipLogProgress(chipTool, " ***** Test Step 159 : Write attribute NULLABLE_BITMAP8 Invalid Value\n"); - err = TestWriteAttributeNullableBitmap8InvalidValue_159(); + ChipLogProgress( + chipTool, + " ***** Test Step 159 : Send Test Command With List of Struct Argument and arg1.b of first item is true\n"); + err = TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsTrue_159(); break; case 160: - ChipLogProgress(chipTool, " ***** Test Step 160 : Read attribute NULLABLE_BITMAP8 unchanged Value\n"); - err = TestReadAttributeNullableBitmap8UnchangedValue_160(); + ChipLogProgress( + chipTool, + " ***** Test Step 160 : Send Test Command With List of Struct Argument and arg1.b of first item is false\n"); + err = TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsFalse_160(); break; case 161: - ChipLogProgress(chipTool, " ***** Test Step 161 : Write attribute NULLABLE_BITMAP8 null Value\n"); - err = TestWriteAttributeNullableBitmap8NullValue_161(); + ChipLogProgress(chipTool, + " ***** Test Step 161 : Send Test Command With List of Nested Struct List Argument and all fields b of " + "elements of arg1.d are true\n"); + err = TestSendTestCommandWithListOfNestedStructListArgumentAndAllFieldsBOfElementsOfArg1dAreTrue_161(); break; case 162: - ChipLogProgress(chipTool, " ***** Test Step 162 : Read attribute NULLABLE_BITMAP8 null Value\n"); - err = TestReadAttributeNullableBitmap8NullValue_162(); + ChipLogProgress(chipTool, + " ***** Test Step 162 : Send Test Command With Nested Struct List Argument and some fields b of " + "elements of arg1.d are false\n"); + err = TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfElementsOfArg1dAreFalse_162(); break; case 163: - ChipLogProgress(chipTool, " ***** Test Step 163 : Write attribute NULLABLE_BITMAP16 Max Value\n"); - err = TestWriteAttributeNullableBitmap16MaxValue_163(); + ChipLogProgress(chipTool, + " ***** Test Step 163 : Write attribute LIST With List of INT8U and none of them is set to 0\n"); + err = TestWriteAttributeListWithListOfInt8uAndNoneOfThemIsSetTo0_163(); break; case 164: - ChipLogProgress(chipTool, " ***** Test Step 164 : Read attribute NULLABLE_BITMAP16 Max Value\n"); - err = TestReadAttributeNullableBitmap16MaxValue_164(); + ChipLogProgress(chipTool, " ***** Test Step 164 : Read attribute LIST With List of INT8U\n"); + err = TestReadAttributeListWithListOfInt8u_164(); break; case 165: - ChipLogProgress(chipTool, " ***** Test Step 165 : Write attribute NULLABLE_BITMAP16 Invalid Value\n"); - err = TestWriteAttributeNullableBitmap16InvalidValue_165(); + ChipLogProgress(chipTool, " ***** Test Step 165 : Write attribute LIST With List of OCTET_STRING\n"); + err = TestWriteAttributeListWithListOfOctetString_165(); break; case 166: - ChipLogProgress(chipTool, " ***** Test Step 166 : Read attribute NULLABLE_BITMAP16 unchanged Value\n"); - err = TestReadAttributeNullableBitmap16UnchangedValue_166(); + ChipLogProgress(chipTool, " ***** Test Step 166 : Read attribute LIST With List of OCTET_STRING\n"); + err = TestReadAttributeListWithListOfOctetString_166(); break; case 167: - ChipLogProgress(chipTool, " ***** Test Step 167 : Write attribute NULLABLE_BITMAP16 null Value\n"); - err = TestWriteAttributeNullableBitmap16NullValue_167(); + ChipLogProgress(chipTool, " ***** Test Step 167 : Write attribute LIST With List of LIST_STRUCT_OCTET_STRING\n"); + err = TestWriteAttributeListWithListOfListStructOctetString_167(); break; case 168: - ChipLogProgress(chipTool, " ***** Test Step 168 : Read attribute NULLABLE_BITMAP16 null Value\n"); - err = TestReadAttributeNullableBitmap16NullValue_168(); + ChipLogProgress(chipTool, " ***** Test Step 168 : Read attribute LIST With List of LIST_STRUCT_OCTET_STRING\n"); + err = TestReadAttributeListWithListOfListStructOctetString_168(); break; case 169: - ChipLogProgress(chipTool, " ***** Test Step 169 : Write attribute NULLABLE_BITMAP32 Max Value\n"); - err = TestWriteAttributeNullableBitmap32MaxValue_169(); + ChipLogProgress(chipTool, " ***** Test Step 169 : Send Test Command with optional arg set.\n"); + err = TestSendTestCommandWithOptionalArgSet_169(); break; case 170: - ChipLogProgress(chipTool, " ***** Test Step 170 : Read attribute NULLABLE_BITMAP32 Max Value\n"); - err = TestReadAttributeNullableBitmap32MaxValue_170(); + ChipLogProgress(chipTool, " ***** Test Step 170 : Send Test Command without its optional arg.\n"); + err = TestSendTestCommandWithoutItsOptionalArg_170(); break; case 171: - ChipLogProgress(chipTool, " ***** Test Step 171 : Write attribute NULLABLE_BITMAP32 Invalid Value\n"); - err = TestWriteAttributeNullableBitmap32InvalidValue_171(); + ChipLogProgress(chipTool, " ***** Test Step 171 : Write attribute NULLABLE_BOOLEAN null\n"); + err = TestWriteAttributeNullableBooleanNull_171(); break; case 172: - ChipLogProgress(chipTool, " ***** Test Step 172 : Read attribute NULLABLE_BITMAP32 unchanged Value\n"); - err = TestReadAttributeNullableBitmap32UnchangedValue_172(); + ChipLogProgress(chipTool, " ***** Test Step 172 : Read attribute NULLABLE_BOOLEAN null\n"); + err = TestReadAttributeNullableBooleanNull_172(); break; case 173: - ChipLogProgress(chipTool, " ***** Test Step 173 : Write attribute NULLABLE_BITMAP32 null Value\n"); - err = TestWriteAttributeNullableBitmap32NullValue_173(); + ChipLogProgress(chipTool, " ***** Test Step 173 : Write attribute NULLABLE_BOOLEAN True\n"); + err = TestWriteAttributeNullableBooleanTrue_173(); break; case 174: - ChipLogProgress(chipTool, " ***** Test Step 174 : Read attribute NULLABLE_BITMAP32 null Value\n"); - err = TestReadAttributeNullableBitmap32NullValue_174(); + ChipLogProgress(chipTool, " ***** Test Step 174 : Read attribute NULLABLE_BOOLEAN True\n"); + err = TestReadAttributeNullableBooleanTrue_174(); break; case 175: - ChipLogProgress(chipTool, " ***** Test Step 175 : Write attribute NULLABLE_BITMAP64 Max Value\n"); - err = TestWriteAttributeNullableBitmap64MaxValue_175(); + ChipLogProgress(chipTool, " ***** Test Step 175 : Write attribute NULLABLE_BITMAP8 Max Value\n"); + err = TestWriteAttributeNullableBitmap8MaxValue_175(); break; case 176: - ChipLogProgress(chipTool, " ***** Test Step 176 : Read attribute NULLABLE_BITMAP64 Max Value\n"); - err = TestReadAttributeNullableBitmap64MaxValue_176(); + ChipLogProgress(chipTool, " ***** Test Step 176 : Read attribute NULLABLE_BITMAP8 Max Value\n"); + err = TestReadAttributeNullableBitmap8MaxValue_176(); break; case 177: - ChipLogProgress(chipTool, " ***** Test Step 177 : Write attribute NULLABLE_BITMAP64 Invalid Value\n"); - err = TestWriteAttributeNullableBitmap64InvalidValue_177(); + ChipLogProgress(chipTool, " ***** Test Step 177 : Write attribute NULLABLE_BITMAP8 Invalid Value\n"); + err = TestWriteAttributeNullableBitmap8InvalidValue_177(); break; case 178: - ChipLogProgress(chipTool, " ***** Test Step 178 : Read attribute NULLABLE_BITMAP64 unchanged Value\n"); - err = TestReadAttributeNullableBitmap64UnchangedValue_178(); + ChipLogProgress(chipTool, " ***** Test Step 178 : Read attribute NULLABLE_BITMAP8 unchanged Value\n"); + err = TestReadAttributeNullableBitmap8UnchangedValue_178(); break; case 179: - ChipLogProgress(chipTool, " ***** Test Step 179 : Write attribute NULLABLE_BITMAP64 null Value\n"); - err = TestWriteAttributeNullableBitmap64NullValue_179(); + ChipLogProgress(chipTool, " ***** Test Step 179 : Write attribute NULLABLE_BITMAP8 null Value\n"); + err = TestWriteAttributeNullableBitmap8NullValue_179(); break; case 180: - ChipLogProgress(chipTool, " ***** Test Step 180 : Read attribute NULLABLE_BITMAP64 null Value\n"); - err = TestReadAttributeNullableBitmap64NullValue_180(); + ChipLogProgress(chipTool, " ***** Test Step 180 : Read attribute NULLABLE_BITMAP8 null Value\n"); + err = TestReadAttributeNullableBitmap8NullValue_180(); break; case 181: - ChipLogProgress(chipTool, " ***** Test Step 181 : Write attribute NULLABLE_INT8U Max Value\n"); - err = TestWriteAttributeNullableInt8uMaxValue_181(); + ChipLogProgress(chipTool, " ***** Test Step 181 : Write attribute NULLABLE_BITMAP16 Max Value\n"); + err = TestWriteAttributeNullableBitmap16MaxValue_181(); break; case 182: - ChipLogProgress(chipTool, " ***** Test Step 182 : Read attribute NULLABLE_INT8U Max Value\n"); - err = TestReadAttributeNullableInt8uMaxValue_182(); + ChipLogProgress(chipTool, " ***** Test Step 182 : Read attribute NULLABLE_BITMAP16 Max Value\n"); + err = TestReadAttributeNullableBitmap16MaxValue_182(); break; case 183: - ChipLogProgress(chipTool, " ***** Test Step 183 : Write attribute NULLABLE_INT8U Invalid Value\n"); - err = TestWriteAttributeNullableInt8uInvalidValue_183(); + ChipLogProgress(chipTool, " ***** Test Step 183 : Write attribute NULLABLE_BITMAP16 Invalid Value\n"); + err = TestWriteAttributeNullableBitmap16InvalidValue_183(); break; case 184: - ChipLogProgress(chipTool, " ***** Test Step 184 : Read attribute NULLABLE_INT8U unchanged Value\n"); - err = TestReadAttributeNullableInt8uUnchangedValue_184(); + ChipLogProgress(chipTool, " ***** Test Step 184 : Read attribute NULLABLE_BITMAP16 unchanged Value\n"); + err = TestReadAttributeNullableBitmap16UnchangedValue_184(); break; case 185: - ChipLogProgress(chipTool, " ***** Test Step 185 : Write attribute NULLABLE_INT8U null Value\n"); - err = TestWriteAttributeNullableInt8uNullValue_185(); + ChipLogProgress(chipTool, " ***** Test Step 185 : Write attribute NULLABLE_BITMAP16 null Value\n"); + err = TestWriteAttributeNullableBitmap16NullValue_185(); break; case 186: - ChipLogProgress(chipTool, " ***** Test Step 186 : Read attribute NULLABLE_INT8U null Value\n"); - err = TestReadAttributeNullableInt8uNullValue_186(); + ChipLogProgress(chipTool, " ***** Test Step 186 : Read attribute NULLABLE_BITMAP16 null Value\n"); + err = TestReadAttributeNullableBitmap16NullValue_186(); break; case 187: - ChipLogProgress(chipTool, " ***** Test Step 187 : Write attribute NULLABLE_INT16U Max Value\n"); - err = TestWriteAttributeNullableInt16uMaxValue_187(); + ChipLogProgress(chipTool, " ***** Test Step 187 : Write attribute NULLABLE_BITMAP32 Max Value\n"); + err = TestWriteAttributeNullableBitmap32MaxValue_187(); break; case 188: - ChipLogProgress(chipTool, " ***** Test Step 188 : Read attribute NULLABLE_INT16U Max Value\n"); - err = TestReadAttributeNullableInt16uMaxValue_188(); + ChipLogProgress(chipTool, " ***** Test Step 188 : Read attribute NULLABLE_BITMAP32 Max Value\n"); + err = TestReadAttributeNullableBitmap32MaxValue_188(); break; case 189: - ChipLogProgress(chipTool, " ***** Test Step 189 : Write attribute NULLABLE_INT16U Invalid Value\n"); - err = TestWriteAttributeNullableInt16uInvalidValue_189(); + ChipLogProgress(chipTool, " ***** Test Step 189 : Write attribute NULLABLE_BITMAP32 Invalid Value\n"); + err = TestWriteAttributeNullableBitmap32InvalidValue_189(); break; case 190: - ChipLogProgress(chipTool, " ***** Test Step 190 : Read attribute NULLABLE_INT16U unchanged Value\n"); - err = TestReadAttributeNullableInt16uUnchangedValue_190(); + ChipLogProgress(chipTool, " ***** Test Step 190 : Read attribute NULLABLE_BITMAP32 unchanged Value\n"); + err = TestReadAttributeNullableBitmap32UnchangedValue_190(); break; case 191: - ChipLogProgress(chipTool, " ***** Test Step 191 : Write attribute NULLABLE_INT16U null Value\n"); - err = TestWriteAttributeNullableInt16uNullValue_191(); + ChipLogProgress(chipTool, " ***** Test Step 191 : Write attribute NULLABLE_BITMAP32 null Value\n"); + err = TestWriteAttributeNullableBitmap32NullValue_191(); break; case 192: - ChipLogProgress(chipTool, " ***** Test Step 192 : Read attribute NULLABLE_INT16U null Value\n"); - err = TestReadAttributeNullableInt16uNullValue_192(); + ChipLogProgress(chipTool, " ***** Test Step 192 : Read attribute NULLABLE_BITMAP32 null Value\n"); + err = TestReadAttributeNullableBitmap32NullValue_192(); break; case 193: - ChipLogProgress(chipTool, " ***** Test Step 193 : Write attribute NULLABLE_INT32U Max Value\n"); - err = TestWriteAttributeNullableInt32uMaxValue_193(); + ChipLogProgress(chipTool, " ***** Test Step 193 : Write attribute NULLABLE_BITMAP64 Max Value\n"); + err = TestWriteAttributeNullableBitmap64MaxValue_193(); break; case 194: - ChipLogProgress(chipTool, " ***** Test Step 194 : Read attribute NULLABLE_INT32U Max Value\n"); - err = TestReadAttributeNullableInt32uMaxValue_194(); + ChipLogProgress(chipTool, " ***** Test Step 194 : Read attribute NULLABLE_BITMAP64 Max Value\n"); + err = TestReadAttributeNullableBitmap64MaxValue_194(); break; case 195: - ChipLogProgress(chipTool, " ***** Test Step 195 : Write attribute NULLABLE_INT32U Invalid Value\n"); - err = TestWriteAttributeNullableInt32uInvalidValue_195(); + ChipLogProgress(chipTool, " ***** Test Step 195 : Write attribute NULLABLE_BITMAP64 Invalid Value\n"); + err = TestWriteAttributeNullableBitmap64InvalidValue_195(); break; case 196: - ChipLogProgress(chipTool, " ***** Test Step 196 : Read attribute NULLABLE_INT32U unchanged Value\n"); - err = TestReadAttributeNullableInt32uUnchangedValue_196(); + ChipLogProgress(chipTool, " ***** Test Step 196 : Read attribute NULLABLE_BITMAP64 unchanged Value\n"); + err = TestReadAttributeNullableBitmap64UnchangedValue_196(); break; case 197: - ChipLogProgress(chipTool, " ***** Test Step 197 : Write attribute NULLABLE_INT32U null Value\n"); - err = TestWriteAttributeNullableInt32uNullValue_197(); + ChipLogProgress(chipTool, " ***** Test Step 197 : Write attribute NULLABLE_BITMAP64 null Value\n"); + err = TestWriteAttributeNullableBitmap64NullValue_197(); break; case 198: - ChipLogProgress(chipTool, " ***** Test Step 198 : Read attribute NULLABLE_INT32U null Value\n"); - err = TestReadAttributeNullableInt32uNullValue_198(); + ChipLogProgress(chipTool, " ***** Test Step 198 : Read attribute NULLABLE_BITMAP64 null Value\n"); + err = TestReadAttributeNullableBitmap64NullValue_198(); break; case 199: - ChipLogProgress(chipTool, " ***** Test Step 199 : Write attribute NULLABLE_INT64U Max Value\n"); - err = TestWriteAttributeNullableInt64uMaxValue_199(); + ChipLogProgress(chipTool, " ***** Test Step 199 : Write attribute NULLABLE_INT8U Max Value\n"); + err = TestWriteAttributeNullableInt8uMaxValue_199(); break; case 200: - ChipLogProgress(chipTool, " ***** Test Step 200 : Read attribute NULLABLE_INT64U Max Value\n"); - err = TestReadAttributeNullableInt64uMaxValue_200(); + ChipLogProgress(chipTool, " ***** Test Step 200 : Read attribute NULLABLE_INT8U Max Value\n"); + err = TestReadAttributeNullableInt8uMaxValue_200(); break; case 201: - ChipLogProgress(chipTool, " ***** Test Step 201 : Write attribute NULLABLE_INT64U Invalid Value\n"); - err = TestWriteAttributeNullableInt64uInvalidValue_201(); + ChipLogProgress(chipTool, " ***** Test Step 201 : Write attribute NULLABLE_INT8U Invalid Value\n"); + err = TestWriteAttributeNullableInt8uInvalidValue_201(); break; case 202: - ChipLogProgress(chipTool, " ***** Test Step 202 : Read attribute NULLABLE_INT64U unchanged Value\n"); - err = TestReadAttributeNullableInt64uUnchangedValue_202(); + ChipLogProgress(chipTool, " ***** Test Step 202 : Read attribute NULLABLE_INT8U unchanged Value\n"); + err = TestReadAttributeNullableInt8uUnchangedValue_202(); break; case 203: - ChipLogProgress(chipTool, " ***** Test Step 203 : Write attribute NULLABLE_INT64U null Value\n"); - err = TestWriteAttributeNullableInt64uNullValue_203(); + ChipLogProgress(chipTool, " ***** Test Step 203 : Write attribute NULLABLE_INT8U null Value\n"); + err = TestWriteAttributeNullableInt8uNullValue_203(); break; case 204: - ChipLogProgress(chipTool, " ***** Test Step 204 : Read attribute NULLABLE_INT64U null Value\n"); - err = TestReadAttributeNullableInt64uNullValue_204(); + ChipLogProgress(chipTool, " ***** Test Step 204 : Read attribute NULLABLE_INT8U null Value\n"); + err = TestReadAttributeNullableInt8uNullValue_204(); break; case 205: - ChipLogProgress(chipTool, " ***** Test Step 205 : Write attribute NULLABLE_INT8S Min Value\n"); - err = TestWriteAttributeNullableInt8sMinValue_205(); + ChipLogProgress(chipTool, " ***** Test Step 205 : Write attribute NULLABLE_INT16U Max Value\n"); + err = TestWriteAttributeNullableInt16uMaxValue_205(); break; case 206: - ChipLogProgress(chipTool, " ***** Test Step 206 : Read attribute NULLABLE_INT8S Min Value\n"); - err = TestReadAttributeNullableInt8sMinValue_206(); + ChipLogProgress(chipTool, " ***** Test Step 206 : Read attribute NULLABLE_INT16U Max Value\n"); + err = TestReadAttributeNullableInt16uMaxValue_206(); break; case 207: - ChipLogProgress(chipTool, " ***** Test Step 207 : Write attribute NULLABLE_INT8S Invalid Value\n"); - err = TestWriteAttributeNullableInt8sInvalidValue_207(); + ChipLogProgress(chipTool, " ***** Test Step 207 : Write attribute NULLABLE_INT16U Invalid Value\n"); + err = TestWriteAttributeNullableInt16uInvalidValue_207(); break; case 208: - ChipLogProgress(chipTool, " ***** Test Step 208 : Read attribute NULLABLE_INT8S unchanged Value\n"); - err = TestReadAttributeNullableInt8sUnchangedValue_208(); + ChipLogProgress(chipTool, " ***** Test Step 208 : Read attribute NULLABLE_INT16U unchanged Value\n"); + err = TestReadAttributeNullableInt16uUnchangedValue_208(); break; case 209: - ChipLogProgress(chipTool, " ***** Test Step 209 : Write attribute NULLABLE_INT8S null Value\n"); - err = TestWriteAttributeNullableInt8sNullValue_209(); + ChipLogProgress(chipTool, " ***** Test Step 209 : Write attribute NULLABLE_INT16U null Value\n"); + err = TestWriteAttributeNullableInt16uNullValue_209(); break; case 210: - ChipLogProgress(chipTool, " ***** Test Step 210 : Read attribute NULLABLE_INT8S null Value\n"); - err = TestReadAttributeNullableInt8sNullValue_210(); + ChipLogProgress(chipTool, " ***** Test Step 210 : Read attribute NULLABLE_INT16U null Value\n"); + err = TestReadAttributeNullableInt16uNullValue_210(); break; case 211: - ChipLogProgress(chipTool, " ***** Test Step 211 : Write attribute NULLABLE_INT16S Min Value\n"); - err = TestWriteAttributeNullableInt16sMinValue_211(); + ChipLogProgress(chipTool, " ***** Test Step 211 : Write attribute NULLABLE_INT32U Max Value\n"); + err = TestWriteAttributeNullableInt32uMaxValue_211(); break; case 212: - ChipLogProgress(chipTool, " ***** Test Step 212 : Read attribute NULLABLE_INT16S Min Value\n"); - err = TestReadAttributeNullableInt16sMinValue_212(); + ChipLogProgress(chipTool, " ***** Test Step 212 : Read attribute NULLABLE_INT32U Max Value\n"); + err = TestReadAttributeNullableInt32uMaxValue_212(); break; case 213: - ChipLogProgress(chipTool, " ***** Test Step 213 : Write attribute NULLABLE_INT16S Invalid Value\n"); - err = TestWriteAttributeNullableInt16sInvalidValue_213(); + ChipLogProgress(chipTool, " ***** Test Step 213 : Write attribute NULLABLE_INT32U Invalid Value\n"); + err = TestWriteAttributeNullableInt32uInvalidValue_213(); break; case 214: - ChipLogProgress(chipTool, " ***** Test Step 214 : Read attribute NULLABLE_INT16S unchanged Value\n"); - err = TestReadAttributeNullableInt16sUnchangedValue_214(); + ChipLogProgress(chipTool, " ***** Test Step 214 : Read attribute NULLABLE_INT32U unchanged Value\n"); + err = TestReadAttributeNullableInt32uUnchangedValue_214(); break; case 215: - ChipLogProgress(chipTool, " ***** Test Step 215 : Write attribute NULLABLE_INT16S null Value\n"); - err = TestWriteAttributeNullableInt16sNullValue_215(); + ChipLogProgress(chipTool, " ***** Test Step 215 : Write attribute NULLABLE_INT32U null Value\n"); + err = TestWriteAttributeNullableInt32uNullValue_215(); break; case 216: - ChipLogProgress(chipTool, " ***** Test Step 216 : Read attribute NULLABLE_INT16S null Value\n"); - err = TestReadAttributeNullableInt16sNullValue_216(); + ChipLogProgress(chipTool, " ***** Test Step 216 : Read attribute NULLABLE_INT32U null Value\n"); + err = TestReadAttributeNullableInt32uNullValue_216(); break; case 217: - ChipLogProgress(chipTool, " ***** Test Step 217 : Write attribute NULLABLE_INT32S Min Value\n"); - err = TestWriteAttributeNullableInt32sMinValue_217(); + ChipLogProgress(chipTool, " ***** Test Step 217 : Write attribute NULLABLE_INT64U Max Value\n"); + err = TestWriteAttributeNullableInt64uMaxValue_217(); break; case 218: - ChipLogProgress(chipTool, " ***** Test Step 218 : Read attribute NULLABLE_INT32S Min Value\n"); - err = TestReadAttributeNullableInt32sMinValue_218(); + ChipLogProgress(chipTool, " ***** Test Step 218 : Read attribute NULLABLE_INT64U Max Value\n"); + err = TestReadAttributeNullableInt64uMaxValue_218(); break; case 219: - ChipLogProgress(chipTool, " ***** Test Step 219 : Write attribute NULLABLE_INT32S Invalid Value\n"); - err = TestWriteAttributeNullableInt32sInvalidValue_219(); + ChipLogProgress(chipTool, " ***** Test Step 219 : Write attribute NULLABLE_INT64U Invalid Value\n"); + err = TestWriteAttributeNullableInt64uInvalidValue_219(); break; case 220: - ChipLogProgress(chipTool, " ***** Test Step 220 : Read attribute NULLABLE_INT32S unchanged Value\n"); - err = TestReadAttributeNullableInt32sUnchangedValue_220(); + ChipLogProgress(chipTool, " ***** Test Step 220 : Read attribute NULLABLE_INT64U unchanged Value\n"); + err = TestReadAttributeNullableInt64uUnchangedValue_220(); break; case 221: - ChipLogProgress(chipTool, " ***** Test Step 221 : Write attribute NULLABLE_INT32S null Value\n"); - err = TestWriteAttributeNullableInt32sNullValue_221(); + ChipLogProgress(chipTool, " ***** Test Step 221 : Write attribute NULLABLE_INT64U null Value\n"); + err = TestWriteAttributeNullableInt64uNullValue_221(); break; case 222: - ChipLogProgress(chipTool, " ***** Test Step 222 : Read attribute NULLABLE_INT32S null Value\n"); - err = TestReadAttributeNullableInt32sNullValue_222(); + ChipLogProgress(chipTool, " ***** Test Step 222 : Read attribute NULLABLE_INT64U null Value\n"); + err = TestReadAttributeNullableInt64uNullValue_222(); break; case 223: - ChipLogProgress(chipTool, " ***** Test Step 223 : Write attribute NULLABLE_INT64S Min Value\n"); - err = TestWriteAttributeNullableInt64sMinValue_223(); + ChipLogProgress(chipTool, " ***** Test Step 223 : Write attribute NULLABLE_INT8S Min Value\n"); + err = TestWriteAttributeNullableInt8sMinValue_223(); break; case 224: - ChipLogProgress(chipTool, " ***** Test Step 224 : Read attribute NULLABLE_INT64S Min Value\n"); - err = TestReadAttributeNullableInt64sMinValue_224(); + ChipLogProgress(chipTool, " ***** Test Step 224 : Read attribute NULLABLE_INT8S Min Value\n"); + err = TestReadAttributeNullableInt8sMinValue_224(); break; case 225: - ChipLogProgress(chipTool, " ***** Test Step 225 : Write attribute NULLABLE_INT64S Invalid Value\n"); - err = TestWriteAttributeNullableInt64sInvalidValue_225(); + ChipLogProgress(chipTool, " ***** Test Step 225 : Write attribute NULLABLE_INT8S Invalid Value\n"); + err = TestWriteAttributeNullableInt8sInvalidValue_225(); break; case 226: - ChipLogProgress(chipTool, " ***** Test Step 226 : Read attribute NULLABLE_INT64S unchanged Value\n"); - err = TestReadAttributeNullableInt64sUnchangedValue_226(); + ChipLogProgress(chipTool, " ***** Test Step 226 : Read attribute NULLABLE_INT8S unchanged Value\n"); + err = TestReadAttributeNullableInt8sUnchangedValue_226(); break; case 227: - ChipLogProgress(chipTool, " ***** Test Step 227 : Write attribute NULLABLE_INT64S null Value\n"); - err = TestWriteAttributeNullableInt64sNullValue_227(); + ChipLogProgress(chipTool, " ***** Test Step 227 : Write attribute NULLABLE_INT8S null Value\n"); + err = TestWriteAttributeNullableInt8sNullValue_227(); break; case 228: - ChipLogProgress(chipTool, " ***** Test Step 228 : Read attribute NULLABLE_INT64S null Value\n"); - err = TestReadAttributeNullableInt64sNullValue_228(); + ChipLogProgress(chipTool, " ***** Test Step 228 : Read attribute NULLABLE_INT8S null Value\n"); + err = TestReadAttributeNullableInt8sNullValue_228(); break; case 229: - ChipLogProgress(chipTool, " ***** Test Step 229 : Write attribute NULLABLE_ENUM8 Max Value\n"); - err = TestWriteAttributeNullableEnum8MaxValue_229(); + ChipLogProgress(chipTool, " ***** Test Step 229 : Write attribute NULLABLE_INT16S Min Value\n"); + err = TestWriteAttributeNullableInt16sMinValue_229(); break; case 230: - ChipLogProgress(chipTool, " ***** Test Step 230 : Read attribute NULLABLE_ENUM8 Max Value\n"); - err = TestReadAttributeNullableEnum8MaxValue_230(); + ChipLogProgress(chipTool, " ***** Test Step 230 : Read attribute NULLABLE_INT16S Min Value\n"); + err = TestReadAttributeNullableInt16sMinValue_230(); break; case 231: - ChipLogProgress(chipTool, " ***** Test Step 231 : Write attribute NULLABLE_ENUM8 Invalid Value\n"); - err = TestWriteAttributeNullableEnum8InvalidValue_231(); + ChipLogProgress(chipTool, " ***** Test Step 231 : Write attribute NULLABLE_INT16S Invalid Value\n"); + err = TestWriteAttributeNullableInt16sInvalidValue_231(); break; case 232: - ChipLogProgress(chipTool, " ***** Test Step 232 : Read attribute NULLABLE_ENUM8 unchanged Value\n"); - err = TestReadAttributeNullableEnum8UnchangedValue_232(); + ChipLogProgress(chipTool, " ***** Test Step 232 : Read attribute NULLABLE_INT16S unchanged Value\n"); + err = TestReadAttributeNullableInt16sUnchangedValue_232(); break; case 233: - ChipLogProgress(chipTool, " ***** Test Step 233 : Write attribute NULLABLE_ENUM8 null Value\n"); - err = TestWriteAttributeNullableEnum8NullValue_233(); + ChipLogProgress(chipTool, " ***** Test Step 233 : Write attribute NULLABLE_INT16S null Value\n"); + err = TestWriteAttributeNullableInt16sNullValue_233(); break; case 234: - ChipLogProgress(chipTool, " ***** Test Step 234 : Read attribute NULLABLE_ENUM8 null Value\n"); - err = TestReadAttributeNullableEnum8NullValue_234(); + ChipLogProgress(chipTool, " ***** Test Step 234 : Read attribute NULLABLE_INT16S null Value\n"); + err = TestReadAttributeNullableInt16sNullValue_234(); break; case 235: - ChipLogProgress(chipTool, " ***** Test Step 235 : Write attribute NULLABLE_ENUM16 Max Value\n"); - err = TestWriteAttributeNullableEnum16MaxValue_235(); + ChipLogProgress(chipTool, " ***** Test Step 235 : Write attribute NULLABLE_INT32S Min Value\n"); + err = TestWriteAttributeNullableInt32sMinValue_235(); break; case 236: - ChipLogProgress(chipTool, " ***** Test Step 236 : Read attribute NULLABLE_ENUM16 Max Value\n"); - err = TestReadAttributeNullableEnum16MaxValue_236(); + ChipLogProgress(chipTool, " ***** Test Step 236 : Read attribute NULLABLE_INT32S Min Value\n"); + err = TestReadAttributeNullableInt32sMinValue_236(); break; case 237: - ChipLogProgress(chipTool, " ***** Test Step 237 : Write attribute NULLABLE_ENUM16 Invalid Value\n"); - err = TestWriteAttributeNullableEnum16InvalidValue_237(); + ChipLogProgress(chipTool, " ***** Test Step 237 : Write attribute NULLABLE_INT32S Invalid Value\n"); + err = TestWriteAttributeNullableInt32sInvalidValue_237(); break; case 238: - ChipLogProgress(chipTool, " ***** Test Step 238 : Read attribute NULLABLE_ENUM16 unchanged Value\n"); - err = TestReadAttributeNullableEnum16UnchangedValue_238(); + ChipLogProgress(chipTool, " ***** Test Step 238 : Read attribute NULLABLE_INT32S unchanged Value\n"); + err = TestReadAttributeNullableInt32sUnchangedValue_238(); break; case 239: - ChipLogProgress(chipTool, " ***** Test Step 239 : Write attribute NULLABLE_ENUM16 null Value\n"); - err = TestWriteAttributeNullableEnum16NullValue_239(); + ChipLogProgress(chipTool, " ***** Test Step 239 : Write attribute NULLABLE_INT32S null Value\n"); + err = TestWriteAttributeNullableInt32sNullValue_239(); break; case 240: - ChipLogProgress(chipTool, " ***** Test Step 240 : Read attribute NULLABLE_ENUM16 null Value\n"); - err = TestReadAttributeNullableEnum16NullValue_240(); + ChipLogProgress(chipTool, " ***** Test Step 240 : Read attribute NULLABLE_INT32S null Value\n"); + err = TestReadAttributeNullableInt32sNullValue_240(); break; case 241: - ChipLogProgress(chipTool, " ***** Test Step 241 : Read attribute NULLABLE_OCTET_STRING Default Value\n"); - err = TestReadAttributeNullableOctetStringDefaultValue_241(); + ChipLogProgress(chipTool, " ***** Test Step 241 : Write attribute NULLABLE_INT64S Min Value\n"); + err = TestWriteAttributeNullableInt64sMinValue_241(); break; case 242: - ChipLogProgress(chipTool, " ***** Test Step 242 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_242(); + ChipLogProgress(chipTool, " ***** Test Step 242 : Read attribute NULLABLE_INT64S Min Value\n"); + err = TestReadAttributeNullableInt64sMinValue_242(); break; case 243: - ChipLogProgress(chipTool, " ***** Test Step 243 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_243(); + ChipLogProgress(chipTool, " ***** Test Step 243 : Write attribute NULLABLE_INT64S Invalid Value\n"); + err = TestWriteAttributeNullableInt64sInvalidValue_243(); break; case 244: - ChipLogProgress(chipTool, " ***** Test Step 244 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_244(); + ChipLogProgress(chipTool, " ***** Test Step 244 : Read attribute NULLABLE_INT64S unchanged Value\n"); + err = TestReadAttributeNullableInt64sUnchangedValue_244(); break; case 245: - ChipLogProgress(chipTool, " ***** Test Step 245 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_245(); + ChipLogProgress(chipTool, " ***** Test Step 245 : Write attribute NULLABLE_INT64S null Value\n"); + err = TestWriteAttributeNullableInt64sNullValue_245(); break; case 246: - ChipLogProgress(chipTool, " ***** Test Step 246 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_246(); + ChipLogProgress(chipTool, " ***** Test Step 246 : Read attribute NULLABLE_INT64S null Value\n"); + err = TestReadAttributeNullableInt64sNullValue_246(); break; case 247: - ChipLogProgress(chipTool, " ***** Test Step 247 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_247(); + ChipLogProgress(chipTool, " ***** Test Step 247 : Write attribute NULLABLE_SINGLE medium Value\n"); + err = TestWriteAttributeNullableSingleMediumValue_247(); break; case 248: - ChipLogProgress(chipTool, " ***** Test Step 248 : Read attribute NULLABLE_CHAR_STRING Default Value\n"); - err = TestReadAttributeNullableCharStringDefaultValue_248(); + ChipLogProgress(chipTool, " ***** Test Step 248 : Read attribute NULLABLE_SINGLE medium Value\n"); + err = TestReadAttributeNullableSingleMediumValue_248(); break; case 249: - ChipLogProgress(chipTool, " ***** Test Step 249 : Write attribute NULLABLE_CHAR_STRING\n"); - err = TestWriteAttributeNullableCharString_249(); + ChipLogProgress(chipTool, " ***** Test Step 249 : Write attribute NULLABLE_SINGLE largest Value\n"); + err = TestWriteAttributeNullableSingleLargestValue_249(); break; case 250: - ChipLogProgress(chipTool, " ***** Test Step 250 : Read attribute NULLABLE_CHAR_STRING\n"); - err = TestReadAttributeNullableCharString_250(); + ChipLogProgress(chipTool, " ***** Test Step 250 : Read attribute NULLABLE_SINGLE largest Value\n"); + err = TestReadAttributeNullableSingleLargestValue_250(); break; case 251: - ChipLogProgress(chipTool, " ***** Test Step 251 : Write attribute NULLABLE_CHAR_STRING - Value too long\n"); - err = TestWriteAttributeNullableCharStringValueTooLong_251(); + ChipLogProgress(chipTool, " ***** Test Step 251 : Write attribute NULLABLE_SINGLE smallest Value\n"); + err = TestWriteAttributeNullableSingleSmallestValue_251(); break; case 252: - ChipLogProgress(chipTool, " ***** Test Step 252 : Read attribute NULLABLE_CHAR_STRING\n"); - err = TestReadAttributeNullableCharString_252(); + ChipLogProgress(chipTool, " ***** Test Step 252 : Read attribute NULLABLE_SINGLE smallest Value\n"); + err = TestReadAttributeNullableSingleSmallestValue_252(); break; case 253: - ChipLogProgress(chipTool, " ***** Test Step 253 : Write attribute NULLABLE_CHAR_STRING - Empty\n"); - err = TestWriteAttributeNullableCharStringEmpty_253(); + ChipLogProgress(chipTool, " ***** Test Step 253 : Write attribute NULLABLE_SINGLE null Value\n"); + err = TestWriteAttributeNullableSingleNullValue_253(); break; case 254: - ChipLogProgress(chipTool, " ***** Test Step 254 : Read attribute NULLABLE_CHAR_STRING\n"); - err = TestReadAttributeNullableCharString_254(); + ChipLogProgress(chipTool, " ***** Test Step 254 : Read attribute NULLABLE_SINGLE null Value\n"); + err = TestReadAttributeNullableSingleNullValue_254(); break; case 255: - ChipLogProgress(chipTool, " ***** Test Step 255 : Read attribute from nonexistent endpoint.\n"); - err = TestReadAttributeFromNonexistentEndpoint_255(); + ChipLogProgress(chipTool, " ***** Test Step 255 : Write attribute NULLABLE_SINGLE 0 Value\n"); + err = TestWriteAttributeNullableSingle0Value_255(); break; case 256: - ChipLogProgress(chipTool, " ***** Test Step 256 : Read attribute from nonexistent cluster.\n"); - err = TestReadAttributeFromNonexistentCluster_256(); + ChipLogProgress(chipTool, " ***** Test Step 256 : Read attribute NULLABLE_SINGLE 0 Value\n"); + err = TestReadAttributeNullableSingle0Value_256(); + break; + case 257: + ChipLogProgress(chipTool, " ***** Test Step 257 : Write attribute NULLABLE_DOUBLE medium Value\n"); + err = TestWriteAttributeNullableDoubleMediumValue_257(); + break; + case 258: + ChipLogProgress(chipTool, " ***** Test Step 258 : Read attribute NULLABLE_DOUBLE medium Value\n"); + err = TestReadAttributeNullableDoubleMediumValue_258(); + break; + case 259: + ChipLogProgress(chipTool, " ***** Test Step 259 : Write attribute NULLABLE_DOUBLE largest Value\n"); + err = TestWriteAttributeNullableDoubleLargestValue_259(); + break; + case 260: + ChipLogProgress(chipTool, " ***** Test Step 260 : Read attribute NULLABLE_DOUBLE largest Value\n"); + err = TestReadAttributeNullableDoubleLargestValue_260(); + break; + case 261: + ChipLogProgress(chipTool, " ***** Test Step 261 : Write attribute NULLABLE_DOUBLE smallest Value\n"); + err = TestWriteAttributeNullableDoubleSmallestValue_261(); + break; + case 262: + ChipLogProgress(chipTool, " ***** Test Step 262 : Read attribute NULLABLE_DOUBLE smallest Value\n"); + err = TestReadAttributeNullableDoubleSmallestValue_262(); + break; + case 263: + ChipLogProgress(chipTool, " ***** Test Step 263 : Write attribute NULLABLE_DOUBLE null Value\n"); + err = TestWriteAttributeNullableDoubleNullValue_263(); + break; + case 264: + ChipLogProgress(chipTool, " ***** Test Step 264 : Read attribute NULLABLE_DOUBLE null Value\n"); + err = TestReadAttributeNullableDoubleNullValue_264(); + break; + case 265: + ChipLogProgress(chipTool, " ***** Test Step 265 : Write attribute NULLABLE_DOUBLE 0 Value\n"); + err = TestWriteAttributeNullableDouble0Value_265(); + break; + case 266: + ChipLogProgress(chipTool, " ***** Test Step 266 : Read attribute NULLABLE_DOUBLE 0 Value\n"); + err = TestReadAttributeNullableDouble0Value_266(); + break; + case 267: + ChipLogProgress(chipTool, " ***** Test Step 267 : Write attribute NULLABLE_ENUM8 Max Value\n"); + err = TestWriteAttributeNullableEnum8MaxValue_267(); + break; + case 268: + ChipLogProgress(chipTool, " ***** Test Step 268 : Read attribute NULLABLE_ENUM8 Max Value\n"); + err = TestReadAttributeNullableEnum8MaxValue_268(); + break; + case 269: + ChipLogProgress(chipTool, " ***** Test Step 269 : Write attribute NULLABLE_ENUM8 Invalid Value\n"); + err = TestWriteAttributeNullableEnum8InvalidValue_269(); + break; + case 270: + ChipLogProgress(chipTool, " ***** Test Step 270 : Read attribute NULLABLE_ENUM8 unchanged Value\n"); + err = TestReadAttributeNullableEnum8UnchangedValue_270(); + break; + case 271: + ChipLogProgress(chipTool, " ***** Test Step 271 : Write attribute NULLABLE_ENUM8 null Value\n"); + err = TestWriteAttributeNullableEnum8NullValue_271(); + break; + case 272: + ChipLogProgress(chipTool, " ***** Test Step 272 : Read attribute NULLABLE_ENUM8 null Value\n"); + err = TestReadAttributeNullableEnum8NullValue_272(); + break; + case 273: + ChipLogProgress(chipTool, " ***** Test Step 273 : Write attribute NULLABLE_ENUM16 Max Value\n"); + err = TestWriteAttributeNullableEnum16MaxValue_273(); + break; + case 274: + ChipLogProgress(chipTool, " ***** Test Step 274 : Read attribute NULLABLE_ENUM16 Max Value\n"); + err = TestReadAttributeNullableEnum16MaxValue_274(); + break; + case 275: + ChipLogProgress(chipTool, " ***** Test Step 275 : Write attribute NULLABLE_ENUM16 Invalid Value\n"); + err = TestWriteAttributeNullableEnum16InvalidValue_275(); + break; + case 276: + ChipLogProgress(chipTool, " ***** Test Step 276 : Read attribute NULLABLE_ENUM16 unchanged Value\n"); + err = TestReadAttributeNullableEnum16UnchangedValue_276(); + break; + case 277: + ChipLogProgress(chipTool, " ***** Test Step 277 : Write attribute NULLABLE_ENUM16 null Value\n"); + err = TestWriteAttributeNullableEnum16NullValue_277(); + break; + case 278: + ChipLogProgress(chipTool, " ***** Test Step 278 : Read attribute NULLABLE_ENUM16 null Value\n"); + err = TestReadAttributeNullableEnum16NullValue_278(); + break; + case 279: + ChipLogProgress(chipTool, " ***** Test Step 279 : Read attribute NULLABLE_OCTET_STRING Default Value\n"); + err = TestReadAttributeNullableOctetStringDefaultValue_279(); + break; + case 280: + ChipLogProgress(chipTool, " ***** Test Step 280 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_280(); + break; + case 281: + ChipLogProgress(chipTool, " ***** Test Step 281 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_281(); + break; + case 282: + ChipLogProgress(chipTool, " ***** Test Step 282 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_282(); + break; + case 283: + ChipLogProgress(chipTool, " ***** Test Step 283 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_283(); + break; + case 284: + ChipLogProgress(chipTool, " ***** Test Step 284 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_284(); + break; + case 285: + ChipLogProgress(chipTool, " ***** Test Step 285 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_285(); + break; + case 286: + ChipLogProgress(chipTool, " ***** Test Step 286 : Read attribute NULLABLE_CHAR_STRING Default Value\n"); + err = TestReadAttributeNullableCharStringDefaultValue_286(); + break; + case 287: + ChipLogProgress(chipTool, " ***** Test Step 287 : Write attribute NULLABLE_CHAR_STRING\n"); + err = TestWriteAttributeNullableCharString_287(); + break; + case 288: + ChipLogProgress(chipTool, " ***** Test Step 288 : Read attribute NULLABLE_CHAR_STRING\n"); + err = TestReadAttributeNullableCharString_288(); + break; + case 289: + ChipLogProgress(chipTool, " ***** Test Step 289 : Write attribute NULLABLE_CHAR_STRING - Value too long\n"); + err = TestWriteAttributeNullableCharStringValueTooLong_289(); + break; + case 290: + ChipLogProgress(chipTool, " ***** Test Step 290 : Read attribute NULLABLE_CHAR_STRING\n"); + err = TestReadAttributeNullableCharString_290(); + break; + case 291: + ChipLogProgress(chipTool, " ***** Test Step 291 : Write attribute NULLABLE_CHAR_STRING - Empty\n"); + err = TestWriteAttributeNullableCharStringEmpty_291(); + break; + case 292: + ChipLogProgress(chipTool, " ***** Test Step 292 : Read attribute NULLABLE_CHAR_STRING\n"); + err = TestReadAttributeNullableCharString_292(); + break; + case 293: + ChipLogProgress(chipTool, " ***** Test Step 293 : Read attribute from nonexistent endpoint.\n"); + err = TestReadAttributeFromNonexistentEndpoint_293(); + break; + case 294: + ChipLogProgress(chipTool, " ***** Test Step 294 : Read attribute from nonexistent cluster.\n"); + err = TestReadAttributeFromNonexistentCluster_294(); break; } @@ -33283,7 +33436,7 @@ class TestCluster : public TestCommand private: std::atomic_uint16_t mTestIndex; - const uint16_t mTestCount = 257; + const uint16_t mTestCount = 295; static void OnFailureCallback_6(void * context, EmberAfStatus status) { @@ -33930,9 +34083,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_79(chip::to_underlying(status)); } - static void OnSuccessCallback_79(void * context, uint8_t enum8) + static void OnSuccessCallback_79(void * context, float floatSingle) { - (static_cast(context))->OnSuccessResponse_79(enum8); + (static_cast(context))->OnSuccessResponse_79(floatSingle); } static void OnFailureCallback_80(void * context, EmberAfStatus status) @@ -33947,9 +34100,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_81(chip::to_underlying(status)); } - static void OnSuccessCallback_81(void * context, uint8_t enum8) + static void OnSuccessCallback_81(void * context, float floatSingle) { - (static_cast(context))->OnSuccessResponse_81(enum8); + (static_cast(context))->OnSuccessResponse_81(floatSingle); } static void OnFailureCallback_82(void * context, EmberAfStatus status) @@ -33964,9 +34117,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_83(chip::to_underlying(status)); } - static void OnSuccessCallback_83(void * context, uint8_t enum8) + static void OnSuccessCallback_83(void * context, float floatSingle) { - (static_cast(context))->OnSuccessResponse_83(enum8); + (static_cast(context))->OnSuccessResponse_83(floatSingle); } static void OnFailureCallback_84(void * context, EmberAfStatus status) @@ -33974,43 +34127,43 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_84(chip::to_underlying(status)); } - static void OnSuccessCallback_84(void * context, uint16_t enum16) - { - (static_cast(context))->OnSuccessResponse_84(enum16); - } + static void OnSuccessCallback_84(void * context) { (static_cast(context))->OnSuccessResponse_84(); } static void OnFailureCallback_85(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_85(chip::to_underlying(status)); } - static void OnSuccessCallback_85(void * context) { (static_cast(context))->OnSuccessResponse_85(); } + static void OnSuccessCallback_85(void * context, float floatSingle) + { + (static_cast(context))->OnSuccessResponse_85(floatSingle); + } static void OnFailureCallback_86(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_86(chip::to_underlying(status)); } - static void OnSuccessCallback_86(void * context, uint16_t enum16) - { - (static_cast(context))->OnSuccessResponse_86(enum16); - } + static void OnSuccessCallback_86(void * context) { (static_cast(context))->OnSuccessResponse_86(); } static void OnFailureCallback_87(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_87(chip::to_underlying(status)); } - static void OnSuccessCallback_87(void * context) { (static_cast(context))->OnSuccessResponse_87(); } + static void OnSuccessCallback_87(void * context, float floatSingle) + { + (static_cast(context))->OnSuccessResponse_87(floatSingle); + } static void OnFailureCallback_88(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_88(chip::to_underlying(status)); } - static void OnSuccessCallback_88(void * context, uint16_t enum16) + static void OnSuccessCallback_88(void * context, double floatDouble) { - (static_cast(context))->OnSuccessResponse_88(enum16); + (static_cast(context))->OnSuccessResponse_88(floatDouble); } static void OnFailureCallback_89(void * context, EmberAfStatus status) @@ -34018,77 +34171,77 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_89(chip::to_underlying(status)); } - static void OnSuccessCallback_89(void * context, chip::ByteSpan octetString) - { - (static_cast(context))->OnSuccessResponse_89(octetString); - } + static void OnSuccessCallback_89(void * context) { (static_cast(context))->OnSuccessResponse_89(); } static void OnFailureCallback_90(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_90(chip::to_underlying(status)); } - static void OnSuccessCallback_90(void * context) { (static_cast(context))->OnSuccessResponse_90(); } + static void OnSuccessCallback_90(void * context, double floatDouble) + { + (static_cast(context))->OnSuccessResponse_90(floatDouble); + } static void OnFailureCallback_91(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_91(chip::to_underlying(status)); } - static void OnSuccessCallback_91(void * context, chip::ByteSpan octetString) - { - (static_cast(context))->OnSuccessResponse_91(octetString); - } + static void OnSuccessCallback_91(void * context) { (static_cast(context))->OnSuccessResponse_91(); } static void OnFailureCallback_92(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_92(chip::to_underlying(status)); } - static void OnSuccessCallback_92(void * context) { (static_cast(context))->OnSuccessResponse_92(); } + static void OnSuccessCallback_92(void * context, double floatDouble) + { + (static_cast(context))->OnSuccessResponse_92(floatDouble); + } static void OnFailureCallback_93(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_93(chip::to_underlying(status)); } - static void OnSuccessCallback_93(void * context, chip::ByteSpan octetString) - { - (static_cast(context))->OnSuccessResponse_93(octetString); - } + static void OnSuccessCallback_93(void * context) { (static_cast(context))->OnSuccessResponse_93(); } static void OnFailureCallback_94(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_94(chip::to_underlying(status)); } - static void OnSuccessCallback_94(void * context) { (static_cast(context))->OnSuccessResponse_94(); } + static void OnSuccessCallback_94(void * context, double floatDouble) + { + (static_cast(context))->OnSuccessResponse_94(floatDouble); + } static void OnFailureCallback_95(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_95(chip::to_underlying(status)); } - static void OnSuccessCallback_95(void * context, chip::ByteSpan octetString) - { - (static_cast(context))->OnSuccessResponse_95(octetString); - } + static void OnSuccessCallback_95(void * context) { (static_cast(context))->OnSuccessResponse_95(); } static void OnFailureCallback_96(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_96(chip::to_underlying(status)); } - static void OnSuccessCallback_96(void * context) { (static_cast(context))->OnSuccessResponse_96(); } + static void OnSuccessCallback_96(void * context, double floatDouble) + { + (static_cast(context))->OnSuccessResponse_96(floatDouble); + } static void OnFailureCallback_97(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_97(chip::to_underlying(status)); } - static void OnSuccessCallback_97(void * context, chip::ByteSpan longOctetString) + static void OnSuccessCallback_97(void * context, uint8_t enum8) { - (static_cast(context))->OnSuccessResponse_97(longOctetString); + (static_cast(context))->OnSuccessResponse_97(enum8); } static void OnFailureCallback_98(void * context, EmberAfStatus status) @@ -34103,9 +34256,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_99(chip::to_underlying(status)); } - static void OnSuccessCallback_99(void * context, chip::ByteSpan longOctetString) + static void OnSuccessCallback_99(void * context, uint8_t enum8) { - (static_cast(context))->OnSuccessResponse_99(longOctetString); + (static_cast(context))->OnSuccessResponse_99(enum8); } static void OnFailureCallback_100(void * context, EmberAfStatus status) @@ -34120,9 +34273,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_101(chip::to_underlying(status)); } - static void OnSuccessCallback_101(void * context, chip::CharSpan charString) + static void OnSuccessCallback_101(void * context, uint8_t enum8) { - (static_cast(context))->OnSuccessResponse_101(charString); + (static_cast(context))->OnSuccessResponse_101(enum8); } static void OnFailureCallback_102(void * context, EmberAfStatus status) @@ -34130,50 +34283,53 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_102(chip::to_underlying(status)); } - static void OnSuccessCallback_102(void * context) { (static_cast(context))->OnSuccessResponse_102(); } + static void OnSuccessCallback_102(void * context, uint16_t enum16) + { + (static_cast(context))->OnSuccessResponse_102(enum16); + } static void OnFailureCallback_103(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_103(chip::to_underlying(status)); } - static void OnSuccessCallback_103(void * context, chip::CharSpan charString) - { - (static_cast(context))->OnSuccessResponse_103(charString); - } + static void OnSuccessCallback_103(void * context) { (static_cast(context))->OnSuccessResponse_103(); } static void OnFailureCallback_104(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_104(chip::to_underlying(status)); } - static void OnSuccessCallback_104(void * context) { (static_cast(context))->OnSuccessResponse_104(); } + static void OnSuccessCallback_104(void * context, uint16_t enum16) + { + (static_cast(context))->OnSuccessResponse_104(enum16); + } static void OnFailureCallback_105(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_105(chip::to_underlying(status)); } - static void OnSuccessCallback_105(void * context, chip::CharSpan charString) - { - (static_cast(context))->OnSuccessResponse_105(charString); - } + static void OnSuccessCallback_105(void * context) { (static_cast(context))->OnSuccessResponse_105(); } static void OnFailureCallback_106(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_106(chip::to_underlying(status)); } - static void OnSuccessCallback_106(void * context) { (static_cast(context))->OnSuccessResponse_106(); } + static void OnSuccessCallback_106(void * context, uint16_t enum16) + { + (static_cast(context))->OnSuccessResponse_106(enum16); + } static void OnFailureCallback_107(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_107(chip::to_underlying(status)); } - static void OnSuccessCallback_107(void * context, chip::CharSpan longCharString) + static void OnSuccessCallback_107(void * context, chip::ByteSpan octetString) { - (static_cast(context))->OnSuccessResponse_107(longCharString); + (static_cast(context))->OnSuccessResponse_107(octetString); } static void OnFailureCallback_108(void * context, EmberAfStatus status) @@ -34188,9 +34344,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_109(chip::to_underlying(status)); } - static void OnSuccessCallback_109(void * context, chip::CharSpan longCharString) + static void OnSuccessCallback_109(void * context, chip::ByteSpan octetString) { - (static_cast(context))->OnSuccessResponse_109(longCharString); + (static_cast(context))->OnSuccessResponse_109(octetString); } static void OnFailureCallback_110(void * context, EmberAfStatus status) @@ -34205,9 +34361,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_111(chip::to_underlying(status)); } - static void OnSuccessCallback_111(void * context, uint64_t epochUs) + static void OnSuccessCallback_111(void * context, chip::ByteSpan octetString) { - (static_cast(context))->OnSuccessResponse_111(epochUs); + (static_cast(context))->OnSuccessResponse_111(octetString); } static void OnFailureCallback_112(void * context, EmberAfStatus status) @@ -34222,9 +34378,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_113(chip::to_underlying(status)); } - static void OnSuccessCallback_113(void * context, uint64_t epochUs) + static void OnSuccessCallback_113(void * context, chip::ByteSpan octetString) { - (static_cast(context))->OnSuccessResponse_113(epochUs); + (static_cast(context))->OnSuccessResponse_113(octetString); } static void OnFailureCallback_114(void * context, EmberAfStatus status) @@ -34239,9 +34395,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_115(chip::to_underlying(status)); } - static void OnSuccessCallback_115(void * context, uint64_t epochUs) + static void OnSuccessCallback_115(void * context, chip::ByteSpan longOctetString) { - (static_cast(context))->OnSuccessResponse_115(epochUs); + (static_cast(context))->OnSuccessResponse_115(longOctetString); } static void OnFailureCallback_116(void * context, EmberAfStatus status) @@ -34249,53 +34405,50 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_116(chip::to_underlying(status)); } - static void OnSuccessCallback_116(void * context, uint32_t epochS) - { - (static_cast(context))->OnSuccessResponse_116(epochS); - } + static void OnSuccessCallback_116(void * context) { (static_cast(context))->OnSuccessResponse_116(); } static void OnFailureCallback_117(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_117(chip::to_underlying(status)); } - static void OnSuccessCallback_117(void * context) { (static_cast(context))->OnSuccessResponse_117(); } + static void OnSuccessCallback_117(void * context, chip::ByteSpan longOctetString) + { + (static_cast(context))->OnSuccessResponse_117(longOctetString); + } static void OnFailureCallback_118(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_118(chip::to_underlying(status)); } - static void OnSuccessCallback_118(void * context, uint32_t epochS) - { - (static_cast(context))->OnSuccessResponse_118(epochS); - } + static void OnSuccessCallback_118(void * context) { (static_cast(context))->OnSuccessResponse_118(); } static void OnFailureCallback_119(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_119(chip::to_underlying(status)); } - static void OnSuccessCallback_119(void * context) { (static_cast(context))->OnSuccessResponse_119(); } + static void OnSuccessCallback_119(void * context, chip::CharSpan charString) + { + (static_cast(context))->OnSuccessResponse_119(charString); + } static void OnFailureCallback_120(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_120(chip::to_underlying(status)); } - static void OnSuccessCallback_120(void * context, uint32_t epochS) - { - (static_cast(context))->OnSuccessResponse_120(epochS); - } + static void OnSuccessCallback_120(void * context) { (static_cast(context))->OnSuccessResponse_120(); } static void OnFailureCallback_121(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_121(chip::to_underlying(status)); } - static void OnSuccessCallback_121(void * context, bool unsupported) + static void OnSuccessCallback_121(void * context, chip::CharSpan charString) { - (static_cast(context))->OnSuccessResponse_121(unsupported); + (static_cast(context))->OnSuccessResponse_121(charString); } static void OnFailureCallback_122(void * context, EmberAfStatus status) @@ -34305,14 +34458,31 @@ class TestCluster : public TestCommand static void OnSuccessCallback_122(void * context) { (static_cast(context))->OnSuccessResponse_122(); } + static void OnFailureCallback_123(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_123(chip::to_underlying(status)); + } + + static void OnSuccessCallback_123(void * context, chip::CharSpan charString) + { + (static_cast(context))->OnSuccessResponse_123(charString); + } + + static void OnFailureCallback_124(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_124(chip::to_underlying(status)); + } + + static void OnSuccessCallback_124(void * context) { (static_cast(context))->OnSuccessResponse_124(); } + static void OnFailureCallback_125(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_125(chip::to_underlying(status)); } - static void OnSuccessCallback_125(void * context, chip::VendorId vendorId) + static void OnSuccessCallback_125(void * context, chip::CharSpan longCharString) { - (static_cast(context))->OnSuccessResponse_125(vendorId); + (static_cast(context))->OnSuccessResponse_125(longCharString); } static void OnFailureCallback_126(void * context, EmberAfStatus status) @@ -34327,9 +34497,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_127(chip::to_underlying(status)); } - static void OnSuccessCallback_127(void * context, chip::VendorId vendorId) + static void OnSuccessCallback_127(void * context, chip::CharSpan longCharString) { - (static_cast(context))->OnSuccessResponse_127(vendorId); + (static_cast(context))->OnSuccessResponse_127(longCharString); } static void OnFailureCallback_128(void * context, EmberAfStatus status) @@ -34339,145 +34509,145 @@ class TestCluster : public TestCommand static void OnSuccessCallback_128(void * context) { (static_cast(context))->OnSuccessResponse_128(); } - static void OnFailureCallback_145(void * context, EmberAfStatus status) + static void OnFailureCallback_129(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_145(chip::to_underlying(status)); + (static_cast(context))->OnFailureResponse_129(chip::to_underlying(status)); } - static void OnSuccessCallback_145(void * context) { (static_cast(context))->OnSuccessResponse_145(); } - - static void OnFailureCallback_146(void * context, EmberAfStatus status) + static void OnSuccessCallback_129(void * context, uint64_t epochUs) { - (static_cast(context))->OnFailureResponse_146(chip::to_underlying(status)); + (static_cast(context))->OnSuccessResponse_129(epochUs); } - static void OnSuccessCallback_146(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnFailureCallback_130(void * context, EmberAfStatus status) { - (static_cast(context))->OnSuccessResponse_146(listInt8u); + (static_cast(context))->OnFailureResponse_130(chip::to_underlying(status)); } - static void OnFailureCallback_147(void * context, EmberAfStatus status) + static void OnSuccessCallback_130(void * context) { (static_cast(context))->OnSuccessResponse_130(); } + + static void OnFailureCallback_131(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_147(chip::to_underlying(status)); + (static_cast(context))->OnFailureResponse_131(chip::to_underlying(status)); } - static void OnSuccessCallback_147(void * context) { (static_cast(context))->OnSuccessResponse_147(); } - - static void OnFailureCallback_148(void * context, EmberAfStatus status) + static void OnSuccessCallback_131(void * context, uint64_t epochUs) { - (static_cast(context))->OnFailureResponse_148(chip::to_underlying(status)); + (static_cast(context))->OnSuccessResponse_131(epochUs); } - static void OnSuccessCallback_148(void * context, const chip::app::DataModel::DecodableList & listOctetString) + static void OnFailureCallback_132(void * context, EmberAfStatus status) { - (static_cast(context))->OnSuccessResponse_148(listOctetString); + (static_cast(context))->OnFailureResponse_132(chip::to_underlying(status)); } - static void OnFailureCallback_149(void * context, EmberAfStatus status) + static void OnSuccessCallback_132(void * context) { (static_cast(context))->OnSuccessResponse_132(); } + + static void OnFailureCallback_133(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_149(chip::to_underlying(status)); + (static_cast(context))->OnFailureResponse_133(chip::to_underlying(status)); } - static void OnSuccessCallback_149(void * context) { (static_cast(context))->OnSuccessResponse_149(); } + static void OnSuccessCallback_133(void * context, uint64_t epochUs) + { + (static_cast(context))->OnSuccessResponse_133(epochUs); + } - static void OnFailureCallback_150(void * context, EmberAfStatus status) + static void OnFailureCallback_134(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_150(chip::to_underlying(status)); + (static_cast(context))->OnFailureResponse_134(chip::to_underlying(status)); } - static void OnSuccessCallback_150( - void * context, - const chip::app::DataModel::DecodableList & - listStructOctetString) + static void OnSuccessCallback_134(void * context, uint32_t epochS) { - (static_cast(context))->OnSuccessResponse_150(listStructOctetString); + (static_cast(context))->OnSuccessResponse_134(epochS); } - static void OnFailureCallback_153(void * context, EmberAfStatus status) + static void OnFailureCallback_135(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_153(chip::to_underlying(status)); + (static_cast(context))->OnFailureResponse_135(chip::to_underlying(status)); } - static void OnSuccessCallback_153(void * context) { (static_cast(context))->OnSuccessResponse_153(); } + static void OnSuccessCallback_135(void * context) { (static_cast(context))->OnSuccessResponse_135(); } - static void OnFailureCallback_154(void * context, EmberAfStatus status) + static void OnFailureCallback_136(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_154(chip::to_underlying(status)); + (static_cast(context))->OnFailureResponse_136(chip::to_underlying(status)); } - static void OnSuccessCallback_154(void * context, const chip::app::DataModel::Nullable & nullableBoolean) + static void OnSuccessCallback_136(void * context, uint32_t epochS) { - (static_cast(context))->OnSuccessResponse_154(nullableBoolean); + (static_cast(context))->OnSuccessResponse_136(epochS); } - static void OnFailureCallback_155(void * context, EmberAfStatus status) + static void OnFailureCallback_137(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_155(chip::to_underlying(status)); + (static_cast(context))->OnFailureResponse_137(chip::to_underlying(status)); } - static void OnSuccessCallback_155(void * context) { (static_cast(context))->OnSuccessResponse_155(); } + static void OnSuccessCallback_137(void * context) { (static_cast(context))->OnSuccessResponse_137(); } - static void OnFailureCallback_156(void * context, EmberAfStatus status) + static void OnFailureCallback_138(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_156(chip::to_underlying(status)); + (static_cast(context))->OnFailureResponse_138(chip::to_underlying(status)); } - static void OnSuccessCallback_156(void * context, const chip::app::DataModel::Nullable & nullableBoolean) + static void OnSuccessCallback_138(void * context, uint32_t epochS) { - (static_cast(context))->OnSuccessResponse_156(nullableBoolean); + (static_cast(context))->OnSuccessResponse_138(epochS); } - static void OnFailureCallback_157(void * context, EmberAfStatus status) + static void OnFailureCallback_139(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_157(chip::to_underlying(status)); + (static_cast(context))->OnFailureResponse_139(chip::to_underlying(status)); } - static void OnSuccessCallback_157(void * context) { (static_cast(context))->OnSuccessResponse_157(); } - - static void OnFailureCallback_158(void * context, EmberAfStatus status) + static void OnSuccessCallback_139(void * context, bool unsupported) { - (static_cast(context))->OnFailureResponse_158(chip::to_underlying(status)); + (static_cast(context))->OnSuccessResponse_139(unsupported); } - static void OnSuccessCallback_158(void * context, const chip::app::DataModel::Nullable & nullableBitmap8) + static void OnFailureCallback_140(void * context, EmberAfStatus status) { - (static_cast(context))->OnSuccessResponse_158(nullableBitmap8); + (static_cast(context))->OnFailureResponse_140(chip::to_underlying(status)); } - static void OnFailureCallback_159(void * context, EmberAfStatus status) + static void OnSuccessCallback_140(void * context) { (static_cast(context))->OnSuccessResponse_140(); } + + static void OnFailureCallback_143(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_159(chip::to_underlying(status)); + (static_cast(context))->OnFailureResponse_143(chip::to_underlying(status)); } - static void OnSuccessCallback_159(void * context) { (static_cast(context))->OnSuccessResponse_159(); } - - static void OnFailureCallback_160(void * context, EmberAfStatus status) + static void OnSuccessCallback_143(void * context, chip::VendorId vendorId) { - (static_cast(context))->OnFailureResponse_160(chip::to_underlying(status)); + (static_cast(context))->OnSuccessResponse_143(vendorId); } - static void OnSuccessCallback_160(void * context, const chip::app::DataModel::Nullable & nullableBitmap8) + static void OnFailureCallback_144(void * context, EmberAfStatus status) { - (static_cast(context))->OnSuccessResponse_160(nullableBitmap8); + (static_cast(context))->OnFailureResponse_144(chip::to_underlying(status)); } - static void OnFailureCallback_161(void * context, EmberAfStatus status) + static void OnSuccessCallback_144(void * context) { (static_cast(context))->OnSuccessResponse_144(); } + + static void OnFailureCallback_145(void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_161(chip::to_underlying(status)); + (static_cast(context))->OnFailureResponse_145(chip::to_underlying(status)); } - static void OnSuccessCallback_161(void * context) { (static_cast(context))->OnSuccessResponse_161(); } - - static void OnFailureCallback_162(void * context, EmberAfStatus status) + static void OnSuccessCallback_145(void * context, chip::VendorId vendorId) { - (static_cast(context))->OnFailureResponse_162(chip::to_underlying(status)); + (static_cast(context))->OnSuccessResponse_145(vendorId); } - static void OnSuccessCallback_162(void * context, const chip::app::DataModel::Nullable & nullableBitmap8) + static void OnFailureCallback_146(void * context, EmberAfStatus status) { - (static_cast(context))->OnSuccessResponse_162(nullableBitmap8); + (static_cast(context))->OnFailureResponse_146(chip::to_underlying(status)); } + static void OnSuccessCallback_146(void * context) { (static_cast(context))->OnSuccessResponse_146(); } + static void OnFailureCallback_163(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_163(chip::to_underlying(status)); @@ -34490,9 +34660,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_164(chip::to_underlying(status)); } - static void OnSuccessCallback_164(void * context, const chip::app::DataModel::Nullable & nullableBitmap16) + static void OnSuccessCallback_164(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnSuccessResponse_164(nullableBitmap16); + (static_cast(context))->OnSuccessResponse_164(listInt8u); } static void OnFailureCallback_165(void * context, EmberAfStatus status) @@ -34507,9 +34677,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_166(chip::to_underlying(status)); } - static void OnSuccessCallback_166(void * context, const chip::app::DataModel::Nullable & nullableBitmap16) + static void OnSuccessCallback_166(void * context, const chip::app::DataModel::DecodableList & listOctetString) { - (static_cast(context))->OnSuccessResponse_166(nullableBitmap16); + (static_cast(context))->OnSuccessResponse_166(listOctetString); } static void OnFailureCallback_167(void * context, EmberAfStatus status) @@ -34524,26 +34694,12 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_168(chip::to_underlying(status)); } - static void OnSuccessCallback_168(void * context, const chip::app::DataModel::Nullable & nullableBitmap16) - { - (static_cast(context))->OnSuccessResponse_168(nullableBitmap16); - } - - static void OnFailureCallback_169(void * context, EmberAfStatus status) - { - (static_cast(context))->OnFailureResponse_169(chip::to_underlying(status)); - } - - 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, const chip::app::DataModel::Nullable & nullableBitmap32) + static void OnSuccessCallback_168( + void * context, + const chip::app::DataModel::DecodableList & + listStructOctetString) { - (static_cast(context))->OnSuccessResponse_170(nullableBitmap32); + (static_cast(context))->OnSuccessResponse_168(listStructOctetString); } static void OnFailureCallback_171(void * context, EmberAfStatus status) @@ -34558,9 +34714,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_172(chip::to_underlying(status)); } - static void OnSuccessCallback_172(void * context, const chip::app::DataModel::Nullable & nullableBitmap32) + static void OnSuccessCallback_172(void * context, const chip::app::DataModel::Nullable & nullableBoolean) { - (static_cast(context))->OnSuccessResponse_172(nullableBitmap32); + (static_cast(context))->OnSuccessResponse_172(nullableBoolean); } static void OnFailureCallback_173(void * context, EmberAfStatus status) @@ -34575,9 +34731,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_174(chip::to_underlying(status)); } - static void OnSuccessCallback_174(void * context, const chip::app::DataModel::Nullable & nullableBitmap32) + static void OnSuccessCallback_174(void * context, const chip::app::DataModel::Nullable & nullableBoolean) { - (static_cast(context))->OnSuccessResponse_174(nullableBitmap32); + (static_cast(context))->OnSuccessResponse_174(nullableBoolean); } static void OnFailureCallback_175(void * context, EmberAfStatus status) @@ -34592,9 +34748,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_176(chip::to_underlying(status)); } - static void OnSuccessCallback_176(void * context, const chip::app::DataModel::Nullable & nullableBitmap64) + static void OnSuccessCallback_176(void * context, const chip::app::DataModel::Nullable & nullableBitmap8) { - (static_cast(context))->OnSuccessResponse_176(nullableBitmap64); + (static_cast(context))->OnSuccessResponse_176(nullableBitmap8); } static void OnFailureCallback_177(void * context, EmberAfStatus status) @@ -34609,9 +34765,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_178(chip::to_underlying(status)); } - static void OnSuccessCallback_178(void * context, const chip::app::DataModel::Nullable & nullableBitmap64) + static void OnSuccessCallback_178(void * context, const chip::app::DataModel::Nullable & nullableBitmap8) { - (static_cast(context))->OnSuccessResponse_178(nullableBitmap64); + (static_cast(context))->OnSuccessResponse_178(nullableBitmap8); } static void OnFailureCallback_179(void * context, EmberAfStatus status) @@ -34626,9 +34782,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_180(chip::to_underlying(status)); } - static void OnSuccessCallback_180(void * context, const chip::app::DataModel::Nullable & nullableBitmap64) + static void OnSuccessCallback_180(void * context, const chip::app::DataModel::Nullable & nullableBitmap8) { - (static_cast(context))->OnSuccessResponse_180(nullableBitmap64); + (static_cast(context))->OnSuccessResponse_180(nullableBitmap8); } static void OnFailureCallback_181(void * context, EmberAfStatus status) @@ -34643,9 +34799,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_182(chip::to_underlying(status)); } - static void OnSuccessCallback_182(void * context, const chip::app::DataModel::Nullable & nullableInt8u) + static void OnSuccessCallback_182(void * context, const chip::app::DataModel::Nullable & nullableBitmap16) { - (static_cast(context))->OnSuccessResponse_182(nullableInt8u); + (static_cast(context))->OnSuccessResponse_182(nullableBitmap16); } static void OnFailureCallback_183(void * context, EmberAfStatus status) @@ -34660,9 +34816,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_184(chip::to_underlying(status)); } - static void OnSuccessCallback_184(void * context, const chip::app::DataModel::Nullable & nullableInt8u) + static void OnSuccessCallback_184(void * context, const chip::app::DataModel::Nullable & nullableBitmap16) { - (static_cast(context))->OnSuccessResponse_184(nullableInt8u); + (static_cast(context))->OnSuccessResponse_184(nullableBitmap16); } static void OnFailureCallback_185(void * context, EmberAfStatus status) @@ -34677,9 +34833,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_186(chip::to_underlying(status)); } - static void OnSuccessCallback_186(void * context, const chip::app::DataModel::Nullable & nullableInt8u) + static void OnSuccessCallback_186(void * context, const chip::app::DataModel::Nullable & nullableBitmap16) { - (static_cast(context))->OnSuccessResponse_186(nullableInt8u); + (static_cast(context))->OnSuccessResponse_186(nullableBitmap16); } static void OnFailureCallback_187(void * context, EmberAfStatus status) @@ -34694,9 +34850,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_188(chip::to_underlying(status)); } - static void OnSuccessCallback_188(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + static void OnSuccessCallback_188(void * context, const chip::app::DataModel::Nullable & nullableBitmap32) { - (static_cast(context))->OnSuccessResponse_188(nullableInt16u); + (static_cast(context))->OnSuccessResponse_188(nullableBitmap32); } static void OnFailureCallback_189(void * context, EmberAfStatus status) @@ -34711,9 +34867,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_190(chip::to_underlying(status)); } - static void OnSuccessCallback_190(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + static void OnSuccessCallback_190(void * context, const chip::app::DataModel::Nullable & nullableBitmap32) { - (static_cast(context))->OnSuccessResponse_190(nullableInt16u); + (static_cast(context))->OnSuccessResponse_190(nullableBitmap32); } static void OnFailureCallback_191(void * context, EmberAfStatus status) @@ -34728,9 +34884,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_192(chip::to_underlying(status)); } - static void OnSuccessCallback_192(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + static void OnSuccessCallback_192(void * context, const chip::app::DataModel::Nullable & nullableBitmap32) { - (static_cast(context))->OnSuccessResponse_192(nullableInt16u); + (static_cast(context))->OnSuccessResponse_192(nullableBitmap32); } static void OnFailureCallback_193(void * context, EmberAfStatus status) @@ -34745,9 +34901,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_194(chip::to_underlying(status)); } - static void OnSuccessCallback_194(void * context, const chip::app::DataModel::Nullable & nullableInt32u) + static void OnSuccessCallback_194(void * context, const chip::app::DataModel::Nullable & nullableBitmap64) { - (static_cast(context))->OnSuccessResponse_194(nullableInt32u); + (static_cast(context))->OnSuccessResponse_194(nullableBitmap64); } static void OnFailureCallback_195(void * context, EmberAfStatus status) @@ -34762,9 +34918,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_196(chip::to_underlying(status)); } - static void OnSuccessCallback_196(void * context, const chip::app::DataModel::Nullable & nullableInt32u) + static void OnSuccessCallback_196(void * context, const chip::app::DataModel::Nullable & nullableBitmap64) { - (static_cast(context))->OnSuccessResponse_196(nullableInt32u); + (static_cast(context))->OnSuccessResponse_196(nullableBitmap64); } static void OnFailureCallback_197(void * context, EmberAfStatus status) @@ -34779,9 +34935,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_198(chip::to_underlying(status)); } - static void OnSuccessCallback_198(void * context, const chip::app::DataModel::Nullable & nullableInt32u) + static void OnSuccessCallback_198(void * context, const chip::app::DataModel::Nullable & nullableBitmap64) { - (static_cast(context))->OnSuccessResponse_198(nullableInt32u); + (static_cast(context))->OnSuccessResponse_198(nullableBitmap64); } static void OnFailureCallback_199(void * context, EmberAfStatus status) @@ -34796,9 +34952,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_200(chip::to_underlying(status)); } - static void OnSuccessCallback_200(void * context, const chip::app::DataModel::Nullable & nullableInt64u) + static void OnSuccessCallback_200(void * context, const chip::app::DataModel::Nullable & nullableInt8u) { - (static_cast(context))->OnSuccessResponse_200(nullableInt64u); + (static_cast(context))->OnSuccessResponse_200(nullableInt8u); } static void OnFailureCallback_201(void * context, EmberAfStatus status) @@ -34813,9 +34969,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_202(chip::to_underlying(status)); } - static void OnSuccessCallback_202(void * context, const chip::app::DataModel::Nullable & nullableInt64u) + static void OnSuccessCallback_202(void * context, const chip::app::DataModel::Nullable & nullableInt8u) { - (static_cast(context))->OnSuccessResponse_202(nullableInt64u); + (static_cast(context))->OnSuccessResponse_202(nullableInt8u); } static void OnFailureCallback_203(void * context, EmberAfStatus status) @@ -34830,9 +34986,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_204(chip::to_underlying(status)); } - static void OnSuccessCallback_204(void * context, const chip::app::DataModel::Nullable & nullableInt64u) + static void OnSuccessCallback_204(void * context, const chip::app::DataModel::Nullable & nullableInt8u) { - (static_cast(context))->OnSuccessResponse_204(nullableInt64u); + (static_cast(context))->OnSuccessResponse_204(nullableInt8u); } static void OnFailureCallback_205(void * context, EmberAfStatus status) @@ -34847,9 +35003,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_206(chip::to_underlying(status)); } - static void OnSuccessCallback_206(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + static void OnSuccessCallback_206(void * context, const chip::app::DataModel::Nullable & nullableInt16u) { - (static_cast(context))->OnSuccessResponse_206(nullableInt8s); + (static_cast(context))->OnSuccessResponse_206(nullableInt16u); } static void OnFailureCallback_207(void * context, EmberAfStatus status) @@ -34864,9 +35020,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_208(chip::to_underlying(status)); } - static void OnSuccessCallback_208(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + static void OnSuccessCallback_208(void * context, const chip::app::DataModel::Nullable & nullableInt16u) { - (static_cast(context))->OnSuccessResponse_208(nullableInt8s); + (static_cast(context))->OnSuccessResponse_208(nullableInt16u); } static void OnFailureCallback_209(void * context, EmberAfStatus status) @@ -34881,9 +35037,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_210(chip::to_underlying(status)); } - static void OnSuccessCallback_210(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + static void OnSuccessCallback_210(void * context, const chip::app::DataModel::Nullable & nullableInt16u) { - (static_cast(context))->OnSuccessResponse_210(nullableInt8s); + (static_cast(context))->OnSuccessResponse_210(nullableInt16u); } static void OnFailureCallback_211(void * context, EmberAfStatus status) @@ -34898,9 +35054,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_212(chip::to_underlying(status)); } - static void OnSuccessCallback_212(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + static void OnSuccessCallback_212(void * context, const chip::app::DataModel::Nullable & nullableInt32u) { - (static_cast(context))->OnSuccessResponse_212(nullableInt16s); + (static_cast(context))->OnSuccessResponse_212(nullableInt32u); } static void OnFailureCallback_213(void * context, EmberAfStatus status) @@ -34915,9 +35071,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_214(chip::to_underlying(status)); } - static void OnSuccessCallback_214(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + static void OnSuccessCallback_214(void * context, const chip::app::DataModel::Nullable & nullableInt32u) { - (static_cast(context))->OnSuccessResponse_214(nullableInt16s); + (static_cast(context))->OnSuccessResponse_214(nullableInt32u); } static void OnFailureCallback_215(void * context, EmberAfStatus status) @@ -34932,9 +35088,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_216(chip::to_underlying(status)); } - static void OnSuccessCallback_216(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + static void OnSuccessCallback_216(void * context, const chip::app::DataModel::Nullable & nullableInt32u) { - (static_cast(context))->OnSuccessResponse_216(nullableInt16s); + (static_cast(context))->OnSuccessResponse_216(nullableInt32u); } static void OnFailureCallback_217(void * context, EmberAfStatus status) @@ -34949,9 +35105,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_218(chip::to_underlying(status)); } - static void OnSuccessCallback_218(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + static void OnSuccessCallback_218(void * context, const chip::app::DataModel::Nullable & nullableInt64u) { - (static_cast(context))->OnSuccessResponse_218(nullableInt32s); + (static_cast(context))->OnSuccessResponse_218(nullableInt64u); } static void OnFailureCallback_219(void * context, EmberAfStatus status) @@ -34966,9 +35122,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_220(chip::to_underlying(status)); } - static void OnSuccessCallback_220(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + static void OnSuccessCallback_220(void * context, const chip::app::DataModel::Nullable & nullableInt64u) { - (static_cast(context))->OnSuccessResponse_220(nullableInt32s); + (static_cast(context))->OnSuccessResponse_220(nullableInt64u); } static void OnFailureCallback_221(void * context, EmberAfStatus status) @@ -34983,9 +35139,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_222(chip::to_underlying(status)); } - static void OnSuccessCallback_222(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + static void OnSuccessCallback_222(void * context, const chip::app::DataModel::Nullable & nullableInt64u) { - (static_cast(context))->OnSuccessResponse_222(nullableInt32s); + (static_cast(context))->OnSuccessResponse_222(nullableInt64u); } static void OnFailureCallback_223(void * context, EmberAfStatus status) @@ -35000,9 +35156,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_224(chip::to_underlying(status)); } - static void OnSuccessCallback_224(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + static void OnSuccessCallback_224(void * context, const chip::app::DataModel::Nullable & nullableInt8s) { - (static_cast(context))->OnSuccessResponse_224(nullableInt64s); + (static_cast(context))->OnSuccessResponse_224(nullableInt8s); } static void OnFailureCallback_225(void * context, EmberAfStatus status) @@ -35017,9 +35173,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_226(chip::to_underlying(status)); } - static void OnSuccessCallback_226(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + static void OnSuccessCallback_226(void * context, const chip::app::DataModel::Nullable & nullableInt8s) { - (static_cast(context))->OnSuccessResponse_226(nullableInt64s); + (static_cast(context))->OnSuccessResponse_226(nullableInt8s); } static void OnFailureCallback_227(void * context, EmberAfStatus status) @@ -35034,9 +35190,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_228(chip::to_underlying(status)); } - static void OnSuccessCallback_228(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + static void OnSuccessCallback_228(void * context, const chip::app::DataModel::Nullable & nullableInt8s) { - (static_cast(context))->OnSuccessResponse_228(nullableInt64s); + (static_cast(context))->OnSuccessResponse_228(nullableInt8s); } static void OnFailureCallback_229(void * context, EmberAfStatus status) @@ -35051,9 +35207,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_230(chip::to_underlying(status)); } - static void OnSuccessCallback_230(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + static void OnSuccessCallback_230(void * context, const chip::app::DataModel::Nullable & nullableInt16s) { - (static_cast(context))->OnSuccessResponse_230(nullableEnum8); + (static_cast(context))->OnSuccessResponse_230(nullableInt16s); } static void OnFailureCallback_231(void * context, EmberAfStatus status) @@ -35068,9 +35224,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_232(chip::to_underlying(status)); } - static void OnSuccessCallback_232(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + static void OnSuccessCallback_232(void * context, const chip::app::DataModel::Nullable & nullableInt16s) { - (static_cast(context))->OnSuccessResponse_232(nullableEnum8); + (static_cast(context))->OnSuccessResponse_232(nullableInt16s); } static void OnFailureCallback_233(void * context, EmberAfStatus status) @@ -35085,9 +35241,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_234(chip::to_underlying(status)); } - static void OnSuccessCallback_234(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + static void OnSuccessCallback_234(void * context, const chip::app::DataModel::Nullable & nullableInt16s) { - (static_cast(context))->OnSuccessResponse_234(nullableEnum8); + (static_cast(context))->OnSuccessResponse_234(nullableInt16s); } static void OnFailureCallback_235(void * context, EmberAfStatus status) @@ -35102,9 +35258,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_236(chip::to_underlying(status)); } - static void OnSuccessCallback_236(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + static void OnSuccessCallback_236(void * context, const chip::app::DataModel::Nullable & nullableInt32s) { - (static_cast(context))->OnSuccessResponse_236(nullableEnum16); + (static_cast(context))->OnSuccessResponse_236(nullableInt32s); } static void OnFailureCallback_237(void * context, EmberAfStatus status) @@ -35119,9 +35275,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_238(chip::to_underlying(status)); } - static void OnSuccessCallback_238(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + static void OnSuccessCallback_238(void * context, const chip::app::DataModel::Nullable & nullableInt32s) { - (static_cast(context))->OnSuccessResponse_238(nullableEnum16); + (static_cast(context))->OnSuccessResponse_238(nullableInt32s); } static void OnFailureCallback_239(void * context, EmberAfStatus status) @@ -35136,9 +35292,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_240(chip::to_underlying(status)); } - static void OnSuccessCallback_240(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + static void OnSuccessCallback_240(void * context, const chip::app::DataModel::Nullable & nullableInt32s) { - (static_cast(context))->OnSuccessResponse_240(nullableEnum16); + (static_cast(context))->OnSuccessResponse_240(nullableInt32s); } static void OnFailureCallback_241(void * context, EmberAfStatus status) @@ -35146,70 +35302,67 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_241(chip::to_underlying(status)); } - static void OnSuccessCallback_241(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_241(nullableOctetString); - } + static void OnSuccessCallback_241(void * context) { (static_cast(context))->OnSuccessResponse_241(); } static void OnFailureCallback_242(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_242(chip::to_underlying(status)); } - static void OnSuccessCallback_242(void * context) { (static_cast(context))->OnSuccessResponse_242(); } + static void OnSuccessCallback_242(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + { + (static_cast(context))->OnSuccessResponse_242(nullableInt64s); + } 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::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_243(nullableOctetString); - } + static void OnSuccessCallback_243(void * context) { (static_cast(context))->OnSuccessResponse_243(); } static void OnFailureCallback_244(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_244(chip::to_underlying(status)); } - static void OnSuccessCallback_244(void * context) { (static_cast(context))->OnSuccessResponse_244(); } + static void OnSuccessCallback_244(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + { + (static_cast(context))->OnSuccessResponse_244(nullableInt64s); + } static void OnFailureCallback_245(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_245(chip::to_underlying(status)); } - static void OnSuccessCallback_245(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_245(nullableOctetString); - } + static void OnSuccessCallback_245(void * context) { (static_cast(context))->OnSuccessResponse_245(); } static void OnFailureCallback_246(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_246(chip::to_underlying(status)); } - static void OnSuccessCallback_246(void * context) { (static_cast(context))->OnSuccessResponse_246(); } + static void OnSuccessCallback_246(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + { + (static_cast(context))->OnSuccessResponse_246(nullableInt64s); + } static void OnFailureCallback_247(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_247(chip::to_underlying(status)); } - static void OnSuccessCallback_247(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_247(nullableOctetString); - } + static void OnSuccessCallback_247(void * context) { (static_cast(context))->OnSuccessResponse_247(); } static void OnFailureCallback_248(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_248(chip::to_underlying(status)); } - static void OnSuccessCallback_248(void * context, const chip::app::DataModel::Nullable & nullableCharString) + static void OnSuccessCallback_248(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) { - (static_cast(context))->OnSuccessResponse_248(nullableCharString); + (static_cast(context))->OnSuccessResponse_248(nullableFloatSingle); } static void OnFailureCallback_249(void * context, EmberAfStatus status) @@ -35224,9 +35377,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_250(chip::to_underlying(status)); } - static void OnSuccessCallback_250(void * context, const chip::app::DataModel::Nullable & nullableCharString) + static void OnSuccessCallback_250(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) { - (static_cast(context))->OnSuccessResponse_250(nullableCharString); + (static_cast(context))->OnSuccessResponse_250(nullableFloatSingle); } static void OnFailureCallback_251(void * context, EmberAfStatus status) @@ -35241,9 +35394,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_252(chip::to_underlying(status)); } - static void OnSuccessCallback_252(void * context, const chip::app::DataModel::Nullable & nullableCharString) + static void OnSuccessCallback_252(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) { - (static_cast(context))->OnSuccessResponse_252(nullableCharString); + (static_cast(context))->OnSuccessResponse_252(nullableFloatSingle); } static void OnFailureCallback_253(void * context, EmberAfStatus status) @@ -35258,9 +35411,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_254(chip::to_underlying(status)); } - static void OnSuccessCallback_254(void * context, const chip::app::DataModel::Nullable & nullableCharString) + static void OnSuccessCallback_254(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) { - (static_cast(context))->OnSuccessResponse_254(nullableCharString); + (static_cast(context))->OnSuccessResponse_254(nullableFloatSingle); } static void OnFailureCallback_255(void * context, EmberAfStatus status) @@ -35268,19 +35421,345 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_255(chip::to_underlying(status)); } - static void OnSuccessCallback_255(void * context, const chip::app::DataModel::DecodableList & listInt8u) - { - (static_cast(context))->OnSuccessResponse_255(listInt8u); - } + static void OnSuccessCallback_255(void * context) { (static_cast(context))->OnSuccessResponse_255(); } static void OnFailureCallback_256(void * context, EmberAfStatus status) { (static_cast(context))->OnFailureResponse_256(chip::to_underlying(status)); } - static void OnSuccessCallback_256(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnSuccessCallback_256(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) + { + (static_cast(context))->OnSuccessResponse_256(nullableFloatSingle); + } + + static void OnFailureCallback_257(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_257(chip::to_underlying(status)); + } + + static void OnSuccessCallback_257(void * context) { (static_cast(context))->OnSuccessResponse_257(); } + + static void OnFailureCallback_258(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_258(chip::to_underlying(status)); + } + + static void OnSuccessCallback_258(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) + { + (static_cast(context))->OnSuccessResponse_258(nullableFloatDouble); + } + + static void OnFailureCallback_259(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_259(chip::to_underlying(status)); + } + + static void OnSuccessCallback_259(void * context) { (static_cast(context))->OnSuccessResponse_259(); } + + static void OnFailureCallback_260(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_260(chip::to_underlying(status)); + } + + static void OnSuccessCallback_260(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) + { + (static_cast(context))->OnSuccessResponse_260(nullableFloatDouble); + } + + static void OnFailureCallback_261(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_261(chip::to_underlying(status)); + } + + static void OnSuccessCallback_261(void * context) { (static_cast(context))->OnSuccessResponse_261(); } + + static void OnFailureCallback_262(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_262(chip::to_underlying(status)); + } + + static void OnSuccessCallback_262(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) + { + (static_cast(context))->OnSuccessResponse_262(nullableFloatDouble); + } + + static void OnFailureCallback_263(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_263(chip::to_underlying(status)); + } + + static void OnSuccessCallback_263(void * context) { (static_cast(context))->OnSuccessResponse_263(); } + + static void OnFailureCallback_264(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_264(chip::to_underlying(status)); + } + + static void OnSuccessCallback_264(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) + { + (static_cast(context))->OnSuccessResponse_264(nullableFloatDouble); + } + + static void OnFailureCallback_265(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_265(chip::to_underlying(status)); + } + + static void OnSuccessCallback_265(void * context) { (static_cast(context))->OnSuccessResponse_265(); } + + static void OnFailureCallback_266(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_266(chip::to_underlying(status)); + } + + static void OnSuccessCallback_266(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) + { + (static_cast(context))->OnSuccessResponse_266(nullableFloatDouble); + } + + static void OnFailureCallback_267(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_267(chip::to_underlying(status)); + } + + static void OnSuccessCallback_267(void * context) { (static_cast(context))->OnSuccessResponse_267(); } + + static void OnFailureCallback_268(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_268(chip::to_underlying(status)); + } + + static void OnSuccessCallback_268(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + { + (static_cast(context))->OnSuccessResponse_268(nullableEnum8); + } + + static void OnFailureCallback_269(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_269(chip::to_underlying(status)); + } + + static void OnSuccessCallback_269(void * context) { (static_cast(context))->OnSuccessResponse_269(); } + + static void OnFailureCallback_270(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_270(chip::to_underlying(status)); + } + + static void OnSuccessCallback_270(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + { + (static_cast(context))->OnSuccessResponse_270(nullableEnum8); + } + + static void OnFailureCallback_271(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_271(chip::to_underlying(status)); + } + + static void OnSuccessCallback_271(void * context) { (static_cast(context))->OnSuccessResponse_271(); } + + static void OnFailureCallback_272(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_272(chip::to_underlying(status)); + } + + static void OnSuccessCallback_272(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + { + (static_cast(context))->OnSuccessResponse_272(nullableEnum8); + } + + static void OnFailureCallback_273(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_273(chip::to_underlying(status)); + } + + static void OnSuccessCallback_273(void * context) { (static_cast(context))->OnSuccessResponse_273(); } + + static void OnFailureCallback_274(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_274(chip::to_underlying(status)); + } + + static void OnSuccessCallback_274(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + { + (static_cast(context))->OnSuccessResponse_274(nullableEnum16); + } + + static void OnFailureCallback_275(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_275(chip::to_underlying(status)); + } + + static void OnSuccessCallback_275(void * context) { (static_cast(context))->OnSuccessResponse_275(); } + + static void OnFailureCallback_276(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_276(chip::to_underlying(status)); + } + + static void OnSuccessCallback_276(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + { + (static_cast(context))->OnSuccessResponse_276(nullableEnum16); + } + + static void OnFailureCallback_277(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_277(chip::to_underlying(status)); + } + + static void OnSuccessCallback_277(void * context) { (static_cast(context))->OnSuccessResponse_277(); } + + static void OnFailureCallback_278(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_278(chip::to_underlying(status)); + } + + static void OnSuccessCallback_278(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + { + (static_cast(context))->OnSuccessResponse_278(nullableEnum16); + } + + static void OnFailureCallback_279(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_279(chip::to_underlying(status)); + } + + static void OnSuccessCallback_279(void * context, const chip::app::DataModel::Nullable & nullableOctetString) + { + (static_cast(context))->OnSuccessResponse_279(nullableOctetString); + } + + static void OnFailureCallback_280(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_280(chip::to_underlying(status)); + } + + static void OnSuccessCallback_280(void * context) { (static_cast(context))->OnSuccessResponse_280(); } + + static void OnFailureCallback_281(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_281(chip::to_underlying(status)); + } + + static void OnSuccessCallback_281(void * context, const chip::app::DataModel::Nullable & nullableOctetString) + { + (static_cast(context))->OnSuccessResponse_281(nullableOctetString); + } + + static void OnFailureCallback_282(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_282(chip::to_underlying(status)); + } + + static void OnSuccessCallback_282(void * context) { (static_cast(context))->OnSuccessResponse_282(); } + + static void OnFailureCallback_283(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_283(chip::to_underlying(status)); + } + + static void OnSuccessCallback_283(void * context, const chip::app::DataModel::Nullable & nullableOctetString) + { + (static_cast(context))->OnSuccessResponse_283(nullableOctetString); + } + + static void OnFailureCallback_284(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_284(chip::to_underlying(status)); + } + + static void OnSuccessCallback_284(void * context) { (static_cast(context))->OnSuccessResponse_284(); } + + static void OnFailureCallback_285(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_285(chip::to_underlying(status)); + } + + static void OnSuccessCallback_285(void * context, const chip::app::DataModel::Nullable & nullableOctetString) + { + (static_cast(context))->OnSuccessResponse_285(nullableOctetString); + } + + static void OnFailureCallback_286(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_286(chip::to_underlying(status)); + } + + static void OnSuccessCallback_286(void * context, const chip::app::DataModel::Nullable & nullableCharString) + { + (static_cast(context))->OnSuccessResponse_286(nullableCharString); + } + + static void OnFailureCallback_287(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_287(chip::to_underlying(status)); + } + + static void OnSuccessCallback_287(void * context) { (static_cast(context))->OnSuccessResponse_287(); } + + static void OnFailureCallback_288(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_288(chip::to_underlying(status)); + } + + static void OnSuccessCallback_288(void * context, const chip::app::DataModel::Nullable & nullableCharString) + { + (static_cast(context))->OnSuccessResponse_288(nullableCharString); + } + + static void OnFailureCallback_289(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_289(chip::to_underlying(status)); + } + + static void OnSuccessCallback_289(void * context) { (static_cast(context))->OnSuccessResponse_289(); } + + static void OnFailureCallback_290(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_290(chip::to_underlying(status)); + } + + static void OnSuccessCallback_290(void * context, const chip::app::DataModel::Nullable & nullableCharString) + { + (static_cast(context))->OnSuccessResponse_290(nullableCharString); + } + + static void OnFailureCallback_291(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_291(chip::to_underlying(status)); + } + + static void OnSuccessCallback_291(void * context) { (static_cast(context))->OnSuccessResponse_291(); } + + static void OnFailureCallback_292(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_292(chip::to_underlying(status)); + } + + static void OnSuccessCallback_292(void * context, const chip::app::DataModel::Nullable & nullableCharString) + { + (static_cast(context))->OnSuccessResponse_292(nullableCharString); + } + + static void OnFailureCallback_293(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_293(chip::to_underlying(status)); + } + + static void OnSuccessCallback_293(void * context, const chip::app::DataModel::DecodableList & listInt8u) + { + (static_cast(context))->OnSuccessResponse_293(listInt8u); + } + + static void OnFailureCallback_294(void * context, EmberAfStatus status) + { + (static_cast(context))->OnFailureResponse_294(chip::to_underlying(status)); + } + + static void OnSuccessCallback_294(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnSuccessResponse_256(listInt8u); + (static_cast(context))->OnSuccessResponse_294(listInt8u); } // @@ -36757,26 +37236,352 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeEnum8DefaultValue_79() + CHIP_ERROR TestReadAttributeSingleDefaultValue_79() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_79, - OnFailureCallback_79); + return cluster.ReadAttribute( + this, OnSuccessCallback_79, OnFailureCallback_79); } void OnFailureResponse_79(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_79(uint8_t enum8) + void OnSuccessResponse_79(float floatSingle) + { + VerifyOrReturn(CheckValue("floatSingle", floatSingle, 0.0f)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeSingleMediumValue_80() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + float floatSingleArgument; + floatSingleArgument = 0.1f; + + return cluster.WriteAttribute( + floatSingleArgument, this, OnSuccessCallback_80, OnFailureCallback_80); + } + + void OnFailureResponse_80(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_80() { NextTest(); } + + CHIP_ERROR TestReadAttributeSingleMediumValue_81() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_81, OnFailureCallback_81); + } + + void OnFailureResponse_81(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_81(float floatSingle) + { + VerifyOrReturn(CheckValue("floatSingle", floatSingle, 0.1f)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeSingleLargeValue_82() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + float floatSingleArgument; + floatSingleArgument = 17000000000.0f; + + return cluster.WriteAttribute( + floatSingleArgument, this, OnSuccessCallback_82, OnFailureCallback_82); + } + + void OnFailureResponse_82(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_82() { NextTest(); } + + CHIP_ERROR TestReadAttributeSingleLargeValue_83() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_83, OnFailureCallback_83); + } + + void OnFailureResponse_83(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_83(float floatSingle) + { + VerifyOrReturn(CheckValue("floatSingle", floatSingle, 17000000000.0f)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeSingleSmallValue_84() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + float floatSingleArgument; + floatSingleArgument = 1.7e-10f; + + return cluster.WriteAttribute( + floatSingleArgument, this, OnSuccessCallback_84, OnFailureCallback_84); + } + + void OnFailureResponse_84(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_84() { NextTest(); } + + CHIP_ERROR TestReadAttributeSingleSmallValue_85() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_85, OnFailureCallback_85); + } + + void OnFailureResponse_85(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_85(float floatSingle) + { + VerifyOrReturn(CheckValue("floatSingle", floatSingle, 1.7e-10f)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeSingleDefaultValue_86() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + float floatSingleArgument; + floatSingleArgument = 0.0f; + + return cluster.WriteAttribute( + floatSingleArgument, this, OnSuccessCallback_86, OnFailureCallback_86); + } + + void OnFailureResponse_86(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_86() { NextTest(); } + + CHIP_ERROR TestReadAttributeSingleDefaultValue_87() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_87, OnFailureCallback_87); + } + + void OnFailureResponse_87(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_87(float floatSingle) + { + VerifyOrReturn(CheckValue("floatSingle", floatSingle, 0.0f)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeDoubleDefaultValue_88() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_88, OnFailureCallback_88); + } + + void OnFailureResponse_88(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_88(double floatDouble) + { + VerifyOrReturn(CheckValue("floatDouble", floatDouble, 0)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeDoubleMediumValue_89() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + double floatDoubleArgument; + floatDoubleArgument = 0.1234567890123; + + return cluster.WriteAttribute( + floatDoubleArgument, this, OnSuccessCallback_89, OnFailureCallback_89); + } + + void OnFailureResponse_89(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_89() { NextTest(); } + + CHIP_ERROR TestReadAttributeDoubleMediumValue_90() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_90, OnFailureCallback_90); + } + + void OnFailureResponse_90(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_90(double floatDouble) + { + VerifyOrReturn(CheckValue("floatDouble", floatDouble, 0.1234567890123)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeDoubleLargeValue_91() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + double floatDoubleArgument; + floatDoubleArgument = 1.7e+200; + + return cluster.WriteAttribute( + floatDoubleArgument, this, OnSuccessCallback_91, OnFailureCallback_91); + } + + void OnFailureResponse_91(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_91() { NextTest(); } + + CHIP_ERROR TestReadAttributeDoubleLargeValue_92() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_92, OnFailureCallback_92); + } + + void OnFailureResponse_92(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_92(double floatDouble) + { + VerifyOrReturn(CheckValue("floatDouble", floatDouble, 1.7e+200)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeDoubleSmallValue_93() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + double floatDoubleArgument; + floatDoubleArgument = 1.7e-200; + + return cluster.WriteAttribute( + floatDoubleArgument, this, OnSuccessCallback_93, OnFailureCallback_93); + } + + void OnFailureResponse_93(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_93() { NextTest(); } + + CHIP_ERROR TestReadAttributeDoubleSmallValue_94() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_94, OnFailureCallback_94); + } + + void OnFailureResponse_94(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_94(double floatDouble) + { + VerifyOrReturn(CheckValue("floatDouble", floatDouble, 1.7e-200)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeDoubleDefaultValue_95() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + double floatDoubleArgument; + floatDoubleArgument = 0; + + return cluster.WriteAttribute( + floatDoubleArgument, this, OnSuccessCallback_95, OnFailureCallback_95); + } + + void OnFailureResponse_95(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_95() { NextTest(); } + + CHIP_ERROR TestReadAttributeDoubleDefaultValue_96() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_96, OnFailureCallback_96); + } + + void OnFailureResponse_96(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_96(double floatDouble) + { + VerifyOrReturn(CheckValue("floatDouble", floatDouble, 0)); + + NextTest(); + } + + CHIP_ERROR TestReadAttributeEnum8DefaultValue_97() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute(this, OnSuccessCallback_97, + OnFailureCallback_97); + } + + void OnFailureResponse_97(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_97(uint8_t enum8) { VerifyOrReturn(CheckValue("enum8", enum8, 0)); NextTest(); } - CHIP_ERROR TestWriteAttributeEnum8MaxValue_80() + CHIP_ERROR TestWriteAttributeEnum8MaxValue_98() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36786,33 +37591,33 @@ class TestCluster : public TestCommand enum8Argument = static_cast(255); return cluster.WriteAttribute( - enum8Argument, this, OnSuccessCallback_80, OnFailureCallback_80); + enum8Argument, this, OnSuccessCallback_98, OnFailureCallback_98); } - void OnFailureResponse_80(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_98(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_80() { NextTest(); } + void OnSuccessResponse_98() { NextTest(); } - CHIP_ERROR TestReadAttributeEnum8MaxValue_81() + CHIP_ERROR TestReadAttributeEnum8MaxValue_99() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_81, - OnFailureCallback_81); + return cluster.ReadAttribute(this, OnSuccessCallback_99, + OnFailureCallback_99); } - void OnFailureResponse_81(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_99(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_81(uint8_t enum8) + void OnSuccessResponse_99(uint8_t enum8) { VerifyOrReturn(CheckValue("enum8", enum8, 255)); NextTest(); } - CHIP_ERROR TestWriteAttributeEnum8MinValue_82() + CHIP_ERROR TestWriteAttributeEnum8MinValue_100() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36822,52 +37627,52 @@ class TestCluster : public TestCommand enum8Argument = static_cast(0); return cluster.WriteAttribute( - enum8Argument, this, OnSuccessCallback_82, OnFailureCallback_82); + enum8Argument, this, OnSuccessCallback_100, OnFailureCallback_100); } - void OnFailureResponse_82(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_100(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_82() { NextTest(); } + void OnSuccessResponse_100() { NextTest(); } - CHIP_ERROR TestReadAttributeEnum8MinValue_83() + CHIP_ERROR TestReadAttributeEnum8MinValue_101() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_83, - OnFailureCallback_83); + return cluster.ReadAttribute(this, OnSuccessCallback_101, + OnFailureCallback_101); } - void OnFailureResponse_83(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_101(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_83(uint8_t enum8) + void OnSuccessResponse_101(uint8_t enum8) { VerifyOrReturn(CheckValue("enum8", enum8, 0)); NextTest(); } - CHIP_ERROR TestReadAttributeEnum16DefaultValue_84() + CHIP_ERROR TestReadAttributeEnum16DefaultValue_102() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_84, - OnFailureCallback_84); + return cluster.ReadAttribute(this, OnSuccessCallback_102, + OnFailureCallback_102); } - void OnFailureResponse_84(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_102(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_84(uint16_t enum16) + void OnSuccessResponse_102(uint16_t enum16) { VerifyOrReturn(CheckValue("enum16", enum16, 0U)); NextTest(); } - CHIP_ERROR TestWriteAttributeEnum16MaxValue_85() + CHIP_ERROR TestWriteAttributeEnum16MaxValue_103() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36877,33 +37682,33 @@ class TestCluster : public TestCommand enum16Argument = static_cast(65535); return cluster.WriteAttribute( - enum16Argument, this, OnSuccessCallback_85, OnFailureCallback_85); + enum16Argument, this, OnSuccessCallback_103, OnFailureCallback_103); } - void OnFailureResponse_85(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_103(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_85() { NextTest(); } + void OnSuccessResponse_103() { NextTest(); } - CHIP_ERROR TestReadAttributeEnum16MaxValue_86() + CHIP_ERROR TestReadAttributeEnum16MaxValue_104() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_86, - OnFailureCallback_86); + return cluster.ReadAttribute(this, OnSuccessCallback_104, + OnFailureCallback_104); } - void OnFailureResponse_86(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_104(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_86(uint16_t enum16) + void OnSuccessResponse_104(uint16_t enum16) { VerifyOrReturn(CheckValue("enum16", enum16, 65535U)); NextTest(); } - CHIP_ERROR TestWriteAttributeEnum16MinValue_87() + CHIP_ERROR TestWriteAttributeEnum16MinValue_105() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36913,52 +37718,52 @@ class TestCluster : public TestCommand enum16Argument = static_cast(0); return cluster.WriteAttribute( - enum16Argument, this, OnSuccessCallback_87, OnFailureCallback_87); + enum16Argument, this, OnSuccessCallback_105, OnFailureCallback_105); } - void OnFailureResponse_87(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_105(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_87() { NextTest(); } + void OnSuccessResponse_105() { NextTest(); } - CHIP_ERROR TestReadAttributeEnum16MinValue_88() + CHIP_ERROR TestReadAttributeEnum16MinValue_106() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_88, - OnFailureCallback_88); + return cluster.ReadAttribute(this, OnSuccessCallback_106, + OnFailureCallback_106); } - void OnFailureResponse_88(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_106(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_88(uint16_t enum16) + void OnSuccessResponse_106(uint16_t enum16) { VerifyOrReturn(CheckValue("enum16", enum16, 0U)); NextTest(); } - CHIP_ERROR TestReadAttributeOctetStringDefaultValue_89() + CHIP_ERROR TestReadAttributeOctetStringDefaultValue_107() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_89, OnFailureCallback_89); + this, OnSuccessCallback_107, OnFailureCallback_107); } - void OnFailureResponse_89(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_107(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_89(chip::ByteSpan octetString) + void OnSuccessResponse_107(chip::ByteSpan octetString) { VerifyOrReturn(CheckValueAsString("octetString", octetString, chip::ByteSpan(chip::Uint8::from_const_char(""), 0))); NextTest(); } - CHIP_ERROR TestWriteAttributeOctetStringWithEmbeddedNull_90() + CHIP_ERROR TestWriteAttributeOctetStringWithEmbeddedNull_108() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -36968,26 +37773,26 @@ class TestCluster : public TestCommand octetStringArgument = chip::ByteSpan(chip::Uint8::from_const_char("Tes\x00ti\x00nggarbage: not in length on purpose"), 9); return cluster.WriteAttribute( - octetStringArgument, this, OnSuccessCallback_90, OnFailureCallback_90); + octetStringArgument, this, OnSuccessCallback_108, OnFailureCallback_108); } - void OnFailureResponse_90(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_108(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_90() { NextTest(); } + void OnSuccessResponse_108() { NextTest(); } - CHIP_ERROR TestReadAttributeOctetStringWithEmbeddedNull_91() + CHIP_ERROR TestReadAttributeOctetStringWithEmbeddedNull_109() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_91, OnFailureCallback_91); + this, OnSuccessCallback_109, OnFailureCallback_109); } - void OnFailureResponse_91(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_109(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_91(chip::ByteSpan octetString) + void OnSuccessResponse_109(chip::ByteSpan octetString) { VerifyOrReturn( CheckValueAsString("octetString", octetString, chip::ByteSpan(chip::Uint8::from_const_char("Tes\x00ti\x00ng"), 9))); @@ -36995,7 +37800,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeOctetString_92() + CHIP_ERROR TestWriteAttributeOctetString_110() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37005,26 +37810,26 @@ class TestCluster : public TestCommand octetStringArgument = chip::ByteSpan(chip::Uint8::from_const_char("TestValuegarbage: not in length on purpose"), 9); return cluster.WriteAttribute( - octetStringArgument, this, OnSuccessCallback_92, OnFailureCallback_92); + octetStringArgument, this, OnSuccessCallback_110, OnFailureCallback_110); } - void OnFailureResponse_92(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_110(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_92() { NextTest(); } + void OnSuccessResponse_110() { NextTest(); } - CHIP_ERROR TestReadAttributeOctetString_93() + CHIP_ERROR TestReadAttributeOctetString_111() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_93, OnFailureCallback_93); + this, OnSuccessCallback_111, OnFailureCallback_111); } - void OnFailureResponse_93(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_111(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_93(chip::ByteSpan octetString) + void OnSuccessResponse_111(chip::ByteSpan octetString) { VerifyOrReturn( CheckValueAsString("octetString", octetString, chip::ByteSpan(chip::Uint8::from_const_char("TestValue"), 9))); @@ -37032,7 +37837,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeOctetString_94() + CHIP_ERROR TestWriteAttributeOctetString_112() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37043,30 +37848,30 @@ class TestCluster : public TestCommand chip::ByteSpan(chip::Uint8::from_const_char("TestValueLongerThan10garbage: not in length on purpose"), 21); return cluster.WriteAttribute( - octetStringArgument, this, OnSuccessCallback_94, OnFailureCallback_94); + octetStringArgument, this, OnSuccessCallback_112, OnFailureCallback_112); } - void OnFailureResponse_94(uint8_t status) + void OnFailureResponse_112(uint8_t status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_94() { ThrowSuccessResponse(); } + void OnSuccessResponse_112() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeOctetString_95() + CHIP_ERROR TestReadAttributeOctetString_113() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_95, OnFailureCallback_95); + this, OnSuccessCallback_113, OnFailureCallback_113); } - void OnFailureResponse_95(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_113(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_95(chip::ByteSpan octetString) + void OnSuccessResponse_113(chip::ByteSpan octetString) { VerifyOrReturn( CheckValueAsString("octetString", octetString, chip::ByteSpan(chip::Uint8::from_const_char("TestValue"), 9))); @@ -37074,7 +37879,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeOctetString_96() + CHIP_ERROR TestWriteAttributeOctetString_114() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37084,33 +37889,33 @@ class TestCluster : public TestCommand octetStringArgument = chip::ByteSpan(chip::Uint8::from_const_char("garbage: not in length on purpose"), 0); return cluster.WriteAttribute( - octetStringArgument, this, OnSuccessCallback_96, OnFailureCallback_96); + octetStringArgument, this, OnSuccessCallback_114, OnFailureCallback_114); } - void OnFailureResponse_96(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_114(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_96() { NextTest(); } + void OnSuccessResponse_114() { NextTest(); } - CHIP_ERROR TestReadAttributeLongOctetStringDefaultValue_97() + CHIP_ERROR TestReadAttributeLongOctetStringDefaultValue_115() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_97, OnFailureCallback_97); + this, OnSuccessCallback_115, OnFailureCallback_115); } - void OnFailureResponse_97(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_115(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_97(chip::ByteSpan longOctetString) + void OnSuccessResponse_115(chip::ByteSpan longOctetString) { VerifyOrReturn(CheckValueAsString("longOctetString", longOctetString, chip::ByteSpan(chip::Uint8::from_const_char(""), 0))); NextTest(); } - CHIP_ERROR TestWriteAttributeLongOctetString_98() + CHIP_ERROR TestWriteAttributeLongOctetString_116() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37125,26 +37930,26 @@ class TestCluster : public TestCommand 300); return cluster.WriteAttribute( - longOctetStringArgument, this, OnSuccessCallback_98, OnFailureCallback_98); + longOctetStringArgument, this, OnSuccessCallback_116, OnFailureCallback_116); } - void OnFailureResponse_98(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_116(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_98() { NextTest(); } + void OnSuccessResponse_116() { NextTest(); } - CHIP_ERROR TestReadAttributeLongOctetString_99() + CHIP_ERROR TestReadAttributeLongOctetString_117() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_99, OnFailureCallback_99); + this, OnSuccessCallback_117, OnFailureCallback_117); } - void OnFailureResponse_99(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_117(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_99(chip::ByteSpan longOctetString) + void OnSuccessResponse_117(chip::ByteSpan longOctetString) { VerifyOrReturn(CheckValueAsString( "longOctetString", longOctetString, @@ -37158,7 +37963,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeLongOctetString_100() + CHIP_ERROR TestWriteAttributeLongOctetString_118() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37168,33 +37973,33 @@ class TestCluster : public TestCommand longOctetStringArgument = chip::ByteSpan(chip::Uint8::from_const_char("garbage: not in length on purpose"), 0); return cluster.WriteAttribute( - longOctetStringArgument, this, OnSuccessCallback_100, OnFailureCallback_100); + longOctetStringArgument, this, OnSuccessCallback_118, OnFailureCallback_118); } - void OnFailureResponse_100(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_118(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_100() { NextTest(); } + void OnSuccessResponse_118() { NextTest(); } - CHIP_ERROR TestReadAttributeCharStringDefaultValue_101() + CHIP_ERROR TestReadAttributeCharStringDefaultValue_119() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_101, OnFailureCallback_101); + this, OnSuccessCallback_119, OnFailureCallback_119); } - void OnFailureResponse_101(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_119(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_101(chip::CharSpan charString) + void OnSuccessResponse_119(chip::CharSpan charString) { VerifyOrReturn(CheckValueAsString("charString", charString, chip::CharSpan("", 0))); NextTest(); } - CHIP_ERROR TestWriteAttributeCharString_102() + CHIP_ERROR TestWriteAttributeCharString_120() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37204,33 +38009,33 @@ class TestCluster : public TestCommand charStringArgument = chip::Span("☉T☉garbage: not in length on purpose", 7); return cluster.WriteAttribute( - charStringArgument, this, OnSuccessCallback_102, OnFailureCallback_102); + charStringArgument, this, OnSuccessCallback_120, OnFailureCallback_120); } - void OnFailureResponse_102(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_120(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_102() { NextTest(); } + void OnSuccessResponse_120() { NextTest(); } - CHIP_ERROR TestReadAttributeCharString_103() + CHIP_ERROR TestReadAttributeCharString_121() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_103, OnFailureCallback_103); + this, OnSuccessCallback_121, OnFailureCallback_121); } - void OnFailureResponse_103(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_121(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_103(chip::CharSpan charString) + void OnSuccessResponse_121(chip::CharSpan charString) { VerifyOrReturn(CheckValueAsString("charString", charString, chip::CharSpan("☉T☉", 7))); NextTest(); } - CHIP_ERROR TestWriteAttributeCharStringValueTooLong_104() + CHIP_ERROR TestWriteAttributeCharStringValueTooLong_122() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37240,37 +38045,37 @@ class TestCluster : public TestCommand charStringArgument = chip::Span("☉TestValueLongerThan10☉garbage: not in length on purpose", 27); return cluster.WriteAttribute( - charStringArgument, this, OnSuccessCallback_104, OnFailureCallback_104); + charStringArgument, this, OnSuccessCallback_122, OnFailureCallback_122); } - void OnFailureResponse_104(uint8_t status) + void OnFailureResponse_122(uint8_t status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_104() { ThrowSuccessResponse(); } + void OnSuccessResponse_122() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeCharString_105() + CHIP_ERROR TestReadAttributeCharString_123() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_105, OnFailureCallback_105); + this, OnSuccessCallback_123, OnFailureCallback_123); } - void OnFailureResponse_105(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_123(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_105(chip::CharSpan charString) + void OnSuccessResponse_123(chip::CharSpan charString) { VerifyOrReturn(CheckValueAsString("charString", charString, chip::CharSpan("☉T☉", 7))); NextTest(); } - CHIP_ERROR TestWriteAttributeCharStringEmpty_106() + CHIP_ERROR TestWriteAttributeCharStringEmpty_124() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37280,33 +38085,33 @@ class TestCluster : public TestCommand charStringArgument = chip::Span("garbage: not in length on purpose", 0); return cluster.WriteAttribute( - charStringArgument, this, OnSuccessCallback_106, OnFailureCallback_106); + charStringArgument, this, OnSuccessCallback_124, OnFailureCallback_124); } - void OnFailureResponse_106(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_124(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_106() { NextTest(); } + void OnSuccessResponse_124() { NextTest(); } - CHIP_ERROR TestReadAttributeLongCharStringDefaultValue_107() + CHIP_ERROR TestReadAttributeLongCharStringDefaultValue_125() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_107, OnFailureCallback_107); + this, OnSuccessCallback_125, OnFailureCallback_125); } - void OnFailureResponse_107(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_125(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_107(chip::CharSpan longCharString) + void OnSuccessResponse_125(chip::CharSpan longCharString) { VerifyOrReturn(CheckValueAsString("longCharString", longCharString, chip::CharSpan("", 0))); NextTest(); } - CHIP_ERROR TestWriteAttributeLongCharString_108() + CHIP_ERROR TestWriteAttributeLongCharString_126() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37320,26 +38125,26 @@ class TestCluster : public TestCommand 900); return cluster.WriteAttribute( - longCharStringArgument, this, OnSuccessCallback_108, OnFailureCallback_108); + longCharStringArgument, this, OnSuccessCallback_126, OnFailureCallback_126); } - void OnFailureResponse_108(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_126(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_108() { NextTest(); } + void OnSuccessResponse_126() { NextTest(); } - CHIP_ERROR TestReadAttributeLongCharString_109() + CHIP_ERROR TestReadAttributeLongCharString_127() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_109, OnFailureCallback_109); + this, OnSuccessCallback_127, OnFailureCallback_127); } - void OnFailureResponse_109(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_127(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_109(chip::CharSpan longCharString) + void OnSuccessResponse_127(chip::CharSpan longCharString) { VerifyOrReturn(CheckValueAsString( "longCharString", longCharString, @@ -37351,7 +38156,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeLongCharString_110() + CHIP_ERROR TestWriteAttributeLongCharString_128() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37361,33 +38166,33 @@ class TestCluster : public TestCommand longCharStringArgument = chip::Span("garbage: not in length on purpose", 0); return cluster.WriteAttribute( - longCharStringArgument, this, OnSuccessCallback_110, OnFailureCallback_110); + longCharStringArgument, this, OnSuccessCallback_128, OnFailureCallback_128); } - void OnFailureResponse_110(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_128(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_110() { NextTest(); } + void OnSuccessResponse_128() { NextTest(); } - CHIP_ERROR TestReadAttributeEpochUsDefaultValue_111() + CHIP_ERROR TestReadAttributeEpochUsDefaultValue_129() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_111, - OnFailureCallback_111); + return cluster.ReadAttribute(this, OnSuccessCallback_129, + OnFailureCallback_129); } - void OnFailureResponse_111(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_129(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_111(uint64_t epochUs) + void OnSuccessResponse_129(uint64_t epochUs) { VerifyOrReturn(CheckValue("epochUs", epochUs, 0ULL)); NextTest(); } - CHIP_ERROR TestWriteAttributeEpochUsMaxValue_112() + CHIP_ERROR TestWriteAttributeEpochUsMaxValue_130() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37397,33 +38202,33 @@ class TestCluster : public TestCommand epochUsArgument = 18446744073709551615ULL; return cluster.WriteAttribute( - epochUsArgument, this, OnSuccessCallback_112, OnFailureCallback_112); + epochUsArgument, this, OnSuccessCallback_130, OnFailureCallback_130); } - void OnFailureResponse_112(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_130(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_112() { NextTest(); } + void OnSuccessResponse_130() { NextTest(); } - CHIP_ERROR TestReadAttributeEpochUsMaxValue_113() + CHIP_ERROR TestReadAttributeEpochUsMaxValue_131() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_113, - OnFailureCallback_113); + return cluster.ReadAttribute(this, OnSuccessCallback_131, + OnFailureCallback_131); } - void OnFailureResponse_113(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_131(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_113(uint64_t epochUs) + void OnSuccessResponse_131(uint64_t epochUs) { VerifyOrReturn(CheckValue("epochUs", epochUs, 18446744073709551615ULL)); NextTest(); } - CHIP_ERROR TestWriteAttributeEpochUsMinValue_114() + CHIP_ERROR TestWriteAttributeEpochUsMinValue_132() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37433,52 +38238,52 @@ class TestCluster : public TestCommand epochUsArgument = 0ULL; return cluster.WriteAttribute( - epochUsArgument, this, OnSuccessCallback_114, OnFailureCallback_114); + epochUsArgument, this, OnSuccessCallback_132, OnFailureCallback_132); } - void OnFailureResponse_114(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_132(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_114() { NextTest(); } + void OnSuccessResponse_132() { NextTest(); } - CHIP_ERROR TestReadAttributeEpochUsMinValue_115() + CHIP_ERROR TestReadAttributeEpochUsMinValue_133() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_115, - OnFailureCallback_115); + return cluster.ReadAttribute(this, OnSuccessCallback_133, + OnFailureCallback_133); } - void OnFailureResponse_115(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_133(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_115(uint64_t epochUs) + void OnSuccessResponse_133(uint64_t epochUs) { VerifyOrReturn(CheckValue("epochUs", epochUs, 0ULL)); NextTest(); } - CHIP_ERROR TestReadAttributeEpochSDefaultValue_116() + CHIP_ERROR TestReadAttributeEpochSDefaultValue_134() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_116, - OnFailureCallback_116); + return cluster.ReadAttribute(this, OnSuccessCallback_134, + OnFailureCallback_134); } - void OnFailureResponse_116(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_134(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_116(uint32_t epochS) + void OnSuccessResponse_134(uint32_t epochS) { VerifyOrReturn(CheckValue("epochS", epochS, 0UL)); NextTest(); } - CHIP_ERROR TestWriteAttributeEpochSMaxValue_117() + CHIP_ERROR TestWriteAttributeEpochSMaxValue_135() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37488,33 +38293,33 @@ class TestCluster : public TestCommand epochSArgument = 4294967295UL; return cluster.WriteAttribute( - epochSArgument, this, OnSuccessCallback_117, OnFailureCallback_117); + epochSArgument, this, OnSuccessCallback_135, OnFailureCallback_135); } - void OnFailureResponse_117(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_135(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_117() { NextTest(); } + void OnSuccessResponse_135() { NextTest(); } - CHIP_ERROR TestReadAttributeEpochSMaxValue_118() + CHIP_ERROR TestReadAttributeEpochSMaxValue_136() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_118, - OnFailureCallback_118); + return cluster.ReadAttribute(this, OnSuccessCallback_136, + OnFailureCallback_136); } - void OnFailureResponse_118(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_136(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_118(uint32_t epochS) + void OnSuccessResponse_136(uint32_t epochS) { VerifyOrReturn(CheckValue("epochS", epochS, 4294967295UL)); NextTest(); } - CHIP_ERROR TestWriteAttributeEpochSMinValue_119() + CHIP_ERROR TestWriteAttributeEpochSMinValue_137() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37524,55 +38329,55 @@ class TestCluster : public TestCommand epochSArgument = 0UL; return cluster.WriteAttribute( - epochSArgument, this, OnSuccessCallback_119, OnFailureCallback_119); + epochSArgument, this, OnSuccessCallback_137, OnFailureCallback_137); } - void OnFailureResponse_119(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_137(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_119() { NextTest(); } + void OnSuccessResponse_137() { NextTest(); } - CHIP_ERROR TestReadAttributeEpochSMinValue_120() + CHIP_ERROR TestReadAttributeEpochSMinValue_138() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_120, - OnFailureCallback_120); + return cluster.ReadAttribute(this, OnSuccessCallback_138, + OnFailureCallback_138); } - void OnFailureResponse_120(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_138(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_120(uint32_t epochS) + void OnSuccessResponse_138(uint32_t epochS) { VerifyOrReturn(CheckValue("epochS", epochS, 0UL)); NextTest(); } - CHIP_ERROR TestReadAttributeUnsupported_121() + CHIP_ERROR TestReadAttributeUnsupported_139() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_121, OnFailureCallback_121); + this, OnSuccessCallback_139, OnFailureCallback_139); } - void OnFailureResponse_121(uint8_t status) + void OnFailureResponse_139(uint8_t status) { (status == EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE) ? NextTest() : ThrowFailureResponse(); } - void OnSuccessResponse_121(bool unsupported) + void OnSuccessResponse_139(bool unsupported) { VerifyOrReturn(CheckValue("unsupported", unsupported, 0)); NextTest(); } - CHIP_ERROR TestWriteattributeUnsupported_122() + CHIP_ERROR TestWriteattributeUnsupported_140() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37582,17 +38387,17 @@ class TestCluster : public TestCommand unsupportedArgument = 0; return cluster.WriteAttribute( - unsupportedArgument, this, OnSuccessCallback_122, OnFailureCallback_122); + unsupportedArgument, this, OnSuccessCallback_140, OnFailureCallback_140); } - void OnFailureResponse_122(uint8_t status) + void OnFailureResponse_140(uint8_t status) { (status == EMBER_ZCL_STATUS_UNSUPPORTED_ATTRIBUTE) ? NextTest() : ThrowFailureResponse(); } - void OnSuccessResponse_122() { NextTest(); } + void OnSuccessResponse_140() { NextTest(); } - CHIP_ERROR TestSendTestCommandToUnsupportedEndpoint_123() + CHIP_ERROR TestSendTestCommandToUnsupportedEndpoint_141() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 200; using RequestType = chip::app::Clusters::TestCluster::Commands::Test::Type; @@ -37600,26 +38405,26 @@ class TestCluster : public TestCommand RequestType request; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_123(); + (static_cast(context))->OnSuccessResponse_141(); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_123(status); + (static_cast(context))->OnFailureResponse_141(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_123(uint8_t status) + void OnFailureResponse_141(uint8_t status) { VerifyOrReturn(CheckConstraintNotValue("status", status, 0)); NextTest(); } - void OnSuccessResponse_123() { ThrowSuccessResponse(); } + void OnSuccessResponse_141() { ThrowSuccessResponse(); } - CHIP_ERROR TestSendTestCommandToUnsupportedCluster_124() + CHIP_ERROR TestSendTestCommandToUnsupportedCluster_142() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 0; using RequestType = chip::app::Clusters::TestCluster::Commands::Test::Type; @@ -37627,45 +38432,45 @@ class TestCluster : public TestCommand RequestType request; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_124(); + (static_cast(context))->OnSuccessResponse_142(); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_124(status); + (static_cast(context))->OnFailureResponse_142(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_124(uint8_t status) + void OnFailureResponse_142(uint8_t status) { VerifyOrReturn(CheckConstraintNotValue("status", status, 0)); NextTest(); } - void OnSuccessResponse_124() { ThrowSuccessResponse(); } + void OnSuccessResponse_142() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeVendorIdDefaultValue_125() + CHIP_ERROR TestReadAttributeVendorIdDefaultValue_143() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_125, - OnFailureCallback_125); + return cluster.ReadAttribute(this, OnSuccessCallback_143, + OnFailureCallback_143); } - void OnFailureResponse_125(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_143(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_125(chip::VendorId vendorId) + void OnSuccessResponse_143(chip::VendorId vendorId) { VerifyOrReturn(CheckValue("vendorId", vendorId, 0U)); NextTest(); } - CHIP_ERROR TestWriteAttributeVendorId_126() + CHIP_ERROR TestWriteAttributeVendorId_144() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37675,33 +38480,33 @@ class TestCluster : public TestCommand vendorIdArgument = static_cast(17); return cluster.WriteAttribute( - vendorIdArgument, this, OnSuccessCallback_126, OnFailureCallback_126); + vendorIdArgument, this, OnSuccessCallback_144, OnFailureCallback_144); } - void OnFailureResponse_126(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_144(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_126() { NextTest(); } + void OnSuccessResponse_144() { NextTest(); } - CHIP_ERROR TestReadAttributeVendorId_127() + CHIP_ERROR TestReadAttributeVendorId_145() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_127, - OnFailureCallback_127); + return cluster.ReadAttribute(this, OnSuccessCallback_145, + OnFailureCallback_145); } - void OnFailureResponse_127(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_145(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_127(chip::VendorId vendorId) + void OnSuccessResponse_145(chip::VendorId vendorId) { VerifyOrReturn(CheckValue("vendorId", vendorId, 17U)); NextTest(); } - CHIP_ERROR TestRestoreAttributeVendorId_128() + CHIP_ERROR TestRestoreAttributeVendorId_146() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -37711,14 +38516,14 @@ class TestCluster : public TestCommand vendorIdArgument = static_cast(0); return cluster.WriteAttribute( - vendorIdArgument, this, OnSuccessCallback_128, OnFailureCallback_128); + vendorIdArgument, this, OnSuccessCallback_146, OnFailureCallback_146); } - void OnFailureResponse_128(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_146(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_128() { NextTest(); } + void OnSuccessResponse_146() { NextTest(); } - CHIP_ERROR TestSendACommandWithAVendorIdAndEnum_129() + CHIP_ERROR TestSendACommandWithAVendorIdAndEnum_147() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestEnumsRequest::Type; @@ -37728,20 +38533,20 @@ class TestCluster : public TestCommand request.arg2 = static_cast(101); auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_129(data.arg1, data.arg2); + (static_cast(context))->OnSuccessResponse_147(data.arg1, data.arg2); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_129(status); + (static_cast(context))->OnFailureResponse_147(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_129(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_147(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_129(chip::VendorId arg1, chip::app::Clusters::TestCluster::SimpleEnum arg2) + void OnSuccessResponse_147(chip::VendorId arg1, chip::app::Clusters::TestCluster::SimpleEnum arg2) { VerifyOrReturn(CheckValue("arg1", arg1, 20003U)); @@ -37750,7 +38555,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestSendTestCommandWithStructArgumentAndArg1bIsTrue_130() + CHIP_ERROR TestSendTestCommandWithStructArgumentAndArg1bIsTrue_148() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestStructArgumentRequest::Type; @@ -37763,31 +38568,31 @@ 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.g = 0.0f; request.arg1.h = 0; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_130(data.value); + (static_cast(context))->OnSuccessResponse_148(data.value); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_130(status); + (static_cast(context))->OnFailureResponse_148(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_130(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_148(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_130(bool value) + void OnSuccessResponse_148(bool value) { VerifyOrReturn(CheckValue("value", value, true)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithStructArgumentAndArg1bIsFalse_131() + CHIP_ERROR TestSendTestCommandWithStructArgumentAndArg1bIsFalse_149() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestStructArgumentRequest::Type; @@ -37800,31 +38605,31 @@ 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.g = 0.0f; request.arg1.h = 0; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_131(data.value); + (static_cast(context))->OnSuccessResponse_149(data.value); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_131(status); + (static_cast(context))->OnFailureResponse_149(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_131(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_149(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_131(bool value) + void OnSuccessResponse_149(bool value) { VerifyOrReturn(CheckValue("value", value, false)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithNestedStructArgumentAndArg1cbIsTrue_132() + CHIP_ERROR TestSendTestCommandWithNestedStructArgumentAndArg1cbIsTrue_150() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestNestedStructArgumentRequest::Type; @@ -37840,31 +38645,31 @@ class TestCluster : public TestCommand request.arg1.c.d = chip::ByteSpan(chip::Uint8::from_const_char("octet_stringgarbage: not in length on purpose"), 12); request.arg1.c.e = chip::Span("char_stringgarbage: not in length on purpose", 11); request.arg1.c.f = static_cast>(1); - request.arg1.c.g = 0; + request.arg1.c.g = 0.0f; request.arg1.c.h = 0; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_132(data.value); + (static_cast(context))->OnSuccessResponse_150(data.value); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_132(status); + (static_cast(context))->OnFailureResponse_150(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_132(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_150(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_132(bool value) + void OnSuccessResponse_150(bool value) { VerifyOrReturn(CheckValue("value", value, true)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithNestedStructArgumentArg1cbIsFalse_133() + CHIP_ERROR TestSendTestCommandWithNestedStructArgumentArg1cbIsFalse_151() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestNestedStructArgumentRequest::Type; @@ -37880,31 +38685,31 @@ class TestCluster : public TestCommand request.arg1.c.d = chip::ByteSpan(chip::Uint8::from_const_char("octet_stringgarbage: not in length on purpose"), 12); request.arg1.c.e = chip::Span("char_stringgarbage: not in length on purpose", 11); request.arg1.c.f = static_cast>(1); - request.arg1.c.g = 0; + request.arg1.c.g = 0.0f; request.arg1.c.h = 0; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_133(data.value); + (static_cast(context))->OnSuccessResponse_151(data.value); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_133(status); + (static_cast(context))->OnFailureResponse_151(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_133(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_151(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_133(bool value) + void OnSuccessResponse_151(bool value) { VerifyOrReturn(CheckValue("value", value, false)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithNestedStructListArgumentAndAllFieldsBOfArg1dAreTrue_134() + CHIP_ERROR TestSendTestCommandWithNestedStructListArgumentAndAllFieldsBOfArg1dAreTrue_152() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestNestedStructListArgumentRequest::Type; @@ -37920,7 +38725,7 @@ class TestCluster : public TestCommand request.arg1.c.d = chip::ByteSpan(chip::Uint8::from_const_char("octet_stringgarbage: not in length on purpose"), 12); request.arg1.c.e = chip::Span("char_stringgarbage: not in length on purpose", 11); request.arg1.c.f = static_cast>(1); - request.arg1.c.g = 0; + request.arg1.c.g = 0.0f; request.arg1.c.h = 0; chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type dList[2]; @@ -37931,7 +38736,7 @@ class TestCluster : public TestCommand dList[0].d = chip::ByteSpan(chip::Uint8::from_const_char("nested_octet_stringgarbage: not in length on purpose"), 19); dList[0].e = chip::Span("nested_char_stringgarbage: not in length on purpose", 18); dList[0].f = static_cast>(1); - dList[0].g = 0; + dList[0].g = 0.0f; dList[0].h = 0; dList[1].a = 2; @@ -37940,7 +38745,7 @@ class TestCluster : public TestCommand dList[1].d = chip::ByteSpan(chip::Uint8::from_const_char("nested_octet_stringgarbage: not in length on purpose"), 19); dList[1].e = chip::Span("nested_char_stringgarbage: not in length on purpose", 18); dList[1].f = static_cast>(1); - dList[1].g = 0; + dList[1].g = 0.0f; dList[1].h = 0; request.arg1.d = dList; @@ -37963,27 +38768,27 @@ class TestCluster : public TestCommand request.arg1.g = gList; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_134(data.value); + (static_cast(context))->OnSuccessResponse_152(data.value); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_134(status); + (static_cast(context))->OnFailureResponse_152(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_134(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_152(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_134(bool value) + void OnSuccessResponse_152(bool value) { VerifyOrReturn(CheckValue("value", value, true)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfArg1dAreFalse_135() + CHIP_ERROR TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfArg1dAreFalse_153() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestNestedStructListArgumentRequest::Type; @@ -37999,7 +38804,7 @@ class TestCluster : public TestCommand request.arg1.c.d = chip::ByteSpan(chip::Uint8::from_const_char("octet_stringgarbage: not in length on purpose"), 12); request.arg1.c.e = chip::Span("char_stringgarbage: not in length on purpose", 11); request.arg1.c.f = static_cast>(1); - request.arg1.c.g = 0; + request.arg1.c.g = 0.0f; request.arg1.c.h = 0; chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type dList[2]; @@ -38010,7 +38815,7 @@ class TestCluster : public TestCommand dList[0].d = chip::ByteSpan(chip::Uint8::from_const_char("nested_octet_stringgarbage: not in length on purpose"), 19); dList[0].e = chip::Span("nested_char_stringgarbage: not in length on purpose", 18); dList[0].f = static_cast>(1); - dList[0].g = 0; + dList[0].g = 0.0f; dList[0].h = 0; dList[1].a = 2; @@ -38019,7 +38824,7 @@ class TestCluster : public TestCommand dList[1].d = chip::ByteSpan(chip::Uint8::from_const_char("nested_octet_stringgarbage: not in length on purpose"), 19); dList[1].e = chip::Span("nested_char_stringgarbage: not in length on purpose", 18); dList[1].f = static_cast>(1); - dList[1].g = 0; + dList[1].g = 0.0f; dList[1].h = 0; request.arg1.d = dList; @@ -38042,27 +38847,27 @@ class TestCluster : public TestCommand request.arg1.g = gList; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_135(data.value); + (static_cast(context))->OnSuccessResponse_153(data.value); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_135(status); + (static_cast(context))->OnFailureResponse_153(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_135(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_153(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_135(bool value) + void OnSuccessResponse_153(bool value) { VerifyOrReturn(CheckValue("value", value, false)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithStructArgumentAndSeeWhatWeGetBack_136() + CHIP_ERROR TestSendTestCommandWithStructArgumentAndSeeWhatWeGetBack_154() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::SimpleStructEchoRequest::Type; @@ -38079,20 +38884,20 @@ class TestCluster : public TestCommand request.arg1.h = 0.1; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_136(data.arg1); + (static_cast(context))->OnSuccessResponse_154(data.arg1); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_136(status); + (static_cast(context))->OnFailureResponse_154(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_136(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_154(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_136(const chip::app::Clusters::TestCluster::Structs::SimpleStruct::DecodableType & arg1) + void OnSuccessResponse_154(const chip::app::Clusters::TestCluster::Structs::SimpleStruct::DecodableType & arg1) { VerifyOrReturn(CheckValue("arg1.a", arg1.a, 17)); VerifyOrReturn(CheckValue("arg1.b", arg1.b, false)); @@ -38106,7 +38911,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestSendTestCommandWithListOfInt8uAndNoneOfThemIsSetTo0_137() + CHIP_ERROR TestSendTestCommandWithListOfInt8uAndNoneOfThemIsSetTo0_155() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListInt8UArgumentRequest::Type; @@ -38126,27 +38931,27 @@ class TestCluster : public TestCommand request.arg1 = arg1List; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_137(data.value); + (static_cast(context))->OnSuccessResponse_155(data.value); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_137(status); + (static_cast(context))->OnFailureResponse_155(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_137(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_155(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_137(bool value) + void OnSuccessResponse_155(bool value) { VerifyOrReturn(CheckValue("value", value, true)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithListOfInt8uAndOneOfThemIsSetTo0_138() + CHIP_ERROR TestSendTestCommandWithListOfInt8uAndOneOfThemIsSetTo0_156() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListInt8UArgumentRequest::Type; @@ -38167,27 +38972,27 @@ class TestCluster : public TestCommand request.arg1 = arg1List; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_138(data.value); + (static_cast(context))->OnSuccessResponse_156(data.value); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_138(status); + (static_cast(context))->OnFailureResponse_156(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_138(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_156(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_138(bool value) + void OnSuccessResponse_156(bool value) { VerifyOrReturn(CheckValue("value", value, false)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithListOfInt8uAndGetItReversed_139() + CHIP_ERROR TestSendTestCommandWithListOfInt8uAndGetItReversed_157() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListInt8UReverseRequest::Type; @@ -38207,20 +39012,20 @@ class TestCluster : public TestCommand request.arg1 = arg1List; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_139(data.arg1); + (static_cast(context))->OnSuccessResponse_157(data.arg1); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_139(status); + (static_cast(context))->OnFailureResponse_157(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_139(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_157(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_139(const chip::app::DataModel::DecodableList & arg1) + void OnSuccessResponse_157(const chip::app::DataModel::DecodableList & arg1) { auto iter = arg1.begin(); VerifyOrReturn(CheckNextListItemDecodes("arg1", iter, 0)); @@ -38246,7 +39051,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestSendTestCommandWithEmptyListOfInt8uAndGetAnEmptyListBack_140() + CHIP_ERROR TestSendTestCommandWithEmptyListOfInt8uAndGetAnEmptyListBack_158() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListInt8UReverseRequest::Type; @@ -38256,20 +39061,20 @@ class TestCluster : public TestCommand request.arg1 = chip::app::DataModel::List(); auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_140(data.arg1); + (static_cast(context))->OnSuccessResponse_158(data.arg1); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_140(status); + (static_cast(context))->OnFailureResponse_158(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_140(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_158(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_140(const chip::app::DataModel::DecodableList & arg1) + void OnSuccessResponse_158(const chip::app::DataModel::DecodableList & arg1) { auto iter = arg1.begin(); VerifyOrReturn(CheckNoMoreListItems("arg1", iter, 0)); @@ -38277,7 +39082,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsTrue_141() + CHIP_ERROR TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsTrue_159() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListStructArgumentRequest::Type; @@ -38292,7 +39097,7 @@ 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].g = 0.0f; arg1List[0].h = 0; arg1List[1].a = 1; @@ -38301,33 +39106,33 @@ 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].g = 0.0f; arg1List[1].h = 0; request.arg1 = arg1List; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_141(data.value); + (static_cast(context))->OnSuccessResponse_159(data.value); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_141(status); + (static_cast(context))->OnFailureResponse_159(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_141(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_159(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_141(bool value) + void OnSuccessResponse_159(bool value) { VerifyOrReturn(CheckValue("value", value, true)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsFalse_142() + CHIP_ERROR TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsFalse_160() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListStructArgumentRequest::Type; @@ -38342,7 +39147,7 @@ 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].g = 0.0f; arg1List[0].h = 0; arg1List[1].a = 0; @@ -38351,33 +39156,33 @@ 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].g = 0.0f; arg1List[1].h = 0; request.arg1 = arg1List; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_142(data.value); + (static_cast(context))->OnSuccessResponse_160(data.value); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_142(status); + (static_cast(context))->OnFailureResponse_160(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_142(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_160(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_142(bool value) + void OnSuccessResponse_160(bool value) { VerifyOrReturn(CheckValue("value", value, false)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithListOfNestedStructListArgumentAndAllFieldsBOfElementsOfArg1dAreTrue_143() + CHIP_ERROR TestSendTestCommandWithListOfNestedStructListArgumentAndAllFieldsBOfElementsOfArg1dAreTrue_161() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListNestedStructListArgumentRequest::Type; @@ -38395,7 +39200,7 @@ class TestCluster : public TestCommand arg1List[0].c.d = chip::ByteSpan(chip::Uint8::from_const_char("octet_stringgarbage: not in length on purpose"), 12); arg1List[0].c.e = chip::Span("char_stringgarbage: not in length on purpose", 11); arg1List[0].c.f = static_cast>(1); - arg1List[0].c.g = 0; + arg1List[0].c.g = 0.0f; arg1List[0].c.h = 0; chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type dList[2]; @@ -38406,7 +39211,7 @@ class TestCluster : public TestCommand dList[0].d = chip::ByteSpan(chip::Uint8::from_const_char("nested_octet_stringgarbage: not in length on purpose"), 19); dList[0].e = chip::Span("nested_char_stringgarbage: not in length on purpose", 18); dList[0].f = static_cast>(1); - dList[0].g = 0; + dList[0].g = 0.0f; dList[0].h = 0; dList[1].a = 2; @@ -38415,7 +39220,7 @@ class TestCluster : public TestCommand dList[1].d = chip::ByteSpan(chip::Uint8::from_const_char("nested_octet_stringgarbage: not in length on purpose"), 19); dList[1].e = chip::Span("nested_char_stringgarbage: not in length on purpose", 18); dList[1].f = static_cast>(1); - dList[1].g = 0; + dList[1].g = 0.0f; dList[1].h = 0; arg1List[0].d = dList; @@ -38440,27 +39245,27 @@ class TestCluster : public TestCommand request.arg1 = arg1List; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_143(data.value); + (static_cast(context))->OnSuccessResponse_161(data.value); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_143(status); + (static_cast(context))->OnFailureResponse_161(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_143(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_161(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_143(bool value) + void OnSuccessResponse_161(bool value) { VerifyOrReturn(CheckValue("value", value, true)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfElementsOfArg1dAreFalse_144() + CHIP_ERROR TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfElementsOfArg1dAreFalse_162() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListNestedStructListArgumentRequest::Type; @@ -38478,7 +39283,7 @@ class TestCluster : public TestCommand arg1List[0].c.d = chip::ByteSpan(chip::Uint8::from_const_char("octet_stringgarbage: not in length on purpose"), 12); arg1List[0].c.e = chip::Span("char_stringgarbage: not in length on purpose", 11); arg1List[0].c.f = static_cast>(1); - arg1List[0].c.g = 0; + arg1List[0].c.g = 0.0f; arg1List[0].c.h = 0; chip::app::Clusters::TestCluster::Structs::SimpleStruct::Type dList[2]; @@ -38489,7 +39294,7 @@ class TestCluster : public TestCommand dList[0].d = chip::ByteSpan(chip::Uint8::from_const_char("nested_octet_stringgarbage: not in length on purpose"), 19); dList[0].e = chip::Span("nested_char_stringgarbage: not in length on purpose", 18); dList[0].f = static_cast>(1); - dList[0].g = 0; + dList[0].g = 0.0f; dList[0].h = 0; dList[1].a = 2; @@ -38498,7 +39303,7 @@ class TestCluster : public TestCommand dList[1].d = chip::ByteSpan(chip::Uint8::from_const_char("nested_octet_stringgarbage: not in length on purpose"), 19); dList[1].e = chip::Span("nested_char_stringgarbage: not in length on purpose", 18); dList[1].f = static_cast>(1); - dList[1].g = 0; + dList[1].g = 0.0f; dList[1].h = 0; arg1List[0].d = dList; @@ -38523,27 +39328,27 @@ class TestCluster : public TestCommand request.arg1 = arg1List; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_144(data.value); + (static_cast(context))->OnSuccessResponse_162(data.value); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_144(status); + (static_cast(context))->OnFailureResponse_162(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_144(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_162(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_144(bool value) + void OnSuccessResponse_162(bool value) { VerifyOrReturn(CheckValue("value", value, false)); NextTest(); } - CHIP_ERROR TestWriteAttributeListWithListOfInt8uAndNoneOfThemIsSetTo0_145() + CHIP_ERROR TestWriteAttributeListWithListOfInt8uAndNoneOfThemIsSetTo0_163() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -38559,26 +39364,26 @@ class TestCluster : public TestCommand listInt8uArgument = listInt8uList; return cluster.WriteAttribute( - listInt8uArgument, this, OnSuccessCallback_145, OnFailureCallback_145); + listInt8uArgument, this, OnSuccessCallback_163, OnFailureCallback_163); } - void OnFailureResponse_145(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_163(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_145() { NextTest(); } + void OnSuccessResponse_163() { NextTest(); } - CHIP_ERROR TestReadAttributeListWithListOfInt8u_146() + CHIP_ERROR TestReadAttributeListWithListOfInt8u_164() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_146, - OnFailureCallback_146); + return cluster.ReadAttribute(this, OnSuccessCallback_164, + OnFailureCallback_164); } - void OnFailureResponse_146(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_164(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_146(const chip::app::DataModel::DecodableList & listInt8u) + void OnSuccessResponse_164(const chip::app::DataModel::DecodableList & listInt8u) { auto iter = listInt8u.begin(); VerifyOrReturn(CheckNextListItemDecodes("listInt8u", iter, 0)); @@ -38594,7 +39399,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeListWithListOfOctetString_147() + CHIP_ERROR TestWriteAttributeListWithListOfOctetString_165() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -38610,26 +39415,26 @@ class TestCluster : public TestCommand listOctetStringArgument = listOctetStringList; return cluster.WriteAttribute( - listOctetStringArgument, this, OnSuccessCallback_147, OnFailureCallback_147); + listOctetStringArgument, this, OnSuccessCallback_165, OnFailureCallback_165); } - void OnFailureResponse_147(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_165(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_147() { NextTest(); } + void OnSuccessResponse_165() { NextTest(); } - CHIP_ERROR TestReadAttributeListWithListOfOctetString_148() + CHIP_ERROR TestReadAttributeListWithListOfOctetString_166() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_148, OnFailureCallback_148); + this, OnSuccessCallback_166, OnFailureCallback_166); } - void OnFailureResponse_148(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_166(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_148(const chip::app::DataModel::DecodableList & listOctetString) + void OnSuccessResponse_166(const chip::app::DataModel::DecodableList & listOctetString) { auto iter = listOctetString.begin(); VerifyOrReturn(CheckNextListItemDecodes("listOctetString", iter, 0)); @@ -38649,7 +39454,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeListWithListOfListStructOctetString_149() + CHIP_ERROR TestWriteAttributeListWithListOfListStructOctetString_167() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -38679,26 +39484,26 @@ class TestCluster : public TestCommand listStructOctetStringArgument = listStructOctetStringList; return cluster.WriteAttribute( - listStructOctetStringArgument, this, OnSuccessCallback_149, OnFailureCallback_149); + listStructOctetStringArgument, this, OnSuccessCallback_167, OnFailureCallback_167); } - void OnFailureResponse_149(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_167(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_149() { NextTest(); } + void OnSuccessResponse_167() { NextTest(); } - CHIP_ERROR TestReadAttributeListWithListOfListStructOctetString_150() + CHIP_ERROR TestReadAttributeListWithListOfListStructOctetString_168() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_150, OnFailureCallback_150); + this, OnSuccessCallback_168, OnFailureCallback_168); } - void OnFailureResponse_150(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_168(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_150( + void OnSuccessResponse_168( const chip::app::DataModel::DecodableList & listStructOctetString) { @@ -38724,7 +39529,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestSendTestCommandWithOptionalArgSet_151() + CHIP_ERROR TestSendTestCommandWithOptionalArgSet_169() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestNullableOptionalRequest::Type; @@ -38734,20 +39539,20 @@ class TestCluster : public TestCommand auto success = [](void * context, const typename RequestType::ResponseType & data) { (static_cast(context)) - ->OnSuccessResponse_151(data.wasPresent, data.wasNull, data.value, data.originalValue); + ->OnSuccessResponse_169(data.wasPresent, data.wasNull, data.value, data.originalValue); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_151(status); + (static_cast(context))->OnFailureResponse_169(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_151(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_169(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_151(bool wasPresent, const chip::Optional & wasNull, const chip::Optional & value, + void OnSuccessResponse_169(bool wasPresent, const chip::Optional & wasNull, const chip::Optional & value, const chip::Optional> & originalValue) { VerifyOrReturn(CheckValue("wasPresent", wasPresent, true)); @@ -38765,7 +39570,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestSendTestCommandWithoutItsOptionalArg_152() + CHIP_ERROR TestSendTestCommandWithoutItsOptionalArg_170() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestNullableOptionalRequest::Type; @@ -38774,20 +39579,20 @@ class TestCluster : public TestCommand auto success = [](void * context, const typename RequestType::ResponseType & data) { (static_cast(context)) - ->OnSuccessResponse_152(data.wasPresent, data.wasNull, data.value, data.originalValue); + ->OnSuccessResponse_170(data.wasPresent, data.wasNull, data.value, data.originalValue); }; auto failure = [](void * context, EmberAfStatus status) { - (static_cast(context))->OnFailureResponse_152(status); + (static_cast(context))->OnFailureResponse_170(status); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_152(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_170(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_152(bool wasPresent, const chip::Optional & wasNull, const chip::Optional & value, + void OnSuccessResponse_170(bool wasPresent, const chip::Optional & wasNull, const chip::Optional & value, const chip::Optional> & originalValue) { VerifyOrReturn(CheckValue("wasPresent", wasPresent, false)); @@ -38795,7 +39600,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBooleanNull_153() + CHIP_ERROR TestWriteAttributeNullableBooleanNull_171() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -38805,33 +39610,33 @@ class TestCluster : public TestCommand nullableBooleanArgument.SetNull(); return cluster.WriteAttribute( - nullableBooleanArgument, this, OnSuccessCallback_153, OnFailureCallback_153); + nullableBooleanArgument, this, OnSuccessCallback_171, OnFailureCallback_171); } - void OnFailureResponse_153(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_171(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_153() { NextTest(); } + void OnSuccessResponse_171() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBooleanNull_154() + CHIP_ERROR TestReadAttributeNullableBooleanNull_172() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_154, OnFailureCallback_154); + this, OnSuccessCallback_172, OnFailureCallback_172); } - void OnFailureResponse_154(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_172(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_154(const chip::app::DataModel::Nullable & nullableBoolean) + void OnSuccessResponse_172(const chip::app::DataModel::Nullable & nullableBoolean) { VerifyOrReturn(CheckValueNull("nullableBoolean", nullableBoolean)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBooleanTrue_155() + CHIP_ERROR TestWriteAttributeNullableBooleanTrue_173() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -38841,26 +39646,26 @@ class TestCluster : public TestCommand nullableBooleanArgument.SetNonNull() = true; return cluster.WriteAttribute( - nullableBooleanArgument, this, OnSuccessCallback_155, OnFailureCallback_155); + nullableBooleanArgument, this, OnSuccessCallback_173, OnFailureCallback_173); } - void OnFailureResponse_155(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_173(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_155() { NextTest(); } + void OnSuccessResponse_173() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBooleanTrue_156() + CHIP_ERROR TestReadAttributeNullableBooleanTrue_174() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_156, OnFailureCallback_156); + this, OnSuccessCallback_174, OnFailureCallback_174); } - void OnFailureResponse_156(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_174(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_156(const chip::app::DataModel::Nullable & nullableBoolean) + void OnSuccessResponse_174(const chip::app::DataModel::Nullable & nullableBoolean) { VerifyOrReturn(CheckValueNonNull("nullableBoolean", nullableBoolean)); VerifyOrReturn(CheckValue("nullableBoolean.Value()", nullableBoolean.Value(), true)); @@ -38868,7 +39673,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap8MaxValue_157() + CHIP_ERROR TestWriteAttributeNullableBitmap8MaxValue_175() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -38878,26 +39683,26 @@ class TestCluster : public TestCommand nullableBitmap8Argument.SetNonNull() = 254; return cluster.WriteAttribute( - nullableBitmap8Argument, this, OnSuccessCallback_157, OnFailureCallback_157); + nullableBitmap8Argument, this, OnSuccessCallback_175, OnFailureCallback_175); } - void OnFailureResponse_157(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_175(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_157() { NextTest(); } + void OnSuccessResponse_175() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap8MaxValue_158() + CHIP_ERROR TestReadAttributeNullableBitmap8MaxValue_176() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_158, OnFailureCallback_158); + this, OnSuccessCallback_176, OnFailureCallback_176); } - void OnFailureResponse_158(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_176(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_158(const chip::app::DataModel::Nullable & nullableBitmap8) + void OnSuccessResponse_176(const chip::app::DataModel::Nullable & nullableBitmap8) { VerifyOrReturn(CheckValueNonNull("nullableBitmap8", nullableBitmap8)); VerifyOrReturn(CheckValue("nullableBitmap8.Value()", nullableBitmap8.Value(), 254)); @@ -38905,7 +39710,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap8InvalidValue_159() + CHIP_ERROR TestWriteAttributeNullableBitmap8InvalidValue_177() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -38915,30 +39720,30 @@ class TestCluster : public TestCommand nullableBitmap8Argument.SetNonNull() = 255; return cluster.WriteAttribute( - nullableBitmap8Argument, this, OnSuccessCallback_159, OnFailureCallback_159); + nullableBitmap8Argument, this, OnSuccessCallback_177, OnFailureCallback_177); } - void OnFailureResponse_159(uint8_t status) + void OnFailureResponse_177(uint8_t status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_159() { ThrowSuccessResponse(); } + void OnSuccessResponse_177() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableBitmap8UnchangedValue_160() + CHIP_ERROR TestReadAttributeNullableBitmap8UnchangedValue_178() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_160, OnFailureCallback_160); + this, OnSuccessCallback_178, OnFailureCallback_178); } - void OnFailureResponse_160(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_178(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_160(const chip::app::DataModel::Nullable & nullableBitmap8) + void OnSuccessResponse_178(const chip::app::DataModel::Nullable & nullableBitmap8) { VerifyOrReturn(CheckValueNonNull("nullableBitmap8", nullableBitmap8)); VerifyOrReturn(CheckValue("nullableBitmap8.Value()", nullableBitmap8.Value(), 254)); @@ -38946,7 +39751,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap8NullValue_161() + CHIP_ERROR TestWriteAttributeNullableBitmap8NullValue_179() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -38956,33 +39761,33 @@ class TestCluster : public TestCommand nullableBitmap8Argument.SetNull(); return cluster.WriteAttribute( - nullableBitmap8Argument, this, OnSuccessCallback_161, OnFailureCallback_161); + nullableBitmap8Argument, this, OnSuccessCallback_179, OnFailureCallback_179); } - void OnFailureResponse_161(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_179(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_161() { NextTest(); } + void OnSuccessResponse_179() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap8NullValue_162() + CHIP_ERROR TestReadAttributeNullableBitmap8NullValue_180() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_162, OnFailureCallback_162); + this, OnSuccessCallback_180, OnFailureCallback_180); } - void OnFailureResponse_162(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_180(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_162(const chip::app::DataModel::Nullable & nullableBitmap8) + void OnSuccessResponse_180(const chip::app::DataModel::Nullable & nullableBitmap8) { VerifyOrReturn(CheckValueNull("nullableBitmap8", nullableBitmap8)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap16MaxValue_163() + CHIP_ERROR TestWriteAttributeNullableBitmap16MaxValue_181() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -38992,26 +39797,26 @@ class TestCluster : public TestCommand nullableBitmap16Argument.SetNonNull() = 65534U; return cluster.WriteAttribute( - nullableBitmap16Argument, this, OnSuccessCallback_163, OnFailureCallback_163); + nullableBitmap16Argument, this, OnSuccessCallback_181, OnFailureCallback_181); } - void OnFailureResponse_163(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_181(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_163() { NextTest(); } + void OnSuccessResponse_181() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap16MaxValue_164() + CHIP_ERROR TestReadAttributeNullableBitmap16MaxValue_182() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_164, OnFailureCallback_164); + this, OnSuccessCallback_182, OnFailureCallback_182); } - void OnFailureResponse_164(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_182(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_164(const chip::app::DataModel::Nullable & nullableBitmap16) + void OnSuccessResponse_182(const chip::app::DataModel::Nullable & nullableBitmap16) { VerifyOrReturn(CheckValueNonNull("nullableBitmap16", nullableBitmap16)); VerifyOrReturn(CheckValue("nullableBitmap16.Value()", nullableBitmap16.Value(), 65534U)); @@ -39019,7 +39824,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap16InvalidValue_165() + CHIP_ERROR TestWriteAttributeNullableBitmap16InvalidValue_183() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39029,30 +39834,30 @@ class TestCluster : public TestCommand nullableBitmap16Argument.SetNonNull() = 65535U; return cluster.WriteAttribute( - nullableBitmap16Argument, this, OnSuccessCallback_165, OnFailureCallback_165); + nullableBitmap16Argument, this, OnSuccessCallback_183, OnFailureCallback_183); } - void OnFailureResponse_165(uint8_t status) + void OnFailureResponse_183(uint8_t status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_165() { ThrowSuccessResponse(); } + void OnSuccessResponse_183() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableBitmap16UnchangedValue_166() + CHIP_ERROR TestReadAttributeNullableBitmap16UnchangedValue_184() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_166, OnFailureCallback_166); + this, OnSuccessCallback_184, OnFailureCallback_184); } - void OnFailureResponse_166(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_184(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_166(const chip::app::DataModel::Nullable & nullableBitmap16) + void OnSuccessResponse_184(const chip::app::DataModel::Nullable & nullableBitmap16) { VerifyOrReturn(CheckValueNonNull("nullableBitmap16", nullableBitmap16)); VerifyOrReturn(CheckValue("nullableBitmap16.Value()", nullableBitmap16.Value(), 65534U)); @@ -39060,7 +39865,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap16NullValue_167() + CHIP_ERROR TestWriteAttributeNullableBitmap16NullValue_185() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39070,33 +39875,33 @@ class TestCluster : public TestCommand nullableBitmap16Argument.SetNull(); return cluster.WriteAttribute( - nullableBitmap16Argument, this, OnSuccessCallback_167, OnFailureCallback_167); + nullableBitmap16Argument, this, OnSuccessCallback_185, OnFailureCallback_185); } - void OnFailureResponse_167(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_185(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_167() { NextTest(); } + void OnSuccessResponse_185() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap16NullValue_168() + CHIP_ERROR TestReadAttributeNullableBitmap16NullValue_186() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_168, OnFailureCallback_168); + this, OnSuccessCallback_186, OnFailureCallback_186); } - void OnFailureResponse_168(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_186(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_168(const chip::app::DataModel::Nullable & nullableBitmap16) + void OnSuccessResponse_186(const chip::app::DataModel::Nullable & nullableBitmap16) { VerifyOrReturn(CheckValueNull("nullableBitmap16", nullableBitmap16)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap32MaxValue_169() + CHIP_ERROR TestWriteAttributeNullableBitmap32MaxValue_187() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39106,26 +39911,26 @@ class TestCluster : public TestCommand nullableBitmap32Argument.SetNonNull() = 4294967294UL; return cluster.WriteAttribute( - nullableBitmap32Argument, this, OnSuccessCallback_169, OnFailureCallback_169); + nullableBitmap32Argument, this, OnSuccessCallback_187, OnFailureCallback_187); } - void OnFailureResponse_169(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_187(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_169() { NextTest(); } + void OnSuccessResponse_187() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap32MaxValue_170() + CHIP_ERROR TestReadAttributeNullableBitmap32MaxValue_188() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_170, OnFailureCallback_170); + this, OnSuccessCallback_188, OnFailureCallback_188); } - void OnFailureResponse_170(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_188(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_170(const chip::app::DataModel::Nullable & nullableBitmap32) + void OnSuccessResponse_188(const chip::app::DataModel::Nullable & nullableBitmap32) { VerifyOrReturn(CheckValueNonNull("nullableBitmap32", nullableBitmap32)); VerifyOrReturn(CheckValue("nullableBitmap32.Value()", nullableBitmap32.Value(), 4294967294UL)); @@ -39133,7 +39938,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap32InvalidValue_171() + CHIP_ERROR TestWriteAttributeNullableBitmap32InvalidValue_189() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39143,30 +39948,30 @@ class TestCluster : public TestCommand nullableBitmap32Argument.SetNonNull() = 4294967295UL; return cluster.WriteAttribute( - nullableBitmap32Argument, this, OnSuccessCallback_171, OnFailureCallback_171); + nullableBitmap32Argument, this, OnSuccessCallback_189, OnFailureCallback_189); } - void OnFailureResponse_171(uint8_t status) + void OnFailureResponse_189(uint8_t status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_171() { ThrowSuccessResponse(); } + void OnSuccessResponse_189() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableBitmap32UnchangedValue_172() + CHIP_ERROR TestReadAttributeNullableBitmap32UnchangedValue_190() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_172, OnFailureCallback_172); + this, OnSuccessCallback_190, OnFailureCallback_190); } - void OnFailureResponse_172(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_190(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_172(const chip::app::DataModel::Nullable & nullableBitmap32) + void OnSuccessResponse_190(const chip::app::DataModel::Nullable & nullableBitmap32) { VerifyOrReturn(CheckValueNonNull("nullableBitmap32", nullableBitmap32)); VerifyOrReturn(CheckValue("nullableBitmap32.Value()", nullableBitmap32.Value(), 4294967294UL)); @@ -39174,7 +39979,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap32NullValue_173() + CHIP_ERROR TestWriteAttributeNullableBitmap32NullValue_191() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39184,33 +39989,33 @@ class TestCluster : public TestCommand nullableBitmap32Argument.SetNull(); return cluster.WriteAttribute( - nullableBitmap32Argument, this, OnSuccessCallback_173, OnFailureCallback_173); + nullableBitmap32Argument, this, OnSuccessCallback_191, OnFailureCallback_191); } - void OnFailureResponse_173(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_191(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_173() { NextTest(); } + void OnSuccessResponse_191() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap32NullValue_174() + CHIP_ERROR TestReadAttributeNullableBitmap32NullValue_192() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_174, OnFailureCallback_174); + this, OnSuccessCallback_192, OnFailureCallback_192); } - void OnFailureResponse_174(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_192(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_174(const chip::app::DataModel::Nullable & nullableBitmap32) + void OnSuccessResponse_192(const chip::app::DataModel::Nullable & nullableBitmap32) { VerifyOrReturn(CheckValueNull("nullableBitmap32", nullableBitmap32)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap64MaxValue_175() + CHIP_ERROR TestWriteAttributeNullableBitmap64MaxValue_193() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39220,26 +40025,26 @@ class TestCluster : public TestCommand nullableBitmap64Argument.SetNonNull() = 18446744073709551614ULL; return cluster.WriteAttribute( - nullableBitmap64Argument, this, OnSuccessCallback_175, OnFailureCallback_175); + nullableBitmap64Argument, this, OnSuccessCallback_193, OnFailureCallback_193); } - void OnFailureResponse_175(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_193(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_175() { NextTest(); } + void OnSuccessResponse_193() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap64MaxValue_176() + CHIP_ERROR TestReadAttributeNullableBitmap64MaxValue_194() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_176, OnFailureCallback_176); + this, OnSuccessCallback_194, OnFailureCallback_194); } - void OnFailureResponse_176(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_194(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_176(const chip::app::DataModel::Nullable & nullableBitmap64) + void OnSuccessResponse_194(const chip::app::DataModel::Nullable & nullableBitmap64) { VerifyOrReturn(CheckValueNonNull("nullableBitmap64", nullableBitmap64)); VerifyOrReturn(CheckValue("nullableBitmap64.Value()", nullableBitmap64.Value(), 18446744073709551614ULL)); @@ -39247,7 +40052,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap64InvalidValue_177() + CHIP_ERROR TestWriteAttributeNullableBitmap64InvalidValue_195() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39257,30 +40062,30 @@ class TestCluster : public TestCommand nullableBitmap64Argument.SetNonNull() = 18446744073709551615ULL; return cluster.WriteAttribute( - nullableBitmap64Argument, this, OnSuccessCallback_177, OnFailureCallback_177); + nullableBitmap64Argument, this, OnSuccessCallback_195, OnFailureCallback_195); } - void OnFailureResponse_177(uint8_t status) + void OnFailureResponse_195(uint8_t status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_177() { ThrowSuccessResponse(); } + void OnSuccessResponse_195() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableBitmap64UnchangedValue_178() + CHIP_ERROR TestReadAttributeNullableBitmap64UnchangedValue_196() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_178, OnFailureCallback_178); + this, OnSuccessCallback_196, OnFailureCallback_196); } - void OnFailureResponse_178(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_196(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_178(const chip::app::DataModel::Nullable & nullableBitmap64) + void OnSuccessResponse_196(const chip::app::DataModel::Nullable & nullableBitmap64) { VerifyOrReturn(CheckValueNonNull("nullableBitmap64", nullableBitmap64)); VerifyOrReturn(CheckValue("nullableBitmap64.Value()", nullableBitmap64.Value(), 18446744073709551614ULL)); @@ -39288,7 +40093,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap64NullValue_179() + CHIP_ERROR TestWriteAttributeNullableBitmap64NullValue_197() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39298,33 +40103,33 @@ class TestCluster : public TestCommand nullableBitmap64Argument.SetNull(); return cluster.WriteAttribute( - nullableBitmap64Argument, this, OnSuccessCallback_179, OnFailureCallback_179); + nullableBitmap64Argument, this, OnSuccessCallback_197, OnFailureCallback_197); } - void OnFailureResponse_179(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_197(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_179() { NextTest(); } + void OnSuccessResponse_197() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap64NullValue_180() + CHIP_ERROR TestReadAttributeNullableBitmap64NullValue_198() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_180, OnFailureCallback_180); + this, OnSuccessCallback_198, OnFailureCallback_198); } - void OnFailureResponse_180(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_198(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_180(const chip::app::DataModel::Nullable & nullableBitmap64) + void OnSuccessResponse_198(const chip::app::DataModel::Nullable & nullableBitmap64) { VerifyOrReturn(CheckValueNull("nullableBitmap64", nullableBitmap64)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8uMaxValue_181() + CHIP_ERROR TestWriteAttributeNullableInt8uMaxValue_199() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39334,26 +40139,26 @@ class TestCluster : public TestCommand nullableInt8uArgument.SetNonNull() = 254; return cluster.WriteAttribute( - nullableInt8uArgument, this, OnSuccessCallback_181, OnFailureCallback_181); + nullableInt8uArgument, this, OnSuccessCallback_199, OnFailureCallback_199); } - void OnFailureResponse_181(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_199(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_181() { NextTest(); } + void OnSuccessResponse_199() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8uMaxValue_182() + CHIP_ERROR TestReadAttributeNullableInt8uMaxValue_200() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_182, OnFailureCallback_182); + this, OnSuccessCallback_200, OnFailureCallback_200); } - void OnFailureResponse_182(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_200(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_182(const chip::app::DataModel::Nullable & nullableInt8u) + void OnSuccessResponse_200(const chip::app::DataModel::Nullable & nullableInt8u) { VerifyOrReturn(CheckValueNonNull("nullableInt8u", nullableInt8u)); VerifyOrReturn(CheckValue("nullableInt8u.Value()", nullableInt8u.Value(), 254)); @@ -39361,7 +40166,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8uInvalidValue_183() + CHIP_ERROR TestWriteAttributeNullableInt8uInvalidValue_201() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39371,30 +40176,30 @@ class TestCluster : public TestCommand nullableInt8uArgument.SetNonNull() = 255; return cluster.WriteAttribute( - nullableInt8uArgument, this, OnSuccessCallback_183, OnFailureCallback_183); + nullableInt8uArgument, this, OnSuccessCallback_201, OnFailureCallback_201); } - void OnFailureResponse_183(uint8_t status) + void OnFailureResponse_201(uint8_t status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_183() { ThrowSuccessResponse(); } + void OnSuccessResponse_201() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt8uUnchangedValue_184() + CHIP_ERROR TestReadAttributeNullableInt8uUnchangedValue_202() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_184, OnFailureCallback_184); + this, OnSuccessCallback_202, OnFailureCallback_202); } - void OnFailureResponse_184(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_202(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_184(const chip::app::DataModel::Nullable & nullableInt8u) + void OnSuccessResponse_202(const chip::app::DataModel::Nullable & nullableInt8u) { VerifyOrReturn(CheckValueNonNull("nullableInt8u", nullableInt8u)); VerifyOrReturn(CheckValue("nullableInt8u.Value()", nullableInt8u.Value(), 254)); @@ -39402,7 +40207,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8uNullValue_185() + CHIP_ERROR TestWriteAttributeNullableInt8uNullValue_203() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39412,33 +40217,33 @@ class TestCluster : public TestCommand nullableInt8uArgument.SetNull(); return cluster.WriteAttribute( - nullableInt8uArgument, this, OnSuccessCallback_185, OnFailureCallback_185); + nullableInt8uArgument, this, OnSuccessCallback_203, OnFailureCallback_203); } - void OnFailureResponse_185(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_203(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_185() { NextTest(); } + void OnSuccessResponse_203() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8uNullValue_186() + CHIP_ERROR TestReadAttributeNullableInt8uNullValue_204() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_186, OnFailureCallback_186); + this, OnSuccessCallback_204, OnFailureCallback_204); } - void OnFailureResponse_186(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_204(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_186(const chip::app::DataModel::Nullable & nullableInt8u) + void OnSuccessResponse_204(const chip::app::DataModel::Nullable & nullableInt8u) { VerifyOrReturn(CheckValueNull("nullableInt8u", nullableInt8u)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16uMaxValue_187() + CHIP_ERROR TestWriteAttributeNullableInt16uMaxValue_205() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39448,26 +40253,26 @@ class TestCluster : public TestCommand nullableInt16uArgument.SetNonNull() = 65534U; return cluster.WriteAttribute( - nullableInt16uArgument, this, OnSuccessCallback_187, OnFailureCallback_187); + nullableInt16uArgument, this, OnSuccessCallback_205, OnFailureCallback_205); } - void OnFailureResponse_187(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_205(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_187() { NextTest(); } + void OnSuccessResponse_205() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uMaxValue_188() + CHIP_ERROR TestReadAttributeNullableInt16uMaxValue_206() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_188, OnFailureCallback_188); + this, OnSuccessCallback_206, OnFailureCallback_206); } - void OnFailureResponse_188(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_206(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_188(const chip::app::DataModel::Nullable & nullableInt16u) + void OnSuccessResponse_206(const chip::app::DataModel::Nullable & nullableInt16u) { VerifyOrReturn(CheckValueNonNull("nullableInt16u", nullableInt16u)); VerifyOrReturn(CheckValue("nullableInt16u.Value()", nullableInt16u.Value(), 65534U)); @@ -39475,7 +40280,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16uInvalidValue_189() + CHIP_ERROR TestWriteAttributeNullableInt16uInvalidValue_207() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39485,30 +40290,30 @@ class TestCluster : public TestCommand nullableInt16uArgument.SetNonNull() = 65535U; return cluster.WriteAttribute( - nullableInt16uArgument, this, OnSuccessCallback_189, OnFailureCallback_189); + nullableInt16uArgument, this, OnSuccessCallback_207, OnFailureCallback_207); } - void OnFailureResponse_189(uint8_t status) + void OnFailureResponse_207(uint8_t status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_189() { ThrowSuccessResponse(); } + void OnSuccessResponse_207() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt16uUnchangedValue_190() + CHIP_ERROR TestReadAttributeNullableInt16uUnchangedValue_208() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_190, OnFailureCallback_190); + this, OnSuccessCallback_208, OnFailureCallback_208); } - void OnFailureResponse_190(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_208(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_190(const chip::app::DataModel::Nullable & nullableInt16u) + void OnSuccessResponse_208(const chip::app::DataModel::Nullable & nullableInt16u) { VerifyOrReturn(CheckValueNonNull("nullableInt16u", nullableInt16u)); VerifyOrReturn(CheckValue("nullableInt16u.Value()", nullableInt16u.Value(), 65534U)); @@ -39516,7 +40321,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16uNullValue_191() + CHIP_ERROR TestWriteAttributeNullableInt16uNullValue_209() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39526,33 +40331,33 @@ class TestCluster : public TestCommand nullableInt16uArgument.SetNull(); return cluster.WriteAttribute( - nullableInt16uArgument, this, OnSuccessCallback_191, OnFailureCallback_191); + nullableInt16uArgument, this, OnSuccessCallback_209, OnFailureCallback_209); } - void OnFailureResponse_191(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_209(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_191() { NextTest(); } + void OnSuccessResponse_209() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uNullValue_192() + CHIP_ERROR TestReadAttributeNullableInt16uNullValue_210() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_192, OnFailureCallback_192); + this, OnSuccessCallback_210, OnFailureCallback_210); } - void OnFailureResponse_192(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_210(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_192(const chip::app::DataModel::Nullable & nullableInt16u) + void OnSuccessResponse_210(const chip::app::DataModel::Nullable & nullableInt16u) { VerifyOrReturn(CheckValueNull("nullableInt16u", nullableInt16u)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32uMaxValue_193() + CHIP_ERROR TestWriteAttributeNullableInt32uMaxValue_211() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39562,26 +40367,26 @@ class TestCluster : public TestCommand nullableInt32uArgument.SetNonNull() = 4294967294UL; return cluster.WriteAttribute( - nullableInt32uArgument, this, OnSuccessCallback_193, OnFailureCallback_193); + nullableInt32uArgument, this, OnSuccessCallback_211, OnFailureCallback_211); } - void OnFailureResponse_193(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_211(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_193() { NextTest(); } + void OnSuccessResponse_211() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32uMaxValue_194() + CHIP_ERROR TestReadAttributeNullableInt32uMaxValue_212() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_194, OnFailureCallback_194); + this, OnSuccessCallback_212, OnFailureCallback_212); } - void OnFailureResponse_194(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_212(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_194(const chip::app::DataModel::Nullable & nullableInt32u) + void OnSuccessResponse_212(const chip::app::DataModel::Nullable & nullableInt32u) { VerifyOrReturn(CheckValueNonNull("nullableInt32u", nullableInt32u)); VerifyOrReturn(CheckValue("nullableInt32u.Value()", nullableInt32u.Value(), 4294967294UL)); @@ -39589,7 +40394,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32uInvalidValue_195() + CHIP_ERROR TestWriteAttributeNullableInt32uInvalidValue_213() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39599,30 +40404,30 @@ class TestCluster : public TestCommand nullableInt32uArgument.SetNonNull() = 4294967295UL; return cluster.WriteAttribute( - nullableInt32uArgument, this, OnSuccessCallback_195, OnFailureCallback_195); + nullableInt32uArgument, this, OnSuccessCallback_213, OnFailureCallback_213); } - void OnFailureResponse_195(uint8_t status) + void OnFailureResponse_213(uint8_t status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_195() { ThrowSuccessResponse(); } + void OnSuccessResponse_213() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt32uUnchangedValue_196() + CHIP_ERROR TestReadAttributeNullableInt32uUnchangedValue_214() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_196, OnFailureCallback_196); + this, OnSuccessCallback_214, OnFailureCallback_214); } - void OnFailureResponse_196(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_214(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_196(const chip::app::DataModel::Nullable & nullableInt32u) + void OnSuccessResponse_214(const chip::app::DataModel::Nullable & nullableInt32u) { VerifyOrReturn(CheckValueNonNull("nullableInt32u", nullableInt32u)); VerifyOrReturn(CheckValue("nullableInt32u.Value()", nullableInt32u.Value(), 4294967294UL)); @@ -39630,7 +40435,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32uNullValue_197() + CHIP_ERROR TestWriteAttributeNullableInt32uNullValue_215() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39640,33 +40445,33 @@ class TestCluster : public TestCommand nullableInt32uArgument.SetNull(); return cluster.WriteAttribute( - nullableInt32uArgument, this, OnSuccessCallback_197, OnFailureCallback_197); + nullableInt32uArgument, this, OnSuccessCallback_215, OnFailureCallback_215); } - void OnFailureResponse_197(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_215(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_197() { NextTest(); } + void OnSuccessResponse_215() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32uNullValue_198() + CHIP_ERROR TestReadAttributeNullableInt32uNullValue_216() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_198, OnFailureCallback_198); + this, OnSuccessCallback_216, OnFailureCallback_216); } - void OnFailureResponse_198(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_216(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_198(const chip::app::DataModel::Nullable & nullableInt32u) + void OnSuccessResponse_216(const chip::app::DataModel::Nullable & nullableInt32u) { VerifyOrReturn(CheckValueNull("nullableInt32u", nullableInt32u)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64uMaxValue_199() + CHIP_ERROR TestWriteAttributeNullableInt64uMaxValue_217() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39676,26 +40481,26 @@ class TestCluster : public TestCommand nullableInt64uArgument.SetNonNull() = 18446744073709551614ULL; return cluster.WriteAttribute( - nullableInt64uArgument, this, OnSuccessCallback_199, OnFailureCallback_199); + nullableInt64uArgument, this, OnSuccessCallback_217, OnFailureCallback_217); } - void OnFailureResponse_199(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_217(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_199() { NextTest(); } + void OnSuccessResponse_217() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64uMaxValue_200() + CHIP_ERROR TestReadAttributeNullableInt64uMaxValue_218() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_200, OnFailureCallback_200); + this, OnSuccessCallback_218, OnFailureCallback_218); } - void OnFailureResponse_200(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_218(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_200(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_218(const chip::app::DataModel::Nullable & nullableInt64u) { VerifyOrReturn(CheckValueNonNull("nullableInt64u", nullableInt64u)); VerifyOrReturn(CheckValue("nullableInt64u.Value()", nullableInt64u.Value(), 18446744073709551614ULL)); @@ -39703,7 +40508,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64uInvalidValue_201() + CHIP_ERROR TestWriteAttributeNullableInt64uInvalidValue_219() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39713,30 +40518,30 @@ class TestCluster : public TestCommand nullableInt64uArgument.SetNonNull() = 18446744073709551615ULL; return cluster.WriteAttribute( - nullableInt64uArgument, this, OnSuccessCallback_201, OnFailureCallback_201); + nullableInt64uArgument, this, OnSuccessCallback_219, OnFailureCallback_219); } - void OnFailureResponse_201(uint8_t status) + void OnFailureResponse_219(uint8_t status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_201() { ThrowSuccessResponse(); } + void OnSuccessResponse_219() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt64uUnchangedValue_202() + CHIP_ERROR TestReadAttributeNullableInt64uUnchangedValue_220() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_202, OnFailureCallback_202); + this, OnSuccessCallback_220, OnFailureCallback_220); } - void OnFailureResponse_202(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_220(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_202(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_220(const chip::app::DataModel::Nullable & nullableInt64u) { VerifyOrReturn(CheckValueNonNull("nullableInt64u", nullableInt64u)); VerifyOrReturn(CheckValue("nullableInt64u.Value()", nullableInt64u.Value(), 18446744073709551614ULL)); @@ -39744,7 +40549,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64uNullValue_203() + CHIP_ERROR TestWriteAttributeNullableInt64uNullValue_221() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39754,33 +40559,33 @@ class TestCluster : public TestCommand nullableInt64uArgument.SetNull(); return cluster.WriteAttribute( - nullableInt64uArgument, this, OnSuccessCallback_203, OnFailureCallback_203); + nullableInt64uArgument, this, OnSuccessCallback_221, OnFailureCallback_221); } - void OnFailureResponse_203(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_221(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_203() { NextTest(); } + void OnSuccessResponse_221() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64uNullValue_204() + CHIP_ERROR TestReadAttributeNullableInt64uNullValue_222() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_204, OnFailureCallback_204); + this, OnSuccessCallback_222, OnFailureCallback_222); } - void OnFailureResponse_204(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_222(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_204(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_222(const chip::app::DataModel::Nullable & nullableInt64u) { VerifyOrReturn(CheckValueNull("nullableInt64u", nullableInt64u)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sMinValue_205() + CHIP_ERROR TestWriteAttributeNullableInt8sMinValue_223() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39790,26 +40595,26 @@ class TestCluster : public TestCommand nullableInt8sArgument.SetNonNull() = -127; return cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_205, OnFailureCallback_205); + nullableInt8sArgument, this, OnSuccessCallback_223, OnFailureCallback_223); } - void OnFailureResponse_205(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_223(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_205() { NextTest(); } + void OnSuccessResponse_223() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sMinValue_206() + CHIP_ERROR TestReadAttributeNullableInt8sMinValue_224() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_206, OnFailureCallback_206); + this, OnSuccessCallback_224, OnFailureCallback_224); } - void OnFailureResponse_206(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_224(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_206(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_224(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckValueNonNull("nullableInt8s", nullableInt8s)); VerifyOrReturn(CheckValue("nullableInt8s.Value()", nullableInt8s.Value(), -127)); @@ -39817,7 +40622,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sInvalidValue_207() + CHIP_ERROR TestWriteAttributeNullableInt8sInvalidValue_225() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39827,30 +40632,30 @@ class TestCluster : public TestCommand nullableInt8sArgument.SetNonNull() = -128; return cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_207, OnFailureCallback_207); + nullableInt8sArgument, this, OnSuccessCallback_225, OnFailureCallback_225); } - void OnFailureResponse_207(uint8_t status) + void OnFailureResponse_225(uint8_t status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_207() { ThrowSuccessResponse(); } + void OnSuccessResponse_225() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt8sUnchangedValue_208() + CHIP_ERROR TestReadAttributeNullableInt8sUnchangedValue_226() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_208, OnFailureCallback_208); + this, OnSuccessCallback_226, OnFailureCallback_226); } - void OnFailureResponse_208(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_226(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_208(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_226(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckValueNonNull("nullableInt8s", nullableInt8s)); VerifyOrReturn(CheckValue("nullableInt8s.Value()", nullableInt8s.Value(), -127)); @@ -39858,7 +40663,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sNullValue_209() + CHIP_ERROR TestWriteAttributeNullableInt8sNullValue_227() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39868,33 +40673,33 @@ class TestCluster : public TestCommand nullableInt8sArgument.SetNull(); return cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_209, OnFailureCallback_209); + nullableInt8sArgument, this, OnSuccessCallback_227, OnFailureCallback_227); } - void OnFailureResponse_209(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_227(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_209() { NextTest(); } + void OnSuccessResponse_227() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sNullValue_210() + CHIP_ERROR TestReadAttributeNullableInt8sNullValue_228() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_210, OnFailureCallback_210); + this, OnSuccessCallback_228, OnFailureCallback_228); } - void OnFailureResponse_210(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_228(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_210(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_228(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckValueNull("nullableInt8s", nullableInt8s)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sMinValue_211() + CHIP_ERROR TestWriteAttributeNullableInt16sMinValue_229() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39904,26 +40709,26 @@ class TestCluster : public TestCommand nullableInt16sArgument.SetNonNull() = -32767; return cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_211, OnFailureCallback_211); + nullableInt16sArgument, this, OnSuccessCallback_229, OnFailureCallback_229); } - void OnFailureResponse_211(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_229(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_211() { NextTest(); } + void OnSuccessResponse_229() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sMinValue_212() + CHIP_ERROR TestReadAttributeNullableInt16sMinValue_230() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_212, OnFailureCallback_212); + this, OnSuccessCallback_230, OnFailureCallback_230); } - void OnFailureResponse_212(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_230(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_212(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_230(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckValueNonNull("nullableInt16s", nullableInt16s)); VerifyOrReturn(CheckValue("nullableInt16s.Value()", nullableInt16s.Value(), -32767)); @@ -39931,7 +40736,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sInvalidValue_213() + CHIP_ERROR TestWriteAttributeNullableInt16sInvalidValue_231() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39941,30 +40746,30 @@ class TestCluster : public TestCommand nullableInt16sArgument.SetNonNull() = -32768; return cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_213, OnFailureCallback_213); + nullableInt16sArgument, this, OnSuccessCallback_231, OnFailureCallback_231); } - void OnFailureResponse_213(uint8_t status) + void OnFailureResponse_231(uint8_t status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_213() { ThrowSuccessResponse(); } + void OnSuccessResponse_231() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt16sUnchangedValue_214() + CHIP_ERROR TestReadAttributeNullableInt16sUnchangedValue_232() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_214, OnFailureCallback_214); + this, OnSuccessCallback_232, OnFailureCallback_232); } - void OnFailureResponse_214(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_232(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_214(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_232(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckValueNonNull("nullableInt16s", nullableInt16s)); VerifyOrReturn(CheckValue("nullableInt16s.Value()", nullableInt16s.Value(), -32767)); @@ -39972,7 +40777,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sNullValue_215() + CHIP_ERROR TestWriteAttributeNullableInt16sNullValue_233() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -39982,33 +40787,33 @@ class TestCluster : public TestCommand nullableInt16sArgument.SetNull(); return cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_215, OnFailureCallback_215); + nullableInt16sArgument, this, OnSuccessCallback_233, OnFailureCallback_233); } - void OnFailureResponse_215(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_233(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_215() { NextTest(); } + void OnSuccessResponse_233() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sNullValue_216() + CHIP_ERROR TestReadAttributeNullableInt16sNullValue_234() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_216, OnFailureCallback_216); + this, OnSuccessCallback_234, OnFailureCallback_234); } - void OnFailureResponse_216(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_234(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_216(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_234(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckValueNull("nullableInt16s", nullableInt16s)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sMinValue_217() + CHIP_ERROR TestWriteAttributeNullableInt32sMinValue_235() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -40018,26 +40823,26 @@ class TestCluster : public TestCommand nullableInt32sArgument.SetNonNull() = -2147483647L; return cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_217, OnFailureCallback_217); + nullableInt32sArgument, this, OnSuccessCallback_235, OnFailureCallback_235); } - void OnFailureResponse_217(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_235(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_217() { NextTest(); } + void OnSuccessResponse_235() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sMinValue_218() + CHIP_ERROR TestReadAttributeNullableInt32sMinValue_236() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_218, OnFailureCallback_218); + this, OnSuccessCallback_236, OnFailureCallback_236); } - void OnFailureResponse_218(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_236(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_218(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_236(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckValueNonNull("nullableInt32s", nullableInt32s)); VerifyOrReturn(CheckValue("nullableInt32s.Value()", nullableInt32s.Value(), -2147483647L)); @@ -40045,7 +40850,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sInvalidValue_219() + CHIP_ERROR TestWriteAttributeNullableInt32sInvalidValue_237() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -40055,30 +40860,30 @@ class TestCluster : public TestCommand nullableInt32sArgument.SetNonNull() = -2147483648L; return cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_219, OnFailureCallback_219); + nullableInt32sArgument, this, OnSuccessCallback_237, OnFailureCallback_237); } - void OnFailureResponse_219(uint8_t status) + void OnFailureResponse_237(uint8_t status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_219() { ThrowSuccessResponse(); } + void OnSuccessResponse_237() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt32sUnchangedValue_220() + CHIP_ERROR TestReadAttributeNullableInt32sUnchangedValue_238() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_220, OnFailureCallback_220); + this, OnSuccessCallback_238, OnFailureCallback_238); } - void OnFailureResponse_220(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_238(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_220(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_238(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckValueNonNull("nullableInt32s", nullableInt32s)); VerifyOrReturn(CheckValue("nullableInt32s.Value()", nullableInt32s.Value(), -2147483647L)); @@ -40086,7 +40891,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sNullValue_221() + CHIP_ERROR TestWriteAttributeNullableInt32sNullValue_239() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -40096,33 +40901,33 @@ class TestCluster : public TestCommand nullableInt32sArgument.SetNull(); return cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_221, OnFailureCallback_221); + nullableInt32sArgument, this, OnSuccessCallback_239, OnFailureCallback_239); } - void OnFailureResponse_221(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_239(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_221() { NextTest(); } + void OnSuccessResponse_239() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sNullValue_222() + CHIP_ERROR TestReadAttributeNullableInt32sNullValue_240() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_222, OnFailureCallback_222); + this, OnSuccessCallback_240, OnFailureCallback_240); } - void OnFailureResponse_222(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_240(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_222(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_240(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckValueNull("nullableInt32s", nullableInt32s)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sMinValue_223() + CHIP_ERROR TestWriteAttributeNullableInt64sMinValue_241() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -40132,26 +40937,26 @@ class TestCluster : public TestCommand nullableInt64sArgument.SetNonNull() = -9223372036854775807LL; return cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_223, OnFailureCallback_223); + nullableInt64sArgument, this, OnSuccessCallback_241, OnFailureCallback_241); } - void OnFailureResponse_223(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_241(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_223() { NextTest(); } + void OnSuccessResponse_241() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sMinValue_224() + CHIP_ERROR TestReadAttributeNullableInt64sMinValue_242() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_224, OnFailureCallback_224); + this, OnSuccessCallback_242, OnFailureCallback_242); } - void OnFailureResponse_224(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_242(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_224(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_242(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckValueNonNull("nullableInt64s", nullableInt64s)); VerifyOrReturn(CheckValue("nullableInt64s.Value()", nullableInt64s.Value(), -9223372036854775807LL)); @@ -40159,7 +40964,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sInvalidValue_225() + CHIP_ERROR TestWriteAttributeNullableInt64sInvalidValue_243() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -40169,30 +40974,30 @@ class TestCluster : public TestCommand nullableInt64sArgument.SetNonNull() = -9223372036854775807LL - 1; return cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_225, OnFailureCallback_225); + nullableInt64sArgument, this, OnSuccessCallback_243, OnFailureCallback_243); } - void OnFailureResponse_225(uint8_t status) + void OnFailureResponse_243(uint8_t status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_225() { ThrowSuccessResponse(); } + void OnSuccessResponse_243() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt64sUnchangedValue_226() + CHIP_ERROR TestReadAttributeNullableInt64sUnchangedValue_244() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_226, OnFailureCallback_226); + this, OnSuccessCallback_244, OnFailureCallback_244); } - void OnFailureResponse_226(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_244(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_226(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_244(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckValueNonNull("nullableInt64s", nullableInt64s)); VerifyOrReturn(CheckValue("nullableInt64s.Value()", nullableInt64s.Value(), -9223372036854775807LL)); @@ -40200,7 +41005,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sNullValue_227() + CHIP_ERROR TestWriteAttributeNullableInt64sNullValue_245() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -40210,33 +41015,401 @@ class TestCluster : public TestCommand nullableInt64sArgument.SetNull(); return cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_227, OnFailureCallback_227); + nullableInt64sArgument, this, OnSuccessCallback_245, OnFailureCallback_245); } - void OnFailureResponse_227(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_245(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_227() { NextTest(); } + void OnSuccessResponse_245() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sNullValue_228() + CHIP_ERROR TestReadAttributeNullableInt64sNullValue_246() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_228, OnFailureCallback_228); + this, OnSuccessCallback_246, OnFailureCallback_246); } - void OnFailureResponse_228(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_246(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_228(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_246(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckValueNull("nullableInt64s", nullableInt64s)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8MaxValue_229() + CHIP_ERROR TestWriteAttributeNullableSingleMediumValue_247() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableFloatSingleArgument; + nullableFloatSingleArgument.SetNonNull() = 0.1f; + + return cluster.WriteAttribute( + nullableFloatSingleArgument, this, OnSuccessCallback_247, OnFailureCallback_247); + } + + void OnFailureResponse_247(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_247() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableSingleMediumValue_248() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_248, OnFailureCallback_248); + } + + void OnFailureResponse_248(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_248(const chip::app::DataModel::Nullable & nullableFloatSingle) + { + VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); + VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), 0.1f)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableSingleLargestValue_249() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableFloatSingleArgument; + nullableFloatSingleArgument.SetNonNull() = INFINITY; + + return cluster.WriteAttribute( + nullableFloatSingleArgument, this, OnSuccessCallback_249, OnFailureCallback_249); + } + + void OnFailureResponse_249(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_249() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableSingleLargestValue_250() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_250, OnFailureCallback_250); + } + + void OnFailureResponse_250(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_250(const chip::app::DataModel::Nullable & nullableFloatSingle) + { + VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); + VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), INFINITY)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableSingleSmallestValue_251() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableFloatSingleArgument; + nullableFloatSingleArgument.SetNonNull() = -INFINITY; + + return cluster.WriteAttribute( + nullableFloatSingleArgument, this, OnSuccessCallback_251, OnFailureCallback_251); + } + + void OnFailureResponse_251(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_251() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableSingleSmallestValue_252() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_252, OnFailureCallback_252); + } + + void OnFailureResponse_252(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_252(const chip::app::DataModel::Nullable & nullableFloatSingle) + { + VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); + VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), -INFINITY)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableSingleNullValue_253() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableFloatSingleArgument; + nullableFloatSingleArgument.SetNull(); + + return cluster.WriteAttribute( + nullableFloatSingleArgument, this, OnSuccessCallback_253, OnFailureCallback_253); + } + + void OnFailureResponse_253(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_253() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableSingleNullValue_254() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_254, OnFailureCallback_254); + } + + void OnFailureResponse_254(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_254(const chip::app::DataModel::Nullable & nullableFloatSingle) + { + VerifyOrReturn(CheckValueNull("nullableFloatSingle", nullableFloatSingle)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableSingle0Value_255() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableFloatSingleArgument; + nullableFloatSingleArgument.SetNonNull() = 0.0f; + + return cluster.WriteAttribute( + nullableFloatSingleArgument, this, OnSuccessCallback_255, OnFailureCallback_255); + } + + void OnFailureResponse_255(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_255() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableSingle0Value_256() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_256, OnFailureCallback_256); + } + + void OnFailureResponse_256(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_256(const chip::app::DataModel::Nullable & nullableFloatSingle) + { + VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); + VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), 0.0f)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableDoubleMediumValue_257() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableFloatDoubleArgument; + nullableFloatDoubleArgument.SetNonNull() = 0.1234567890123; + + return cluster.WriteAttribute( + nullableFloatDoubleArgument, this, OnSuccessCallback_257, OnFailureCallback_257); + } + + void OnFailureResponse_257(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_257() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableDoubleMediumValue_258() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_258, OnFailureCallback_258); + } + + void OnFailureResponse_258(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_258(const chip::app::DataModel::Nullable & nullableFloatDouble) + { + VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); + VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), 0.1234567890123)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableDoubleLargestValue_259() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableFloatDoubleArgument; + nullableFloatDoubleArgument.SetNonNull() = INFINITY; + + return cluster.WriteAttribute( + nullableFloatDoubleArgument, this, OnSuccessCallback_259, OnFailureCallback_259); + } + + void OnFailureResponse_259(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_259() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableDoubleLargestValue_260() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_260, OnFailureCallback_260); + } + + void OnFailureResponse_260(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_260(const chip::app::DataModel::Nullable & nullableFloatDouble) + { + VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); + VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), INFINITY)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableDoubleSmallestValue_261() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableFloatDoubleArgument; + nullableFloatDoubleArgument.SetNonNull() = -INFINITY; + + return cluster.WriteAttribute( + nullableFloatDoubleArgument, this, OnSuccessCallback_261, OnFailureCallback_261); + } + + void OnFailureResponse_261(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_261() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableDoubleSmallestValue_262() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_262, OnFailureCallback_262); + } + + void OnFailureResponse_262(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_262(const chip::app::DataModel::Nullable & nullableFloatDouble) + { + VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); + VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), -INFINITY)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableDoubleNullValue_263() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableFloatDoubleArgument; + nullableFloatDoubleArgument.SetNull(); + + return cluster.WriteAttribute( + nullableFloatDoubleArgument, this, OnSuccessCallback_263, OnFailureCallback_263); + } + + void OnFailureResponse_263(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_263() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableDoubleNullValue_264() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_264, OnFailureCallback_264); + } + + void OnFailureResponse_264(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_264(const chip::app::DataModel::Nullable & nullableFloatDouble) + { + VerifyOrReturn(CheckValueNull("nullableFloatDouble", nullableFloatDouble)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableDouble0Value_265() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableFloatDoubleArgument; + nullableFloatDoubleArgument.SetNonNull() = 0; + + return cluster.WriteAttribute( + nullableFloatDoubleArgument, this, OnSuccessCallback_265, OnFailureCallback_265); + } + + void OnFailureResponse_265(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_265() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableDouble0Value_266() + { + const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + return cluster.ReadAttribute( + this, OnSuccessCallback_266, OnFailureCallback_266); + } + + void OnFailureResponse_266(uint8_t status) { ThrowFailureResponse(); } + + void OnSuccessResponse_266(const chip::app::DataModel::Nullable & nullableFloatDouble) + { + VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); + VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), 0)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableEnum8MaxValue_267() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -40246,26 +41419,26 @@ class TestCluster : public TestCommand nullableEnum8Argument.SetNonNull() = static_cast(254); return cluster.WriteAttribute( - nullableEnum8Argument, this, OnSuccessCallback_229, OnFailureCallback_229); + nullableEnum8Argument, this, OnSuccessCallback_267, OnFailureCallback_267); } - void OnFailureResponse_229(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_267(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_229() { NextTest(); } + void OnSuccessResponse_267() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum8MaxValue_230() + CHIP_ERROR TestReadAttributeNullableEnum8MaxValue_268() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_230, OnFailureCallback_230); + this, OnSuccessCallback_268, OnFailureCallback_268); } - void OnFailureResponse_230(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_268(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_230(const chip::app::DataModel::Nullable & nullableEnum8) + void OnSuccessResponse_268(const chip::app::DataModel::Nullable & nullableEnum8) { VerifyOrReturn(CheckValueNonNull("nullableEnum8", nullableEnum8)); VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 254)); @@ -40273,7 +41446,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8InvalidValue_231() + CHIP_ERROR TestWriteAttributeNullableEnum8InvalidValue_269() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -40283,30 +41456,30 @@ class TestCluster : public TestCommand nullableEnum8Argument.SetNonNull() = static_cast(255); return cluster.WriteAttribute( - nullableEnum8Argument, this, OnSuccessCallback_231, OnFailureCallback_231); + nullableEnum8Argument, this, OnSuccessCallback_269, OnFailureCallback_269); } - void OnFailureResponse_231(uint8_t status) + void OnFailureResponse_269(uint8_t status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_231() { ThrowSuccessResponse(); } + void OnSuccessResponse_269() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableEnum8UnchangedValue_232() + CHIP_ERROR TestReadAttributeNullableEnum8UnchangedValue_270() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_232, OnFailureCallback_232); + this, OnSuccessCallback_270, OnFailureCallback_270); } - void OnFailureResponse_232(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_270(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_232(const chip::app::DataModel::Nullable & nullableEnum8) + void OnSuccessResponse_270(const chip::app::DataModel::Nullable & nullableEnum8) { VerifyOrReturn(CheckValueNonNull("nullableEnum8", nullableEnum8)); VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 254)); @@ -40314,7 +41487,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8NullValue_233() + CHIP_ERROR TestWriteAttributeNullableEnum8NullValue_271() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -40324,33 +41497,33 @@ class TestCluster : public TestCommand nullableEnum8Argument.SetNull(); return cluster.WriteAttribute( - nullableEnum8Argument, this, OnSuccessCallback_233, OnFailureCallback_233); + nullableEnum8Argument, this, OnSuccessCallback_271, OnFailureCallback_271); } - void OnFailureResponse_233(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_271(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_233() { NextTest(); } + void OnSuccessResponse_271() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum8NullValue_234() + CHIP_ERROR TestReadAttributeNullableEnum8NullValue_272() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_234, OnFailureCallback_234); + this, OnSuccessCallback_272, OnFailureCallback_272); } - void OnFailureResponse_234(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_272(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_234(const chip::app::DataModel::Nullable & nullableEnum8) + void OnSuccessResponse_272(const chip::app::DataModel::Nullable & nullableEnum8) { VerifyOrReturn(CheckValueNull("nullableEnum8", nullableEnum8)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16MaxValue_235() + CHIP_ERROR TestWriteAttributeNullableEnum16MaxValue_273() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -40360,26 +41533,26 @@ class TestCluster : public TestCommand nullableEnum16Argument.SetNonNull() = static_cast(65534); return cluster.WriteAttribute( - nullableEnum16Argument, this, OnSuccessCallback_235, OnFailureCallback_235); + nullableEnum16Argument, this, OnSuccessCallback_273, OnFailureCallback_273); } - void OnFailureResponse_235(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_273(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_235() { NextTest(); } + void OnSuccessResponse_273() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum16MaxValue_236() + CHIP_ERROR TestReadAttributeNullableEnum16MaxValue_274() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_236, OnFailureCallback_236); + this, OnSuccessCallback_274, OnFailureCallback_274); } - void OnFailureResponse_236(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_274(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_236(const chip::app::DataModel::Nullable & nullableEnum16) + void OnSuccessResponse_274(const chip::app::DataModel::Nullable & nullableEnum16) { VerifyOrReturn(CheckValueNonNull("nullableEnum16", nullableEnum16)); VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 65534U)); @@ -40387,7 +41560,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16InvalidValue_237() + CHIP_ERROR TestWriteAttributeNullableEnum16InvalidValue_275() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -40397,30 +41570,30 @@ class TestCluster : public TestCommand nullableEnum16Argument.SetNonNull() = static_cast(65535); return cluster.WriteAttribute( - nullableEnum16Argument, this, OnSuccessCallback_237, OnFailureCallback_237); + nullableEnum16Argument, this, OnSuccessCallback_275, OnFailureCallback_275); } - void OnFailureResponse_237(uint8_t status) + void OnFailureResponse_275(uint8_t status) { VerifyOrReturn(CheckValue("status", status, EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_237() { ThrowSuccessResponse(); } + void OnSuccessResponse_275() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableEnum16UnchangedValue_238() + CHIP_ERROR TestReadAttributeNullableEnum16UnchangedValue_276() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_238, OnFailureCallback_238); + this, OnSuccessCallback_276, OnFailureCallback_276); } - void OnFailureResponse_238(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_276(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_238(const chip::app::DataModel::Nullable & nullableEnum16) + void OnSuccessResponse_276(const chip::app::DataModel::Nullable & nullableEnum16) { VerifyOrReturn(CheckValueNonNull("nullableEnum16", nullableEnum16)); VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 65534U)); @@ -40428,7 +41601,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16NullValue_239() + CHIP_ERROR TestWriteAttributeNullableEnum16NullValue_277() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -40438,45 +41611,45 @@ class TestCluster : public TestCommand nullableEnum16Argument.SetNull(); return cluster.WriteAttribute( - nullableEnum16Argument, this, OnSuccessCallback_239, OnFailureCallback_239); + nullableEnum16Argument, this, OnSuccessCallback_277, OnFailureCallback_277); } - void OnFailureResponse_239(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_277(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_239() { NextTest(); } + void OnSuccessResponse_277() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum16NullValue_240() + CHIP_ERROR TestReadAttributeNullableEnum16NullValue_278() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_240, OnFailureCallback_240); + this, OnSuccessCallback_278, OnFailureCallback_278); } - void OnFailureResponse_240(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_278(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_240(const chip::app::DataModel::Nullable & nullableEnum16) + void OnSuccessResponse_278(const chip::app::DataModel::Nullable & nullableEnum16) { VerifyOrReturn(CheckValueNull("nullableEnum16", nullableEnum16)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetStringDefaultValue_241() + CHIP_ERROR TestReadAttributeNullableOctetStringDefaultValue_279() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_241, OnFailureCallback_241); + this, OnSuccessCallback_279, OnFailureCallback_279); } - void OnFailureResponse_241(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_279(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_241(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_279(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), @@ -40485,7 +41658,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableOctetString_242() + CHIP_ERROR TestWriteAttributeNullableOctetString_280() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -40496,26 +41669,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_242, OnFailureCallback_242); + nullableOctetStringArgument, this, OnSuccessCallback_280, OnFailureCallback_280); } - void OnFailureResponse_242(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_280(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_242() { NextTest(); } + void OnSuccessResponse_280() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetString_243() + CHIP_ERROR TestReadAttributeNullableOctetString_281() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_243, OnFailureCallback_243); + this, OnSuccessCallback_281, OnFailureCallback_281); } - void OnFailureResponse_243(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_281(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_243(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_281(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), @@ -40524,7 +41697,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableOctetString_244() + CHIP_ERROR TestWriteAttributeNullableOctetString_282() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -40534,33 +41707,33 @@ class TestCluster : public TestCommand nullableOctetStringArgument.SetNull(); return cluster.WriteAttribute( - nullableOctetStringArgument, this, OnSuccessCallback_244, OnFailureCallback_244); + nullableOctetStringArgument, this, OnSuccessCallback_282, OnFailureCallback_282); } - void OnFailureResponse_244(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_282(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_244() { NextTest(); } + void OnSuccessResponse_282() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetString_245() + CHIP_ERROR TestReadAttributeNullableOctetString_283() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_245, OnFailureCallback_245); + this, OnSuccessCallback_283, OnFailureCallback_283); } - void OnFailureResponse_245(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_283(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_245(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_283(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNull("nullableOctetString", nullableOctetString)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableOctetString_246() + CHIP_ERROR TestWriteAttributeNullableOctetString_284() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -40571,26 +41744,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_246, OnFailureCallback_246); + nullableOctetStringArgument, this, OnSuccessCallback_284, OnFailureCallback_284); } - void OnFailureResponse_246(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_284(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_246() { NextTest(); } + void OnSuccessResponse_284() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetString_247() + CHIP_ERROR TestReadAttributeNullableOctetString_285() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_247, OnFailureCallback_247); + this, OnSuccessCallback_285, OnFailureCallback_285); } - void OnFailureResponse_247(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_285(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_247(const chip::app::DataModel::Nullable & nullableOctetString) + void OnSuccessResponse_285(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), @@ -40599,19 +41772,19 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharStringDefaultValue_248() + CHIP_ERROR TestReadAttributeNullableCharStringDefaultValue_286() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_248, OnFailureCallback_248); + this, OnSuccessCallback_286, OnFailureCallback_286); } - void OnFailureResponse_248(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_286(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_248(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_286(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNonNull("nullableCharString", nullableCharString)); VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", nullableCharString.Value(), chip::CharSpan("", 0))); @@ -40619,7 +41792,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableCharString_249() + CHIP_ERROR TestWriteAttributeNullableCharString_287() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -40629,26 +41802,26 @@ class TestCluster : public TestCommand nullableCharStringArgument.SetNonNull() = chip::Span("☉T☉garbage: not in length on purpose", 7); return cluster.WriteAttribute( - nullableCharStringArgument, this, OnSuccessCallback_249, OnFailureCallback_249); + nullableCharStringArgument, this, OnSuccessCallback_287, OnFailureCallback_287); } - void OnFailureResponse_249(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_287(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_249() { NextTest(); } + void OnSuccessResponse_287() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharString_250() + CHIP_ERROR TestReadAttributeNullableCharString_288() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_250, OnFailureCallback_250); + this, OnSuccessCallback_288, OnFailureCallback_288); } - void OnFailureResponse_250(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_288(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_250(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_288(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNonNull("nullableCharString", nullableCharString)); VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", nullableCharString.Value(), chip::CharSpan("☉T☉", 7))); @@ -40656,7 +41829,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableCharStringValueTooLong_251() + CHIP_ERROR TestWriteAttributeNullableCharStringValueTooLong_289() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -40666,33 +41839,33 @@ class TestCluster : public TestCommand nullableCharStringArgument.SetNull(); return cluster.WriteAttribute( - nullableCharStringArgument, this, OnSuccessCallback_251, OnFailureCallback_251); + nullableCharStringArgument, this, OnSuccessCallback_289, OnFailureCallback_289); } - void OnFailureResponse_251(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_289(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_251() { NextTest(); } + void OnSuccessResponse_289() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharString_252() + CHIP_ERROR TestReadAttributeNullableCharString_290() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_252, OnFailureCallback_252); + this, OnSuccessCallback_290, OnFailureCallback_290); } - void OnFailureResponse_252(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_290(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_252(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_290(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNull("nullableCharString", nullableCharString)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableCharStringEmpty_253() + CHIP_ERROR TestWriteAttributeNullableCharStringEmpty_291() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -40702,26 +41875,26 @@ class TestCluster : public TestCommand nullableCharStringArgument.SetNonNull() = chip::Span("garbage: not in length on purpose", 0); return cluster.WriteAttribute( - nullableCharStringArgument, this, OnSuccessCallback_253, OnFailureCallback_253); + nullableCharStringArgument, this, OnSuccessCallback_291, OnFailureCallback_291); } - void OnFailureResponse_253(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_291(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_253() { NextTest(); } + void OnSuccessResponse_291() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharString_254() + CHIP_ERROR TestReadAttributeNullableCharString_292() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); return cluster.ReadAttribute( - this, OnSuccessCallback_254, OnFailureCallback_254); + this, OnSuccessCallback_292, OnFailureCallback_292); } - void OnFailureResponse_254(uint8_t status) { ThrowFailureResponse(); } + void OnFailureResponse_292(uint8_t status) { ThrowFailureResponse(); } - void OnSuccessResponse_254(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_292(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNonNull("nullableCharString", nullableCharString)); VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", nullableCharString.Value(), chip::CharSpan("", 0))); @@ -40729,41 +41902,41 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeFromNonexistentEndpoint_255() + CHIP_ERROR TestReadAttributeFromNonexistentEndpoint_293() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 200; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_255, - OnFailureCallback_255); + return cluster.ReadAttribute(this, OnSuccessCallback_293, + OnFailureCallback_293); } - void OnFailureResponse_255(uint8_t status) + void OnFailureResponse_293(uint8_t status) { VerifyOrReturn(CheckConstraintNotValue("status", status, 0)); NextTest(); } - void OnSuccessResponse_255(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } + void OnSuccessResponse_293(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeFromNonexistentCluster_256() + CHIP_ERROR TestReadAttributeFromNonexistentCluster_294() { const chip::EndpointId endpoint = mEndpointId.HasValue() ? mEndpointId.Value() : 0; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - return cluster.ReadAttribute(this, OnSuccessCallback_256, - OnFailureCallback_256); + return cluster.ReadAttribute(this, OnSuccessCallback_294, + OnFailureCallback_294); } - void OnFailureResponse_256(uint8_t status) + void OnFailureResponse_294(uint8_t status) { VerifyOrReturn(CheckConstraintNotValue("status", status, 0)); NextTest(); } - void OnSuccessResponse_256(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } + void OnSuccessResponse_294(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } }; class TestClusterComplexTypes : public TestCommand diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp index 244c79fe2579a9..45b3233fe2f3a6 100644 --- a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp +++ b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.cpp @@ -17308,6 +17308,84 @@ CHIP_ERROR TestClusterCluster::ReportAttributeEnum16(Callback::Cancelable * onRe BasicAttributeFilter); } +CHIP_ERROR TestClusterCluster::ReadAttributeFloatSingle(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00000017; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeFloatSingle(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, float value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::FloatSingle::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeFloatSingle(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::FloatSingle::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeFloatSingle(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::FloatSingle::Id, onReportCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::ReadAttributeFloatDouble(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00000018; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeFloatDouble(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, double value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::FloatDouble::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeFloatDouble(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::FloatDouble::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeFloatDouble(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::FloatDouble::Id, onReportCallback, + BasicAttributeFilter); +} + CHIP_ERROR TestClusterCluster::ReadAttributeOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { @@ -18739,6 +18817,84 @@ CHIP_ERROR TestClusterCluster::ReportAttributeNullableEnum16(Callback::Cancelabl BasicAttributeFilter); } +CHIP_ERROR TestClusterCluster::ReadAttributeNullableFloatSingle(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00008017; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeNullableFloatSingle(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, float value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::NullableFloatSingle::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeNullableFloatSingle(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::NullableFloatSingle::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeNullableFloatSingle(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::NullableFloatSingle::Id, onReportCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::ReadAttributeNullableFloatDouble(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback) +{ + app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = 0x00008018; + return mDevice->SendReadAttributeRequest(attributePath, onSuccessCallback, onFailureCallback, + BasicAttributeFilter); +} + +CHIP_ERROR TestClusterCluster::WriteAttributeNullableFloatDouble(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, double value) +{ + app::WriteClientHandle handle; + ReturnErrorOnFailure( + app::InteractionModelEngine::GetInstance()->NewWriteClient(handle, mDevice->GetInteractionModelDelegate())); + ReturnErrorOnFailure(handle.EncodeAttributeWritePayload( + chip::app::AttributePathParams(mEndpoint, mClusterId, TestCluster::Attributes::NullableFloatDouble::Id), value)); + return mDevice->SendWriteAttributeRequest(std::move(handle), onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::SubscribeAttributeNullableFloatDouble(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval) +{ + chip::app::AttributePathParams attributePath; + attributePath.mEndpointId = mEndpoint; + attributePath.mClusterId = mClusterId; + attributePath.mAttributeId = TestCluster::Attributes::NullableFloatDouble::Id; + return mDevice->SendSubscribeAttributeRequest(attributePath, minInterval, maxInterval, onSuccessCallback, onFailureCallback); +} + +CHIP_ERROR TestClusterCluster::ReportAttributeNullableFloatDouble(Callback::Cancelable * onReportCallback) +{ + return RequestAttributeReporting(TestCluster::Attributes::NullableFloatDouble::Id, onReportCallback, + BasicAttributeFilter); +} + CHIP_ERROR TestClusterCluster::ReadAttributeNullableOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback) { diff --git a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h index e0fe847a6bbdb0..a28444391ec309 100644 --- a/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h +++ b/zzz_generated/controller-clusters/zap-generated/CHIPClusters.h @@ -2447,6 +2447,18 @@ class DLL_EXPORT TestClusterCluster : public ClusterBase CHIP_ERROR SubscribeAttributeEnum16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeEnum16(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeFloatSingle(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeFloatSingle(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + float value); + CHIP_ERROR SubscribeAttributeFloatSingle(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeFloatSingle(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeFloatDouble(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeFloatDouble(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + double value); + CHIP_ERROR SubscribeAttributeFloatDouble(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + uint16_t minInterval, uint16_t maxInterval); + CHIP_ERROR ReportAttributeFloatDouble(Callback::Cancelable * onReportCallback); CHIP_ERROR ReadAttributeOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan value); @@ -2677,6 +2689,20 @@ class DLL_EXPORT TestClusterCluster : public ClusterBase CHIP_ERROR SubscribeAttributeNullableEnum16(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, uint16_t minInterval, uint16_t maxInterval); CHIP_ERROR ReportAttributeNullableEnum16(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableFloatSingle(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableFloatSingle(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + float value); + CHIP_ERROR SubscribeAttributeNullableFloatSingle(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval); + CHIP_ERROR ReportAttributeNullableFloatSingle(Callback::Cancelable * onReportCallback); + CHIP_ERROR ReadAttributeNullableFloatDouble(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); + CHIP_ERROR WriteAttributeNullableFloatDouble(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, + double value); + CHIP_ERROR SubscribeAttributeNullableFloatDouble(Callback::Cancelable * onSuccessCallback, + Callback::Cancelable * onFailureCallback, uint16_t minInterval, + uint16_t maxInterval); + CHIP_ERROR ReportAttributeNullableFloatDouble(Callback::Cancelable * onReportCallback); CHIP_ERROR ReadAttributeNullableOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback); CHIP_ERROR WriteAttributeNullableOctetString(Callback::Cancelable * onSuccessCallback, Callback::Cancelable * onFailureCallback, chip::ByteSpan value);