diff --git a/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter b/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter index cdfba66a341c61..9e8b67630fb2a9 100644 --- a/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter +++ b/examples/all-clusters-app/all-clusters-common/all-clusters-app.matter @@ -2957,7 +2957,7 @@ server cluster TestCluster = 1295 { attribute int8s rangeRestrictedInt8s = 39; attribute int16u rangeRestrictedInt16u = 40; attribute int16s rangeRestrictedInt16s = 41; - readonly attribute LONG_OCTET_STRING listLongOctetString[] = 42; + attribute LONG_OCTET_STRING listLongOctetString[] = 42; readonly attribute TestFabricScoped listFabricScoped[] = 43; attribute boolean timedWriteBoolean = 48; attribute boolean generalErrorBoolean = 49; diff --git a/examples/chip-tool/commands/clusters/WriteAttributeCommand.h b/examples/chip-tool/commands/clusters/WriteAttributeCommand.h index 2caef6af6be0df..120d44cd775d6c 100644 --- a/examples/chip-tool/commands/clusters/WriteAttributeCommand.h +++ b/examples/chip-tool/commands/clusters/WriteAttributeCommand.h @@ -58,7 +58,7 @@ class WriteAttribute : public ModelCommand, public chip::app::WriteClient::Callb } /////////// WriteClient Callback Interface ///////// - void OnResponse(const chip::app::WriteClient * client, const chip::app::ConcreteAttributePath & path, + void OnResponse(const chip::app::WriteClient * client, const chip::app::ConcreteDataAttributePath & path, chip::app::StatusIB status) override { CHIP_ERROR error = status.ToChipError(); @@ -98,7 +98,7 @@ class WriteAttribute : public ModelCommand, public chip::app::WriteClient::Callb mWriteClient = std::make_unique(device->GetExchangeManager(), this, mTimedInteractionTimeoutMs); - ReturnErrorOnFailure(mWriteClient->EncodeAttributeWritePayload(attributePathParams, value)); + ReturnErrorOnFailure(mWriteClient->EncodeAttribute(attributePathParams, value)); return mWriteClient->SendWriteRequest(device->GetSecureSession().Value()); } diff --git a/src/app/AttributeAccessToken.h b/src/app/AttributeAccessToken.h new file mode 100644 index 00000000000000..f1cd49d9c29d9c --- /dev/null +++ b/src/app/AttributeAccessToken.h @@ -0,0 +1,45 @@ +/* + * + * Copyright (c) 2022 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include +#include + +namespace chip { +namespace app { + +/** + * AttributeAccessToken records the privilege granted for accessing the specified attribute. This struct is used in chunked write + * to avoid losing privilege when updating ACL items. + */ +struct AttributeAccessToken +{ + ConcreteAttributePath mPath; + Access::Privilege mPrivilege; + + bool operator==(const AttributeAccessToken & other) const { return mPath == other.mPath && mPrivilege == other.mPrivilege; } + + bool Matches(const ConcreteAttributePath & aPath, const Access::Privilege & aPrivilege) const + { + return mPath == aPath && mPrivilege == aPrivilege; + } +}; + +} // namespace app +} // namespace chip diff --git a/src/app/BUILD.gn b/src/app/BUILD.gn index 6dea88b05224b0..04bc6b105ebd5a 100644 --- a/src/app/BUILD.gn +++ b/src/app/BUILD.gn @@ -48,6 +48,8 @@ static_library("app") { "CASEClientPool.h", "CASESessionManager.cpp", "CASESessionManager.h", + "ChunkedWriteCallback.cpp", + "ChunkedWriteCallback.h", "CommandHandler.cpp", "CommandResponseHelper.h", "CommandSender.cpp", diff --git a/src/app/ChunkedWriteCallback.cpp b/src/app/ChunkedWriteCallback.cpp new file mode 100644 index 00000000000000..af5215627b0b26 --- /dev/null +++ b/src/app/ChunkedWriteCallback.cpp @@ -0,0 +1,91 @@ +/* + * + * Copyright (c) 2022 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +namespace chip { +namespace app { + +void ChunkedWriteCallback::OnResponse(const WriteClient * apWriteClient, const ConcreteDataAttributePath & aPath, StatusIB aStatus) +{ + // We may send a chunked list. To make the behavior consistent whether a list is being chunked or not, + // we merge the write responses for a chunked list here and provide our consumer with a single status response. + if (mLastAttributePath.HasValue()) + { + // This is not the first write response. + if (IsAppendingToLastItem(aPath)) + { + // This is a response on the same path as what we already have stored. Report the first + // failure status we encountered, and ignore subsequent ones. + if (mAttributeStatus.IsSuccess()) + { + mAttributeStatus = aStatus; + } + return; + } + else + { + // This is a response to another attribute write. Report the final result of last attribute write. + callback->OnResponse(apWriteClient, mLastAttributePath.Value(), mAttributeStatus); + } + } + + // This is the first report for a new attribute. We assume it will never be a list item operation. + if (aPath.IsListItemOperation()) + { + aStatus = StatusIB(CHIP_ERROR_INCORRECT_STATE); + } + + mLastAttributePath.SetValue(aPath); + mAttributeStatus = aStatus; + // For the last status in the response, we will call the application callback in OnDone() +} + +void ChunkedWriteCallback::OnError(const WriteClient * apWriteClient, CHIP_ERROR aError) +{ + callback->OnError(apWriteClient, aError); +} + +void ChunkedWriteCallback::OnDone(WriteClient * apWriteClient) +{ + if (mLastAttributePath.HasValue()) + { + // We have a cached status that has yet to be reported to the application so report it now. + // If we failed to receive the response, or we received a malformed response, OnResponse won't be called, + // mLastAttributePath will be Missing() in this case. + callback->OnResponse(apWriteClient, mLastAttributePath.Value(), mAttributeStatus); + } + + callback->OnDone(apWriteClient); +} + +bool ChunkedWriteCallback::IsAppendingToLastItem(const ConcreteDataAttributePath & aPath) +{ + if (!aPath.IsListItemOperation()) + { + return false; + } + if (!mLastAttributePath.HasValue() || !(mLastAttributePath.Value() == aPath)) + { + return false; + } + return aPath.mListOp == ConcreteDataAttributePath::ListOperation::AppendItem; +} + +} // namespace app +} // namespace chip diff --git a/src/app/ChunkedWriteCallback.h b/src/app/ChunkedWriteCallback.h new file mode 100644 index 00000000000000..e652f6d09fe1f2 --- /dev/null +++ b/src/app/ChunkedWriteCallback.h @@ -0,0 +1,55 @@ +/* + * + * Copyright (c) 2022 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include + +namespace chip { +namespace app { + +/* + * This is an adapter that intercepts calls that deliver status codes from the WriteClient and + * selectively "merge"s the status codes for a chunked list write as follows: + * - If the whole list was successfully written, callback->OnResponse will be called with success. + * - If any element in the list was not successfully written, callback->OnResponse will be called with the first error received. + * - callback->OnResponse will always have NotList as mListOp since we have merged the chunked responses. + * The merge logic assumes all list operations are part of list chunking. + */ +class ChunkedWriteCallback : public WriteClient::Callback +{ +public: + ChunkedWriteCallback(WriteClient::Callback * apCallback) : callback(apCallback) {} + + void OnResponse(const WriteClient * apWriteClient, const ConcreteDataAttributePath & aPath, StatusIB status) override; + void OnError(const WriteClient * apWriteClient, CHIP_ERROR aError) override; + void OnDone(WriteClient * apWriteClient) override; + +private: + bool IsAppendingToLastItem(const ConcreteDataAttributePath & aPath); + + // We are using the casts between ConcreteAttributePath and ConcreteDataAttributePath, then all paths passed to upper + // applications will always have NotList as mListOp. + Optional mLastAttributePath; + StatusIB mAttributeStatus; + + WriteClient::Callback * callback; +}; + +} // namespace app +} // namespace chip diff --git a/src/app/InteractionModelEngine.h b/src/app/InteractionModelEngine.h index c6b916fd8ba07b..78b936b45e8b01 100644 --- a/src/app/InteractionModelEngine.h +++ b/src/app/InteractionModelEngine.h @@ -337,7 +337,8 @@ CHIP_ERROR ReadSingleClusterData(const Access::SubjectDescriptor & aSubjectDescr /** * TODO: Document. */ -CHIP_ERROR WriteSingleClusterData(const Access::SubjectDescriptor & aSubjectDescriptor, ClusterInfo & aClusterInfo, - TLV::TLVReader & aReader, WriteHandler * apWriteHandler); +CHIP_ERROR WriteSingleClusterData(const Access::SubjectDescriptor & aSubjectDescriptor, + const ConcreteDataAttributePath & aAttributePath, TLV::TLVReader & aReader, + WriteHandler * apWriteHandler); } // namespace app } // namespace chip diff --git a/src/app/MessageDef/AttributePathIB.cpp b/src/app/MessageDef/AttributePathIB.cpp index a1f1835de6e323..6ccf2af371fa6b 100644 --- a/src/app/MessageDef/AttributePathIB.cpp +++ b/src/app/MessageDef/AttributePathIB.cpp @@ -198,6 +198,33 @@ CHIP_ERROR AttributePathIB::Parser::GetListIndex(DataModel::Nullable return GetNullableUnsignedInteger(to_underlying(Tag::kListIndex), apListIndex); } +CHIP_ERROR AttributePathIB::Parser::GetListIndex(ConcreteDataAttributePath & aAttributePath) const +{ + CHIP_ERROR err = CHIP_NO_ERROR; + DataModel::Nullable listIndex; + err = GetListIndex(&(listIndex)); + if (err == CHIP_NO_ERROR) + { + if (listIndex.IsNull()) + { + aAttributePath.mListOp = ConcreteDataAttributePath::ListOperation::AppendItem; + } + else + { + // TODO: Add ListOperation::ReplaceItem support. (Attribute path with valid list index) + err = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH; + } + } + else if (CHIP_END_OF_TLV == err) + { + // We do not have the context for the actual data type here. We always set the list operation to not list and the users + // should interpret it as ReplaceAll when the attribute type is a list. + aAttributePath.mListOp = ConcreteDataAttributePath::ListOperation::NotList; + err = CHIP_NO_ERROR; + } + return err; +} + AttributePathIB::Builder & AttributePathIB::Builder::EnableTagCompression(const bool aEnableTagCompression) { // skip if error has already been set @@ -300,5 +327,29 @@ CHIP_ERROR AttributePathIB::Builder::Encode(const AttributePathParams & aAttribu return GetError(); } +CHIP_ERROR AttributePathIB::Builder::Encode(const ConcreteDataAttributePath & aAttributePath) +{ + Endpoint(aAttributePath.mEndpointId); + Cluster(aAttributePath.mClusterId); + Attribute(aAttributePath.mAttributeId); + + if (!aAttributePath.IsListOperation() || aAttributePath.mListOp == ConcreteDataAttributePath::ListOperation::ReplaceAll) + { + /* noop */ + } + else if (aAttributePath.mListOp == ConcreteDataAttributePath::ListOperation::AppendItem) + { + ListIndex(DataModel::NullNullable); + } + else + { + // TODO: Add ListOperation::ReplaceItem support. (Attribute path with valid list index) + return CHIP_ERROR_INVALID_ARGUMENT; + } + + EndOfAttributePathIB(); + return GetError(); +} + } // namespace app } // namespace chip diff --git a/src/app/MessageDef/AttributePathIB.h b/src/app/MessageDef/AttributePathIB.h index b7a0d7e32ca65c..a7df656b57d566 100644 --- a/src/app/MessageDef/AttributePathIB.h +++ b/src/app/MessageDef/AttributePathIB.h @@ -139,6 +139,18 @@ class Parser : public ListParser * #CHIP_END_OF_TLV if there is no such element */ CHIP_ERROR GetListIndex(DataModel::Nullable * const apListIndex) const; + + /** + * @brief Get the ListIndex, and set the mListIndex and mListOp fields in the ConcreteDataAttributePath accordingly. It will set + * ListOp to NotList when the list index is missing, users should interpret it as ReplaceAll according to the context. + * + * @param [in] aAttributePath The attribute path object for setting list index and list op. + * + * @return #CHIP_NO_ERROR on success + */ + CHIP_ERROR GetListIndex(ConcreteDataAttributePath & aAttributePath) const; + + // TODO(#14934) Add a function to get ConcreteDataAttributePath from AttributePathIB::Parser directly. }; class Builder : public ListBuilder @@ -209,6 +221,7 @@ class Builder : public ListBuilder AttributePathIB::Builder & EndOfAttributePathIB(); CHIP_ERROR Encode(const AttributePathParams & aAttributePathParams); + CHIP_ERROR Encode(const ConcreteDataAttributePath & aAttributePathParams); }; } // namespace AttributePathIB } // namespace app diff --git a/src/app/MessageDef/WriteRequestMessage.cpp b/src/app/MessageDef/WriteRequestMessage.cpp index de08b814c0251b..10521b715f6841 100644 --- a/src/app/MessageDef/WriteRequestMessage.cpp +++ b/src/app/MessageDef/WriteRequestMessage.cpp @@ -125,8 +125,7 @@ CHIP_ERROR WriteRequestMessage::Parser::CheckSchemaValidity() const if (CHIP_END_OF_TLV == err) { - const int RequiredFields = (1 << to_underlying(Tag::kIsFabricFiltered)) | (1 << to_underlying(Tag::kTimedRequest)) | - (1 << to_underlying(Tag::kWriteRequests)); + const int RequiredFields = ((1 << to_underlying(Tag::kTimedRequest)) | (1 << to_underlying(Tag::kWriteRequests))); if ((tagPresenceMask & RequiredFields) == RequiredFields) { diff --git a/src/app/ReadClient.cpp b/src/app/ReadClient.cpp index c46cba6ee232c8..7c0047b9cad3ac 100644 --- a/src/app/ReadClient.cpp +++ b/src/app/ReadClient.cpp @@ -533,22 +533,7 @@ CHIP_ERROR ReadClient::ProcessAttributePath(AttributePathIB::Parser & aAttribute VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH); err = aAttributePathParser.GetAttribute(&(aAttributePath.mAttributeId)); VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH); - - DataModel::Nullable listIndex; - err = aAttributePathParser.GetListIndex(&(listIndex)); - if (CHIP_END_OF_TLV == err) - { - err = CHIP_NO_ERROR; - } - else if (listIndex.IsNull()) - { - aAttributePath.mListOp = ConcreteDataAttributePath::ListOperation::AppendItem; - } - else - { - // TODO: Add ListOperation::ReplaceItem support. (Attribute path with valid list index) - err = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH; - } + err = aAttributePathParser.GetListIndex(aAttributePath); VerifyOrReturnError(err == CHIP_NO_ERROR, CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH); return CHIP_NO_ERROR; } diff --git a/src/app/WriteClient.cpp b/src/app/WriteClient.cpp index 90991841ef8c83..2ecc1ec2c3bf5e 100644 --- a/src/app/WriteClient.cpp +++ b/src/app/WriteClient.cpp @@ -31,28 +31,6 @@ namespace chip { namespace app { -CHIP_ERROR WriteClient::Init() -{ - VerifyOrReturnError(mState == State::Uninitialized, CHIP_ERROR_INCORRECT_STATE); - VerifyOrReturnError(mpExchangeMgr != nullptr, CHIP_ERROR_INCORRECT_STATE); - VerifyOrReturnError(mpExchangeCtx == nullptr, CHIP_ERROR_INCORRECT_STATE); - - System::PacketBufferHandle packet = System::PacketBufferHandle::New(chip::app::kMaxSecureSduLengthBytes); - VerifyOrReturnError(!packet.IsNull(), CHIP_ERROR_NO_MEMORY); - - mMessageWriter.Init(std::move(packet)); - - ReturnErrorOnFailure(mWriteRequestBuilder.Init(&mMessageWriter)); - mWriteRequestBuilder.TimedRequest(mTimedWriteTimeoutMs.HasValue()); - ReturnErrorOnFailure(mWriteRequestBuilder.GetError()); - mWriteRequestBuilder.CreateWriteRequests(); - ReturnErrorOnFailure(mWriteRequestBuilder.GetError()); - - MoveToState(State::Initialized); - - return CHIP_NO_ERROR; -} - void WriteClient::Close() { MoveToState(State::AwaitingDestruction); @@ -144,13 +122,8 @@ CHIP_ERROR WriteClient::ProcessWriteResponseMessage(System::PacketBufferHandle & return err; } -CHIP_ERROR WriteClient::PrepareAttribute(const AttributePathParams & attributePathParams) +CHIP_ERROR WriteClient::PrepareAttributeIB(const ConcreteDataAttributePath & aPath) { - if (mState == State::Uninitialized) - { - ReturnErrorOnFailure(Init()); - } - VerifyOrReturnError(attributePathParams.IsValidAttributePath(), CHIP_ERROR_INVALID_PATH_LIST); AttributeDataIBs::Builder & writeRequests = mWriteRequestBuilder.GetWriteRequests(); AttributeDataIB::Builder & attributeDataIB = writeRequests.CreateAttributeDataIBBuilder(); ReturnErrorOnFailure(writeRequests.GetError()); @@ -158,11 +131,32 @@ CHIP_ERROR WriteClient::PrepareAttribute(const AttributePathParams & attributePa attributeDataIB.DataVersion(0); ReturnErrorOnFailure(attributeDataIB.GetError()); AttributePathIB::Builder & path = attributeDataIB.CreatePath(); - ReturnErrorOnFailure(path.Encode(attributePathParams)); + + // We are using kInvalidEndpointId just for group write requests. This is not the correct use of ConcreteDataAttributePath. + // TODO: update AttributePathParams or ConcreteDataAttributePath for a class supports both nullable list index and missing + // endpoint id. + if (aPath.mEndpointId != kInvalidEndpointId) + { + path.Endpoint(aPath.mEndpointId); + } + path.Cluster(aPath.mClusterId).Attribute(aPath.mAttributeId); + if (aPath.IsListItemOperation()) + { + if (aPath.mListOp == ConcreteDataAttributePath::ListOperation::AppendItem) + { + path.ListIndex(DataModel::NullNullable); + } + else + { + // We do not support other list operations (i.e. update, delete etc) for now. + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; + } + } + ReturnErrorOnFailure(path.EndOfAttributePathIB().GetError()); return CHIP_NO_ERROR; } -CHIP_ERROR WriteClient::FinishAttribute() +CHIP_ERROR WriteClient::FinishAttributeIB() { AttributeDataIB::Builder & attributeDataIB = mWriteRequestBuilder.GetWriteRequests().GetAttributeDataIBBuilder(); attributeDataIB.EndOfAttributeDataIB(); @@ -176,26 +170,164 @@ TLV::TLVWriter * WriteClient::GetAttributeDataIBTLVWriter() return mWriteRequestBuilder.GetWriteRequests().GetAttributeDataIBBuilder().GetWriter(); } -CHIP_ERROR WriteClient::FinalizeMessage(System::PacketBufferHandle & aPacket) +CHIP_ERROR WriteClient::FinalizeMessage(bool aHasMoreChunks) { + System::PacketBufferHandle packet; VerifyOrReturnError(mState == State::AddAttribute, CHIP_ERROR_INCORRECT_STATE); + + TLV::TLVWriter * writer = mWriteRequestBuilder.GetWriter(); + ReturnErrorCodeIf(writer == nullptr, CHIP_ERROR_INCORRECT_STATE); + ReturnErrorOnFailure(writer->UnreserveBuffer(kReservedSizeForTLVEncodingOverhead)); + AttributeDataIBs::Builder & attributeDataIBsBuilder = mWriteRequestBuilder.GetWriteRequests().EndOfAttributeDataIBs(); ReturnErrorOnFailure(attributeDataIBsBuilder.GetError()); - mWriteRequestBuilder.IsFabricFiltered(false).EndOfWriteRequestMessage(); + mWriteRequestBuilder.MoreChunkedMessages(aHasMoreChunks).EndOfWriteRequestMessage(); ReturnErrorOnFailure(mWriteRequestBuilder.GetError()); - ReturnErrorOnFailure(mMessageWriter.Finalize(&aPacket)); + ReturnErrorOnFailure(mMessageWriter.Finalize(&packet)); + mChunks.AddToEnd(std::move(packet)); + return CHIP_NO_ERROR; +} + +CHIP_ERROR WriteClient::EnsureMessage() +{ + if (mState != State::AddAttribute) + { + return StartNewMessage(); + } return CHIP_NO_ERROR; } +CHIP_ERROR WriteClient::StartNewMessage() +{ + uint16_t reservedSize = 0; + + if (mState == State::AddAttribute) + { + ReturnErrorOnFailure(FinalizeMessage(true)); + } + + // Do not allow timed request with chunks. + VerifyOrReturnError(!(mTimedWriteTimeoutMs.HasValue() && !mChunks.IsNull()), CHIP_ERROR_NO_MEMORY); + + System::PacketBufferHandle packet = System::PacketBufferHandle::New(kMaxSecureSduLengthBytes); + VerifyOrReturnError(!packet.IsNull(), CHIP_ERROR_NO_MEMORY); + + // Always limit the size of the packet to fit within kMaxSecureSduLengthBytes regardless of the available buffer capacity. + if (packet->AvailableDataLength() > kMaxSecureSduLengthBytes) + { + reservedSize = static_cast(packet->AvailableDataLength() - kMaxSecureSduLengthBytes); + } + + // ... and we need to reserve some extra space for the MIC field. + reservedSize = static_cast(reservedSize + Crypto::CHIP_CRYPTO_AEAD_MIC_LENGTH_BYTES); + + // ... and the overhead for end of AttributeDataIBs (end of container), more chunks flag, end of WriteRequestMessage (another + // end of container). + reservedSize = static_cast(reservedSize + kReservedSizeForTLVEncodingOverhead); + +#if CONFIG_IM_BUILD_FOR_UNIT_TEST + // ... and for unit tests. + reservedSize = static_cast(reservedSize + mReservedSize); +#endif + + mMessageWriter.Init(std::move(packet)); + + ReturnErrorOnFailure(mMessageWriter.ReserveBuffer(reservedSize)); + + ReturnErrorOnFailure(mWriteRequestBuilder.Init(&mMessageWriter)); + mWriteRequestBuilder.TimedRequest(mTimedWriteTimeoutMs.HasValue()); + ReturnErrorOnFailure(mWriteRequestBuilder.GetError()); + mWriteRequestBuilder.CreateWriteRequests(); + ReturnErrorOnFailure(mWriteRequestBuilder.GetError()); + + TLV::TLVWriter * writer = mWriteRequestBuilder.GetWriter(); + VerifyOrReturnError(writer != nullptr, CHIP_ERROR_INCORRECT_STATE); + + return CHIP_NO_ERROR; +} + +CHIP_ERROR WriteClient::TryPutSinglePreencodedAttributeWritePayload(const ConcreteDataAttributePath & attributePath, + const TLV::TLVReader & data) +{ + TLV::TLVReader dataToWrite; + dataToWrite.Init(data); + + TLV::TLVWriter * writer = nullptr; + + ReturnErrorOnFailure(PrepareAttributeIB(attributePath)); + VerifyOrReturnError((writer = GetAttributeDataIBTLVWriter()) != nullptr, CHIP_ERROR_INCORRECT_STATE); + ReturnErrorOnFailure(writer->CopyElement(TLV::ContextTag(to_underlying(AttributeDataIB::Tag::kData)), dataToWrite)); + ReturnErrorOnFailure(FinishAttributeIB()); + return CHIP_NO_ERROR; +} + +CHIP_ERROR WriteClient::PutSinglePreencodedAttributeWritePayload(const chip::app::ConcreteDataAttributePath & attributePath, + const TLV::TLVReader & data) +{ + TLV::TLVWriter backupWriter; + + mWriteRequestBuilder.GetWriteRequests().Checkpoint(backupWriter); + + // First attempt to write this attribute. + CHIP_ERROR err = TryPutSinglePreencodedAttributeWritePayload(attributePath, data); + if (err == CHIP_ERROR_NO_MEMORY || err == CHIP_ERROR_BUFFER_TOO_SMALL) + { + // If it failed with no memory, then we create a new chunk for it. + mWriteRequestBuilder.GetWriteRequests().Rollback(backupWriter); + mWriteRequestBuilder.GetWriteRequests().ResetError(); + ReturnErrorOnFailure(StartNewMessage()); + err = TryPutSinglePreencodedAttributeWritePayload(attributePath, data); + // Since we have created a new chunk for this element, the encode is expected to succeed. + } + return err; +} + +CHIP_ERROR WriteClient::PutPreencodedAttribute(const ConcreteDataAttributePath & attributePath, const TLV::TLVReader & data) +{ + ReturnErrorOnFailure(EnsureMessage()); + + // ListIndex is missing and the data is an array -- we are writing a whole list. + if (!attributePath.IsListOperation() && data.GetType() == TLV::TLVType::kTLVType_Array) + { + TLV::TLVReader dataReader; + TLV::TLVReader valueReader; + CHIP_ERROR err = CHIP_NO_ERROR; + + ConcreteDataAttributePath path = attributePath; + + dataReader.Init(data); + dataReader.OpenContainer(valueReader); + + // Encode an empty list for the chunking protocol. + ReturnErrorOnFailure(EncodeSingleAttributeDataIB(path, DataModel::List())); + + if (err == CHIP_NO_ERROR) + { + path.mListOp = ConcreteDataAttributePath::ListOperation::AppendItem; + while ((err = valueReader.Next()) == CHIP_NO_ERROR) + { + ReturnErrorOnFailure(PutSinglePreencodedAttributeWritePayload(path, valueReader)); + } + } + + if (err == CHIP_END_OF_TLV) + { + err = CHIP_NO_ERROR; + } + return err; + } + else // We are writing a non-list attribute, or we are writing a single element of a list. + { + return PutSinglePreencodedAttributeWritePayload(attributePath, data); + } +} + const char * WriteClient::GetStateStr() const { #if CHIP_DETAIL_LOGGING switch (mState) { - case State::Uninitialized: - return "Uninitialized"; - case State::Initialized: return "Initialized"; @@ -224,18 +356,13 @@ void WriteClient::MoveToState(const State aTargetState) ChipLogDetail(DataManagement, "WriteClient moving to [%10.10s]", GetStateStr()); } -void WriteClient::ClearState() -{ - MoveToState(State::Uninitialized); -} - CHIP_ERROR WriteClient::SendWriteRequest(const SessionHandle & session, System::Clock::Timeout timeout) { CHIP_ERROR err = CHIP_NO_ERROR; VerifyOrExit(mState == State::AddAttribute, err = CHIP_ERROR_INCORRECT_STATE); - err = FinalizeMessage(mPendingWriteData); + err = FinalizeMessage(false /* hasMoreChunks */); SuccessOrExit(err); // Create a new exchange context. @@ -288,9 +415,17 @@ CHIP_ERROR WriteClient::SendWriteRequest() using namespace Protocols::InteractionModel; using namespace Messaging; + System::PacketBufferHandle data = mChunks.PopHead(); + + if (!mChunks.IsNull() && mpExchangeCtx->IsGroupExchangeContext()) + { + // Reject this request if we have more than one chunk (mChunks is not null after PopHead()), and this is a group + // exchange context. + return CHIP_ERROR_INCORRECT_STATE; + } + // kExpectResponse is ignored by ExchangeContext in case of groupcast - ReturnErrorOnFailure( - mpExchangeCtx->SendMessage(MsgType::WriteRequest, std::move(mPendingWriteData), SendMessageFlags::kExpectResponse)); + ReturnErrorOnFailure(mpExchangeCtx->SendMessage(MsgType::WriteRequest, std::move(data), SendMessageFlags::kExpectResponse)); MoveToState(State::AwaitingResponse); return CHIP_NO_ERROR; } @@ -298,7 +433,9 @@ CHIP_ERROR WriteClient::SendWriteRequest() CHIP_ERROR WriteClient::OnMessageReceived(Messaging::ExchangeContext * apExchangeContext, const PayloadHeader & aPayloadHeader, System::PacketBufferHandle && aPayload) { - if (mState == State::AwaitingResponse) + if (mState == State::AwaitingResponse && + // We had sent the last chunk of data, and received all responses + mChunks.IsNull()) { MoveToState(State::ResponseReceived); } @@ -322,6 +459,11 @@ CHIP_ERROR WriteClient::OnMessageReceived(Messaging::ExchangeContext * apExchang { err = ProcessWriteResponseMessage(std::move(aPayload)); SuccessOrExit(err); + if (!mChunks.IsNull()) + { + // Send the next chunk. + SuccessOrExit(SendWriteRequest()); + } } else if (aPayloadHeader.HasMessageType(Protocols::InteractionModel::MsgType::StatusResponse)) { @@ -366,28 +508,22 @@ void WriteClient::OnResponseTimeout(Messaging::ExchangeContext * apExchangeConte CHIP_ERROR WriteClient::ProcessAttributeStatusIB(AttributeStatusIB::Parser & aAttributeStatusIB) { CHIP_ERROR err = CHIP_NO_ERROR; - AttributePathIB::Parser attributePath; + AttributePathIB::Parser attributePathParser; StatusIB statusIB; StatusIB::Parser StatusIBParser; - AttributePathParams attributePathParams; + ConcreteDataAttributePath attributePath; - err = aAttributeStatusIB.GetPath(&attributePath); + err = aAttributeStatusIB.GetPath(&attributePathParser); SuccessOrExit(err); - err = attributePath.GetCluster(&(attributePathParams.mClusterId)); + + err = attributePathParser.GetCluster(&(attributePath.mClusterId)); SuccessOrExit(err); - err = attributePath.GetEndpoint(&(attributePathParams.mEndpointId)); + err = attributePathParser.GetEndpoint(&(attributePath.mEndpointId)); SuccessOrExit(err); - err = attributePath.GetAttribute(&(attributePathParams.mAttributeId)); + err = attributePathParser.GetAttribute(&(attributePath.mAttributeId)); + SuccessOrExit(err); + err = attributePathParser.GetListIndex(attributePath); SuccessOrExit(err); - err = attributePath.GetListIndex(&(attributePathParams.mListIndex)); - if (err == CHIP_END_OF_TLV) - { - err = CHIP_NO_ERROR; - } - // TODO: (#11423) Attribute paths has a pattern of invalid paths, should add a function for checking invalid paths here. - // NOTE: We don't support wildcard write for now, reject all wildcard paths. - VerifyOrExit(!attributePathParams.HasAttributeWildcard() && attributePathParams.IsValidAttributePath(), - err = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH); err = aAttributeStatusIB.GetErrorStatus(&(StatusIBParser)); if (CHIP_NO_ERROR == err) @@ -396,9 +532,7 @@ CHIP_ERROR WriteClient::ProcessAttributeStatusIB(AttributeStatusIB::Parser & aAt SuccessOrExit(err); if (mpCallback != nullptr) { - ConcreteAttributePath path(attributePathParams.mEndpointId, attributePathParams.mClusterId, - attributePathParams.mAttributeId); - mpCallback->OnResponse(this, path, statusIB); + mpCallback->OnResponse(this, attributePath, statusIB); } } diff --git a/src/app/WriteClient.h b/src/app/WriteClient.h index 7e26402fa445b8..19839c877e633f 100644 --- a/src/app/WriteClient.h +++ b/src/app/WriteClient.h @@ -20,6 +20,7 @@ #include #include +#include #include #include #include @@ -49,6 +50,10 @@ class InteractionModelEngine; * Consumer can allocate one write client, then call PrepareAttribute, insert attribute value, followed by FinishAttribute for * every attribute it wants to insert in write request, then call SendWriteRequest * + * Note: When writing lists, you may receive multiple write status responses for a single list. + * Please see ChunkedWriteCallback.h for a high level API which will merge status codes for + * chunked write requests. + * */ class WriteClient : public Messaging::ExchangeDelegate { @@ -70,7 +75,9 @@ class WriteClient : public Messaging::ExchangeDelegate * @param[in] attributeStatus Attribute-specific status, containing an InteractionModel::Status code as well as * an optional cluster-specific status code. */ - virtual void OnResponse(const WriteClient * apWriteClient, const ConcreteAttributePath & aPath, StatusIB attributeStatus) {} + virtual void OnResponse(const WriteClient * apWriteClient, const ConcreteDataAttributePath & aPath, + StatusIB attributeStatus) + {} /** * OnError will be called when an error occurs *after* a successful call to SendWriteRequest(). The following @@ -119,23 +126,86 @@ class WriteClient : public Messaging::ExchangeDelegate mpCallback(apCallback), mTimedWriteTimeoutMs(aTimedWriteTimeoutMs) {} +#if CONFIG_IM_BUILD_FOR_UNIT_TEST + WriteClient(Messaging::ExchangeManager * apExchangeMgr, Callback * apCallback, const Optional & aTimedWriteTimeoutMs, + uint16_t aReservedSize) : + mpExchangeMgr(apExchangeMgr), + mpCallback(apCallback), mTimedWriteTimeoutMs(aTimedWriteTimeoutMs), mReservedSize(aReservedSize) + {} +#endif + /** - * Encode an attribute value that can be directly encoded using TLVWriter::Put + * Encode an attribute value that can be directly encoded using DataModel::Encode. Will create a new chunk when necessary. */ template - CHIP_ERROR EncodeAttributeWritePayload(const chip::app::AttributePathParams & attributePath, const T & value) + CHIP_ERROR EncodeAttribute(const AttributePathParams & attributePath, const T & value) { - chip::TLV::TLVWriter * writer = nullptr; + ReturnErrorOnFailure(EnsureMessage()); - ReturnErrorOnFailure(PrepareAttribute(attributePath)); - VerifyOrReturnError((writer = GetAttributeDataIBTLVWriter()) != nullptr, CHIP_ERROR_INCORRECT_STATE); - ReturnErrorOnFailure( - DataModel::Encode(*writer, chip::TLV::ContextTag(to_underlying(chip::app::AttributeDataIB::Tag::kData)), value)); - ReturnErrorOnFailure(FinishAttribute()); + // Here, we are using kInvalidEndpointId for missing endpoint id, which is used when sending group write requests. + return EncodeSingleAttributeDataIB( + ConcreteDataAttributePath(attributePath.HasWildcardEndpointId() ? kInvalidEndpointId : attributePath.mEndpointId, + attributePath.mClusterId, attributePath.mAttributeId), + value); + } + + /** + * Encode a possibly-chunked list attribute value. Will create a new chunk when necessary. + */ + template + CHIP_ERROR EncodeAttribute(const AttributePathParams & attributePath, const DataModel::List & value) + { + // Here, we are using kInvalidEndpointId for missing endpoint id, which is used when sending group write requests. + ConcreteDataAttributePath path = + ConcreteDataAttributePath(attributePath.HasWildcardEndpointId() ? kInvalidEndpointId : attributePath.mEndpointId, + attributePath.mClusterId, attributePath.mAttributeId); + + ReturnErrorOnFailure(EnsureMessage()); + + // Encode an empty list for the chunking protocol. + ReturnErrorOnFailure(EncodeSingleAttributeDataIB(path, DataModel::List())); + + path.mListOp = ConcreteDataAttributePath::ListOperation::AppendItem; + for (ListIndex i = 0; i < value.size(); i++) + { + ReturnErrorOnFailure(EncodeSingleAttributeDataIB(path, value.data()[i])); + } return CHIP_NO_ERROR; } + /** + * Encode a Nullable attribute value. This needs a separate overload so it can dispatch to the right + * EncodeAttribute when writing a nullable list. + */ + template + CHIP_ERROR EncodeAttribute(const AttributePathParams & attributePath, const DataModel::Nullable & value) + { + ReturnErrorOnFailure(EnsureMessage()); + + if (value.IsNull()) + { + // Here, we are using kInvalidEndpointId to for missing endpoint id, which is used when sending group write requests. + return EncodeSingleAttributeDataIB( + ConcreteDataAttributePath(attributePath.HasWildcardEndpointId() ? kInvalidEndpointId : attributePath.mEndpointId, + attributePath.mClusterId, attributePath.mAttributeId), + value); + } + else + { + return EncodeAttribute(attributePath, value.Value()); + } + } + + /** + * Encode an attribute value which is already encoded into a TLV. The TLVReader is expected to be initialized and the read head + * is expected to point to the element to be encoded. + * + * Note: When encoding lists with this function, you may receive more than one write status for a single list. You can refer + * to ChunkedWriteCallback.h for a high level API which will merge status codes for chunked write requests. + */ + CHIP_ERROR PutPreencodedAttribute(const ConcreteDataAttributePath & attributePath, const TLV::TLVReader & data); + /** * Once SendWriteRequest returns successfully, the WriteClient will * handle calling Shutdown on itself once it decides it's done with waiting @@ -153,10 +223,6 @@ class WriteClient : public Messaging::ExchangeDelegate */ void Shutdown(); - CHIP_ERROR PrepareAttribute(const AttributePathParams & attributePathParams); - CHIP_ERROR FinishAttribute(); - TLV::TLVWriter * GetAttributeDataIBTLVWriter(); - /* * Destructor - as part of destruction, it will abort the exchange context * if a valid one still exists. @@ -171,8 +237,7 @@ class WriteClient : public Messaging::ExchangeDelegate enum class State { - Uninitialized = 0, // The client has not been initialized - Initialized, // The client has been initialized + Initialized = 0, // The client has been initialized AddAttribute, // The client has added attribute and ready for a SendWriteRequest AwaitingTimedStatus, // Sent a Tiemd Request, waiting for response. AwaitingResponse, // The client has sent out the write request message @@ -180,30 +245,75 @@ class WriteClient : public Messaging::ExchangeDelegate AwaitingDestruction, // The object has completed its work and is awaiting destruction by the application. }; + CHIP_ERROR OnMessageReceived(Messaging::ExchangeContext * apExchangeContext, const PayloadHeader & aPayloadHeader, + System::PacketBufferHandle && aPayload) override; + void OnResponseTimeout(Messaging::ExchangeContext * apExchangeContext) override; + + void MoveToState(const State aTargetState); + CHIP_ERROR ProcessWriteResponseMessage(System::PacketBufferHandle && payload); + CHIP_ERROR ProcessAttributeStatusIB(AttributeStatusIB::Parser & aAttributeStatusIB); + const char * GetStateStr() const; + /** - * The actual init function, called during encoding first attribute data. + * Encode an attribute value that can be directly encoded using DataModel::Encode. */ - CHIP_ERROR Init(); + template + CHIP_ERROR TryEncodeSingleAttributeDataIB(const ConcreteDataAttributePath & attributePath, const T & value) + { + chip::TLV::TLVWriter * writer = nullptr; + + ReturnErrorOnFailure(PrepareAttributeIB(attributePath)); + VerifyOrReturnError((writer = GetAttributeDataIBTLVWriter()) != nullptr, CHIP_ERROR_INCORRECT_STATE); + ReturnErrorOnFailure( + DataModel::Encode(*writer, chip::TLV::ContextTag(to_underlying(chip::app::AttributeDataIB::Tag::kData)), value)); + ReturnErrorOnFailure(FinishAttributeIB()); + + return CHIP_NO_ERROR; + } /** - * Finalize Write Request Message TLV Builder and retrieve final data from tlv builder for later sending + * A wrapper for TryEncodeSingleAttributeDataIB which will start a new chunk when failed with CHIP_ERROR_NO_MEMORY or + * CHIP_ERROR_BUFFER_TOO_SMALL. */ - CHIP_ERROR FinalizeMessage(System::PacketBufferHandle & aPacket); + template + CHIP_ERROR EncodeSingleAttributeDataIB(const ConcreteDataAttributePath & attributePath, const T & value) + { + TLV::TLVWriter backupWriter; - CHIP_ERROR OnMessageReceived(Messaging::ExchangeContext * apExchangeContext, const PayloadHeader & aPayloadHeader, - System::PacketBufferHandle && aPayload) override; - void OnResponseTimeout(Messaging::ExchangeContext * apExchangeContext) override; + mWriteRequestBuilder.GetWriteRequests().Checkpoint(backupWriter); + + // First attempt to write this attribute. + CHIP_ERROR err = TryEncodeSingleAttributeDataIB(attributePath, value); + if (err == CHIP_ERROR_NO_MEMORY || err == CHIP_ERROR_BUFFER_TOO_SMALL) + { + // If it failed with no memory, then we create a new chunk for it. + mWriteRequestBuilder.GetWriteRequests().Rollback(backupWriter); + mWriteRequestBuilder.GetWriteRequests().ResetError(); + ReturnErrorOnFailure(StartNewMessage()); + ReturnErrorOnFailure(TryEncodeSingleAttributeDataIB(attributePath, value)); + } + else + { + ReturnErrorOnFailure(err); + } + + return CHIP_NO_ERROR; + } /** - * Check if current write client is being used + * Encode a preencoded attribute data, returns TLV encode error if the ramaining space of current chunk is too small for the + * AttributeDataIB. */ - bool IsFree() const { return mState == State::Uninitialized; }; + CHIP_ERROR TryPutSinglePreencodedAttributeWritePayload(const ConcreteDataAttributePath & attributePath, + const TLV::TLVReader & data); - void MoveToState(const State aTargetState); - CHIP_ERROR ProcessWriteResponseMessage(System::PacketBufferHandle && payload); - CHIP_ERROR ProcessAttributeStatusIB(AttributeStatusIB::Parser & aAttributeStatusIB); - const char * GetStateStr() const; - void ClearState(); + /** + * Encode a preencoded attribute data, will try to create a new chunk when necessary. + */ + CHIP_ERROR PutSinglePreencodedAttributeWritePayload(const ConcreteDataAttributePath & attributePath, + const TLV::TLVReader & data); + + CHIP_ERROR EnsureMessage(); /** * Called internally to signal the completion of all work on this object, gracefully close the @@ -233,10 +343,27 @@ class WriteClient : public Messaging::ExchangeDelegate // and mPendingWriteData is populated. CHIP_ERROR SendWriteRequest(); + // Encodes the header of an AttributeDataIB, a special case for attributePath is its EndpointId can be kInvalidEndpointId, this + // is used when sending group write requests. + // TODO(#14935) Update AttributePathParams to support more list operations. + CHIP_ERROR PrepareAttributeIB(const ConcreteDataAttributePath & attributePath); + CHIP_ERROR FinishAttributeIB(); + TLV::TLVWriter * GetAttributeDataIBTLVWriter(); + + /** + * Create a new message (or a new chunk) for the write request. + */ + CHIP_ERROR StartNewMessage(); + + /** + * Finalize Write Request Message TLV Builder and retrieve final data from tlv builder for later sending + */ + CHIP_ERROR FinalizeMessage(bool aHasMoreChunks); + Messaging::ExchangeManager * mpExchangeMgr = nullptr; Messaging::ExchangeContext * mpExchangeCtx = nullptr; Callback * mpCallback = nullptr; - State mState = State::Uninitialized; + State mState = State::Initialized; System::PacketBufferTLVWriter mMessageWriter; WriteRequestMessage::Builder mWriteRequestBuilder; // TODO Maybe we should change PacketBufferTLVWriter so we can finalize it @@ -246,6 +373,54 @@ class WriteClient : public Messaging::ExchangeDelegate // If mTimedWriteTimeoutMs has a value, we are expected to do a timed // write. Optional mTimedWriteTimeoutMs; + + // A list of buffers, one buffer for each chunk. + System::PacketBufferHandle mChunks; + + // TODO: This file might be compiled with different build flags on Darwin platform (when building WriteClient.cpp and + // CHIPClustersObjc.mm), which will cause undefined behavior when building write requests. Uncomment the #if and #endif after + // resolving it. + // #if CONFIG_IM_BUILD_FOR_UNIT_TEST + uint16_t mReservedSize = 0; + // #endif + + /** + * Below we define several const variables for encoding overheads. + * WriteRequestMessage = + * { + * timedRequest = false, + * AttributeDataIBs = + * [ + * AttributeDataIB = \ + * { | + * DataVersion = 0x0, | + * AttributePathIB = | + * { | + * Endpoint = 0x2, | "atomically" encoded via + * Cluster = 0x50f, > EncodeAttribute or + * Attribute = 0x0000_0006, | PutPreencodedAttribute + * ListIndex = Null, | + * } | + * Data = ... | + * }, / + * (...) + * ], <-- 1 byte "end of AttributeDataIB" (end of container) + * moreChunkedMessages = false, <-- 2 bytes "kReservedSizeForMoreChunksFlag" + * InteractionModelRevision = 1,<-- 3 bytes "kReservedSizeForIMRevision" + * } <-- 1 byte "end of WriteRequestMessage" (end of container) + */ + + // Reserved size for the MoreChunks boolean flag, which takes up 1 byte for the control tag and 1 byte for the context tag. + static constexpr uint16_t kReservedSizeForMoreChunksFlag = 1 + 1; + // End Of Container (0x18) uses one byte. + static constexpr uint16_t kReservedSizeForEndOfContainer = 1; + // Reserved size for the uint8_t InteractionModelRevision flag, which takes up 1 byte for the control tag and 1 byte for the + // context tag, 1 byte for value + static constexpr uint16_t kReservedSizeForIMRevision = 1 + 1 + 1; + // Reserved buffer for TLV level overhead (the overhead for end of AttributeDataIBs (end of container), more chunks flag, end + // of WriteRequestMessage (another end of container)). + static constexpr uint16_t kReservedSizeForTLVEncodingOverhead = kReservedSizeForIMRevision + kReservedSizeForMoreChunksFlag + + kReservedSizeForEndOfContainer + kReservedSizeForEndOfContainer; }; } // namespace app diff --git a/src/app/WriteHandler.cpp b/src/app/WriteHandler.cpp index 82d9fb55d7f3ce..5aa9908b08aeff 100644 --- a/src/app/WriteHandler.cpp +++ b/src/app/WriteHandler.cpp @@ -20,6 +20,7 @@ #include #include #include +#include #include #include #include @@ -35,17 +36,10 @@ CHIP_ERROR WriteHandler::Init() { VerifyOrReturnError(mpExchangeCtx == nullptr, CHIP_ERROR_INCORRECT_STATE); - System::PacketBufferHandle packet = System::PacketBufferHandle::New(chip::app::kMaxSecureSduLengthBytes); - VerifyOrReturnError(!packet.IsNull(), CHIP_ERROR_NO_MEMORY); - - mMessageWriter.Init(std::move(packet)); - ReturnErrorOnFailure(mWriteResponseBuilder.Init(&mMessageWriter)); - - mWriteResponseBuilder.CreateWriteResponses(); - ReturnErrorOnFailure(mWriteResponseBuilder.GetError()); - MoveToState(State::Initialized); + mACLCheckCache.ClearValue(); + return CHIP_NO_ERROR; } @@ -66,13 +60,6 @@ void WriteHandler::Close() void WriteHandler::Abort() { -#if 0 - // TODO: When chunking gets added, we should add this back. - // - // If the exchange context hasn't already been gracefully closed - // (signaled by setting it to null), then we need to forcibly - // tear it down. - // if (mpExchangeCtx != nullptr) { // We might be a delegate for this exchange, and we don't want the @@ -88,26 +75,19 @@ void WriteHandler::Abort() } ClearState(); -#else - // - // The WriteHandler should get synchronously allocated and destroyed in the same execution - // context given that it's just a 2 message exchange (request + response). Consequently, we should - // never arrive at a situation where we have active handlers at any time Abort() is called. - // - VerifyOrDie(mState == State::Uninitialized); -#endif } -Status WriteHandler::OnWriteRequest(Messaging::ExchangeContext * apExchangeContext, System::PacketBufferHandle && aPayload, - bool aIsTimedWrite) +Status WriteHandler::HandleWriteRequestMessage(Messaging::ExchangeContext * apExchangeContext, + System::PacketBufferHandle && aPayload, bool aIsTimedWrite) { - mpExchangeCtx = apExchangeContext; + System::PacketBufferHandle packet = System::PacketBufferHandle::New(chip::app::kMaxSecureSduLengthBytes); + VerifyOrReturnError(!packet.IsNull(), Status::Failure); - // - // Let's take over further message processing on this exchange from the IM. - // This is only relevant during chunked requests. - // - mpExchangeCtx->SetDelegate(this); + mMessageWriter.Init(std::move(packet)); + VerifyOrReturnError(mWriteResponseBuilder.Init(&mMessageWriter) == CHIP_NO_ERROR, Status::Failure); + + mWriteResponseBuilder.CreateWriteResponses(); + VerifyOrReturnError(mWriteResponseBuilder.GetError() == CHIP_NO_ERROR, Status::Failure); Status status = ProcessWriteRequest(std::move(aPayload), aIsTimedWrite); @@ -121,35 +101,70 @@ Status WriteHandler::OnWriteRequest(Messaging::ExchangeContext * apExchangeConte } } - Close(); return status; } -CHIP_ERROR WriteHandler::OnMessageReceived(Messaging::ExchangeContext * apExchangeContext, const PayloadHeader & aPayloadHeader, - System::PacketBufferHandle && aPayload) +Status WriteHandler::OnWriteRequest(Messaging::ExchangeContext * apExchangeContext, System::PacketBufferHandle && aPayload, + bool aIsTimedWrite) { + mpExchangeCtx = apExchangeContext; + // - // As part of write handling, the exchange should get closed sychronously given there is always - // just a single response to a Write Request message before the exchange gets closed. There-after, - // even if we get any more messages on that exchange from a non-compliant client, our exchange layer - // should correctly discard those. If there is a bug there, this function here may get invoked. - // - // NOTE: Once chunking gets implemented, this will no longer be true. + // Let's take over further message processing on this exchange from the IM. + // This is only relevant during chunked requests. // - VerifyOrDieWithMsg(false, DataManagement, "This function should never get invoked"); + mpExchangeCtx->SetDelegate(this); + + Status status = HandleWriteRequestMessage(apExchangeContext, std::move(aPayload), aIsTimedWrite); + + // The write transaction will be alive only when the message was handled successfully and there are more chunks. + if (!(status == Status::Success && mHasMoreChunks)) + { + Close(); + } + + return status; +} + +CHIP_ERROR WriteHandler::OnMessageReceived(Messaging::ExchangeContext * apExchangeContext, const PayloadHeader & aPayloadHeader, + System::PacketBufferHandle && aPayload) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + + VerifyOrDieWithMsg(apExchangeContext == mpExchangeCtx, DataManagement, + "Incoming exchange context should be same as the initial request."); + VerifyOrDieWithMsg(!apExchangeContext->IsGroupExchangeContext(), DataManagement, + "OnMessageReceived should not be called on GroupExchangeContext"); + if (!aPayloadHeader.HasMessageType(Protocols::InteractionModel::MsgType::WriteRequest)) + { + ChipLogDetail(DataManagement, "Unexpected message type %d", aPayloadHeader.GetMessageType()); + Close(); + return CHIP_ERROR_INVALID_MESSAGE_TYPE; + } + + Status status = + HandleWriteRequestMessage(apExchangeContext, std::move(aPayload), false /* chunked write should not be timed write */); + if (status == Status::Success) + { + // We have no more chunks, the write response has been sent in HandleWriteRequestMessage, so close directly. + if (!mHasMoreChunks) + { + Close(); + } + } + else if (status != Protocols::InteractionModel::Status::Success) + { + err = StatusResponse::Send(status, apExchangeContext, false /*aExpectResponse*/); + Close(); + } + return CHIP_NO_ERROR; } void WriteHandler::OnResponseTimeout(Messaging::ExchangeContext * apExchangeContext) { - // - // As part of write handling, the exchange should get closed sychronously given there is always - // just a single response to a Write Request message before the exchange gets closed. That response - // does not solicit any further responses back. Consequently, we never expect to get notified - // of any response timeouts. - // - // NOTE: Once chunking gets implemented, this will no longer be true. - // - VerifyOrDieWithMsg(false, DataManagement, "This function should never get invoked"); + ChipLogProgress(DataManagement, "Time out! failed to receive status response from Exchange: " ChipLogFormatExchange, + ChipLogValueExchange(apExchangeContext)); + Close(); } CHIP_ERROR WriteHandler::FinalizeMessage(System::PacketBufferHandle & packet) @@ -174,7 +189,9 @@ CHIP_ERROR WriteHandler::SendWriteResponse() SuccessOrExit(err); VerifyOrExit(mpExchangeCtx != nullptr, err = CHIP_ERROR_INCORRECT_STATE); - err = mpExchangeCtx->SendMessage(Protocols::InteractionModel::MsgType::WriteResponse, std::move(packet)); + err = mpExchangeCtx->SendMessage(Protocols::InteractionModel::MsgType::WriteResponse, std::move(packet), + mHasMoreChunks ? Messaging::SendMessageFlags::kExpectResponse + : Messaging::SendMessageFlags::kNone); SuccessOrExit(err); MoveToState(State::Sending); @@ -195,7 +212,7 @@ CHIP_ERROR WriteHandler::ProcessAttributeDataIBs(TLV::TLVReader & aAttributeData chip::TLV::TLVReader dataReader; AttributeDataIB::Parser element; AttributePathIB::Parser attributePath; - ClusterInfo clusterInfo; + ConcreteDataAttributePath dataAttributePath; TLV::TLVReader reader = aAttributeDataIBsReader; err = element.Init(reader); @@ -207,47 +224,37 @@ CHIP_ERROR WriteHandler::ProcessAttributeDataIBs(TLV::TLVReader & aAttributeData // We are using the feature that the parser won't touch the value if the field does not exist, since all fields in the // cluster info will be invalid / wildcard, it is safe ignore CHIP_END_OF_TLV directly. - err = attributePath.GetNode(&(clusterInfo.mNodeId)); - if (CHIP_END_OF_TLV == err) - { - err = CHIP_NO_ERROR; - } - - err = attributePath.GetEndpoint(&(clusterInfo.mEndpointId)); + err = attributePath.GetEndpoint(&(dataAttributePath.mEndpointId)); SuccessOrExit(err); - err = attributePath.GetCluster(&(clusterInfo.mClusterId)); + err = attributePath.GetCluster(&(dataAttributePath.mClusterId)); SuccessOrExit(err); - err = attributePath.GetAttribute(&(clusterInfo.mAttributeId)); + err = attributePath.GetAttribute(&(dataAttributePath.mAttributeId)); SuccessOrExit(err); - err = attributePath.GetListIndex(&(clusterInfo.mListIndex)); - if (CHIP_END_OF_TLV == err) - { - err = CHIP_NO_ERROR; - } - - // We do not support Wildcard writes for now, reject all wildcard write requests. - VerifyOrExit(clusterInfo.IsValidAttributePath() && !clusterInfo.HasAttributeWildcard(), - err = CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH); + err = attributePath.GetListIndex(dataAttributePath); + SuccessOrExit(err); err = element.GetData(&dataReader); SuccessOrExit(err); + if (!dataAttributePath.IsListOperation() && dataReader.GetType() == TLV::TLVType::kTLVType_Array) { - const ConcreteAttributePath concretePath = - ConcreteAttributePath(clusterInfo.mEndpointId, clusterInfo.mClusterId, clusterInfo.mAttributeId); - MatterPreAttributeWriteCallback(concretePath); + dataAttributePath.mListOp = ConcreteDataAttributePath::ListOperation::ReplaceAll; + } + + { + MatterPreAttributeWriteCallback(dataAttributePath); TLV::TLVWriter backup; mWriteResponseBuilder.Checkpoint(backup); - err = WriteSingleClusterData(subjectDescriptor, clusterInfo, dataReader, this); + err = WriteSingleClusterData(subjectDescriptor, dataAttributePath, dataReader, this); if (err != CHIP_NO_ERROR) { mWriteResponseBuilder.Rollback(backup); - err = AddStatus(concretePath, StatusIB(err)); + err = AddStatus(dataAttributePath, StatusIB(err)); } - MatterPostAttributeWriteCallback(concretePath); + MatterPostAttributeWriteCallback(dataAttributePath); } SuccessOrExit(err); } @@ -273,7 +280,7 @@ CHIP_ERROR WriteHandler::ProcessGroupAttributeDataIBs(TLV::TLVReader & aAttribut chip::TLV::TLVReader dataReader; AttributeDataIB::Parser element; AttributePathIB::Parser attributePath; - ClusterInfo clusterInfo; + ConcreteDataAttributePath dataAttributePath; GroupId groupId; FabricIndex fabric; TLV::TLVReader reader = aAttributeDataIBsReader; @@ -291,34 +298,25 @@ CHIP_ERROR WriteHandler::ProcessGroupAttributeDataIBs(TLV::TLVReader & aAttribut // We are using the feature that the parser won't touch the value if the field does not exist, since all fields in the // cluster info will be invalid / wildcard, it is safe to ignore CHIP_END_OF_TLV. - err = attributePath.GetNode(&(clusterInfo.mNodeId)); - if (CHIP_END_OF_TLV == err) - { - err = CHIP_NO_ERROR; - } + err = attributePath.GetCluster(&(dataAttributePath.mClusterId)); + SuccessOrExit(err); - err = attributePath.GetCluster(&(clusterInfo.mClusterId)); + err = attributePath.GetAttribute(&(dataAttributePath.mAttributeId)); SuccessOrExit(err); - err = attributePath.GetAttribute(&(clusterInfo.mAttributeId)); + err = attributePath.GetListIndex(dataAttributePath); SuccessOrExit(err); groupId = mpExchangeCtx->GetSessionHandle()->AsGroupSession()->GetGroupId(); fabric = GetAccessingFabricIndex(); - err = attributePath.GetListIndex(&(clusterInfo.mListIndex)); - if (CHIP_END_OF_TLV == err) - { - err = CHIP_NO_ERROR; - } - err = element.GetData(&dataReader); SuccessOrExit(err); ChipLogDetail(DataManagement, "Received group attribute write for Group=%" PRIu16 " Cluster=" ChipLogFormatMEI " attribute=" ChipLogFormatMEI, - groupId, ChipLogValueMEI(clusterInfo.mClusterId), ChipLogValueMEI(clusterInfo.mAttributeId)); + groupId, ChipLogValueMEI(dataAttributePath.mClusterId), ChipLogValueMEI(dataAttributePath.mAttributeId)); iterator = groupDataProvider->IterateEndpoints(fabric); VerifyOrExit(iterator != nullptr, err = CHIP_ERROR_NO_MEMORY); @@ -330,40 +328,28 @@ CHIP_ERROR WriteHandler::ProcessGroupAttributeDataIBs(TLV::TLVReader & aAttribut continue; } - clusterInfo.mEndpointId = mapping.endpoint_id; - - if (!clusterInfo.IsValidAttributePath() || clusterInfo.HasAttributeWildcard()) - { - ChipLogDetail(DataManagement, - "Invalid group attribute write for endpoint=%" PRIu16 " Cluster=" ChipLogFormatMEI - " attribute=" ChipLogFormatMEI, - mapping.endpoint_id, ChipLogValueMEI(clusterInfo.mClusterId), - ChipLogValueMEI(clusterInfo.mAttributeId)); - - continue; - } + dataAttributePath.mEndpointId = mapping.endpoint_id; ChipLogDetail(DataManagement, "Processing group attribute write for endpoint=%" PRIu16 " Cluster=" ChipLogFormatMEI " attribute=" ChipLogFormatMEI, - mapping.endpoint_id, ChipLogValueMEI(clusterInfo.mClusterId), ChipLogValueMEI(clusterInfo.mAttributeId)); + mapping.endpoint_id, ChipLogValueMEI(dataAttributePath.mClusterId), + ChipLogValueMEI(dataAttributePath.mAttributeId)); chip::TLV::TLVReader tmpDataReader(dataReader); - const ConcreteAttributePath concretePath(clusterInfo.mEndpointId, clusterInfo.mClusterId, clusterInfo.mAttributeId); - - MatterPreAttributeWriteCallback(concretePath); - err = WriteSingleClusterData(subjectDescriptor, clusterInfo, tmpDataReader, this); + MatterPreAttributeWriteCallback(dataAttributePath); + err = WriteSingleClusterData(subjectDescriptor, dataAttributePath, tmpDataReader, this); if (err != CHIP_NO_ERROR) { ChipLogError(DataManagement, "Error when calling WriteSingleClusterData for Endpoint=%" PRIu16 " Cluster=" ChipLogFormatMEI " Attribute =" ChipLogFormatMEI " : %" CHIP_ERROR_FORMAT, - mapping.endpoint_id, ChipLogValueMEI(clusterInfo.mClusterId), - ChipLogValueMEI(clusterInfo.mAttributeId), err.Format()); + mapping.endpoint_id, ChipLogValueMEI(dataAttributePath.mClusterId), + ChipLogValueMEI(dataAttributePath.mAttributeId), err.Format()); } - MatterPostAttributeWriteCallback(concretePath); + MatterPostAttributeWriteCallback(dataAttributePath); } iterator->Release(); @@ -417,9 +403,20 @@ Status WriteHandler::ProcessWriteRequest(System::PacketBufferHandle && aPayload, err = writeRequestParser.GetTimedRequest(&mIsTimedRequest); SuccessOrExit(err); - err = writeRequestParser.GetIsFabricFiltered(&mIsFabricFiltered); + err = writeRequestParser.GetMoreChunkedMessages(&mHasMoreChunks); + if (err == CHIP_ERROR_END_OF_TLV) + { + err = CHIP_NO_ERROR; + } SuccessOrExit(err); + if (mHasMoreChunks && (mpExchangeCtx->IsGroupExchangeContext() || mIsTimedRequest)) + { + // Sanity check: group exchange context should only have one chunk. + // Also, timed requests should not have more than one chunk. + ExitNow(err = CHIP_ERROR_INVALID_MESSAGE_TYPE); + } + err = writeRequestParser.GetWriteRequests(&AttributeDataIBsParser); SuccessOrExit(err); @@ -448,15 +445,19 @@ Status WriteHandler::ProcessWriteRequest(System::PacketBufferHandle && aPayload, } exit: + if (err != CHIP_NO_ERROR) + { + ChipLogError(DataManagement, "Failed to process write request: %" CHIP_ERROR_FORMAT, err.Format()); + } return status; } -CHIP_ERROR WriteHandler::AddStatus(const ConcreteAttributePath & aPath, const Protocols::InteractionModel::Status aStatus) +CHIP_ERROR WriteHandler::AddStatus(const ConcreteDataAttributePath & aPath, const Protocols::InteractionModel::Status aStatus) { return AddStatus(aPath, StatusIB(aStatus)); } -CHIP_ERROR WriteHandler::AddStatus(const ConcreteAttributePath & aPath, const StatusIB & aStatus) +CHIP_ERROR WriteHandler::AddStatus(const ConcreteDataAttributePath & aPath, const StatusIB & aStatus) { AttributeStatusIBs::Builder & writeResponses = mWriteResponseBuilder.GetWriteResponses(); AttributeStatusIB::Builder & attributeStatusIB = writeResponses.CreateAttributeStatus(); @@ -464,7 +465,7 @@ CHIP_ERROR WriteHandler::AddStatus(const ConcreteAttributePath & aPath, const St AttributePathIB::Builder & path = attributeStatusIB.CreatePath(); ReturnErrorOnFailure(attributeStatusIB.GetError()); - ReturnErrorOnFailure(path.Encode(AttributePathParams(aPath.mEndpointId, aPath.mClusterId, aPath.mAttributeId))); + ReturnErrorOnFailure(path.Encode(aPath)); StatusIB::Builder & statusIBBuilder = attributeStatusIB.CreateErrorStatus(); ReturnErrorOnFailure(attributeStatusIB.GetError()); diff --git a/src/app/WriteHandler.h b/src/app/WriteHandler.h index f3b120361e626f..b475361114031b 100644 --- a/src/app/WriteHandler.h +++ b/src/app/WriteHandler.h @@ -17,6 +17,7 @@ */ #pragma once +#include #include #include #include @@ -79,8 +80,8 @@ class WriteHandler : public Messaging::ExchangeDelegate CHIP_ERROR ProcessAttributeDataIBs(TLV::TLVReader & aAttributeDataIBsReader); CHIP_ERROR ProcessGroupAttributeDataIBs(TLV::TLVReader & aAttributeDataIBsReader); - CHIP_ERROR AddStatus(const ConcreteAttributePath & aPath, const Protocols::InteractionModel::Status aStatus); - CHIP_ERROR AddStatus(const ConcreteAttributePath & aPath, const StatusIB & aStatus); + CHIP_ERROR AddStatus(const ConcreteDataAttributePath & aPath, const Protocols::InteractionModel::Status aStatus); + CHIP_ERROR AddStatus(const ConcreteDataAttributePath & aPath, const StatusIB & aStatus); CHIP_ERROR AddClusterSpecificSuccess(const AttributePathParams & aAttributePathParams, uint8_t aClusterStatus) { @@ -99,6 +100,18 @@ class WriteHandler : public Messaging::ExchangeDelegate */ bool IsTimedWrite() const { return mIsTimedRequest; } + bool MatchesExchangeContext(Messaging::ExchangeContext * apExchangeContext) const + { + return !IsFree() && mpExchangeCtx == apExchangeContext; + } + + void CacheACLCheckResult(const AttributeAccessToken & aToken) { mACLCheckCache.SetValue(aToken); } + + bool ACLCheckCacheHit(const AttributeAccessToken & aToken) + { + return mACLCheckCache.HasValue() && mACLCheckCache.Value() == aToken; + } + private: enum class State { @@ -108,6 +121,9 @@ class WriteHandler : public Messaging::ExchangeDelegate Sending, // The handler has sent out the write response }; Protocols::InteractionModel::Status ProcessWriteRequest(System::PacketBufferHandle && aPayload, bool aIsTimedWrite); + Protocols::InteractionModel::Status HandleWriteRequestMessage(Messaging::ExchangeContext * apExchangeContext, + System::PacketBufferHandle && aPayload, bool aIsTimedWrite); + CHIP_ERROR FinalizeMessage(System::PacketBufferHandle & packet); CHIP_ERROR SendWriteResponse(); @@ -128,9 +144,10 @@ class WriteHandler : public Messaging::ExchangeDelegate Messaging::ExchangeContext * mpExchangeCtx = nullptr; WriteResponseMessage::Builder mWriteResponseBuilder; System::PacketBufferTLVWriter mMessageWriter; - State mState = State::Uninitialized; - bool mIsTimedRequest = false; - bool mIsFabricFiltered = false; + State mState = State::Uninitialized; + bool mIsTimedRequest = false; + bool mHasMoreChunks = false; + Optional mACLCheckCache = NullOptional; }; } // namespace app } // namespace chip diff --git a/src/app/clusters/access-control-server/access-control-server.cpp b/src/app/clusters/access-control-server/access-control-server.cpp index 857b183f39827e..a87ff94e2abb21 100644 --- a/src/app/clusters/access-control-server/access-control-server.cpp +++ b/src/app/clusters/access-control-server/access-control-server.cpp @@ -299,7 +299,7 @@ class AccessControlAttribute : public chip::app::AttributeAccessInterface private: CHIP_ERROR ReadAcl(AttributeValueEncoder & aEncoder); CHIP_ERROR ReadExtension(AttributeValueEncoder & aEncoder); - CHIP_ERROR WriteAcl(AttributeValueDecoder & aDecoder); + CHIP_ERROR WriteAcl(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder); CHIP_ERROR WriteExtension(AttributeValueDecoder & aDecoder); }; @@ -426,7 +426,7 @@ CHIP_ERROR AccessControlAttribute::Write(const ConcreteDataAttributePath & aPath switch (aPath.mAttributeId) { case AccessControlCluster::Attributes::Acl::Id: - return WriteAcl(aDecoder); + return WriteAcl(aPath, aDecoder); case AccessControlCluster::Attributes::Extension::Id: return WriteExtension(aDecoder); } @@ -434,60 +434,76 @@ CHIP_ERROR AccessControlAttribute::Write(const ConcreteDataAttributePath & aPath return CHIP_NO_ERROR; } -CHIP_ERROR AccessControlAttribute::WriteAcl(AttributeValueDecoder & aDecoder) +CHIP_ERROR AccessControlAttribute::WriteAcl(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder) { FabricIndex accessingFabricIndex = aDecoder.AccessingFabricIndex(); - DataModel::DecodableList list; - ReturnErrorOnFailure(aDecoder.Decode(list)); + if (!aPath.IsListItemOperation()) + { + DataModel::DecodableList list; + ReturnErrorOnFailure(aDecoder.Decode(list)); - size_t oldCount = 0; - size_t allCount; - size_t newCount; - size_t maxCount; + size_t oldCount = 0; + size_t allCount; + size_t newCount; + size_t maxCount; - { - AccessControl::EntryIterator it; - AccessControl::Entry entry; - ReturnErrorOnFailure(GetAccessControl().Entries(it, &accessingFabricIndex)); - while (it.Next(entry) == CHIP_NO_ERROR) { - oldCount++; + AccessControl::EntryIterator it; + AccessControl::Entry entry; + ReturnErrorOnFailure(GetAccessControl().Entries(it, &accessingFabricIndex)); + while (it.Next(entry) == CHIP_NO_ERROR) + { + oldCount++; + } } - } - ReturnErrorOnFailure(GetAccessControl().GetEntryCount(allCount)); - ReturnErrorOnFailure(list.ComputeSize(&newCount)); - ReturnErrorOnFailure(GetAccessControl().GetMaxEntryCount(maxCount)); - VerifyOrReturnError(allCount >= oldCount, CHIP_ERROR_INTERNAL); - VerifyOrReturnError(static_cast(allCount - oldCount + newCount) <= maxCount, CHIP_ERROR_INVALID_LIST_LENGTH); + ReturnErrorOnFailure(GetAccessControl().GetEntryCount(allCount)); + ReturnErrorOnFailure(list.ComputeSize(&newCount)); + ReturnErrorOnFailure(GetAccessControl().GetMaxEntryCount(maxCount)); + VerifyOrReturnError(allCount >= oldCount, CHIP_ERROR_INTERNAL); + VerifyOrReturnError(static_cast(allCount - oldCount + newCount) <= maxCount, CHIP_ERROR_INVALID_LIST_LENGTH); - auto iterator = list.begin(); - size_t i = 0; - while (iterator.Next()) - { - if (i < oldCount) + auto iterator = list.begin(); + size_t i = 0; + while (iterator.Next()) { - ReturnErrorOnFailure(GetAccessControl().UpdateEntry(i, iterator.GetValue().entry, &accessingFabricIndex)); - ReturnErrorOnFailure(LogAccessControlEvent(iterator.GetValue().entry, aDecoder.GetSubjectDescriptor(), - AccessControlCluster::ChangeTypeEnum::kChanged)); + if (i < oldCount) + { + ReturnErrorOnFailure(GetAccessControl().UpdateEntry(i, iterator.GetValue().entry, &accessingFabricIndex)); + ReturnErrorOnFailure(LogAccessControlEvent(iterator.GetValue().entry, aDecoder.GetSubjectDescriptor(), + AccessControlCluster::ChangeTypeEnum::kChanged)); + } + else + { + ReturnErrorOnFailure(GetAccessControl().CreateEntry(nullptr, iterator.GetValue().entry, &accessingFabricIndex)); + ReturnErrorOnFailure(LogAccessControlEvent(iterator.GetValue().entry, aDecoder.GetSubjectDescriptor(), + AccessControlCluster::ChangeTypeEnum::kAdded)); + } + ++i; } - else + ReturnErrorOnFailure(iterator.GetStatus()); + + while (i < oldCount) { - ReturnErrorOnFailure(GetAccessControl().CreateEntry(nullptr, iterator.GetValue().entry, &accessingFabricIndex)); + --oldCount; + ReturnErrorOnFailure(GetAccessControl().DeleteEntry(oldCount, &accessingFabricIndex)); ReturnErrorOnFailure(LogAccessControlEvent(iterator.GetValue().entry, aDecoder.GetSubjectDescriptor(), - AccessControlCluster::ChangeTypeEnum::kAdded)); + AccessControlCluster::ChangeTypeEnum::kRemoved)); } - ++i; } - ReturnErrorOnFailure(iterator.GetStatus()); + else if (aPath.mListOp == ConcreteDataAttributePath::ListOperation::AppendItem) + { + AccessControlEntryCodec item; + ReturnErrorOnFailure(aDecoder.Decode(item)); - while (i < oldCount) + ReturnErrorOnFailure(GetAccessControl().CreateEntry(nullptr, item.entry, &accessingFabricIndex)); + ReturnErrorOnFailure( + LogAccessControlEvent(item.entry, aDecoder.GetSubjectDescriptor(), AccessControlCluster::ChangeTypeEnum::kAdded)); + } + else { - --oldCount; - ReturnErrorOnFailure(GetAccessControl().DeleteEntry(oldCount, &accessingFabricIndex)); - ReturnErrorOnFailure(LogAccessControlEvent(iterator.GetValue().entry, aDecoder.GetSubjectDescriptor(), - AccessControlCluster::ChangeTypeEnum::kRemoved)); + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; } return CHIP_NO_ERROR; diff --git a/src/app/clusters/group-key-mgmt-server/group-key-mgmt-server.cpp b/src/app/clusters/group-key-mgmt-server/group-key-mgmt-server.cpp index f3d1406741e68e..4206e049c6cb9f 100644 --- a/src/app/clusters/group-key-mgmt-server/group-key-mgmt-server.cpp +++ b/src/app/clusters/group-key-mgmt-server/group-key-mgmt-server.cpp @@ -33,6 +33,7 @@ using namespace chip; using namespace chip::app; using namespace chip::Credentials; using namespace chip::app::Clusters; +using namespace chip::app::Clusters::GroupKeyManagement; // // Attributes @@ -139,7 +140,7 @@ class GroupKeyManagementAttributeAccess : public AttributeAccessInterface if (GroupKeyManagement::Attributes::GroupKeyMap::Id == aPath.mAttributeId) { - return WriteGroupKeyMap(aPath.mEndpointId, aDecoder); + return WriteGroupKeyMap(aPath, aDecoder); } return CHIP_ERROR_WRITE_FAILED; } @@ -175,31 +176,57 @@ class GroupKeyManagementAttributeAccess : public AttributeAccessInterface return err; } - CHIP_ERROR WriteGroupKeyMap(EndpointId endpoint, AttributeValueDecoder & aDecoder) + CHIP_ERROR WriteGroupKeyMap(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder) { auto fabric_index = aDecoder.AccessingFabricIndex(); auto provider = GetGroupDataProvider(); - GroupKeyManagement::Attributes::GroupKeyMap::TypeInfo::DecodableType list; - size_t new_count; - VerifyOrReturnError(nullptr != provider, CHIP_ERROR_INTERNAL); - ReturnErrorOnFailure(aDecoder.Decode(list)); - ReturnErrorOnFailure(list.ComputeSize(&new_count)); + if (!aPath.IsListItemOperation()) + { + Attributes::GroupKeyMap::TypeInfo::DecodableType list; + size_t new_count; - // Remove existing keys, ignore errors - provider->RemoveGroupKeys(fabric_index); + VerifyOrReturnError(nullptr != provider, CHIP_ERROR_INTERNAL); + ReturnErrorOnFailure(aDecoder.Decode(list)); + ReturnErrorOnFailure(list.ComputeSize(&new_count)); - // Add the new keys - auto iter = list.begin(); - size_t i = 0; - while (iter.Next()) + // Remove existing keys, ignore errors + provider->RemoveGroupKeys(fabric_index); + + // Add the new keys + auto iter = list.begin(); + size_t i = 0; + while (iter.Next()) + { + const auto & value = iter.GetValue(); + VerifyOrReturnError(fabric_index == value.fabricIndex, CHIP_ERROR_INVALID_FABRIC_ID); + ReturnErrorOnFailure(provider->SetGroupKeyAt(value.fabricIndex, i++, + GroupDataProvider::GroupKey(value.groupId, value.groupKeySetID))); + } + ReturnErrorOnFailure(iter.GetStatus()); + } + else if (aPath.mListOp == ConcreteDataAttributePath::ListOperation::AppendItem) { - const auto & value = iter.GetValue(); + Structs::GroupKeyMapStruct::DecodableType value; + size_t current_count = 0; + VerifyOrReturnError(nullptr != provider, CHIP_ERROR_INTERNAL); + ReturnErrorOnFailure(aDecoder.Decode(value)); VerifyOrReturnError(fabric_index == value.fabricIndex, CHIP_ERROR_INVALID_FABRIC_ID); - ReturnErrorOnFailure( - provider->SetGroupKeyAt(value.fabricIndex, i++, GroupDataProvider::GroupKey(value.groupId, value.groupKeySetID))); + + { + auto iter = provider->IterateGroupKeys(fabric_index); + current_count = iter->Count(); + iter->Release(); + } + + ReturnErrorOnFailure(provider->SetGroupKeyAt(value.fabricIndex, current_count, + GroupDataProvider::GroupKey(value.groupId, value.groupKeySetID))); } - ReturnErrorOnFailure(iter.GetStatus()); + else + { + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; + } + return CHIP_NO_ERROR; } diff --git a/src/app/clusters/test-cluster-server/test-cluster-server.cpp b/src/app/clusters/test-cluster-server/test-cluster-server.cpp index fce8e432558bc3..82a39e8d8b2ed9 100644 --- a/src/app/clusters/test-cluster-server/test-cluster-server.cpp +++ b/src/app/clusters/test-cluster-server/test-cluster-server.cpp @@ -76,14 +76,16 @@ class TestAttrAccess : public AttributeAccessInterface private: CHIP_ERROR ReadListInt8uAttribute(AttributeValueEncoder & aEncoder); - CHIP_ERROR WriteListInt8uAttribute(AttributeValueDecoder & aDecoder); + CHIP_ERROR WriteListInt8uAttribute(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder); CHIP_ERROR ReadListOctetStringAttribute(AttributeValueEncoder & aEncoder); - CHIP_ERROR WriteListOctetStringAttribute(AttributeValueDecoder & aDecoder); + CHIP_ERROR WriteListOctetStringAttribute(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder); CHIP_ERROR ReadListLongOctetStringAttribute(AttributeValueEncoder & aEncoder); + CHIP_ERROR WriteListLongOctetStringAttribute(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder); CHIP_ERROR ReadListStructOctetStringAttribute(AttributeValueEncoder & aEncoder); - CHIP_ERROR WriteListStructOctetStringAttribute(AttributeValueDecoder & aDecoder); + CHIP_ERROR WriteListStructOctetStringAttribute(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder); CHIP_ERROR ReadListNullablesAndOptionalsStructAttribute(AttributeValueEncoder & aEncoder); - CHIP_ERROR WriteListNullablesAndOptionalsStructAttribute(AttributeValueDecoder & aDecoder); + CHIP_ERROR WriteListNullablesAndOptionalsStructAttribute(const ConcreteDataAttributePath & aPath, + AttributeValueDecoder & aDecoder); CHIP_ERROR ReadStructAttribute(AttributeValueEncoder & aEncoder); CHIP_ERROR WriteStructAttribute(AttributeValueDecoder & aDecoder); CHIP_ERROR ReadNullableStruct(AttributeValueEncoder & aEncoder); @@ -93,13 +95,27 @@ class TestAttrAccess : public AttributeAccessInterface TestAttrAccess gAttrAccess; uint8_t gListUint8Data[kAttributeListLength]; +size_t gListUint8DataLen = kAttributeListLength; OctetStringData gListOctetStringData[kAttributeListLength]; +size_t gListOctetStringDataLen = kAttributeListLength; OctetStringData gListOperationalCert[kAttributeListLength]; +size_t gListOperationalCertLen = kAttributeListLength; +size_t gListLongOctetStringLen = kAttributeListLength; Structs::TestListStructOctet::Type listStructOctetStringData[kAttributeListLength]; OctetStringData gStructAttributeByteSpanData; Structs::SimpleStruct::Type gStructAttributeValue; NullableStruct::TypeInfo::Type gNullableStructAttributeValue; +// /16 /32 /48 /64 +const char sLongOctetStringBuf[513] = "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" // 64 + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" // 128 + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" // 192 + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" // 256 + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" // 320 + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" // 384 + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" // 448 + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"; // 512 + // We don't actually support any interesting bits in the struct for now, except // for a non-null nullableList member. SimpleEnum gSimpleEnums[kAttributeListLength]; @@ -153,16 +169,19 @@ CHIP_ERROR TestAttrAccess::Write(const ConcreteDataAttributePath & aPath, Attrib switch (aPath.mAttributeId) { case ListInt8u::Id: { - return WriteListInt8uAttribute(aDecoder); + return WriteListInt8uAttribute(aPath, aDecoder); } case ListOctetString::Id: { - return WriteListOctetStringAttribute(aDecoder); + return WriteListOctetStringAttribute(aPath, aDecoder); + } + case ListLongOctetString::Id: { + return WriteListLongOctetStringAttribute(aPath, aDecoder); } case ListStructOctetString::Id: { - return WriteListStructOctetStringAttribute(aDecoder); + return WriteListStructOctetStringAttribute(aPath, aDecoder); } case ListNullablesAndOptionalsStruct::Id: { - return WriteListNullablesAndOptionalsStructAttribute(aDecoder); + return WriteListNullablesAndOptionalsStructAttribute(aPath, aDecoder); } case StructAttr::Id: { return WriteStructAttribute(aDecoder); @@ -197,7 +216,7 @@ CHIP_ERROR TestAttrAccess::WriteNullableStruct(AttributeValueDecoder & aDecoder) CHIP_ERROR TestAttrAccess::ReadListInt8uAttribute(AttributeValueEncoder & aEncoder) { return aEncoder.EncodeList([](const auto & encoder) -> CHIP_ERROR { - for (uint8_t index = 0; index < kAttributeListLength; index++) + for (uint8_t index = 0; index < gListUint8DataLen; index++) { ReturnErrorOnFailure(encoder.Encode(gListUint8Data[index])); } @@ -205,36 +224,49 @@ CHIP_ERROR TestAttrAccess::ReadListInt8uAttribute(AttributeValueEncoder & aEncod }); } -CHIP_ERROR TestAttrAccess::WriteListInt8uAttribute(AttributeValueDecoder & aDecoder) +CHIP_ERROR TestAttrAccess::WriteListInt8uAttribute(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder) { - ListInt8u::TypeInfo::DecodableType list; + if (!aPath.IsListItemOperation()) + { - ReturnErrorOnFailure(aDecoder.Decode(list)); + ListInt8u::TypeInfo::DecodableType list; - size_t size; - ReturnErrorOnFailure(list.ComputeSize(&size)); + ReturnErrorOnFailure(aDecoder.Decode(list)); - // We never change our length, so fail out attempts to change it. This - // should really return one of the spec errors! - VerifyOrReturnError(size == kAttributeListLength, CHIP_ERROR_INVALID_ARGUMENT); + size_t size; + ReturnErrorOnFailure(list.ComputeSize(&size)); - uint8_t index = 0; - auto iter = list.begin(); - while (iter.Next()) - { - auto & entry = iter.GetValue(); + uint8_t index = 0; + auto iter = list.begin(); + while (iter.Next()) + { + auto & entry = iter.GetValue(); - VerifyOrReturnError(index < kAttributeListLength, CHIP_ERROR_BUFFER_TOO_SMALL); - gListUint8Data[index++] = entry; - } + VerifyOrReturnError(index < kAttributeListLength, CHIP_ERROR_BUFFER_TOO_SMALL); + gListUint8Data[index++] = entry; + } + + gListUint8DataLen = size; - return iter.GetStatus(); + return iter.GetStatus(); + } + else if (aPath.mListOp == ConcreteDataAttributePath::ListOperation::AppendItem) + { + VerifyOrReturnError(gListUint8DataLen < kAttributeListLength, CHIP_ERROR_INVALID_ARGUMENT); + ReturnErrorOnFailure(aDecoder.Decode(gListUint8Data[gListUint8DataLen])); + gListUint8DataLen++; + return CHIP_NO_ERROR; + } + else + { + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; + } } CHIP_ERROR TestAttrAccess::ReadListOctetStringAttribute(AttributeValueEncoder & aEncoder) { return aEncoder.EncodeList([](const auto & encoder) -> CHIP_ERROR { - for (uint8_t index = 0; index < kAttributeListLength; index++) + for (uint8_t index = 0; index < gListOctetStringDataLen; index++) { ReturnErrorOnFailure(encoder.Encode(gListOctetStringData[index].AsSpan())); } @@ -242,77 +274,103 @@ CHIP_ERROR TestAttrAccess::ReadListOctetStringAttribute(AttributeValueEncoder & }); } -CHIP_ERROR TestAttrAccess::WriteListOctetStringAttribute(AttributeValueDecoder & aDecoder) +CHIP_ERROR TestAttrAccess::WriteListOctetStringAttribute(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder) { - ListOctetString::TypeInfo::DecodableType list; + if (!aPath.IsListItemOperation()) + { + ListOctetString::TypeInfo::DecodableType list; + + ReturnErrorOnFailure(aDecoder.Decode(list)); + + uint8_t index = 0; + auto iter = list.begin(); + while (iter.Next()) + { + const auto & entry = iter.GetValue(); + + VerifyOrReturnError(index < kAttributeListLength, CHIP_ERROR_BUFFER_TOO_SMALL); + VerifyOrReturnError(entry.size() <= kAttributeEntryLength, CHIP_ERROR_BUFFER_TOO_SMALL); + memcpy(gListOctetStringData[index].Data(), entry.data(), entry.size()); + gListOctetStringData[index].SetLength(entry.size()); + index++; + } - ReturnErrorOnFailure(aDecoder.Decode(list)); + gListOctetStringDataLen = index; - uint8_t index = 0; - auto iter = list.begin(); - while (iter.Next()) + return iter.GetStatus(); + } + else if (aPath.mListOp == ConcreteDataAttributePath::ListOperation::AppendItem) { - const auto & entry = iter.GetValue(); + ByteSpan entry; + ReturnErrorOnFailure(aDecoder.Decode(entry)); - VerifyOrReturnError(index < kAttributeListLength, CHIP_ERROR_BUFFER_TOO_SMALL); + VerifyOrReturnError(gListOctetStringDataLen < kAttributeListLength, CHIP_ERROR_INVALID_ARGUMENT); VerifyOrReturnError(entry.size() <= kAttributeEntryLength, CHIP_ERROR_BUFFER_TOO_SMALL); - memcpy(gListOctetStringData[index].Data(), entry.data(), entry.size()); - gListOctetStringData[index].SetLength(entry.size()); - index++; + memcpy(gListOctetStringData[gListOctetStringDataLen].Data(), entry.data(), entry.size()); + gListOctetStringData[gListOctetStringDataLen].SetLength(entry.size()); + gListOctetStringDataLen++; + return CHIP_NO_ERROR; + } + else + { + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; } - - return iter.GetStatus(); } CHIP_ERROR TestAttrAccess::ReadListLongOctetStringAttribute(AttributeValueEncoder & aEncoder) { // The ListOctetStringAttribute takes 512 bytes, and the whole attribute will exceed the IPv6 MTU, so we can test list chunking // feature with this attribute. - char buf[513] = "0123456789abcdef" - "0123456789abcdef" - "0123456789abcdef" - "0123456789abcdef" - "0123456789abcdef" // 5 - "0123456789abcdef" - "0123456789abcdef" - "0123456789abcdef" - "0123456789abcdef" - "0123456789abcdef" // 10 - "0123456789abcdef" - "0123456789abcdef" - "0123456789abcdef" - "0123456789abcdef" - "0123456789abcdef" // 15 - "0123456789abcdef" - "0123456789abcdef" - "0123456789abcdef" - "0123456789abcdef" - "0123456789abcdef" // 20 - "0123456789abcdef" - "0123456789abcdef" - "0123456789abcdef" - "0123456789abcdef" - "0123456789abcdef" // 25 - "0123456789abcdef" - "0123456789abcdef" - "0123456789abcdef" - "0123456789abcdef" - "0123456789abcdef" // 30 - "0123456789abcdef" - "0123456789abcdef"; // 32 * 16 = 512 - return aEncoder.EncodeList([buf](const auto & encoder) -> CHIP_ERROR { - for (uint8_t index = 0; index < kAttributeListLength; index++) + return aEncoder.EncodeList([](const auto & encoder) -> CHIP_ERROR { + for (uint8_t index = 0; index < gListLongOctetStringLen; index++) { - ReturnErrorOnFailure(encoder.Encode(ByteSpan(chip::Uint8::from_const_char(buf), 512))); + ReturnErrorOnFailure(encoder.Encode(ByteSpan(chip::Uint8::from_const_char(sLongOctetStringBuf), 512))); } return CHIP_NO_ERROR; }); } +CHIP_ERROR TestAttrAccess::WriteListLongOctetStringAttribute(const ConcreteDataAttributePath & aPath, + AttributeValueDecoder & aDecoder) +{ + if (!aPath.IsListItemOperation()) + { + ListLongOctetString::TypeInfo::DecodableType list; + + ReturnErrorOnFailure(aDecoder.Decode(list)); + + auto iter = list.begin(); + gListLongOctetStringLen = 0; + while (iter.Next()) + { + const auto & entry = iter.GetValue(); + VerifyOrReturnError(entry.size() == sizeof(sLongOctetStringBuf) - 1, CHIP_ERROR_BUFFER_TOO_SMALL); + VerifyOrReturnError(memcmp(entry.data(), sLongOctetStringBuf, entry.size()) == 0, CHIP_ERROR_INVALID_ARGUMENT); + gListLongOctetStringLen++; + } + + return iter.GetStatus(); + } + else if (aPath.mListOp == ConcreteDataAttributePath::ListOperation::AppendItem) + { + ByteSpan entry; + ReturnErrorOnFailure(aDecoder.Decode(entry)); + + VerifyOrReturnError(entry.size() == sizeof(sLongOctetStringBuf) - 1, CHIP_ERROR_BUFFER_TOO_SMALL); + VerifyOrReturnError(memcmp(entry.data(), sLongOctetStringBuf, entry.size()) == 0, CHIP_ERROR_INVALID_ARGUMENT); + gListLongOctetStringLen++; + return CHIP_NO_ERROR; + } + else + { + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; + } +} + CHIP_ERROR TestAttrAccess::ReadListStructOctetStringAttribute(AttributeValueEncoder & aEncoder) { return aEncoder.EncodeList([](const auto & encoder) -> CHIP_ERROR { - for (uint8_t index = 0; index < kAttributeListLength; index++) + for (uint8_t index = 0; index < gListOperationalCertLen; index++) { Structs::TestListStructOctet::Type structOctet; structOctet.fabricIndex = listStructOctetStringData[index].fabricIndex; @@ -324,17 +382,46 @@ CHIP_ERROR TestAttrAccess::ReadListStructOctetStringAttribute(AttributeValueEnco }); } -CHIP_ERROR TestAttrAccess::WriteListStructOctetStringAttribute(AttributeValueDecoder & aDecoder) +CHIP_ERROR TestAttrAccess::WriteListStructOctetStringAttribute(const ConcreteDataAttributePath & aPath, + AttributeValueDecoder & aDecoder) { - ListStructOctetString::TypeInfo::DecodableType list; + if (!aPath.IsListItemOperation()) + { + ListStructOctetString::TypeInfo::DecodableType list; - ReturnErrorOnFailure(aDecoder.Decode(list)); + ReturnErrorOnFailure(aDecoder.Decode(list)); + + uint8_t index = 0; + auto iter = list.begin(); + while (iter.Next()) + { + const auto & entry = iter.GetValue(); - uint8_t index = 0; - auto iter = list.begin(); - while (iter.Next()) + VerifyOrReturnError(index < kAttributeListLength, CHIP_ERROR_BUFFER_TOO_SMALL); + VerifyOrReturnError(entry.operationalCert.size() <= kAttributeEntryLength, CHIP_ERROR_BUFFER_TOO_SMALL); + memcpy(gListOperationalCert[index].Data(), entry.operationalCert.data(), entry.operationalCert.size()); + gListOperationalCert[index].SetLength(entry.operationalCert.size()); + + listStructOctetStringData[index].fabricIndex = entry.fabricIndex; + listStructOctetStringData[index].operationalCert = gListOperationalCert[index].AsSpan(); + + index++; + } + + gListOperationalCertLen = index; + + if (iter.GetStatus() != CHIP_NO_ERROR) + { + return CHIP_ERROR_INVALID_DATA_LIST; + } + + return CHIP_NO_ERROR; + } + else if (aPath.mListOp == ConcreteDataAttributePath::ListOperation::AppendItem) { - const auto & entry = iter.GetValue(); + chip::app::Clusters::TestCluster::Structs::TestListStructOctet::DecodableType entry; + ReturnErrorOnFailure(aDecoder.Decode(entry)); + size_t index = gListOperationalCertLen; VerifyOrReturnError(index < kAttributeListLength, CHIP_ERROR_BUFFER_TOO_SMALL); VerifyOrReturnError(entry.operationalCert.size() <= kAttributeEntryLength, CHIP_ERROR_BUFFER_TOO_SMALL); @@ -343,15 +430,14 @@ CHIP_ERROR TestAttrAccess::WriteListStructOctetStringAttribute(AttributeValueDec listStructOctetStringData[index].fabricIndex = entry.fabricIndex; listStructOctetStringData[index].operationalCert = gListOperationalCert[index].AsSpan(); - index++; - } - if (iter.GetStatus() != CHIP_NO_ERROR) + gListOperationalCertLen++; + return CHIP_NO_ERROR; + } + else { - return CHIP_ERROR_INVALID_DATA_LIST; + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; } - - return CHIP_NO_ERROR; } CHIP_ERROR TestAttrAccess::ReadListNullablesAndOptionalsStructAttribute(AttributeValueEncoder & aEncoder) @@ -363,20 +449,29 @@ CHIP_ERROR TestAttrAccess::ReadListNullablesAndOptionalsStructAttribute(Attribut }); } -CHIP_ERROR TestAttrAccess::WriteListNullablesAndOptionalsStructAttribute(AttributeValueDecoder & aDecoder) +CHIP_ERROR TestAttrAccess::WriteListNullablesAndOptionalsStructAttribute(const ConcreteDataAttributePath & aPath, + AttributeValueDecoder & aDecoder) { - DataModel::DecodableList list; - ReturnErrorOnFailure(aDecoder.Decode(list)); + static size_t count = 1; + if (!aPath.IsListItemOperation()) + { + DataModel::DecodableList list; + ReturnErrorOnFailure(aDecoder.Decode(list)); - size_t count; - ReturnErrorOnFailure(list.ComputeSize(&count)); - // This should really send proper errors on invalid input! - VerifyOrReturnError(count == 1, CHIP_ERROR_INVALID_ARGUMENT); + ReturnErrorOnFailure(list.ComputeSize(&count)); + // We are assuming we are using list chunking feature for attribute writes. + VerifyOrReturnError(count == 0, CHIP_ERROR_INVALID_ARGUMENT); - auto iter = list.begin(); - while (iter.Next()) + return CHIP_NO_ERROR; + } + else if (aPath.mListOp == ConcreteDataAttributePath::ListOperation::AppendItem) { - auto & value = iter.GetValue(); + // And we only support one entry in the list. + VerifyOrReturnError(count == 0, CHIP_ERROR_INVALID_ARGUMENT); + + Structs::NullablesAndOptionalsStruct::DecodableType value; + ReturnErrorOnFailure(aDecoder.Decode(value)); + // We only support some values so far. VerifyOrReturnError(value.nullableString.IsNull(), CHIP_ERROR_INVALID_ARGUMENT); VerifyOrReturnError(value.nullableStruct.IsNull(), CHIP_ERROR_INVALID_ARGUMENT); @@ -388,6 +483,8 @@ CHIP_ERROR TestAttrAccess::WriteListNullablesAndOptionalsStructAttribute(Attribu VerifyOrReturnError(!value.optionalList.HasValue(), CHIP_ERROR_INVALID_ARGUMENT); VerifyOrReturnError(!value.nullableOptionalList.HasValue(), CHIP_ERROR_INVALID_ARGUMENT); + count++; + // Start our value off as null, just in case we fail to decode things. gNullablesAndOptionalsStruct.nullableList.SetNull(); if (!value.nullableList.IsNull()) @@ -407,10 +504,13 @@ CHIP_ERROR TestAttrAccess::WriteListNullablesAndOptionalsStructAttribute(Attribu gNullablesAndOptionalsStruct.nullableInt = value.nullableInt; gNullablesAndOptionalsStruct.optionalInt = value.optionalInt; gNullablesAndOptionalsStruct.nullableOptionalInt = value.nullableOptionalInt; - } - ReturnErrorOnFailure(iter.GetStatus()); - return CHIP_NO_ERROR; + return CHIP_NO_ERROR; + } + else + { + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; + } } CHIP_ERROR TestAttrAccess::ReadStructAttribute(AttributeValueEncoder & aEncoder) diff --git a/src/app/clusters/user-label-server/user-label-server.cpp b/src/app/clusters/user-label-server/user-label-server.cpp index 311eb8027c10b0..44c59630b15f88 100644 --- a/src/app/clusters/user-label-server/user-label-server.cpp +++ b/src/app/clusters/user-label-server/user-label-server.cpp @@ -49,7 +49,7 @@ class UserLabelAttrAccess : public AttributeAccessInterface private: CHIP_ERROR ReadLabelList(EndpointId endpoint, AttributeValueEncoder & aEncoder); - CHIP_ERROR WriteLabelList(EndpointId endpoint, AttributeValueDecoder & aDecoder); + CHIP_ERROR WriteLabelList(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder); }; UserLabelAttrAccess gAttrAccess; @@ -78,22 +78,39 @@ CHIP_ERROR UserLabelAttrAccess::ReadLabelList(EndpointId endpoint, AttributeValu return err; } -CHIP_ERROR UserLabelAttrAccess::WriteLabelList(EndpointId endpoint, AttributeValueDecoder & aDecoder) +CHIP_ERROR UserLabelAttrAccess::WriteLabelList(const ConcreteDataAttributePath & aPath, AttributeValueDecoder & aDecoder) { - DeviceLayer::AttributeList labelList; - LabelList::TypeInfo::DecodableType decodablelist; + EndpointId endpoint = aPath.mEndpointId; + if (!aPath.IsListItemOperation()) + { + DeviceLayer::AttributeList labelList; + LabelList::TypeInfo::DecodableType decodablelist; + + ReturnErrorOnFailure(aDecoder.Decode(decodablelist)); - ReturnErrorOnFailure(aDecoder.Decode(decodablelist)); + auto iter = decodablelist.begin(); + while (iter.Next()) + { + auto & entry = iter.GetValue(); + ReturnErrorOnFailure(labelList.add(entry)); + } + ReturnErrorOnFailure(iter.GetStatus()); - auto iter = decodablelist.begin(); - while (iter.Next()) + return DeviceLayer::PlatformMgr().SetUserLabelList(endpoint, labelList); + } + else if (aPath.mListOp == ConcreteDataAttributePath::ListOperation::AppendItem) { - auto & entry = iter.GetValue(); + Structs::LabelStruct::DecodableType entry; + DeviceLayer::AttributeList labelList; + ReturnErrorOnFailure(DeviceLayer::PlatformMgr().GetUserLabelList(endpoint, labelList)); + ReturnErrorOnFailure(aDecoder.Decode(entry)); ReturnErrorOnFailure(labelList.add(entry)); + return DeviceLayer::PlatformMgr().SetUserLabelList(endpoint, labelList); + } + else + { + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; } - ReturnErrorOnFailure(iter.GetStatus()); - - return DeviceLayer::PlatformMgr().SetUserLabelList(endpoint, labelList); } CHIP_ERROR UserLabelAttrAccess::Read(const ConcreteReadAttributePath & aPath, AttributeValueEncoder & aEncoder) @@ -117,7 +134,7 @@ CHIP_ERROR UserLabelAttrAccess::Write(const ConcreteDataAttributePath & aPath, A switch (aPath.mAttributeId) { case LabelList::Id: - return WriteLabelList(aPath.mEndpointId, aDecoder); + return WriteLabelList(aPath, aDecoder); default: break; } diff --git a/src/app/data-model/Nullable.h b/src/app/data-model/Nullable.h index 25eb7a51320641..31513d1f8a8817 100644 --- a/src/app/data-model/Nullable.h +++ b/src/app/data-model/Nullable.h @@ -27,6 +27,11 @@ namespace chip { namespace app { namespace DataModel { +/** + * NullNullable is an alias for NullOptional, for better readability. + */ +constexpr auto NullNullable = NullOptional; + /* * Dedicated type for nullable things, to differentiate them from optional * things. diff --git a/src/app/tests/TestWriteInteraction.cpp b/src/app/tests/TestWriteInteraction.cpp index 8fb27fb286f8b8..15b6a159bdc288 100644 --- a/src/app/tests/TestWriteInteraction.cpp +++ b/src/app/tests/TestWriteInteraction.cpp @@ -75,7 +75,7 @@ class TestWriteClientCallback : public chip::app::WriteClient::Callback { public: void ResetCounter() { mOnSuccessCalled = mOnErrorCalled = mOnDoneCalled = 0; } - void OnResponse(const WriteClient * apWriteClient, const chip::app::ConcreteAttributePath & path, StatusIB status) override + void OnResponse(const WriteClient * apWriteClient, const chip::app::ConcreteDataAttributePath & path, StatusIB status) override { mOnSuccessCalled++; } @@ -91,19 +91,12 @@ void TestWriteInteraction::AddAttributeDataIB(nlTestSuite * apSuite, void * apCo { CHIP_ERROR err = CHIP_NO_ERROR; AttributePathParams attributePathParams; + bool attributeValue = true; attributePathParams.mEndpointId = 2; attributePathParams.mClusterId = 3; attributePathParams.mAttributeId = 4; - err = aWriteClient.PrepareAttribute(attributePathParams); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); - - chip::TLV::TLVWriter * writer = aWriteClient.GetAttributeDataIBTLVWriter(); - - err = writer->PutBoolean(chip::TLV::ContextTag(to_underlying(AttributeDataIB::Tag::kData)), true); - NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); - - err = aWriteClient.FinishAttribute(); + err = aWriteClient.EncodeAttribute(attributePathParams, attributeValue); NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); } @@ -137,7 +130,12 @@ void TestWriteInteraction::GenerateWriteRequest(nlTestSuite * apSuite, void * ap NL_TEST_ASSERT(apSuite, attributeDataIBBuilder.GetError() == CHIP_NO_ERROR); AttributePathIB::Builder & attributePathBuilder = attributeDataIBBuilder.CreatePath(); NL_TEST_ASSERT(apSuite, attributePathBuilder.GetError() == CHIP_NO_ERROR); - attributePathBuilder.Node(1).Endpoint(2).Cluster(3).Attribute(4).ListIndex(5).EndOfAttributePathIB(); + attributePathBuilder.Node(1) + .Endpoint(2) + .Cluster(3) + .Attribute(4) + .ListIndex(DataModel::Nullable()) + .EndOfAttributePathIB(); err = attributePathBuilder.GetError(); NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); @@ -184,7 +182,12 @@ void TestWriteInteraction::GenerateWriteResponse(nlTestSuite * apSuite, void * a AttributePathIB::Builder & attributePathBuilder = attributeStatusIBBuilder.CreatePath(); NL_TEST_ASSERT(apSuite, attributePathBuilder.GetError() == CHIP_NO_ERROR); - attributePathBuilder.Node(1).Endpoint(2).Cluster(3).Attribute(4).ListIndex(5).EndOfAttributePathIB(); + attributePathBuilder.Node(1) + .Endpoint(2) + .Cluster(3) + .Attribute(4) + .ListIndex(DataModel::Nullable()) + .EndOfAttributePathIB(); err = attributePathBuilder.GetError(); NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); @@ -325,16 +328,14 @@ void TestWriteInteraction::TestWriteHandler(nlTestSuite * apSuite, void * apCont ctx.DisableAsyncDispatch(); } -CHIP_ERROR WriteSingleClusterData(const Access::SubjectDescriptor & aSubjectDescriptor, ClusterInfo & aClusterInfo, +CHIP_ERROR WriteSingleClusterData(const Access::SubjectDescriptor & aSubjectDescriptor, const ConcreteDataAttributePath & aPath, TLV::TLVReader & aReader, WriteHandler * aWriteHandler) { TLV::TLVWriter writer; writer.Init(attributeDataTLV); writer.CopyElement(TLV::AnonymousTag(), aReader); attributeDataTLVLen = writer.GetLengthWritten(); - return aWriteHandler->AddStatus( - ConcreteAttributePath(aClusterInfo.mEndpointId, aClusterInfo.mClusterId, aClusterInfo.mAttributeId), - Protocols::InteractionModel::Status::Success); + return aWriteHandler->AddStatus(aPath, Protocols::InteractionModel::Status::Success); } void TestWriteInteraction::TestWriteRoundtripWithClusterObjects(nlTestSuite * apSuite, void * apContext) @@ -371,7 +372,7 @@ void TestWriteInteraction::TestWriteRoundtripWithClusterObjects(nlTestSuite * ap // Spec A.11.2 strings SHALL NOT include a terminating null character to mark the end of a string. dataTx.e = chip::Span(charSpanData, strlen(charSpanData)); - writeClient.EncodeAttributeWritePayload(attributePathParams, dataTx); + writeClient.EncodeAttribute(attributePathParams, dataTx); NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); NL_TEST_ASSERT(apSuite, callback.mOnSuccessCalled == 0); diff --git a/src/app/tests/integration/chip_im_initiator.cpp b/src/app/tests/integration/chip_im_initiator.cpp index 7f700638a37e99..56c0cadd5caca4 100644 --- a/src/app/tests/integration/chip_im_initiator.cpp +++ b/src/app/tests/integration/chip_im_initiator.cpp @@ -185,7 +185,7 @@ class MockInteractionModelApp : public ::chip::app::CommandSender::Callback, } void OnDone(chip::app::CommandSender * apCommandSender) override { delete apCommandSender; } - void OnResponse(const chip::app::WriteClient * apWriteClient, const chip::app::ConcreteAttributePath & path, + void OnResponse(const chip::app::WriteClient * apWriteClient, const chip::app::ConcreteDataAttributePath & path, chip::app::StatusIB status) override { auto respTime = chip::System::SystemClock().GetMonotonicTimestamp(); @@ -360,24 +360,13 @@ CHIP_ERROR SendReadRequest() CHIP_ERROR SendWriteRequest(chip::app::WriteClient & apWriteClient) { - CHIP_ERROR err = CHIP_NO_ERROR; - chip::TLV::TLVWriter * writer; + CHIP_ERROR err = CHIP_NO_ERROR; gLastMessageTime = chip::System::SystemClock().GetMonotonicTimestamp(); - chip::app::AttributePathParams attributePathParams; printf("\nSend write request message to Node: %" PRIu64 "\n", chip::kTestDeviceNodeId); - attributePathParams.mEndpointId = 2; - attributePathParams.mClusterId = 3; - attributePathParams.mAttributeId = 4; - - SuccessOrExit(err = apWriteClient.PrepareAttribute(attributePathParams)); - - writer = apWriteClient.GetAttributeDataIBTLVWriter(); - - SuccessOrExit(err = - writer->PutBoolean(chip::TLV::ContextTag(chip::to_underlying(chip::app::AttributeDataIB::Tag::kData)), true)); - SuccessOrExit(err = apWriteClient.FinishAttribute()); + SuccessOrExit(err = apWriteClient.EncodeAttribute( + chip::app::AttributePathParams(2 /* endpoint */, 3 /* cluster */, 4 /* attribute */), true)); SuccessOrExit(err = apWriteClient.SendWriteRequest(gSession.Get(), gMessageTimeout)); gWriteCount++; @@ -664,10 +653,10 @@ CHIP_ERROR ReadSingleClusterData(const Access::SubjectDescriptor & aSubjectDescr return attributeReport.EndOfAttributeReportIB().GetError(); } -CHIP_ERROR WriteSingleClusterData(const Access::SubjectDescriptor & aSubjectDescriptor, ClusterInfo & aClusterInfo, +CHIP_ERROR WriteSingleClusterData(const Access::SubjectDescriptor & aSubjectDescriptor, const ConcreteDataAttributePath & aPath, TLV::TLVReader & aReader, WriteHandler *) { - if (aClusterInfo.mClusterId != kTestClusterId || aClusterInfo.mEndpointId != kTestEndpointId) + if (aPath.mClusterId != kTestClusterId || aPath.mEndpointId != kTestEndpointId) { return CHIP_ERROR_INVALID_ARGUMENT; } diff --git a/src/app/tests/integration/chip_im_responder.cpp b/src/app/tests/integration/chip_im_responder.cpp index c9d5e86c7b6eec..481dbae7c46bc1 100644 --- a/src/app/tests/integration/chip_im_responder.cpp +++ b/src/app/tests/integration/chip_im_responder.cpp @@ -121,11 +121,11 @@ CHIP_ERROR ReadSingleClusterData(const Access::SubjectDescriptor & aSubjectDescr return CHIP_NO_ERROR; } -CHIP_ERROR WriteSingleClusterData(const Access::SubjectDescriptor & aSubjectDescriptor, ClusterInfo & aClusterInfo, +CHIP_ERROR WriteSingleClusterData(const Access::SubjectDescriptor & aSubjectDescriptor, const ConcreteDataAttributePath & aPath, TLV::TLVReader & aReader, WriteHandler * apWriteHandler) { CHIP_ERROR err = CHIP_NO_ERROR; - ConcreteAttributePath attributePath(2, 3, 4); + ConcreteDataAttributePath attributePath(2, 3, 4); err = apWriteHandler->AddStatus(attributePath, Protocols::InteractionModel::Status::Success); return err; } diff --git a/src/app/tests/suites/TestCluster.yaml b/src/app/tests/suites/TestCluster.yaml index 36ed3409a42758..093315f0aae6e5 100644 --- a/src/app/tests/suites/TestCluster.yaml +++ b/src/app/tests/suites/TestCluster.yaml @@ -858,7 +858,7 @@ tests: arguments: value: "" - - label: "Read attribute LIST_LONG_OCTET_STRING" + - label: "Read attribute LIST_LONG_OCTET_STRING (for chunked read)" command: "readAttribute" attribute: "list_long_octet_string" response: @@ -870,6 +870,32 @@ tests: "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", ] + - label: "Write attribute LIST_LONG_OCTET_STRING (for chunked write)" + command: "writeAttribute" + attribute: "list_long_octet_string" + arguments: + value: + [ + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", + ] + + - label: "Read attribute LIST_LONG_OCTET_STRING (for chunked read)" + command: "readAttribute" + attribute: "list_long_octet_string" + response: + value: + [ + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", + ] + # Tests for Epoch Microseconds - label: "Read attribute EPOCH_US Default Value" diff --git a/src/app/util/ember-compatibility-functions.cpp b/src/app/util/ember-compatibility-functions.cpp index f2b39780d5e003..f7bc0ab2872bdd 100644 --- a/src/app/util/ember-compatibility-functions.cpp +++ b/src/app/util/ember-compatibility-functions.cpp @@ -904,14 +904,9 @@ CHIP_ERROR prepareWriteData(const EmberAfAttributeMetadata * attributeMetadata, } } // namespace -// TODO: Refactor WriteSingleClusterData and all dependent functions to take ConcreteAttributePath instead of ClusterInfo -// as the input argument. -CHIP_ERROR WriteSingleClusterData(const SubjectDescriptor & aSubjectDescriptor, ClusterInfo & aClusterInfo, +CHIP_ERROR WriteSingleClusterData(const SubjectDescriptor & aSubjectDescriptor, const ConcreteDataAttributePath & aPath, TLV::TLVReader & aReader, WriteHandler * apWriteHandler) { - // Named aPath for now to reduce the amount of code change that needs to - // happen when the above TODO is resolved. - ConcreteDataAttributePath aPath(aClusterInfo.mEndpointId, aClusterInfo.mClusterId, aClusterInfo.mAttributeId); const EmberAfAttributeMetadata * attributeMetadata = emberAfLocateAttributeMetadata(aPath.mEndpointId, aPath.mClusterId, aPath.mAttributeId, CLUSTER_MASK_SERVER); @@ -928,7 +923,11 @@ CHIP_ERROR WriteSingleClusterData(const SubjectDescriptor & aSubjectDescriptor, { Access::RequestPath requestPath{ .cluster = aPath.mClusterId, .endpoint = aPath.mEndpointId }; Access::Privilege requestPrivilege = RequiredPrivilege::ForWriteAttribute(aPath); - CHIP_ERROR err = Access::GetAccessControl().Check(aSubjectDescriptor, requestPath, requestPrivilege); + CHIP_ERROR err = CHIP_NO_ERROR; + if (!apWriteHandler->ACLCheckCacheHit({ aPath, requestPrivilege })) + { + err = Access::GetAccessControl().Check(aSubjectDescriptor, requestPath, requestPrivilege); + } if (err != CHIP_NO_ERROR) { // Grace period until ACLs are in place @@ -941,6 +940,7 @@ CHIP_ERROR WriteSingleClusterData(const SubjectDescriptor & aSubjectDescriptor, // TODO: when wildcard/group writes are supported, handle them to discard rather than fail with status return apWriteHandler->AddStatus(aPath, Protocols::InteractionModel::Status::UnsupportedAccess); } + apWriteHandler->CacheACLCheckResult({ aPath, requestPrivilege }); } if (attributeMetadata->MustUseTimedWrite() && !apWriteHandler->IsTimedWrite()) @@ -948,7 +948,7 @@ CHIP_ERROR WriteSingleClusterData(const SubjectDescriptor & aSubjectDescriptor, return apWriteHandler->AddStatus(aPath, Protocols::InteractionModel::Status::NeedsTimedInteraction); } - if (auto * attrOverride = findAttributeAccessOverride(aClusterInfo.mEndpointId, aClusterInfo.mClusterId)) + if (auto * attrOverride = findAttributeAccessOverride(aPath.mEndpointId, aPath.mClusterId)) { AttributeValueDecoder valueDecoder(aReader, aSubjectDescriptor); ReturnErrorOnFailure(attrOverride->Write(aPath, valueDecoder)); diff --git a/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml b/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml index 799eccfe2836c4..1bce175846b795 100644 --- a/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml +++ b/src/app/zap-templates/zcl/data-model/chip/test-cluster.xml @@ -149,7 +149,7 @@ limitations under the License. range_restricted_int8s range_restricted_int16u range_restricted_int16s - list_long_octet_string + list_long_octet_string list_fabric_scoped timed_write_boolean diff --git a/src/controller/WriteInteraction.h b/src/controller/WriteInteraction.h index 66b4b8e293259e..24ae88322a9abd 100644 --- a/src/controller/WriteInteraction.h +++ b/src/controller/WriteInteraction.h @@ -18,6 +18,7 @@ #pragma once +#include #include #include #include @@ -50,10 +51,13 @@ class WriteCallback final : public app::WriteClient::Callback using OnDoneCallbackType = std::function; WriteCallback(OnSuccessCallbackType aOnSuccess, OnErrorCallbackType aOnError, OnDoneCallbackType aOnDone) : - mOnSuccess(aOnSuccess), mOnError(aOnError), mOnDone(aOnDone) + mOnSuccess(aOnSuccess), mOnError(aOnError), mOnDone(aOnDone), mCallback(this) {} - void OnResponse(const app::WriteClient * apWriteClient, const app::ConcreteAttributePath & aPath, app::StatusIB status) override + app::WriteClient::Callback * GetChunkedCallback() { return &mCallback; } + + void OnResponse(const app::WriteClient * apWriteClient, const app::ConcreteDataAttributePath & aPath, + app::StatusIB status) override { if (status.IsSuccess()) { @@ -83,6 +87,8 @@ class WriteCallback final : public app::WriteClient::Callback OnSuccessCallbackType mOnSuccess = nullptr; OnErrorCallbackType mOnError = nullptr; OnDoneCallbackType mOnDone = nullptr; + + app::ChunkedWriteCallback mCallback; }; /** @@ -98,21 +104,20 @@ CHIP_ERROR WriteAttribute(const SessionHandle & sessionHandle, chip::EndpointId WriteCallback::OnDoneCallbackType onDoneCb = nullptr) { auto callback = Platform::MakeUnique(onSuccessCb, onErrorCb, onDoneCb); - auto client = Platform::MakeUnique(app::InteractionModelEngine::GetInstance()->GetExchangeManager(), - callback.get(), aTimedWriteTimeoutMs); - VerifyOrReturnError(callback != nullptr, CHIP_ERROR_NO_MEMORY); + + auto client = Platform::MakeUnique(app::InteractionModelEngine::GetInstance()->GetExchangeManager(), + callback->GetChunkedCallback(), aTimedWriteTimeoutMs); VerifyOrReturnError(client != nullptr, CHIP_ERROR_NO_MEMORY); if (sessionHandle->IsGroupSession()) { - ReturnErrorOnFailure( - client->EncodeAttributeWritePayload(chip::app::AttributePathParams(clusterId, attributeId), requestData)); + ReturnErrorOnFailure(client->EncodeAttribute(chip::app::AttributePathParams(clusterId, attributeId), requestData)); } else { ReturnErrorOnFailure( - client->EncodeAttributeWritePayload(chip::app::AttributePathParams(endpointId, clusterId, attributeId), requestData)); + client->EncodeAttribute(chip::app::AttributePathParams(endpointId, clusterId, attributeId), requestData)); } ReturnErrorOnFailure(client->SendWriteRequest(sessionHandle)); diff --git a/src/controller/data_model/controller-clusters.matter b/src/controller/data_model/controller-clusters.matter index cff8148d004dff..cab14873d2b69f 100644 --- a/src/controller/data_model/controller-clusters.matter +++ b/src/controller/data_model/controller-clusters.matter @@ -3371,7 +3371,7 @@ client cluster TestCluster = 1295 { attribute int8s rangeRestrictedInt8s = 39; attribute int16u rangeRestrictedInt16u = 40; attribute int16s rangeRestrictedInt16s = 41; - readonly attribute LONG_OCTET_STRING listLongOctetString[] = 42; + attribute LONG_OCTET_STRING listLongOctetString[] = 42; attribute boolean timedWriteBoolean = 48; attribute boolean generalErrorBoolean = 49; attribute boolean clusterErrorBoolean = 50; diff --git a/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp b/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp index bb2aa7730058bc..975480620aa189 100644 --- a/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp +++ b/src/controller/java/zap-generated/CHIPClustersWrite-JNI.cpp @@ -5572,6 +5572,81 @@ JNI_METHOD(void, TestClusterCluster, writeRangeRestrictedInt16sAttribute) onFailure.release(); } +JNI_METHOD(void, TestClusterCluster, writeListLongOctetStringAttribute) +(JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jbyteArray value, jobject timedWriteTimeoutMs) +{ + chip::DeviceLayer::StackLock lock; + ListFreer listFreer; + using TypeInfo = chip::app::Clusters::TestCluster::Attributes::ListLongOctetString::TypeInfo; + TypeInfo::Type cppValue; + + std::vector> cleanupByteArrays; + std::vector> cleanupStrings; + + { + using ListType_0 = std::remove_reference_t; + using ListMemberType_0 = ListMemberTypeGetter::Type; + jint valueSize; + chip::JniReferences::GetInstance().GetArrayListSize(value, valueSize); + if (valueSize != 0) + { + auto * listHolder_0 = new ListHolder(valueSize); + listFreer.add(listHolder_0); + + for (size_t i_0 = 0; i_0 < static_cast(valueSize); ++i_0) + { + jobject element_0; + chip::JniReferences::GetInstance().GetArrayListItem(value, i_0, element_0); + cleanupByteArrays.push_back( + chip::Platform::MakeUnique(env, static_cast(element_0))); + listHolder_0->mList[i_0] = cleanupByteArrays.back()->byteSpan(); + } + cppValue = ListType_0(listHolder_0->mList, valueSize); + } + else + { + cppValue = ListType_0(); + } + } + + 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()); + + if (timedWriteTimeoutMs == nullptr) + { + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall); + } + else + { + err = cppCluster->WriteAttribute(cppValue, onSuccess->mContext, successFn->mCall, failureFn->mCall, + chip::JniReferences::GetInstance().IntegerToPrimitive(timedWriteTimeoutMs)); + } + VerifyOrReturn( + err == CHIP_NO_ERROR, + chip::AndroidClusterExceptions::GetInstance().ReturnIllegalStateException(env, callback, "Error writing attribute", err)); + + onSuccess.release(); + onFailure.release(); +} + JNI_METHOD(void, TestClusterCluster, writeTimedWriteBooleanAttribute) (JNIEnv * env, jobject self, jlong clusterPtr, jobject callback, jobject value, jobject timedWriteTimeoutMs) { diff --git a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java index 1360fb32c69f8d..d759f31dfe703b 100644 --- a/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java +++ b/src/controller/java/zap-generated/chip/devicecontroller/ChipClusters.java @@ -16778,6 +16778,16 @@ public void readListLongOctetStringAttribute(ListLongOctetStringAttributeCallbac readListLongOctetStringAttribute(chipClusterPtr, callback); } + public void writeListLongOctetStringAttribute( + DefaultClusterCallback callback, ArrayList value) { + writeListLongOctetStringAttribute(chipClusterPtr, callback, value, null); + } + + public void writeListLongOctetStringAttribute( + DefaultClusterCallback callback, ArrayList value, int timedWriteTimeoutMs) { + writeListLongOctetStringAttribute(chipClusterPtr, callback, value, timedWriteTimeoutMs); + } + public void subscribeListLongOctetStringAttribute( ListLongOctetStringAttributeCallback callback, int minInterval, int maxInterval) { subscribeListLongOctetStringAttribute(chipClusterPtr, callback, minInterval, maxInterval); @@ -17977,6 +17987,12 @@ private native void subscribeRangeRestrictedInt16sAttribute( private native void readListLongOctetStringAttribute( long chipClusterPtr, ListLongOctetStringAttributeCallback callback); + private native void writeListLongOctetStringAttribute( + long chipClusterPtr, + DefaultClusterCallback callback, + ArrayList value, + @Nullable Integer timedWriteTimeoutMs); + private native void subscribeListLongOctetStringAttribute( long chipClusterPtr, ListLongOctetStringAttributeCallback callback, diff --git a/src/controller/python/chip/clusters/CHIPClusters.py b/src/controller/python/chip/clusters/CHIPClusters.py index 543bfbad61449a..603bedbe82b3a8 100644 --- a/src/controller/python/chip/clusters/CHIPClusters.py +++ b/src/controller/python/chip/clusters/CHIPClusters.py @@ -5280,6 +5280,7 @@ class ChipClusters: "attributeId": 0x0000002A, "type": "bytes", "reportable": True, + "writable": True, }, 0x00000030: { "attributeName": "TimedWriteBoolean", diff --git a/src/controller/python/chip/clusters/attribute.cpp b/src/controller/python/chip/clusters/attribute.cpp index f1e11d2f804afe..2fd4195cee5f3d 100644 --- a/src/controller/python/chip/clusters/attribute.cpp +++ b/src/controller/python/chip/clusters/attribute.cpp @@ -20,6 +20,7 @@ #include #include +#include #include #include #include @@ -215,9 +216,11 @@ OnWriteDoneCallback gOnWriteDoneCallback = nullptr; class WriteClientCallback : public WriteClient::Callback { public: - WriteClientCallback(PyObject * appContext) : mAppContext(appContext) {} + WriteClientCallback(PyObject * appContext) : mCallback(this), mAppContext(appContext) {} - void OnResponse(const WriteClient * apWriteClient, const ConcreteAttributePath & aPath, app::StatusIB aStatus) override + WriteClient::Callback * GetChunkedCallback() { return &mCallback; } + + void OnResponse(const WriteClient * apWriteClient, const ConcreteDataAttributePath & aPath, app::StatusIB aStatus) override { gOnWriteResponseCallback(mAppContext, aPath.mEndpointId, aPath.mClusterId, aPath.mAttributeId, to_underlying(aStatus.mStatus)); @@ -236,6 +239,7 @@ class WriteClientCallback : public WriteClient::Callback }; private: + ChunkedWriteCallback mCallback; PyObject * mAppContext = nullptr; }; @@ -275,7 +279,7 @@ chip::ChipError::StorageType pychip_WriteClient_WriteAttributes(void * appContex std::unique_ptr callback = std::make_unique(appContext); std::unique_ptr client = std::make_unique( - app::InteractionModelEngine::GetInstance()->GetExchangeManager(), callback.get(), + app::InteractionModelEngine::GetInstance()->GetExchangeManager(), callback->GetChunkedCallback(), timedWriteTimeoutMs != 0 ? Optional(timedWriteTimeoutMs) : Optional::Missing()); va_list args; @@ -294,19 +298,13 @@ chip::ChipError::StorageType pychip_WriteClient_WriteAttributes(void * appContex memcpy(&pathObj, path, sizeof(python::AttributePath)); uint8_t * tlvBuffer = reinterpret_cast(tlv); - TLV::TLVWriter * writer; TLV::TLVReader reader; - - SuccessOrExit(err = client->PrepareAttribute( - chip::app::AttributePathParams(pathObj.endpointId, pathObj.clusterId, pathObj.attributeId))); - VerifyOrExit((writer = client->GetAttributeDataIBTLVWriter()) != nullptr, err = CHIP_ERROR_INCORRECT_STATE); - reader.Init(tlvBuffer, static_cast(length)); reader.Next(); - SuccessOrExit( - err = writer->CopyElement(chip::TLV::ContextTag(to_underlying(chip::app::AttributeDataIB::Tag::kData)), reader)); - SuccessOrExit(err = client->FinishAttribute()); + SuccessOrExit( + err = client->PutPreencodedAttribute( + chip::app::ConcreteDataAttributePath(pathObj.endpointId, pathObj.clusterId, pathObj.attributeId), reader)); } } diff --git a/src/controller/python/test/test_scripts/cluster_objects.py b/src/controller/python/test/test_scripts/cluster_objects.py index 38a5020329cc60..02c17615e0bf0c 100644 --- a/src/controller/python/test/test_scripts/cluster_objects.py +++ b/src/controller/python/test/test_scripts/cluster_objects.py @@ -103,6 +103,7 @@ async def SendCommandWithResponse(cls, devCtrl): @classmethod async def SendWriteRequest(cls, devCtrl): + logger.info("1: Trivial writes (multiple attributes)") res = await devCtrl.WriteAttribute(nodeid=NODE_ID, attributes=[ (0, Clusters.Basic.Attributes.NodeLabel( @@ -117,12 +118,26 @@ async def SendWriteRequest(cls, devCtrl): AttributeId=6), Status=chip.interaction_model.Status.InvalidValue) ] + logger.info(f"Received WriteResponse: {res}") if res != expectedRes: for i in range(len(res)): if res[i] != expectedRes[i]: logger.error( f"Item {i} is not expected, expect {expectedRes[i]} got {res[i]}") - raise AssertionError("Read returned unexpected result.") + raise AssertionError("Write returned unexpected result.") + + logger.info("2: Write chunked list") + res = await devCtrl.WriteAttribute(nodeid=NODE_ID, + attributes=[(1, Clusters.TestCluster.Attributes.ListLongOctetString([b"0123456789abcdef" * 32] * 5))]) + expectedRes = [ + AttributeStatus(Path=AttributePath( + EndpointId=1, Attribute=Clusters.TestCluster.Attributes.ListLongOctetString), Status=chip.interaction_model.Status.Success), + ] + + logger.info(f"Received WriteResponse: {res}") + if res != expectedRes: + logger.error(f"Expect {expectedRes} got {res}") + raise AssertionError("Write returned unexpected result.") @classmethod async def TestSubscribeAttribute(cls, devCtrl): @@ -346,9 +361,10 @@ async def RunTest(cls, devCtrl): await cls.RoundTripTestWithBadEndpoint(devCtrl) await cls.SendCommandWithResponse(devCtrl) await cls.TestReadEventRequests(devCtrl, 1) - await cls.SendWriteRequest(devCtrl) await cls.TestReadAttributeRequests(devCtrl) await cls.TestSubscribeAttribute(devCtrl) + # Note: Write will change some attribute values, always put it after read tests + await cls.SendWriteRequest(devCtrl) await cls.TestTimedRequest(devCtrl) except Exception as ex: logger.error( diff --git a/src/controller/tests/BUILD.gn b/src/controller/tests/BUILD.gn index 563c32e6f36ed6..5d3758c83c6710 100644 --- a/src/controller/tests/BUILD.gn +++ b/src/controller/tests/BUILD.gn @@ -27,6 +27,7 @@ chip_test_suite("tests") { chip_device_platform != "esp32") { test_sources += [ "TestServerCommandDispatch.cpp" ] test_sources += [ "TestReadChunking.cpp" ] + test_sources += [ "TestWriteChunking.cpp" ] } cflags = [ "-Wconversion" ] diff --git a/src/controller/tests/TestWriteChunking.cpp b/src/controller/tests/TestWriteChunking.cpp new file mode 100644 index 00000000000000..876921778bd5b8 --- /dev/null +++ b/src/controller/tests/TestWriteChunking.cpp @@ -0,0 +1,336 @@ +/* + * + * Copyright (c) 2022 Project CHIP Authors + * All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "app-common/zap-generated/ids/Attributes.h" +#include "app-common/zap-generated/ids/Clusters.h" +#include "app/ConcreteAttributePath.h" +#include "protocols/interaction_model/Constants.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using TestContext = chip::Test::AppContext; +using namespace chip; +using namespace chip::app::Clusters; + +namespace { + +uint32_t gIterationCount = 0; +nlTestSuite * gSuite = nullptr; + +// +// The generated endpoint_config for the controller app has Endpoint 1 +// already used in the fixed endpoint set of size 1. Consequently, let's use the next +// number higher than that for our dynamic test endpoint. +// +constexpr EndpointId kTestEndpointId = 2; +constexpr AttributeId kTestListAttribute = 6; +constexpr uint32_t kTestListLength = 5; + +// We don't really care about the content, we just need a buffer. +uint8_t sByteSpanData[app::kMaxSecureSduLengthBytes]; + +class TestWriteChunking +{ +public: + TestWriteChunking() {} + static void TestListChunking(nlTestSuite * apSuite, void * apContext); + static void TestBadChunking(nlTestSuite * apSuite, void * apContext); + +private: +}; + +//clang-format off +DECLARE_DYNAMIC_ATTRIBUTE_LIST_BEGIN(testClusterAttrsOnEndpoint) +DECLARE_DYNAMIC_ATTRIBUTE(kTestListAttribute, ARRAY, 1, ATTRIBUTE_MASK_WRITABLE), DECLARE_DYNAMIC_ATTRIBUTE_LIST_END(); + +DECLARE_DYNAMIC_CLUSTER_LIST_BEGIN(testEndpointClusters) +DECLARE_DYNAMIC_CLUSTER(TestCluster::Id, testClusterAttrsOnEndpoint, nullptr, nullptr), DECLARE_DYNAMIC_CLUSTER_LIST_END; + +DECLARE_DYNAMIC_ENDPOINT(testEndpoint, testEndpointClusters); + +DataVersion dataVersionStorage[ArraySize(testEndpointClusters)]; + +//clang-format on + +class TestWriteCallback : public app::WriteClient::Callback +{ +public: + void OnResponse(const app::WriteClient * apWriteClient, const app::ConcreteDataAttributePath & aPath, + app::StatusIB status) override + { + if (status.mStatus == Protocols::InteractionModel::Status::Success) + { + mSuccessCount++; + } + else + { + mErrorCount++; + } + } + + void OnError(const app::WriteClient * apWriteClient, CHIP_ERROR aError) override { mErrorCount++; } + + void OnDone(app::WriteClient * apWriteClient) override { mOnDoneCount++; } + + uint32_t mSuccessCount = 0; + uint32_t mErrorCount = 0; + uint32_t mOnDoneCount = 0; +}; + +class TestAttrAccess : public app::AttributeAccessInterface +{ +public: + // Register for the Test Cluster cluster on all endpoints. + TestAttrAccess() : AttributeAccessInterface(Optional::Missing(), TestCluster::Id) {} + + CHIP_ERROR Read(const app::ConcreteReadAttributePath & aPath, app::AttributeValueEncoder & aEncoder) override; + CHIP_ERROR Write(const app::ConcreteDataAttributePath & aPath, app::AttributeValueDecoder & aDecoder) override; +} testServer; + +CHIP_ERROR TestAttrAccess::Read(const app::ConcreteReadAttributePath & aPath, app::AttributeValueEncoder & aEncoder) +{ + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; +} + +CHIP_ERROR TestAttrAccess::Write(const app::ConcreteDataAttributePath & aPath, app::AttributeValueDecoder & aDecoder) +{ + // We only care about the number of attribute data. + if (!aPath.IsListItemOperation()) + { + app::DataModel::DecodableList list; + CHIP_ERROR err = aDecoder.Decode(list); + ChipLogError(Zcl, "Decode result: %s", err.AsString()); + return err; + } + else if (aPath.mListOp == app::ConcreteDataAttributePath::ListOperation::AppendItem) + { + ByteSpan listItem; + CHIP_ERROR err = aDecoder.Decode(listItem); + ChipLogError(Zcl, "Decode result: %s", err.AsString()); + return err; + } + else + { + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; + } +} + +/* + * This validates all the various corner cases encountered during chunking by artificially reducing the size of a packet buffer used + * to encode attribute data to force chunking to happen over multiple packets even with a small number of attributes and then slowly + * increasing the available size by 1 byte in each test iteration and re-running the write request generation logic. This 1-byte + * incremental approach sweeps through from a base scenario of N attributes fitting in a write request chunk, to eventually + * resulting in N+1 attributes fitting in a write request chunk. + * + * This will cause all the various corner cases encountered of closing out the various containers within the write request and + * thoroughly and definitely validate those edge cases. + */ +void TestWriteChunking::TestListChunking(nlTestSuite * apSuite, void * apContext) +{ + TestContext & ctx = *static_cast(apContext); + auto sessionHandle = ctx.GetSessionBobToAlice(); + + // Initialize the ember side server logic + InitDataModelHandler(&ctx.GetExchangeManager()); + + // Register our fake dynamic endpoint. + emberAfSetDynamicEndpoint(0, kTestEndpointId, &testEndpoint, 0, 0, Span(dataVersionStorage)); + + // Register our fake attribute access interface. + registerAttributeAccessOverride(&testServer); + + app::AttributePathParams attributePath(kTestEndpointId, app::Clusters::TestCluster::Id, kTestListAttribute); + // + // We've empirically determined that by reserving 950 bytes in the packet buffer, we can fit 2 + // AttributeDataIBs into the packet. ~30-40 bytes covers a single write chunk, but let's 2-3x that + // to ensure we'll sweep from fitting 2 chunks to 3-4 chunks. + // + for (int i = 100; i > 0; i--) + { + CHIP_ERROR err = CHIP_NO_ERROR; + TestWriteCallback writeCallback; + + ChipLogDetail(DataManagement, "Running iteration %d\n", i); + + gIterationCount = (uint32_t) i; + + app::WriteClient writeClient(&ctx.GetExchangeManager(), &writeCallback, Optional::Missing(), + static_cast(850 + i) /* reserved buffer size */); + + ByteSpan list[kTestListLength]; + + err = writeClient.EncodeAttribute(attributePath, app::DataModel::List(list, kTestListLength)); + NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + + err = writeClient.SendWriteRequest(sessionHandle); + NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + + // + // Service the IO + Engine till we get a ReportEnd callback on the client. + // Since bugs can happen, we don't want this test to never stop, so create a ceiling for how many + // times this can run without seeing expected results. + // + for (int j = 0; j < 10 && writeCallback.mOnDoneCount == 0; j++) + { + ctx.DrainAndServiceIO(); + } + + NL_TEST_ASSERT(apSuite, + writeCallback.mSuccessCount == kTestListLength + 1 /* an extra item for the empty list at the beginning */); + NL_TEST_ASSERT(apSuite, writeCallback.mErrorCount == 0); + NL_TEST_ASSERT(apSuite, writeCallback.mOnDoneCount == 1); + + NL_TEST_ASSERT(apSuite, ctx.GetExchangeManager().GetNumActiveExchanges() == 0); + + // + // Stop the test if we detected an error. Otherwise, it'll be difficult to read the logs. + // + if (apSuite->flagError) + { + break; + } + } +} + +// We encode a pretty large write payload to test the corner cases related to message layer and secure session overheads. +// The test should gurantee that if encode returns no error, the send should also success. +// As the actual overhead may change, we will test over a few possible payload lengths, from 850 to MTU used in write clients. +void TestWriteChunking::TestBadChunking(nlTestSuite * apSuite, void * apContext) +{ + TestContext & ctx = *static_cast(apContext); + auto sessionHandle = ctx.GetSessionBobToAlice(); + + bool atLeastOneRequestSent = false; + bool atLeastOneRequestFailed = false; + + // Initialize the ember side server logic + InitDataModelHandler(&ctx.GetExchangeManager()); + + // Register our fake dynamic endpoint. + emberAfSetDynamicEndpoint(0, kTestEndpointId, &testEndpoint, 0, 0, Span(dataVersionStorage)); + + // Register our fake attribute access interface. + registerAttributeAccessOverride(&testServer); + + app::AttributePathParams attributePath(kTestEndpointId, app::Clusters::TestCluster::Id, kTestListAttribute); + + for (int i = 850; i < static_cast(chip::app::kMaxSecureSduLengthBytes); i++) + { + CHIP_ERROR err = CHIP_NO_ERROR; + TestWriteCallback writeCallback; + + ChipLogDetail(DataManagement, "Running iteration with OCTET_STRING length = %d\n", i); + + gIterationCount = (uint32_t) i; + + app::WriteClient writeClient(&ctx.GetExchangeManager(), &writeCallback, Optional::Missing()); + + ByteSpan list[kTestListLength]; + for (uint8_t j = 0; j < kTestListLength; j++) + { + list[j] = ByteSpan(sByteSpanData, static_cast(i)); + } + + err = writeClient.EncodeAttribute(attributePath, app::DataModel::List(list, kTestListLength)); + if (err == CHIP_ERROR_NO_MEMORY || err == CHIP_ERROR_BUFFER_TOO_SMALL) + { + // This kind of error is expected. + atLeastOneRequestFailed = true; + continue; + } + + atLeastOneRequestSent = true; + + // If we successfully encoded the attribute, then we must be able to send the message. + err = writeClient.SendWriteRequest(sessionHandle); + NL_TEST_ASSERT(apSuite, err == CHIP_NO_ERROR); + + // + // Service the IO + Engine till we get a ReportEnd callback on the client. + // Since bugs can happen, we don't want this test to never stop, so create a ceiling for how many + // times this can run without seeing expected results. + // + for (int j = 0; j < 10 && writeCallback.mOnDoneCount == 0; j++) + { + ctx.DrainAndServiceIO(); + } + + NL_TEST_ASSERT(apSuite, + writeCallback.mSuccessCount == kTestListLength + 1 /* an extra item for the empty list at the beginning */); + NL_TEST_ASSERT(apSuite, writeCallback.mErrorCount == 0); + NL_TEST_ASSERT(apSuite, writeCallback.mOnDoneCount == 1); + + NL_TEST_ASSERT(apSuite, ctx.GetExchangeManager().GetNumActiveExchanges() == 0); + + // + // Stop the test if we detected an error. Otherwise, it'll be difficult to read the logs. + // + if (apSuite->flagError) + { + break; + } + } + NL_TEST_ASSERT(apSuite, ctx.GetExchangeManager().GetNumActiveExchanges() == 0); + NL_TEST_ASSERT(apSuite, atLeastOneRequestSent && atLeastOneRequestFailed); +} + +// clang-format off +const nlTest sTests[] = +{ + NL_TEST_DEF("TestListChunking", TestWriteChunking::TestListChunking), + NL_TEST_DEF("TestBadChunking", TestWriteChunking::TestBadChunking), + NL_TEST_SENTINEL() +}; + +// clang-format on + +// clang-format off +nlTestSuite sSuite = +{ + "TestWriteChunking", + &sTests[0], + TestContext::InitializeAsync, + TestContext::Finalize +}; +// clang-format on + +} // namespace + +int TestWriteChunkingTests() +{ + TestContext gContext; + gSuite = &sSuite; + nlTestRunner(&sSuite, &gContext); + return (nlTestRunnerStats(&sSuite)); +} + +CHIP_REGISTER_TEST_SUITE(TestWriteChunkingTests) diff --git a/src/controller/tests/data_model/TestCommands.cpp b/src/controller/tests/data_model/TestCommands.cpp index d13f08f83faabd..aedc62f28527d2 100644 --- a/src/controller/tests/data_model/TestCommands.cpp +++ b/src/controller/tests/data_model/TestCommands.cpp @@ -156,7 +156,7 @@ CHIP_ERROR ReadSingleClusterData(const Access::SubjectDescriptor & aSubjectDescr return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; } -CHIP_ERROR WriteSingleClusterData(const Access::SubjectDescriptor & aSubjectDescriptor, ClusterInfo & aClusterInfo, +CHIP_ERROR WriteSingleClusterData(const Access::SubjectDescriptor & aSubjectDescriptor, const ConcreteDataAttributePath & aPath, TLV::TLVReader & aReader, WriteHandler * aWriteHandler) { return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; diff --git a/src/controller/tests/data_model/TestRead.cpp b/src/controller/tests/data_model/TestRead.cpp index 52ba22a6624937..dcf98a40e31758 100644 --- a/src/controller/tests/data_model/TestRead.cpp +++ b/src/controller/tests/data_model/TestRead.cpp @@ -148,7 +148,7 @@ CHIP_ERROR ReadSingleClusterData(const Access::SubjectDescriptor & aSubjectDescr return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; } -CHIP_ERROR WriteSingleClusterData(const Access::SubjectDescriptor & aSubjectDescriptor, ClusterInfo & aClusterInfo, +CHIP_ERROR WriteSingleClusterData(const Access::SubjectDescriptor & aSubjectDescriptor, const ConcreteDataAttributePath & aPath, TLV::TLVReader & aReader, WriteHandler * aWriteHandler) { return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; diff --git a/src/controller/tests/data_model/TestWrite.cpp b/src/controller/tests/data_model/TestWrite.cpp index be60e8317add34..e97feaec9ec7b7 100644 --- a/src/controller/tests/data_model/TestWrite.cpp +++ b/src/controller/tests/data_model/TestWrite.cpp @@ -31,7 +31,9 @@ using TestContext = chip::Test::AppContext; using namespace chip; +using namespace chip::app; using namespace chip::app::Clusters; +using namespace chip::app::Clusters::TestCluster; using namespace chip::Protocols; namespace { @@ -80,37 +82,50 @@ CHIP_ERROR ReadSingleClusterData(const Access::SubjectDescriptor & aSubjectDescr return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; } -CHIP_ERROR WriteSingleClusterData(const Access::SubjectDescriptor & aSubjectDescriptor, ClusterInfo & aClusterInfo, +CHIP_ERROR WriteSingleClusterData(const Access::SubjectDescriptor & aSubjectDescriptor, const ConcreteDataAttributePath & aPath, TLV::TLVReader & aReader, WriteHandler * aWriteHandler) { - if (aClusterInfo.mClusterId == TestCluster::Id && - aClusterInfo.mAttributeId == TestCluster::Attributes::ListStructOctetString::TypeInfo::GetAttributeId()) + static ListIndex listStructOctetStringElementCount = 0; + if (aPath.mClusterId == TestCluster::Id && aPath.mAttributeId == Attributes::ListStructOctetString::TypeInfo::GetAttributeId()) { if (responseDirective == kSendAttributeSuccess) { - TestCluster::Attributes::ListStructOctetString::TypeInfo::DecodableType value; + if (!aPath.IsListOperation() || aPath.mListOp == ConcreteDataAttributePath::ListOperation::ReplaceAll) + { - ReturnErrorOnFailure(DataModel::Decode(aReader, value)); + Attributes::ListStructOctetString::TypeInfo::DecodableType value; - auto iter = value.begin(); - uint8_t i = 0; - while (iter.Next()) - { - auto & item = iter.GetValue(); + ReturnErrorOnFailure(DataModel::Decode(aReader, value)); - VerifyOrReturnError(item.fabricIndex == i, CHIP_ERROR_INVALID_ARGUMENT); - i++; - } + auto iter = value.begin(); + listStructOctetStringElementCount = 0; + while (iter.Next()) + { + auto & item = iter.GetValue(); - VerifyOrReturnError(i == 4, CHIP_ERROR_INVALID_ARGUMENT); + VerifyOrReturnError(item.fabricIndex == listStructOctetStringElementCount, CHIP_ERROR_INVALID_ARGUMENT); + listStructOctetStringElementCount++; + } - ConcreteAttributePath attributePath(aClusterInfo.mClusterId, aClusterInfo.mEndpointId, aClusterInfo.mAttributeId); - aWriteHandler->AddStatus(attributePath, Protocols::InteractionModel::Status::Success); + aWriteHandler->AddStatus(aPath, Protocols::InteractionModel::Status::Success); + } + else if (aPath.mListOp == ConcreteDataAttributePath::ListOperation::AppendItem) + { + Structs::TestListStructOctet::DecodableType item; + ReturnErrorOnFailure(DataModel::Decode(aReader, item)); + VerifyOrReturnError(item.fabricIndex == listStructOctetStringElementCount, CHIP_ERROR_INVALID_ARGUMENT); + listStructOctetStringElementCount++; + + aWriteHandler->AddStatus(aPath, Protocols::InteractionModel::Status::Success); + } + else + { + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; + } } else { - ConcreteAttributePath attributePath(aClusterInfo.mClusterId, aClusterInfo.mEndpointId, aClusterInfo.mAttributeId); - aWriteHandler->AddStatus(attributePath, Protocols::InteractionModel::Status::Failure); + aWriteHandler->AddStatus(aPath, Protocols::InteractionModel::Status::Failure); } return CHIP_NO_ERROR; @@ -157,11 +172,11 @@ void TestWriteInteraction::TestDataResponse(nlTestSuite * apSuite, void * apCont // Passing of stack variables by reference is only safe because of synchronous completion of the interaction. Otherwise, it's // not safe to do so. - auto onSuccessCb = [&onSuccessCbInvoked](const app::ConcreteAttributePath & attributePath) { onSuccessCbInvoked = true; }; + auto onSuccessCb = [&onSuccessCbInvoked](const ConcreteAttributePath & attributePath) { onSuccessCbInvoked = true; }; // Passing of stack variables by reference is only safe because of synchronous completion of the interaction. Otherwise, it's // not safe to do so. - auto onFailureCb = [&onFailureCbInvoked](const app::ConcreteAttributePath * attributePath, CHIP_ERROR aError) { + auto onFailureCb = [&onFailureCbInvoked](const ConcreteAttributePath * attributePath, CHIP_ERROR aError) { onFailureCbInvoked = true; }; @@ -180,8 +195,8 @@ void TestWriteInteraction::TestAttributeError(nlTestSuite * apSuite, void * apCo TestContext & ctx = *static_cast(apContext); auto sessionHandle = ctx.GetSessionBobToAlice(); bool onSuccessCbInvoked = false, onFailureCbInvoked = false; - TestCluster::Attributes::ListStructOctetString::TypeInfo::Type value; - TestCluster::Structs::TestListStructOctet::Type valueBuf[4]; + Attributes::ListStructOctetString::TypeInfo::Type value; + Structs::TestListStructOctet::Type valueBuf[4]; value = valueBuf; @@ -196,22 +211,22 @@ void TestWriteInteraction::TestAttributeError(nlTestSuite * apSuite, void * apCo // Passing of stack variables by reference is only safe because of synchronous completion of the interaction. Otherwise, it's // not safe to do so. - auto onSuccessCb = [&onSuccessCbInvoked](const app::ConcreteAttributePath & attributePath) { onSuccessCbInvoked = true; }; + auto onSuccessCb = [&onSuccessCbInvoked](const ConcreteAttributePath & attributePath) { onSuccessCbInvoked = true; }; // Passing of stack variables by reference is only safe because of synchronous completion of the interaction. Otherwise, it's // not safe to do so. - auto onFailureCb = [apSuite, &onFailureCbInvoked](const app::ConcreteAttributePath * attributePath, CHIP_ERROR aError) { + auto onFailureCb = [apSuite, &onFailureCbInvoked](const ConcreteAttributePath * attributePath, CHIP_ERROR aError) { NL_TEST_ASSERT(apSuite, attributePath != nullptr); onFailureCbInvoked = true; }; - chip::Controller::WriteAttribute(sessionHandle, kTestEndpointId, - value, onSuccessCb, onFailureCb); + Controller::WriteAttribute(sessionHandle, kTestEndpointId, value, onSuccessCb, + onFailureCb); ctx.DrainAndServiceIO(); NL_TEST_ASSERT(apSuite, !onSuccessCbInvoked && onFailureCbInvoked); - NL_TEST_ASSERT(apSuite, chip::app::InteractionModelEngine::GetInstance()->GetNumActiveWriteHandlers() == 0); + NL_TEST_ASSERT(apSuite, InteractionModelEngine::GetInstance()->GetNumActiveWriteHandlers() == 0); NL_TEST_ASSERT(apSuite, ctx.GetExchangeManager().GetNumActiveExchanges() == 0); } diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h index 620f0dcbe0c958..341bef4f380193 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.h @@ -5423,6 +5423,7 @@ NS_ASSUME_NONNULL_BEGIN - (void)readAttributeListLongOctetStringWithCompletionHandler:(void (^)(NSArray * _Nullable value, NSError * _Nullable error))completionHandler; +- (void)writeAttributeListLongOctetStringWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)subscribeAttributeListLongOctetStringWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval subscriptionEstablished: diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm index f6cabdf3ba1f39..261bd1cbe30a90 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPClustersObjc.mm @@ -23104,6 +23104,45 @@ new CHIPTestClusterListLongOctetStringListAttributeCallbackBridge( }); } +- (void)writeAttributeListLongOctetStringWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler +{ + new CHIPDefaultSuccessCallbackBridge( + self.callbackQueue, + ^(id _Nullable ignored, NSError * _Nullable error) { + completionHandler(error); + }, + ^(Cancelable * success, Cancelable * failure) { + ListFreer listFreer; + using TypeInfo = TestCluster::Attributes::ListLongOctetString::TypeInfo; + TypeInfo::Type cppValue; + { + using ListType_0 = std::remove_reference_t; + using ListMemberType_0 = ListMemberTypeGetter::Type; + if (value.count != 0) { + auto * listHolder_0 = new ListHolder(value.count); + if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) { + return CHIP_ERROR_INVALID_ARGUMENT; + } + listFreer.add(listHolder_0); + for (size_t i_0 = 0; i_0 < value.count; ++i_0) { + if (![value[i_0] isKindOfClass:[NSData class]]) { + // Wrong kind of value. + return CHIP_ERROR_INVALID_ARGUMENT; + } + auto element_0 = (NSData *) value[i_0]; + listHolder_0->mList[i_0] = [self asByteSpan:element_0]; + } + cppValue = ListType_0(listHolder_0->mList, value.count); + } else { + cppValue = ListType_0(); + } + } + auto successFn = Callback::FromCancelable(success); + auto failureFn = Callback::FromCancelable(failure); + return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); + }); +} + - (void)subscribeAttributeListLongOctetStringWithMinInterval:(uint16_t)minInterval maxInterval:(uint16_t)maxInterval subscriptionEstablished: diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.h b/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.h index 3e5888b5d0b943..0db7ddab2bf8e0 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.h +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.h @@ -1105,7 +1105,6 @@ NS_ASSUME_NONNULL_BEGIN */ @interface CHIPTestTestCluster : CHIPTestCluster -- (void)writeAttributeListLongOctetStringWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)writeAttributeServerGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler; - (void)writeAttributeClientGeneratedCommandListWithValue:(NSArray * _Nonnull)value diff --git a/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm b/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm index ab354fc884cd75..256048e1292a52 100644 --- a/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm +++ b/src/darwin/Framework/CHIP/zap-generated/CHIPTestClustersObjc.mm @@ -13199,45 +13199,6 @@ @implementation CHIPTestTestCluster return &_cppCluster; } -- (void)writeAttributeListLongOctetStringWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler -{ - new CHIPDefaultSuccessCallbackBridge( - self.callbackQueue, - ^(id _Nullable ignored, NSError * _Nullable error) { - completionHandler(error); - }, - ^(Cancelable * success, Cancelable * failure) { - ListFreer listFreer; - using TypeInfo = TestCluster::Attributes::ListLongOctetString::TypeInfo; - TypeInfo::Type cppValue; - { - using ListType_0 = std::remove_reference_t; - using ListMemberType_0 = ListMemberTypeGetter::Type; - if (value.count != 0) { - auto * listHolder_0 = new ListHolder(value.count); - if (listHolder_0 == nullptr || listHolder_0->mList == nullptr) { - return CHIP_ERROR_INVALID_ARGUMENT; - } - listFreer.add(listHolder_0); - for (size_t i_0 = 0; i_0 < value.count; ++i_0) { - if (![value[i_0] isKindOfClass:[NSData class]]) { - // Wrong kind of value. - return CHIP_ERROR_INVALID_ARGUMENT; - } - auto element_0 = (NSData *) value[i_0]; - listHolder_0->mList[i_0] = [self asByteSpan:element_0]; - } - cppValue = ListType_0(listHolder_0->mList, value.count); - } else { - cppValue = ListType_0(); - } - } - auto successFn = Callback::FromCancelable(success); - auto failureFn = Callback::FromCancelable(failure); - return self.cppCluster.WriteAttribute(cppValue, successFn->mContext, successFn->mCall, failureFn->mCall); - }); -} - - (void)writeAttributeServerGeneratedCommandListWithValue:(NSArray * _Nonnull)value completionHandler:(StatusCompletion)completionHandler { diff --git a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m index 459a73c1d7c3e1..692119e484d4e7 100644 --- a/src/darwin/Framework/CHIPTests/CHIPClustersTests.m +++ b/src/darwin/Framework/CHIPTests/CHIPClustersTests.m @@ -30495,7 +30495,7 @@ - (void)testSendClusterTestCluster_000130_WriteAttribute } - (void)testSendClusterTestCluster_000131_ReadAttribute { - XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST_LONG_OCTET_STRING"]; + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST_LONG_OCTET_STRING (for chunked read)"]; CHIPDevice * device = GetConnectedDevice(); dispatch_queue_t queue = dispatch_get_main_queue(); @@ -30503,7 +30503,7 @@ - (void)testSendClusterTestCluster_000131_ReadAttribute XCTAssertNotNil(cluster); [cluster readAttributeListLongOctetStringWithCompletionHandler:^(NSArray * _Nullable value, NSError * _Nullable err) { - NSLog(@"Read attribute LIST_LONG_OCTET_STRING Error: %@", err); + NSLog(@"Read attribute LIST_LONG_OCTET_STRING (for chunked read) Error: %@", err); XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); @@ -30557,7 +30557,142 @@ - (void)testSendClusterTestCluster_000131_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000132_ReadAttribute +- (void)testSendClusterTestCluster_000132_WriteAttribute +{ + XCTestExpectation * expectation = + [self expectationWithDescription:@"Write attribute LIST_LONG_OCTET_STRING (for chunked write)"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + id listLongOctetStringArgument; + { + NSMutableArray * temp_0 = [[NSMutableArray alloc] init]; + temp_0[0] = [[NSData alloc] + initWithBytes:"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + length:512]; + temp_0[1] = [[NSData alloc] + initWithBytes:"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + length:512]; + temp_0[2] = [[NSData alloc] + initWithBytes:"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + length:512]; + temp_0[3] = [[NSData alloc] + initWithBytes:"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + length:512]; + temp_0[4] = [[NSData alloc] + initWithBytes:"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + length:512]; + listLongOctetStringArgument = temp_0; + } + [cluster writeAttributeListLongOctetStringWithValue:listLongOctetStringArgument + completionHandler:^(NSError * _Nullable err) { + NSLog(@"Write attribute LIST_LONG_OCTET_STRING (for chunked write) Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000133_ReadAttribute +{ + XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST_LONG_OCTET_STRING (for chunked read)"]; + + CHIPDevice * device = GetConnectedDevice(); + dispatch_queue_t queue = dispatch_get_main_queue(); + CHIPTestTestCluster * cluster = [[CHIPTestTestCluster alloc] initWithDevice:device endpoint:1 queue:queue]; + XCTAssertNotNil(cluster); + + [cluster readAttributeListLongOctetStringWithCompletionHandler:^(NSArray * _Nullable value, NSError * _Nullable err) { + NSLog(@"Read attribute LIST_LONG_OCTET_STRING (for chunked read) Error: %@", err); + + XCTAssertEqual([CHIPErrorTestUtils errorToZCLErrorCode:err], 0); + + { + id actualValue = value; + XCTAssertEqual([actualValue count], 5); + XCTAssertTrue([actualValue[0] + isEqualToData: + [[NSData alloc] + initWithBytes:"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789ab" + "cdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123" + "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789ab" + "cdef0123456789abcdef0123456789abcdef0123456789abcdef" + length:512]]); + XCTAssertTrue([actualValue[1] + isEqualToData: + [[NSData alloc] + initWithBytes:"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789ab" + "cdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123" + "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789ab" + "cdef0123456789abcdef0123456789abcdef0123456789abcdef" + length:512]]); + XCTAssertTrue([actualValue[2] + isEqualToData: + [[NSData alloc] + initWithBytes:"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789ab" + "cdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123" + "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789ab" + "cdef0123456789abcdef0123456789abcdef0123456789abcdef" + length:512]]); + XCTAssertTrue([actualValue[3] + isEqualToData: + [[NSData alloc] + initWithBytes:"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789ab" + "cdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123" + "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789ab" + "cdef0123456789abcdef0123456789abcdef0123456789abcdef" + length:512]]); + XCTAssertTrue([actualValue[4] + isEqualToData: + [[NSData alloc] + initWithBytes:"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789ab" + "cdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123" + "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef" + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789ab" + "cdef0123456789abcdef0123456789abcdef0123456789abcdef" + length:512]]); + } + + [expectation fulfill]; + }]; + + [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; +} +- (void)testSendClusterTestCluster_000134_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_US Default Value"]; @@ -30581,7 +30716,7 @@ - (void)testSendClusterTestCluster_000132_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000133_WriteAttribute +- (void)testSendClusterTestCluster_000135_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_US Max Value"]; @@ -30603,7 +30738,7 @@ - (void)testSendClusterTestCluster_000133_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000134_ReadAttribute +- (void)testSendClusterTestCluster_000136_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_US Max Value"]; @@ -30627,7 +30762,7 @@ - (void)testSendClusterTestCluster_000134_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000135_WriteAttribute +- (void)testSendClusterTestCluster_000137_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_US Min Value"]; @@ -30649,7 +30784,7 @@ - (void)testSendClusterTestCluster_000135_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000136_ReadAttribute +- (void)testSendClusterTestCluster_000138_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_US Min Value"]; @@ -30673,7 +30808,7 @@ - (void)testSendClusterTestCluster_000136_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000137_ReadAttribute +- (void)testSendClusterTestCluster_000139_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_S Default Value"]; @@ -30697,7 +30832,7 @@ - (void)testSendClusterTestCluster_000137_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000138_WriteAttribute +- (void)testSendClusterTestCluster_000140_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_S Max Value"]; @@ -30719,7 +30854,7 @@ - (void)testSendClusterTestCluster_000138_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000139_ReadAttribute +- (void)testSendClusterTestCluster_000141_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_S Max Value"]; @@ -30743,7 +30878,7 @@ - (void)testSendClusterTestCluster_000139_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000140_WriteAttribute +- (void)testSendClusterTestCluster_000142_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute EPOCH_S Min Value"]; @@ -30765,7 +30900,7 @@ - (void)testSendClusterTestCluster_000140_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000141_ReadAttribute +- (void)testSendClusterTestCluster_000143_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute EPOCH_S Min Value"]; @@ -30789,7 +30924,7 @@ - (void)testSendClusterTestCluster_000141_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000142_ReadAttribute +- (void)testSendClusterTestCluster_000144_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute UNSUPPORTED"]; @@ -30818,7 +30953,7 @@ - (void)testSendClusterTestCluster_000142_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000143_WriteAttribute +- (void)testSendClusterTestCluster_000145_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Writeattribute UNSUPPORTED"]; @@ -30845,7 +30980,7 @@ - (void)testSendClusterTestCluster_000143_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000144_Test +- (void)testSendClusterTestCluster_000146_Test { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command to unsupported endpoint"]; @@ -30863,7 +30998,7 @@ - (void)testSendClusterTestCluster_000144_Test [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000145_Test +- (void)testSendClusterTestCluster_000147_Test { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command to unsupported cluster"]; @@ -30881,7 +31016,7 @@ - (void)testSendClusterTestCluster_000145_Test [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000146_ReadAttribute +- (void)testSendClusterTestCluster_000148_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute vendor_id Default Value"]; @@ -30905,7 +31040,7 @@ - (void)testSendClusterTestCluster_000146_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000147_WriteAttribute +- (void)testSendClusterTestCluster_000149_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute vendor_id"]; @@ -30927,7 +31062,7 @@ - (void)testSendClusterTestCluster_000147_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000148_ReadAttribute +- (void)testSendClusterTestCluster_000150_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute vendor_id"]; @@ -30951,7 +31086,7 @@ - (void)testSendClusterTestCluster_000148_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000149_WriteAttribute +- (void)testSendClusterTestCluster_000151_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Restore attribute vendor_id"]; @@ -30973,7 +31108,7 @@ - (void)testSendClusterTestCluster_000149_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000150_TestEnumsRequest +- (void)testSendClusterTestCluster_000152_TestEnumsRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send a command with a vendor_id and enum"]; @@ -31006,7 +31141,7 @@ - (void)testSendClusterTestCluster_000150_TestEnumsRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000151_TestStructArgumentRequest +- (void)testSendClusterTestCluster_000153_TestStructArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With Struct Argument and arg1.b is true"]; @@ -31044,7 +31179,7 @@ - (void)testSendClusterTestCluster_000151_TestStructArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000152_TestStructArgumentRequest +- (void)testSendClusterTestCluster_000154_TestStructArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With Struct Argument and arg1.b is false"]; @@ -31082,7 +31217,7 @@ - (void)testSendClusterTestCluster_000152_TestStructArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000153_TestNestedStructArgumentRequest +- (void)testSendClusterTestCluster_000155_TestNestedStructArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With Nested Struct Argument and arg1.c.b is true"]; @@ -31131,7 +31266,7 @@ - (void)testSendClusterTestCluster_000153_TestNestedStructArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000154_TestNestedStructArgumentRequest +- (void)testSendClusterTestCluster_000156_TestNestedStructArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With Nested Struct Argument arg1.c.b is false"]; @@ -31179,7 +31314,7 @@ - (void)testSendClusterTestCluster_000154_TestNestedStructArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000155_TestNestedStructListArgumentRequest +- (void)testSendClusterTestCluster_000157_TestNestedStructListArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With Nested Struct List Argument and all fields b of arg1.d are true"]; @@ -31274,7 +31409,7 @@ - (void)testSendClusterTestCluster_000155_TestNestedStructListArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000156_TestNestedStructListArgumentRequest +- (void)testSendClusterTestCluster_000158_TestNestedStructListArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With Nested Struct List Argument and some fields b of arg1.d are false"]; @@ -31369,7 +31504,7 @@ - (void)testSendClusterTestCluster_000156_TestNestedStructListArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000157_SimpleStructEchoRequest +- (void)testSendClusterTestCluster_000159_SimpleStructEchoRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With Struct Argument and see what we get back"]; @@ -31416,7 +31551,7 @@ - (void)testSendClusterTestCluster_000157_SimpleStructEchoRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000158_TestListInt8UArgumentRequest +- (void)testSendClusterTestCluster_000160_TestListInt8UArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With List of INT8U and none of them is set to 0"]; @@ -31457,7 +31592,7 @@ - (void)testSendClusterTestCluster_000158_TestListInt8UArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000159_TestListInt8UArgumentRequest +- (void)testSendClusterTestCluster_000161_TestListInt8UArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With List of INT8U and one of them is set to 0"]; @@ -31499,7 +31634,7 @@ - (void)testSendClusterTestCluster_000159_TestListInt8UArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000160_TestListInt8UReverseRequest +- (void)testSendClusterTestCluster_000162_TestListInt8UReverseRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With List of INT8U and get it reversed"]; @@ -31548,7 +31683,7 @@ - (void)testSendClusterTestCluster_000160_TestListInt8UReverseRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000161_TestListInt8UReverseRequest +- (void)testSendClusterTestCluster_000163_TestListInt8UReverseRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With empty List of INT8U and get an empty list back"]; @@ -31580,7 +31715,7 @@ - (void)testSendClusterTestCluster_000161_TestListInt8UReverseRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000162_TestListStructArgumentRequest +- (void)testSendClusterTestCluster_000164_TestListStructArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With List of Struct Argument and arg1.b of first item is true"]; @@ -31635,7 +31770,7 @@ - (void)testSendClusterTestCluster_000162_TestListStructArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000163_TestListStructArgumentRequest +- (void)testSendClusterTestCluster_000165_TestListStructArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command With List of Struct Argument and arg1.b of first item is false"]; @@ -31690,7 +31825,7 @@ - (void)testSendClusterTestCluster_000163_TestListStructArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000164_TestListNestedStructListArgumentRequest +- (void)testSendClusterTestCluster_000166_TestListNestedStructListArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription: @@ -31790,7 +31925,7 @@ - (void)testSendClusterTestCluster_000164_TestListNestedStructListArgumentReques [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000165_TestListNestedStructListArgumentRequest +- (void)testSendClusterTestCluster_000167_TestListNestedStructListArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription: @@ -31890,7 +32025,7 @@ - (void)testSendClusterTestCluster_000165_TestListNestedStructListArgumentReques [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000166_WriteAttribute +- (void)testSendClusterTestCluster_000168_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute LIST With List of INT8U and none of them is set to 0"]; @@ -31920,7 +32055,7 @@ - (void)testSendClusterTestCluster_000166_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000167_ReadAttribute +- (void)testSendClusterTestCluster_000169_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST With List of INT8U"]; @@ -31948,7 +32083,7 @@ - (void)testSendClusterTestCluster_000167_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000168_WriteAttribute +- (void)testSendClusterTestCluster_000170_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute LIST With List of OCTET_STRING"]; @@ -31977,7 +32112,7 @@ - (void)testSendClusterTestCluster_000168_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000169_ReadAttribute +- (void)testSendClusterTestCluster_000171_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST With List of OCTET_STRING"]; @@ -32005,7 +32140,7 @@ - (void)testSendClusterTestCluster_000169_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000170_WriteAttribute +- (void)testSendClusterTestCluster_000172_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute LIST With List of LIST_STRUCT_OCTET_STRING"]; @@ -32047,7 +32182,7 @@ - (void)testSendClusterTestCluster_000170_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000171_ReadAttribute +- (void)testSendClusterTestCluster_000173_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute LIST With List of LIST_STRUCT_OCTET_STRING"]; @@ -32088,7 +32223,7 @@ - (void)testSendClusterTestCluster_000171_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000172_TestNullableOptionalRequest +- (void)testSendClusterTestCluster_000174_TestNullableOptionalRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command with optional arg set."]; @@ -32129,7 +32264,7 @@ - (void)testSendClusterTestCluster_000172_TestNullableOptionalRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000173_TestNullableOptionalRequest +- (void)testSendClusterTestCluster_000175_TestNullableOptionalRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send Test Command without its optional arg."]; @@ -32156,7 +32291,7 @@ - (void)testSendClusterTestCluster_000173_TestNullableOptionalRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000174_ReadAttribute +- (void)testSendClusterTestCluster_000176_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read list of structs containing nullables and optionals"]; @@ -32185,7 +32320,7 @@ - (void)testSendClusterTestCluster_000174_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000175_WriteAttribute +- (void)testSendClusterTestCluster_000177_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write list of structs containing nullables and optionals"]; @@ -32222,7 +32357,7 @@ - (void)testSendClusterTestCluster_000175_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000176_ReadAttribute +- (void)testSendClusterTestCluster_000178_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read list of structs containing nullables and optionals after writing"]; @@ -32257,7 +32392,7 @@ - (void)testSendClusterTestCluster_000176_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000177_WriteAttribute +- (void)testSendClusterTestCluster_000179_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BOOLEAN null"]; @@ -32279,7 +32414,7 @@ - (void)testSendClusterTestCluster_000177_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000178_ReadAttribute +- (void)testSendClusterTestCluster_000180_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BOOLEAN null"]; @@ -32303,7 +32438,7 @@ - (void)testSendClusterTestCluster_000178_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000179_WriteAttribute +- (void)testSendClusterTestCluster_000181_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BOOLEAN True"]; @@ -32325,7 +32460,7 @@ - (void)testSendClusterTestCluster_000179_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000180_ReadAttribute +- (void)testSendClusterTestCluster_000182_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BOOLEAN True"]; @@ -32350,7 +32485,7 @@ - (void)testSendClusterTestCluster_000180_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000181_WriteAttribute +- (void)testSendClusterTestCluster_000183_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP8 Max Value"]; @@ -32372,7 +32507,7 @@ - (void)testSendClusterTestCluster_000181_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000182_ReadAttribute +- (void)testSendClusterTestCluster_000184_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP8 Max Value"]; @@ -32397,7 +32532,7 @@ - (void)testSendClusterTestCluster_000182_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000183_WriteAttribute +- (void)testSendClusterTestCluster_000185_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP8 Invalid Value"]; @@ -32419,7 +32554,7 @@ - (void)testSendClusterTestCluster_000183_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000184_ReadAttribute +- (void)testSendClusterTestCluster_000186_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP8 unchanged Value"]; @@ -32444,7 +32579,7 @@ - (void)testSendClusterTestCluster_000184_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000185_WriteAttribute +- (void)testSendClusterTestCluster_000187_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP8 null Value"]; @@ -32466,7 +32601,7 @@ - (void)testSendClusterTestCluster_000185_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000186_ReadAttribute +- (void)testSendClusterTestCluster_000188_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP8 null Value"]; @@ -32490,7 +32625,7 @@ - (void)testSendClusterTestCluster_000186_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000187_WriteAttribute +- (void)testSendClusterTestCluster_000189_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP16 Max Value"]; @@ -32512,7 +32647,7 @@ - (void)testSendClusterTestCluster_000187_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000188_ReadAttribute +- (void)testSendClusterTestCluster_000190_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP16 Max Value"]; @@ -32537,7 +32672,7 @@ - (void)testSendClusterTestCluster_000188_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000189_WriteAttribute +- (void)testSendClusterTestCluster_000191_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP16 Invalid Value"]; @@ -32559,7 +32694,7 @@ - (void)testSendClusterTestCluster_000189_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000190_ReadAttribute +- (void)testSendClusterTestCluster_000192_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP16 unchanged Value"]; @@ -32584,7 +32719,7 @@ - (void)testSendClusterTestCluster_000190_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000191_WriteAttribute +- (void)testSendClusterTestCluster_000193_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP16 null Value"]; @@ -32606,7 +32741,7 @@ - (void)testSendClusterTestCluster_000191_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000192_ReadAttribute +- (void)testSendClusterTestCluster_000194_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP16 null Value"]; @@ -32630,7 +32765,7 @@ - (void)testSendClusterTestCluster_000192_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000193_WriteAttribute +- (void)testSendClusterTestCluster_000195_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP32 Max Value"]; @@ -32652,7 +32787,7 @@ - (void)testSendClusterTestCluster_000193_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000194_ReadAttribute +- (void)testSendClusterTestCluster_000196_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP32 Max Value"]; @@ -32677,7 +32812,7 @@ - (void)testSendClusterTestCluster_000194_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000195_WriteAttribute +- (void)testSendClusterTestCluster_000197_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP32 Invalid Value"]; @@ -32699,7 +32834,7 @@ - (void)testSendClusterTestCluster_000195_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000196_ReadAttribute +- (void)testSendClusterTestCluster_000198_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP32 unchanged Value"]; @@ -32724,7 +32859,7 @@ - (void)testSendClusterTestCluster_000196_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000197_WriteAttribute +- (void)testSendClusterTestCluster_000199_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP32 null Value"]; @@ -32746,7 +32881,7 @@ - (void)testSendClusterTestCluster_000197_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000198_ReadAttribute +- (void)testSendClusterTestCluster_000200_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP32 null Value"]; @@ -32770,7 +32905,7 @@ - (void)testSendClusterTestCluster_000198_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000199_WriteAttribute +- (void)testSendClusterTestCluster_000201_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP64 Max Value"]; @@ -32792,7 +32927,7 @@ - (void)testSendClusterTestCluster_000199_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000200_ReadAttribute +- (void)testSendClusterTestCluster_000202_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP64 Max Value"]; @@ -32817,7 +32952,7 @@ - (void)testSendClusterTestCluster_000200_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000201_WriteAttribute +- (void)testSendClusterTestCluster_000203_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP64 Invalid Value"]; @@ -32839,7 +32974,7 @@ - (void)testSendClusterTestCluster_000201_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000202_ReadAttribute +- (void)testSendClusterTestCluster_000204_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP64 unchanged Value"]; @@ -32864,7 +32999,7 @@ - (void)testSendClusterTestCluster_000202_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000203_WriteAttribute +- (void)testSendClusterTestCluster_000205_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_BITMAP64 null Value"]; @@ -32886,7 +33021,7 @@ - (void)testSendClusterTestCluster_000203_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000204_ReadAttribute +- (void)testSendClusterTestCluster_000206_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_BITMAP64 null Value"]; @@ -32910,7 +33045,7 @@ - (void)testSendClusterTestCluster_000204_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000205_WriteAttribute +- (void)testSendClusterTestCluster_000207_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U Min Value"]; @@ -32932,7 +33067,7 @@ - (void)testSendClusterTestCluster_000205_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000206_ReadAttribute +- (void)testSendClusterTestCluster_000208_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U Min Value"]; @@ -32957,7 +33092,7 @@ - (void)testSendClusterTestCluster_000206_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000207_WriteAttribute +- (void)testSendClusterTestCluster_000209_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U Max Value"]; @@ -32979,7 +33114,7 @@ - (void)testSendClusterTestCluster_000207_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000208_ReadAttribute +- (void)testSendClusterTestCluster_000210_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U Max Value"]; @@ -33004,7 +33139,7 @@ - (void)testSendClusterTestCluster_000208_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000209_WriteAttribute +- (void)testSendClusterTestCluster_000211_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U Invalid Value"]; @@ -33025,7 +33160,7 @@ - (void)testSendClusterTestCluster_000209_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000210_ReadAttribute +- (void)testSendClusterTestCluster_000212_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U unchanged Value"]; @@ -33050,7 +33185,7 @@ - (void)testSendClusterTestCluster_000210_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000211_ReadAttribute +- (void)testSendClusterTestCluster_000213_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U unchanged Value with constraint"]; @@ -33075,7 +33210,7 @@ - (void)testSendClusterTestCluster_000211_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000212_WriteAttribute +- (void)testSendClusterTestCluster_000214_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U null Value"]; @@ -33097,7 +33232,7 @@ - (void)testSendClusterTestCluster_000212_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000213_ReadAttribute +- (void)testSendClusterTestCluster_000215_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U null Value"]; @@ -33121,7 +33256,7 @@ - (void)testSendClusterTestCluster_000213_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000214_ReadAttribute +- (void)testSendClusterTestCluster_000216_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U null Value & range"]; @@ -33153,7 +33288,7 @@ - (void)testSendClusterTestCluster_000214_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000215_ReadAttribute +- (void)testSendClusterTestCluster_000217_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U null Value & not"]; @@ -33179,7 +33314,7 @@ - (void)testSendClusterTestCluster_000215_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000216_WriteAttribute +- (void)testSendClusterTestCluster_000218_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8U Value"]; @@ -33201,7 +33336,7 @@ - (void)testSendClusterTestCluster_000216_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000217_ReadAttribute +- (void)testSendClusterTestCluster_000219_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U Value in range"]; @@ -33233,7 +33368,7 @@ - (void)testSendClusterTestCluster_000217_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000218_ReadAttribute +- (void)testSendClusterTestCluster_000220_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8U notValue OK"]; @@ -33259,7 +33394,7 @@ - (void)testSendClusterTestCluster_000218_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000219_WriteAttribute +- (void)testSendClusterTestCluster_000221_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U Min Value"]; @@ -33281,7 +33416,7 @@ - (void)testSendClusterTestCluster_000219_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000220_ReadAttribute +- (void)testSendClusterTestCluster_000222_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U Min Value"]; @@ -33306,7 +33441,7 @@ - (void)testSendClusterTestCluster_000220_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000221_WriteAttribute +- (void)testSendClusterTestCluster_000223_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U Max Value"]; @@ -33328,7 +33463,7 @@ - (void)testSendClusterTestCluster_000221_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000222_ReadAttribute +- (void)testSendClusterTestCluster_000224_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U Max Value"]; @@ -33353,7 +33488,7 @@ - (void)testSendClusterTestCluster_000222_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000223_WriteAttribute +- (void)testSendClusterTestCluster_000225_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U Invalid Value"]; @@ -33375,7 +33510,7 @@ - (void)testSendClusterTestCluster_000223_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000224_ReadAttribute +- (void)testSendClusterTestCluster_000226_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U unchanged Value"]; @@ -33400,7 +33535,7 @@ - (void)testSendClusterTestCluster_000224_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000225_WriteAttribute +- (void)testSendClusterTestCluster_000227_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U null Value"]; @@ -33422,7 +33557,7 @@ - (void)testSendClusterTestCluster_000225_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000226_ReadAttribute +- (void)testSendClusterTestCluster_000228_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U null Value"]; @@ -33446,7 +33581,7 @@ - (void)testSendClusterTestCluster_000226_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000227_ReadAttribute +- (void)testSendClusterTestCluster_000229_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U null Value & range"]; @@ -33478,7 +33613,7 @@ - (void)testSendClusterTestCluster_000227_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000228_ReadAttribute +- (void)testSendClusterTestCluster_000230_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U null Value & not"]; @@ -33504,7 +33639,7 @@ - (void)testSendClusterTestCluster_000228_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000229_WriteAttribute +- (void)testSendClusterTestCluster_000231_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16U Value"]; @@ -33526,7 +33661,7 @@ - (void)testSendClusterTestCluster_000229_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000230_ReadAttribute +- (void)testSendClusterTestCluster_000232_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U Value in range"]; @@ -33558,7 +33693,7 @@ - (void)testSendClusterTestCluster_000230_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000231_ReadAttribute +- (void)testSendClusterTestCluster_000233_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16U notValue OK"]; @@ -33584,7 +33719,7 @@ - (void)testSendClusterTestCluster_000231_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000232_WriteAttribute +- (void)testSendClusterTestCluster_000234_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U Min Value"]; @@ -33606,7 +33741,7 @@ - (void)testSendClusterTestCluster_000232_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000233_ReadAttribute +- (void)testSendClusterTestCluster_000235_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U Min Value"]; @@ -33631,7 +33766,7 @@ - (void)testSendClusterTestCluster_000233_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000234_WriteAttribute +- (void)testSendClusterTestCluster_000236_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U Max Value"]; @@ -33653,7 +33788,7 @@ - (void)testSendClusterTestCluster_000234_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000235_ReadAttribute +- (void)testSendClusterTestCluster_000237_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U Max Value"]; @@ -33678,7 +33813,7 @@ - (void)testSendClusterTestCluster_000235_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000236_WriteAttribute +- (void)testSendClusterTestCluster_000238_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U Invalid Value"]; @@ -33700,7 +33835,7 @@ - (void)testSendClusterTestCluster_000236_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000237_ReadAttribute +- (void)testSendClusterTestCluster_000239_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U unchanged Value"]; @@ -33725,7 +33860,7 @@ - (void)testSendClusterTestCluster_000237_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000238_WriteAttribute +- (void)testSendClusterTestCluster_000240_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U null Value"]; @@ -33747,7 +33882,7 @@ - (void)testSendClusterTestCluster_000238_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000239_ReadAttribute +- (void)testSendClusterTestCluster_000241_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U null Value"]; @@ -33771,7 +33906,7 @@ - (void)testSendClusterTestCluster_000239_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000240_ReadAttribute +- (void)testSendClusterTestCluster_000242_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U null Value & range"]; @@ -33803,7 +33938,7 @@ - (void)testSendClusterTestCluster_000240_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000241_ReadAttribute +- (void)testSendClusterTestCluster_000243_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U null Value & not"]; @@ -33829,7 +33964,7 @@ - (void)testSendClusterTestCluster_000241_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000242_WriteAttribute +- (void)testSendClusterTestCluster_000244_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32U Value"]; @@ -33851,7 +33986,7 @@ - (void)testSendClusterTestCluster_000242_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000243_ReadAttribute +- (void)testSendClusterTestCluster_000245_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U Value in range"]; @@ -33883,7 +34018,7 @@ - (void)testSendClusterTestCluster_000243_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000244_ReadAttribute +- (void)testSendClusterTestCluster_000246_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32U notValue OK"]; @@ -33909,7 +34044,7 @@ - (void)testSendClusterTestCluster_000244_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000245_WriteAttribute +- (void)testSendClusterTestCluster_000247_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U Min Value"]; @@ -33931,7 +34066,7 @@ - (void)testSendClusterTestCluster_000245_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000246_ReadAttribute +- (void)testSendClusterTestCluster_000248_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U Min Value"]; @@ -33956,7 +34091,7 @@ - (void)testSendClusterTestCluster_000246_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000247_WriteAttribute +- (void)testSendClusterTestCluster_000249_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U Max Value"]; @@ -33978,7 +34113,7 @@ - (void)testSendClusterTestCluster_000247_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000248_ReadAttribute +- (void)testSendClusterTestCluster_000250_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U Max Value"]; @@ -34003,7 +34138,7 @@ - (void)testSendClusterTestCluster_000248_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000249_WriteAttribute +- (void)testSendClusterTestCluster_000251_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U Invalid Value"]; @@ -34025,7 +34160,7 @@ - (void)testSendClusterTestCluster_000249_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000250_ReadAttribute +- (void)testSendClusterTestCluster_000252_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U unchanged Value"]; @@ -34050,7 +34185,7 @@ - (void)testSendClusterTestCluster_000250_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000251_WriteAttribute +- (void)testSendClusterTestCluster_000253_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U null Value"]; @@ -34072,7 +34207,7 @@ - (void)testSendClusterTestCluster_000251_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000252_ReadAttribute +- (void)testSendClusterTestCluster_000254_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U null Value"]; @@ -34096,7 +34231,7 @@ - (void)testSendClusterTestCluster_000252_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000253_ReadAttribute +- (void)testSendClusterTestCluster_000255_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U null Value & range"]; @@ -34128,7 +34263,7 @@ - (void)testSendClusterTestCluster_000253_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000254_ReadAttribute +- (void)testSendClusterTestCluster_000256_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U null Value & not"]; @@ -34154,7 +34289,7 @@ - (void)testSendClusterTestCluster_000254_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000255_WriteAttribute +- (void)testSendClusterTestCluster_000257_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64U Value"]; @@ -34176,7 +34311,7 @@ - (void)testSendClusterTestCluster_000255_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000256_ReadAttribute +- (void)testSendClusterTestCluster_000258_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U Value in range"]; @@ -34208,7 +34343,7 @@ - (void)testSendClusterTestCluster_000256_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000257_ReadAttribute +- (void)testSendClusterTestCluster_000259_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64U notValue OK"]; @@ -34234,7 +34369,7 @@ - (void)testSendClusterTestCluster_000257_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000258_WriteAttribute +- (void)testSendClusterTestCluster_000260_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S Min Value"]; @@ -34256,7 +34391,7 @@ - (void)testSendClusterTestCluster_000258_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000259_ReadAttribute +- (void)testSendClusterTestCluster_000261_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S Min Value"]; @@ -34281,7 +34416,7 @@ - (void)testSendClusterTestCluster_000259_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000260_WriteAttribute +- (void)testSendClusterTestCluster_000262_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S Invalid Value"]; @@ -34302,7 +34437,7 @@ - (void)testSendClusterTestCluster_000260_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000261_ReadAttribute +- (void)testSendClusterTestCluster_000263_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S unchanged Value"]; @@ -34327,7 +34462,7 @@ - (void)testSendClusterTestCluster_000261_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000262_WriteAttribute +- (void)testSendClusterTestCluster_000264_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S null Value"]; @@ -34349,7 +34484,7 @@ - (void)testSendClusterTestCluster_000262_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000263_ReadAttribute +- (void)testSendClusterTestCluster_000265_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S null Value"]; @@ -34373,7 +34508,7 @@ - (void)testSendClusterTestCluster_000263_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000264_ReadAttribute +- (void)testSendClusterTestCluster_000266_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S null Value & range"]; @@ -34405,7 +34540,7 @@ - (void)testSendClusterTestCluster_000264_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000265_ReadAttribute +- (void)testSendClusterTestCluster_000267_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S null Value & not"]; @@ -34431,7 +34566,7 @@ - (void)testSendClusterTestCluster_000265_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000266_WriteAttribute +- (void)testSendClusterTestCluster_000268_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT8S Value"]; @@ -34453,7 +34588,7 @@ - (void)testSendClusterTestCluster_000266_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000267_ReadAttribute +- (void)testSendClusterTestCluster_000269_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S Value in range"]; @@ -34485,7 +34620,7 @@ - (void)testSendClusterTestCluster_000267_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000268_ReadAttribute +- (void)testSendClusterTestCluster_000270_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT8S notValue OK"]; @@ -34511,7 +34646,7 @@ - (void)testSendClusterTestCluster_000268_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000269_WriteAttribute +- (void)testSendClusterTestCluster_000271_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S Min Value"]; @@ -34533,7 +34668,7 @@ - (void)testSendClusterTestCluster_000269_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000270_ReadAttribute +- (void)testSendClusterTestCluster_000272_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S Min Value"]; @@ -34558,7 +34693,7 @@ - (void)testSendClusterTestCluster_000270_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000271_WriteAttribute +- (void)testSendClusterTestCluster_000273_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S Invalid Value"]; @@ -34580,7 +34715,7 @@ - (void)testSendClusterTestCluster_000271_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000272_ReadAttribute +- (void)testSendClusterTestCluster_000274_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S unchanged Value"]; @@ -34605,7 +34740,7 @@ - (void)testSendClusterTestCluster_000272_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000273_WriteAttribute +- (void)testSendClusterTestCluster_000275_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S null Value"]; @@ -34627,7 +34762,7 @@ - (void)testSendClusterTestCluster_000273_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000274_ReadAttribute +- (void)testSendClusterTestCluster_000276_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S null Value"]; @@ -34651,7 +34786,7 @@ - (void)testSendClusterTestCluster_000274_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000275_ReadAttribute +- (void)testSendClusterTestCluster_000277_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S null Value & range"]; @@ -34683,7 +34818,7 @@ - (void)testSendClusterTestCluster_000275_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000276_ReadAttribute +- (void)testSendClusterTestCluster_000278_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S null Value & not"]; @@ -34709,7 +34844,7 @@ - (void)testSendClusterTestCluster_000276_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000277_WriteAttribute +- (void)testSendClusterTestCluster_000279_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT16S Value"]; @@ -34731,7 +34866,7 @@ - (void)testSendClusterTestCluster_000277_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000278_ReadAttribute +- (void)testSendClusterTestCluster_000280_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S Value in range"]; @@ -34763,7 +34898,7 @@ - (void)testSendClusterTestCluster_000278_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000279_ReadAttribute +- (void)testSendClusterTestCluster_000281_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT16S notValue OK"]; @@ -34789,7 +34924,7 @@ - (void)testSendClusterTestCluster_000279_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000280_WriteAttribute +- (void)testSendClusterTestCluster_000282_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S Min Value"]; @@ -34811,7 +34946,7 @@ - (void)testSendClusterTestCluster_000280_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000281_ReadAttribute +- (void)testSendClusterTestCluster_000283_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S Min Value"]; @@ -34836,7 +34971,7 @@ - (void)testSendClusterTestCluster_000281_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000282_WriteAttribute +- (void)testSendClusterTestCluster_000284_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S Invalid Value"]; @@ -34858,7 +34993,7 @@ - (void)testSendClusterTestCluster_000282_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000283_ReadAttribute +- (void)testSendClusterTestCluster_000285_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S unchanged Value"]; @@ -34883,7 +35018,7 @@ - (void)testSendClusterTestCluster_000283_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000284_WriteAttribute +- (void)testSendClusterTestCluster_000286_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S null Value"]; @@ -34905,7 +35040,7 @@ - (void)testSendClusterTestCluster_000284_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000285_ReadAttribute +- (void)testSendClusterTestCluster_000287_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S null Value"]; @@ -34929,7 +35064,7 @@ - (void)testSendClusterTestCluster_000285_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000286_ReadAttribute +- (void)testSendClusterTestCluster_000288_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S null Value & range"]; @@ -34961,7 +35096,7 @@ - (void)testSendClusterTestCluster_000286_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000287_ReadAttribute +- (void)testSendClusterTestCluster_000289_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S null Value & not"]; @@ -34987,7 +35122,7 @@ - (void)testSendClusterTestCluster_000287_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000288_WriteAttribute +- (void)testSendClusterTestCluster_000290_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT32S Value"]; @@ -35009,7 +35144,7 @@ - (void)testSendClusterTestCluster_000288_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000289_ReadAttribute +- (void)testSendClusterTestCluster_000291_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S Value in range"]; @@ -35041,7 +35176,7 @@ - (void)testSendClusterTestCluster_000289_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000290_ReadAttribute +- (void)testSendClusterTestCluster_000292_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT32S notValue OK"]; @@ -35067,7 +35202,7 @@ - (void)testSendClusterTestCluster_000290_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000291_WriteAttribute +- (void)testSendClusterTestCluster_000293_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S Min Value"]; @@ -35089,7 +35224,7 @@ - (void)testSendClusterTestCluster_000291_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000292_ReadAttribute +- (void)testSendClusterTestCluster_000294_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S Min Value"]; @@ -35114,7 +35249,7 @@ - (void)testSendClusterTestCluster_000292_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000293_WriteAttribute +- (void)testSendClusterTestCluster_000295_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S Invalid Value"]; @@ -35136,7 +35271,7 @@ - (void)testSendClusterTestCluster_000293_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000294_ReadAttribute +- (void)testSendClusterTestCluster_000296_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S unchanged Value"]; @@ -35161,7 +35296,7 @@ - (void)testSendClusterTestCluster_000294_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000295_WriteAttribute +- (void)testSendClusterTestCluster_000297_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S null Value"]; @@ -35183,7 +35318,7 @@ - (void)testSendClusterTestCluster_000295_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000296_ReadAttribute +- (void)testSendClusterTestCluster_000298_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S null Value"]; @@ -35207,7 +35342,7 @@ - (void)testSendClusterTestCluster_000296_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000297_ReadAttribute +- (void)testSendClusterTestCluster_000299_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S null Value & range"]; @@ -35239,7 +35374,7 @@ - (void)testSendClusterTestCluster_000297_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000298_ReadAttribute +- (void)testSendClusterTestCluster_000300_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S null Value & not"]; @@ -35265,7 +35400,7 @@ - (void)testSendClusterTestCluster_000298_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000299_WriteAttribute +- (void)testSendClusterTestCluster_000301_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_INT64S Value"]; @@ -35287,7 +35422,7 @@ - (void)testSendClusterTestCluster_000299_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000300_ReadAttribute +- (void)testSendClusterTestCluster_000302_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S Value in range"]; @@ -35319,7 +35454,7 @@ - (void)testSendClusterTestCluster_000300_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000301_ReadAttribute +- (void)testSendClusterTestCluster_000303_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_INT64S notValue OK"]; @@ -35345,7 +35480,7 @@ - (void)testSendClusterTestCluster_000301_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000302_WriteAttribute +- (void)testSendClusterTestCluster_000304_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE medium Value"]; @@ -35367,7 +35502,7 @@ - (void)testSendClusterTestCluster_000302_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000303_ReadAttribute +- (void)testSendClusterTestCluster_000305_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE medium Value"]; @@ -35392,7 +35527,7 @@ - (void)testSendClusterTestCluster_000303_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000304_WriteAttribute +- (void)testSendClusterTestCluster_000306_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE largest Value"]; @@ -35414,7 +35549,7 @@ - (void)testSendClusterTestCluster_000304_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000305_ReadAttribute +- (void)testSendClusterTestCluster_000307_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE largest Value"]; @@ -35439,7 +35574,7 @@ - (void)testSendClusterTestCluster_000305_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000306_WriteAttribute +- (void)testSendClusterTestCluster_000308_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE smallest Value"]; @@ -35461,7 +35596,7 @@ - (void)testSendClusterTestCluster_000306_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000307_ReadAttribute +- (void)testSendClusterTestCluster_000309_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE smallest Value"]; @@ -35486,7 +35621,7 @@ - (void)testSendClusterTestCluster_000307_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000308_WriteAttribute +- (void)testSendClusterTestCluster_000310_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE null Value"]; @@ -35508,7 +35643,7 @@ - (void)testSendClusterTestCluster_000308_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000309_ReadAttribute +- (void)testSendClusterTestCluster_000311_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE null Value"]; @@ -35532,7 +35667,7 @@ - (void)testSendClusterTestCluster_000309_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000310_WriteAttribute +- (void)testSendClusterTestCluster_000312_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SINGLE 0 Value"]; @@ -35554,7 +35689,7 @@ - (void)testSendClusterTestCluster_000310_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000311_ReadAttribute +- (void)testSendClusterTestCluster_000313_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SINGLE 0 Value"]; @@ -35579,7 +35714,7 @@ - (void)testSendClusterTestCluster_000311_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000312_WriteAttribute +- (void)testSendClusterTestCluster_000314_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE medium Value"]; @@ -35601,7 +35736,7 @@ - (void)testSendClusterTestCluster_000312_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000313_ReadAttribute +- (void)testSendClusterTestCluster_000315_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE medium Value"]; @@ -35626,7 +35761,7 @@ - (void)testSendClusterTestCluster_000313_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000314_WriteAttribute +- (void)testSendClusterTestCluster_000316_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE largest Value"]; @@ -35648,7 +35783,7 @@ - (void)testSendClusterTestCluster_000314_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000315_ReadAttribute +- (void)testSendClusterTestCluster_000317_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE largest Value"]; @@ -35673,7 +35808,7 @@ - (void)testSendClusterTestCluster_000315_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000316_WriteAttribute +- (void)testSendClusterTestCluster_000318_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE smallest Value"]; @@ -35695,7 +35830,7 @@ - (void)testSendClusterTestCluster_000316_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000317_ReadAttribute +- (void)testSendClusterTestCluster_000319_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE smallest Value"]; @@ -35720,7 +35855,7 @@ - (void)testSendClusterTestCluster_000317_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000318_WriteAttribute +- (void)testSendClusterTestCluster_000320_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE null Value"]; @@ -35742,7 +35877,7 @@ - (void)testSendClusterTestCluster_000318_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000319_ReadAttribute +- (void)testSendClusterTestCluster_000321_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE null Value"]; @@ -35766,7 +35901,7 @@ - (void)testSendClusterTestCluster_000319_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000320_WriteAttribute +- (void)testSendClusterTestCluster_000322_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_DOUBLE 0 Value"]; @@ -35788,7 +35923,7 @@ - (void)testSendClusterTestCluster_000320_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000321_ReadAttribute +- (void)testSendClusterTestCluster_000323_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_DOUBLE 0 Value"]; @@ -35813,7 +35948,7 @@ - (void)testSendClusterTestCluster_000321_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000322_WriteAttribute +- (void)testSendClusterTestCluster_000324_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 Min Value"]; @@ -35835,7 +35970,7 @@ - (void)testSendClusterTestCluster_000322_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000323_ReadAttribute +- (void)testSendClusterTestCluster_000325_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 Min Value"]; @@ -35860,7 +35995,7 @@ - (void)testSendClusterTestCluster_000323_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000324_WriteAttribute +- (void)testSendClusterTestCluster_000326_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 Max Value"]; @@ -35882,7 +36017,7 @@ - (void)testSendClusterTestCluster_000324_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000325_ReadAttribute +- (void)testSendClusterTestCluster_000327_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 Max Value"]; @@ -35907,7 +36042,7 @@ - (void)testSendClusterTestCluster_000325_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000326_WriteAttribute +- (void)testSendClusterTestCluster_000328_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 Invalid Value"]; @@ -35928,7 +36063,7 @@ - (void)testSendClusterTestCluster_000326_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000327_ReadAttribute +- (void)testSendClusterTestCluster_000329_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 unchanged Value"]; @@ -35953,7 +36088,7 @@ - (void)testSendClusterTestCluster_000327_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000328_WriteAttribute +- (void)testSendClusterTestCluster_000330_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM8 null Value"]; @@ -35975,7 +36110,7 @@ - (void)testSendClusterTestCluster_000328_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000329_ReadAttribute +- (void)testSendClusterTestCluster_000331_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM8 null Value"]; @@ -35999,7 +36134,7 @@ - (void)testSendClusterTestCluster_000329_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000330_WriteAttribute +- (void)testSendClusterTestCluster_000332_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 Min Value"]; @@ -36021,7 +36156,7 @@ - (void)testSendClusterTestCluster_000330_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000331_ReadAttribute +- (void)testSendClusterTestCluster_000333_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 Min Value"]; @@ -36046,7 +36181,7 @@ - (void)testSendClusterTestCluster_000331_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000332_WriteAttribute +- (void)testSendClusterTestCluster_000334_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 Max Value"]; @@ -36068,7 +36203,7 @@ - (void)testSendClusterTestCluster_000332_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000333_ReadAttribute +- (void)testSendClusterTestCluster_000335_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 Max Value"]; @@ -36093,7 +36228,7 @@ - (void)testSendClusterTestCluster_000333_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000334_WriteAttribute +- (void)testSendClusterTestCluster_000336_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 Invalid Value"]; @@ -36115,7 +36250,7 @@ - (void)testSendClusterTestCluster_000334_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000335_ReadAttribute +- (void)testSendClusterTestCluster_000337_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 unchanged Value"]; @@ -36140,7 +36275,7 @@ - (void)testSendClusterTestCluster_000335_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000336_WriteAttribute +- (void)testSendClusterTestCluster_000338_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_ENUM16 null Value"]; @@ -36162,7 +36297,7 @@ - (void)testSendClusterTestCluster_000336_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000337_ReadAttribute +- (void)testSendClusterTestCluster_000339_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_ENUM16 null Value"]; @@ -36186,7 +36321,7 @@ - (void)testSendClusterTestCluster_000337_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000338_WriteAttribute +- (void)testSendClusterTestCluster_000340_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SIMPLE_ENUM Min Value"]; @@ -36208,7 +36343,7 @@ - (void)testSendClusterTestCluster_000338_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000339_ReadAttribute +- (void)testSendClusterTestCluster_000341_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SIMPLE_ENUM Min Value"]; @@ -36233,7 +36368,7 @@ - (void)testSendClusterTestCluster_000339_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000340_WriteAttribute +- (void)testSendClusterTestCluster_000342_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SIMPLE_ENUM Max Value"]; @@ -36255,7 +36390,7 @@ - (void)testSendClusterTestCluster_000340_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000341_ReadAttribute +- (void)testSendClusterTestCluster_000343_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SIMPLE_ENUM Max Value"]; @@ -36280,7 +36415,7 @@ - (void)testSendClusterTestCluster_000341_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000342_WriteAttribute +- (void)testSendClusterTestCluster_000344_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SIMPLE_ENUM Invalid Value"]; @@ -36302,7 +36437,7 @@ - (void)testSendClusterTestCluster_000342_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000343_ReadAttribute +- (void)testSendClusterTestCluster_000345_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SIMPLE_ENUM unchanged Value"]; @@ -36327,7 +36462,7 @@ - (void)testSendClusterTestCluster_000343_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000344_WriteAttribute +- (void)testSendClusterTestCluster_000346_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_SIMPLE_ENUM null Value"]; @@ -36349,7 +36484,7 @@ - (void)testSendClusterTestCluster_000344_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000345_ReadAttribute +- (void)testSendClusterTestCluster_000347_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_SIMPLE_ENUM null Value"]; @@ -36373,7 +36508,7 @@ - (void)testSendClusterTestCluster_000345_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000346_ReadAttribute +- (void)testSendClusterTestCluster_000348_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING Default Value"]; @@ -36398,7 +36533,7 @@ - (void)testSendClusterTestCluster_000346_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000347_WriteAttribute +- (void)testSendClusterTestCluster_000349_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_OCTET_STRING"]; @@ -36420,7 +36555,7 @@ - (void)testSendClusterTestCluster_000347_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000348_ReadAttribute +- (void)testSendClusterTestCluster_000350_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING"]; @@ -36445,7 +36580,7 @@ - (void)testSendClusterTestCluster_000348_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000349_WriteAttribute +- (void)testSendClusterTestCluster_000351_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_OCTET_STRING"]; @@ -36467,7 +36602,7 @@ - (void)testSendClusterTestCluster_000349_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000350_ReadAttribute +- (void)testSendClusterTestCluster_000352_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING"]; @@ -36491,7 +36626,7 @@ - (void)testSendClusterTestCluster_000350_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000351_WriteAttribute +- (void)testSendClusterTestCluster_000353_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_OCTET_STRING"]; @@ -36513,7 +36648,7 @@ - (void)testSendClusterTestCluster_000351_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000352_ReadAttribute +- (void)testSendClusterTestCluster_000354_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_OCTET_STRING"]; @@ -36538,7 +36673,7 @@ - (void)testSendClusterTestCluster_000352_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000353_ReadAttribute +- (void)testSendClusterTestCluster_000355_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING Default Value"]; @@ -36563,7 +36698,7 @@ - (void)testSendClusterTestCluster_000353_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000354_WriteAttribute +- (void)testSendClusterTestCluster_000356_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_CHAR_STRING"]; @@ -36585,7 +36720,7 @@ - (void)testSendClusterTestCluster_000354_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000355_ReadAttribute +- (void)testSendClusterTestCluster_000357_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING"]; @@ -36610,7 +36745,7 @@ - (void)testSendClusterTestCluster_000355_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000356_WriteAttribute +- (void)testSendClusterTestCluster_000358_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_CHAR_STRING - Value too long"]; @@ -36632,7 +36767,7 @@ - (void)testSendClusterTestCluster_000356_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000357_ReadAttribute +- (void)testSendClusterTestCluster_000359_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING"]; @@ -36656,7 +36791,7 @@ - (void)testSendClusterTestCluster_000357_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000358_WriteAttribute +- (void)testSendClusterTestCluster_000360_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute NULLABLE_CHAR_STRING - Empty"]; @@ -36678,7 +36813,7 @@ - (void)testSendClusterTestCluster_000358_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000359_ReadAttribute +- (void)testSendClusterTestCluster_000361_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute NULLABLE_CHAR_STRING"]; @@ -36703,7 +36838,7 @@ - (void)testSendClusterTestCluster_000359_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000360_ReadAttribute +- (void)testSendClusterTestCluster_000362_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute from nonexistent endpoint."]; @@ -36721,7 +36856,7 @@ - (void)testSendClusterTestCluster_000360_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000361_ReadAttribute +- (void)testSendClusterTestCluster_000363_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute from nonexistent cluster."]; @@ -36739,7 +36874,7 @@ - (void)testSendClusterTestCluster_000361_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000362_TestSimpleOptionalArgumentRequest +- (void)testSendClusterTestCluster_000364_TestSimpleOptionalArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send a command that takes an optional parameter but do not set it."]; @@ -36761,7 +36896,7 @@ - (void)testSendClusterTestCluster_000362_TestSimpleOptionalArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000363_TestSimpleOptionalArgumentRequest +- (void)testSendClusterTestCluster_000365_TestSimpleOptionalArgumentRequest { XCTestExpectation * expectation = [self expectationWithDescription:@"Send a command that takes an optional parameter but do not set it."]; @@ -36785,9 +36920,9 @@ - (void)testSendClusterTestCluster_000363_TestSimpleOptionalArgumentRequest [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -bool testSendClusterTestCluster_000364_WaitForReport_Fulfilled = false; +bool testSendClusterTestCluster_000366_WaitForReport_Fulfilled = false; ResponseHandler test_TestCluster_list_int8u_Reported = nil; -- (void)testSendClusterTestCluster_000364_WaitForReport +- (void)testSendClusterTestCluster_000366_WaitForReport { CHIPDevice * device = GetConnectedDevice(); @@ -36809,10 +36944,10 @@ - (void)testSendClusterTestCluster_000364_WaitForReport XCTAssertEqual([actualValue[3] unsignedCharValue], 4); } - testSendClusterTestCluster_000364_WaitForReport_Fulfilled = true; + testSendClusterTestCluster_000366_WaitForReport_Fulfilled = true; }; } -- (void)testSendClusterTestCluster_000365_SubscribeAttribute +- (void)testSendClusterTestCluster_000367_SubscribeAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Subscribe to list attribute"]; @@ -36826,7 +36961,7 @@ - (void)testSendClusterTestCluster_000365_SubscribeAttribute [cluster subscribeAttributeListInt8uWithMinInterval:minIntervalArgument maxInterval:maxIntervalArgument subscriptionEstablished:^{ - XCTAssertEqual(testSendClusterTestCluster_000364_WaitForReport_Fulfilled, true); + XCTAssertEqual(testSendClusterTestCluster_000366_WaitForReport_Fulfilled, true); [expectation fulfill]; } reportHandler:^(NSArray * _Nullable value, NSError * _Nullable err) { @@ -36842,7 +36977,7 @@ - (void)testSendClusterTestCluster_000365_SubscribeAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000366_WriteAttribute +- (void)testSendClusterTestCluster_000368_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write subscribed-to list attribute"]; @@ -36871,7 +37006,7 @@ - (void)testSendClusterTestCluster_000366_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000367_WaitForReport +- (void)testSendClusterTestCluster_000369_WaitForReport { XCTestExpectation * expectation = [self expectationWithDescription:@"Check for list attribute report"]; @@ -36899,7 +37034,7 @@ - (void)testSendClusterTestCluster_000367_WaitForReport [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000368_ReadAttribute +- (void)testSendClusterTestCluster_000370_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read range-restricted unsigned 8-bit integer"]; @@ -36923,7 +37058,7 @@ - (void)testSendClusterTestCluster_000368_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000369_WriteAttribute +- (void)testSendClusterTestCluster_000371_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a range-restricted unsigned 8-bit integer"]; @@ -36946,7 +37081,7 @@ - (void)testSendClusterTestCluster_000369_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000370_WriteAttribute +- (void)testSendClusterTestCluster_000372_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a range-restricted unsigned 8-bit integer"]; @@ -36971,7 +37106,7 @@ - (void)testSendClusterTestCluster_000370_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000371_WriteAttribute +- (void)testSendClusterTestCluster_000373_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a range-restricted unsigned 8-bit integer"]; @@ -36996,7 +37131,7 @@ - (void)testSendClusterTestCluster_000371_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000372_WriteAttribute +- (void)testSendClusterTestCluster_000374_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a range-restricted unsigned 8-bit integer"]; @@ -37019,7 +37154,7 @@ - (void)testSendClusterTestCluster_000372_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000373_ReadAttribute +- (void)testSendClusterTestCluster_000375_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 8-bit integer value has not changed"]; @@ -37044,7 +37179,7 @@ - (void)testSendClusterTestCluster_000373_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000374_WriteAttribute +- (void)testSendClusterTestCluster_000376_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a range-restricted unsigned 8-bit integer"]; @@ -37068,7 +37203,7 @@ - (void)testSendClusterTestCluster_000374_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000375_ReadAttribute +- (void)testSendClusterTestCluster_000377_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 8-bit integer value is at min valid"]; @@ -37093,7 +37228,7 @@ - (void)testSendClusterTestCluster_000375_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000376_WriteAttribute +- (void)testSendClusterTestCluster_000378_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a range-restricted unsigned 8-bit integer"]; @@ -37117,7 +37252,7 @@ - (void)testSendClusterTestCluster_000376_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000377_ReadAttribute +- (void)testSendClusterTestCluster_000379_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 8-bit integer value is at max valid"]; @@ -37142,7 +37277,7 @@ - (void)testSendClusterTestCluster_000377_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000378_WriteAttribute +- (void)testSendClusterTestCluster_000380_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a range-restricted unsigned 8-bit integer"]; @@ -37166,7 +37301,7 @@ - (void)testSendClusterTestCluster_000378_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000379_ReadAttribute +- (void)testSendClusterTestCluster_000381_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 8-bit integer value is at mid valid"]; @@ -37191,7 +37326,7 @@ - (void)testSendClusterTestCluster_000379_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000380_ReadAttribute +- (void)testSendClusterTestCluster_000382_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read range-restricted unsigned 16-bit integer"]; @@ -37215,7 +37350,7 @@ - (void)testSendClusterTestCluster_000380_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000381_WriteAttribute +- (void)testSendClusterTestCluster_000383_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a range-restricted unsigned 16-bit integer"]; @@ -37238,7 +37373,7 @@ - (void)testSendClusterTestCluster_000381_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000382_WriteAttribute +- (void)testSendClusterTestCluster_000384_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a range-restricted unsigned 16-bit integer"]; @@ -37264,7 +37399,7 @@ - (void)testSendClusterTestCluster_000382_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000383_WriteAttribute +- (void)testSendClusterTestCluster_000385_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a range-restricted unsigned 16-bit integer"]; @@ -37290,7 +37425,7 @@ - (void)testSendClusterTestCluster_000383_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000384_WriteAttribute +- (void)testSendClusterTestCluster_000386_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a range-restricted unsigned 16-bit integer"]; @@ -37313,7 +37448,7 @@ - (void)testSendClusterTestCluster_000384_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000385_ReadAttribute +- (void)testSendClusterTestCluster_000387_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 16-bit integer value has not changed"]; @@ -37338,7 +37473,7 @@ - (void)testSendClusterTestCluster_000385_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000386_WriteAttribute +- (void)testSendClusterTestCluster_000388_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a range-restricted unsigned 16-bit integer"]; @@ -37362,7 +37497,7 @@ - (void)testSendClusterTestCluster_000386_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000387_ReadAttribute +- (void)testSendClusterTestCluster_000389_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 16-bit integer value is at min valid"]; @@ -37387,7 +37522,7 @@ - (void)testSendClusterTestCluster_000387_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000388_WriteAttribute +- (void)testSendClusterTestCluster_000390_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a range-restricted unsigned 16-bit integer"]; @@ -37411,7 +37546,7 @@ - (void)testSendClusterTestCluster_000388_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000389_ReadAttribute +- (void)testSendClusterTestCluster_000391_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 16-bit integer value is at max valid"]; @@ -37436,7 +37571,7 @@ - (void)testSendClusterTestCluster_000389_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000390_WriteAttribute +- (void)testSendClusterTestCluster_000392_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a range-restricted unsigned 16-bit integer"]; @@ -37461,7 +37596,7 @@ - (void)testSendClusterTestCluster_000390_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000391_ReadAttribute +- (void)testSendClusterTestCluster_000393_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted unsigned 16-bit integer value is at mid valid"]; @@ -37486,7 +37621,7 @@ - (void)testSendClusterTestCluster_000391_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000392_ReadAttribute +- (void)testSendClusterTestCluster_000394_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read range-restricted signed 8-bit integer"]; @@ -37510,7 +37645,7 @@ - (void)testSendClusterTestCluster_000392_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000393_WriteAttribute +- (void)testSendClusterTestCluster_000395_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a range-restricted signed 8-bit integer"]; @@ -37533,7 +37668,7 @@ - (void)testSendClusterTestCluster_000393_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000394_WriteAttribute +- (void)testSendClusterTestCluster_000396_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a range-restricted signed 8-bit integer"]; @@ -37558,7 +37693,7 @@ - (void)testSendClusterTestCluster_000394_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000395_WriteAttribute +- (void)testSendClusterTestCluster_000397_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a range-restricted signed 8-bit integer"]; @@ -37583,7 +37718,7 @@ - (void)testSendClusterTestCluster_000395_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000396_WriteAttribute +- (void)testSendClusterTestCluster_000398_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a range-restricted signed 8-bit integer"]; @@ -37606,7 +37741,7 @@ - (void)testSendClusterTestCluster_000396_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000397_ReadAttribute +- (void)testSendClusterTestCluster_000399_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 8-bit integer value has not changed"]; @@ -37631,7 +37766,7 @@ - (void)testSendClusterTestCluster_000397_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000398_WriteAttribute +- (void)testSendClusterTestCluster_000400_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a range-restricted signed 8-bit integer"]; @@ -37655,7 +37790,7 @@ - (void)testSendClusterTestCluster_000398_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000399_ReadAttribute +- (void)testSendClusterTestCluster_000401_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 8-bit integer value is at min valid"]; @@ -37680,7 +37815,7 @@ - (void)testSendClusterTestCluster_000399_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000400_WriteAttribute +- (void)testSendClusterTestCluster_000402_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a range-restricted signed 8-bit integer"]; @@ -37704,7 +37839,7 @@ - (void)testSendClusterTestCluster_000400_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000401_ReadAttribute +- (void)testSendClusterTestCluster_000403_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 8-bit integer value is at max valid"]; @@ -37729,7 +37864,7 @@ - (void)testSendClusterTestCluster_000401_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000402_WriteAttribute +- (void)testSendClusterTestCluster_000404_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a range-restricted signed 8-bit integer"]; @@ -37753,7 +37888,7 @@ - (void)testSendClusterTestCluster_000402_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000403_ReadAttribute +- (void)testSendClusterTestCluster_000405_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 8-bit integer value is at mid valid"]; @@ -37778,7 +37913,7 @@ - (void)testSendClusterTestCluster_000403_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000404_ReadAttribute +- (void)testSendClusterTestCluster_000406_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read range-restricted signed 16-bit integer"]; @@ -37802,7 +37937,7 @@ - (void)testSendClusterTestCluster_000404_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000405_WriteAttribute +- (void)testSendClusterTestCluster_000407_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a range-restricted signed 16-bit integer"]; @@ -37825,7 +37960,7 @@ - (void)testSendClusterTestCluster_000405_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000406_WriteAttribute +- (void)testSendClusterTestCluster_000408_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a range-restricted signed 16-bit integer"]; @@ -37850,7 +37985,7 @@ - (void)testSendClusterTestCluster_000406_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000407_WriteAttribute +- (void)testSendClusterTestCluster_000409_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a range-restricted signed 16-bit integer"]; @@ -37875,7 +38010,7 @@ - (void)testSendClusterTestCluster_000407_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000408_WriteAttribute +- (void)testSendClusterTestCluster_000410_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a range-restricted signed 16-bit integer"]; @@ -37898,7 +38033,7 @@ - (void)testSendClusterTestCluster_000408_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000409_ReadAttribute +- (void)testSendClusterTestCluster_000411_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 16-bit integer value has not changed"]; @@ -37923,7 +38058,7 @@ - (void)testSendClusterTestCluster_000409_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000410_WriteAttribute +- (void)testSendClusterTestCluster_000412_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a range-restricted signed 16-bit integer"]; @@ -37947,7 +38082,7 @@ - (void)testSendClusterTestCluster_000410_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000411_ReadAttribute +- (void)testSendClusterTestCluster_000413_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 16-bit integer value is at min valid"]; @@ -37972,7 +38107,7 @@ - (void)testSendClusterTestCluster_000411_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000412_WriteAttribute +- (void)testSendClusterTestCluster_000414_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a range-restricted signed 16-bit integer"]; @@ -37996,7 +38131,7 @@ - (void)testSendClusterTestCluster_000412_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000413_ReadAttribute +- (void)testSendClusterTestCluster_000415_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 16-bit integer value is at max valid"]; @@ -38021,7 +38156,7 @@ - (void)testSendClusterTestCluster_000413_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000414_WriteAttribute +- (void)testSendClusterTestCluster_000416_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a range-restricted signed 16-bit integer"]; @@ -38045,7 +38180,7 @@ - (void)testSendClusterTestCluster_000414_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000415_ReadAttribute +- (void)testSendClusterTestCluster_000417_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify range-restricted signed 16-bit integer value is at mid valid"]; @@ -38070,7 +38205,7 @@ - (void)testSendClusterTestCluster_000415_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000416_ReadAttribute +- (void)testSendClusterTestCluster_000418_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read nullable range-restricted unsigned 8-bit integer"]; @@ -38095,7 +38230,7 @@ - (void)testSendClusterTestCluster_000416_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000417_WriteAttribute +- (void)testSendClusterTestCluster_000419_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a nullable range-restricted unsigned 8-bit integer"]; @@ -38120,7 +38255,7 @@ - (void)testSendClusterTestCluster_000417_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000418_WriteAttribute +- (void)testSendClusterTestCluster_000420_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a nullable range-restricted unsigned 8-bit integer"]; @@ -38145,7 +38280,7 @@ - (void)testSendClusterTestCluster_000418_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000419_WriteAttribute +- (void)testSendClusterTestCluster_000421_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a nullable range-restricted unsigned 8-bit integer"]; @@ -38170,7 +38305,7 @@ - (void)testSendClusterTestCluster_000419_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000420_WriteAttribute +- (void)testSendClusterTestCluster_000422_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a nullable range-restricted unsigned 8-bit integer"]; @@ -38195,7 +38330,7 @@ - (void)testSendClusterTestCluster_000420_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000421_ReadAttribute +- (void)testSendClusterTestCluster_000423_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value has not changed"]; @@ -38221,7 +38356,7 @@ - (void)testSendClusterTestCluster_000421_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000422_WriteAttribute +- (void)testSendClusterTestCluster_000424_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a nullable range-restricted unsigned 8-bit integer"]; @@ -38246,7 +38381,7 @@ - (void)testSendClusterTestCluster_000422_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000423_ReadAttribute +- (void)testSendClusterTestCluster_000425_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value is at min valid"]; @@ -38272,7 +38407,7 @@ - (void)testSendClusterTestCluster_000423_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000424_WriteAttribute +- (void)testSendClusterTestCluster_000426_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a nullable range-restricted unsigned 8-bit integer"]; @@ -38297,7 +38432,7 @@ - (void)testSendClusterTestCluster_000424_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000425_ReadAttribute +- (void)testSendClusterTestCluster_000427_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value is at max valid"]; @@ -38323,7 +38458,7 @@ - (void)testSendClusterTestCluster_000425_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000426_WriteAttribute +- (void)testSendClusterTestCluster_000428_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a nullable range-restricted unsigned 8-bit integer"]; @@ -38348,7 +38483,7 @@ - (void)testSendClusterTestCluster_000426_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000427_ReadAttribute +- (void)testSendClusterTestCluster_000429_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value is at mid valid"]; @@ -38374,7 +38509,7 @@ - (void)testSendClusterTestCluster_000427_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000428_WriteAttribute +- (void)testSendClusterTestCluster_000430_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write null value to a nullable range-restricted unsigned 8-bit integer"]; @@ -38399,7 +38534,7 @@ - (void)testSendClusterTestCluster_000428_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000429_ReadAttribute +- (void)testSendClusterTestCluster_000431_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 8-bit integer value is null"]; @@ -38424,7 +38559,7 @@ - (void)testSendClusterTestCluster_000429_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000430_ReadAttribute +- (void)testSendClusterTestCluster_000432_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read nullable range-restricted unsigned 16-bit integer"]; @@ -38450,7 +38585,7 @@ - (void)testSendClusterTestCluster_000430_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000431_WriteAttribute +- (void)testSendClusterTestCluster_000433_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a nullable range-restricted unsigned 16-bit integer"]; @@ -38475,7 +38610,7 @@ - (void)testSendClusterTestCluster_000431_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000432_WriteAttribute +- (void)testSendClusterTestCluster_000434_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a nullable range-restricted unsigned 16-bit integer"]; @@ -38500,7 +38635,7 @@ - (void)testSendClusterTestCluster_000432_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000433_WriteAttribute +- (void)testSendClusterTestCluster_000435_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a nullable range-restricted unsigned 16-bit integer"]; @@ -38525,7 +38660,7 @@ - (void)testSendClusterTestCluster_000433_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000434_WriteAttribute +- (void)testSendClusterTestCluster_000436_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a nullable range-restricted unsigned 16-bit integer"]; @@ -38550,7 +38685,7 @@ - (void)testSendClusterTestCluster_000434_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000435_ReadAttribute +- (void)testSendClusterTestCluster_000437_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value has not changed"]; @@ -38577,7 +38712,7 @@ - (void)testSendClusterTestCluster_000435_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000436_WriteAttribute +- (void)testSendClusterTestCluster_000438_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a nullable range-restricted unsigned 16-bit integer"]; @@ -38602,7 +38737,7 @@ - (void)testSendClusterTestCluster_000436_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000437_ReadAttribute +- (void)testSendClusterTestCluster_000439_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value is at min valid"]; @@ -38629,7 +38764,7 @@ - (void)testSendClusterTestCluster_000437_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000438_WriteAttribute +- (void)testSendClusterTestCluster_000440_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a nullable range-restricted unsigned 16-bit integer"]; @@ -38654,7 +38789,7 @@ - (void)testSendClusterTestCluster_000438_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000439_ReadAttribute +- (void)testSendClusterTestCluster_000441_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value is at max valid"]; @@ -38681,7 +38816,7 @@ - (void)testSendClusterTestCluster_000439_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000440_WriteAttribute +- (void)testSendClusterTestCluster_000442_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a nullable range-restricted unsigned 16-bit integer"]; @@ -38706,7 +38841,7 @@ - (void)testSendClusterTestCluster_000440_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000441_ReadAttribute +- (void)testSendClusterTestCluster_000443_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value is at mid valid"]; @@ -38733,7 +38868,7 @@ - (void)testSendClusterTestCluster_000441_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000442_WriteAttribute +- (void)testSendClusterTestCluster_000444_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write null value to a nullable range-restricted unsigned 16-bit integer"]; @@ -38758,7 +38893,7 @@ - (void)testSendClusterTestCluster_000442_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000443_ReadAttribute +- (void)testSendClusterTestCluster_000445_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted unsigned 16-bit integer value is null"]; @@ -38784,7 +38919,7 @@ - (void)testSendClusterTestCluster_000443_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000444_ReadAttribute +- (void)testSendClusterTestCluster_000446_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read nullable range-restricted signed 8-bit integer"]; @@ -38809,7 +38944,7 @@ - (void)testSendClusterTestCluster_000444_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000445_WriteAttribute +- (void)testSendClusterTestCluster_000447_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a nullable range-restricted signed 8-bit integer"]; @@ -38835,7 +38970,7 @@ - (void)testSendClusterTestCluster_000445_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000446_WriteAttribute +- (void)testSendClusterTestCluster_000448_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a nullable range-restricted signed 8-bit integer"]; @@ -38860,7 +38995,7 @@ - (void)testSendClusterTestCluster_000446_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000447_WriteAttribute +- (void)testSendClusterTestCluster_000449_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a nullable range-restricted signed 8-bit integer"]; @@ -38885,7 +39020,7 @@ - (void)testSendClusterTestCluster_000447_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000448_WriteAttribute +- (void)testSendClusterTestCluster_000450_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a nullable range-restricted signed 8-bit integer"]; @@ -38911,7 +39046,7 @@ - (void)testSendClusterTestCluster_000448_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000449_ReadAttribute +- (void)testSendClusterTestCluster_000451_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value has not changed"]; @@ -38937,7 +39072,7 @@ - (void)testSendClusterTestCluster_000449_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000450_WriteAttribute +- (void)testSendClusterTestCluster_000452_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a nullable range-restricted signed 8-bit integer"]; @@ -38962,7 +39097,7 @@ - (void)testSendClusterTestCluster_000450_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000451_ReadAttribute +- (void)testSendClusterTestCluster_000453_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value is at min valid"]; @@ -38988,7 +39123,7 @@ - (void)testSendClusterTestCluster_000451_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000452_WriteAttribute +- (void)testSendClusterTestCluster_000454_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a nullable range-restricted signed 8-bit integer"]; @@ -39013,7 +39148,7 @@ - (void)testSendClusterTestCluster_000452_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000453_ReadAttribute +- (void)testSendClusterTestCluster_000455_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value is at max valid"]; @@ -39039,7 +39174,7 @@ - (void)testSendClusterTestCluster_000453_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000454_WriteAttribute +- (void)testSendClusterTestCluster_000456_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a nullable range-restricted signed 8-bit integer"]; @@ -39064,7 +39199,7 @@ - (void)testSendClusterTestCluster_000454_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000455_ReadAttribute +- (void)testSendClusterTestCluster_000457_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value is at mid valid"]; @@ -39090,7 +39225,7 @@ - (void)testSendClusterTestCluster_000455_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000456_WriteAttribute +- (void)testSendClusterTestCluster_000458_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write null value to a nullable range-restricted signed 8-bit integer"]; @@ -39116,7 +39251,7 @@ - (void)testSendClusterTestCluster_000456_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000457_ReadAttribute +- (void)testSendClusterTestCluster_000459_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 8-bit integer value is at null"]; @@ -39141,7 +39276,7 @@ - (void)testSendClusterTestCluster_000457_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000458_ReadAttribute +- (void)testSendClusterTestCluster_000460_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read nullable range-restricted signed 16-bit integer"]; @@ -39167,7 +39302,7 @@ - (void)testSendClusterTestCluster_000458_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000459_WriteAttribute +- (void)testSendClusterTestCluster_000461_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min value to a nullable range-restricted signed 16-bit integer"]; @@ -39192,7 +39327,7 @@ - (void)testSendClusterTestCluster_000459_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000460_WriteAttribute +- (void)testSendClusterTestCluster_000462_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-below-range value to a nullable range-restricted signed 16-bit integer"]; @@ -39217,7 +39352,7 @@ - (void)testSendClusterTestCluster_000460_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000461_WriteAttribute +- (void)testSendClusterTestCluster_000463_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write just-above-range value to a nullable range-restricted signed 16-bit integer"]; @@ -39242,7 +39377,7 @@ - (void)testSendClusterTestCluster_000461_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000462_WriteAttribute +- (void)testSendClusterTestCluster_000464_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max value to a nullable range-restricted signed 16-bit integer"]; @@ -39267,7 +39402,7 @@ - (void)testSendClusterTestCluster_000462_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000463_ReadAttribute +- (void)testSendClusterTestCluster_000465_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value has not changed"]; @@ -39294,7 +39429,7 @@ - (void)testSendClusterTestCluster_000463_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000464_WriteAttribute +- (void)testSendClusterTestCluster_000466_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write min valid value to a nullable range-restricted signed 16-bit integer"]; @@ -39319,7 +39454,7 @@ - (void)testSendClusterTestCluster_000464_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000465_ReadAttribute +- (void)testSendClusterTestCluster_000467_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value is at min valid"]; @@ -39346,7 +39481,7 @@ - (void)testSendClusterTestCluster_000465_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000466_WriteAttribute +- (void)testSendClusterTestCluster_000468_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write max valid value to a nullable range-restricted signed 16-bit integer"]; @@ -39371,7 +39506,7 @@ - (void)testSendClusterTestCluster_000466_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000467_ReadAttribute +- (void)testSendClusterTestCluster_000469_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value is at max valid"]; @@ -39398,7 +39533,7 @@ - (void)testSendClusterTestCluster_000467_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000468_WriteAttribute +- (void)testSendClusterTestCluster_000470_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write middle valid value to a nullable range-restricted signed 16-bit integer"]; @@ -39423,7 +39558,7 @@ - (void)testSendClusterTestCluster_000468_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000469_ReadAttribute +- (void)testSendClusterTestCluster_000471_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value is at mid valid"]; @@ -39450,7 +39585,7 @@ - (void)testSendClusterTestCluster_000469_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000470_WriteAttribute +- (void)testSendClusterTestCluster_000472_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write null value to a nullable range-restricted signed 16-bit integer"]; @@ -39475,7 +39610,7 @@ - (void)testSendClusterTestCluster_000470_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000471_ReadAttribute +- (void)testSendClusterTestCluster_000473_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Verify nullable range-restricted signed 16-bit integer value is null"]; @@ -39501,7 +39636,7 @@ - (void)testSendClusterTestCluster_000471_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000472_WriteAttribute +- (void)testSendClusterTestCluster_000474_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute that returns general status on write"]; @@ -39523,7 +39658,7 @@ - (void)testSendClusterTestCluster_000472_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000473_WriteAttribute +- (void)testSendClusterTestCluster_000475_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write attribute that returns cluster-specific status on write"]; @@ -39545,7 +39680,7 @@ - (void)testSendClusterTestCluster_000473_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000474_ReadAttribute +- (void)testSendClusterTestCluster_000476_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read attribute that returns general status on read"]; @@ -39563,7 +39698,7 @@ - (void)testSendClusterTestCluster_000474_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000475_ReadAttribute +- (void)testSendClusterTestCluster_000477_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"read attribute that returns cluster-specific status on read"]; @@ -39582,7 +39717,7 @@ - (void)testSendClusterTestCluster_000475_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000476_ReadAttribute +- (void)testSendClusterTestCluster_000478_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"read ClientGeneratedCommandList attribute"]; @@ -39624,7 +39759,7 @@ - (void)testSendClusterTestCluster_000476_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000477_ReadAttribute +- (void)testSendClusterTestCluster_000479_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"read ServerGeneratedCommandList attribute"]; @@ -39656,7 +39791,7 @@ - (void)testSendClusterTestCluster_000477_ReadAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000478_WriteAttribute +- (void)testSendClusterTestCluster_000480_WriteAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Write struct-typed attribute"]; @@ -39687,7 +39822,7 @@ - (void)testSendClusterTestCluster_000478_WriteAttribute [self waitForExpectationsWithTimeout:kTimeoutInSeconds handler:nil]; } -- (void)testSendClusterTestCluster_000479_ReadAttribute +- (void)testSendClusterTestCluster_000481_ReadAttribute { XCTestExpectation * expectation = [self expectationWithDescription:@"Read struct-typed attribute"]; 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 009b95ce0155cc..1bf7b78799defe 100644 --- a/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h +++ b/zzz_generated/all-clusters-app/zap-generated/endpoint_config.h @@ -2308,8 +2308,9 @@ { 0x00000028, ZAP_TYPE(INT16U), 2, ZAP_ATTRIBUTE_MASK(MIN_MAX) | ZAP_ATTRIBUTE_MASK(WRITABLE), \ ZAP_MIN_MAX_DEFAULTS_INDEX(34) }, /* range_restricted_int16u */ \ { 0x00000029, ZAP_TYPE(INT16S), 2, ZAP_ATTRIBUTE_MASK(MIN_MAX) | ZAP_ATTRIBUTE_MASK(WRITABLE), \ - ZAP_MIN_MAX_DEFAULTS_INDEX(35) }, /* range_restricted_int16s */ \ - { 0x0000002A, ZAP_TYPE(ARRAY), 1000, 0, ZAP_LONG_DEFAULTS_INDEX(2685) }, /* list_long_octet_string */ \ + ZAP_MIN_MAX_DEFAULTS_INDEX(35) }, /* range_restricted_int16s */ \ + { 0x0000002A, ZAP_TYPE(ARRAY), 1000, ZAP_ATTRIBUTE_MASK(WRITABLE), \ + ZAP_LONG_DEFAULTS_INDEX(2685) }, /* list_long_octet_string */ \ { 0x0000002B, ZAP_TYPE(ARRAY), 0, ZAP_ATTRIBUTE_MASK(EXTERNAL_STORAGE), \ ZAP_EMPTY_DEFAULT() }, /* list_fabric_scoped */ \ { 0x00000030, ZAP_TYPE(BOOLEAN), 1, ZAP_ATTRIBUTE_MASK(WRITABLE) | ZAP_ATTRIBUTE_MASK(MUST_USE_TIMED_WRITE), \ diff --git a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h index aa41cd903d29bd..2b50fb7196d14c 100644 --- a/zzz_generated/chip-tool/zap-generated/cluster/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/cluster/Commands.h @@ -7510,6 +7510,29 @@ class WriteTestClusterRangeRestrictedInt16s : public WriteAttribute int16_t mValue; }; +class WriteTestClusterListLongOctetString : public WriteAttribute +{ +public: + WriteTestClusterListLongOctetString(CredentialIssuerCommands * credsIssuerConfig) : + WriteAttribute("ListLongOctetString", credsIssuerConfig), mComplex(&mValue) + { + AddArgument("attr-name", "list-long-octet-string"); + AddArgument("attr-value", &mComplex); + WriteAttribute::AddArguments(); + } + + ~WriteTestClusterListLongOctetString() {} + + CHIP_ERROR SendCommand(ChipDevice * device, chip::EndpointId endpointId) override + { + return WriteAttribute::SendCommand(device, endpointId, 0x0000050F, 0x0000002A, mValue); + } + +private: + chip::app::DataModel::List mValue; + TypedComplexArgument> mComplex; +}; + class WriteTestClusterTimedWriteBoolean : public WriteAttribute { public: @@ -12409,6 +12432,7 @@ void registerClusterTestCluster(Commands & commands, CredentialIssuerCommands * make_unique(credsIssuerConfig), // make_unique(credsIssuerConfig), // make_unique(credsIssuerConfig), // + make_unique(credsIssuerConfig), // make_unique(credsIssuerConfig), // make_unique(credsIssuerConfig), // make_unique(credsIssuerConfig), // diff --git a/zzz_generated/chip-tool/zap-generated/test/Commands.h b/zzz_generated/chip-tool/zap-generated/test/Commands.h index 2592a21de6dab2..315f23d107f0f3 100644 --- a/zzz_generated/chip-tool/zap-generated/test/Commands.h +++ b/zzz_generated/chip-tool/zap-generated/test/Commands.h @@ -52158,892 +52158,892 @@ class TestCluster : public TestCommand err = TestWriteAttributeLongCharString_130(); break; case 131: - ChipLogProgress(chipTool, " ***** Test Step 131 : Read attribute LIST_LONG_OCTET_STRING\n"); - err = TestReadAttributeListLongOctetString_131(); + ChipLogProgress(chipTool, " ***** Test Step 131 : Read attribute LIST_LONG_OCTET_STRING (for chunked read)\n"); + err = TestReadAttributeListLongOctetStringForChunkedRead_131(); break; case 132: - ChipLogProgress(chipTool, " ***** Test Step 132 : Read attribute EPOCH_US Default Value\n"); - err = TestReadAttributeEpochUsDefaultValue_132(); + ChipLogProgress(chipTool, " ***** Test Step 132 : Write attribute LIST_LONG_OCTET_STRING (for chunked write)\n"); + err = TestWriteAttributeListLongOctetStringForChunkedWrite_132(); break; case 133: - ChipLogProgress(chipTool, " ***** Test Step 133 : Write attribute EPOCH_US Max Value\n"); - err = TestWriteAttributeEpochUsMaxValue_133(); + ChipLogProgress(chipTool, " ***** Test Step 133 : Read attribute LIST_LONG_OCTET_STRING (for chunked read)\n"); + err = TestReadAttributeListLongOctetStringForChunkedRead_133(); break; case 134: - ChipLogProgress(chipTool, " ***** Test Step 134 : Read attribute EPOCH_US Max Value\n"); - err = TestReadAttributeEpochUsMaxValue_134(); + ChipLogProgress(chipTool, " ***** Test Step 134 : Read attribute EPOCH_US Default Value\n"); + err = TestReadAttributeEpochUsDefaultValue_134(); break; case 135: - ChipLogProgress(chipTool, " ***** Test Step 135 : Write attribute EPOCH_US Min Value\n"); - err = TestWriteAttributeEpochUsMinValue_135(); + ChipLogProgress(chipTool, " ***** Test Step 135 : Write attribute EPOCH_US Max Value\n"); + err = TestWriteAttributeEpochUsMaxValue_135(); break; case 136: - ChipLogProgress(chipTool, " ***** Test Step 136 : Read attribute EPOCH_US Min Value\n"); - err = TestReadAttributeEpochUsMinValue_136(); + ChipLogProgress(chipTool, " ***** Test Step 136 : Read attribute EPOCH_US Max Value\n"); + err = TestReadAttributeEpochUsMaxValue_136(); break; case 137: - ChipLogProgress(chipTool, " ***** Test Step 137 : Read attribute EPOCH_S Default Value\n"); - err = TestReadAttributeEpochSDefaultValue_137(); + ChipLogProgress(chipTool, " ***** Test Step 137 : Write attribute EPOCH_US Min Value\n"); + err = TestWriteAttributeEpochUsMinValue_137(); break; case 138: - ChipLogProgress(chipTool, " ***** Test Step 138 : Write attribute EPOCH_S Max Value\n"); - err = TestWriteAttributeEpochSMaxValue_138(); + ChipLogProgress(chipTool, " ***** Test Step 138 : Read attribute EPOCH_US Min Value\n"); + err = TestReadAttributeEpochUsMinValue_138(); break; case 139: - ChipLogProgress(chipTool, " ***** Test Step 139 : Read attribute EPOCH_S Max Value\n"); - err = TestReadAttributeEpochSMaxValue_139(); + ChipLogProgress(chipTool, " ***** Test Step 139 : Read attribute EPOCH_S Default Value\n"); + err = TestReadAttributeEpochSDefaultValue_139(); break; case 140: - ChipLogProgress(chipTool, " ***** Test Step 140 : Write attribute EPOCH_S Min Value\n"); - err = TestWriteAttributeEpochSMinValue_140(); + ChipLogProgress(chipTool, " ***** Test Step 140 : Write attribute EPOCH_S Max Value\n"); + err = TestWriteAttributeEpochSMaxValue_140(); break; case 141: - ChipLogProgress(chipTool, " ***** Test Step 141 : Read attribute EPOCH_S Min Value\n"); - err = TestReadAttributeEpochSMinValue_141(); + ChipLogProgress(chipTool, " ***** Test Step 141 : Read attribute EPOCH_S Max Value\n"); + err = TestReadAttributeEpochSMaxValue_141(); break; case 142: - ChipLogProgress(chipTool, " ***** Test Step 142 : Read attribute UNSUPPORTED\n"); - err = TestReadAttributeUnsupported_142(); + ChipLogProgress(chipTool, " ***** Test Step 142 : Write attribute EPOCH_S Min Value\n"); + err = TestWriteAttributeEpochSMinValue_142(); break; case 143: - ChipLogProgress(chipTool, " ***** Test Step 143 : Writeattribute UNSUPPORTED\n"); - err = TestWriteattributeUnsupported_143(); + ChipLogProgress(chipTool, " ***** Test Step 143 : Read attribute EPOCH_S Min Value\n"); + err = TestReadAttributeEpochSMinValue_143(); break; case 144: - ChipLogProgress(chipTool, " ***** Test Step 144 : Send Test Command to unsupported endpoint\n"); - err = TestSendTestCommandToUnsupportedEndpoint_144(); + ChipLogProgress(chipTool, " ***** Test Step 144 : Read attribute UNSUPPORTED\n"); + err = TestReadAttributeUnsupported_144(); break; case 145: - ChipLogProgress(chipTool, " ***** Test Step 145 : Send Test Command to unsupported cluster\n"); - err = TestSendTestCommandToUnsupportedCluster_145(); + ChipLogProgress(chipTool, " ***** Test Step 145 : Writeattribute UNSUPPORTED\n"); + err = TestWriteattributeUnsupported_145(); break; case 146: - ChipLogProgress(chipTool, " ***** Test Step 146 : Read attribute vendor_id Default Value\n"); - err = TestReadAttributeVendorIdDefaultValue_146(); + ChipLogProgress(chipTool, " ***** Test Step 146 : Send Test Command to unsupported endpoint\n"); + err = TestSendTestCommandToUnsupportedEndpoint_146(); break; case 147: - ChipLogProgress(chipTool, " ***** Test Step 147 : Write attribute vendor_id\n"); - err = TestWriteAttributeVendorId_147(); + ChipLogProgress(chipTool, " ***** Test Step 147 : Send Test Command to unsupported cluster\n"); + err = TestSendTestCommandToUnsupportedCluster_147(); break; case 148: - ChipLogProgress(chipTool, " ***** Test Step 148 : Read attribute vendor_id\n"); - err = TestReadAttributeVendorId_148(); + ChipLogProgress(chipTool, " ***** Test Step 148 : Read attribute vendor_id Default Value\n"); + err = TestReadAttributeVendorIdDefaultValue_148(); break; case 149: - ChipLogProgress(chipTool, " ***** Test Step 149 : Restore attribute vendor_id\n"); - err = TestRestoreAttributeVendorId_149(); + ChipLogProgress(chipTool, " ***** Test Step 149 : Write attribute vendor_id\n"); + err = TestWriteAttributeVendorId_149(); break; case 150: - ChipLogProgress(chipTool, " ***** Test Step 150 : Send a command with a vendor_id and enum\n"); - err = TestSendACommandWithAVendorIdAndEnum_150(); + ChipLogProgress(chipTool, " ***** Test Step 150 : Read attribute vendor_id\n"); + err = TestReadAttributeVendorId_150(); break; case 151: - ChipLogProgress(chipTool, " ***** Test Step 151 : Send Test Command With Struct Argument and arg1.b is true\n"); - err = TestSendTestCommandWithStructArgumentAndArg1bIsTrue_151(); + ChipLogProgress(chipTool, " ***** Test Step 151 : Restore attribute vendor_id\n"); + err = TestRestoreAttributeVendorId_151(); break; case 152: - ChipLogProgress(chipTool, " ***** Test Step 152 : Send Test Command With Struct Argument and arg1.b is false\n"); - err = TestSendTestCommandWithStructArgumentAndArg1bIsFalse_152(); + ChipLogProgress(chipTool, " ***** Test Step 152 : Send a command with a vendor_id and enum\n"); + err = TestSendACommandWithAVendorIdAndEnum_152(); break; case 153: - ChipLogProgress(chipTool, - " ***** Test Step 153 : Send Test Command With Nested Struct Argument and arg1.c.b is true\n"); - err = TestSendTestCommandWithNestedStructArgumentAndArg1cbIsTrue_153(); + ChipLogProgress(chipTool, " ***** Test Step 153 : Send Test Command With Struct Argument and arg1.b is true\n"); + err = TestSendTestCommandWithStructArgumentAndArg1bIsTrue_153(); break; case 154: - ChipLogProgress(chipTool, " ***** Test Step 154 : Send Test Command With Nested Struct Argument arg1.c.b is false\n"); - err = TestSendTestCommandWithNestedStructArgumentArg1cbIsFalse_154(); + ChipLogProgress(chipTool, " ***** Test Step 154 : Send Test Command With Struct Argument and arg1.b is false\n"); + err = TestSendTestCommandWithStructArgumentAndArg1bIsFalse_154(); break; case 155: - ChipLogProgress( - chipTool, - " ***** Test Step 155 : Send Test Command With Nested Struct List Argument and all fields b of arg1.d are true\n"); - err = TestSendTestCommandWithNestedStructListArgumentAndAllFieldsBOfArg1dAreTrue_155(); + ChipLogProgress(chipTool, + " ***** Test Step 155 : Send Test Command With Nested Struct Argument and arg1.c.b is true\n"); + err = TestSendTestCommandWithNestedStructArgumentAndArg1cbIsTrue_155(); break; case 156: - ChipLogProgress(chipTool, - " ***** Test Step 156 : Send Test Command With Nested Struct List Argument and some fields b of arg1.d " - "are false\n"); - err = TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfArg1dAreFalse_156(); + ChipLogProgress(chipTool, " ***** Test Step 156 : Send Test Command With Nested Struct Argument arg1.c.b is false\n"); + err = TestSendTestCommandWithNestedStructArgumentArg1cbIsFalse_156(); break; case 157: - ChipLogProgress(chipTool, " ***** Test Step 157 : Send Test Command With Struct Argument and see what we get back\n"); - err = TestSendTestCommandWithStructArgumentAndSeeWhatWeGetBack_157(); + ChipLogProgress( + chipTool, + " ***** Test Step 157 : Send Test Command With Nested Struct List Argument and all fields b of arg1.d are true\n"); + err = TestSendTestCommandWithNestedStructListArgumentAndAllFieldsBOfArg1dAreTrue_157(); break; case 158: - ChipLogProgress(chipTool, " ***** Test Step 158 : Send Test Command With List of INT8U and none of them is set to 0\n"); - err = TestSendTestCommandWithListOfInt8uAndNoneOfThemIsSetTo0_158(); + ChipLogProgress(chipTool, + " ***** Test Step 158 : Send Test Command With Nested Struct List Argument and some fields b of arg1.d " + "are false\n"); + err = TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfArg1dAreFalse_158(); break; case 159: - ChipLogProgress(chipTool, " ***** Test Step 159 : Send Test Command With List of INT8U and one of them is set to 0\n"); - err = TestSendTestCommandWithListOfInt8uAndOneOfThemIsSetTo0_159(); + ChipLogProgress(chipTool, " ***** Test Step 159 : Send Test Command With Struct Argument and see what we get back\n"); + err = TestSendTestCommandWithStructArgumentAndSeeWhatWeGetBack_159(); break; case 160: - ChipLogProgress(chipTool, " ***** Test Step 160 : Send Test Command With List of INT8U and get it reversed\n"); - err = TestSendTestCommandWithListOfInt8uAndGetItReversed_160(); + ChipLogProgress(chipTool, " ***** Test Step 160 : Send Test Command With List of INT8U and none of them is set to 0\n"); + err = TestSendTestCommandWithListOfInt8uAndNoneOfThemIsSetTo0_160(); break; case 161: - ChipLogProgress(chipTool, - " ***** Test Step 161 : Send Test Command With empty List of INT8U and get an empty list back\n"); - err = TestSendTestCommandWithEmptyListOfInt8uAndGetAnEmptyListBack_161(); + ChipLogProgress(chipTool, " ***** Test Step 161 : Send Test Command With List of INT8U and one of them is set to 0\n"); + err = TestSendTestCommandWithListOfInt8uAndOneOfThemIsSetTo0_161(); break; case 162: - ChipLogProgress( - chipTool, - " ***** Test Step 162 : Send Test Command With List of Struct Argument and arg1.b of first item is true\n"); - err = TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsTrue_162(); + ChipLogProgress(chipTool, " ***** Test Step 162 : Send Test Command With List of INT8U and get it reversed\n"); + err = TestSendTestCommandWithListOfInt8uAndGetItReversed_162(); break; case 163: - ChipLogProgress( - chipTool, - " ***** Test Step 163 : Send Test Command With List of Struct Argument and arg1.b of first item is false\n"); - err = TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsFalse_163(); + ChipLogProgress(chipTool, + " ***** Test Step 163 : Send Test Command With empty List of INT8U and get an empty list back\n"); + err = TestSendTestCommandWithEmptyListOfInt8uAndGetAnEmptyListBack_163(); break; case 164: - ChipLogProgress(chipTool, - " ***** Test Step 164 : Send Test Command With List of Nested Struct List Argument and all fields b of " - "elements of arg1.d are true\n"); - err = TestSendTestCommandWithListOfNestedStructListArgumentAndAllFieldsBOfElementsOfArg1dAreTrue_164(); + ChipLogProgress( + chipTool, + " ***** Test Step 164 : Send Test Command With List of Struct Argument and arg1.b of first item is true\n"); + err = TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsTrue_164(); break; case 165: - ChipLogProgress(chipTool, - " ***** Test Step 165 : Send Test Command With Nested Struct List Argument and some fields b of " - "elements of arg1.d are false\n"); - err = TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfElementsOfArg1dAreFalse_165(); + ChipLogProgress( + chipTool, + " ***** Test Step 165 : Send Test Command With List of Struct Argument and arg1.b of first item is false\n"); + err = TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsFalse_165(); break; case 166: ChipLogProgress(chipTool, - " ***** Test Step 166 : Write attribute LIST With List of INT8U and none of them is set to 0\n"); - err = TestWriteAttributeListWithListOfInt8uAndNoneOfThemIsSetTo0_166(); + " ***** Test Step 166 : Send Test Command With List of Nested Struct List Argument and all fields b of " + "elements of arg1.d are true\n"); + err = TestSendTestCommandWithListOfNestedStructListArgumentAndAllFieldsBOfElementsOfArg1dAreTrue_166(); break; case 167: - ChipLogProgress(chipTool, " ***** Test Step 167 : Read attribute LIST With List of INT8U\n"); - err = TestReadAttributeListWithListOfInt8u_167(); + ChipLogProgress(chipTool, + " ***** Test Step 167 : Send Test Command With Nested Struct List Argument and some fields b of " + "elements of arg1.d are false\n"); + err = TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfElementsOfArg1dAreFalse_167(); break; case 168: - ChipLogProgress(chipTool, " ***** Test Step 168 : Write attribute LIST With List of OCTET_STRING\n"); - err = TestWriteAttributeListWithListOfOctetString_168(); + ChipLogProgress(chipTool, + " ***** Test Step 168 : Write attribute LIST With List of INT8U and none of them is set to 0\n"); + err = TestWriteAttributeListWithListOfInt8uAndNoneOfThemIsSetTo0_168(); break; case 169: - ChipLogProgress(chipTool, " ***** Test Step 169 : Read attribute LIST With List of OCTET_STRING\n"); - err = TestReadAttributeListWithListOfOctetString_169(); + ChipLogProgress(chipTool, " ***** Test Step 169 : Read attribute LIST With List of INT8U\n"); + err = TestReadAttributeListWithListOfInt8u_169(); break; case 170: - ChipLogProgress(chipTool, " ***** Test Step 170 : Write attribute LIST With List of LIST_STRUCT_OCTET_STRING\n"); - err = TestWriteAttributeListWithListOfListStructOctetString_170(); + ChipLogProgress(chipTool, " ***** Test Step 170 : Write attribute LIST With List of OCTET_STRING\n"); + err = TestWriteAttributeListWithListOfOctetString_170(); break; case 171: - ChipLogProgress(chipTool, " ***** Test Step 171 : Read attribute LIST With List of LIST_STRUCT_OCTET_STRING\n"); - err = TestReadAttributeListWithListOfListStructOctetString_171(); + ChipLogProgress(chipTool, " ***** Test Step 171 : Read attribute LIST With List of OCTET_STRING\n"); + err = TestReadAttributeListWithListOfOctetString_171(); break; case 172: - ChipLogProgress(chipTool, " ***** Test Step 172 : Send Test Command with optional arg set.\n"); - err = TestSendTestCommandWithOptionalArgSet_172(); + ChipLogProgress(chipTool, " ***** Test Step 172 : Write attribute LIST With List of LIST_STRUCT_OCTET_STRING\n"); + err = TestWriteAttributeListWithListOfListStructOctetString_172(); break; case 173: - ChipLogProgress(chipTool, " ***** Test Step 173 : Send Test Command without its optional arg.\n"); - err = TestSendTestCommandWithoutItsOptionalArg_173(); + ChipLogProgress(chipTool, " ***** Test Step 173 : Read attribute LIST With List of LIST_STRUCT_OCTET_STRING\n"); + err = TestReadAttributeListWithListOfListStructOctetString_173(); break; case 174: - ChipLogProgress(chipTool, " ***** Test Step 174 : Read list of structs containing nullables and optionals\n"); - err = TestReadListOfStructsContainingNullablesAndOptionals_174(); + ChipLogProgress(chipTool, " ***** Test Step 174 : Send Test Command with optional arg set.\n"); + err = TestSendTestCommandWithOptionalArgSet_174(); break; case 175: - ChipLogProgress(chipTool, " ***** Test Step 175 : Write list of structs containing nullables and optionals\n"); - err = TestWriteListOfStructsContainingNullablesAndOptionals_175(); + ChipLogProgress(chipTool, " ***** Test Step 175 : Send Test Command without its optional arg.\n"); + err = TestSendTestCommandWithoutItsOptionalArg_175(); break; case 176: - ChipLogProgress(chipTool, - " ***** Test Step 176 : Read list of structs containing nullables and optionals after writing\n"); - err = TestReadListOfStructsContainingNullablesAndOptionalsAfterWriting_176(); + ChipLogProgress(chipTool, " ***** Test Step 176 : Read list of structs containing nullables and optionals\n"); + err = TestReadListOfStructsContainingNullablesAndOptionals_176(); break; case 177: - ChipLogProgress(chipTool, " ***** Test Step 177 : Write attribute NULLABLE_BOOLEAN null\n"); - err = TestWriteAttributeNullableBooleanNull_177(); + ChipLogProgress(chipTool, " ***** Test Step 177 : Write list of structs containing nullables and optionals\n"); + err = TestWriteListOfStructsContainingNullablesAndOptionals_177(); break; case 178: - ChipLogProgress(chipTool, " ***** Test Step 178 : Read attribute NULLABLE_BOOLEAN null\n"); - err = TestReadAttributeNullableBooleanNull_178(); + ChipLogProgress(chipTool, + " ***** Test Step 178 : Read list of structs containing nullables and optionals after writing\n"); + err = TestReadListOfStructsContainingNullablesAndOptionalsAfterWriting_178(); break; case 179: - ChipLogProgress(chipTool, " ***** Test Step 179 : Write attribute NULLABLE_BOOLEAN True\n"); - err = TestWriteAttributeNullableBooleanTrue_179(); + ChipLogProgress(chipTool, " ***** Test Step 179 : Write attribute NULLABLE_BOOLEAN null\n"); + err = TestWriteAttributeNullableBooleanNull_179(); break; case 180: - ChipLogProgress(chipTool, " ***** Test Step 180 : Read attribute NULLABLE_BOOLEAN True\n"); - err = TestReadAttributeNullableBooleanTrue_180(); + ChipLogProgress(chipTool, " ***** Test Step 180 : Read attribute NULLABLE_BOOLEAN null\n"); + err = TestReadAttributeNullableBooleanNull_180(); break; case 181: - ChipLogProgress(chipTool, " ***** Test Step 181 : Write attribute NULLABLE_BITMAP8 Max Value\n"); - err = TestWriteAttributeNullableBitmap8MaxValue_181(); + ChipLogProgress(chipTool, " ***** Test Step 181 : Write attribute NULLABLE_BOOLEAN True\n"); + err = TestWriteAttributeNullableBooleanTrue_181(); break; case 182: - ChipLogProgress(chipTool, " ***** Test Step 182 : Read attribute NULLABLE_BITMAP8 Max Value\n"); - err = TestReadAttributeNullableBitmap8MaxValue_182(); + ChipLogProgress(chipTool, " ***** Test Step 182 : Read attribute NULLABLE_BOOLEAN True\n"); + err = TestReadAttributeNullableBooleanTrue_182(); break; case 183: - ChipLogProgress(chipTool, " ***** Test Step 183 : Write attribute NULLABLE_BITMAP8 Invalid Value\n"); - err = TestWriteAttributeNullableBitmap8InvalidValue_183(); + ChipLogProgress(chipTool, " ***** Test Step 183 : Write attribute NULLABLE_BITMAP8 Max Value\n"); + err = TestWriteAttributeNullableBitmap8MaxValue_183(); break; case 184: - ChipLogProgress(chipTool, " ***** Test Step 184 : Read attribute NULLABLE_BITMAP8 unchanged Value\n"); - err = TestReadAttributeNullableBitmap8UnchangedValue_184(); + ChipLogProgress(chipTool, " ***** Test Step 184 : Read attribute NULLABLE_BITMAP8 Max Value\n"); + err = TestReadAttributeNullableBitmap8MaxValue_184(); break; case 185: - ChipLogProgress(chipTool, " ***** Test Step 185 : Write attribute NULLABLE_BITMAP8 null Value\n"); - err = TestWriteAttributeNullableBitmap8NullValue_185(); + ChipLogProgress(chipTool, " ***** Test Step 185 : Write attribute NULLABLE_BITMAP8 Invalid Value\n"); + err = TestWriteAttributeNullableBitmap8InvalidValue_185(); break; case 186: - ChipLogProgress(chipTool, " ***** Test Step 186 : Read attribute NULLABLE_BITMAP8 null Value\n"); - err = TestReadAttributeNullableBitmap8NullValue_186(); + ChipLogProgress(chipTool, " ***** Test Step 186 : Read attribute NULLABLE_BITMAP8 unchanged Value\n"); + err = TestReadAttributeNullableBitmap8UnchangedValue_186(); break; case 187: - ChipLogProgress(chipTool, " ***** Test Step 187 : Write attribute NULLABLE_BITMAP16 Max Value\n"); - err = TestWriteAttributeNullableBitmap16MaxValue_187(); + ChipLogProgress(chipTool, " ***** Test Step 187 : Write attribute NULLABLE_BITMAP8 null Value\n"); + err = TestWriteAttributeNullableBitmap8NullValue_187(); break; case 188: - ChipLogProgress(chipTool, " ***** Test Step 188 : Read attribute NULLABLE_BITMAP16 Max Value\n"); - err = TestReadAttributeNullableBitmap16MaxValue_188(); + ChipLogProgress(chipTool, " ***** Test Step 188 : Read attribute NULLABLE_BITMAP8 null Value\n"); + err = TestReadAttributeNullableBitmap8NullValue_188(); break; case 189: - ChipLogProgress(chipTool, " ***** Test Step 189 : Write attribute NULLABLE_BITMAP16 Invalid Value\n"); - err = TestWriteAttributeNullableBitmap16InvalidValue_189(); + ChipLogProgress(chipTool, " ***** Test Step 189 : Write attribute NULLABLE_BITMAP16 Max Value\n"); + err = TestWriteAttributeNullableBitmap16MaxValue_189(); break; case 190: - ChipLogProgress(chipTool, " ***** Test Step 190 : Read attribute NULLABLE_BITMAP16 unchanged Value\n"); - err = TestReadAttributeNullableBitmap16UnchangedValue_190(); + ChipLogProgress(chipTool, " ***** Test Step 190 : Read attribute NULLABLE_BITMAP16 Max Value\n"); + err = TestReadAttributeNullableBitmap16MaxValue_190(); break; case 191: - ChipLogProgress(chipTool, " ***** Test Step 191 : Write attribute NULLABLE_BITMAP16 null Value\n"); - err = TestWriteAttributeNullableBitmap16NullValue_191(); + ChipLogProgress(chipTool, " ***** Test Step 191 : Write attribute NULLABLE_BITMAP16 Invalid Value\n"); + err = TestWriteAttributeNullableBitmap16InvalidValue_191(); break; case 192: - ChipLogProgress(chipTool, " ***** Test Step 192 : Read attribute NULLABLE_BITMAP16 null Value\n"); - err = TestReadAttributeNullableBitmap16NullValue_192(); + ChipLogProgress(chipTool, " ***** Test Step 192 : Read attribute NULLABLE_BITMAP16 unchanged Value\n"); + err = TestReadAttributeNullableBitmap16UnchangedValue_192(); break; case 193: - ChipLogProgress(chipTool, " ***** Test Step 193 : Write attribute NULLABLE_BITMAP32 Max Value\n"); - err = TestWriteAttributeNullableBitmap32MaxValue_193(); + ChipLogProgress(chipTool, " ***** Test Step 193 : Write attribute NULLABLE_BITMAP16 null Value\n"); + err = TestWriteAttributeNullableBitmap16NullValue_193(); break; case 194: - ChipLogProgress(chipTool, " ***** Test Step 194 : Read attribute NULLABLE_BITMAP32 Max Value\n"); - err = TestReadAttributeNullableBitmap32MaxValue_194(); + ChipLogProgress(chipTool, " ***** Test Step 194 : Read attribute NULLABLE_BITMAP16 null Value\n"); + err = TestReadAttributeNullableBitmap16NullValue_194(); break; case 195: - ChipLogProgress(chipTool, " ***** Test Step 195 : Write attribute NULLABLE_BITMAP32 Invalid Value\n"); - err = TestWriteAttributeNullableBitmap32InvalidValue_195(); + ChipLogProgress(chipTool, " ***** Test Step 195 : Write attribute NULLABLE_BITMAP32 Max Value\n"); + err = TestWriteAttributeNullableBitmap32MaxValue_195(); break; case 196: - ChipLogProgress(chipTool, " ***** Test Step 196 : Read attribute NULLABLE_BITMAP32 unchanged Value\n"); - err = TestReadAttributeNullableBitmap32UnchangedValue_196(); + ChipLogProgress(chipTool, " ***** Test Step 196 : Read attribute NULLABLE_BITMAP32 Max Value\n"); + err = TestReadAttributeNullableBitmap32MaxValue_196(); break; case 197: - ChipLogProgress(chipTool, " ***** Test Step 197 : Write attribute NULLABLE_BITMAP32 null Value\n"); - err = TestWriteAttributeNullableBitmap32NullValue_197(); + ChipLogProgress(chipTool, " ***** Test Step 197 : Write attribute NULLABLE_BITMAP32 Invalid Value\n"); + err = TestWriteAttributeNullableBitmap32InvalidValue_197(); break; case 198: - ChipLogProgress(chipTool, " ***** Test Step 198 : Read attribute NULLABLE_BITMAP32 null Value\n"); - err = TestReadAttributeNullableBitmap32NullValue_198(); + ChipLogProgress(chipTool, " ***** Test Step 198 : Read attribute NULLABLE_BITMAP32 unchanged Value\n"); + err = TestReadAttributeNullableBitmap32UnchangedValue_198(); break; case 199: - ChipLogProgress(chipTool, " ***** Test Step 199 : Write attribute NULLABLE_BITMAP64 Max Value\n"); - err = TestWriteAttributeNullableBitmap64MaxValue_199(); + ChipLogProgress(chipTool, " ***** Test Step 199 : Write attribute NULLABLE_BITMAP32 null Value\n"); + err = TestWriteAttributeNullableBitmap32NullValue_199(); break; case 200: - ChipLogProgress(chipTool, " ***** Test Step 200 : Read attribute NULLABLE_BITMAP64 Max Value\n"); - err = TestReadAttributeNullableBitmap64MaxValue_200(); + ChipLogProgress(chipTool, " ***** Test Step 200 : Read attribute NULLABLE_BITMAP32 null Value\n"); + err = TestReadAttributeNullableBitmap32NullValue_200(); break; case 201: - ChipLogProgress(chipTool, " ***** Test Step 201 : Write attribute NULLABLE_BITMAP64 Invalid Value\n"); - err = TestWriteAttributeNullableBitmap64InvalidValue_201(); + ChipLogProgress(chipTool, " ***** Test Step 201 : Write attribute NULLABLE_BITMAP64 Max Value\n"); + err = TestWriteAttributeNullableBitmap64MaxValue_201(); break; case 202: - ChipLogProgress(chipTool, " ***** Test Step 202 : Read attribute NULLABLE_BITMAP64 unchanged Value\n"); - err = TestReadAttributeNullableBitmap64UnchangedValue_202(); + ChipLogProgress(chipTool, " ***** Test Step 202 : Read attribute NULLABLE_BITMAP64 Max Value\n"); + err = TestReadAttributeNullableBitmap64MaxValue_202(); break; case 203: - ChipLogProgress(chipTool, " ***** Test Step 203 : Write attribute NULLABLE_BITMAP64 null Value\n"); - err = TestWriteAttributeNullableBitmap64NullValue_203(); + ChipLogProgress(chipTool, " ***** Test Step 203 : Write attribute NULLABLE_BITMAP64 Invalid Value\n"); + err = TestWriteAttributeNullableBitmap64InvalidValue_203(); break; case 204: - ChipLogProgress(chipTool, " ***** Test Step 204 : Read attribute NULLABLE_BITMAP64 null Value\n"); - err = TestReadAttributeNullableBitmap64NullValue_204(); + ChipLogProgress(chipTool, " ***** Test Step 204 : Read attribute NULLABLE_BITMAP64 unchanged Value\n"); + err = TestReadAttributeNullableBitmap64UnchangedValue_204(); break; case 205: - ChipLogProgress(chipTool, " ***** Test Step 205 : Write attribute NULLABLE_INT8U Min Value\n"); - err = TestWriteAttributeNullableInt8uMinValue_205(); + ChipLogProgress(chipTool, " ***** Test Step 205 : Write attribute NULLABLE_BITMAP64 null Value\n"); + err = TestWriteAttributeNullableBitmap64NullValue_205(); break; case 206: - ChipLogProgress(chipTool, " ***** Test Step 206 : Read attribute NULLABLE_INT8U Min Value\n"); - err = TestReadAttributeNullableInt8uMinValue_206(); + ChipLogProgress(chipTool, " ***** Test Step 206 : Read attribute NULLABLE_BITMAP64 null Value\n"); + err = TestReadAttributeNullableBitmap64NullValue_206(); break; case 207: - ChipLogProgress(chipTool, " ***** Test Step 207 : Write attribute NULLABLE_INT8U Max Value\n"); - err = TestWriteAttributeNullableInt8uMaxValue_207(); + ChipLogProgress(chipTool, " ***** Test Step 207 : Write attribute NULLABLE_INT8U Min Value\n"); + err = TestWriteAttributeNullableInt8uMinValue_207(); break; case 208: - ChipLogProgress(chipTool, " ***** Test Step 208 : Read attribute NULLABLE_INT8U Max Value\n"); - err = TestReadAttributeNullableInt8uMaxValue_208(); + ChipLogProgress(chipTool, " ***** Test Step 208 : Read attribute NULLABLE_INT8U Min Value\n"); + err = TestReadAttributeNullableInt8uMinValue_208(); break; case 209: - ChipLogProgress(chipTool, " ***** Test Step 209 : Write attribute NULLABLE_INT8U Invalid Value\n"); - err = TestWriteAttributeNullableInt8uInvalidValue_209(); + ChipLogProgress(chipTool, " ***** Test Step 209 : Write attribute NULLABLE_INT8U Max Value\n"); + err = TestWriteAttributeNullableInt8uMaxValue_209(); break; case 210: - ChipLogProgress(chipTool, " ***** Test Step 210 : Read attribute NULLABLE_INT8U unchanged Value\n"); - err = TestReadAttributeNullableInt8uUnchangedValue_210(); + ChipLogProgress(chipTool, " ***** Test Step 210 : Read attribute NULLABLE_INT8U Max Value\n"); + err = TestReadAttributeNullableInt8uMaxValue_210(); break; case 211: - ChipLogProgress(chipTool, " ***** Test Step 211 : Read attribute NULLABLE_INT8U unchanged Value with constraint\n"); - err = TestReadAttributeNullableInt8uUnchangedValueWithConstraint_211(); + ChipLogProgress(chipTool, " ***** Test Step 211 : Write attribute NULLABLE_INT8U Invalid Value\n"); + err = TestWriteAttributeNullableInt8uInvalidValue_211(); break; case 212: - ChipLogProgress(chipTool, " ***** Test Step 212 : Write attribute NULLABLE_INT8U null Value\n"); - err = TestWriteAttributeNullableInt8uNullValue_212(); + ChipLogProgress(chipTool, " ***** Test Step 212 : Read attribute NULLABLE_INT8U unchanged Value\n"); + err = TestReadAttributeNullableInt8uUnchangedValue_212(); break; case 213: - ChipLogProgress(chipTool, " ***** Test Step 213 : Read attribute NULLABLE_INT8U null Value\n"); - err = TestReadAttributeNullableInt8uNullValue_213(); + ChipLogProgress(chipTool, " ***** Test Step 213 : Read attribute NULLABLE_INT8U unchanged Value with constraint\n"); + err = TestReadAttributeNullableInt8uUnchangedValueWithConstraint_213(); break; case 214: - ChipLogProgress(chipTool, " ***** Test Step 214 : Read attribute NULLABLE_INT8U null Value & range\n"); - err = TestReadAttributeNullableInt8uNullValueRange_214(); + ChipLogProgress(chipTool, " ***** Test Step 214 : Write attribute NULLABLE_INT8U null Value\n"); + err = TestWriteAttributeNullableInt8uNullValue_214(); break; case 215: - ChipLogProgress(chipTool, " ***** Test Step 215 : Read attribute NULLABLE_INT8U null Value & not\n"); - err = TestReadAttributeNullableInt8uNullValueNot_215(); + ChipLogProgress(chipTool, " ***** Test Step 215 : Read attribute NULLABLE_INT8U null Value\n"); + err = TestReadAttributeNullableInt8uNullValue_215(); break; case 216: - ChipLogProgress(chipTool, " ***** Test Step 216 : Write attribute NULLABLE_INT8U Value\n"); - err = TestWriteAttributeNullableInt8uValue_216(); + ChipLogProgress(chipTool, " ***** Test Step 216 : Read attribute NULLABLE_INT8U null Value & range\n"); + err = TestReadAttributeNullableInt8uNullValueRange_216(); break; case 217: - ChipLogProgress(chipTool, " ***** Test Step 217 : Read attribute NULLABLE_INT8U Value in range\n"); - err = TestReadAttributeNullableInt8uValueInRange_217(); + ChipLogProgress(chipTool, " ***** Test Step 217 : Read attribute NULLABLE_INT8U null Value & not\n"); + err = TestReadAttributeNullableInt8uNullValueNot_217(); break; case 218: - ChipLogProgress(chipTool, " ***** Test Step 218 : Read attribute NULLABLE_INT8U notValue OK\n"); - err = TestReadAttributeNullableInt8uNotValueOk_218(); + ChipLogProgress(chipTool, " ***** Test Step 218 : Write attribute NULLABLE_INT8U Value\n"); + err = TestWriteAttributeNullableInt8uValue_218(); break; case 219: - ChipLogProgress(chipTool, " ***** Test Step 219 : Write attribute NULLABLE_INT16U Min Value\n"); - err = TestWriteAttributeNullableInt16uMinValue_219(); + ChipLogProgress(chipTool, " ***** Test Step 219 : Read attribute NULLABLE_INT8U Value in range\n"); + err = TestReadAttributeNullableInt8uValueInRange_219(); break; case 220: - ChipLogProgress(chipTool, " ***** Test Step 220 : Read attribute NULLABLE_INT16U Min Value\n"); - err = TestReadAttributeNullableInt16uMinValue_220(); + ChipLogProgress(chipTool, " ***** Test Step 220 : Read attribute NULLABLE_INT8U notValue OK\n"); + err = TestReadAttributeNullableInt8uNotValueOk_220(); break; case 221: - ChipLogProgress(chipTool, " ***** Test Step 221 : Write attribute NULLABLE_INT16U Max Value\n"); - err = TestWriteAttributeNullableInt16uMaxValue_221(); + ChipLogProgress(chipTool, " ***** Test Step 221 : Write attribute NULLABLE_INT16U Min Value\n"); + err = TestWriteAttributeNullableInt16uMinValue_221(); break; case 222: - ChipLogProgress(chipTool, " ***** Test Step 222 : Read attribute NULLABLE_INT16U Max Value\n"); - err = TestReadAttributeNullableInt16uMaxValue_222(); + ChipLogProgress(chipTool, " ***** Test Step 222 : Read attribute NULLABLE_INT16U Min Value\n"); + err = TestReadAttributeNullableInt16uMinValue_222(); break; case 223: - ChipLogProgress(chipTool, " ***** Test Step 223 : Write attribute NULLABLE_INT16U Invalid Value\n"); - err = TestWriteAttributeNullableInt16uInvalidValue_223(); + ChipLogProgress(chipTool, " ***** Test Step 223 : Write attribute NULLABLE_INT16U Max Value\n"); + err = TestWriteAttributeNullableInt16uMaxValue_223(); break; case 224: - ChipLogProgress(chipTool, " ***** Test Step 224 : Read attribute NULLABLE_INT16U unchanged Value\n"); - err = TestReadAttributeNullableInt16uUnchangedValue_224(); + ChipLogProgress(chipTool, " ***** Test Step 224 : Read attribute NULLABLE_INT16U Max Value\n"); + err = TestReadAttributeNullableInt16uMaxValue_224(); break; case 225: - ChipLogProgress(chipTool, " ***** Test Step 225 : Write attribute NULLABLE_INT16U null Value\n"); - err = TestWriteAttributeNullableInt16uNullValue_225(); + ChipLogProgress(chipTool, " ***** Test Step 225 : Write attribute NULLABLE_INT16U Invalid Value\n"); + err = TestWriteAttributeNullableInt16uInvalidValue_225(); break; case 226: - ChipLogProgress(chipTool, " ***** Test Step 226 : Read attribute NULLABLE_INT16U null Value\n"); - err = TestReadAttributeNullableInt16uNullValue_226(); + ChipLogProgress(chipTool, " ***** Test Step 226 : Read attribute NULLABLE_INT16U unchanged Value\n"); + err = TestReadAttributeNullableInt16uUnchangedValue_226(); break; case 227: - ChipLogProgress(chipTool, " ***** Test Step 227 : Read attribute NULLABLE_INT16U null Value & range\n"); - err = TestReadAttributeNullableInt16uNullValueRange_227(); + ChipLogProgress(chipTool, " ***** Test Step 227 : Write attribute NULLABLE_INT16U null Value\n"); + err = TestWriteAttributeNullableInt16uNullValue_227(); break; case 228: - ChipLogProgress(chipTool, " ***** Test Step 228 : Read attribute NULLABLE_INT16U null Value & not\n"); - err = TestReadAttributeNullableInt16uNullValueNot_228(); + ChipLogProgress(chipTool, " ***** Test Step 228 : Read attribute NULLABLE_INT16U null Value\n"); + err = TestReadAttributeNullableInt16uNullValue_228(); break; case 229: - ChipLogProgress(chipTool, " ***** Test Step 229 : Write attribute NULLABLE_INT16U Value\n"); - err = TestWriteAttributeNullableInt16uValue_229(); + ChipLogProgress(chipTool, " ***** Test Step 229 : Read attribute NULLABLE_INT16U null Value & range\n"); + err = TestReadAttributeNullableInt16uNullValueRange_229(); break; case 230: - ChipLogProgress(chipTool, " ***** Test Step 230 : Read attribute NULLABLE_INT16U Value in range\n"); - err = TestReadAttributeNullableInt16uValueInRange_230(); + ChipLogProgress(chipTool, " ***** Test Step 230 : Read attribute NULLABLE_INT16U null Value & not\n"); + err = TestReadAttributeNullableInt16uNullValueNot_230(); break; case 231: - ChipLogProgress(chipTool, " ***** Test Step 231 : Read attribute NULLABLE_INT16U notValue OK\n"); - err = TestReadAttributeNullableInt16uNotValueOk_231(); + ChipLogProgress(chipTool, " ***** Test Step 231 : Write attribute NULLABLE_INT16U Value\n"); + err = TestWriteAttributeNullableInt16uValue_231(); break; case 232: - ChipLogProgress(chipTool, " ***** Test Step 232 : Write attribute NULLABLE_INT32U Min Value\n"); - err = TestWriteAttributeNullableInt32uMinValue_232(); + ChipLogProgress(chipTool, " ***** Test Step 232 : Read attribute NULLABLE_INT16U Value in range\n"); + err = TestReadAttributeNullableInt16uValueInRange_232(); break; case 233: - ChipLogProgress(chipTool, " ***** Test Step 233 : Read attribute NULLABLE_INT32U Min Value\n"); - err = TestReadAttributeNullableInt32uMinValue_233(); + ChipLogProgress(chipTool, " ***** Test Step 233 : Read attribute NULLABLE_INT16U notValue OK\n"); + err = TestReadAttributeNullableInt16uNotValueOk_233(); break; case 234: - ChipLogProgress(chipTool, " ***** Test Step 234 : Write attribute NULLABLE_INT32U Max Value\n"); - err = TestWriteAttributeNullableInt32uMaxValue_234(); + ChipLogProgress(chipTool, " ***** Test Step 234 : Write attribute NULLABLE_INT32U Min Value\n"); + err = TestWriteAttributeNullableInt32uMinValue_234(); break; case 235: - ChipLogProgress(chipTool, " ***** Test Step 235 : Read attribute NULLABLE_INT32U Max Value\n"); - err = TestReadAttributeNullableInt32uMaxValue_235(); + ChipLogProgress(chipTool, " ***** Test Step 235 : Read attribute NULLABLE_INT32U Min Value\n"); + err = TestReadAttributeNullableInt32uMinValue_235(); break; case 236: - ChipLogProgress(chipTool, " ***** Test Step 236 : Write attribute NULLABLE_INT32U Invalid Value\n"); - err = TestWriteAttributeNullableInt32uInvalidValue_236(); + ChipLogProgress(chipTool, " ***** Test Step 236 : Write attribute NULLABLE_INT32U Max Value\n"); + err = TestWriteAttributeNullableInt32uMaxValue_236(); break; case 237: - ChipLogProgress(chipTool, " ***** Test Step 237 : Read attribute NULLABLE_INT32U unchanged Value\n"); - err = TestReadAttributeNullableInt32uUnchangedValue_237(); + ChipLogProgress(chipTool, " ***** Test Step 237 : Read attribute NULLABLE_INT32U Max Value\n"); + err = TestReadAttributeNullableInt32uMaxValue_237(); break; case 238: - ChipLogProgress(chipTool, " ***** Test Step 238 : Write attribute NULLABLE_INT32U null Value\n"); - err = TestWriteAttributeNullableInt32uNullValue_238(); + ChipLogProgress(chipTool, " ***** Test Step 238 : Write attribute NULLABLE_INT32U Invalid Value\n"); + err = TestWriteAttributeNullableInt32uInvalidValue_238(); break; case 239: - ChipLogProgress(chipTool, " ***** Test Step 239 : Read attribute NULLABLE_INT32U null Value\n"); - err = TestReadAttributeNullableInt32uNullValue_239(); + ChipLogProgress(chipTool, " ***** Test Step 239 : Read attribute NULLABLE_INT32U unchanged Value\n"); + err = TestReadAttributeNullableInt32uUnchangedValue_239(); break; case 240: - ChipLogProgress(chipTool, " ***** Test Step 240 : Read attribute NULLABLE_INT32U null Value & range\n"); - err = TestReadAttributeNullableInt32uNullValueRange_240(); + ChipLogProgress(chipTool, " ***** Test Step 240 : Write attribute NULLABLE_INT32U null Value\n"); + err = TestWriteAttributeNullableInt32uNullValue_240(); break; case 241: - ChipLogProgress(chipTool, " ***** Test Step 241 : Read attribute NULLABLE_INT32U null Value & not\n"); - err = TestReadAttributeNullableInt32uNullValueNot_241(); + ChipLogProgress(chipTool, " ***** Test Step 241 : Read attribute NULLABLE_INT32U null Value\n"); + err = TestReadAttributeNullableInt32uNullValue_241(); break; case 242: - ChipLogProgress(chipTool, " ***** Test Step 242 : Write attribute NULLABLE_INT32U Value\n"); - err = TestWriteAttributeNullableInt32uValue_242(); + ChipLogProgress(chipTool, " ***** Test Step 242 : Read attribute NULLABLE_INT32U null Value & range\n"); + err = TestReadAttributeNullableInt32uNullValueRange_242(); break; case 243: - ChipLogProgress(chipTool, " ***** Test Step 243 : Read attribute NULLABLE_INT32U Value in range\n"); - err = TestReadAttributeNullableInt32uValueInRange_243(); + ChipLogProgress(chipTool, " ***** Test Step 243 : Read attribute NULLABLE_INT32U null Value & not\n"); + err = TestReadAttributeNullableInt32uNullValueNot_243(); break; case 244: - ChipLogProgress(chipTool, " ***** Test Step 244 : Read attribute NULLABLE_INT32U notValue OK\n"); - err = TestReadAttributeNullableInt32uNotValueOk_244(); + ChipLogProgress(chipTool, " ***** Test Step 244 : Write attribute NULLABLE_INT32U Value\n"); + err = TestWriteAttributeNullableInt32uValue_244(); break; case 245: - ChipLogProgress(chipTool, " ***** Test Step 245 : Write attribute NULLABLE_INT64U Min Value\n"); - err = TestWriteAttributeNullableInt64uMinValue_245(); + ChipLogProgress(chipTool, " ***** Test Step 245 : Read attribute NULLABLE_INT32U Value in range\n"); + err = TestReadAttributeNullableInt32uValueInRange_245(); break; case 246: - ChipLogProgress(chipTool, " ***** Test Step 246 : Read attribute NULLABLE_INT64U Min Value\n"); - err = TestReadAttributeNullableInt64uMinValue_246(); + ChipLogProgress(chipTool, " ***** Test Step 246 : Read attribute NULLABLE_INT32U notValue OK\n"); + err = TestReadAttributeNullableInt32uNotValueOk_246(); break; case 247: - ChipLogProgress(chipTool, " ***** Test Step 247 : Write attribute NULLABLE_INT64U Max Value\n"); - err = TestWriteAttributeNullableInt64uMaxValue_247(); + ChipLogProgress(chipTool, " ***** Test Step 247 : Write attribute NULLABLE_INT64U Min Value\n"); + err = TestWriteAttributeNullableInt64uMinValue_247(); break; case 248: - ChipLogProgress(chipTool, " ***** Test Step 248 : Read attribute NULLABLE_INT64U Max Value\n"); - err = TestReadAttributeNullableInt64uMaxValue_248(); + ChipLogProgress(chipTool, " ***** Test Step 248 : Read attribute NULLABLE_INT64U Min Value\n"); + err = TestReadAttributeNullableInt64uMinValue_248(); break; case 249: - ChipLogProgress(chipTool, " ***** Test Step 249 : Write attribute NULLABLE_INT64U Invalid Value\n"); - err = TestWriteAttributeNullableInt64uInvalidValue_249(); + ChipLogProgress(chipTool, " ***** Test Step 249 : Write attribute NULLABLE_INT64U Max Value\n"); + err = TestWriteAttributeNullableInt64uMaxValue_249(); break; case 250: - ChipLogProgress(chipTool, " ***** Test Step 250 : Read attribute NULLABLE_INT64U unchanged Value\n"); - err = TestReadAttributeNullableInt64uUnchangedValue_250(); + ChipLogProgress(chipTool, " ***** Test Step 250 : Read attribute NULLABLE_INT64U Max Value\n"); + err = TestReadAttributeNullableInt64uMaxValue_250(); break; case 251: - ChipLogProgress(chipTool, " ***** Test Step 251 : Write attribute NULLABLE_INT64U null Value\n"); - err = TestWriteAttributeNullableInt64uNullValue_251(); + ChipLogProgress(chipTool, " ***** Test Step 251 : Write attribute NULLABLE_INT64U Invalid Value\n"); + err = TestWriteAttributeNullableInt64uInvalidValue_251(); break; case 252: - ChipLogProgress(chipTool, " ***** Test Step 252 : Read attribute NULLABLE_INT64U null Value\n"); - err = TestReadAttributeNullableInt64uNullValue_252(); + ChipLogProgress(chipTool, " ***** Test Step 252 : Read attribute NULLABLE_INT64U unchanged Value\n"); + err = TestReadAttributeNullableInt64uUnchangedValue_252(); break; case 253: - ChipLogProgress(chipTool, " ***** Test Step 253 : Read attribute NULLABLE_INT64U null Value & range\n"); - err = TestReadAttributeNullableInt64uNullValueRange_253(); + ChipLogProgress(chipTool, " ***** Test Step 253 : Write attribute NULLABLE_INT64U null Value\n"); + err = TestWriteAttributeNullableInt64uNullValue_253(); break; case 254: - ChipLogProgress(chipTool, " ***** Test Step 254 : Read attribute NULLABLE_INT64U null Value & not\n"); - err = TestReadAttributeNullableInt64uNullValueNot_254(); + ChipLogProgress(chipTool, " ***** Test Step 254 : Read attribute NULLABLE_INT64U null Value\n"); + err = TestReadAttributeNullableInt64uNullValue_254(); break; case 255: - ChipLogProgress(chipTool, " ***** Test Step 255 : Write attribute NULLABLE_INT64U Value\n"); - err = TestWriteAttributeNullableInt64uValue_255(); + ChipLogProgress(chipTool, " ***** Test Step 255 : Read attribute NULLABLE_INT64U null Value & range\n"); + err = TestReadAttributeNullableInt64uNullValueRange_255(); break; case 256: - ChipLogProgress(chipTool, " ***** Test Step 256 : Read attribute NULLABLE_INT64U Value in range\n"); - err = TestReadAttributeNullableInt64uValueInRange_256(); + ChipLogProgress(chipTool, " ***** Test Step 256 : Read attribute NULLABLE_INT64U null Value & not\n"); + err = TestReadAttributeNullableInt64uNullValueNot_256(); break; case 257: - ChipLogProgress(chipTool, " ***** Test Step 257 : Read attribute NULLABLE_INT64U notValue OK\n"); - err = TestReadAttributeNullableInt64uNotValueOk_257(); + ChipLogProgress(chipTool, " ***** Test Step 257 : Write attribute NULLABLE_INT64U Value\n"); + err = TestWriteAttributeNullableInt64uValue_257(); break; case 258: - ChipLogProgress(chipTool, " ***** Test Step 258 : Write attribute NULLABLE_INT8S Min Value\n"); - err = TestWriteAttributeNullableInt8sMinValue_258(); + ChipLogProgress(chipTool, " ***** Test Step 258 : Read attribute NULLABLE_INT64U Value in range\n"); + err = TestReadAttributeNullableInt64uValueInRange_258(); break; case 259: - ChipLogProgress(chipTool, " ***** Test Step 259 : Read attribute NULLABLE_INT8S Min Value\n"); - err = TestReadAttributeNullableInt8sMinValue_259(); + ChipLogProgress(chipTool, " ***** Test Step 259 : Read attribute NULLABLE_INT64U notValue OK\n"); + err = TestReadAttributeNullableInt64uNotValueOk_259(); break; case 260: - ChipLogProgress(chipTool, " ***** Test Step 260 : Write attribute NULLABLE_INT8S Invalid Value\n"); - err = TestWriteAttributeNullableInt8sInvalidValue_260(); + ChipLogProgress(chipTool, " ***** Test Step 260 : Write attribute NULLABLE_INT8S Min Value\n"); + err = TestWriteAttributeNullableInt8sMinValue_260(); break; case 261: - ChipLogProgress(chipTool, " ***** Test Step 261 : Read attribute NULLABLE_INT8S unchanged Value\n"); - err = TestReadAttributeNullableInt8sUnchangedValue_261(); + ChipLogProgress(chipTool, " ***** Test Step 261 : Read attribute NULLABLE_INT8S Min Value\n"); + err = TestReadAttributeNullableInt8sMinValue_261(); break; case 262: - ChipLogProgress(chipTool, " ***** Test Step 262 : Write attribute NULLABLE_INT8S null Value\n"); - err = TestWriteAttributeNullableInt8sNullValue_262(); + ChipLogProgress(chipTool, " ***** Test Step 262 : Write attribute NULLABLE_INT8S Invalid Value\n"); + err = TestWriteAttributeNullableInt8sInvalidValue_262(); break; case 263: - ChipLogProgress(chipTool, " ***** Test Step 263 : Read attribute NULLABLE_INT8S null Value\n"); - err = TestReadAttributeNullableInt8sNullValue_263(); + ChipLogProgress(chipTool, " ***** Test Step 263 : Read attribute NULLABLE_INT8S unchanged Value\n"); + err = TestReadAttributeNullableInt8sUnchangedValue_263(); break; case 264: - ChipLogProgress(chipTool, " ***** Test Step 264 : Read attribute NULLABLE_INT8S null Value & range\n"); - err = TestReadAttributeNullableInt8sNullValueRange_264(); + ChipLogProgress(chipTool, " ***** Test Step 264 : Write attribute NULLABLE_INT8S null Value\n"); + err = TestWriteAttributeNullableInt8sNullValue_264(); break; case 265: - ChipLogProgress(chipTool, " ***** Test Step 265 : Read attribute NULLABLE_INT8S null Value & not\n"); - err = TestReadAttributeNullableInt8sNullValueNot_265(); + ChipLogProgress(chipTool, " ***** Test Step 265 : Read attribute NULLABLE_INT8S null Value\n"); + err = TestReadAttributeNullableInt8sNullValue_265(); break; case 266: - ChipLogProgress(chipTool, " ***** Test Step 266 : Write attribute NULLABLE_INT8S Value\n"); - err = TestWriteAttributeNullableInt8sValue_266(); + ChipLogProgress(chipTool, " ***** Test Step 266 : Read attribute NULLABLE_INT8S null Value & range\n"); + err = TestReadAttributeNullableInt8sNullValueRange_266(); break; case 267: - ChipLogProgress(chipTool, " ***** Test Step 267 : Read attribute NULLABLE_INT8S Value in range\n"); - err = TestReadAttributeNullableInt8sValueInRange_267(); + ChipLogProgress(chipTool, " ***** Test Step 267 : Read attribute NULLABLE_INT8S null Value & not\n"); + err = TestReadAttributeNullableInt8sNullValueNot_267(); break; case 268: - ChipLogProgress(chipTool, " ***** Test Step 268 : Read attribute NULLABLE_INT8S notValue OK\n"); - err = TestReadAttributeNullableInt8sNotValueOk_268(); + ChipLogProgress(chipTool, " ***** Test Step 268 : Write attribute NULLABLE_INT8S Value\n"); + err = TestWriteAttributeNullableInt8sValue_268(); break; case 269: - ChipLogProgress(chipTool, " ***** Test Step 269 : Write attribute NULLABLE_INT16S Min Value\n"); - err = TestWriteAttributeNullableInt16sMinValue_269(); + ChipLogProgress(chipTool, " ***** Test Step 269 : Read attribute NULLABLE_INT8S Value in range\n"); + err = TestReadAttributeNullableInt8sValueInRange_269(); break; case 270: - ChipLogProgress(chipTool, " ***** Test Step 270 : Read attribute NULLABLE_INT16S Min Value\n"); - err = TestReadAttributeNullableInt16sMinValue_270(); + ChipLogProgress(chipTool, " ***** Test Step 270 : Read attribute NULLABLE_INT8S notValue OK\n"); + err = TestReadAttributeNullableInt8sNotValueOk_270(); break; case 271: - ChipLogProgress(chipTool, " ***** Test Step 271 : Write attribute NULLABLE_INT16S Invalid Value\n"); - err = TestWriteAttributeNullableInt16sInvalidValue_271(); + ChipLogProgress(chipTool, " ***** Test Step 271 : Write attribute NULLABLE_INT16S Min Value\n"); + err = TestWriteAttributeNullableInt16sMinValue_271(); break; case 272: - ChipLogProgress(chipTool, " ***** Test Step 272 : Read attribute NULLABLE_INT16S unchanged Value\n"); - err = TestReadAttributeNullableInt16sUnchangedValue_272(); + ChipLogProgress(chipTool, " ***** Test Step 272 : Read attribute NULLABLE_INT16S Min Value\n"); + err = TestReadAttributeNullableInt16sMinValue_272(); break; case 273: - ChipLogProgress(chipTool, " ***** Test Step 273 : Write attribute NULLABLE_INT16S null Value\n"); - err = TestWriteAttributeNullableInt16sNullValue_273(); + ChipLogProgress(chipTool, " ***** Test Step 273 : Write attribute NULLABLE_INT16S Invalid Value\n"); + err = TestWriteAttributeNullableInt16sInvalidValue_273(); break; case 274: - ChipLogProgress(chipTool, " ***** Test Step 274 : Read attribute NULLABLE_INT16S null Value\n"); - err = TestReadAttributeNullableInt16sNullValue_274(); + ChipLogProgress(chipTool, " ***** Test Step 274 : Read attribute NULLABLE_INT16S unchanged Value\n"); + err = TestReadAttributeNullableInt16sUnchangedValue_274(); break; case 275: - ChipLogProgress(chipTool, " ***** Test Step 275 : Read attribute NULLABLE_INT16S null Value & range\n"); - err = TestReadAttributeNullableInt16sNullValueRange_275(); + ChipLogProgress(chipTool, " ***** Test Step 275 : Write attribute NULLABLE_INT16S null Value\n"); + err = TestWriteAttributeNullableInt16sNullValue_275(); break; case 276: - ChipLogProgress(chipTool, " ***** Test Step 276 : Read attribute NULLABLE_INT16S null Value & not\n"); - err = TestReadAttributeNullableInt16sNullValueNot_276(); + ChipLogProgress(chipTool, " ***** Test Step 276 : Read attribute NULLABLE_INT16S null Value\n"); + err = TestReadAttributeNullableInt16sNullValue_276(); break; case 277: - ChipLogProgress(chipTool, " ***** Test Step 277 : Write attribute NULLABLE_INT16S Value\n"); - err = TestWriteAttributeNullableInt16sValue_277(); + ChipLogProgress(chipTool, " ***** Test Step 277 : Read attribute NULLABLE_INT16S null Value & range\n"); + err = TestReadAttributeNullableInt16sNullValueRange_277(); break; case 278: - ChipLogProgress(chipTool, " ***** Test Step 278 : Read attribute NULLABLE_INT16S Value in range\n"); - err = TestReadAttributeNullableInt16sValueInRange_278(); + ChipLogProgress(chipTool, " ***** Test Step 278 : Read attribute NULLABLE_INT16S null Value & not\n"); + err = TestReadAttributeNullableInt16sNullValueNot_278(); break; case 279: - ChipLogProgress(chipTool, " ***** Test Step 279 : Read attribute NULLABLE_INT16S notValue OK\n"); - err = TestReadAttributeNullableInt16sNotValueOk_279(); + ChipLogProgress(chipTool, " ***** Test Step 279 : Write attribute NULLABLE_INT16S Value\n"); + err = TestWriteAttributeNullableInt16sValue_279(); break; case 280: - ChipLogProgress(chipTool, " ***** Test Step 280 : Write attribute NULLABLE_INT32S Min Value\n"); - err = TestWriteAttributeNullableInt32sMinValue_280(); + ChipLogProgress(chipTool, " ***** Test Step 280 : Read attribute NULLABLE_INT16S Value in range\n"); + err = TestReadAttributeNullableInt16sValueInRange_280(); break; case 281: - ChipLogProgress(chipTool, " ***** Test Step 281 : Read attribute NULLABLE_INT32S Min Value\n"); - err = TestReadAttributeNullableInt32sMinValue_281(); + ChipLogProgress(chipTool, " ***** Test Step 281 : Read attribute NULLABLE_INT16S notValue OK\n"); + err = TestReadAttributeNullableInt16sNotValueOk_281(); break; case 282: - ChipLogProgress(chipTool, " ***** Test Step 282 : Write attribute NULLABLE_INT32S Invalid Value\n"); - err = TestWriteAttributeNullableInt32sInvalidValue_282(); + ChipLogProgress(chipTool, " ***** Test Step 282 : Write attribute NULLABLE_INT32S Min Value\n"); + err = TestWriteAttributeNullableInt32sMinValue_282(); break; case 283: - ChipLogProgress(chipTool, " ***** Test Step 283 : Read attribute NULLABLE_INT32S unchanged Value\n"); - err = TestReadAttributeNullableInt32sUnchangedValue_283(); + ChipLogProgress(chipTool, " ***** Test Step 283 : Read attribute NULLABLE_INT32S Min Value\n"); + err = TestReadAttributeNullableInt32sMinValue_283(); break; case 284: - ChipLogProgress(chipTool, " ***** Test Step 284 : Write attribute NULLABLE_INT32S null Value\n"); - err = TestWriteAttributeNullableInt32sNullValue_284(); + ChipLogProgress(chipTool, " ***** Test Step 284 : Write attribute NULLABLE_INT32S Invalid Value\n"); + err = TestWriteAttributeNullableInt32sInvalidValue_284(); break; case 285: - ChipLogProgress(chipTool, " ***** Test Step 285 : Read attribute NULLABLE_INT32S null Value\n"); - err = TestReadAttributeNullableInt32sNullValue_285(); + ChipLogProgress(chipTool, " ***** Test Step 285 : Read attribute NULLABLE_INT32S unchanged Value\n"); + err = TestReadAttributeNullableInt32sUnchangedValue_285(); break; case 286: - ChipLogProgress(chipTool, " ***** Test Step 286 : Read attribute NULLABLE_INT32S null Value & range\n"); - err = TestReadAttributeNullableInt32sNullValueRange_286(); + ChipLogProgress(chipTool, " ***** Test Step 286 : Write attribute NULLABLE_INT32S null Value\n"); + err = TestWriteAttributeNullableInt32sNullValue_286(); break; case 287: - ChipLogProgress(chipTool, " ***** Test Step 287 : Read attribute NULLABLE_INT32S null Value & not\n"); - err = TestReadAttributeNullableInt32sNullValueNot_287(); + ChipLogProgress(chipTool, " ***** Test Step 287 : Read attribute NULLABLE_INT32S null Value\n"); + err = TestReadAttributeNullableInt32sNullValue_287(); break; case 288: - ChipLogProgress(chipTool, " ***** Test Step 288 : Write attribute NULLABLE_INT32S Value\n"); - err = TestWriteAttributeNullableInt32sValue_288(); + ChipLogProgress(chipTool, " ***** Test Step 288 : Read attribute NULLABLE_INT32S null Value & range\n"); + err = TestReadAttributeNullableInt32sNullValueRange_288(); break; case 289: - ChipLogProgress(chipTool, " ***** Test Step 289 : Read attribute NULLABLE_INT32S Value in range\n"); - err = TestReadAttributeNullableInt32sValueInRange_289(); + ChipLogProgress(chipTool, " ***** Test Step 289 : Read attribute NULLABLE_INT32S null Value & not\n"); + err = TestReadAttributeNullableInt32sNullValueNot_289(); break; case 290: - ChipLogProgress(chipTool, " ***** Test Step 290 : Read attribute NULLABLE_INT32S notValue OK\n"); - err = TestReadAttributeNullableInt32sNotValueOk_290(); + ChipLogProgress(chipTool, " ***** Test Step 290 : Write attribute NULLABLE_INT32S Value\n"); + err = TestWriteAttributeNullableInt32sValue_290(); break; case 291: - ChipLogProgress(chipTool, " ***** Test Step 291 : Write attribute NULLABLE_INT64S Min Value\n"); - err = TestWriteAttributeNullableInt64sMinValue_291(); + ChipLogProgress(chipTool, " ***** Test Step 291 : Read attribute NULLABLE_INT32S Value in range\n"); + err = TestReadAttributeNullableInt32sValueInRange_291(); break; case 292: - ChipLogProgress(chipTool, " ***** Test Step 292 : Read attribute NULLABLE_INT64S Min Value\n"); - err = TestReadAttributeNullableInt64sMinValue_292(); + ChipLogProgress(chipTool, " ***** Test Step 292 : Read attribute NULLABLE_INT32S notValue OK\n"); + err = TestReadAttributeNullableInt32sNotValueOk_292(); break; case 293: - ChipLogProgress(chipTool, " ***** Test Step 293 : Write attribute NULLABLE_INT64S Invalid Value\n"); - err = TestWriteAttributeNullableInt64sInvalidValue_293(); + ChipLogProgress(chipTool, " ***** Test Step 293 : Write attribute NULLABLE_INT64S Min Value\n"); + err = TestWriteAttributeNullableInt64sMinValue_293(); break; case 294: - ChipLogProgress(chipTool, " ***** Test Step 294 : Read attribute NULLABLE_INT64S unchanged Value\n"); - err = TestReadAttributeNullableInt64sUnchangedValue_294(); + ChipLogProgress(chipTool, " ***** Test Step 294 : Read attribute NULLABLE_INT64S Min Value\n"); + err = TestReadAttributeNullableInt64sMinValue_294(); break; case 295: - ChipLogProgress(chipTool, " ***** Test Step 295 : Write attribute NULLABLE_INT64S null Value\n"); - err = TestWriteAttributeNullableInt64sNullValue_295(); + ChipLogProgress(chipTool, " ***** Test Step 295 : Write attribute NULLABLE_INT64S Invalid Value\n"); + err = TestWriteAttributeNullableInt64sInvalidValue_295(); break; case 296: - ChipLogProgress(chipTool, " ***** Test Step 296 : Read attribute NULLABLE_INT64S null Value\n"); - err = TestReadAttributeNullableInt64sNullValue_296(); + ChipLogProgress(chipTool, " ***** Test Step 296 : Read attribute NULLABLE_INT64S unchanged Value\n"); + err = TestReadAttributeNullableInt64sUnchangedValue_296(); break; case 297: - ChipLogProgress(chipTool, " ***** Test Step 297 : Read attribute NULLABLE_INT64S null Value & range\n"); - err = TestReadAttributeNullableInt64sNullValueRange_297(); + ChipLogProgress(chipTool, " ***** Test Step 297 : Write attribute NULLABLE_INT64S null Value\n"); + err = TestWriteAttributeNullableInt64sNullValue_297(); break; case 298: - ChipLogProgress(chipTool, " ***** Test Step 298 : Read attribute NULLABLE_INT64S null Value & not\n"); - err = TestReadAttributeNullableInt64sNullValueNot_298(); + ChipLogProgress(chipTool, " ***** Test Step 298 : Read attribute NULLABLE_INT64S null Value\n"); + err = TestReadAttributeNullableInt64sNullValue_298(); break; case 299: - ChipLogProgress(chipTool, " ***** Test Step 299 : Write attribute NULLABLE_INT64S Value\n"); - err = TestWriteAttributeNullableInt64sValue_299(); + ChipLogProgress(chipTool, " ***** Test Step 299 : Read attribute NULLABLE_INT64S null Value & range\n"); + err = TestReadAttributeNullableInt64sNullValueRange_299(); break; case 300: - ChipLogProgress(chipTool, " ***** Test Step 300 : Read attribute NULLABLE_INT64S Value in range\n"); - err = TestReadAttributeNullableInt64sValueInRange_300(); + ChipLogProgress(chipTool, " ***** Test Step 300 : Read attribute NULLABLE_INT64S null Value & not\n"); + err = TestReadAttributeNullableInt64sNullValueNot_300(); break; case 301: - ChipLogProgress(chipTool, " ***** Test Step 301 : Read attribute NULLABLE_INT64S notValue OK\n"); - err = TestReadAttributeNullableInt64sNotValueOk_301(); + ChipLogProgress(chipTool, " ***** Test Step 301 : Write attribute NULLABLE_INT64S Value\n"); + err = TestWriteAttributeNullableInt64sValue_301(); break; case 302: - ChipLogProgress(chipTool, " ***** Test Step 302 : Write attribute NULLABLE_SINGLE medium Value\n"); - err = TestWriteAttributeNullableSingleMediumValue_302(); + ChipLogProgress(chipTool, " ***** Test Step 302 : Read attribute NULLABLE_INT64S Value in range\n"); + err = TestReadAttributeNullableInt64sValueInRange_302(); break; case 303: - ChipLogProgress(chipTool, " ***** Test Step 303 : Read attribute NULLABLE_SINGLE medium Value\n"); - err = TestReadAttributeNullableSingleMediumValue_303(); + ChipLogProgress(chipTool, " ***** Test Step 303 : Read attribute NULLABLE_INT64S notValue OK\n"); + err = TestReadAttributeNullableInt64sNotValueOk_303(); break; case 304: - ChipLogProgress(chipTool, " ***** Test Step 304 : Write attribute NULLABLE_SINGLE largest Value\n"); - err = TestWriteAttributeNullableSingleLargestValue_304(); + ChipLogProgress(chipTool, " ***** Test Step 304 : Write attribute NULLABLE_SINGLE medium Value\n"); + err = TestWriteAttributeNullableSingleMediumValue_304(); break; case 305: - ChipLogProgress(chipTool, " ***** Test Step 305 : Read attribute NULLABLE_SINGLE largest Value\n"); - err = TestReadAttributeNullableSingleLargestValue_305(); + ChipLogProgress(chipTool, " ***** Test Step 305 : Read attribute NULLABLE_SINGLE medium Value\n"); + err = TestReadAttributeNullableSingleMediumValue_305(); break; case 306: - ChipLogProgress(chipTool, " ***** Test Step 306 : Write attribute NULLABLE_SINGLE smallest Value\n"); - err = TestWriteAttributeNullableSingleSmallestValue_306(); + ChipLogProgress(chipTool, " ***** Test Step 306 : Write attribute NULLABLE_SINGLE largest Value\n"); + err = TestWriteAttributeNullableSingleLargestValue_306(); break; case 307: - ChipLogProgress(chipTool, " ***** Test Step 307 : Read attribute NULLABLE_SINGLE smallest Value\n"); - err = TestReadAttributeNullableSingleSmallestValue_307(); + ChipLogProgress(chipTool, " ***** Test Step 307 : Read attribute NULLABLE_SINGLE largest Value\n"); + err = TestReadAttributeNullableSingleLargestValue_307(); break; case 308: - ChipLogProgress(chipTool, " ***** Test Step 308 : Write attribute NULLABLE_SINGLE null Value\n"); - err = TestWriteAttributeNullableSingleNullValue_308(); + ChipLogProgress(chipTool, " ***** Test Step 308 : Write attribute NULLABLE_SINGLE smallest Value\n"); + err = TestWriteAttributeNullableSingleSmallestValue_308(); break; case 309: - ChipLogProgress(chipTool, " ***** Test Step 309 : Read attribute NULLABLE_SINGLE null Value\n"); - err = TestReadAttributeNullableSingleNullValue_309(); + ChipLogProgress(chipTool, " ***** Test Step 309 : Read attribute NULLABLE_SINGLE smallest Value\n"); + err = TestReadAttributeNullableSingleSmallestValue_309(); break; case 310: - ChipLogProgress(chipTool, " ***** Test Step 310 : Write attribute NULLABLE_SINGLE 0 Value\n"); - err = TestWriteAttributeNullableSingle0Value_310(); + ChipLogProgress(chipTool, " ***** Test Step 310 : Write attribute NULLABLE_SINGLE null Value\n"); + err = TestWriteAttributeNullableSingleNullValue_310(); break; case 311: - ChipLogProgress(chipTool, " ***** Test Step 311 : Read attribute NULLABLE_SINGLE 0 Value\n"); - err = TestReadAttributeNullableSingle0Value_311(); + ChipLogProgress(chipTool, " ***** Test Step 311 : Read attribute NULLABLE_SINGLE null Value\n"); + err = TestReadAttributeNullableSingleNullValue_311(); break; case 312: - ChipLogProgress(chipTool, " ***** Test Step 312 : Write attribute NULLABLE_DOUBLE medium Value\n"); - err = TestWriteAttributeNullableDoubleMediumValue_312(); + ChipLogProgress(chipTool, " ***** Test Step 312 : Write attribute NULLABLE_SINGLE 0 Value\n"); + err = TestWriteAttributeNullableSingle0Value_312(); break; case 313: - ChipLogProgress(chipTool, " ***** Test Step 313 : Read attribute NULLABLE_DOUBLE medium Value\n"); - err = TestReadAttributeNullableDoubleMediumValue_313(); + ChipLogProgress(chipTool, " ***** Test Step 313 : Read attribute NULLABLE_SINGLE 0 Value\n"); + err = TestReadAttributeNullableSingle0Value_313(); break; case 314: - ChipLogProgress(chipTool, " ***** Test Step 314 : Write attribute NULLABLE_DOUBLE largest Value\n"); - err = TestWriteAttributeNullableDoubleLargestValue_314(); + ChipLogProgress(chipTool, " ***** Test Step 314 : Write attribute NULLABLE_DOUBLE medium Value\n"); + err = TestWriteAttributeNullableDoubleMediumValue_314(); break; case 315: - ChipLogProgress(chipTool, " ***** Test Step 315 : Read attribute NULLABLE_DOUBLE largest Value\n"); - err = TestReadAttributeNullableDoubleLargestValue_315(); + ChipLogProgress(chipTool, " ***** Test Step 315 : Read attribute NULLABLE_DOUBLE medium Value\n"); + err = TestReadAttributeNullableDoubleMediumValue_315(); break; case 316: - ChipLogProgress(chipTool, " ***** Test Step 316 : Write attribute NULLABLE_DOUBLE smallest Value\n"); - err = TestWriteAttributeNullableDoubleSmallestValue_316(); + ChipLogProgress(chipTool, " ***** Test Step 316 : Write attribute NULLABLE_DOUBLE largest Value\n"); + err = TestWriteAttributeNullableDoubleLargestValue_316(); break; case 317: - ChipLogProgress(chipTool, " ***** Test Step 317 : Read attribute NULLABLE_DOUBLE smallest Value\n"); - err = TestReadAttributeNullableDoubleSmallestValue_317(); + ChipLogProgress(chipTool, " ***** Test Step 317 : Read attribute NULLABLE_DOUBLE largest Value\n"); + err = TestReadAttributeNullableDoubleLargestValue_317(); break; case 318: - ChipLogProgress(chipTool, " ***** Test Step 318 : Write attribute NULLABLE_DOUBLE null Value\n"); - err = TestWriteAttributeNullableDoubleNullValue_318(); + ChipLogProgress(chipTool, " ***** Test Step 318 : Write attribute NULLABLE_DOUBLE smallest Value\n"); + err = TestWriteAttributeNullableDoubleSmallestValue_318(); break; case 319: - ChipLogProgress(chipTool, " ***** Test Step 319 : Read attribute NULLABLE_DOUBLE null Value\n"); - err = TestReadAttributeNullableDoubleNullValue_319(); + ChipLogProgress(chipTool, " ***** Test Step 319 : Read attribute NULLABLE_DOUBLE smallest Value\n"); + err = TestReadAttributeNullableDoubleSmallestValue_319(); break; case 320: - ChipLogProgress(chipTool, " ***** Test Step 320 : Write attribute NULLABLE_DOUBLE 0 Value\n"); - err = TestWriteAttributeNullableDouble0Value_320(); + ChipLogProgress(chipTool, " ***** Test Step 320 : Write attribute NULLABLE_DOUBLE null Value\n"); + err = TestWriteAttributeNullableDoubleNullValue_320(); break; case 321: - ChipLogProgress(chipTool, " ***** Test Step 321 : Read attribute NULLABLE_DOUBLE 0 Value\n"); - err = TestReadAttributeNullableDouble0Value_321(); + ChipLogProgress(chipTool, " ***** Test Step 321 : Read attribute NULLABLE_DOUBLE null Value\n"); + err = TestReadAttributeNullableDoubleNullValue_321(); break; case 322: - ChipLogProgress(chipTool, " ***** Test Step 322 : Write attribute NULLABLE_ENUM8 Min Value\n"); - err = TestWriteAttributeNullableEnum8MinValue_322(); + ChipLogProgress(chipTool, " ***** Test Step 322 : Write attribute NULLABLE_DOUBLE 0 Value\n"); + err = TestWriteAttributeNullableDouble0Value_322(); break; case 323: - ChipLogProgress(chipTool, " ***** Test Step 323 : Read attribute NULLABLE_ENUM8 Min Value\n"); - err = TestReadAttributeNullableEnum8MinValue_323(); + ChipLogProgress(chipTool, " ***** Test Step 323 : Read attribute NULLABLE_DOUBLE 0 Value\n"); + err = TestReadAttributeNullableDouble0Value_323(); break; case 324: - ChipLogProgress(chipTool, " ***** Test Step 324 : Write attribute NULLABLE_ENUM8 Max Value\n"); - err = TestWriteAttributeNullableEnum8MaxValue_324(); + ChipLogProgress(chipTool, " ***** Test Step 324 : Write attribute NULLABLE_ENUM8 Min Value\n"); + err = TestWriteAttributeNullableEnum8MinValue_324(); break; case 325: - ChipLogProgress(chipTool, " ***** Test Step 325 : Read attribute NULLABLE_ENUM8 Max Value\n"); - err = TestReadAttributeNullableEnum8MaxValue_325(); + ChipLogProgress(chipTool, " ***** Test Step 325 : Read attribute NULLABLE_ENUM8 Min Value\n"); + err = TestReadAttributeNullableEnum8MinValue_325(); break; case 326: - ChipLogProgress(chipTool, " ***** Test Step 326 : Write attribute NULLABLE_ENUM8 Invalid Value\n"); - err = TestWriteAttributeNullableEnum8InvalidValue_326(); + ChipLogProgress(chipTool, " ***** Test Step 326 : Write attribute NULLABLE_ENUM8 Max Value\n"); + err = TestWriteAttributeNullableEnum8MaxValue_326(); break; case 327: - ChipLogProgress(chipTool, " ***** Test Step 327 : Read attribute NULLABLE_ENUM8 unchanged Value\n"); - err = TestReadAttributeNullableEnum8UnchangedValue_327(); + ChipLogProgress(chipTool, " ***** Test Step 327 : Read attribute NULLABLE_ENUM8 Max Value\n"); + err = TestReadAttributeNullableEnum8MaxValue_327(); break; case 328: - ChipLogProgress(chipTool, " ***** Test Step 328 : Write attribute NULLABLE_ENUM8 null Value\n"); - err = TestWriteAttributeNullableEnum8NullValue_328(); + ChipLogProgress(chipTool, " ***** Test Step 328 : Write attribute NULLABLE_ENUM8 Invalid Value\n"); + err = TestWriteAttributeNullableEnum8InvalidValue_328(); break; case 329: - ChipLogProgress(chipTool, " ***** Test Step 329 : Read attribute NULLABLE_ENUM8 null Value\n"); - err = TestReadAttributeNullableEnum8NullValue_329(); + ChipLogProgress(chipTool, " ***** Test Step 329 : Read attribute NULLABLE_ENUM8 unchanged Value\n"); + err = TestReadAttributeNullableEnum8UnchangedValue_329(); break; case 330: - ChipLogProgress(chipTool, " ***** Test Step 330 : Write attribute NULLABLE_ENUM16 Min Value\n"); - err = TestWriteAttributeNullableEnum16MinValue_330(); + ChipLogProgress(chipTool, " ***** Test Step 330 : Write attribute NULLABLE_ENUM8 null Value\n"); + err = TestWriteAttributeNullableEnum8NullValue_330(); break; case 331: - ChipLogProgress(chipTool, " ***** Test Step 331 : Read attribute NULLABLE_ENUM16 Min Value\n"); - err = TestReadAttributeNullableEnum16MinValue_331(); + ChipLogProgress(chipTool, " ***** Test Step 331 : Read attribute NULLABLE_ENUM8 null Value\n"); + err = TestReadAttributeNullableEnum8NullValue_331(); break; case 332: - ChipLogProgress(chipTool, " ***** Test Step 332 : Write attribute NULLABLE_ENUM16 Max Value\n"); - err = TestWriteAttributeNullableEnum16MaxValue_332(); + ChipLogProgress(chipTool, " ***** Test Step 332 : Write attribute NULLABLE_ENUM16 Min Value\n"); + err = TestWriteAttributeNullableEnum16MinValue_332(); break; case 333: - ChipLogProgress(chipTool, " ***** Test Step 333 : Read attribute NULLABLE_ENUM16 Max Value\n"); - err = TestReadAttributeNullableEnum16MaxValue_333(); + ChipLogProgress(chipTool, " ***** Test Step 333 : Read attribute NULLABLE_ENUM16 Min Value\n"); + err = TestReadAttributeNullableEnum16MinValue_333(); break; case 334: - ChipLogProgress(chipTool, " ***** Test Step 334 : Write attribute NULLABLE_ENUM16 Invalid Value\n"); - err = TestWriteAttributeNullableEnum16InvalidValue_334(); + ChipLogProgress(chipTool, " ***** Test Step 334 : Write attribute NULLABLE_ENUM16 Max Value\n"); + err = TestWriteAttributeNullableEnum16MaxValue_334(); break; case 335: - ChipLogProgress(chipTool, " ***** Test Step 335 : Read attribute NULLABLE_ENUM16 unchanged Value\n"); - err = TestReadAttributeNullableEnum16UnchangedValue_335(); + ChipLogProgress(chipTool, " ***** Test Step 335 : Read attribute NULLABLE_ENUM16 Max Value\n"); + err = TestReadAttributeNullableEnum16MaxValue_335(); break; case 336: - ChipLogProgress(chipTool, " ***** Test Step 336 : Write attribute NULLABLE_ENUM16 null Value\n"); - err = TestWriteAttributeNullableEnum16NullValue_336(); + ChipLogProgress(chipTool, " ***** Test Step 336 : Write attribute NULLABLE_ENUM16 Invalid Value\n"); + err = TestWriteAttributeNullableEnum16InvalidValue_336(); break; case 337: - ChipLogProgress(chipTool, " ***** Test Step 337 : Read attribute NULLABLE_ENUM16 null Value\n"); - err = TestReadAttributeNullableEnum16NullValue_337(); + ChipLogProgress(chipTool, " ***** Test Step 337 : Read attribute NULLABLE_ENUM16 unchanged Value\n"); + err = TestReadAttributeNullableEnum16UnchangedValue_337(); break; case 338: - ChipLogProgress(chipTool, " ***** Test Step 338 : Write attribute NULLABLE_SIMPLE_ENUM Min Value\n"); - err = TestWriteAttributeNullableSimpleEnumMinValue_338(); + ChipLogProgress(chipTool, " ***** Test Step 338 : Write attribute NULLABLE_ENUM16 null Value\n"); + err = TestWriteAttributeNullableEnum16NullValue_338(); break; case 339: - ChipLogProgress(chipTool, " ***** Test Step 339 : Read attribute NULLABLE_SIMPLE_ENUM Min Value\n"); - err = TestReadAttributeNullableSimpleEnumMinValue_339(); + ChipLogProgress(chipTool, " ***** Test Step 339 : Read attribute NULLABLE_ENUM16 null Value\n"); + err = TestReadAttributeNullableEnum16NullValue_339(); break; case 340: - ChipLogProgress(chipTool, " ***** Test Step 340 : Write attribute NULLABLE_SIMPLE_ENUM Max Value\n"); - err = TestWriteAttributeNullableSimpleEnumMaxValue_340(); + ChipLogProgress(chipTool, " ***** Test Step 340 : Write attribute NULLABLE_SIMPLE_ENUM Min Value\n"); + err = TestWriteAttributeNullableSimpleEnumMinValue_340(); break; case 341: - ChipLogProgress(chipTool, " ***** Test Step 341 : Read attribute NULLABLE_SIMPLE_ENUM Max Value\n"); - err = TestReadAttributeNullableSimpleEnumMaxValue_341(); + ChipLogProgress(chipTool, " ***** Test Step 341 : Read attribute NULLABLE_SIMPLE_ENUM Min Value\n"); + err = TestReadAttributeNullableSimpleEnumMinValue_341(); break; case 342: - ChipLogProgress(chipTool, " ***** Test Step 342 : Write attribute NULLABLE_SIMPLE_ENUM Invalid Value\n"); - err = TestWriteAttributeNullableSimpleEnumInvalidValue_342(); + ChipLogProgress(chipTool, " ***** Test Step 342 : Write attribute NULLABLE_SIMPLE_ENUM Max Value\n"); + err = TestWriteAttributeNullableSimpleEnumMaxValue_342(); break; case 343: - ChipLogProgress(chipTool, " ***** Test Step 343 : Read attribute NULLABLE_SIMPLE_ENUM unchanged Value\n"); - err = TestReadAttributeNullableSimpleEnumUnchangedValue_343(); + ChipLogProgress(chipTool, " ***** Test Step 343 : Read attribute NULLABLE_SIMPLE_ENUM Max Value\n"); + err = TestReadAttributeNullableSimpleEnumMaxValue_343(); break; case 344: - ChipLogProgress(chipTool, " ***** Test Step 344 : Write attribute NULLABLE_SIMPLE_ENUM null Value\n"); - err = TestWriteAttributeNullableSimpleEnumNullValue_344(); + ChipLogProgress(chipTool, " ***** Test Step 344 : Write attribute NULLABLE_SIMPLE_ENUM Invalid Value\n"); + err = TestWriteAttributeNullableSimpleEnumInvalidValue_344(); break; case 345: - ChipLogProgress(chipTool, " ***** Test Step 345 : Read attribute NULLABLE_SIMPLE_ENUM null Value\n"); - err = TestReadAttributeNullableSimpleEnumNullValue_345(); + ChipLogProgress(chipTool, " ***** Test Step 345 : Read attribute NULLABLE_SIMPLE_ENUM unchanged Value\n"); + err = TestReadAttributeNullableSimpleEnumUnchangedValue_345(); break; case 346: - ChipLogProgress(chipTool, " ***** Test Step 346 : Read attribute NULLABLE_OCTET_STRING Default Value\n"); - err = TestReadAttributeNullableOctetStringDefaultValue_346(); + ChipLogProgress(chipTool, " ***** Test Step 346 : Write attribute NULLABLE_SIMPLE_ENUM null Value\n"); + err = TestWriteAttributeNullableSimpleEnumNullValue_346(); break; case 347: - ChipLogProgress(chipTool, " ***** Test Step 347 : Write attribute NULLABLE_OCTET_STRING\n"); - err = TestWriteAttributeNullableOctetString_347(); + ChipLogProgress(chipTool, " ***** Test Step 347 : Read attribute NULLABLE_SIMPLE_ENUM null Value\n"); + err = TestReadAttributeNullableSimpleEnumNullValue_347(); break; case 348: - ChipLogProgress(chipTool, " ***** Test Step 348 : Read attribute NULLABLE_OCTET_STRING\n"); - err = TestReadAttributeNullableOctetString_348(); + ChipLogProgress(chipTool, " ***** Test Step 348 : Read attribute NULLABLE_OCTET_STRING Default Value\n"); + err = TestReadAttributeNullableOctetStringDefaultValue_348(); break; case 349: ChipLogProgress(chipTool, " ***** Test Step 349 : Write attribute NULLABLE_OCTET_STRING\n"); @@ -53062,612 +53062,620 @@ class TestCluster : public TestCommand err = TestReadAttributeNullableOctetString_352(); break; case 353: - ChipLogProgress(chipTool, " ***** Test Step 353 : Read attribute NULLABLE_CHAR_STRING Default Value\n"); - err = TestReadAttributeNullableCharStringDefaultValue_353(); + ChipLogProgress(chipTool, " ***** Test Step 353 : Write attribute NULLABLE_OCTET_STRING\n"); + err = TestWriteAttributeNullableOctetString_353(); break; case 354: - ChipLogProgress(chipTool, " ***** Test Step 354 : Write attribute NULLABLE_CHAR_STRING\n"); - err = TestWriteAttributeNullableCharString_354(); + ChipLogProgress(chipTool, " ***** Test Step 354 : Read attribute NULLABLE_OCTET_STRING\n"); + err = TestReadAttributeNullableOctetString_354(); break; case 355: - ChipLogProgress(chipTool, " ***** Test Step 355 : Read attribute NULLABLE_CHAR_STRING\n"); - err = TestReadAttributeNullableCharString_355(); + ChipLogProgress(chipTool, " ***** Test Step 355 : Read attribute NULLABLE_CHAR_STRING Default Value\n"); + err = TestReadAttributeNullableCharStringDefaultValue_355(); break; case 356: - ChipLogProgress(chipTool, " ***** Test Step 356 : Write attribute NULLABLE_CHAR_STRING - Value too long\n"); - err = TestWriteAttributeNullableCharStringValueTooLong_356(); + ChipLogProgress(chipTool, " ***** Test Step 356 : Write attribute NULLABLE_CHAR_STRING\n"); + err = TestWriteAttributeNullableCharString_356(); break; case 357: ChipLogProgress(chipTool, " ***** Test Step 357 : Read attribute NULLABLE_CHAR_STRING\n"); err = TestReadAttributeNullableCharString_357(); break; case 358: - ChipLogProgress(chipTool, " ***** Test Step 358 : Write attribute NULLABLE_CHAR_STRING - Empty\n"); - err = TestWriteAttributeNullableCharStringEmpty_358(); + ChipLogProgress(chipTool, " ***** Test Step 358 : Write attribute NULLABLE_CHAR_STRING - Value too long\n"); + err = TestWriteAttributeNullableCharStringValueTooLong_358(); break; case 359: ChipLogProgress(chipTool, " ***** Test Step 359 : Read attribute NULLABLE_CHAR_STRING\n"); err = TestReadAttributeNullableCharString_359(); break; case 360: - ChipLogProgress(chipTool, " ***** Test Step 360 : Read attribute from nonexistent endpoint.\n"); - err = TestReadAttributeFromNonexistentEndpoint_360(); + ChipLogProgress(chipTool, " ***** Test Step 360 : Write attribute NULLABLE_CHAR_STRING - Empty\n"); + err = TestWriteAttributeNullableCharStringEmpty_360(); break; case 361: - ChipLogProgress(chipTool, " ***** Test Step 361 : Read attribute from nonexistent cluster.\n"); - err = TestReadAttributeFromNonexistentCluster_361(); + ChipLogProgress(chipTool, " ***** Test Step 361 : Read attribute NULLABLE_CHAR_STRING\n"); + err = TestReadAttributeNullableCharString_361(); break; case 362: - ChipLogProgress(chipTool, - " ***** Test Step 362 : Send a command that takes an optional parameter but do not set it.\n"); - err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_362(); + ChipLogProgress(chipTool, " ***** Test Step 362 : Read attribute from nonexistent endpoint.\n"); + err = TestReadAttributeFromNonexistentEndpoint_362(); break; case 363: - ChipLogProgress(chipTool, - " ***** Test Step 363 : Send a command that takes an optional parameter but do not set it.\n"); - err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_363(); + ChipLogProgress(chipTool, " ***** Test Step 363 : Read attribute from nonexistent cluster.\n"); + err = TestReadAttributeFromNonexistentCluster_363(); break; case 364: - ChipLogProgress(chipTool, " ***** Test Step 364 : Report: Subscribe to list attribute\n"); - err = TestReportSubscribeToListAttribute_364(); + ChipLogProgress(chipTool, + " ***** Test Step 364 : Send a command that takes an optional parameter but do not set it.\n"); + err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_364(); break; case 365: - ChipLogProgress(chipTool, " ***** Test Step 365 : Subscribe to list attribute\n"); - err = TestSubscribeToListAttribute_365(); + ChipLogProgress(chipTool, + " ***** Test Step 365 : Send a command that takes an optional parameter but do not set it.\n"); + err = TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_365(); break; case 366: - ChipLogProgress(chipTool, " ***** Test Step 366 : Write subscribed-to list attribute\n"); - err = TestWriteSubscribedToListAttribute_366(); + ChipLogProgress(chipTool, " ***** Test Step 366 : Report: Subscribe to list attribute\n"); + err = TestReportSubscribeToListAttribute_366(); break; case 367: - ChipLogProgress(chipTool, " ***** Test Step 367 : Check for list attribute report\n"); - err = TestCheckForListAttributeReport_367(); + ChipLogProgress(chipTool, " ***** Test Step 367 : Subscribe to list attribute\n"); + err = TestSubscribeToListAttribute_367(); break; case 368: - ChipLogProgress(chipTool, " ***** Test Step 368 : Read range-restricted unsigned 8-bit integer\n"); - err = TestReadRangeRestrictedUnsigned8BitInteger_368(); + ChipLogProgress(chipTool, " ***** Test Step 368 : Write subscribed-to list attribute\n"); + err = TestWriteSubscribedToListAttribute_368(); break; case 369: - ChipLogProgress(chipTool, " ***** Test Step 369 : Write min value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_369(); + ChipLogProgress(chipTool, " ***** Test Step 369 : Check for list attribute report\n"); + err = TestCheckForListAttributeReport_369(); break; case 370: - ChipLogProgress(chipTool, - " ***** Test Step 370 : Write just-below-range value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_370(); + ChipLogProgress(chipTool, " ***** Test Step 370 : Read range-restricted unsigned 8-bit integer\n"); + err = TestReadRangeRestrictedUnsigned8BitInteger_370(); break; case 371: - ChipLogProgress(chipTool, - " ***** Test Step 371 : Write just-above-range value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_371(); + ChipLogProgress(chipTool, " ***** Test Step 371 : Write min value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_371(); break; case 372: - ChipLogProgress(chipTool, " ***** Test Step 372 : Write max value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_372(); + ChipLogProgress(chipTool, + " ***** Test Step 372 : Write just-below-range value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_372(); break; case 373: ChipLogProgress(chipTool, - " ***** Test Step 373 : Verify range-restricted unsigned 8-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_373(); + " ***** Test Step 373 : Write just-above-range value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_373(); break; case 374: - ChipLogProgress(chipTool, - " ***** Test Step 374 : Write min valid value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_374(); + ChipLogProgress(chipTool, " ***** Test Step 374 : Write max value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_374(); break; case 375: ChipLogProgress(chipTool, - " ***** Test Step 375 : Verify range-restricted unsigned 8-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_375(); + " ***** Test Step 375 : Verify range-restricted unsigned 8-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_375(); break; case 376: ChipLogProgress(chipTool, - " ***** Test Step 376 : Write max valid value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_376(); + " ***** Test Step 376 : Write min valid value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_376(); break; case 377: ChipLogProgress(chipTool, - " ***** Test Step 377 : Verify range-restricted unsigned 8-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_377(); + " ***** Test Step 377 : Verify range-restricted unsigned 8-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_377(); break; case 378: ChipLogProgress(chipTool, - " ***** Test Step 378 : Write middle valid value to a range-restricted unsigned 8-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_378(); + " ***** Test Step 378 : Write max valid value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_378(); break; case 379: ChipLogProgress(chipTool, - " ***** Test Step 379 : Verify range-restricted unsigned 8-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_379(); + " ***** Test Step 379 : Verify range-restricted unsigned 8-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_379(); break; case 380: - ChipLogProgress(chipTool, " ***** Test Step 380 : Read range-restricted unsigned 16-bit integer\n"); - err = TestReadRangeRestrictedUnsigned16BitInteger_380(); + ChipLogProgress(chipTool, + " ***** Test Step 380 : Write middle valid value to a range-restricted unsigned 8-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_380(); break; case 381: - ChipLogProgress(chipTool, " ***** Test Step 381 : Write min value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_381(); + ChipLogProgress(chipTool, + " ***** Test Step 381 : Verify range-restricted unsigned 8-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_381(); break; case 382: - ChipLogProgress(chipTool, - " ***** Test Step 382 : Write just-below-range value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_382(); + ChipLogProgress(chipTool, " ***** Test Step 382 : Read range-restricted unsigned 16-bit integer\n"); + err = TestReadRangeRestrictedUnsigned16BitInteger_382(); break; case 383: - ChipLogProgress(chipTool, - " ***** Test Step 383 : Write just-above-range value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_383(); + ChipLogProgress(chipTool, " ***** Test Step 383 : Write min value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_383(); break; case 384: - ChipLogProgress(chipTool, " ***** Test Step 384 : Write max value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_384(); + ChipLogProgress(chipTool, + " ***** Test Step 384 : Write just-below-range value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_384(); break; case 385: ChipLogProgress(chipTool, - " ***** Test Step 385 : Verify range-restricted unsigned 16-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_385(); + " ***** Test Step 385 : Write just-above-range value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_385(); break; case 386: - ChipLogProgress(chipTool, - " ***** Test Step 386 : Write min valid value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_386(); + ChipLogProgress(chipTool, " ***** Test Step 386 : Write max value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_386(); break; case 387: ChipLogProgress(chipTool, - " ***** Test Step 387 : Verify range-restricted unsigned 16-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_387(); + " ***** Test Step 387 : Verify range-restricted unsigned 16-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_387(); break; case 388: ChipLogProgress(chipTool, - " ***** Test Step 388 : Write max valid value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_388(); + " ***** Test Step 388 : Write min valid value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_388(); break; case 389: ChipLogProgress(chipTool, - " ***** Test Step 389 : Verify range-restricted unsigned 16-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_389(); + " ***** Test Step 389 : Verify range-restricted unsigned 16-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_389(); break; case 390: ChipLogProgress(chipTool, - " ***** Test Step 390 : Write middle valid value to a range-restricted unsigned 16-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_390(); + " ***** Test Step 390 : Write max valid value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_390(); break; case 391: ChipLogProgress(chipTool, - " ***** Test Step 391 : Verify range-restricted unsigned 16-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_391(); + " ***** Test Step 391 : Verify range-restricted unsigned 16-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_391(); break; case 392: - ChipLogProgress(chipTool, " ***** Test Step 392 : Read range-restricted signed 8-bit integer\n"); - err = TestReadRangeRestrictedSigned8BitInteger_392(); + ChipLogProgress(chipTool, + " ***** Test Step 392 : Write middle valid value to a range-restricted unsigned 16-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_392(); break; case 393: - ChipLogProgress(chipTool, " ***** Test Step 393 : Write min value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedSigned8BitInteger_393(); + ChipLogProgress(chipTool, + " ***** Test Step 393 : Verify range-restricted unsigned 16-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_393(); break; case 394: - ChipLogProgress(chipTool, - " ***** Test Step 394 : Write just-below-range value to a range-restricted signed 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_394(); + ChipLogProgress(chipTool, " ***** Test Step 394 : Read range-restricted signed 8-bit integer\n"); + err = TestReadRangeRestrictedSigned8BitInteger_394(); break; case 395: - ChipLogProgress(chipTool, - " ***** Test Step 395 : Write just-above-range value to a range-restricted signed 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_395(); + ChipLogProgress(chipTool, " ***** Test Step 395 : Write min value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedSigned8BitInteger_395(); break; case 396: - ChipLogProgress(chipTool, " ***** Test Step 396 : Write max value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedSigned8BitInteger_396(); + ChipLogProgress(chipTool, + " ***** Test Step 396 : Write just-below-range value to a range-restricted signed 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_396(); break; case 397: ChipLogProgress(chipTool, - " ***** Test Step 397 : Verify range-restricted signed 8-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_397(); + " ***** Test Step 397 : Write just-above-range value to a range-restricted signed 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_397(); break; case 398: - ChipLogProgress(chipTool, " ***** Test Step 398 : Write min valid value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_398(); + ChipLogProgress(chipTool, " ***** Test Step 398 : Write max value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedSigned8BitInteger_398(); break; case 399: ChipLogProgress(chipTool, - " ***** Test Step 399 : Verify range-restricted signed 8-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_399(); + " ***** Test Step 399 : Verify range-restricted signed 8-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_399(); break; case 400: - ChipLogProgress(chipTool, " ***** Test Step 400 : Write max valid value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_400(); + ChipLogProgress(chipTool, " ***** Test Step 400 : Write min valid value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_400(); break; case 401: ChipLogProgress(chipTool, - " ***** Test Step 401 : Verify range-restricted signed 8-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_401(); + " ***** Test Step 401 : Verify range-restricted signed 8-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_401(); break; case 402: - ChipLogProgress(chipTool, - " ***** Test Step 402 : Write middle valid value to a range-restricted signed 8-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_402(); + ChipLogProgress(chipTool, " ***** Test Step 402 : Write max valid value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_402(); break; case 403: ChipLogProgress(chipTool, - " ***** Test Step 403 : Verify range-restricted signed 8-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_403(); + " ***** Test Step 403 : Verify range-restricted signed 8-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_403(); break; case 404: - ChipLogProgress(chipTool, " ***** Test Step 404 : Read range-restricted signed 16-bit integer\n"); - err = TestReadRangeRestrictedSigned16BitInteger_404(); + ChipLogProgress(chipTool, + " ***** Test Step 404 : Write middle valid value to a range-restricted signed 8-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_404(); break; case 405: - ChipLogProgress(chipTool, " ***** Test Step 405 : Write min value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMinValueToARangeRestrictedSigned16BitInteger_405(); + ChipLogProgress(chipTool, + " ***** Test Step 405 : Verify range-restricted signed 8-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_405(); break; case 406: - ChipLogProgress(chipTool, - " ***** Test Step 406 : Write just-below-range value to a range-restricted signed 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_406(); + ChipLogProgress(chipTool, " ***** Test Step 406 : Read range-restricted signed 16-bit integer\n"); + err = TestReadRangeRestrictedSigned16BitInteger_406(); break; case 407: - ChipLogProgress(chipTool, - " ***** Test Step 407 : Write just-above-range value to a range-restricted signed 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_407(); + ChipLogProgress(chipTool, " ***** Test Step 407 : Write min value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMinValueToARangeRestrictedSigned16BitInteger_407(); break; case 408: - ChipLogProgress(chipTool, " ***** Test Step 408 : Write max value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValueToARangeRestrictedSigned16BitInteger_408(); + ChipLogProgress(chipTool, + " ***** Test Step 408 : Write just-below-range value to a range-restricted signed 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_408(); break; case 409: ChipLogProgress(chipTool, - " ***** Test Step 409 : Verify range-restricted signed 16-bit integer value has not changed\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_409(); + " ***** Test Step 409 : Write just-above-range value to a range-restricted signed 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_409(); break; case 410: - ChipLogProgress(chipTool, " ***** Test Step 410 : Write min valid value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_410(); + ChipLogProgress(chipTool, " ***** Test Step 410 : Write max value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValueToARangeRestrictedSigned16BitInteger_410(); break; case 411: ChipLogProgress(chipTool, - " ***** Test Step 411 : Verify range-restricted signed 16-bit integer value is at min valid\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_411(); + " ***** Test Step 411 : Verify range-restricted signed 16-bit integer value has not changed\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_411(); break; case 412: - ChipLogProgress(chipTool, " ***** Test Step 412 : Write max valid value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_412(); + ChipLogProgress(chipTool, " ***** Test Step 412 : Write min valid value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_412(); break; case 413: ChipLogProgress(chipTool, - " ***** Test Step 413 : Verify range-restricted signed 16-bit integer value is at max valid\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_413(); + " ***** Test Step 413 : Verify range-restricted signed 16-bit integer value is at min valid\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_413(); break; case 414: - ChipLogProgress(chipTool, - " ***** Test Step 414 : Write middle valid value to a range-restricted signed 16-bit integer\n"); - err = TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_414(); + ChipLogProgress(chipTool, " ***** Test Step 414 : Write max valid value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_414(); break; case 415: ChipLogProgress(chipTool, - " ***** Test Step 415 : Verify range-restricted signed 16-bit integer value is at mid valid\n"); - err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_415(); + " ***** Test Step 415 : Verify range-restricted signed 16-bit integer value is at max valid\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_415(); break; case 416: - ChipLogProgress(chipTool, " ***** Test Step 416 : Read nullable range-restricted unsigned 8-bit integer\n"); - err = TestReadNullableRangeRestrictedUnsigned8BitInteger_416(); + ChipLogProgress(chipTool, + " ***** Test Step 416 : Write middle valid value to a range-restricted signed 16-bit integer\n"); + err = TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_416(); break; case 417: ChipLogProgress(chipTool, - " ***** Test Step 417 : Write min value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_417(); + " ***** Test Step 417 : Verify range-restricted signed 16-bit integer value is at mid valid\n"); + err = TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_417(); break; case 418: - ChipLogProgress( - chipTool, - " ***** Test Step 418 : Write just-below-range value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_418(); + ChipLogProgress(chipTool, " ***** Test Step 418 : Read nullable range-restricted unsigned 8-bit integer\n"); + err = TestReadNullableRangeRestrictedUnsigned8BitInteger_418(); break; case 419: - ChipLogProgress( - chipTool, - " ***** Test Step 419 : Write just-above-range value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_419(); + ChipLogProgress(chipTool, + " ***** Test Step 419 : Write min value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_419(); break; case 420: - ChipLogProgress(chipTool, - " ***** Test Step 420 : Write max value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_420(); + ChipLogProgress( + chipTool, + " ***** Test Step 420 : Write just-below-range value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_420(); break; case 421: ChipLogProgress( - chipTool, " ***** Test Step 421 : Verify nullable range-restricted unsigned 8-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_421(); + chipTool, + " ***** Test Step 421 : Write just-above-range value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_421(); break; case 422: ChipLogProgress(chipTool, - " ***** Test Step 422 : Write min valid value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_422(); + " ***** Test Step 422 : Write max value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_422(); break; case 423: ChipLogProgress( - chipTool, " ***** Test Step 423 : Verify nullable range-restricted unsigned 8-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_423(); + chipTool, " ***** Test Step 423 : Verify nullable range-restricted unsigned 8-bit integer value has not changed\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_423(); break; case 424: ChipLogProgress(chipTool, - " ***** Test Step 424 : Write max valid value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_424(); + " ***** Test Step 424 : Write min valid value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_424(); break; case 425: ChipLogProgress( - chipTool, " ***** Test Step 425 : Verify nullable range-restricted unsigned 8-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_425(); + chipTool, " ***** Test Step 425 : Verify nullable range-restricted unsigned 8-bit integer value is at min valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_425(); break; case 426: - ChipLogProgress( - chipTool, - " ***** Test Step 426 : Write middle valid value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_426(); + ChipLogProgress(chipTool, + " ***** Test Step 426 : Write max valid value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_426(); break; case 427: ChipLogProgress( - chipTool, " ***** Test Step 427 : Verify nullable range-restricted unsigned 8-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_427(); + chipTool, " ***** Test Step 427 : Verify nullable range-restricted unsigned 8-bit integer value is at max valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_427(); break; case 428: - ChipLogProgress(chipTool, - " ***** Test Step 428 : Write null value to a nullable range-restricted unsigned 8-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_428(); + ChipLogProgress( + chipTool, + " ***** Test Step 428 : Write middle valid value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_428(); break; case 429: - ChipLogProgress(chipTool, - " ***** Test Step 429 : Verify nullable range-restricted unsigned 8-bit integer value is null\n"); - err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_429(); + ChipLogProgress( + chipTool, " ***** Test Step 429 : Verify nullable range-restricted unsigned 8-bit integer value is at mid valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_429(); break; case 430: - ChipLogProgress(chipTool, " ***** Test Step 430 : Read nullable range-restricted unsigned 16-bit integer\n"); - err = TestReadNullableRangeRestrictedUnsigned16BitInteger_430(); + ChipLogProgress(chipTool, + " ***** Test Step 430 : Write null value to a nullable range-restricted unsigned 8-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_430(); break; case 431: ChipLogProgress(chipTool, - " ***** Test Step 431 : Write min value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_431(); + " ***** Test Step 431 : Verify nullable range-restricted unsigned 8-bit integer value is null\n"); + err = TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_431(); break; case 432: - ChipLogProgress( - chipTool, - " ***** Test Step 432 : Write just-below-range value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_432(); + ChipLogProgress(chipTool, " ***** Test Step 432 : Read nullable range-restricted unsigned 16-bit integer\n"); + err = TestReadNullableRangeRestrictedUnsigned16BitInteger_432(); break; case 433: - ChipLogProgress( - chipTool, - " ***** Test Step 433 : Write just-above-range value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_433(); + ChipLogProgress(chipTool, + " ***** Test Step 433 : Write min value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_433(); break; case 434: - ChipLogProgress(chipTool, - " ***** Test Step 434 : Write max value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_434(); + ChipLogProgress( + chipTool, + " ***** Test Step 434 : Write just-below-range value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_434(); break; case 435: ChipLogProgress( chipTool, - " ***** Test Step 435 : Verify nullable range-restricted unsigned 16-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_435(); + " ***** Test Step 435 : Write just-above-range value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_435(); break; case 436: - ChipLogProgress( - chipTool, " ***** Test Step 436 : Write min valid value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_436(); + ChipLogProgress(chipTool, + " ***** Test Step 436 : Write max value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_436(); break; case 437: ChipLogProgress( chipTool, - " ***** Test Step 437 : Verify nullable range-restricted unsigned 16-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_437(); + " ***** Test Step 437 : Verify nullable range-restricted unsigned 16-bit integer value has not changed\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_437(); break; case 438: ChipLogProgress( - chipTool, " ***** Test Step 438 : Write max valid value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_438(); + chipTool, " ***** Test Step 438 : Write min valid value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_438(); break; case 439: ChipLogProgress( chipTool, - " ***** Test Step 439 : Verify nullable range-restricted unsigned 16-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_439(); + " ***** Test Step 439 : Verify nullable range-restricted unsigned 16-bit integer value is at min valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_439(); break; case 440: ChipLogProgress( - chipTool, - " ***** Test Step 440 : Write middle valid value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_440(); + chipTool, " ***** Test Step 440 : Write max valid value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_440(); break; case 441: ChipLogProgress( chipTool, - " ***** Test Step 441 : Verify nullable range-restricted unsigned 16-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_441(); + " ***** Test Step 441 : Verify nullable range-restricted unsigned 16-bit integer value is at max valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_441(); break; case 442: - ChipLogProgress(chipTool, - " ***** Test Step 442 : Write null value to a nullable range-restricted unsigned 16-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_442(); + ChipLogProgress( + chipTool, + " ***** Test Step 442 : Write middle valid value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_442(); break; case 443: - ChipLogProgress(chipTool, - " ***** Test Step 443 : Verify nullable range-restricted unsigned 16-bit integer value is null\n"); - err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_443(); + ChipLogProgress( + chipTool, + " ***** Test Step 443 : Verify nullable range-restricted unsigned 16-bit integer value is at mid valid\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_443(); break; case 444: - ChipLogProgress(chipTool, " ***** Test Step 444 : Read nullable range-restricted signed 8-bit integer\n"); - err = TestReadNullableRangeRestrictedSigned8BitInteger_444(); + ChipLogProgress(chipTool, + " ***** Test Step 444 : Write null value to a nullable range-restricted unsigned 16-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_444(); break; case 445: ChipLogProgress(chipTool, - " ***** Test Step 445 : Write min value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_445(); + " ***** Test Step 445 : Verify nullable range-restricted unsigned 16-bit integer value is null\n"); + err = TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_445(); break; case 446: - ChipLogProgress( - chipTool, - " ***** Test Step 446 : Write just-below-range value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_446(); + ChipLogProgress(chipTool, " ***** Test Step 446 : Read nullable range-restricted signed 8-bit integer\n"); + err = TestReadNullableRangeRestrictedSigned8BitInteger_446(); break; case 447: - ChipLogProgress( - chipTool, - " ***** Test Step 447 : Write just-above-range value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_447(); + ChipLogProgress(chipTool, + " ***** Test Step 447 : Write min value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_447(); break; case 448: - ChipLogProgress(chipTool, - " ***** Test Step 448 : Write max value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_448(); + ChipLogProgress( + chipTool, + " ***** Test Step 448 : Write just-below-range value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_448(); break; case 449: - ChipLogProgress(chipTool, - " ***** Test Step 449 : Verify nullable range-restricted signed 8-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_449(); + ChipLogProgress( + chipTool, + " ***** Test Step 449 : Write just-above-range value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_449(); break; case 450: ChipLogProgress(chipTool, - " ***** Test Step 450 : Write min valid value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_450(); + " ***** Test Step 450 : Write max value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_450(); break; case 451: ChipLogProgress(chipTool, - " ***** Test Step 451 : Verify nullable range-restricted signed 8-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_451(); + " ***** Test Step 451 : Verify nullable range-restricted signed 8-bit integer value has not changed\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_451(); break; case 452: ChipLogProgress(chipTool, - " ***** Test Step 452 : Write max valid value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_452(); + " ***** Test Step 452 : Write min valid value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_452(); break; case 453: ChipLogProgress(chipTool, - " ***** Test Step 453 : Verify nullable range-restricted signed 8-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_453(); + " ***** Test Step 453 : Verify nullable range-restricted signed 8-bit integer value is at min valid\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_453(); break; case 454: - ChipLogProgress( - chipTool, " ***** Test Step 454 : Write middle valid value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_454(); + ChipLogProgress(chipTool, + " ***** Test Step 454 : Write max valid value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_454(); break; case 455: ChipLogProgress(chipTool, - " ***** Test Step 455 : Verify nullable range-restricted signed 8-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_455(); + " ***** Test Step 455 : Verify nullable range-restricted signed 8-bit integer value is at max valid\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_455(); break; case 456: - ChipLogProgress(chipTool, - " ***** Test Step 456 : Write null value to a nullable range-restricted signed 8-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_456(); + ChipLogProgress( + chipTool, " ***** Test Step 456 : Write middle valid value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_456(); break; case 457: ChipLogProgress(chipTool, - " ***** Test Step 457 : Verify nullable range-restricted signed 8-bit integer value is at null\n"); - err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_457(); + " ***** Test Step 457 : Verify nullable range-restricted signed 8-bit integer value is at mid valid\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_457(); break; case 458: - ChipLogProgress(chipTool, " ***** Test Step 458 : Read nullable range-restricted signed 16-bit integer\n"); - err = TestReadNullableRangeRestrictedSigned16BitInteger_458(); + ChipLogProgress(chipTool, + " ***** Test Step 458 : Write null value to a nullable range-restricted signed 8-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_458(); break; case 459: ChipLogProgress(chipTool, - " ***** Test Step 459 : Write min value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_459(); + " ***** Test Step 459 : Verify nullable range-restricted signed 8-bit integer value is at null\n"); + err = TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_459(); break; case 460: - ChipLogProgress( - chipTool, - " ***** Test Step 460 : Write just-below-range value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_460(); + ChipLogProgress(chipTool, " ***** Test Step 460 : Read nullable range-restricted signed 16-bit integer\n"); + err = TestReadNullableRangeRestrictedSigned16BitInteger_460(); break; case 461: - ChipLogProgress( - chipTool, - " ***** Test Step 461 : Write just-above-range value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_461(); + ChipLogProgress(chipTool, + " ***** Test Step 461 : Write min value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_461(); break; case 462: - ChipLogProgress(chipTool, - " ***** Test Step 462 : Write max value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_462(); + ChipLogProgress( + chipTool, + " ***** Test Step 462 : Write just-below-range value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_462(); break; case 463: ChipLogProgress( - chipTool, " ***** Test Step 463 : Verify nullable range-restricted signed 16-bit integer value has not changed\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_463(); + chipTool, + " ***** Test Step 463 : Write just-above-range value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_463(); break; case 464: ChipLogProgress(chipTool, - " ***** Test Step 464 : Write min valid value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_464(); + " ***** Test Step 464 : Write max value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_464(); break; case 465: ChipLogProgress( - chipTool, " ***** Test Step 465 : Verify nullable range-restricted signed 16-bit integer value is at min valid\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_465(); + chipTool, " ***** Test Step 465 : Verify nullable range-restricted signed 16-bit integer value has not changed\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_465(); break; case 466: ChipLogProgress(chipTool, - " ***** Test Step 466 : Write max valid value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_466(); + " ***** Test Step 466 : Write min valid value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_466(); break; case 467: ChipLogProgress( - chipTool, " ***** Test Step 467 : Verify nullable range-restricted signed 16-bit integer value is at max valid\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_467(); + chipTool, " ***** Test Step 467 : Verify nullable range-restricted signed 16-bit integer value is at min valid\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_467(); break; case 468: - ChipLogProgress( - chipTool, " ***** Test Step 468 : Write middle valid value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_468(); + ChipLogProgress(chipTool, + " ***** Test Step 468 : Write max valid value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_468(); break; case 469: ChipLogProgress( - chipTool, " ***** Test Step 469 : Verify nullable range-restricted signed 16-bit integer value is at mid valid\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_469(); + chipTool, " ***** Test Step 469 : Verify nullable range-restricted signed 16-bit integer value is at max valid\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_469(); break; case 470: - ChipLogProgress(chipTool, - " ***** Test Step 470 : Write null value to a nullable range-restricted signed 16-bit integer\n"); - err = TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_470(); + ChipLogProgress( + chipTool, " ***** Test Step 470 : Write middle valid value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_470(); break; case 471: - ChipLogProgress(chipTool, - " ***** Test Step 471 : Verify nullable range-restricted signed 16-bit integer value is null\n"); - err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_471(); + ChipLogProgress( + chipTool, " ***** Test Step 471 : Verify nullable range-restricted signed 16-bit integer value is at mid valid\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_471(); break; case 472: - ChipLogProgress(chipTool, " ***** Test Step 472 : Write attribute that returns general status on write\n"); - err = TestWriteAttributeThatReturnsGeneralStatusOnWrite_472(); + ChipLogProgress(chipTool, + " ***** Test Step 472 : Write null value to a nullable range-restricted signed 16-bit integer\n"); + err = TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_472(); break; case 473: - ChipLogProgress(chipTool, " ***** Test Step 473 : Write attribute that returns cluster-specific status on write\n"); - err = TestWriteAttributeThatReturnsClusterSpecificStatusOnWrite_473(); + ChipLogProgress(chipTool, + " ***** Test Step 473 : Verify nullable range-restricted signed 16-bit integer value is null\n"); + err = TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_473(); break; case 474: - ChipLogProgress(chipTool, " ***** Test Step 474 : Read attribute that returns general status on read\n"); - err = TestReadAttributeThatReturnsGeneralStatusOnRead_474(); + ChipLogProgress(chipTool, " ***** Test Step 474 : Write attribute that returns general status on write\n"); + err = TestWriteAttributeThatReturnsGeneralStatusOnWrite_474(); break; case 475: - ChipLogProgress(chipTool, " ***** Test Step 475 : read attribute that returns cluster-specific status on read\n"); - err = TestReadAttributeThatReturnsClusterSpecificStatusOnRead_475(); + ChipLogProgress(chipTool, " ***** Test Step 475 : Write attribute that returns cluster-specific status on write\n"); + err = TestWriteAttributeThatReturnsClusterSpecificStatusOnWrite_475(); break; case 476: - ChipLogProgress(chipTool, " ***** Test Step 476 : read ClientGeneratedCommandList attribute\n"); - err = TestReadClientGeneratedCommandListAttribute_476(); + ChipLogProgress(chipTool, " ***** Test Step 476 : Read attribute that returns general status on read\n"); + err = TestReadAttributeThatReturnsGeneralStatusOnRead_476(); break; case 477: - ChipLogProgress(chipTool, " ***** Test Step 477 : read ServerGeneratedCommandList attribute\n"); - err = TestReadServerGeneratedCommandListAttribute_477(); + ChipLogProgress(chipTool, " ***** Test Step 477 : read attribute that returns cluster-specific status on read\n"); + err = TestReadAttributeThatReturnsClusterSpecificStatusOnRead_477(); break; case 478: - ChipLogProgress(chipTool, " ***** Test Step 478 : Write struct-typed attribute\n"); - err = TestWriteStructTypedAttribute_478(); + ChipLogProgress(chipTool, " ***** Test Step 478 : read ClientGeneratedCommandList attribute\n"); + err = TestReadClientGeneratedCommandListAttribute_478(); break; case 479: - ChipLogProgress(chipTool, " ***** Test Step 479 : Read struct-typed attribute\n"); - err = TestReadStructTypedAttribute_479(); + ChipLogProgress(chipTool, " ***** Test Step 479 : read ServerGeneratedCommandList attribute\n"); + err = TestReadServerGeneratedCommandListAttribute_479(); + break; + case 480: + ChipLogProgress(chipTool, " ***** Test Step 480 : Write struct-typed attribute\n"); + err = TestWriteStructTypedAttribute_480(); + break; + case 481: + ChipLogProgress(chipTool, " ***** Test Step 481 : Read struct-typed attribute\n"); + err = TestReadStructTypedAttribute_481(); break; } @@ -53680,7 +53688,7 @@ class TestCluster : public TestCommand private: std::atomic_uint16_t mTestIndex; - const uint16_t mTestCount = 480; + const uint16_t mTestCount = 482; chip::Optional mCluster; chip::Optional mEndpoint; @@ -54801,17 +54809,18 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_132(error); } - static void OnSuccessCallback_132(void * context, uint64_t epochUs) - { - (static_cast(context))->OnSuccessResponse_132(epochUs); - } + static void OnSuccessCallback_132(void * context) { (static_cast(context))->OnSuccessResponse_132(); } static void OnFailureCallback_133(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_133(error); } - static void OnSuccessCallback_133(void * context) { (static_cast(context))->OnSuccessResponse_133(); } + static void OnSuccessCallback_133(void * context, + const chip::app::DataModel::DecodableList & listLongOctetString) + { + (static_cast(context))->OnSuccessResponse_133(listLongOctetString); + } static void OnFailureCallback_134(void * context, CHIP_ERROR error) { @@ -54845,17 +54854,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_137(error); } - static void OnSuccessCallback_137(void * context, uint32_t epochS) - { - (static_cast(context))->OnSuccessResponse_137(epochS); - } + static void OnSuccessCallback_137(void * context) { (static_cast(context))->OnSuccessResponse_137(); } static void OnFailureCallback_138(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_138(error); } - static void OnSuccessCallback_138(void * context) { (static_cast(context))->OnSuccessResponse_138(); } + static void OnSuccessCallback_138(void * context, uint64_t epochUs) + { + (static_cast(context))->OnSuccessResponse_138(epochUs); + } static void OnFailureCallback_139(void * context, CHIP_ERROR error) { @@ -54889,34 +54898,34 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_142(error); } - static void OnSuccessCallback_142(void * context, bool unsupported) - { - (static_cast(context))->OnSuccessResponse_142(unsupported); - } + static void OnSuccessCallback_142(void * context) { (static_cast(context))->OnSuccessResponse_142(); } static void OnFailureCallback_143(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_143(error); } - static void OnSuccessCallback_143(void * context) { (static_cast(context))->OnSuccessResponse_143(); } + static void OnSuccessCallback_143(void * context, uint32_t epochS) + { + (static_cast(context))->OnSuccessResponse_143(epochS); + } - static void OnFailureCallback_146(void * context, CHIP_ERROR error) + static void OnFailureCallback_144(void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_146(error); + (static_cast(context))->OnFailureResponse_144(error); } - static void OnSuccessCallback_146(void * context, chip::VendorId vendorId) + static void OnSuccessCallback_144(void * context, bool unsupported) { - (static_cast(context))->OnSuccessResponse_146(vendorId); + (static_cast(context))->OnSuccessResponse_144(unsupported); } - static void OnFailureCallback_147(void * context, CHIP_ERROR error) + static void OnFailureCallback_145(void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_147(error); + (static_cast(context))->OnFailureResponse_145(error); } - static void OnSuccessCallback_147(void * context) { (static_cast(context))->OnSuccessResponse_147(); } + static void OnSuccessCallback_145(void * context) { (static_cast(context))->OnSuccessResponse_145(); } static void OnFailureCallback_148(void * context, CHIP_ERROR error) { @@ -54935,23 +54944,23 @@ class TestCluster : public TestCommand static void OnSuccessCallback_149(void * context) { (static_cast(context))->OnSuccessResponse_149(); } - static void OnFailureCallback_166(void * context, CHIP_ERROR error) + static void OnFailureCallback_150(void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_166(error); + (static_cast(context))->OnFailureResponse_150(error); } - static void OnSuccessCallback_166(void * context) { (static_cast(context))->OnSuccessResponse_166(); } - - static void OnFailureCallback_167(void * context, CHIP_ERROR error) + static void OnSuccessCallback_150(void * context, chip::VendorId vendorId) { - (static_cast(context))->OnFailureResponse_167(error); + (static_cast(context))->OnSuccessResponse_150(vendorId); } - static void OnSuccessCallback_167(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnFailureCallback_151(void * context, CHIP_ERROR error) { - (static_cast(context))->OnSuccessResponse_167(listInt8u); + (static_cast(context))->OnFailureResponse_151(error); } + static void OnSuccessCallback_151(void * context) { (static_cast(context))->OnSuccessResponse_151(); } + static void OnFailureCallback_168(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_168(error); @@ -54964,9 +54973,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_169(error); } - static void OnSuccessCallback_169(void * context, const chip::app::DataModel::DecodableList & listOctetString) + static void OnSuccessCallback_169(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnSuccessResponse_169(listOctetString); + (static_cast(context))->OnSuccessResponse_169(listInt8u); } static void OnFailureCallback_170(void * context, CHIP_ERROR error) @@ -54981,34 +54990,31 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_171(error); } - static void OnSuccessCallback_171( - void * context, - const chip::app::DataModel::DecodableList & - listStructOctetString) + static void OnSuccessCallback_171(void * context, const chip::app::DataModel::DecodableList & listOctetString) { - (static_cast(context))->OnSuccessResponse_171(listStructOctetString); + (static_cast(context))->OnSuccessResponse_171(listOctetString); } - static void OnFailureCallback_174(void * context, CHIP_ERROR error) + static void OnFailureCallback_172(void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_174(error); + (static_cast(context))->OnFailureResponse_172(error); } - static void OnSuccessCallback_174(void * context, - const chip::app::DataModel::DecodableList< - chip::app::Clusters::TestCluster::Structs::NullablesAndOptionalsStruct::DecodableType> & - listNullablesAndOptionalsStruct) + static void OnSuccessCallback_172(void * context) { (static_cast(context))->OnSuccessResponse_172(); } + + static void OnFailureCallback_173(void * context, CHIP_ERROR error) { - (static_cast(context))->OnSuccessResponse_174(listNullablesAndOptionalsStruct); + (static_cast(context))->OnFailureResponse_173(error); } - static void OnFailureCallback_175(void * context, CHIP_ERROR error) + static void OnSuccessCallback_173( + void * context, + const chip::app::DataModel::DecodableList & + listStructOctetString) { - (static_cast(context))->OnFailureResponse_175(error); + (static_cast(context))->OnSuccessResponse_173(listStructOctetString); } - static void OnSuccessCallback_175(void * context) { (static_cast(context))->OnSuccessResponse_175(); } - static void OnFailureCallback_176(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_176(error); @@ -55034,9 +55040,12 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_178(error); } - static void OnSuccessCallback_178(void * context, const chip::app::DataModel::Nullable & nullableBoolean) + static void OnSuccessCallback_178(void * context, + const chip::app::DataModel::DecodableList< + chip::app::Clusters::TestCluster::Structs::NullablesAndOptionalsStruct::DecodableType> & + listNullablesAndOptionalsStruct) { - (static_cast(context))->OnSuccessResponse_178(nullableBoolean); + (static_cast(context))->OnSuccessResponse_178(listNullablesAndOptionalsStruct); } static void OnFailureCallback_179(void * context, CHIP_ERROR error) @@ -55068,9 +55077,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_182(error); } - static void OnSuccessCallback_182(void * context, const chip::app::DataModel::Nullable & nullableBitmap8) + static void OnSuccessCallback_182(void * context, const chip::app::DataModel::Nullable & nullableBoolean) { - (static_cast(context))->OnSuccessResponse_182(nullableBitmap8); + (static_cast(context))->OnSuccessResponse_182(nullableBoolean); } static void OnFailureCallback_183(void * context, CHIP_ERROR error) @@ -55119,9 +55128,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_188(error); } - static void OnSuccessCallback_188(void * context, const chip::app::DataModel::Nullable & nullableBitmap16) + static void OnSuccessCallback_188(void * context, const chip::app::DataModel::Nullable & nullableBitmap8) { - (static_cast(context))->OnSuccessResponse_188(nullableBitmap16); + (static_cast(context))->OnSuccessResponse_188(nullableBitmap8); } static void OnFailureCallback_189(void * context, CHIP_ERROR error) @@ -55170,9 +55179,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_194(error); } - static void OnSuccessCallback_194(void * context, const chip::app::DataModel::Nullable & nullableBitmap32) + static void OnSuccessCallback_194(void * context, const chip::app::DataModel::Nullable & nullableBitmap16) { - (static_cast(context))->OnSuccessResponse_194(nullableBitmap32); + (static_cast(context))->OnSuccessResponse_194(nullableBitmap16); } static void OnFailureCallback_195(void * context, CHIP_ERROR error) @@ -55221,9 +55230,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_200(error); } - static void OnSuccessCallback_200(void * context, const chip::app::DataModel::Nullable & nullableBitmap64) + static void OnSuccessCallback_200(void * context, const chip::app::DataModel::Nullable & nullableBitmap32) { - (static_cast(context))->OnSuccessResponse_200(nullableBitmap64); + (static_cast(context))->OnSuccessResponse_200(nullableBitmap32); } static void OnFailureCallback_201(void * context, CHIP_ERROR error) @@ -55272,9 +55281,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_206(error); } - static void OnSuccessCallback_206(void * context, const chip::app::DataModel::Nullable & nullableInt8u) + static void OnSuccessCallback_206(void * context, const chip::app::DataModel::Nullable & nullableBitmap64) { - (static_cast(context))->OnSuccessResponse_206(nullableInt8u); + (static_cast(context))->OnSuccessResponse_206(nullableBitmap64); } static void OnFailureCallback_207(void * context, CHIP_ERROR error) @@ -55316,17 +55325,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_211(error); } - static void OnSuccessCallback_211(void * context, const chip::app::DataModel::Nullable & nullableInt8u) - { - (static_cast(context))->OnSuccessResponse_211(nullableInt8u); - } + static void OnSuccessCallback_211(void * context) { (static_cast(context))->OnSuccessResponse_211(); } static void OnFailureCallback_212(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_212(error); } - static void OnSuccessCallback_212(void * context) { (static_cast(context))->OnSuccessResponse_212(); } + static void OnSuccessCallback_212(void * context, const chip::app::DataModel::Nullable & nullableInt8u) + { + (static_cast(context))->OnSuccessResponse_212(nullableInt8u); + } static void OnFailureCallback_213(void * context, CHIP_ERROR error) { @@ -55343,10 +55352,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_214(error); } - static void OnSuccessCallback_214(void * context, const chip::app::DataModel::Nullable & nullableInt8u) - { - (static_cast(context))->OnSuccessResponse_214(nullableInt8u); - } + static void OnSuccessCallback_214(void * context) { (static_cast(context))->OnSuccessResponse_214(); } static void OnFailureCallback_215(void * context, CHIP_ERROR error) { @@ -55363,7 +55369,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_216(error); } - static void OnSuccessCallback_216(void * context) { (static_cast(context))->OnSuccessResponse_216(); } + static void OnSuccessCallback_216(void * context, const chip::app::DataModel::Nullable & nullableInt8u) + { + (static_cast(context))->OnSuccessResponse_216(nullableInt8u); + } static void OnFailureCallback_217(void * context, CHIP_ERROR error) { @@ -55380,26 +55389,26 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_218(error); } - static void OnSuccessCallback_218(void * context, const chip::app::DataModel::Nullable & nullableInt8u) - { - (static_cast(context))->OnSuccessResponse_218(nullableInt8u); - } + static void OnSuccessCallback_218(void * context) { (static_cast(context))->OnSuccessResponse_218(); } static void OnFailureCallback_219(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_219(error); } - static void OnSuccessCallback_219(void * context) { (static_cast(context))->OnSuccessResponse_219(); } + static void OnSuccessCallback_219(void * context, const chip::app::DataModel::Nullable & nullableInt8u) + { + (static_cast(context))->OnSuccessResponse_219(nullableInt8u); + } static void OnFailureCallback_220(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_220(error); } - static void OnSuccessCallback_220(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + static void OnSuccessCallback_220(void * context, const chip::app::DataModel::Nullable & nullableInt8u) { - (static_cast(context))->OnSuccessResponse_220(nullableInt16u); + (static_cast(context))->OnSuccessResponse_220(nullableInt8u); } static void OnFailureCallback_221(void * context, CHIP_ERROR error) @@ -55458,10 +55467,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_227(error); } - static void OnSuccessCallback_227(void * context, const chip::app::DataModel::Nullable & nullableInt16u) - { - (static_cast(context))->OnSuccessResponse_227(nullableInt16u); - } + static void OnSuccessCallback_227(void * context) { (static_cast(context))->OnSuccessResponse_227(); } static void OnFailureCallback_228(void * context, CHIP_ERROR error) { @@ -55478,7 +55484,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_229(error); } - static void OnSuccessCallback_229(void * context) { (static_cast(context))->OnSuccessResponse_229(); } + static void OnSuccessCallback_229(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + { + (static_cast(context))->OnSuccessResponse_229(nullableInt16u); + } static void OnFailureCallback_230(void * context, CHIP_ERROR error) { @@ -55495,26 +55504,26 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_231(error); } - static void OnSuccessCallback_231(void * context, const chip::app::DataModel::Nullable & nullableInt16u) - { - (static_cast(context))->OnSuccessResponse_231(nullableInt16u); - } + static void OnSuccessCallback_231(void * context) { (static_cast(context))->OnSuccessResponse_231(); } static void OnFailureCallback_232(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_232(error); } - static void OnSuccessCallback_232(void * context) { (static_cast(context))->OnSuccessResponse_232(); } + static void OnSuccessCallback_232(void * context, const chip::app::DataModel::Nullable & nullableInt16u) + { + (static_cast(context))->OnSuccessResponse_232(nullableInt16u); + } static void OnFailureCallback_233(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_233(error); } - static void OnSuccessCallback_233(void * context, const chip::app::DataModel::Nullable & nullableInt32u) + static void OnSuccessCallback_233(void * context, const chip::app::DataModel::Nullable & nullableInt16u) { - (static_cast(context))->OnSuccessResponse_233(nullableInt32u); + (static_cast(context))->OnSuccessResponse_233(nullableInt16u); } static void OnFailureCallback_234(void * context, CHIP_ERROR error) @@ -55573,10 +55582,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_240(error); } - static void OnSuccessCallback_240(void * context, const chip::app::DataModel::Nullable & nullableInt32u) - { - (static_cast(context))->OnSuccessResponse_240(nullableInt32u); - } + static void OnSuccessCallback_240(void * context) { (static_cast(context))->OnSuccessResponse_240(); } static void OnFailureCallback_241(void * context, CHIP_ERROR error) { @@ -55593,7 +55599,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_242(error); } - static void OnSuccessCallback_242(void * context) { (static_cast(context))->OnSuccessResponse_242(); } + static void OnSuccessCallback_242(void * context, const chip::app::DataModel::Nullable & nullableInt32u) + { + (static_cast(context))->OnSuccessResponse_242(nullableInt32u); + } static void OnFailureCallback_243(void * context, CHIP_ERROR error) { @@ -55610,26 +55619,26 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_244(error); } - static void OnSuccessCallback_244(void * context, const chip::app::DataModel::Nullable & nullableInt32u) - { - (static_cast(context))->OnSuccessResponse_244(nullableInt32u); - } + static void OnSuccessCallback_244(void * context) { (static_cast(context))->OnSuccessResponse_244(); } static void OnFailureCallback_245(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_245(error); } - static void OnSuccessCallback_245(void * context) { (static_cast(context))->OnSuccessResponse_245(); } + static void OnSuccessCallback_245(void * context, const chip::app::DataModel::Nullable & nullableInt32u) + { + (static_cast(context))->OnSuccessResponse_245(nullableInt32u); + } static void OnFailureCallback_246(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_246(error); } - static void OnSuccessCallback_246(void * context, const chip::app::DataModel::Nullable & nullableInt64u) + static void OnSuccessCallback_246(void * context, const chip::app::DataModel::Nullable & nullableInt32u) { - (static_cast(context))->OnSuccessResponse_246(nullableInt64u); + (static_cast(context))->OnSuccessResponse_246(nullableInt32u); } static void OnFailureCallback_247(void * context, CHIP_ERROR error) @@ -55688,10 +55697,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_253(error); } - static void OnSuccessCallback_253(void * context, const chip::app::DataModel::Nullable & nullableInt64u) - { - (static_cast(context))->OnSuccessResponse_253(nullableInt64u); - } + static void OnSuccessCallback_253(void * context) { (static_cast(context))->OnSuccessResponse_253(); } static void OnFailureCallback_254(void * context, CHIP_ERROR error) { @@ -55708,7 +55714,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_255(error); } - static void OnSuccessCallback_255(void * context) { (static_cast(context))->OnSuccessResponse_255(); } + static void OnSuccessCallback_255(void * context, const chip::app::DataModel::Nullable & nullableInt64u) + { + (static_cast(context))->OnSuccessResponse_255(nullableInt64u); + } static void OnFailureCallback_256(void * context, CHIP_ERROR error) { @@ -55725,26 +55734,26 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_257(error); } - static void OnSuccessCallback_257(void * context, const chip::app::DataModel::Nullable & nullableInt64u) - { - (static_cast(context))->OnSuccessResponse_257(nullableInt64u); - } + static void OnSuccessCallback_257(void * context) { (static_cast(context))->OnSuccessResponse_257(); } static void OnFailureCallback_258(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_258(error); } - static void OnSuccessCallback_258(void * context) { (static_cast(context))->OnSuccessResponse_258(); } + static void OnSuccessCallback_258(void * context, const chip::app::DataModel::Nullable & nullableInt64u) + { + (static_cast(context))->OnSuccessResponse_258(nullableInt64u); + } static void OnFailureCallback_259(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_259(error); } - static void OnSuccessCallback_259(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + static void OnSuccessCallback_259(void * context, const chip::app::DataModel::Nullable & nullableInt64u) { - (static_cast(context))->OnSuccessResponse_259(nullableInt8s); + (static_cast(context))->OnSuccessResponse_259(nullableInt64u); } static void OnFailureCallback_260(void * context, CHIP_ERROR error) @@ -55786,10 +55795,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_264(error); } - static void OnSuccessCallback_264(void * context, const chip::app::DataModel::Nullable & nullableInt8s) - { - (static_cast(context))->OnSuccessResponse_264(nullableInt8s); - } + static void OnSuccessCallback_264(void * context) { (static_cast(context))->OnSuccessResponse_264(); } static void OnFailureCallback_265(void * context, CHIP_ERROR error) { @@ -55806,7 +55812,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_266(error); } - static void OnSuccessCallback_266(void * context) { (static_cast(context))->OnSuccessResponse_266(); } + static void OnSuccessCallback_266(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + { + (static_cast(context))->OnSuccessResponse_266(nullableInt8s); + } static void OnFailureCallback_267(void * context, CHIP_ERROR error) { @@ -55823,26 +55832,26 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_268(error); } - static void OnSuccessCallback_268(void * context, const chip::app::DataModel::Nullable & nullableInt8s) - { - (static_cast(context))->OnSuccessResponse_268(nullableInt8s); - } + static void OnSuccessCallback_268(void * context) { (static_cast(context))->OnSuccessResponse_268(); } static void OnFailureCallback_269(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_269(error); } - static void OnSuccessCallback_269(void * context) { (static_cast(context))->OnSuccessResponse_269(); } + static void OnSuccessCallback_269(void * context, const chip::app::DataModel::Nullable & nullableInt8s) + { + (static_cast(context))->OnSuccessResponse_269(nullableInt8s); + } static void OnFailureCallback_270(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_270(error); } - static void OnSuccessCallback_270(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + static void OnSuccessCallback_270(void * context, const chip::app::DataModel::Nullable & nullableInt8s) { - (static_cast(context))->OnSuccessResponse_270(nullableInt16s); + (static_cast(context))->OnSuccessResponse_270(nullableInt8s); } static void OnFailureCallback_271(void * context, CHIP_ERROR error) @@ -55884,10 +55893,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_275(error); } - static void OnSuccessCallback_275(void * context, const chip::app::DataModel::Nullable & nullableInt16s) - { - (static_cast(context))->OnSuccessResponse_275(nullableInt16s); - } + static void OnSuccessCallback_275(void * context) { (static_cast(context))->OnSuccessResponse_275(); } static void OnFailureCallback_276(void * context, CHIP_ERROR error) { @@ -55904,7 +55910,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_277(error); } - static void OnSuccessCallback_277(void * context) { (static_cast(context))->OnSuccessResponse_277(); } + static void OnSuccessCallback_277(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + { + (static_cast(context))->OnSuccessResponse_277(nullableInt16s); + } static void OnFailureCallback_278(void * context, CHIP_ERROR error) { @@ -55921,26 +55930,26 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_279(error); } - static void OnSuccessCallback_279(void * context, const chip::app::DataModel::Nullable & nullableInt16s) - { - (static_cast(context))->OnSuccessResponse_279(nullableInt16s); - } + static void OnSuccessCallback_279(void * context) { (static_cast(context))->OnSuccessResponse_279(); } static void OnFailureCallback_280(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_280(error); } - static void OnSuccessCallback_280(void * context) { (static_cast(context))->OnSuccessResponse_280(); } + static void OnSuccessCallback_280(void * context, const chip::app::DataModel::Nullable & nullableInt16s) + { + (static_cast(context))->OnSuccessResponse_280(nullableInt16s); + } static void OnFailureCallback_281(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_281(error); } - static void OnSuccessCallback_281(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + static void OnSuccessCallback_281(void * context, const chip::app::DataModel::Nullable & nullableInt16s) { - (static_cast(context))->OnSuccessResponse_281(nullableInt32s); + (static_cast(context))->OnSuccessResponse_281(nullableInt16s); } static void OnFailureCallback_282(void * context, CHIP_ERROR error) @@ -55982,10 +55991,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_286(error); } - static void OnSuccessCallback_286(void * context, const chip::app::DataModel::Nullable & nullableInt32s) - { - (static_cast(context))->OnSuccessResponse_286(nullableInt32s); - } + static void OnSuccessCallback_286(void * context) { (static_cast(context))->OnSuccessResponse_286(); } static void OnFailureCallback_287(void * context, CHIP_ERROR error) { @@ -56002,7 +56008,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_288(error); } - static void OnSuccessCallback_288(void * context) { (static_cast(context))->OnSuccessResponse_288(); } + static void OnSuccessCallback_288(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + { + (static_cast(context))->OnSuccessResponse_288(nullableInt32s); + } static void OnFailureCallback_289(void * context, CHIP_ERROR error) { @@ -56019,26 +56028,26 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_290(error); } - static void OnSuccessCallback_290(void * context, const chip::app::DataModel::Nullable & nullableInt32s) - { - (static_cast(context))->OnSuccessResponse_290(nullableInt32s); - } + static void OnSuccessCallback_290(void * context) { (static_cast(context))->OnSuccessResponse_290(); } static void OnFailureCallback_291(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_291(error); } - static void OnSuccessCallback_291(void * context) { (static_cast(context))->OnSuccessResponse_291(); } + static void OnSuccessCallback_291(void * context, const chip::app::DataModel::Nullable & nullableInt32s) + { + (static_cast(context))->OnSuccessResponse_291(nullableInt32s); + } static void OnFailureCallback_292(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_292(error); } - static void OnSuccessCallback_292(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + static void OnSuccessCallback_292(void * context, const chip::app::DataModel::Nullable & nullableInt32s) { - (static_cast(context))->OnSuccessResponse_292(nullableInt64s); + (static_cast(context))->OnSuccessResponse_292(nullableInt32s); } static void OnFailureCallback_293(void * context, CHIP_ERROR error) @@ -56080,10 +56089,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_297(error); } - static void OnSuccessCallback_297(void * context, const chip::app::DataModel::Nullable & nullableInt64s) - { - (static_cast(context))->OnSuccessResponse_297(nullableInt64s); - } + static void OnSuccessCallback_297(void * context) { (static_cast(context))->OnSuccessResponse_297(); } static void OnFailureCallback_298(void * context, CHIP_ERROR error) { @@ -56100,7 +56106,10 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_299(error); } - static void OnSuccessCallback_299(void * context) { (static_cast(context))->OnSuccessResponse_299(); } + static void OnSuccessCallback_299(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + { + (static_cast(context))->OnSuccessResponse_299(nullableInt64s); + } static void OnFailureCallback_300(void * context, CHIP_ERROR error) { @@ -56117,26 +56126,26 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_301(error); } - static void OnSuccessCallback_301(void * context, const chip::app::DataModel::Nullable & nullableInt64s) - { - (static_cast(context))->OnSuccessResponse_301(nullableInt64s); - } + static void OnSuccessCallback_301(void * context) { (static_cast(context))->OnSuccessResponse_301(); } static void OnFailureCallback_302(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_302(error); } - static void OnSuccessCallback_302(void * context) { (static_cast(context))->OnSuccessResponse_302(); } + static void OnSuccessCallback_302(void * context, const chip::app::DataModel::Nullable & nullableInt64s) + { + (static_cast(context))->OnSuccessResponse_302(nullableInt64s); + } static void OnFailureCallback_303(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_303(error); } - static void OnSuccessCallback_303(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) + static void OnSuccessCallback_303(void * context, const chip::app::DataModel::Nullable & nullableInt64s) { - (static_cast(context))->OnSuccessResponse_303(nullableFloatSingle); + (static_cast(context))->OnSuccessResponse_303(nullableInt64s); } static void OnFailureCallback_304(void * context, CHIP_ERROR error) @@ -56219,9 +56228,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_313(error); } - static void OnSuccessCallback_313(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) + static void OnSuccessCallback_313(void * context, const chip::app::DataModel::Nullable & nullableFloatSingle) { - (static_cast(context))->OnSuccessResponse_313(nullableFloatDouble); + (static_cast(context))->OnSuccessResponse_313(nullableFloatSingle); } static void OnFailureCallback_314(void * context, CHIP_ERROR error) @@ -56304,9 +56313,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_323(error); } - static void OnSuccessCallback_323(void * context, const chip::app::DataModel::Nullable & nullableEnum8) + static void OnSuccessCallback_323(void * context, const chip::app::DataModel::Nullable & nullableFloatDouble) { - (static_cast(context))->OnSuccessResponse_323(nullableEnum8); + (static_cast(context))->OnSuccessResponse_323(nullableFloatDouble); } static void OnFailureCallback_324(void * context, CHIP_ERROR error) @@ -56372,9 +56381,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_331(error); } - static void OnSuccessCallback_331(void * context, const chip::app::DataModel::Nullable & nullableEnum16) + static void OnSuccessCallback_331(void * context, const chip::app::DataModel::Nullable & nullableEnum8) { - (static_cast(context))->OnSuccessResponse_331(nullableEnum16); + (static_cast(context))->OnSuccessResponse_331(nullableEnum8); } static void OnFailureCallback_332(void * context, CHIP_ERROR error) @@ -56440,11 +56449,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_339(error); } - static void - OnSuccessCallback_339(void * context, - const chip::app::DataModel::Nullable & nullableEnumAttr) + static void OnSuccessCallback_339(void * context, const chip::app::DataModel::Nullable & nullableEnum16) { - (static_cast(context))->OnSuccessResponse_339(nullableEnumAttr); + (static_cast(context))->OnSuccessResponse_339(nullableEnum16); } static void OnFailureCallback_340(void * context, CHIP_ERROR error) @@ -56509,17 +56516,19 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_346(error); } - static void OnSuccessCallback_346(void * context, const chip::app::DataModel::Nullable & nullableOctetString) - { - (static_cast(context))->OnSuccessResponse_346(nullableOctetString); - } + static void OnSuccessCallback_346(void * context) { (static_cast(context))->OnSuccessResponse_346(); } static void OnFailureCallback_347(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_347(error); } - static void OnSuccessCallback_347(void * context) { (static_cast(context))->OnSuccessResponse_347(); } + static void + OnSuccessCallback_347(void * context, + const chip::app::DataModel::Nullable & nullableEnumAttr) + { + (static_cast(context))->OnSuccessResponse_347(nullableEnumAttr); + } static void OnFailureCallback_348(void * context, CHIP_ERROR error) { @@ -56570,17 +56579,17 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_353(error); } - static void OnSuccessCallback_353(void * context, const chip::app::DataModel::Nullable & nullableCharString) - { - (static_cast(context))->OnSuccessResponse_353(nullableCharString); - } + static void OnSuccessCallback_353(void * context) { (static_cast(context))->OnSuccessResponse_353(); } static void OnFailureCallback_354(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_354(error); } - static void OnSuccessCallback_354(void * context) { (static_cast(context))->OnSuccessResponse_354(); } + static void OnSuccessCallback_354(void * context, const chip::app::DataModel::Nullable & nullableOctetString) + { + (static_cast(context))->OnSuccessResponse_354(nullableOctetString); + } static void OnFailureCallback_355(void * context, CHIP_ERROR error) { @@ -56631,54 +56640,49 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_360(error); } - static void OnSuccessCallback_360(void * context, const chip::app::DataModel::DecodableList & listInt8u) - { - (static_cast(context))->OnSuccessResponse_360(listInt8u); - } + static void OnSuccessCallback_360(void * context) { (static_cast(context))->OnSuccessResponse_360(); } static void OnFailureCallback_361(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_361(error); } - static void OnSuccessCallback_361(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnSuccessCallback_361(void * context, const chip::app::DataModel::Nullable & nullableCharString) { - (static_cast(context))->OnSuccessResponse_361(listInt8u); + (static_cast(context))->OnSuccessResponse_361(nullableCharString); } - static void OnFailureCallback_364(void * context, CHIP_ERROR error) + static void OnFailureCallback_362(void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_364(error); + (static_cast(context))->OnFailureResponse_362(error); } - static void OnSuccessCallback_364(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnSuccessCallback_362(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnSuccessResponse_364(listInt8u); + (static_cast(context))->OnSuccessResponse_362(listInt8u); } - bool mReceivedReport_364 = false; - - static void OnFailureCallback_365(void * context, CHIP_ERROR error) + static void OnFailureCallback_363(void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_365(error); + (static_cast(context))->OnFailureResponse_363(error); } - static void OnSuccessCallback_365(void * context, const chip::app::DataModel::DecodableList & listInt8u) + static void OnSuccessCallback_363(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnSuccessResponse_365(listInt8u); + (static_cast(context))->OnSuccessResponse_363(listInt8u); } - static void OnSubscriptionEstablished_365(void * context) + static void OnFailureCallback_366(void * context, CHIP_ERROR error) { - (static_cast(context))->OnSubscriptionEstablishedResponse_365(); + (static_cast(context))->OnFailureResponse_366(error); } - static void OnFailureCallback_366(void * context, CHIP_ERROR error) + static void OnSuccessCallback_366(void * context, const chip::app::DataModel::DecodableList & listInt8u) { - (static_cast(context))->OnFailureResponse_366(error); + (static_cast(context))->OnSuccessResponse_366(listInt8u); } - static void OnSuccessCallback_366(void * context) { (static_cast(context))->OnSuccessResponse_366(); } + bool mReceivedReport_366 = false; static void OnFailureCallback_367(void * context, CHIP_ERROR error) { @@ -56690,31 +56694,39 @@ class TestCluster : public TestCommand (static_cast(context))->OnSuccessResponse_367(listInt8u); } - bool mReceivedReport_367 = false; + static void OnSubscriptionEstablished_367(void * context) + { + (static_cast(context))->OnSubscriptionEstablishedResponse_367(); + } static void OnFailureCallback_368(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_368(error); } - static void OnSuccessCallback_368(void * context, uint8_t rangeRestrictedInt8u) - { - (static_cast(context))->OnSuccessResponse_368(rangeRestrictedInt8u); - } + static void OnSuccessCallback_368(void * context) { (static_cast(context))->OnSuccessResponse_368(); } static void OnFailureCallback_369(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_369(error); } - static void OnSuccessCallback_369(void * context) { (static_cast(context))->OnSuccessResponse_369(); } - - static void OnFailureCallback_370(void * context, CHIP_ERROR error) + static void OnSuccessCallback_369(void * context, const chip::app::DataModel::DecodableList & listInt8u) + { + (static_cast(context))->OnSuccessResponse_369(listInt8u); + } + + bool mReceivedReport_369 = false; + + static void OnFailureCallback_370(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_370(error); } - static void OnSuccessCallback_370(void * context) { (static_cast(context))->OnSuccessResponse_370(); } + static void OnSuccessCallback_370(void * context, uint8_t rangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_370(rangeRestrictedInt8u); + } static void OnFailureCallback_371(void * context, CHIP_ERROR error) { @@ -56735,10 +56747,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_373(error); } - static void OnSuccessCallback_373(void * context, uint8_t rangeRestrictedInt8u) - { - (static_cast(context))->OnSuccessResponse_373(rangeRestrictedInt8u); - } + static void OnSuccessCallback_373(void * context) { (static_cast(context))->OnSuccessResponse_373(); } static void OnFailureCallback_374(void * context, CHIP_ERROR error) { @@ -56796,24 +56805,27 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_380(error); } - static void OnSuccessCallback_380(void * context, uint16_t rangeRestrictedInt16u) - { - (static_cast(context))->OnSuccessResponse_380(rangeRestrictedInt16u); - } + static void OnSuccessCallback_380(void * context) { (static_cast(context))->OnSuccessResponse_380(); } static void OnFailureCallback_381(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_381(error); } - static void OnSuccessCallback_381(void * context) { (static_cast(context))->OnSuccessResponse_381(); } + static void OnSuccessCallback_381(void * context, uint8_t rangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_381(rangeRestrictedInt8u); + } static void OnFailureCallback_382(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_382(error); } - static void OnSuccessCallback_382(void * context) { (static_cast(context))->OnSuccessResponse_382(); } + static void OnSuccessCallback_382(void * context, uint16_t rangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_382(rangeRestrictedInt16u); + } static void OnFailureCallback_383(void * context, CHIP_ERROR error) { @@ -56834,10 +56846,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_385(error); } - static void OnSuccessCallback_385(void * context, uint16_t rangeRestrictedInt16u) - { - (static_cast(context))->OnSuccessResponse_385(rangeRestrictedInt16u); - } + static void OnSuccessCallback_385(void * context) { (static_cast(context))->OnSuccessResponse_385(); } static void OnFailureCallback_386(void * context, CHIP_ERROR error) { @@ -56895,24 +56904,27 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_392(error); } - static void OnSuccessCallback_392(void * context, int8_t rangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_392(rangeRestrictedInt8s); - } + static void OnSuccessCallback_392(void * context) { (static_cast(context))->OnSuccessResponse_392(); } static void OnFailureCallback_393(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_393(error); } - static void OnSuccessCallback_393(void * context) { (static_cast(context))->OnSuccessResponse_393(); } + static void OnSuccessCallback_393(void * context, uint16_t rangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_393(rangeRestrictedInt16u); + } static void OnFailureCallback_394(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_394(error); } - static void OnSuccessCallback_394(void * context) { (static_cast(context))->OnSuccessResponse_394(); } + static void OnSuccessCallback_394(void * context, int8_t rangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_394(rangeRestrictedInt8s); + } static void OnFailureCallback_395(void * context, CHIP_ERROR error) { @@ -56933,10 +56945,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_397(error); } - static void OnSuccessCallback_397(void * context, int8_t rangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_397(rangeRestrictedInt8s); - } + static void OnSuccessCallback_397(void * context) { (static_cast(context))->OnSuccessResponse_397(); } static void OnFailureCallback_398(void * context, CHIP_ERROR error) { @@ -56994,24 +57003,27 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_404(error); } - static void OnSuccessCallback_404(void * context, int16_t rangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_404(rangeRestrictedInt16s); - } + static void OnSuccessCallback_404(void * context) { (static_cast(context))->OnSuccessResponse_404(); } static void OnFailureCallback_405(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_405(error); } - static void OnSuccessCallback_405(void * context) { (static_cast(context))->OnSuccessResponse_405(); } + static void OnSuccessCallback_405(void * context, int8_t rangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_405(rangeRestrictedInt8s); + } static void OnFailureCallback_406(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_406(error); } - static void OnSuccessCallback_406(void * context) { (static_cast(context))->OnSuccessResponse_406(); } + static void OnSuccessCallback_406(void * context, int16_t rangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_406(rangeRestrictedInt16s); + } static void OnFailureCallback_407(void * context, CHIP_ERROR error) { @@ -57032,10 +57044,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_409(error); } - static void OnSuccessCallback_409(void * context, int16_t rangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_409(rangeRestrictedInt16s); - } + static void OnSuccessCallback_409(void * context) { (static_cast(context))->OnSuccessResponse_409(); } static void OnFailureCallback_410(void * context, CHIP_ERROR error) { @@ -57093,24 +57102,27 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_416(error); } - static void OnSuccessCallback_416(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) - { - (static_cast(context))->OnSuccessResponse_416(nullableRangeRestrictedInt8u); - } + static void OnSuccessCallback_416(void * context) { (static_cast(context))->OnSuccessResponse_416(); } static void OnFailureCallback_417(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_417(error); } - static void OnSuccessCallback_417(void * context) { (static_cast(context))->OnSuccessResponse_417(); } + static void OnSuccessCallback_417(void * context, int16_t rangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_417(rangeRestrictedInt16s); + } static void OnFailureCallback_418(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_418(error); } - static void OnSuccessCallback_418(void * context) { (static_cast(context))->OnSuccessResponse_418(); } + static void OnSuccessCallback_418(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_418(nullableRangeRestrictedInt8u); + } static void OnFailureCallback_419(void * context, CHIP_ERROR error) { @@ -57131,10 +57143,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_421(error); } - static void OnSuccessCallback_421(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) - { - (static_cast(context))->OnSuccessResponse_421(nullableRangeRestrictedInt8u); - } + static void OnSuccessCallback_421(void * context) { (static_cast(context))->OnSuccessResponse_421(); } static void OnFailureCallback_422(void * context, CHIP_ERROR error) { @@ -57209,25 +57218,28 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_430(error); } - static void OnSuccessCallback_430(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) - { - (static_cast(context))->OnSuccessResponse_430(nullableRangeRestrictedInt16u); - } + static void OnSuccessCallback_430(void * context) { (static_cast(context))->OnSuccessResponse_430(); } static void OnFailureCallback_431(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_431(error); } - static void OnSuccessCallback_431(void * context) { (static_cast(context))->OnSuccessResponse_431(); } + static void OnSuccessCallback_431(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + { + (static_cast(context))->OnSuccessResponse_431(nullableRangeRestrictedInt8u); + } static void OnFailureCallback_432(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_432(error); } - static void OnSuccessCallback_432(void * context) { (static_cast(context))->OnSuccessResponse_432(); } + static void OnSuccessCallback_432(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_432(nullableRangeRestrictedInt16u); + } static void OnFailureCallback_433(void * context, CHIP_ERROR error) { @@ -57248,11 +57260,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_435(error); } - static void OnSuccessCallback_435(void * context, - const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) - { - (static_cast(context))->OnSuccessResponse_435(nullableRangeRestrictedInt16u); - } + static void OnSuccessCallback_435(void * context) { (static_cast(context))->OnSuccessResponse_435(); } static void OnFailureCallback_436(void * context, CHIP_ERROR error) { @@ -57331,24 +57339,28 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_444(error); } - static void OnSuccessCallback_444(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_444(nullableRangeRestrictedInt8s); - } + static void OnSuccessCallback_444(void * context) { (static_cast(context))->OnSuccessResponse_444(); } static void OnFailureCallback_445(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_445(error); } - static void OnSuccessCallback_445(void * context) { (static_cast(context))->OnSuccessResponse_445(); } + static void OnSuccessCallback_445(void * context, + const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + { + (static_cast(context))->OnSuccessResponse_445(nullableRangeRestrictedInt16u); + } static void OnFailureCallback_446(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_446(error); } - static void OnSuccessCallback_446(void * context) { (static_cast(context))->OnSuccessResponse_446(); } + static void OnSuccessCallback_446(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_446(nullableRangeRestrictedInt8s); + } static void OnFailureCallback_447(void * context, CHIP_ERROR error) { @@ -57369,10 +57381,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_449(error); } - static void OnSuccessCallback_449(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) - { - (static_cast(context))->OnSuccessResponse_449(nullableRangeRestrictedInt8s); - } + static void OnSuccessCallback_449(void * context) { (static_cast(context))->OnSuccessResponse_449(); } static void OnFailureCallback_450(void * context, CHIP_ERROR error) { @@ -57447,24 +57456,27 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_458(error); } - static void OnSuccessCallback_458(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_458(nullableRangeRestrictedInt16s); - } + static void OnSuccessCallback_458(void * context) { (static_cast(context))->OnSuccessResponse_458(); } static void OnFailureCallback_459(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_459(error); } - static void OnSuccessCallback_459(void * context) { (static_cast(context))->OnSuccessResponse_459(); } + static void OnSuccessCallback_459(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + { + (static_cast(context))->OnSuccessResponse_459(nullableRangeRestrictedInt8s); + } static void OnFailureCallback_460(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_460(error); } - static void OnSuccessCallback_460(void * context) { (static_cast(context))->OnSuccessResponse_460(); } + static void OnSuccessCallback_460(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_460(nullableRangeRestrictedInt16s); + } static void OnFailureCallback_461(void * context, CHIP_ERROR error) { @@ -57485,10 +57497,7 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_463(error); } - static void OnSuccessCallback_463(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) - { - (static_cast(context))->OnSuccessResponse_463(nullableRangeRestrictedInt16s); - } + static void OnSuccessCallback_463(void * context) { (static_cast(context))->OnSuccessResponse_463(); } static void OnFailureCallback_464(void * context, CHIP_ERROR error) { @@ -57570,37 +57579,33 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_473(error); } - static void OnSuccessCallback_473(void * context) { (static_cast(context))->OnSuccessResponse_473(); } + static void OnSuccessCallback_473(void * context, const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + { + (static_cast(context))->OnSuccessResponse_473(nullableRangeRestrictedInt16s); + } static void OnFailureCallback_474(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_474(error); } - static void OnSuccessCallback_474(void * context, bool generalErrorBoolean) - { - (static_cast(context))->OnSuccessResponse_474(generalErrorBoolean); - } + static void OnSuccessCallback_474(void * context) { (static_cast(context))->OnSuccessResponse_474(); } static void OnFailureCallback_475(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_475(error); } - static void OnSuccessCallback_475(void * context, bool clusterErrorBoolean) - { - (static_cast(context))->OnSuccessResponse_475(clusterErrorBoolean); - } + static void OnSuccessCallback_475(void * context) { (static_cast(context))->OnSuccessResponse_475(); } static void OnFailureCallback_476(void * context, CHIP_ERROR error) { (static_cast(context))->OnFailureResponse_476(error); } - static void OnSuccessCallback_476(void * context, - const chip::app::DataModel::DecodableList & clientGeneratedCommandList) + static void OnSuccessCallback_476(void * context, bool generalErrorBoolean) { - (static_cast(context))->OnSuccessResponse_476(clientGeneratedCommandList); + (static_cast(context))->OnSuccessResponse_476(generalErrorBoolean); } static void OnFailureCallback_477(void * context, CHIP_ERROR error) @@ -57608,10 +57613,9 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_477(error); } - static void OnSuccessCallback_477(void * context, - const chip::app::DataModel::DecodableList & serverGeneratedCommandList) + static void OnSuccessCallback_477(void * context, bool clusterErrorBoolean) { - (static_cast(context))->OnSuccessResponse_477(serverGeneratedCommandList); + (static_cast(context))->OnSuccessResponse_477(clusterErrorBoolean); } static void OnFailureCallback_478(void * context, CHIP_ERROR error) @@ -57619,7 +57623,11 @@ class TestCluster : public TestCommand (static_cast(context))->OnFailureResponse_478(error); } - static void OnSuccessCallback_478(void * context) { (static_cast(context))->OnSuccessResponse_478(); } + static void OnSuccessCallback_478(void * context, + const chip::app::DataModel::DecodableList & clientGeneratedCommandList) + { + (static_cast(context))->OnSuccessResponse_478(clientGeneratedCommandList); + } static void OnFailureCallback_479(void * context, CHIP_ERROR error) { @@ -57627,9 +57635,27 @@ class TestCluster : public TestCommand } static void OnSuccessCallback_479(void * context, + const chip::app::DataModel::DecodableList & serverGeneratedCommandList) + { + (static_cast(context))->OnSuccessResponse_479(serverGeneratedCommandList); + } + + static void OnFailureCallback_480(void * context, CHIP_ERROR error) + { + (static_cast(context))->OnFailureResponse_480(error); + } + + static void OnSuccessCallback_480(void * context) { (static_cast(context))->OnSuccessResponse_480(); } + + static void OnFailureCallback_481(void * context, CHIP_ERROR error) + { + (static_cast(context))->OnFailureResponse_481(error); + } + + static void OnSuccessCallback_481(void * context, const chip::app::Clusters::TestCluster::Structs::SimpleStruct::DecodableType & structAttr) { - (static_cast(context))->OnSuccessResponse_479(structAttr); + (static_cast(context))->OnSuccessResponse_481(structAttr); } // @@ -60704,7 +60730,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_130() { NextTest(); } - CHIP_ERROR TestReadAttributeListLongOctetString_131() + CHIP_ERROR TestReadAttributeListLongOctetStringForChunkedRead_131() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -60775,14 +60801,59 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeEpochUsDefaultValue_132() + CHIP_ERROR TestWriteAttributeListLongOctetStringForChunkedWrite_132() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_132, OnFailureCallback_132)); + chip::app::DataModel::List listLongOctetStringArgument; + + chip::ByteSpan listLongOctetStringList_0[5]; + listLongOctetStringList_0[0] = chip::ByteSpan( + chip::Uint8::from_const_char( + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01" + "23456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123" + "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef012345" + "6789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdefgarbage: not in length on purpose"), + 512); + listLongOctetStringList_0[1] = chip::ByteSpan( + chip::Uint8::from_const_char( + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01" + "23456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123" + "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef012345" + "6789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdefgarbage: not in length on purpose"), + 512); + listLongOctetStringList_0[2] = chip::ByteSpan( + chip::Uint8::from_const_char( + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01" + "23456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123" + "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef012345" + "6789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdefgarbage: not in length on purpose"), + 512); + listLongOctetStringList_0[3] = chip::ByteSpan( + chip::Uint8::from_const_char( + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01" + "23456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123" + "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef012345" + "6789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdefgarbage: not in length on purpose"), + 512); + listLongOctetStringList_0[4] = chip::ByteSpan( + chip::Uint8::from_const_char( + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01" + "23456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123" + "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef012345" + "6789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdefgarbage: not in length on purpose"), + 512); + listLongOctetStringArgument = listLongOctetStringList_0; + + ReturnErrorOnFailure(cluster.WriteAttribute( + listLongOctetStringArgument, this, OnSuccessCallback_132, OnFailureCallback_132)); return CHIP_NO_ERROR; } @@ -60792,14 +60863,115 @@ class TestCluster : public TestCommand ThrowFailureResponse(); } - void OnSuccessResponse_132(uint64_t epochUs) + void OnSuccessResponse_132() { NextTest(); } + + CHIP_ERROR TestReadAttributeListLongOctetStringForChunkedRead_133() + { + const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_133, OnFailureCallback_133)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_133(CHIP_ERROR error) + { + chip::app::StatusIB status(error); + ThrowFailureResponse(); + } + + void OnSuccessResponse_133(const chip::app::DataModel::DecodableList & listLongOctetString) + { + { + auto iter_0 = listLongOctetString.begin(); + VerifyOrReturn(CheckNextListItemDecodes("listLongOctetString", iter_0, 0)); + VerifyOrReturn(CheckValueAsString( + "listLongOctetString[0]", iter_0.GetValue(), + chip::ByteSpan( + chip::Uint8::from_const_char( + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789" + "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123" + "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcd" + "ef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), + 512))); + VerifyOrReturn(CheckNextListItemDecodes("listLongOctetString", iter_0, 1)); + VerifyOrReturn(CheckValueAsString( + "listLongOctetString[1]", iter_0.GetValue(), + chip::ByteSpan( + chip::Uint8::from_const_char( + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789" + "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123" + "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcd" + "ef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), + 512))); + VerifyOrReturn(CheckNextListItemDecodes("listLongOctetString", iter_0, 2)); + VerifyOrReturn(CheckValueAsString( + "listLongOctetString[2]", iter_0.GetValue(), + chip::ByteSpan( + chip::Uint8::from_const_char( + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789" + "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123" + "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcd" + "ef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), + 512))); + VerifyOrReturn(CheckNextListItemDecodes("listLongOctetString", iter_0, 3)); + VerifyOrReturn(CheckValueAsString( + "listLongOctetString[3]", iter_0.GetValue(), + chip::ByteSpan( + chip::Uint8::from_const_char( + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789" + "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123" + "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcd" + "ef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), + 512))); + VerifyOrReturn(CheckNextListItemDecodes("listLongOctetString", iter_0, 4)); + VerifyOrReturn(CheckValueAsString( + "listLongOctetString[4]", iter_0.GetValue(), + chip::ByteSpan( + chip::Uint8::from_const_char( + "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789" + "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123" + "456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcd" + "ef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef01234567" + "89abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"), + 512))); + VerifyOrReturn(CheckNoMoreListItems("listLongOctetString", iter_0, 5)); + } + + NextTest(); + } + + CHIP_ERROR TestReadAttributeEpochUsDefaultValue_134() + { + const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_134, OnFailureCallback_134)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_134(CHIP_ERROR error) + { + chip::app::StatusIB status(error); + ThrowFailureResponse(); + } + + void OnSuccessResponse_134(uint64_t epochUs) { VerifyOrReturn(CheckValue("epochUs", epochUs, 0ULL)); NextTest(); } - CHIP_ERROR TestWriteAttributeEpochUsMaxValue_133() + CHIP_ERROR TestWriteAttributeEpochUsMaxValue_135() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -60809,43 +60981,43 @@ class TestCluster : public TestCommand epochUsArgument = 18446744073709551615ULL; ReturnErrorOnFailure(cluster.WriteAttribute( - epochUsArgument, this, OnSuccessCallback_133, OnFailureCallback_133)); + epochUsArgument, this, OnSuccessCallback_135, OnFailureCallback_135)); return CHIP_NO_ERROR; } - void OnFailureResponse_133(CHIP_ERROR error) + void OnFailureResponse_135(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_133() { NextTest(); } + void OnSuccessResponse_135() { NextTest(); } - CHIP_ERROR TestReadAttributeEpochUsMaxValue_134() + CHIP_ERROR TestReadAttributeEpochUsMaxValue_136() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_134, OnFailureCallback_134)); + this, OnSuccessCallback_136, OnFailureCallback_136)); return CHIP_NO_ERROR; } - void OnFailureResponse_134(CHIP_ERROR error) + void OnFailureResponse_136(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_134(uint64_t epochUs) + void OnSuccessResponse_136(uint64_t epochUs) { VerifyOrReturn(CheckValue("epochUs", epochUs, 18446744073709551615ULL)); NextTest(); } - CHIP_ERROR TestWriteAttributeEpochUsMinValue_135() + CHIP_ERROR TestWriteAttributeEpochUsMinValue_137() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -60855,67 +61027,67 @@ class TestCluster : public TestCommand epochUsArgument = 0ULL; ReturnErrorOnFailure(cluster.WriteAttribute( - epochUsArgument, this, OnSuccessCallback_135, OnFailureCallback_135)); + epochUsArgument, this, OnSuccessCallback_137, OnFailureCallback_137)); return CHIP_NO_ERROR; } - void OnFailureResponse_135(CHIP_ERROR error) + void OnFailureResponse_137(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_135() { NextTest(); } + void OnSuccessResponse_137() { NextTest(); } - CHIP_ERROR TestReadAttributeEpochUsMinValue_136() + CHIP_ERROR TestReadAttributeEpochUsMinValue_138() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_136, OnFailureCallback_136)); + this, OnSuccessCallback_138, OnFailureCallback_138)); return CHIP_NO_ERROR; } - void OnFailureResponse_136(CHIP_ERROR error) + void OnFailureResponse_138(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_136(uint64_t epochUs) + void OnSuccessResponse_138(uint64_t epochUs) { VerifyOrReturn(CheckValue("epochUs", epochUs, 0ULL)); NextTest(); } - CHIP_ERROR TestReadAttributeEpochSDefaultValue_137() + CHIP_ERROR TestReadAttributeEpochSDefaultValue_139() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_137, OnFailureCallback_137)); + this, OnSuccessCallback_139, OnFailureCallback_139)); return CHIP_NO_ERROR; } - void OnFailureResponse_137(CHIP_ERROR error) + void OnFailureResponse_139(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_137(uint32_t epochS) + void OnSuccessResponse_139(uint32_t epochS) { VerifyOrReturn(CheckValue("epochS", epochS, 0UL)); NextTest(); } - CHIP_ERROR TestWriteAttributeEpochSMaxValue_138() + CHIP_ERROR TestWriteAttributeEpochSMaxValue_140() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -60925,43 +61097,43 @@ class TestCluster : public TestCommand epochSArgument = 4294967295UL; ReturnErrorOnFailure(cluster.WriteAttribute( - epochSArgument, this, OnSuccessCallback_138, OnFailureCallback_138)); + epochSArgument, this, OnSuccessCallback_140, OnFailureCallback_140)); return CHIP_NO_ERROR; } - void OnFailureResponse_138(CHIP_ERROR error) + void OnFailureResponse_140(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_138() { NextTest(); } + void OnSuccessResponse_140() { NextTest(); } - CHIP_ERROR TestReadAttributeEpochSMaxValue_139() + CHIP_ERROR TestReadAttributeEpochSMaxValue_141() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_139, OnFailureCallback_139)); + this, OnSuccessCallback_141, OnFailureCallback_141)); return CHIP_NO_ERROR; } - void OnFailureResponse_139(CHIP_ERROR error) + void OnFailureResponse_141(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_139(uint32_t epochS) + void OnSuccessResponse_141(uint32_t epochS) { VerifyOrReturn(CheckValue("epochS", epochS, 4294967295UL)); NextTest(); } - CHIP_ERROR TestWriteAttributeEpochSMinValue_140() + CHIP_ERROR TestWriteAttributeEpochSMinValue_142() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -60971,67 +61143,67 @@ class TestCluster : public TestCommand epochSArgument = 0UL; ReturnErrorOnFailure(cluster.WriteAttribute( - epochSArgument, this, OnSuccessCallback_140, OnFailureCallback_140)); + epochSArgument, this, OnSuccessCallback_142, OnFailureCallback_142)); return CHIP_NO_ERROR; } - void OnFailureResponse_140(CHIP_ERROR error) + void OnFailureResponse_142(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_140() { NextTest(); } + void OnSuccessResponse_142() { NextTest(); } - CHIP_ERROR TestReadAttributeEpochSMinValue_141() + CHIP_ERROR TestReadAttributeEpochSMinValue_143() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_141, OnFailureCallback_141)); + this, OnSuccessCallback_143, OnFailureCallback_143)); return CHIP_NO_ERROR; } - void OnFailureResponse_141(CHIP_ERROR error) + void OnFailureResponse_143(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_141(uint32_t epochS) + void OnSuccessResponse_143(uint32_t epochS) { VerifyOrReturn(CheckValue("epochS", epochS, 0UL)); NextTest(); } - CHIP_ERROR TestReadAttributeUnsupported_142() + CHIP_ERROR TestReadAttributeUnsupported_144() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_142, OnFailureCallback_142)); + this, OnSuccessCallback_144, OnFailureCallback_144)); return CHIP_NO_ERROR; } - void OnFailureResponse_142(CHIP_ERROR error) + void OnFailureResponse_144(CHIP_ERROR error) { chip::app::StatusIB status(error); (status.mStatus == chip::Protocols::InteractionModel::Status::UnsupportedAttribute) ? NextTest() : ThrowFailureResponse(); } - void OnSuccessResponse_142(bool unsupported) + void OnSuccessResponse_144(bool unsupported) { VerifyOrReturn(CheckValue("unsupported", unsupported, 0)); NextTest(); } - CHIP_ERROR TestWriteattributeUnsupported_143() + CHIP_ERROR TestWriteattributeUnsupported_145() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -61041,19 +61213,19 @@ class TestCluster : public TestCommand unsupportedArgument = 0; ReturnErrorOnFailure(cluster.WriteAttribute( - unsupportedArgument, this, OnSuccessCallback_143, OnFailureCallback_143)); + unsupportedArgument, this, OnSuccessCallback_145, OnFailureCallback_145)); return CHIP_NO_ERROR; } - void OnFailureResponse_143(CHIP_ERROR error) + void OnFailureResponse_145(CHIP_ERROR error) { chip::app::StatusIB status(error); (status.mStatus == chip::Protocols::InteractionModel::Status::UnsupportedAttribute) ? NextTest() : ThrowFailureResponse(); } - void OnSuccessResponse_143() { NextTest(); } + void OnSuccessResponse_145() { NextTest(); } - CHIP_ERROR TestSendTestCommandToUnsupportedEndpoint_144() + CHIP_ERROR TestSendTestCommandToUnsupportedEndpoint_146() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 200; using RequestType = chip::app::Clusters::TestCluster::Commands::Test::Type; @@ -61061,27 +61233,27 @@ class TestCluster : public TestCommand RequestType request; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_144(); + (static_cast(context))->OnSuccessResponse_146(); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_144(error); + (static_cast(context))->OnFailureResponse_146(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_144(CHIP_ERROR error) + void OnFailureResponse_146(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_UNSUPPORTED_ENDPOINT)); NextTest(); } - void OnSuccessResponse_144() { ThrowSuccessResponse(); } + void OnSuccessResponse_146() { ThrowSuccessResponse(); } - CHIP_ERROR TestSendTestCommandToUnsupportedCluster_145() + CHIP_ERROR TestSendTestCommandToUnsupportedCluster_147() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 0; using RequestType = chip::app::Clusters::TestCluster::Commands::Test::Type; @@ -61089,51 +61261,51 @@ class TestCluster : public TestCommand RequestType request; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_145(); + (static_cast(context))->OnSuccessResponse_147(); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_145(error); + (static_cast(context))->OnFailureResponse_147(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_145(CHIP_ERROR error) + void OnFailureResponse_147(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER)); NextTest(); } - void OnSuccessResponse_145() { ThrowSuccessResponse(); } + void OnSuccessResponse_147() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeVendorIdDefaultValue_146() + CHIP_ERROR TestReadAttributeVendorIdDefaultValue_148() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_146, OnFailureCallback_146)); + this, OnSuccessCallback_148, OnFailureCallback_148)); return CHIP_NO_ERROR; } - void OnFailureResponse_146(CHIP_ERROR error) + void OnFailureResponse_148(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_146(chip::VendorId vendorId) + void OnSuccessResponse_148(chip::VendorId vendorId) { VerifyOrReturn(CheckValue("vendorId", vendorId, 0U)); NextTest(); } - CHIP_ERROR TestWriteAttributeVendorId_147() + CHIP_ERROR TestWriteAttributeVendorId_149() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -61143,43 +61315,43 @@ class TestCluster : public TestCommand vendorIdArgument = static_cast(17); ReturnErrorOnFailure(cluster.WriteAttribute( - vendorIdArgument, this, OnSuccessCallback_147, OnFailureCallback_147)); + vendorIdArgument, this, OnSuccessCallback_149, OnFailureCallback_149)); return CHIP_NO_ERROR; } - void OnFailureResponse_147(CHIP_ERROR error) + void OnFailureResponse_149(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_147() { NextTest(); } + void OnSuccessResponse_149() { NextTest(); } - CHIP_ERROR TestReadAttributeVendorId_148() + CHIP_ERROR TestReadAttributeVendorId_150() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_148, OnFailureCallback_148)); + this, OnSuccessCallback_150, OnFailureCallback_150)); return CHIP_NO_ERROR; } - void OnFailureResponse_148(CHIP_ERROR error) + void OnFailureResponse_150(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_148(chip::VendorId vendorId) + void OnSuccessResponse_150(chip::VendorId vendorId) { VerifyOrReturn(CheckValue("vendorId", vendorId, 17U)); NextTest(); } - CHIP_ERROR TestRestoreAttributeVendorId_149() + CHIP_ERROR TestRestoreAttributeVendorId_151() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -61189,19 +61361,19 @@ class TestCluster : public TestCommand vendorIdArgument = static_cast(0); ReturnErrorOnFailure(cluster.WriteAttribute( - vendorIdArgument, this, OnSuccessCallback_149, OnFailureCallback_149)); + vendorIdArgument, this, OnSuccessCallback_151, OnFailureCallback_151)); return CHIP_NO_ERROR; } - void OnFailureResponse_149(CHIP_ERROR error) + void OnFailureResponse_151(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_149() { NextTest(); } + void OnSuccessResponse_151() { NextTest(); } - CHIP_ERROR TestSendACommandWithAVendorIdAndEnum_150() + CHIP_ERROR TestSendACommandWithAVendorIdAndEnum_152() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestEnumsRequest::Type; @@ -61211,24 +61383,24 @@ class TestCluster : public TestCommand request.arg2 = static_cast(101); auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_150(data.arg1, data.arg2); + (static_cast(context))->OnSuccessResponse_152(data.arg1, data.arg2); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_150(error); + (static_cast(context))->OnFailureResponse_152(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_150(CHIP_ERROR error) + void OnFailureResponse_152(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_150(chip::VendorId arg1, chip::app::Clusters::TestCluster::SimpleEnum arg2) + void OnSuccessResponse_152(chip::VendorId arg1, chip::app::Clusters::TestCluster::SimpleEnum arg2) { VerifyOrReturn(CheckValue("arg1", arg1, 20003U)); @@ -61237,7 +61409,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestSendTestCommandWithStructArgumentAndArg1bIsTrue_151() + CHIP_ERROR TestSendTestCommandWithStructArgumentAndArg1bIsTrue_153() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestStructArgumentRequest::Type; @@ -61254,31 +61426,31 @@ class TestCluster : public TestCommand request.arg1.h = 0; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_151(data.value); + (static_cast(context))->OnSuccessResponse_153(data.value); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_151(error); + (static_cast(context))->OnFailureResponse_153(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_151(CHIP_ERROR error) + void OnFailureResponse_153(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_151(bool value) + void OnSuccessResponse_153(bool value) { VerifyOrReturn(CheckValue("value", value, true)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithStructArgumentAndArg1bIsFalse_152() + CHIP_ERROR TestSendTestCommandWithStructArgumentAndArg1bIsFalse_154() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestStructArgumentRequest::Type; @@ -61295,31 +61467,31 @@ class TestCluster : public TestCommand request.arg1.h = 0; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_152(data.value); + (static_cast(context))->OnSuccessResponse_154(data.value); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_152(error); + (static_cast(context))->OnFailureResponse_154(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_152(CHIP_ERROR error) + void OnFailureResponse_154(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_152(bool value) + void OnSuccessResponse_154(bool value) { VerifyOrReturn(CheckValue("value", value, false)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithNestedStructArgumentAndArg1cbIsTrue_153() + CHIP_ERROR TestSendTestCommandWithNestedStructArgumentAndArg1cbIsTrue_155() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestNestedStructArgumentRequest::Type; @@ -61339,31 +61511,31 @@ class TestCluster : public TestCommand request.arg1.c.h = 0; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_153(data.value); + (static_cast(context))->OnSuccessResponse_155(data.value); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_153(error); + (static_cast(context))->OnFailureResponse_155(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_153(CHIP_ERROR error) + void OnFailureResponse_155(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_153(bool value) + void OnSuccessResponse_155(bool value) { VerifyOrReturn(CheckValue("value", value, true)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithNestedStructArgumentArg1cbIsFalse_154() + CHIP_ERROR TestSendTestCommandWithNestedStructArgumentArg1cbIsFalse_156() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestNestedStructArgumentRequest::Type; @@ -61383,31 +61555,31 @@ class TestCluster : public TestCommand request.arg1.c.h = 0; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_154(data.value); + (static_cast(context))->OnSuccessResponse_156(data.value); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_154(error); + (static_cast(context))->OnFailureResponse_156(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_154(CHIP_ERROR error) + void OnFailureResponse_156(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_154(bool value) + void OnSuccessResponse_156(bool value) { VerifyOrReturn(CheckValue("value", value, false)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithNestedStructListArgumentAndAllFieldsBOfArg1dAreTrue_155() + CHIP_ERROR TestSendTestCommandWithNestedStructListArgumentAndAllFieldsBOfArg1dAreTrue_157() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestNestedStructListArgumentRequest::Type; @@ -61466,31 +61638,31 @@ class TestCluster : public TestCommand request.arg1.g = gList_1; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_155(data.value); + (static_cast(context))->OnSuccessResponse_157(data.value); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_155(error); + (static_cast(context))->OnFailureResponse_157(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_155(CHIP_ERROR error) + void OnFailureResponse_157(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_155(bool value) + void OnSuccessResponse_157(bool value) { VerifyOrReturn(CheckValue("value", value, true)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfArg1dAreFalse_156() + CHIP_ERROR TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfArg1dAreFalse_158() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestNestedStructListArgumentRequest::Type; @@ -61549,31 +61721,31 @@ class TestCluster : public TestCommand request.arg1.g = gList_1; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_156(data.value); + (static_cast(context))->OnSuccessResponse_158(data.value); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_156(error); + (static_cast(context))->OnFailureResponse_158(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_156(CHIP_ERROR error) + void OnFailureResponse_158(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_156(bool value) + void OnSuccessResponse_158(bool value) { VerifyOrReturn(CheckValue("value", value, false)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithStructArgumentAndSeeWhatWeGetBack_157() + CHIP_ERROR TestSendTestCommandWithStructArgumentAndSeeWhatWeGetBack_159() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::SimpleStructEchoRequest::Type; @@ -61590,24 +61762,24 @@ class TestCluster : public TestCommand request.arg1.h = 0.1; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_157(data.arg1); + (static_cast(context))->OnSuccessResponse_159(data.arg1); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_157(error); + (static_cast(context))->OnFailureResponse_159(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_157(CHIP_ERROR error) + void OnFailureResponse_159(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_157(const chip::app::Clusters::TestCluster::Structs::SimpleStruct::DecodableType & arg1) + void OnSuccessResponse_159(const chip::app::Clusters::TestCluster::Structs::SimpleStruct::DecodableType & arg1) { VerifyOrReturn(CheckValue("arg1.a", arg1.a, 17)); VerifyOrReturn(CheckValue("arg1.b", arg1.b, false)); @@ -61621,7 +61793,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestSendTestCommandWithListOfInt8uAndNoneOfThemIsSetTo0_158() + CHIP_ERROR TestSendTestCommandWithListOfInt8uAndNoneOfThemIsSetTo0_160() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListInt8UArgumentRequest::Type; @@ -61641,31 +61813,31 @@ class TestCluster : public TestCommand request.arg1 = arg1List_0; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_158(data.value); + (static_cast(context))->OnSuccessResponse_160(data.value); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_158(error); + (static_cast(context))->OnFailureResponse_160(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_158(CHIP_ERROR error) + void OnFailureResponse_160(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_158(bool value) + void OnSuccessResponse_160(bool value) { VerifyOrReturn(CheckValue("value", value, true)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithListOfInt8uAndOneOfThemIsSetTo0_159() + CHIP_ERROR TestSendTestCommandWithListOfInt8uAndOneOfThemIsSetTo0_161() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListInt8UArgumentRequest::Type; @@ -61686,31 +61858,31 @@ class TestCluster : public TestCommand request.arg1 = arg1List_0; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_159(data.value); + (static_cast(context))->OnSuccessResponse_161(data.value); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_159(error); + (static_cast(context))->OnFailureResponse_161(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_159(CHIP_ERROR error) + void OnFailureResponse_161(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_159(bool value) + void OnSuccessResponse_161(bool value) { VerifyOrReturn(CheckValue("value", value, false)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithListOfInt8uAndGetItReversed_160() + CHIP_ERROR TestSendTestCommandWithListOfInt8uAndGetItReversed_162() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListInt8UReverseRequest::Type; @@ -61730,24 +61902,24 @@ class TestCluster : public TestCommand request.arg1 = arg1List_0; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_160(data.arg1); + (static_cast(context))->OnSuccessResponse_162(data.arg1); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_160(error); + (static_cast(context))->OnFailureResponse_162(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_160(CHIP_ERROR error) + void OnFailureResponse_162(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_160(const chip::app::DataModel::DecodableList & arg1) + void OnSuccessResponse_162(const chip::app::DataModel::DecodableList & arg1) { { auto iter_0 = arg1.begin(); @@ -61775,7 +61947,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestSendTestCommandWithEmptyListOfInt8uAndGetAnEmptyListBack_161() + CHIP_ERROR TestSendTestCommandWithEmptyListOfInt8uAndGetAnEmptyListBack_163() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListInt8UReverseRequest::Type; @@ -61785,24 +61957,24 @@ class TestCluster : public TestCommand request.arg1 = chip::app::DataModel::List(); auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_161(data.arg1); + (static_cast(context))->OnSuccessResponse_163(data.arg1); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_161(error); + (static_cast(context))->OnFailureResponse_163(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_161(CHIP_ERROR error) + void OnFailureResponse_163(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_161(const chip::app::DataModel::DecodableList & arg1) + void OnSuccessResponse_163(const chip::app::DataModel::DecodableList & arg1) { { auto iter_0 = arg1.begin(); @@ -61812,7 +61984,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsTrue_162() + CHIP_ERROR TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsTrue_164() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListStructArgumentRequest::Type; @@ -61842,31 +62014,31 @@ class TestCluster : public TestCommand request.arg1 = arg1List_0; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_162(data.value); + (static_cast(context))->OnSuccessResponse_164(data.value); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_162(error); + (static_cast(context))->OnFailureResponse_164(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_162(CHIP_ERROR error) + void OnFailureResponse_164(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_162(bool value) + void OnSuccessResponse_164(bool value) { VerifyOrReturn(CheckValue("value", value, true)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsFalse_163() + CHIP_ERROR TestSendTestCommandWithListOfStructArgumentAndArg1bOfFirstItemIsFalse_165() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListStructArgumentRequest::Type; @@ -61896,31 +62068,31 @@ class TestCluster : public TestCommand request.arg1 = arg1List_0; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_163(data.value); + (static_cast(context))->OnSuccessResponse_165(data.value); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_163(error); + (static_cast(context))->OnFailureResponse_165(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_163(CHIP_ERROR error) + void OnFailureResponse_165(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_163(bool value) + void OnSuccessResponse_165(bool value) { VerifyOrReturn(CheckValue("value", value, false)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithListOfNestedStructListArgumentAndAllFieldsBOfElementsOfArg1dAreTrue_164() + CHIP_ERROR TestSendTestCommandWithListOfNestedStructListArgumentAndAllFieldsBOfElementsOfArg1dAreTrue_166() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListNestedStructListArgumentRequest::Type; @@ -61983,31 +62155,31 @@ class TestCluster : public TestCommand request.arg1 = arg1List_0; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_164(data.value); + (static_cast(context))->OnSuccessResponse_166(data.value); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_164(error); + (static_cast(context))->OnFailureResponse_166(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_164(CHIP_ERROR error) + void OnFailureResponse_166(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_164(bool value) + void OnSuccessResponse_166(bool value) { VerifyOrReturn(CheckValue("value", value, true)); NextTest(); } - CHIP_ERROR TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfElementsOfArg1dAreFalse_165() + CHIP_ERROR TestSendTestCommandWithNestedStructListArgumentAndSomeFieldsBOfElementsOfArg1dAreFalse_167() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestListNestedStructListArgumentRequest::Type; @@ -62070,31 +62242,31 @@ class TestCluster : public TestCommand request.arg1 = arg1List_0; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_165(data.value); + (static_cast(context))->OnSuccessResponse_167(data.value); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_165(error); + (static_cast(context))->OnFailureResponse_167(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_165(CHIP_ERROR error) + void OnFailureResponse_167(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_165(bool value) + void OnSuccessResponse_167(bool value) { VerifyOrReturn(CheckValue("value", value, false)); NextTest(); } - CHIP_ERROR TestWriteAttributeListWithListOfInt8uAndNoneOfThemIsSetTo0_166() + CHIP_ERROR TestWriteAttributeListWithListOfInt8uAndNoneOfThemIsSetTo0_168() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -62110,36 +62282,36 @@ class TestCluster : public TestCommand listInt8uArgument = listInt8uList_0; ReturnErrorOnFailure(cluster.WriteAttribute( - listInt8uArgument, this, OnSuccessCallback_166, OnFailureCallback_166)); + listInt8uArgument, this, OnSuccessCallback_168, OnFailureCallback_168)); return CHIP_NO_ERROR; } - void OnFailureResponse_166(CHIP_ERROR error) + void OnFailureResponse_168(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_166() { NextTest(); } + void OnSuccessResponse_168() { NextTest(); } - CHIP_ERROR TestReadAttributeListWithListOfInt8u_167() + CHIP_ERROR TestReadAttributeListWithListOfInt8u_169() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_167, OnFailureCallback_167)); + this, OnSuccessCallback_169, OnFailureCallback_169)); return CHIP_NO_ERROR; } - void OnFailureResponse_167(CHIP_ERROR error) + void OnFailureResponse_169(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_167(const chip::app::DataModel::DecodableList & listInt8u) + void OnSuccessResponse_169(const chip::app::DataModel::DecodableList & listInt8u) { { auto iter_0 = listInt8u.begin(); @@ -62157,7 +62329,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeListWithListOfOctetString_168() + CHIP_ERROR TestWriteAttributeListWithListOfOctetString_170() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -62173,36 +62345,36 @@ class TestCluster : public TestCommand listOctetStringArgument = listOctetStringList_0; ReturnErrorOnFailure(cluster.WriteAttribute( - listOctetStringArgument, this, OnSuccessCallback_168, OnFailureCallback_168)); + listOctetStringArgument, this, OnSuccessCallback_170, OnFailureCallback_170)); return CHIP_NO_ERROR; } - void OnFailureResponse_168(CHIP_ERROR error) + void OnFailureResponse_170(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_168() { NextTest(); } + void OnSuccessResponse_170() { NextTest(); } - CHIP_ERROR TestReadAttributeListWithListOfOctetString_169() + CHIP_ERROR TestReadAttributeListWithListOfOctetString_171() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_169, OnFailureCallback_169)); + this, OnSuccessCallback_171, OnFailureCallback_171)); return CHIP_NO_ERROR; } - void OnFailureResponse_169(CHIP_ERROR error) + void OnFailureResponse_171(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_169(const chip::app::DataModel::DecodableList & listOctetString) + void OnSuccessResponse_171(const chip::app::DataModel::DecodableList & listOctetString) { { auto iter_0 = listOctetString.begin(); @@ -62224,7 +62396,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeListWithListOfListStructOctetString_170() + CHIP_ERROR TestWriteAttributeListWithListOfListStructOctetString_172() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -62254,36 +62426,36 @@ class TestCluster : public TestCommand listStructOctetStringArgument = listStructOctetStringList_0; ReturnErrorOnFailure(cluster.WriteAttribute( - listStructOctetStringArgument, this, OnSuccessCallback_170, OnFailureCallback_170)); + listStructOctetStringArgument, this, OnSuccessCallback_172, OnFailureCallback_172)); return CHIP_NO_ERROR; } - void OnFailureResponse_170(CHIP_ERROR error) + void OnFailureResponse_172(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_170() { NextTest(); } + void OnSuccessResponse_172() { NextTest(); } - CHIP_ERROR TestReadAttributeListWithListOfListStructOctetString_171() + CHIP_ERROR TestReadAttributeListWithListOfListStructOctetString_173() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_171, OnFailureCallback_171)); + this, OnSuccessCallback_173, OnFailureCallback_173)); return CHIP_NO_ERROR; } - void OnFailureResponse_171(CHIP_ERROR error) + void OnFailureResponse_173(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_171( + void OnSuccessResponse_173( const chip::app::DataModel::DecodableList & listStructOctetString) { @@ -62311,7 +62483,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestSendTestCommandWithOptionalArgSet_172() + CHIP_ERROR TestSendTestCommandWithOptionalArgSet_174() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestNullableOptionalRequest::Type; @@ -62323,24 +62495,24 @@ class TestCluster : public TestCommand auto success = [](void * context, const typename RequestType::ResponseType & data) { (static_cast(context)) - ->OnSuccessResponse_172(data.wasPresent, data.wasNull, data.value, data.originalValue); + ->OnSuccessResponse_174(data.wasPresent, data.wasNull, data.value, data.originalValue); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_172(error); + (static_cast(context))->OnFailureResponse_174(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_172(CHIP_ERROR error) + void OnFailureResponse_174(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_172(bool wasPresent, const chip::Optional & wasNull, const chip::Optional & value, + void OnSuccessResponse_174(bool wasPresent, const chip::Optional & wasNull, const chip::Optional & value, const chip::Optional> & originalValue) { VerifyOrReturn(CheckValue("wasPresent", wasPresent, true)); @@ -62358,7 +62530,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestSendTestCommandWithoutItsOptionalArg_173() + CHIP_ERROR TestSendTestCommandWithoutItsOptionalArg_175() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestNullableOptionalRequest::Type; @@ -62367,24 +62539,24 @@ class TestCluster : public TestCommand auto success = [](void * context, const typename RequestType::ResponseType & data) { (static_cast(context)) - ->OnSuccessResponse_173(data.wasPresent, data.wasNull, data.value, data.originalValue); + ->OnSuccessResponse_175(data.wasPresent, data.wasNull, data.value, data.originalValue); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_173(error); + (static_cast(context))->OnFailureResponse_175(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_173(CHIP_ERROR error) + void OnFailureResponse_175(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_173(bool wasPresent, const chip::Optional & wasNull, const chip::Optional & value, + void OnSuccessResponse_175(bool wasPresent, const chip::Optional & wasNull, const chip::Optional & value, const chip::Optional> & originalValue) { VerifyOrReturn(CheckValue("wasPresent", wasPresent, false)); @@ -62392,7 +62564,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadListOfStructsContainingNullablesAndOptionals_174() + CHIP_ERROR TestReadListOfStructsContainingNullablesAndOptionals_176() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -62400,17 +62572,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_174, OnFailureCallback_174)); + this, OnSuccessCallback_176, OnFailureCallback_176)); return CHIP_NO_ERROR; } - void OnFailureResponse_174(CHIP_ERROR error) + void OnFailureResponse_176(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_174(const chip::app::DataModel::DecodableList< + void OnSuccessResponse_176(const chip::app::DataModel::DecodableList< chip::app::Clusters::TestCluster::Structs::NullablesAndOptionalsStruct::DecodableType> & listNullablesAndOptionalsStruct) { @@ -62429,7 +62601,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteListOfStructsContainingNullablesAndOptionals_175() + CHIP_ERROR TestWriteListOfStructsContainingNullablesAndOptionals_177() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -62454,19 +62626,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - listNullablesAndOptionalsStructArgument, this, OnSuccessCallback_175, OnFailureCallback_175)); + listNullablesAndOptionalsStructArgument, this, OnSuccessCallback_177, OnFailureCallback_177)); return CHIP_NO_ERROR; } - void OnFailureResponse_175(CHIP_ERROR error) + void OnFailureResponse_177(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_175() { NextTest(); } + void OnSuccessResponse_177() { NextTest(); } - CHIP_ERROR TestReadListOfStructsContainingNullablesAndOptionalsAfterWriting_176() + CHIP_ERROR TestReadListOfStructsContainingNullablesAndOptionalsAfterWriting_178() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -62474,17 +62646,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_176, OnFailureCallback_176)); + this, OnSuccessCallback_178, OnFailureCallback_178)); return CHIP_NO_ERROR; } - void OnFailureResponse_176(CHIP_ERROR error) + void OnFailureResponse_178(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_176(const chip::app::DataModel::DecodableList< + void OnSuccessResponse_178(const chip::app::DataModel::DecodableList< chip::app::Clusters::TestCluster::Structs::NullablesAndOptionalsStruct::DecodableType> & listNullablesAndOptionalsStruct) { @@ -62514,7 +62686,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBooleanNull_177() + CHIP_ERROR TestWriteAttributeNullableBooleanNull_179() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -62524,43 +62696,43 @@ class TestCluster : public TestCommand nullableBooleanArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableBooleanArgument, this, OnSuccessCallback_177, OnFailureCallback_177)); + nullableBooleanArgument, this, OnSuccessCallback_179, OnFailureCallback_179)); return CHIP_NO_ERROR; } - void OnFailureResponse_177(CHIP_ERROR error) + void OnFailureResponse_179(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_177() { NextTest(); } + void OnSuccessResponse_179() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBooleanNull_178() + CHIP_ERROR TestReadAttributeNullableBooleanNull_180() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_178, OnFailureCallback_178)); + this, OnSuccessCallback_180, OnFailureCallback_180)); return CHIP_NO_ERROR; } - void OnFailureResponse_178(CHIP_ERROR error) + void OnFailureResponse_180(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_178(const chip::app::DataModel::Nullable & nullableBoolean) + void OnSuccessResponse_180(const chip::app::DataModel::Nullable & nullableBoolean) { VerifyOrReturn(CheckValueNull("nullableBoolean", nullableBoolean)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBooleanTrue_179() + CHIP_ERROR TestWriteAttributeNullableBooleanTrue_181() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -62571,36 +62743,36 @@ class TestCluster : public TestCommand nullableBooleanArgument.Value() = true; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableBooleanArgument, this, OnSuccessCallback_179, OnFailureCallback_179)); + nullableBooleanArgument, this, OnSuccessCallback_181, OnFailureCallback_181)); return CHIP_NO_ERROR; } - void OnFailureResponse_179(CHIP_ERROR error) + void OnFailureResponse_181(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_179() { NextTest(); } + void OnSuccessResponse_181() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBooleanTrue_180() + CHIP_ERROR TestReadAttributeNullableBooleanTrue_182() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_180, OnFailureCallback_180)); + this, OnSuccessCallback_182, OnFailureCallback_182)); return CHIP_NO_ERROR; } - void OnFailureResponse_180(CHIP_ERROR error) + void OnFailureResponse_182(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_180(const chip::app::DataModel::Nullable & nullableBoolean) + void OnSuccessResponse_182(const chip::app::DataModel::Nullable & nullableBoolean) { VerifyOrReturn(CheckValueNonNull("nullableBoolean", nullableBoolean)); VerifyOrReturn(CheckValue("nullableBoolean.Value()", nullableBoolean.Value(), true)); @@ -62608,7 +62780,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap8MaxValue_181() + CHIP_ERROR TestWriteAttributeNullableBitmap8MaxValue_183() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -62619,36 +62791,36 @@ class TestCluster : public TestCommand nullableBitmap8Argument.Value() = 254; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableBitmap8Argument, this, OnSuccessCallback_181, OnFailureCallback_181)); + nullableBitmap8Argument, this, OnSuccessCallback_183, OnFailureCallback_183)); return CHIP_NO_ERROR; } - void OnFailureResponse_181(CHIP_ERROR error) + void OnFailureResponse_183(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_181() { NextTest(); } + void OnSuccessResponse_183() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap8MaxValue_182() + CHIP_ERROR TestReadAttributeNullableBitmap8MaxValue_184() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_182, OnFailureCallback_182)); + this, OnSuccessCallback_184, OnFailureCallback_184)); return CHIP_NO_ERROR; } - void OnFailureResponse_182(CHIP_ERROR error) + void OnFailureResponse_184(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_182(const chip::app::DataModel::Nullable & nullableBitmap8) + void OnSuccessResponse_184(const chip::app::DataModel::Nullable & nullableBitmap8) { VerifyOrReturn(CheckValueNonNull("nullableBitmap8", nullableBitmap8)); VerifyOrReturn(CheckValue("nullableBitmap8.Value()", nullableBitmap8.Value(), 254)); @@ -62656,7 +62828,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap8InvalidValue_183() + CHIP_ERROR TestWriteAttributeNullableBitmap8InvalidValue_185() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -62667,37 +62839,37 @@ class TestCluster : public TestCommand nullableBitmap8Argument.Value() = 255; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableBitmap8Argument, this, OnSuccessCallback_183, OnFailureCallback_183)); + nullableBitmap8Argument, this, OnSuccessCallback_185, OnFailureCallback_185)); return CHIP_NO_ERROR; } - void OnFailureResponse_183(CHIP_ERROR error) + void OnFailureResponse_185(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_183() { ThrowSuccessResponse(); } + void OnSuccessResponse_185() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableBitmap8UnchangedValue_184() + CHIP_ERROR TestReadAttributeNullableBitmap8UnchangedValue_186() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_184, OnFailureCallback_184)); + this, OnSuccessCallback_186, OnFailureCallback_186)); return CHIP_NO_ERROR; } - void OnFailureResponse_184(CHIP_ERROR error) + void OnFailureResponse_186(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_184(const chip::app::DataModel::Nullable & nullableBitmap8) + void OnSuccessResponse_186(const chip::app::DataModel::Nullable & nullableBitmap8) { VerifyOrReturn(CheckValueNonNull("nullableBitmap8", nullableBitmap8)); VerifyOrReturn(CheckValue("nullableBitmap8.Value()", nullableBitmap8.Value(), 254)); @@ -62705,7 +62877,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap8NullValue_185() + CHIP_ERROR TestWriteAttributeNullableBitmap8NullValue_187() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -62715,43 +62887,43 @@ class TestCluster : public TestCommand nullableBitmap8Argument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableBitmap8Argument, this, OnSuccessCallback_185, OnFailureCallback_185)); + nullableBitmap8Argument, this, OnSuccessCallback_187, OnFailureCallback_187)); return CHIP_NO_ERROR; } - void OnFailureResponse_185(CHIP_ERROR error) + void OnFailureResponse_187(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_185() { NextTest(); } + void OnSuccessResponse_187() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap8NullValue_186() + CHIP_ERROR TestReadAttributeNullableBitmap8NullValue_188() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_186, OnFailureCallback_186)); + this, OnSuccessCallback_188, OnFailureCallback_188)); return CHIP_NO_ERROR; } - void OnFailureResponse_186(CHIP_ERROR error) + void OnFailureResponse_188(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_186(const chip::app::DataModel::Nullable & nullableBitmap8) + void OnSuccessResponse_188(const chip::app::DataModel::Nullable & nullableBitmap8) { VerifyOrReturn(CheckValueNull("nullableBitmap8", nullableBitmap8)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap16MaxValue_187() + CHIP_ERROR TestWriteAttributeNullableBitmap16MaxValue_189() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -62762,36 +62934,36 @@ class TestCluster : public TestCommand nullableBitmap16Argument.Value() = 65534U; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableBitmap16Argument, this, OnSuccessCallback_187, OnFailureCallback_187)); + nullableBitmap16Argument, this, OnSuccessCallback_189, OnFailureCallback_189)); return CHIP_NO_ERROR; } - void OnFailureResponse_187(CHIP_ERROR error) + void OnFailureResponse_189(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_187() { NextTest(); } + void OnSuccessResponse_189() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap16MaxValue_188() + CHIP_ERROR TestReadAttributeNullableBitmap16MaxValue_190() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_188, OnFailureCallback_188)); + this, OnSuccessCallback_190, OnFailureCallback_190)); return CHIP_NO_ERROR; } - void OnFailureResponse_188(CHIP_ERROR error) + void OnFailureResponse_190(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_188(const chip::app::DataModel::Nullable & nullableBitmap16) + void OnSuccessResponse_190(const chip::app::DataModel::Nullable & nullableBitmap16) { VerifyOrReturn(CheckValueNonNull("nullableBitmap16", nullableBitmap16)); VerifyOrReturn(CheckValue("nullableBitmap16.Value()", nullableBitmap16.Value(), 65534U)); @@ -62799,7 +62971,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap16InvalidValue_189() + CHIP_ERROR TestWriteAttributeNullableBitmap16InvalidValue_191() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -62810,37 +62982,37 @@ class TestCluster : public TestCommand nullableBitmap16Argument.Value() = 65535U; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableBitmap16Argument, this, OnSuccessCallback_189, OnFailureCallback_189)); + nullableBitmap16Argument, this, OnSuccessCallback_191, OnFailureCallback_191)); return CHIP_NO_ERROR; } - void OnFailureResponse_189(CHIP_ERROR error) + void OnFailureResponse_191(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_189() { ThrowSuccessResponse(); } + void OnSuccessResponse_191() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableBitmap16UnchangedValue_190() + CHIP_ERROR TestReadAttributeNullableBitmap16UnchangedValue_192() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_190, OnFailureCallback_190)); + this, OnSuccessCallback_192, OnFailureCallback_192)); return CHIP_NO_ERROR; } - void OnFailureResponse_190(CHIP_ERROR error) + void OnFailureResponse_192(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_190(const chip::app::DataModel::Nullable & nullableBitmap16) + void OnSuccessResponse_192(const chip::app::DataModel::Nullable & nullableBitmap16) { VerifyOrReturn(CheckValueNonNull("nullableBitmap16", nullableBitmap16)); VerifyOrReturn(CheckValue("nullableBitmap16.Value()", nullableBitmap16.Value(), 65534U)); @@ -62848,7 +63020,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap16NullValue_191() + CHIP_ERROR TestWriteAttributeNullableBitmap16NullValue_193() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -62858,43 +63030,43 @@ class TestCluster : public TestCommand nullableBitmap16Argument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableBitmap16Argument, this, OnSuccessCallback_191, OnFailureCallback_191)); + nullableBitmap16Argument, this, OnSuccessCallback_193, OnFailureCallback_193)); return CHIP_NO_ERROR; } - void OnFailureResponse_191(CHIP_ERROR error) + void OnFailureResponse_193(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_191() { NextTest(); } + void OnSuccessResponse_193() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap16NullValue_192() + CHIP_ERROR TestReadAttributeNullableBitmap16NullValue_194() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_192, OnFailureCallback_192)); + this, OnSuccessCallback_194, OnFailureCallback_194)); return CHIP_NO_ERROR; } - void OnFailureResponse_192(CHIP_ERROR error) + void OnFailureResponse_194(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_192(const chip::app::DataModel::Nullable & nullableBitmap16) + void OnSuccessResponse_194(const chip::app::DataModel::Nullable & nullableBitmap16) { VerifyOrReturn(CheckValueNull("nullableBitmap16", nullableBitmap16)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap32MaxValue_193() + CHIP_ERROR TestWriteAttributeNullableBitmap32MaxValue_195() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -62905,36 +63077,36 @@ class TestCluster : public TestCommand nullableBitmap32Argument.Value() = 4294967294UL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableBitmap32Argument, this, OnSuccessCallback_193, OnFailureCallback_193)); + nullableBitmap32Argument, this, OnSuccessCallback_195, OnFailureCallback_195)); return CHIP_NO_ERROR; } - void OnFailureResponse_193(CHIP_ERROR error) + void OnFailureResponse_195(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_193() { NextTest(); } + void OnSuccessResponse_195() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap32MaxValue_194() + CHIP_ERROR TestReadAttributeNullableBitmap32MaxValue_196() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_194, OnFailureCallback_194)); + this, OnSuccessCallback_196, OnFailureCallback_196)); return CHIP_NO_ERROR; } - void OnFailureResponse_194(CHIP_ERROR error) + void OnFailureResponse_196(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_194(const chip::app::DataModel::Nullable & nullableBitmap32) + void OnSuccessResponse_196(const chip::app::DataModel::Nullable & nullableBitmap32) { VerifyOrReturn(CheckValueNonNull("nullableBitmap32", nullableBitmap32)); VerifyOrReturn(CheckValue("nullableBitmap32.Value()", nullableBitmap32.Value(), 4294967294UL)); @@ -62942,7 +63114,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap32InvalidValue_195() + CHIP_ERROR TestWriteAttributeNullableBitmap32InvalidValue_197() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -62953,37 +63125,37 @@ class TestCluster : public TestCommand nullableBitmap32Argument.Value() = 4294967295UL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableBitmap32Argument, this, OnSuccessCallback_195, OnFailureCallback_195)); + nullableBitmap32Argument, this, OnSuccessCallback_197, OnFailureCallback_197)); return CHIP_NO_ERROR; } - void OnFailureResponse_195(CHIP_ERROR error) + void OnFailureResponse_197(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_195() { ThrowSuccessResponse(); } + void OnSuccessResponse_197() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableBitmap32UnchangedValue_196() + CHIP_ERROR TestReadAttributeNullableBitmap32UnchangedValue_198() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_196, OnFailureCallback_196)); + this, OnSuccessCallback_198, OnFailureCallback_198)); return CHIP_NO_ERROR; } - void OnFailureResponse_196(CHIP_ERROR error) + void OnFailureResponse_198(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_196(const chip::app::DataModel::Nullable & nullableBitmap32) + void OnSuccessResponse_198(const chip::app::DataModel::Nullable & nullableBitmap32) { VerifyOrReturn(CheckValueNonNull("nullableBitmap32", nullableBitmap32)); VerifyOrReturn(CheckValue("nullableBitmap32.Value()", nullableBitmap32.Value(), 4294967294UL)); @@ -62991,7 +63163,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap32NullValue_197() + CHIP_ERROR TestWriteAttributeNullableBitmap32NullValue_199() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -63001,43 +63173,43 @@ class TestCluster : public TestCommand nullableBitmap32Argument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableBitmap32Argument, this, OnSuccessCallback_197, OnFailureCallback_197)); + nullableBitmap32Argument, this, OnSuccessCallback_199, OnFailureCallback_199)); return CHIP_NO_ERROR; } - void OnFailureResponse_197(CHIP_ERROR error) + void OnFailureResponse_199(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_197() { NextTest(); } + void OnSuccessResponse_199() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap32NullValue_198() + CHIP_ERROR TestReadAttributeNullableBitmap32NullValue_200() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_198, OnFailureCallback_198)); + this, OnSuccessCallback_200, OnFailureCallback_200)); return CHIP_NO_ERROR; } - void OnFailureResponse_198(CHIP_ERROR error) + void OnFailureResponse_200(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_198(const chip::app::DataModel::Nullable & nullableBitmap32) + void OnSuccessResponse_200(const chip::app::DataModel::Nullable & nullableBitmap32) { VerifyOrReturn(CheckValueNull("nullableBitmap32", nullableBitmap32)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap64MaxValue_199() + CHIP_ERROR TestWriteAttributeNullableBitmap64MaxValue_201() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -63048,36 +63220,36 @@ class TestCluster : public TestCommand nullableBitmap64Argument.Value() = 18446744073709551614ULL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableBitmap64Argument, this, OnSuccessCallback_199, OnFailureCallback_199)); + nullableBitmap64Argument, this, OnSuccessCallback_201, OnFailureCallback_201)); return CHIP_NO_ERROR; } - void OnFailureResponse_199(CHIP_ERROR error) + void OnFailureResponse_201(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_199() { NextTest(); } + void OnSuccessResponse_201() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap64MaxValue_200() + CHIP_ERROR TestReadAttributeNullableBitmap64MaxValue_202() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_200, OnFailureCallback_200)); + this, OnSuccessCallback_202, OnFailureCallback_202)); return CHIP_NO_ERROR; } - void OnFailureResponse_200(CHIP_ERROR error) + void OnFailureResponse_202(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_200(const chip::app::DataModel::Nullable & nullableBitmap64) + void OnSuccessResponse_202(const chip::app::DataModel::Nullable & nullableBitmap64) { VerifyOrReturn(CheckValueNonNull("nullableBitmap64", nullableBitmap64)); VerifyOrReturn(CheckValue("nullableBitmap64.Value()", nullableBitmap64.Value(), 18446744073709551614ULL)); @@ -63085,7 +63257,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap64InvalidValue_201() + CHIP_ERROR TestWriteAttributeNullableBitmap64InvalidValue_203() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -63096,37 +63268,37 @@ class TestCluster : public TestCommand nullableBitmap64Argument.Value() = 18446744073709551615ULL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableBitmap64Argument, this, OnSuccessCallback_201, OnFailureCallback_201)); + nullableBitmap64Argument, this, OnSuccessCallback_203, OnFailureCallback_203)); return CHIP_NO_ERROR; } - void OnFailureResponse_201(CHIP_ERROR error) + void OnFailureResponse_203(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_201() { ThrowSuccessResponse(); } + void OnSuccessResponse_203() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableBitmap64UnchangedValue_202() + CHIP_ERROR TestReadAttributeNullableBitmap64UnchangedValue_204() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_202, OnFailureCallback_202)); + this, OnSuccessCallback_204, OnFailureCallback_204)); return CHIP_NO_ERROR; } - void OnFailureResponse_202(CHIP_ERROR error) + void OnFailureResponse_204(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_202(const chip::app::DataModel::Nullable & nullableBitmap64) + void OnSuccessResponse_204(const chip::app::DataModel::Nullable & nullableBitmap64) { VerifyOrReturn(CheckValueNonNull("nullableBitmap64", nullableBitmap64)); VerifyOrReturn(CheckValue("nullableBitmap64.Value()", nullableBitmap64.Value(), 18446744073709551614ULL)); @@ -63134,7 +63306,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableBitmap64NullValue_203() + CHIP_ERROR TestWriteAttributeNullableBitmap64NullValue_205() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -63144,43 +63316,43 @@ class TestCluster : public TestCommand nullableBitmap64Argument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableBitmap64Argument, this, OnSuccessCallback_203, OnFailureCallback_203)); + nullableBitmap64Argument, this, OnSuccessCallback_205, OnFailureCallback_205)); return CHIP_NO_ERROR; } - void OnFailureResponse_203(CHIP_ERROR error) + void OnFailureResponse_205(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_203() { NextTest(); } + void OnSuccessResponse_205() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableBitmap64NullValue_204() + CHIP_ERROR TestReadAttributeNullableBitmap64NullValue_206() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_204, OnFailureCallback_204)); + this, OnSuccessCallback_206, OnFailureCallback_206)); return CHIP_NO_ERROR; } - void OnFailureResponse_204(CHIP_ERROR error) + void OnFailureResponse_206(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_204(const chip::app::DataModel::Nullable & nullableBitmap64) + void OnSuccessResponse_206(const chip::app::DataModel::Nullable & nullableBitmap64) { VerifyOrReturn(CheckValueNull("nullableBitmap64", nullableBitmap64)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8uMinValue_205() + CHIP_ERROR TestWriteAttributeNullableInt8uMinValue_207() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -63191,36 +63363,36 @@ class TestCluster : public TestCommand nullableInt8uArgument.Value() = 0; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt8uArgument, this, OnSuccessCallback_205, OnFailureCallback_205)); + nullableInt8uArgument, this, OnSuccessCallback_207, OnFailureCallback_207)); return CHIP_NO_ERROR; } - void OnFailureResponse_205(CHIP_ERROR error) + void OnFailureResponse_207(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_205() { NextTest(); } + void OnSuccessResponse_207() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8uMinValue_206() + CHIP_ERROR TestReadAttributeNullableInt8uMinValue_208() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_206, OnFailureCallback_206)); + this, OnSuccessCallback_208, OnFailureCallback_208)); return CHIP_NO_ERROR; } - void OnFailureResponse_206(CHIP_ERROR error) + void OnFailureResponse_208(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_206(const chip::app::DataModel::Nullable & nullableInt8u) + void OnSuccessResponse_208(const chip::app::DataModel::Nullable & nullableInt8u) { VerifyOrReturn(CheckValueNonNull("nullableInt8u", nullableInt8u)); VerifyOrReturn(CheckValue("nullableInt8u.Value()", nullableInt8u.Value(), 0)); @@ -63228,7 +63400,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8uMaxValue_207() + CHIP_ERROR TestWriteAttributeNullableInt8uMaxValue_209() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -63239,36 +63411,36 @@ class TestCluster : public TestCommand nullableInt8uArgument.Value() = 254; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt8uArgument, this, OnSuccessCallback_207, OnFailureCallback_207)); + nullableInt8uArgument, this, OnSuccessCallback_209, OnFailureCallback_209)); return CHIP_NO_ERROR; } - void OnFailureResponse_207(CHIP_ERROR error) + void OnFailureResponse_209(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_207() { NextTest(); } + void OnSuccessResponse_209() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8uMaxValue_208() + CHIP_ERROR TestReadAttributeNullableInt8uMaxValue_210() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_208, OnFailureCallback_208)); + this, OnSuccessCallback_210, OnFailureCallback_210)); return CHIP_NO_ERROR; } - void OnFailureResponse_208(CHIP_ERROR error) + void OnFailureResponse_210(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_208(const chip::app::DataModel::Nullable & nullableInt8u) + void OnSuccessResponse_210(const chip::app::DataModel::Nullable & nullableInt8u) { VerifyOrReturn(CheckValueNonNull("nullableInt8u", nullableInt8u)); VerifyOrReturn(CheckValue("nullableInt8u.Value()", nullableInt8u.Value(), 254)); @@ -63276,7 +63448,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8uInvalidValue_209() + CHIP_ERROR TestWriteAttributeNullableInt8uInvalidValue_211() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -63287,37 +63459,37 @@ class TestCluster : public TestCommand nullableInt8uArgument.Value() = 255; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt8uArgument, this, OnSuccessCallback_209, OnFailureCallback_209)); + nullableInt8uArgument, this, OnSuccessCallback_211, OnFailureCallback_211)); return CHIP_NO_ERROR; } - void OnFailureResponse_209(CHIP_ERROR error) + void OnFailureResponse_211(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_209() { ThrowSuccessResponse(); } + void OnSuccessResponse_211() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt8uUnchangedValue_210() + CHIP_ERROR TestReadAttributeNullableInt8uUnchangedValue_212() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_210, OnFailureCallback_210)); + this, OnSuccessCallback_212, OnFailureCallback_212)); return CHIP_NO_ERROR; } - void OnFailureResponse_210(CHIP_ERROR error) + void OnFailureResponse_212(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_210(const chip::app::DataModel::Nullable & nullableInt8u) + void OnSuccessResponse_212(const chip::app::DataModel::Nullable & nullableInt8u) { VerifyOrReturn(CheckValueNonNull("nullableInt8u", nullableInt8u)); VerifyOrReturn(CheckValue("nullableInt8u.Value()", nullableInt8u.Value(), 254)); @@ -63325,31 +63497,31 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8uUnchangedValueWithConstraint_211() + CHIP_ERROR TestReadAttributeNullableInt8uUnchangedValueWithConstraint_213() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_211, OnFailureCallback_211)); + this, OnSuccessCallback_213, OnFailureCallback_213)); return CHIP_NO_ERROR; } - void OnFailureResponse_211(CHIP_ERROR error) + void OnFailureResponse_213(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_211(const chip::app::DataModel::Nullable & nullableInt8u) + void OnSuccessResponse_213(const chip::app::DataModel::Nullable & nullableInt8u) { VerifyOrReturn(CheckValueNonNull("nullableInt8u", nullableInt8u)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8uNullValue_212() + CHIP_ERROR TestWriteAttributeNullableInt8uNullValue_214() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -63359,91 +63531,91 @@ class TestCluster : public TestCommand nullableInt8uArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt8uArgument, this, OnSuccessCallback_212, OnFailureCallback_212)); + nullableInt8uArgument, this, OnSuccessCallback_214, OnFailureCallback_214)); return CHIP_NO_ERROR; } - void OnFailureResponse_212(CHIP_ERROR error) + void OnFailureResponse_214(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_212() { NextTest(); } + void OnSuccessResponse_214() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8uNullValue_213() + CHIP_ERROR TestReadAttributeNullableInt8uNullValue_215() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_213, OnFailureCallback_213)); + this, OnSuccessCallback_215, OnFailureCallback_215)); return CHIP_NO_ERROR; } - void OnFailureResponse_213(CHIP_ERROR error) + void OnFailureResponse_215(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_213(const chip::app::DataModel::Nullable & nullableInt8u) + void OnSuccessResponse_215(const chip::app::DataModel::Nullable & nullableInt8u) { VerifyOrReturn(CheckValueNull("nullableInt8u", nullableInt8u)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8uNullValueRange_214() + CHIP_ERROR TestReadAttributeNullableInt8uNullValueRange_216() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_214, OnFailureCallback_214)); + this, OnSuccessCallback_216, OnFailureCallback_216)); return CHIP_NO_ERROR; } - void OnFailureResponse_214(CHIP_ERROR error) + void OnFailureResponse_216(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_214(const chip::app::DataModel::Nullable & nullableInt8u) + void OnSuccessResponse_216(const chip::app::DataModel::Nullable & nullableInt8u) { VerifyOrReturn(CheckConstraintMinValue("nullableInt8u", nullableInt8u, 0)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt8u", nullableInt8u, 254)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8uNullValueNot_215() + CHIP_ERROR TestReadAttributeNullableInt8uNullValueNot_217() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_215, OnFailureCallback_215)); + this, OnSuccessCallback_217, OnFailureCallback_217)); return CHIP_NO_ERROR; } - void OnFailureResponse_215(CHIP_ERROR error) + void OnFailureResponse_217(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_215(const chip::app::DataModel::Nullable & nullableInt8u) + void OnSuccessResponse_217(const chip::app::DataModel::Nullable & nullableInt8u) { VerifyOrReturn(CheckConstraintNotValue("nullableInt8u", nullableInt8u, 254)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8uValue_216() + CHIP_ERROR TestWriteAttributeNullableInt8uValue_218() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -63454,67 +63626,67 @@ class TestCluster : public TestCommand nullableInt8uArgument.Value() = 128; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt8uArgument, this, OnSuccessCallback_216, OnFailureCallback_216)); + nullableInt8uArgument, this, OnSuccessCallback_218, OnFailureCallback_218)); return CHIP_NO_ERROR; } - void OnFailureResponse_216(CHIP_ERROR error) + void OnFailureResponse_218(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_216() { NextTest(); } + void OnSuccessResponse_218() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8uValueInRange_217() + CHIP_ERROR TestReadAttributeNullableInt8uValueInRange_219() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_217, OnFailureCallback_217)); + this, OnSuccessCallback_219, OnFailureCallback_219)); return CHIP_NO_ERROR; } - void OnFailureResponse_217(CHIP_ERROR error) + void OnFailureResponse_219(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_217(const chip::app::DataModel::Nullable & nullableInt8u) + void OnSuccessResponse_219(const chip::app::DataModel::Nullable & nullableInt8u) { VerifyOrReturn(CheckConstraintMinValue("nullableInt8u", nullableInt8u, 0)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt8u", nullableInt8u, 254)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8uNotValueOk_218() + CHIP_ERROR TestReadAttributeNullableInt8uNotValueOk_220() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_218, OnFailureCallback_218)); + this, OnSuccessCallback_220, OnFailureCallback_220)); return CHIP_NO_ERROR; } - void OnFailureResponse_218(CHIP_ERROR error) + void OnFailureResponse_220(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_218(const chip::app::DataModel::Nullable & nullableInt8u) + void OnSuccessResponse_220(const chip::app::DataModel::Nullable & nullableInt8u) { VerifyOrReturn(CheckConstraintNotValue("nullableInt8u", nullableInt8u, 129)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16uMinValue_219() + CHIP_ERROR TestWriteAttributeNullableInt16uMinValue_221() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -63525,36 +63697,36 @@ class TestCluster : public TestCommand nullableInt16uArgument.Value() = 0U; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16uArgument, this, OnSuccessCallback_219, OnFailureCallback_219)); + nullableInt16uArgument, this, OnSuccessCallback_221, OnFailureCallback_221)); return CHIP_NO_ERROR; } - void OnFailureResponse_219(CHIP_ERROR error) + void OnFailureResponse_221(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_219() { NextTest(); } + void OnSuccessResponse_221() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uMinValue_220() + CHIP_ERROR TestReadAttributeNullableInt16uMinValue_222() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_220, OnFailureCallback_220)); + this, OnSuccessCallback_222, OnFailureCallback_222)); return CHIP_NO_ERROR; } - void OnFailureResponse_220(CHIP_ERROR error) + void OnFailureResponse_222(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_220(const chip::app::DataModel::Nullable & nullableInt16u) + void OnSuccessResponse_222(const chip::app::DataModel::Nullable & nullableInt16u) { VerifyOrReturn(CheckValueNonNull("nullableInt16u", nullableInt16u)); VerifyOrReturn(CheckValue("nullableInt16u.Value()", nullableInt16u.Value(), 0U)); @@ -63562,7 +63734,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16uMaxValue_221() + CHIP_ERROR TestWriteAttributeNullableInt16uMaxValue_223() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -63573,36 +63745,36 @@ class TestCluster : public TestCommand nullableInt16uArgument.Value() = 65534U; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16uArgument, this, OnSuccessCallback_221, OnFailureCallback_221)); + nullableInt16uArgument, this, OnSuccessCallback_223, OnFailureCallback_223)); return CHIP_NO_ERROR; } - void OnFailureResponse_221(CHIP_ERROR error) + void OnFailureResponse_223(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_221() { NextTest(); } + void OnSuccessResponse_223() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uMaxValue_222() + CHIP_ERROR TestReadAttributeNullableInt16uMaxValue_224() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_222, OnFailureCallback_222)); + this, OnSuccessCallback_224, OnFailureCallback_224)); return CHIP_NO_ERROR; } - void OnFailureResponse_222(CHIP_ERROR error) + void OnFailureResponse_224(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_222(const chip::app::DataModel::Nullable & nullableInt16u) + void OnSuccessResponse_224(const chip::app::DataModel::Nullable & nullableInt16u) { VerifyOrReturn(CheckValueNonNull("nullableInt16u", nullableInt16u)); VerifyOrReturn(CheckValue("nullableInt16u.Value()", nullableInt16u.Value(), 65534U)); @@ -63610,7 +63782,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16uInvalidValue_223() + CHIP_ERROR TestWriteAttributeNullableInt16uInvalidValue_225() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -63621,37 +63793,37 @@ class TestCluster : public TestCommand nullableInt16uArgument.Value() = 65535U; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16uArgument, this, OnSuccessCallback_223, OnFailureCallback_223)); + nullableInt16uArgument, this, OnSuccessCallback_225, OnFailureCallback_225)); return CHIP_NO_ERROR; } - void OnFailureResponse_223(CHIP_ERROR error) + void OnFailureResponse_225(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_223() { ThrowSuccessResponse(); } + void OnSuccessResponse_225() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt16uUnchangedValue_224() + CHIP_ERROR TestReadAttributeNullableInt16uUnchangedValue_226() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_224, OnFailureCallback_224)); + this, OnSuccessCallback_226, OnFailureCallback_226)); return CHIP_NO_ERROR; } - void OnFailureResponse_224(CHIP_ERROR error) + void OnFailureResponse_226(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_224(const chip::app::DataModel::Nullable & nullableInt16u) + void OnSuccessResponse_226(const chip::app::DataModel::Nullable & nullableInt16u) { VerifyOrReturn(CheckValueNonNull("nullableInt16u", nullableInt16u)); VerifyOrReturn(CheckValue("nullableInt16u.Value()", nullableInt16u.Value(), 65534U)); @@ -63659,7 +63831,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16uNullValue_225() + CHIP_ERROR TestWriteAttributeNullableInt16uNullValue_227() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -63669,91 +63841,91 @@ class TestCluster : public TestCommand nullableInt16uArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16uArgument, this, OnSuccessCallback_225, OnFailureCallback_225)); + nullableInt16uArgument, this, OnSuccessCallback_227, OnFailureCallback_227)); return CHIP_NO_ERROR; } - void OnFailureResponse_225(CHIP_ERROR error) + void OnFailureResponse_227(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_225() { NextTest(); } + void OnSuccessResponse_227() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uNullValue_226() + CHIP_ERROR TestReadAttributeNullableInt16uNullValue_228() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_226, OnFailureCallback_226)); + this, OnSuccessCallback_228, OnFailureCallback_228)); return CHIP_NO_ERROR; } - void OnFailureResponse_226(CHIP_ERROR error) + void OnFailureResponse_228(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_226(const chip::app::DataModel::Nullable & nullableInt16u) + void OnSuccessResponse_228(const chip::app::DataModel::Nullable & nullableInt16u) { VerifyOrReturn(CheckValueNull("nullableInt16u", nullableInt16u)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uNullValueRange_227() + CHIP_ERROR TestReadAttributeNullableInt16uNullValueRange_229() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_227, OnFailureCallback_227)); + this, OnSuccessCallback_229, OnFailureCallback_229)); return CHIP_NO_ERROR; } - void OnFailureResponse_227(CHIP_ERROR error) + void OnFailureResponse_229(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_227(const chip::app::DataModel::Nullable & nullableInt16u) + void OnSuccessResponse_229(const chip::app::DataModel::Nullable & nullableInt16u) { VerifyOrReturn(CheckConstraintMinValue("nullableInt16u", nullableInt16u, 0U)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt16u", nullableInt16u, 65534U)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uNullValueNot_228() + CHIP_ERROR TestReadAttributeNullableInt16uNullValueNot_230() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_228, OnFailureCallback_228)); + this, OnSuccessCallback_230, OnFailureCallback_230)); return CHIP_NO_ERROR; } - void OnFailureResponse_228(CHIP_ERROR error) + void OnFailureResponse_230(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_228(const chip::app::DataModel::Nullable & nullableInt16u) + void OnSuccessResponse_230(const chip::app::DataModel::Nullable & nullableInt16u) { VerifyOrReturn(CheckConstraintNotValue("nullableInt16u", nullableInt16u, 65534U)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16uValue_229() + CHIP_ERROR TestWriteAttributeNullableInt16uValue_231() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -63764,67 +63936,67 @@ class TestCluster : public TestCommand nullableInt16uArgument.Value() = 32000U; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16uArgument, this, OnSuccessCallback_229, OnFailureCallback_229)); + nullableInt16uArgument, this, OnSuccessCallback_231, OnFailureCallback_231)); return CHIP_NO_ERROR; } - void OnFailureResponse_229(CHIP_ERROR error) + void OnFailureResponse_231(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_229() { NextTest(); } + void OnSuccessResponse_231() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uValueInRange_230() + CHIP_ERROR TestReadAttributeNullableInt16uValueInRange_232() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_230, OnFailureCallback_230)); + this, OnSuccessCallback_232, OnFailureCallback_232)); return CHIP_NO_ERROR; } - void OnFailureResponse_230(CHIP_ERROR error) + void OnFailureResponse_232(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_230(const chip::app::DataModel::Nullable & nullableInt16u) + void OnSuccessResponse_232(const chip::app::DataModel::Nullable & nullableInt16u) { VerifyOrReturn(CheckConstraintMinValue("nullableInt16u", nullableInt16u, 0U)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt16u", nullableInt16u, 65534U)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16uNotValueOk_231() + CHIP_ERROR TestReadAttributeNullableInt16uNotValueOk_233() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_231, OnFailureCallback_231)); + this, OnSuccessCallback_233, OnFailureCallback_233)); return CHIP_NO_ERROR; } - void OnFailureResponse_231(CHIP_ERROR error) + void OnFailureResponse_233(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_231(const chip::app::DataModel::Nullable & nullableInt16u) + void OnSuccessResponse_233(const chip::app::DataModel::Nullable & nullableInt16u) { VerifyOrReturn(CheckConstraintNotValue("nullableInt16u", nullableInt16u, 32001U)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32uMinValue_232() + CHIP_ERROR TestWriteAttributeNullableInt32uMinValue_234() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -63835,36 +64007,36 @@ class TestCluster : public TestCommand nullableInt32uArgument.Value() = 0UL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32uArgument, this, OnSuccessCallback_232, OnFailureCallback_232)); + nullableInt32uArgument, this, OnSuccessCallback_234, OnFailureCallback_234)); return CHIP_NO_ERROR; } - void OnFailureResponse_232(CHIP_ERROR error) + void OnFailureResponse_234(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_232() { NextTest(); } + void OnSuccessResponse_234() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32uMinValue_233() + CHIP_ERROR TestReadAttributeNullableInt32uMinValue_235() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_233, OnFailureCallback_233)); + this, OnSuccessCallback_235, OnFailureCallback_235)); return CHIP_NO_ERROR; } - void OnFailureResponse_233(CHIP_ERROR error) + void OnFailureResponse_235(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_233(const chip::app::DataModel::Nullable & nullableInt32u) + void OnSuccessResponse_235(const chip::app::DataModel::Nullable & nullableInt32u) { VerifyOrReturn(CheckValueNonNull("nullableInt32u", nullableInt32u)); VerifyOrReturn(CheckValue("nullableInt32u.Value()", nullableInt32u.Value(), 0UL)); @@ -63872,7 +64044,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32uMaxValue_234() + CHIP_ERROR TestWriteAttributeNullableInt32uMaxValue_236() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -63883,36 +64055,36 @@ class TestCluster : public TestCommand nullableInt32uArgument.Value() = 4294967294UL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32uArgument, this, OnSuccessCallback_234, OnFailureCallback_234)); + nullableInt32uArgument, this, OnSuccessCallback_236, OnFailureCallback_236)); return CHIP_NO_ERROR; } - void OnFailureResponse_234(CHIP_ERROR error) + void OnFailureResponse_236(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_234() { NextTest(); } + void OnSuccessResponse_236() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32uMaxValue_235() + CHIP_ERROR TestReadAttributeNullableInt32uMaxValue_237() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_235, OnFailureCallback_235)); + this, OnSuccessCallback_237, OnFailureCallback_237)); return CHIP_NO_ERROR; } - void OnFailureResponse_235(CHIP_ERROR error) + void OnFailureResponse_237(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_235(const chip::app::DataModel::Nullable & nullableInt32u) + void OnSuccessResponse_237(const chip::app::DataModel::Nullable & nullableInt32u) { VerifyOrReturn(CheckValueNonNull("nullableInt32u", nullableInt32u)); VerifyOrReturn(CheckValue("nullableInt32u.Value()", nullableInt32u.Value(), 4294967294UL)); @@ -63920,7 +64092,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32uInvalidValue_236() + CHIP_ERROR TestWriteAttributeNullableInt32uInvalidValue_238() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -63931,37 +64103,37 @@ class TestCluster : public TestCommand nullableInt32uArgument.Value() = 4294967295UL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32uArgument, this, OnSuccessCallback_236, OnFailureCallback_236)); + nullableInt32uArgument, this, OnSuccessCallback_238, OnFailureCallback_238)); return CHIP_NO_ERROR; } - void OnFailureResponse_236(CHIP_ERROR error) + void OnFailureResponse_238(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_236() { ThrowSuccessResponse(); } + void OnSuccessResponse_238() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt32uUnchangedValue_237() + CHIP_ERROR TestReadAttributeNullableInt32uUnchangedValue_239() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_237, OnFailureCallback_237)); + this, OnSuccessCallback_239, OnFailureCallback_239)); return CHIP_NO_ERROR; } - void OnFailureResponse_237(CHIP_ERROR error) + void OnFailureResponse_239(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_237(const chip::app::DataModel::Nullable & nullableInt32u) + void OnSuccessResponse_239(const chip::app::DataModel::Nullable & nullableInt32u) { VerifyOrReturn(CheckValueNonNull("nullableInt32u", nullableInt32u)); VerifyOrReturn(CheckValue("nullableInt32u.Value()", nullableInt32u.Value(), 4294967294UL)); @@ -63969,7 +64141,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32uNullValue_238() + CHIP_ERROR TestWriteAttributeNullableInt32uNullValue_240() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -63979,91 +64151,91 @@ class TestCluster : public TestCommand nullableInt32uArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32uArgument, this, OnSuccessCallback_238, OnFailureCallback_238)); + nullableInt32uArgument, this, OnSuccessCallback_240, OnFailureCallback_240)); return CHIP_NO_ERROR; } - void OnFailureResponse_238(CHIP_ERROR error) + void OnFailureResponse_240(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_238() { NextTest(); } + void OnSuccessResponse_240() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32uNullValue_239() + CHIP_ERROR TestReadAttributeNullableInt32uNullValue_241() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_239, OnFailureCallback_239)); + this, OnSuccessCallback_241, OnFailureCallback_241)); return CHIP_NO_ERROR; } - void OnFailureResponse_239(CHIP_ERROR error) + void OnFailureResponse_241(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_239(const chip::app::DataModel::Nullable & nullableInt32u) + void OnSuccessResponse_241(const chip::app::DataModel::Nullable & nullableInt32u) { VerifyOrReturn(CheckValueNull("nullableInt32u", nullableInt32u)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32uNullValueRange_240() + CHIP_ERROR TestReadAttributeNullableInt32uNullValueRange_242() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_240, OnFailureCallback_240)); + this, OnSuccessCallback_242, OnFailureCallback_242)); return CHIP_NO_ERROR; } - void OnFailureResponse_240(CHIP_ERROR error) + void OnFailureResponse_242(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_240(const chip::app::DataModel::Nullable & nullableInt32u) + void OnSuccessResponse_242(const chip::app::DataModel::Nullable & nullableInt32u) { VerifyOrReturn(CheckConstraintMinValue("nullableInt32u", nullableInt32u, 0UL)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt32u", nullableInt32u, 4294967294UL)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32uNullValueNot_241() + CHIP_ERROR TestReadAttributeNullableInt32uNullValueNot_243() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_241, OnFailureCallback_241)); + this, OnSuccessCallback_243, OnFailureCallback_243)); return CHIP_NO_ERROR; } - void OnFailureResponse_241(CHIP_ERROR error) + void OnFailureResponse_243(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_241(const chip::app::DataModel::Nullable & nullableInt32u) + void OnSuccessResponse_243(const chip::app::DataModel::Nullable & nullableInt32u) { VerifyOrReturn(CheckConstraintNotValue("nullableInt32u", nullableInt32u, 4294967294UL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32uValue_242() + CHIP_ERROR TestWriteAttributeNullableInt32uValue_244() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -64074,67 +64246,67 @@ class TestCluster : public TestCommand nullableInt32uArgument.Value() = 2147483647UL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32uArgument, this, OnSuccessCallback_242, OnFailureCallback_242)); + nullableInt32uArgument, this, OnSuccessCallback_244, OnFailureCallback_244)); return CHIP_NO_ERROR; } - void OnFailureResponse_242(CHIP_ERROR error) + void OnFailureResponse_244(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_242() { NextTest(); } + void OnSuccessResponse_244() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32uValueInRange_243() + CHIP_ERROR TestReadAttributeNullableInt32uValueInRange_245() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_243, OnFailureCallback_243)); + this, OnSuccessCallback_245, OnFailureCallback_245)); return CHIP_NO_ERROR; } - void OnFailureResponse_243(CHIP_ERROR error) + void OnFailureResponse_245(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_243(const chip::app::DataModel::Nullable & nullableInt32u) + void OnSuccessResponse_245(const chip::app::DataModel::Nullable & nullableInt32u) { VerifyOrReturn(CheckConstraintMinValue("nullableInt32u", nullableInt32u, 0UL)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt32u", nullableInt32u, 4294967294UL)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32uNotValueOk_244() + CHIP_ERROR TestReadAttributeNullableInt32uNotValueOk_246() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_244, OnFailureCallback_244)); + this, OnSuccessCallback_246, OnFailureCallback_246)); return CHIP_NO_ERROR; } - void OnFailureResponse_244(CHIP_ERROR error) + void OnFailureResponse_246(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_244(const chip::app::DataModel::Nullable & nullableInt32u) + void OnSuccessResponse_246(const chip::app::DataModel::Nullable & nullableInt32u) { VerifyOrReturn(CheckConstraintNotValue("nullableInt32u", nullableInt32u, 2147483648UL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64uMinValue_245() + CHIP_ERROR TestWriteAttributeNullableInt64uMinValue_247() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -64145,36 +64317,36 @@ class TestCluster : public TestCommand nullableInt64uArgument.Value() = 0ULL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64uArgument, this, OnSuccessCallback_245, OnFailureCallback_245)); + nullableInt64uArgument, this, OnSuccessCallback_247, OnFailureCallback_247)); return CHIP_NO_ERROR; } - void OnFailureResponse_245(CHIP_ERROR error) + void OnFailureResponse_247(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_245() { NextTest(); } + void OnSuccessResponse_247() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64uMinValue_246() + CHIP_ERROR TestReadAttributeNullableInt64uMinValue_248() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_246, OnFailureCallback_246)); + this, OnSuccessCallback_248, OnFailureCallback_248)); return CHIP_NO_ERROR; } - void OnFailureResponse_246(CHIP_ERROR error) + void OnFailureResponse_248(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_246(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_248(const chip::app::DataModel::Nullable & nullableInt64u) { VerifyOrReturn(CheckValueNonNull("nullableInt64u", nullableInt64u)); VerifyOrReturn(CheckValue("nullableInt64u.Value()", nullableInt64u.Value(), 0ULL)); @@ -64182,7 +64354,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64uMaxValue_247() + CHIP_ERROR TestWriteAttributeNullableInt64uMaxValue_249() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -64193,36 +64365,36 @@ class TestCluster : public TestCommand nullableInt64uArgument.Value() = 18446744073709551614ULL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64uArgument, this, OnSuccessCallback_247, OnFailureCallback_247)); + nullableInt64uArgument, this, OnSuccessCallback_249, OnFailureCallback_249)); return CHIP_NO_ERROR; } - void OnFailureResponse_247(CHIP_ERROR error) + void OnFailureResponse_249(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_247() { NextTest(); } + void OnSuccessResponse_249() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64uMaxValue_248() + CHIP_ERROR TestReadAttributeNullableInt64uMaxValue_250() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_248, OnFailureCallback_248)); + this, OnSuccessCallback_250, OnFailureCallback_250)); return CHIP_NO_ERROR; } - void OnFailureResponse_248(CHIP_ERROR error) + void OnFailureResponse_250(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_248(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_250(const chip::app::DataModel::Nullable & nullableInt64u) { VerifyOrReturn(CheckValueNonNull("nullableInt64u", nullableInt64u)); VerifyOrReturn(CheckValue("nullableInt64u.Value()", nullableInt64u.Value(), 18446744073709551614ULL)); @@ -64230,7 +64402,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64uInvalidValue_249() + CHIP_ERROR TestWriteAttributeNullableInt64uInvalidValue_251() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -64241,37 +64413,37 @@ class TestCluster : public TestCommand nullableInt64uArgument.Value() = 18446744073709551615ULL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64uArgument, this, OnSuccessCallback_249, OnFailureCallback_249)); + nullableInt64uArgument, this, OnSuccessCallback_251, OnFailureCallback_251)); return CHIP_NO_ERROR; } - void OnFailureResponse_249(CHIP_ERROR error) + void OnFailureResponse_251(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_249() { ThrowSuccessResponse(); } + void OnSuccessResponse_251() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt64uUnchangedValue_250() + CHIP_ERROR TestReadAttributeNullableInt64uUnchangedValue_252() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_250, OnFailureCallback_250)); + this, OnSuccessCallback_252, OnFailureCallback_252)); return CHIP_NO_ERROR; } - void OnFailureResponse_250(CHIP_ERROR error) + void OnFailureResponse_252(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_250(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_252(const chip::app::DataModel::Nullable & nullableInt64u) { VerifyOrReturn(CheckValueNonNull("nullableInt64u", nullableInt64u)); VerifyOrReturn(CheckValue("nullableInt64u.Value()", nullableInt64u.Value(), 18446744073709551614ULL)); @@ -64279,7 +64451,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64uNullValue_251() + CHIP_ERROR TestWriteAttributeNullableInt64uNullValue_253() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -64289,91 +64461,91 @@ class TestCluster : public TestCommand nullableInt64uArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64uArgument, this, OnSuccessCallback_251, OnFailureCallback_251)); + nullableInt64uArgument, this, OnSuccessCallback_253, OnFailureCallback_253)); return CHIP_NO_ERROR; } - void OnFailureResponse_251(CHIP_ERROR error) + void OnFailureResponse_253(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_251() { NextTest(); } + void OnSuccessResponse_253() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64uNullValue_252() + CHIP_ERROR TestReadAttributeNullableInt64uNullValue_254() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_252, OnFailureCallback_252)); + this, OnSuccessCallback_254, OnFailureCallback_254)); return CHIP_NO_ERROR; } - void OnFailureResponse_252(CHIP_ERROR error) + void OnFailureResponse_254(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_252(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_254(const chip::app::DataModel::Nullable & nullableInt64u) { VerifyOrReturn(CheckValueNull("nullableInt64u", nullableInt64u)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64uNullValueRange_253() + CHIP_ERROR TestReadAttributeNullableInt64uNullValueRange_255() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_253, OnFailureCallback_253)); + this, OnSuccessCallback_255, OnFailureCallback_255)); return CHIP_NO_ERROR; } - void OnFailureResponse_253(CHIP_ERROR error) + void OnFailureResponse_255(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_253(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_255(const chip::app::DataModel::Nullable & nullableInt64u) { VerifyOrReturn(CheckConstraintMinValue("nullableInt64u", nullableInt64u, 0ULL)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt64u", nullableInt64u, 18446744073709551614ULL)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64uNullValueNot_254() + CHIP_ERROR TestReadAttributeNullableInt64uNullValueNot_256() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_254, OnFailureCallback_254)); + this, OnSuccessCallback_256, OnFailureCallback_256)); return CHIP_NO_ERROR; } - void OnFailureResponse_254(CHIP_ERROR error) + void OnFailureResponse_256(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_254(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_256(const chip::app::DataModel::Nullable & nullableInt64u) { VerifyOrReturn(CheckConstraintNotValue("nullableInt64u", nullableInt64u, 18446744073709551614ULL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64uValue_255() + CHIP_ERROR TestWriteAttributeNullableInt64uValue_257() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -64384,67 +64556,67 @@ class TestCluster : public TestCommand nullableInt64uArgument.Value() = 18000000000000000000ULL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64uArgument, this, OnSuccessCallback_255, OnFailureCallback_255)); + nullableInt64uArgument, this, OnSuccessCallback_257, OnFailureCallback_257)); return CHIP_NO_ERROR; } - void OnFailureResponse_255(CHIP_ERROR error) + void OnFailureResponse_257(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_255() { NextTest(); } + void OnSuccessResponse_257() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64uValueInRange_256() + CHIP_ERROR TestReadAttributeNullableInt64uValueInRange_258() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_256, OnFailureCallback_256)); + this, OnSuccessCallback_258, OnFailureCallback_258)); return CHIP_NO_ERROR; } - void OnFailureResponse_256(CHIP_ERROR error) + void OnFailureResponse_258(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_256(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_258(const chip::app::DataModel::Nullable & nullableInt64u) { VerifyOrReturn(CheckConstraintMinValue("nullableInt64u", nullableInt64u, 0ULL)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt64u", nullableInt64u, 18446744073709551614ULL)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64uNotValueOk_257() + CHIP_ERROR TestReadAttributeNullableInt64uNotValueOk_259() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_257, OnFailureCallback_257)); + this, OnSuccessCallback_259, OnFailureCallback_259)); return CHIP_NO_ERROR; } - void OnFailureResponse_257(CHIP_ERROR error) + void OnFailureResponse_259(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_257(const chip::app::DataModel::Nullable & nullableInt64u) + void OnSuccessResponse_259(const chip::app::DataModel::Nullable & nullableInt64u) { VerifyOrReturn(CheckConstraintNotValue("nullableInt64u", nullableInt64u, 18000000000000000001ULL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sMinValue_258() + CHIP_ERROR TestWriteAttributeNullableInt8sMinValue_260() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -64455,36 +64627,36 @@ class TestCluster : public TestCommand nullableInt8sArgument.Value() = -127; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_258, OnFailureCallback_258)); + nullableInt8sArgument, this, OnSuccessCallback_260, OnFailureCallback_260)); return CHIP_NO_ERROR; } - void OnFailureResponse_258(CHIP_ERROR error) + void OnFailureResponse_260(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_258() { NextTest(); } + void OnSuccessResponse_260() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sMinValue_259() + CHIP_ERROR TestReadAttributeNullableInt8sMinValue_261() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_259, OnFailureCallback_259)); + this, OnSuccessCallback_261, OnFailureCallback_261)); return CHIP_NO_ERROR; } - void OnFailureResponse_259(CHIP_ERROR error) + void OnFailureResponse_261(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_259(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_261(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckValueNonNull("nullableInt8s", nullableInt8s)); VerifyOrReturn(CheckValue("nullableInt8s.Value()", nullableInt8s.Value(), -127)); @@ -64492,7 +64664,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sInvalidValue_260() + CHIP_ERROR TestWriteAttributeNullableInt8sInvalidValue_262() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -64503,37 +64675,37 @@ class TestCluster : public TestCommand nullableInt8sArgument.Value() = -128; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_260, OnFailureCallback_260)); + nullableInt8sArgument, this, OnSuccessCallback_262, OnFailureCallback_262)); return CHIP_NO_ERROR; } - void OnFailureResponse_260(CHIP_ERROR error) + void OnFailureResponse_262(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_260() { ThrowSuccessResponse(); } + void OnSuccessResponse_262() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt8sUnchangedValue_261() + CHIP_ERROR TestReadAttributeNullableInt8sUnchangedValue_263() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_261, OnFailureCallback_261)); + this, OnSuccessCallback_263, OnFailureCallback_263)); return CHIP_NO_ERROR; } - void OnFailureResponse_261(CHIP_ERROR error) + void OnFailureResponse_263(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_261(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_263(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckValueNonNull("nullableInt8s", nullableInt8s)); VerifyOrReturn(CheckValue("nullableInt8s.Value()", nullableInt8s.Value(), -127)); @@ -64541,7 +64713,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sNullValue_262() + CHIP_ERROR TestWriteAttributeNullableInt8sNullValue_264() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -64551,91 +64723,91 @@ class TestCluster : public TestCommand nullableInt8sArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_262, OnFailureCallback_262)); + nullableInt8sArgument, this, OnSuccessCallback_264, OnFailureCallback_264)); return CHIP_NO_ERROR; } - void OnFailureResponse_262(CHIP_ERROR error) + void OnFailureResponse_264(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_262() { NextTest(); } + void OnSuccessResponse_264() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sNullValue_263() + CHIP_ERROR TestReadAttributeNullableInt8sNullValue_265() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_263, OnFailureCallback_263)); + this, OnSuccessCallback_265, OnFailureCallback_265)); return CHIP_NO_ERROR; } - void OnFailureResponse_263(CHIP_ERROR error) + void OnFailureResponse_265(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_263(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_265(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckValueNull("nullableInt8s", nullableInt8s)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sNullValueRange_264() + CHIP_ERROR TestReadAttributeNullableInt8sNullValueRange_266() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_264, OnFailureCallback_264)); + this, OnSuccessCallback_266, OnFailureCallback_266)); return CHIP_NO_ERROR; } - void OnFailureResponse_264(CHIP_ERROR error) + void OnFailureResponse_266(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_264(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_266(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt8s", nullableInt8s, -127)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt8s", nullableInt8s, 127)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sNullValueNot_265() + CHIP_ERROR TestReadAttributeNullableInt8sNullValueNot_267() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_265, OnFailureCallback_265)); + this, OnSuccessCallback_267, OnFailureCallback_267)); return CHIP_NO_ERROR; } - void OnFailureResponse_265(CHIP_ERROR error) + void OnFailureResponse_267(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_265(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_267(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt8s", nullableInt8s, -127)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt8sValue_266() + CHIP_ERROR TestWriteAttributeNullableInt8sValue_268() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -64646,67 +64818,67 @@ class TestCluster : public TestCommand nullableInt8sArgument.Value() = -127; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt8sArgument, this, OnSuccessCallback_266, OnFailureCallback_266)); + nullableInt8sArgument, this, OnSuccessCallback_268, OnFailureCallback_268)); return CHIP_NO_ERROR; } - void OnFailureResponse_266(CHIP_ERROR error) + void OnFailureResponse_268(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_266() { NextTest(); } + void OnSuccessResponse_268() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sValueInRange_267() + CHIP_ERROR TestReadAttributeNullableInt8sValueInRange_269() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_267, OnFailureCallback_267)); + this, OnSuccessCallback_269, OnFailureCallback_269)); return CHIP_NO_ERROR; } - void OnFailureResponse_267(CHIP_ERROR error) + void OnFailureResponse_269(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_267(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_269(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt8s", nullableInt8s, -127)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt8s", nullableInt8s, 127)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt8sNotValueOk_268() + CHIP_ERROR TestReadAttributeNullableInt8sNotValueOk_270() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_268, OnFailureCallback_268)); + this, OnSuccessCallback_270, OnFailureCallback_270)); return CHIP_NO_ERROR; } - void OnFailureResponse_268(CHIP_ERROR error) + void OnFailureResponse_270(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_268(const chip::app::DataModel::Nullable & nullableInt8s) + void OnSuccessResponse_270(const chip::app::DataModel::Nullable & nullableInt8s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt8s", nullableInt8s, -126)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sMinValue_269() + CHIP_ERROR TestWriteAttributeNullableInt16sMinValue_271() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -64717,36 +64889,36 @@ class TestCluster : public TestCommand nullableInt16sArgument.Value() = -32767; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_269, OnFailureCallback_269)); + nullableInt16sArgument, this, OnSuccessCallback_271, OnFailureCallback_271)); return CHIP_NO_ERROR; } - void OnFailureResponse_269(CHIP_ERROR error) + void OnFailureResponse_271(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_269() { NextTest(); } + void OnSuccessResponse_271() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sMinValue_270() + CHIP_ERROR TestReadAttributeNullableInt16sMinValue_272() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_270, OnFailureCallback_270)); + this, OnSuccessCallback_272, OnFailureCallback_272)); return CHIP_NO_ERROR; } - void OnFailureResponse_270(CHIP_ERROR error) + void OnFailureResponse_272(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_270(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_272(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckValueNonNull("nullableInt16s", nullableInt16s)); VerifyOrReturn(CheckValue("nullableInt16s.Value()", nullableInt16s.Value(), -32767)); @@ -64754,7 +64926,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sInvalidValue_271() + CHIP_ERROR TestWriteAttributeNullableInt16sInvalidValue_273() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -64765,37 +64937,37 @@ class TestCluster : public TestCommand nullableInt16sArgument.Value() = -32768; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_271, OnFailureCallback_271)); + nullableInt16sArgument, this, OnSuccessCallback_273, OnFailureCallback_273)); return CHIP_NO_ERROR; } - void OnFailureResponse_271(CHIP_ERROR error) + void OnFailureResponse_273(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_271() { ThrowSuccessResponse(); } + void OnSuccessResponse_273() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt16sUnchangedValue_272() + CHIP_ERROR TestReadAttributeNullableInt16sUnchangedValue_274() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_272, OnFailureCallback_272)); + this, OnSuccessCallback_274, OnFailureCallback_274)); return CHIP_NO_ERROR; } - void OnFailureResponse_272(CHIP_ERROR error) + void OnFailureResponse_274(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_272(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_274(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckValueNonNull("nullableInt16s", nullableInt16s)); VerifyOrReturn(CheckValue("nullableInt16s.Value()", nullableInt16s.Value(), -32767)); @@ -64803,7 +64975,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sNullValue_273() + CHIP_ERROR TestWriteAttributeNullableInt16sNullValue_275() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -64813,91 +64985,91 @@ class TestCluster : public TestCommand nullableInt16sArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_273, OnFailureCallback_273)); + nullableInt16sArgument, this, OnSuccessCallback_275, OnFailureCallback_275)); return CHIP_NO_ERROR; } - void OnFailureResponse_273(CHIP_ERROR error) + void OnFailureResponse_275(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_273() { NextTest(); } + void OnSuccessResponse_275() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sNullValue_274() + CHIP_ERROR TestReadAttributeNullableInt16sNullValue_276() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_274, OnFailureCallback_274)); + this, OnSuccessCallback_276, OnFailureCallback_276)); return CHIP_NO_ERROR; } - void OnFailureResponse_274(CHIP_ERROR error) + void OnFailureResponse_276(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_274(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_276(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckValueNull("nullableInt16s", nullableInt16s)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sNullValueRange_275() + CHIP_ERROR TestReadAttributeNullableInt16sNullValueRange_277() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_275, OnFailureCallback_275)); + this, OnSuccessCallback_277, OnFailureCallback_277)); return CHIP_NO_ERROR; } - void OnFailureResponse_275(CHIP_ERROR error) + void OnFailureResponse_277(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_275(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_277(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt16s", nullableInt16s, -32767)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt16s", nullableInt16s, 32767)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sNullValueNot_276() + CHIP_ERROR TestReadAttributeNullableInt16sNullValueNot_278() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_276, OnFailureCallback_276)); + this, OnSuccessCallback_278, OnFailureCallback_278)); return CHIP_NO_ERROR; } - void OnFailureResponse_276(CHIP_ERROR error) + void OnFailureResponse_278(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_276(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_278(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt16s", nullableInt16s, -32767)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt16sValue_277() + CHIP_ERROR TestWriteAttributeNullableInt16sValue_279() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -64908,67 +65080,67 @@ class TestCluster : public TestCommand nullableInt16sArgument.Value() = -32767; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt16sArgument, this, OnSuccessCallback_277, OnFailureCallback_277)); + nullableInt16sArgument, this, OnSuccessCallback_279, OnFailureCallback_279)); return CHIP_NO_ERROR; } - void OnFailureResponse_277(CHIP_ERROR error) + void OnFailureResponse_279(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_277() { NextTest(); } + void OnSuccessResponse_279() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sValueInRange_278() + CHIP_ERROR TestReadAttributeNullableInt16sValueInRange_280() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_278, OnFailureCallback_278)); + this, OnSuccessCallback_280, OnFailureCallback_280)); return CHIP_NO_ERROR; } - void OnFailureResponse_278(CHIP_ERROR error) + void OnFailureResponse_280(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_278(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_280(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt16s", nullableInt16s, -32767)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt16s", nullableInt16s, 32767)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt16sNotValueOk_279() + CHIP_ERROR TestReadAttributeNullableInt16sNotValueOk_281() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_279, OnFailureCallback_279)); + this, OnSuccessCallback_281, OnFailureCallback_281)); return CHIP_NO_ERROR; } - void OnFailureResponse_279(CHIP_ERROR error) + void OnFailureResponse_281(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_279(const chip::app::DataModel::Nullable & nullableInt16s) + void OnSuccessResponse_281(const chip::app::DataModel::Nullable & nullableInt16s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt16s", nullableInt16s, -32766)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sMinValue_280() + CHIP_ERROR TestWriteAttributeNullableInt32sMinValue_282() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -64979,36 +65151,36 @@ class TestCluster : public TestCommand nullableInt32sArgument.Value() = -2147483647L; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_280, OnFailureCallback_280)); + nullableInt32sArgument, this, OnSuccessCallback_282, OnFailureCallback_282)); return CHIP_NO_ERROR; } - void OnFailureResponse_280(CHIP_ERROR error) + void OnFailureResponse_282(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_280() { NextTest(); } + void OnSuccessResponse_282() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sMinValue_281() + CHIP_ERROR TestReadAttributeNullableInt32sMinValue_283() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_281, OnFailureCallback_281)); + this, OnSuccessCallback_283, OnFailureCallback_283)); return CHIP_NO_ERROR; } - void OnFailureResponse_281(CHIP_ERROR error) + void OnFailureResponse_283(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_281(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_283(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckValueNonNull("nullableInt32s", nullableInt32s)); VerifyOrReturn(CheckValue("nullableInt32s.Value()", nullableInt32s.Value(), -2147483647L)); @@ -65016,7 +65188,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sInvalidValue_282() + CHIP_ERROR TestWriteAttributeNullableInt32sInvalidValue_284() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65027,37 +65199,37 @@ class TestCluster : public TestCommand nullableInt32sArgument.Value() = -2147483648L; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_282, OnFailureCallback_282)); + nullableInt32sArgument, this, OnSuccessCallback_284, OnFailureCallback_284)); return CHIP_NO_ERROR; } - void OnFailureResponse_282(CHIP_ERROR error) + void OnFailureResponse_284(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_282() { ThrowSuccessResponse(); } + void OnSuccessResponse_284() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt32sUnchangedValue_283() + CHIP_ERROR TestReadAttributeNullableInt32sUnchangedValue_285() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_283, OnFailureCallback_283)); + this, OnSuccessCallback_285, OnFailureCallback_285)); return CHIP_NO_ERROR; } - void OnFailureResponse_283(CHIP_ERROR error) + void OnFailureResponse_285(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_283(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_285(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckValueNonNull("nullableInt32s", nullableInt32s)); VerifyOrReturn(CheckValue("nullableInt32s.Value()", nullableInt32s.Value(), -2147483647L)); @@ -65065,7 +65237,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sNullValue_284() + CHIP_ERROR TestWriteAttributeNullableInt32sNullValue_286() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65075,91 +65247,91 @@ class TestCluster : public TestCommand nullableInt32sArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_284, OnFailureCallback_284)); + nullableInt32sArgument, this, OnSuccessCallback_286, OnFailureCallback_286)); return CHIP_NO_ERROR; } - void OnFailureResponse_284(CHIP_ERROR error) + void OnFailureResponse_286(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_284() { NextTest(); } + void OnSuccessResponse_286() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sNullValue_285() + CHIP_ERROR TestReadAttributeNullableInt32sNullValue_287() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_285, OnFailureCallback_285)); + this, OnSuccessCallback_287, OnFailureCallback_287)); return CHIP_NO_ERROR; } - void OnFailureResponse_285(CHIP_ERROR error) + void OnFailureResponse_287(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_285(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_287(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckValueNull("nullableInt32s", nullableInt32s)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sNullValueRange_286() + CHIP_ERROR TestReadAttributeNullableInt32sNullValueRange_288() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_286, OnFailureCallback_286)); + this, OnSuccessCallback_288, OnFailureCallback_288)); return CHIP_NO_ERROR; } - void OnFailureResponse_286(CHIP_ERROR error) + void OnFailureResponse_288(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_286(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_288(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt32s", nullableInt32s, -2147483647L)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt32s", nullableInt32s, 2147483647L)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sNullValueNot_287() + CHIP_ERROR TestReadAttributeNullableInt32sNullValueNot_289() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_287, OnFailureCallback_287)); + this, OnSuccessCallback_289, OnFailureCallback_289)); return CHIP_NO_ERROR; } - void OnFailureResponse_287(CHIP_ERROR error) + void OnFailureResponse_289(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_287(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_289(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt32s", nullableInt32s, -2147483647L)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt32sValue_288() + CHIP_ERROR TestWriteAttributeNullableInt32sValue_290() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65170,67 +65342,67 @@ class TestCluster : public TestCommand nullableInt32sArgument.Value() = -2147483647L; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt32sArgument, this, OnSuccessCallback_288, OnFailureCallback_288)); + nullableInt32sArgument, this, OnSuccessCallback_290, OnFailureCallback_290)); return CHIP_NO_ERROR; } - void OnFailureResponse_288(CHIP_ERROR error) + void OnFailureResponse_290(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_288() { NextTest(); } + void OnSuccessResponse_290() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sValueInRange_289() + CHIP_ERROR TestReadAttributeNullableInt32sValueInRange_291() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_289, OnFailureCallback_289)); + this, OnSuccessCallback_291, OnFailureCallback_291)); return CHIP_NO_ERROR; } - void OnFailureResponse_289(CHIP_ERROR error) + void OnFailureResponse_291(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_289(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_291(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt32s", nullableInt32s, -2147483647L)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt32s", nullableInt32s, 2147483647L)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt32sNotValueOk_290() + CHIP_ERROR TestReadAttributeNullableInt32sNotValueOk_292() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_290, OnFailureCallback_290)); + this, OnSuccessCallback_292, OnFailureCallback_292)); return CHIP_NO_ERROR; } - void OnFailureResponse_290(CHIP_ERROR error) + void OnFailureResponse_292(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_290(const chip::app::DataModel::Nullable & nullableInt32s) + void OnSuccessResponse_292(const chip::app::DataModel::Nullable & nullableInt32s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt32s", nullableInt32s, -2147483646L)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sMinValue_291() + CHIP_ERROR TestWriteAttributeNullableInt64sMinValue_293() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65241,36 +65413,36 @@ class TestCluster : public TestCommand nullableInt64sArgument.Value() = -9223372036854775807LL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_291, OnFailureCallback_291)); + nullableInt64sArgument, this, OnSuccessCallback_293, OnFailureCallback_293)); return CHIP_NO_ERROR; } - void OnFailureResponse_291(CHIP_ERROR error) + void OnFailureResponse_293(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_291() { NextTest(); } + void OnSuccessResponse_293() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sMinValue_292() + CHIP_ERROR TestReadAttributeNullableInt64sMinValue_294() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_292, OnFailureCallback_292)); + this, OnSuccessCallback_294, OnFailureCallback_294)); return CHIP_NO_ERROR; } - void OnFailureResponse_292(CHIP_ERROR error) + void OnFailureResponse_294(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_292(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_294(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckValueNonNull("nullableInt64s", nullableInt64s)); VerifyOrReturn(CheckValue("nullableInt64s.Value()", nullableInt64s.Value(), -9223372036854775807LL)); @@ -65278,7 +65450,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sInvalidValue_293() + CHIP_ERROR TestWriteAttributeNullableInt64sInvalidValue_295() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65289,37 +65461,37 @@ class TestCluster : public TestCommand nullableInt64sArgument.Value() = -9223372036854775807LL - 1; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_293, OnFailureCallback_293)); + nullableInt64sArgument, this, OnSuccessCallback_295, OnFailureCallback_295)); return CHIP_NO_ERROR; } - void OnFailureResponse_293(CHIP_ERROR error) + void OnFailureResponse_295(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_293() { ThrowSuccessResponse(); } + void OnSuccessResponse_295() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableInt64sUnchangedValue_294() + CHIP_ERROR TestReadAttributeNullableInt64sUnchangedValue_296() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_294, OnFailureCallback_294)); + this, OnSuccessCallback_296, OnFailureCallback_296)); return CHIP_NO_ERROR; } - void OnFailureResponse_294(CHIP_ERROR error) + void OnFailureResponse_296(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_294(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_296(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckValueNonNull("nullableInt64s", nullableInt64s)); VerifyOrReturn(CheckValue("nullableInt64s.Value()", nullableInt64s.Value(), -9223372036854775807LL)); @@ -65327,7 +65499,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sNullValue_295() + CHIP_ERROR TestWriteAttributeNullableInt64sNullValue_297() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65337,91 +65509,91 @@ class TestCluster : public TestCommand nullableInt64sArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_295, OnFailureCallback_295)); + nullableInt64sArgument, this, OnSuccessCallback_297, OnFailureCallback_297)); return CHIP_NO_ERROR; } - void OnFailureResponse_295(CHIP_ERROR error) + void OnFailureResponse_297(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_295() { NextTest(); } + void OnSuccessResponse_297() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sNullValue_296() + CHIP_ERROR TestReadAttributeNullableInt64sNullValue_298() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_296, OnFailureCallback_296)); + this, OnSuccessCallback_298, OnFailureCallback_298)); return CHIP_NO_ERROR; } - void OnFailureResponse_296(CHIP_ERROR error) + void OnFailureResponse_298(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_296(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_298(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckValueNull("nullableInt64s", nullableInt64s)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sNullValueRange_297() + CHIP_ERROR TestReadAttributeNullableInt64sNullValueRange_299() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_297, OnFailureCallback_297)); + this, OnSuccessCallback_299, OnFailureCallback_299)); return CHIP_NO_ERROR; } - void OnFailureResponse_297(CHIP_ERROR error) + void OnFailureResponse_299(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_297(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_299(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt64s", nullableInt64s, -9223372036854775807LL)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt64s", nullableInt64s, 9223372036854775807LL)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sNullValueNot_298() + CHIP_ERROR TestReadAttributeNullableInt64sNullValueNot_300() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_298, OnFailureCallback_298)); + this, OnSuccessCallback_300, OnFailureCallback_300)); return CHIP_NO_ERROR; } - void OnFailureResponse_298(CHIP_ERROR error) + void OnFailureResponse_300(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_298(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_300(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckConstraintNotValue("nullableInt64s", nullableInt64s, -9223372036854775807LL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableInt64sValue_299() + CHIP_ERROR TestWriteAttributeNullableInt64sValue_301() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65432,96 +65604,49 @@ class TestCluster : public TestCommand nullableInt64sArgument.Value() = -9223372036854775807LL; ReturnErrorOnFailure(cluster.WriteAttribute( - nullableInt64sArgument, this, OnSuccessCallback_299, OnFailureCallback_299)); + nullableInt64sArgument, this, OnSuccessCallback_301, OnFailureCallback_301)); return CHIP_NO_ERROR; } - void OnFailureResponse_299(CHIP_ERROR error) + void OnFailureResponse_301(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_299() { NextTest(); } + void OnSuccessResponse_301() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sValueInRange_300() + CHIP_ERROR TestReadAttributeNullableInt64sValueInRange_302() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_300, OnFailureCallback_300)); + this, OnSuccessCallback_302, OnFailureCallback_302)); return CHIP_NO_ERROR; } - void OnFailureResponse_300(CHIP_ERROR error) + void OnFailureResponse_302(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_300(const chip::app::DataModel::Nullable & nullableInt64s) + void OnSuccessResponse_302(const chip::app::DataModel::Nullable & nullableInt64s) { VerifyOrReturn(CheckConstraintMinValue("nullableInt64s", nullableInt64s, -9223372036854775807LL)); VerifyOrReturn(CheckConstraintMaxValue("nullableInt64s", nullableInt64s, 9223372036854775807LL)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableInt64sNotValueOk_301() + CHIP_ERROR TestReadAttributeNullableInt64sNotValueOk_303() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_301, OnFailureCallback_301)); - return CHIP_NO_ERROR; - } - - void OnFailureResponse_301(CHIP_ERROR error) - { - chip::app::StatusIB status(error); - ThrowFailureResponse(); - } - - void OnSuccessResponse_301(const chip::app::DataModel::Nullable & nullableInt64s) - { - VerifyOrReturn(CheckConstraintNotValue("nullableInt64s", nullableInt64s, -9223372036854775806LL)); - - NextTest(); - } - - CHIP_ERROR TestWriteAttributeNullableSingleMediumValue_302() - { - const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; - chip::Controller::TestClusterClusterTest cluster; - cluster.Associate(mDevices[kIdentityAlpha], endpoint); - - chip::app::DataModel::Nullable nullableFloatSingleArgument; - nullableFloatSingleArgument.SetNonNull(); - nullableFloatSingleArgument.Value() = 0.1f; - - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatSingleArgument, this, OnSuccessCallback_302, OnFailureCallback_302)); - return CHIP_NO_ERROR; - } - - void OnFailureResponse_302(CHIP_ERROR error) - { - chip::app::StatusIB status(error); - ThrowFailureResponse(); - } - - void OnSuccessResponse_302() { NextTest(); } - - CHIP_ERROR TestReadAttributeNullableSingleMediumValue_303() - { - const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; - chip::Controller::TestClusterClusterTest cluster; - cluster.Associate(mDevices[kIdentityAlpha], endpoint); - - ReturnErrorOnFailure(cluster.ReadAttribute( this, OnSuccessCallback_303, OnFailureCallback_303)); return CHIP_NO_ERROR; } @@ -65532,15 +65657,14 @@ class TestCluster : public TestCommand ThrowFailureResponse(); } - void OnSuccessResponse_303(const chip::app::DataModel::Nullable & nullableFloatSingle) + void OnSuccessResponse_303(const chip::app::DataModel::Nullable & nullableInt64s) { - VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); - VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), 0.1f)); + VerifyOrReturn(CheckConstraintNotValue("nullableInt64s", nullableInt64s, -9223372036854775806LL)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingleLargestValue_304() + CHIP_ERROR TestWriteAttributeNullableSingleMediumValue_304() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65548,7 +65672,7 @@ class TestCluster : public TestCommand chip::app::DataModel::Nullable nullableFloatSingleArgument; nullableFloatSingleArgument.SetNonNull(); - nullableFloatSingleArgument.Value() = INFINITY; + nullableFloatSingleArgument.Value() = 0.1f; ReturnErrorOnFailure(cluster.WriteAttribute( nullableFloatSingleArgument, this, OnSuccessCallback_304, OnFailureCallback_304)); @@ -65563,7 +65687,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_304() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingleLargestValue_305() + CHIP_ERROR TestReadAttributeNullableSingleMediumValue_305() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65583,12 +65707,12 @@ class TestCluster : public TestCommand void OnSuccessResponse_305(const chip::app::DataModel::Nullable & nullableFloatSingle) { VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); - VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), INFINITY)); + VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), 0.1f)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingleSmallestValue_306() + CHIP_ERROR TestWriteAttributeNullableSingleLargestValue_306() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65596,7 +65720,7 @@ class TestCluster : public TestCommand chip::app::DataModel::Nullable nullableFloatSingleArgument; nullableFloatSingleArgument.SetNonNull(); - nullableFloatSingleArgument.Value() = -INFINITY; + nullableFloatSingleArgument.Value() = INFINITY; ReturnErrorOnFailure(cluster.WriteAttribute( nullableFloatSingleArgument, this, OnSuccessCallback_306, OnFailureCallback_306)); @@ -65611,7 +65735,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_306() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingleSmallestValue_307() + CHIP_ERROR TestReadAttributeNullableSingleLargestValue_307() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65631,19 +65755,20 @@ class TestCluster : public TestCommand void OnSuccessResponse_307(const chip::app::DataModel::Nullable & nullableFloatSingle) { VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); - VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), -INFINITY)); + VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), INFINITY)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingleNullValue_308() + CHIP_ERROR TestWriteAttributeNullableSingleSmallestValue_308() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); chip::app::DataModel::Nullable nullableFloatSingleArgument; - nullableFloatSingleArgument.SetNull(); + nullableFloatSingleArgument.SetNonNull(); + nullableFloatSingleArgument.Value() = -INFINITY; ReturnErrorOnFailure(cluster.WriteAttribute( nullableFloatSingleArgument, this, OnSuccessCallback_308, OnFailureCallback_308)); @@ -65658,7 +65783,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_308() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingleNullValue_309() + CHIP_ERROR TestReadAttributeNullableSingleSmallestValue_309() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65677,20 +65802,20 @@ class TestCluster : public TestCommand void OnSuccessResponse_309(const chip::app::DataModel::Nullable & nullableFloatSingle) { - VerifyOrReturn(CheckValueNull("nullableFloatSingle", nullableFloatSingle)); + VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); + VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), -INFINITY)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSingle0Value_310() + CHIP_ERROR TestWriteAttributeNullableSingleNullValue_310() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); chip::app::DataModel::Nullable nullableFloatSingleArgument; - nullableFloatSingleArgument.SetNonNull(); - nullableFloatSingleArgument.Value() = 0.0f; + nullableFloatSingleArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( nullableFloatSingleArgument, this, OnSuccessCallback_310, OnFailureCallback_310)); @@ -65705,7 +65830,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_310() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSingle0Value_311() + CHIP_ERROR TestReadAttributeNullableSingleNullValue_311() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65724,24 +65849,23 @@ class TestCluster : public TestCommand void OnSuccessResponse_311(const chip::app::DataModel::Nullable & nullableFloatSingle) { - VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); - VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), 0.0f)); + VerifyOrReturn(CheckValueNull("nullableFloatSingle", nullableFloatSingle)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDoubleMediumValue_312() + CHIP_ERROR TestWriteAttributeNullableSingle0Value_312() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - chip::app::DataModel::Nullable nullableFloatDoubleArgument; - nullableFloatDoubleArgument.SetNonNull(); - nullableFloatDoubleArgument.Value() = 0.1234567890123; + chip::app::DataModel::Nullable nullableFloatSingleArgument; + nullableFloatSingleArgument.SetNonNull(); + nullableFloatSingleArgument.Value() = 0.0f; - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableFloatDoubleArgument, this, OnSuccessCallback_312, OnFailureCallback_312)); + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableFloatSingleArgument, this, OnSuccessCallback_312, OnFailureCallback_312)); return CHIP_NO_ERROR; } @@ -65753,13 +65877,13 @@ class TestCluster : public TestCommand void OnSuccessResponse_312() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDoubleMediumValue_313() + CHIP_ERROR TestReadAttributeNullableSingle0Value_313() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - ReturnErrorOnFailure(cluster.ReadAttribute( + ReturnErrorOnFailure(cluster.ReadAttribute( this, OnSuccessCallback_313, OnFailureCallback_313)); return CHIP_NO_ERROR; } @@ -65770,15 +65894,15 @@ class TestCluster : public TestCommand ThrowFailureResponse(); } - void OnSuccessResponse_313(const chip::app::DataModel::Nullable & nullableFloatDouble) + void OnSuccessResponse_313(const chip::app::DataModel::Nullable & nullableFloatSingle) { - VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); - VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), 0.1234567890123)); + VerifyOrReturn(CheckValueNonNull("nullableFloatSingle", nullableFloatSingle)); + VerifyOrReturn(CheckValue("nullableFloatSingle.Value()", nullableFloatSingle.Value(), 0.0f)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDoubleLargestValue_314() + CHIP_ERROR TestWriteAttributeNullableDoubleMediumValue_314() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65786,7 +65910,7 @@ class TestCluster : public TestCommand chip::app::DataModel::Nullable nullableFloatDoubleArgument; nullableFloatDoubleArgument.SetNonNull(); - nullableFloatDoubleArgument.Value() = INFINITY; + nullableFloatDoubleArgument.Value() = 0.1234567890123; ReturnErrorOnFailure(cluster.WriteAttribute( nullableFloatDoubleArgument, this, OnSuccessCallback_314, OnFailureCallback_314)); @@ -65801,7 +65925,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_314() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDoubleLargestValue_315() + CHIP_ERROR TestReadAttributeNullableDoubleMediumValue_315() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65821,12 +65945,12 @@ class TestCluster : public TestCommand void OnSuccessResponse_315(const chip::app::DataModel::Nullable & nullableFloatDouble) { VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); - VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), INFINITY)); + VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), 0.1234567890123)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDoubleSmallestValue_316() + CHIP_ERROR TestWriteAttributeNullableDoubleLargestValue_316() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65834,7 +65958,7 @@ class TestCluster : public TestCommand chip::app::DataModel::Nullable nullableFloatDoubleArgument; nullableFloatDoubleArgument.SetNonNull(); - nullableFloatDoubleArgument.Value() = -INFINITY; + nullableFloatDoubleArgument.Value() = INFINITY; ReturnErrorOnFailure(cluster.WriteAttribute( nullableFloatDoubleArgument, this, OnSuccessCallback_316, OnFailureCallback_316)); @@ -65849,7 +65973,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_316() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDoubleSmallestValue_317() + CHIP_ERROR TestReadAttributeNullableDoubleLargestValue_317() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65869,19 +65993,20 @@ class TestCluster : public TestCommand void OnSuccessResponse_317(const chip::app::DataModel::Nullable & nullableFloatDouble) { VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); - VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), -INFINITY)); + VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), INFINITY)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDoubleNullValue_318() + CHIP_ERROR TestWriteAttributeNullableDoubleSmallestValue_318() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); chip::app::DataModel::Nullable nullableFloatDoubleArgument; - nullableFloatDoubleArgument.SetNull(); + nullableFloatDoubleArgument.SetNonNull(); + nullableFloatDoubleArgument.Value() = -INFINITY; ReturnErrorOnFailure(cluster.WriteAttribute( nullableFloatDoubleArgument, this, OnSuccessCallback_318, OnFailureCallback_318)); @@ -65896,7 +66021,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_318() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDoubleNullValue_319() + CHIP_ERROR TestReadAttributeNullableDoubleSmallestValue_319() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65915,20 +66040,20 @@ class TestCluster : public TestCommand void OnSuccessResponse_319(const chip::app::DataModel::Nullable & nullableFloatDouble) { - VerifyOrReturn(CheckValueNull("nullableFloatDouble", nullableFloatDouble)); + VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); + VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), -INFINITY)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableDouble0Value_320() + CHIP_ERROR TestWriteAttributeNullableDoubleNullValue_320() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); chip::app::DataModel::Nullable nullableFloatDoubleArgument; - nullableFloatDoubleArgument.SetNonNull(); - nullableFloatDoubleArgument.Value() = 0; + nullableFloatDoubleArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( nullableFloatDoubleArgument, this, OnSuccessCallback_320, OnFailureCallback_320)); @@ -65943,7 +66068,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_320() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableDouble0Value_321() + CHIP_ERROR TestReadAttributeNullableDoubleNullValue_321() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -65962,24 +66087,23 @@ class TestCluster : public TestCommand void OnSuccessResponse_321(const chip::app::DataModel::Nullable & nullableFloatDouble) { - VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); - VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), 0)); + VerifyOrReturn(CheckValueNull("nullableFloatDouble", nullableFloatDouble)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8MinValue_322() + CHIP_ERROR TestWriteAttributeNullableDouble0Value_322() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - chip::app::DataModel::Nullable nullableEnum8Argument; - nullableEnum8Argument.SetNonNull(); - nullableEnum8Argument.Value() = 0; + chip::app::DataModel::Nullable nullableFloatDoubleArgument; + nullableFloatDoubleArgument.SetNonNull(); + nullableFloatDoubleArgument.Value() = 0; - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum8Argument, this, OnSuccessCallback_322, OnFailureCallback_322)); + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableFloatDoubleArgument, this, OnSuccessCallback_322, OnFailureCallback_322)); return CHIP_NO_ERROR; } @@ -65991,13 +66115,13 @@ class TestCluster : public TestCommand void OnSuccessResponse_322() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum8MinValue_323() + CHIP_ERROR TestReadAttributeNullableDouble0Value_323() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - ReturnErrorOnFailure(cluster.ReadAttribute( + ReturnErrorOnFailure(cluster.ReadAttribute( this, OnSuccessCallback_323, OnFailureCallback_323)); return CHIP_NO_ERROR; } @@ -66008,15 +66132,15 @@ class TestCluster : public TestCommand ThrowFailureResponse(); } - void OnSuccessResponse_323(const chip::app::DataModel::Nullable & nullableEnum8) + void OnSuccessResponse_323(const chip::app::DataModel::Nullable & nullableFloatDouble) { - VerifyOrReturn(CheckValueNonNull("nullableEnum8", nullableEnum8)); - VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 0)); + VerifyOrReturn(CheckValueNonNull("nullableFloatDouble", nullableFloatDouble)); + VerifyOrReturn(CheckValue("nullableFloatDouble.Value()", nullableFloatDouble.Value(), 0)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8MaxValue_324() + CHIP_ERROR TestWriteAttributeNullableEnum8MinValue_324() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66024,7 +66148,7 @@ class TestCluster : public TestCommand chip::app::DataModel::Nullable nullableEnum8Argument; nullableEnum8Argument.SetNonNull(); - nullableEnum8Argument.Value() = 254; + nullableEnum8Argument.Value() = 0; ReturnErrorOnFailure(cluster.WriteAttribute( nullableEnum8Argument, this, OnSuccessCallback_324, OnFailureCallback_324)); @@ -66039,7 +66163,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_324() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum8MaxValue_325() + CHIP_ERROR TestReadAttributeNullableEnum8MinValue_325() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66059,12 +66183,12 @@ class TestCluster : public TestCommand void OnSuccessResponse_325(const chip::app::DataModel::Nullable & nullableEnum8) { VerifyOrReturn(CheckValueNonNull("nullableEnum8", nullableEnum8)); - VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 254)); + VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 0)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8InvalidValue_326() + CHIP_ERROR TestWriteAttributeNullableEnum8MaxValue_326() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66072,7 +66196,7 @@ class TestCluster : public TestCommand chip::app::DataModel::Nullable nullableEnum8Argument; nullableEnum8Argument.SetNonNull(); - nullableEnum8Argument.Value() = 255; + nullableEnum8Argument.Value() = 254; ReturnErrorOnFailure(cluster.WriteAttribute( nullableEnum8Argument, this, OnSuccessCallback_326, OnFailureCallback_326)); @@ -66082,13 +66206,12 @@ class TestCluster : public TestCommand void OnFailureResponse_326(CHIP_ERROR error) { chip::app::StatusIB status(error); - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); - NextTest(); + ThrowFailureResponse(); } - void OnSuccessResponse_326() { ThrowSuccessResponse(); } + void OnSuccessResponse_326() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum8UnchangedValue_327() + CHIP_ERROR TestReadAttributeNullableEnum8MaxValue_327() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66113,14 +66236,15 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum8NullValue_328() + CHIP_ERROR TestWriteAttributeNullableEnum8InvalidValue_328() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); chip::app::DataModel::Nullable nullableEnum8Argument; - nullableEnum8Argument.SetNull(); + nullableEnum8Argument.SetNonNull(); + nullableEnum8Argument.Value() = 255; ReturnErrorOnFailure(cluster.WriteAttribute( nullableEnum8Argument, this, OnSuccessCallback_328, OnFailureCallback_328)); @@ -66130,12 +66254,13 @@ class TestCluster : public TestCommand void OnFailureResponse_328(CHIP_ERROR error) { chip::app::StatusIB status(error); - ThrowFailureResponse(); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + NextTest(); } - void OnSuccessResponse_328() { NextTest(); } + void OnSuccessResponse_328() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableEnum8NullValue_329() + CHIP_ERROR TestReadAttributeNullableEnum8UnchangedValue_329() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66154,23 +66279,23 @@ class TestCluster : public TestCommand void OnSuccessResponse_329(const chip::app::DataModel::Nullable & nullableEnum8) { - VerifyOrReturn(CheckValueNull("nullableEnum8", nullableEnum8)); + VerifyOrReturn(CheckValueNonNull("nullableEnum8", nullableEnum8)); + VerifyOrReturn(CheckValue("nullableEnum8.Value()", nullableEnum8.Value(), 254)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16MinValue_330() + CHIP_ERROR TestWriteAttributeNullableEnum8NullValue_330() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - chip::app::DataModel::Nullable nullableEnum16Argument; - nullableEnum16Argument.SetNonNull(); - nullableEnum16Argument.Value() = 0U; + chip::app::DataModel::Nullable nullableEnum8Argument; + nullableEnum8Argument.SetNull(); - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnum16Argument, this, OnSuccessCallback_330, OnFailureCallback_330)); + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableEnum8Argument, this, OnSuccessCallback_330, OnFailureCallback_330)); return CHIP_NO_ERROR; } @@ -66182,13 +66307,13 @@ class TestCluster : public TestCommand void OnSuccessResponse_330() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum16MinValue_331() + CHIP_ERROR TestReadAttributeNullableEnum8NullValue_331() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - ReturnErrorOnFailure(cluster.ReadAttribute( + ReturnErrorOnFailure(cluster.ReadAttribute( this, OnSuccessCallback_331, OnFailureCallback_331)); return CHIP_NO_ERROR; } @@ -66199,15 +66324,14 @@ class TestCluster : public TestCommand ThrowFailureResponse(); } - void OnSuccessResponse_331(const chip::app::DataModel::Nullable & nullableEnum16) + void OnSuccessResponse_331(const chip::app::DataModel::Nullable & nullableEnum8) { - VerifyOrReturn(CheckValueNonNull("nullableEnum16", nullableEnum16)); - VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 0U)); + VerifyOrReturn(CheckValueNull("nullableEnum8", nullableEnum8)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16MaxValue_332() + CHIP_ERROR TestWriteAttributeNullableEnum16MinValue_332() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66215,7 +66339,7 @@ class TestCluster : public TestCommand chip::app::DataModel::Nullable nullableEnum16Argument; nullableEnum16Argument.SetNonNull(); - nullableEnum16Argument.Value() = 65534U; + nullableEnum16Argument.Value() = 0U; ReturnErrorOnFailure(cluster.WriteAttribute( nullableEnum16Argument, this, OnSuccessCallback_332, OnFailureCallback_332)); @@ -66230,7 +66354,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_332() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum16MaxValue_333() + CHIP_ERROR TestReadAttributeNullableEnum16MinValue_333() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66250,12 +66374,12 @@ class TestCluster : public TestCommand void OnSuccessResponse_333(const chip::app::DataModel::Nullable & nullableEnum16) { VerifyOrReturn(CheckValueNonNull("nullableEnum16", nullableEnum16)); - VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 65534U)); + VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 0U)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16InvalidValue_334() + CHIP_ERROR TestWriteAttributeNullableEnum16MaxValue_334() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66263,7 +66387,7 @@ class TestCluster : public TestCommand chip::app::DataModel::Nullable nullableEnum16Argument; nullableEnum16Argument.SetNonNull(); - nullableEnum16Argument.Value() = 65535U; + nullableEnum16Argument.Value() = 65534U; ReturnErrorOnFailure(cluster.WriteAttribute( nullableEnum16Argument, this, OnSuccessCallback_334, OnFailureCallback_334)); @@ -66273,13 +66397,12 @@ class TestCluster : public TestCommand void OnFailureResponse_334(CHIP_ERROR error) { chip::app::StatusIB status(error); - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); - NextTest(); + ThrowFailureResponse(); } - void OnSuccessResponse_334() { ThrowSuccessResponse(); } + void OnSuccessResponse_334() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableEnum16UnchangedValue_335() + CHIP_ERROR TestReadAttributeNullableEnum16MaxValue_335() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66304,14 +66427,15 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableEnum16NullValue_336() + CHIP_ERROR TestWriteAttributeNullableEnum16InvalidValue_336() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); chip::app::DataModel::Nullable nullableEnum16Argument; - nullableEnum16Argument.SetNull(); + nullableEnum16Argument.SetNonNull(); + nullableEnum16Argument.Value() = 65535U; ReturnErrorOnFailure(cluster.WriteAttribute( nullableEnum16Argument, this, OnSuccessCallback_336, OnFailureCallback_336)); @@ -66321,12 +66445,13 @@ class TestCluster : public TestCommand void OnFailureResponse_336(CHIP_ERROR error) { chip::app::StatusIB status(error); - ThrowFailureResponse(); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + NextTest(); } - void OnSuccessResponse_336() { NextTest(); } + void OnSuccessResponse_336() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableEnum16NullValue_337() + CHIP_ERROR TestReadAttributeNullableEnum16UnchangedValue_337() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66345,23 +66470,23 @@ class TestCluster : public TestCommand void OnSuccessResponse_337(const chip::app::DataModel::Nullable & nullableEnum16) { - VerifyOrReturn(CheckValueNull("nullableEnum16", nullableEnum16)); + VerifyOrReturn(CheckValueNonNull("nullableEnum16", nullableEnum16)); + VerifyOrReturn(CheckValue("nullableEnum16.Value()", nullableEnum16.Value(), 65534U)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSimpleEnumMinValue_338() + CHIP_ERROR TestWriteAttributeNullableEnum16NullValue_338() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - chip::app::DataModel::Nullable nullableEnumAttrArgument; - nullableEnumAttrArgument.SetNonNull(); - nullableEnumAttrArgument.Value() = static_cast(0); + chip::app::DataModel::Nullable nullableEnum16Argument; + nullableEnum16Argument.SetNull(); - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableEnumAttrArgument, this, OnSuccessCallback_338, OnFailureCallback_338)); + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableEnum16Argument, this, OnSuccessCallback_338, OnFailureCallback_338)); return CHIP_NO_ERROR; } @@ -66373,13 +66498,13 @@ class TestCluster : public TestCommand void OnSuccessResponse_338() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSimpleEnumMinValue_339() + CHIP_ERROR TestReadAttributeNullableEnum16NullValue_339() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - ReturnErrorOnFailure(cluster.ReadAttribute( + ReturnErrorOnFailure(cluster.ReadAttribute( this, OnSuccessCallback_339, OnFailureCallback_339)); return CHIP_NO_ERROR; } @@ -66390,16 +66515,14 @@ class TestCluster : public TestCommand ThrowFailureResponse(); } - void - OnSuccessResponse_339(const chip::app::DataModel::Nullable & nullableEnumAttr) + void OnSuccessResponse_339(const chip::app::DataModel::Nullable & nullableEnum16) { - VerifyOrReturn(CheckValueNonNull("nullableEnumAttr", nullableEnumAttr)); - VerifyOrReturn(CheckValue("nullableEnumAttr.Value()", nullableEnumAttr.Value(), 0)); + VerifyOrReturn(CheckValueNull("nullableEnum16", nullableEnum16)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSimpleEnumMaxValue_340() + CHIP_ERROR TestWriteAttributeNullableSimpleEnumMinValue_340() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66407,7 +66530,7 @@ class TestCluster : public TestCommand chip::app::DataModel::Nullable nullableEnumAttrArgument; nullableEnumAttrArgument.SetNonNull(); - nullableEnumAttrArgument.Value() = static_cast(254); + nullableEnumAttrArgument.Value() = static_cast(0); ReturnErrorOnFailure(cluster.WriteAttribute( nullableEnumAttrArgument, this, OnSuccessCallback_340, OnFailureCallback_340)); @@ -66422,7 +66545,7 @@ class TestCluster : public TestCommand void OnSuccessResponse_340() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSimpleEnumMaxValue_341() + CHIP_ERROR TestReadAttributeNullableSimpleEnumMinValue_341() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66443,12 +66566,12 @@ class TestCluster : public TestCommand OnSuccessResponse_341(const chip::app::DataModel::Nullable & nullableEnumAttr) { VerifyOrReturn(CheckValueNonNull("nullableEnumAttr", nullableEnumAttr)); - VerifyOrReturn(CheckValue("nullableEnumAttr.Value()", nullableEnumAttr.Value(), 254)); + VerifyOrReturn(CheckValue("nullableEnumAttr.Value()", nullableEnumAttr.Value(), 0)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSimpleEnumInvalidValue_342() + CHIP_ERROR TestWriteAttributeNullableSimpleEnumMaxValue_342() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66456,7 +66579,7 @@ class TestCluster : public TestCommand chip::app::DataModel::Nullable nullableEnumAttrArgument; nullableEnumAttrArgument.SetNonNull(); - nullableEnumAttrArgument.Value() = static_cast(255); + nullableEnumAttrArgument.Value() = static_cast(254); ReturnErrorOnFailure(cluster.WriteAttribute( nullableEnumAttrArgument, this, OnSuccessCallback_342, OnFailureCallback_342)); @@ -66466,13 +66589,12 @@ class TestCluster : public TestCommand void OnFailureResponse_342(CHIP_ERROR error) { chip::app::StatusIB status(error); - VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); - NextTest(); + ThrowFailureResponse(); } - void OnSuccessResponse_342() { ThrowSuccessResponse(); } + void OnSuccessResponse_342() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableSimpleEnumUnchangedValue_343() + CHIP_ERROR TestReadAttributeNullableSimpleEnumMaxValue_343() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66498,14 +66620,15 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableSimpleEnumNullValue_344() + CHIP_ERROR TestWriteAttributeNullableSimpleEnumInvalidValue_344() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); chip::app::DataModel::Nullable nullableEnumAttrArgument; - nullableEnumAttrArgument.SetNull(); + nullableEnumAttrArgument.SetNonNull(); + nullableEnumAttrArgument.Value() = static_cast(255); ReturnErrorOnFailure(cluster.WriteAttribute( nullableEnumAttrArgument, this, OnSuccessCallback_344, OnFailureCallback_344)); @@ -66515,12 +66638,13 @@ class TestCluster : public TestCommand void OnFailureResponse_344(CHIP_ERROR error) { chip::app::StatusIB status(error); - ThrowFailureResponse(); + VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); + NextTest(); } - void OnSuccessResponse_344() { NextTest(); } + void OnSuccessResponse_344() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeNullableSimpleEnumNullValue_345() + CHIP_ERROR TestReadAttributeNullableSimpleEnumUnchangedValue_345() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66540,19 +66664,23 @@ class TestCluster : public TestCommand void OnSuccessResponse_345(const chip::app::DataModel::Nullable & nullableEnumAttr) { - VerifyOrReturn(CheckValueNull("nullableEnumAttr", nullableEnumAttr)); + VerifyOrReturn(CheckValueNonNull("nullableEnumAttr", nullableEnumAttr)); + VerifyOrReturn(CheckValue("nullableEnumAttr.Value()", nullableEnumAttr.Value(), 254)); NextTest(); } - CHIP_ERROR TestReadAttributeNullableOctetStringDefaultValue_346() + CHIP_ERROR TestWriteAttributeNullableSimpleEnumNullValue_346() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_346, OnFailureCallback_346)); + chip::app::DataModel::Nullable nullableEnumAttrArgument; + nullableEnumAttrArgument.SetNull(); + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableEnumAttrArgument, this, OnSuccessCallback_346, OnFailureCallback_346)); return CHIP_NO_ERROR; } @@ -66562,28 +66690,16 @@ class TestCluster : public TestCommand ThrowFailureResponse(); } - void OnSuccessResponse_346(const chip::app::DataModel::Nullable & nullableOctetString) - { - VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); - VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), - chip::ByteSpan(chip::Uint8::from_const_char(""), 0))); + void OnSuccessResponse_346() { NextTest(); } - NextTest(); - } - - CHIP_ERROR TestWriteAttributeNullableOctetString_347() + CHIP_ERROR TestReadAttributeNullableSimpleEnumNullValue_347() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - chip::app::DataModel::Nullable nullableOctetStringArgument; - nullableOctetStringArgument.SetNonNull(); - nullableOctetStringArgument.Value() = - chip::ByteSpan(chip::Uint8::from_const_char("TestValuegarbage: not in length on purpose"), 9); - - ReturnErrorOnFailure(cluster.WriteAttribute( - nullableOctetStringArgument, this, OnSuccessCallback_347, OnFailureCallback_347)); + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_347, OnFailureCallback_347)); return CHIP_NO_ERROR; } @@ -66593,9 +66709,15 @@ class TestCluster : public TestCommand ThrowFailureResponse(); } - void OnSuccessResponse_347() { NextTest(); } + void + OnSuccessResponse_347(const chip::app::DataModel::Nullable & nullableEnumAttr) + { + VerifyOrReturn(CheckValueNull("nullableEnumAttr", nullableEnumAttr)); + + NextTest(); + } - CHIP_ERROR TestReadAttributeNullableOctetString_348() + CHIP_ERROR TestReadAttributeNullableOctetStringDefaultValue_348() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66616,7 +66738,7 @@ class TestCluster : public TestCommand { VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), - chip::ByteSpan(chip::Uint8::from_const_char("TestValue"), 9))); + chip::ByteSpan(chip::Uint8::from_const_char(""), 0))); NextTest(); } @@ -66628,7 +66750,9 @@ class TestCluster : public TestCommand cluster.Associate(mDevices[kIdentityAlpha], endpoint); chip::app::DataModel::Nullable nullableOctetStringArgument; - nullableOctetStringArgument.SetNull(); + nullableOctetStringArgument.SetNonNull(); + nullableOctetStringArgument.Value() = + chip::ByteSpan(chip::Uint8::from_const_char("TestValuegarbage: not in length on purpose"), 9); ReturnErrorOnFailure(cluster.WriteAttribute( nullableOctetStringArgument, this, OnSuccessCallback_349, OnFailureCallback_349)); @@ -66662,7 +66786,9 @@ class TestCluster : public TestCommand void OnSuccessResponse_350(const chip::app::DataModel::Nullable & nullableOctetString) { - VerifyOrReturn(CheckValueNull("nullableOctetString", nullableOctetString)); + VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); + VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), + chip::ByteSpan(chip::Uint8::from_const_char("TestValue"), 9))); NextTest(); } @@ -66674,8 +66800,7 @@ class TestCluster : public TestCommand cluster.Associate(mDevices[kIdentityAlpha], endpoint); chip::app::DataModel::Nullable nullableOctetStringArgument; - nullableOctetStringArgument.SetNonNull(); - nullableOctetStringArgument.Value() = chip::ByteSpan(chip::Uint8::from_const_char("garbage: not in length on purpose"), 0); + nullableOctetStringArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( nullableOctetStringArgument, this, OnSuccessCallback_351, OnFailureCallback_351)); @@ -66708,6 +66833,53 @@ class TestCluster : public TestCommand } void OnSuccessResponse_352(const chip::app::DataModel::Nullable & nullableOctetString) + { + VerifyOrReturn(CheckValueNull("nullableOctetString", nullableOctetString)); + + NextTest(); + } + + CHIP_ERROR TestWriteAttributeNullableOctetString_353() + { + const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + chip::app::DataModel::Nullable nullableOctetStringArgument; + nullableOctetStringArgument.SetNonNull(); + nullableOctetStringArgument.Value() = chip::ByteSpan(chip::Uint8::from_const_char("garbage: not in length on purpose"), 0); + + ReturnErrorOnFailure(cluster.WriteAttribute( + nullableOctetStringArgument, this, OnSuccessCallback_353, OnFailureCallback_353)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_353(CHIP_ERROR error) + { + chip::app::StatusIB status(error); + ThrowFailureResponse(); + } + + void OnSuccessResponse_353() { NextTest(); } + + CHIP_ERROR TestReadAttributeNullableOctetString_354() + { + const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; + chip::Controller::TestClusterClusterTest cluster; + cluster.Associate(mDevices[kIdentityAlpha], endpoint); + + ReturnErrorOnFailure(cluster.ReadAttribute( + this, OnSuccessCallback_354, OnFailureCallback_354)); + return CHIP_NO_ERROR; + } + + void OnFailureResponse_354(CHIP_ERROR error) + { + chip::app::StatusIB status(error); + ThrowFailureResponse(); + } + + void OnSuccessResponse_354(const chip::app::DataModel::Nullable & nullableOctetString) { VerifyOrReturn(CheckValueNonNull("nullableOctetString", nullableOctetString)); VerifyOrReturn(CheckValueAsString("nullableOctetString.Value()", nullableOctetString.Value(), @@ -66716,24 +66888,24 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharStringDefaultValue_353() + CHIP_ERROR TestReadAttributeNullableCharStringDefaultValue_355() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_353, OnFailureCallback_353)); + this, OnSuccessCallback_355, OnFailureCallback_355)); return CHIP_NO_ERROR; } - void OnFailureResponse_353(CHIP_ERROR error) + void OnFailureResponse_355(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_353(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_355(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNonNull("nullableCharString", nullableCharString)); VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", nullableCharString.Value(), chip::CharSpan("", 0))); @@ -66741,7 +66913,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableCharString_354() + CHIP_ERROR TestWriteAttributeNullableCharString_356() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66752,36 +66924,36 @@ class TestCluster : public TestCommand nullableCharStringArgument.Value() = chip::Span("☉T☉garbage: not in length on purpose", 7); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableCharStringArgument, this, OnSuccessCallback_354, OnFailureCallback_354)); + nullableCharStringArgument, this, OnSuccessCallback_356, OnFailureCallback_356)); return CHIP_NO_ERROR; } - void OnFailureResponse_354(CHIP_ERROR error) + void OnFailureResponse_356(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_354() { NextTest(); } + void OnSuccessResponse_356() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharString_355() + CHIP_ERROR TestReadAttributeNullableCharString_357() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_355, OnFailureCallback_355)); + this, OnSuccessCallback_357, OnFailureCallback_357)); return CHIP_NO_ERROR; } - void OnFailureResponse_355(CHIP_ERROR error) + void OnFailureResponse_357(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_355(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_357(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNonNull("nullableCharString", nullableCharString)); VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", nullableCharString.Value(), chip::CharSpan("☉T☉", 7))); @@ -66789,7 +66961,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteAttributeNullableCharStringValueTooLong_356() + CHIP_ERROR TestWriteAttributeNullableCharStringValueTooLong_358() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66799,43 +66971,43 @@ class TestCluster : public TestCommand nullableCharStringArgument.SetNull(); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableCharStringArgument, this, OnSuccessCallback_356, OnFailureCallback_356)); + nullableCharStringArgument, this, OnSuccessCallback_358, OnFailureCallback_358)); return CHIP_NO_ERROR; } - void OnFailureResponse_356(CHIP_ERROR error) + void OnFailureResponse_358(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_356() { NextTest(); } + void OnSuccessResponse_358() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharString_357() + CHIP_ERROR TestReadAttributeNullableCharString_359() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_357, OnFailureCallback_357)); + this, OnSuccessCallback_359, OnFailureCallback_359)); return CHIP_NO_ERROR; } - void OnFailureResponse_357(CHIP_ERROR error) + void OnFailureResponse_359(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_357(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_359(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNull("nullableCharString", nullableCharString)); NextTest(); } - CHIP_ERROR TestWriteAttributeNullableCharStringEmpty_358() + CHIP_ERROR TestWriteAttributeNullableCharStringEmpty_360() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -66846,36 +67018,36 @@ class TestCluster : public TestCommand nullableCharStringArgument.Value() = chip::Span("garbage: not in length on purpose", 0); ReturnErrorOnFailure(cluster.WriteAttribute( - nullableCharStringArgument, this, OnSuccessCallback_358, OnFailureCallback_358)); + nullableCharStringArgument, this, OnSuccessCallback_360, OnFailureCallback_360)); return CHIP_NO_ERROR; } - void OnFailureResponse_358(CHIP_ERROR error) + void OnFailureResponse_360(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_358() { NextTest(); } + void OnSuccessResponse_360() { NextTest(); } - CHIP_ERROR TestReadAttributeNullableCharString_359() + CHIP_ERROR TestReadAttributeNullableCharString_361() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_359, OnFailureCallback_359)); + this, OnSuccessCallback_361, OnFailureCallback_361)); return CHIP_NO_ERROR; } - void OnFailureResponse_359(CHIP_ERROR error) + void OnFailureResponse_361(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_359(const chip::app::DataModel::Nullable & nullableCharString) + void OnSuccessResponse_361(const chip::app::DataModel::Nullable & nullableCharString) { VerifyOrReturn(CheckValueNonNull("nullableCharString", nullableCharString)); VerifyOrReturn(CheckValueAsString("nullableCharString.Value()", nullableCharString.Value(), chip::CharSpan("", 0))); @@ -66883,47 +67055,47 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadAttributeFromNonexistentEndpoint_360() + CHIP_ERROR TestReadAttributeFromNonexistentEndpoint_362() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 200; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_360, OnFailureCallback_360)); + this, OnSuccessCallback_362, OnFailureCallback_362)); return CHIP_NO_ERROR; } - void OnFailureResponse_360(CHIP_ERROR error) + void OnFailureResponse_362(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_UNSUPPORTED_ENDPOINT)); NextTest(); } - void OnSuccessResponse_360(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } + void OnSuccessResponse_362(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeFromNonexistentCluster_361() + CHIP_ERROR TestReadAttributeFromNonexistentCluster_363() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 0; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_361, OnFailureCallback_361)); + this, OnSuccessCallback_363, OnFailureCallback_363)); return CHIP_NO_ERROR; } - void OnFailureResponse_361(CHIP_ERROR error) + void OnFailureResponse_363(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_UNSUPPORTED_CLUSTER)); NextTest(); } - void OnSuccessResponse_361(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } + void OnSuccessResponse_363(const chip::app::DataModel::DecodableList & listInt8u) { ThrowSuccessResponse(); } - CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_362() + CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_364() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestSimpleOptionalArgumentRequest::Type; @@ -66931,27 +67103,27 @@ class TestCluster : public TestCommand RequestType request; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_362(); + (static_cast(context))->OnSuccessResponse_364(); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_362(error); + (static_cast(context))->OnFailureResponse_364(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_362(CHIP_ERROR error) + void OnFailureResponse_364(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_INVALID_VALUE)); NextTest(); } - void OnSuccessResponse_362() { ThrowSuccessResponse(); } + void OnSuccessResponse_364() { ThrowSuccessResponse(); } - CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_363() + CHIP_ERROR TestSendACommandThatTakesAnOptionalParameterButDoNotSetIt_365() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; using RequestType = chip::app::Clusters::TestCluster::Commands::TestSimpleOptionalArgumentRequest::Type; @@ -66961,44 +67133,44 @@ class TestCluster : public TestCommand request.arg1.Value() = 1; auto success = [](void * context, const typename RequestType::ResponseType & data) { - (static_cast(context))->OnSuccessResponse_363(); + (static_cast(context))->OnSuccessResponse_365(); }; auto failure = [](void * context, CHIP_ERROR error) { - (static_cast(context))->OnFailureResponse_363(error); + (static_cast(context))->OnFailureResponse_365(error); }; ReturnErrorOnFailure(chip::Controller::InvokeCommand(mDevices[kIdentityAlpha], this, success, failure, endpoint, request)); return CHIP_NO_ERROR; } - void OnFailureResponse_363(CHIP_ERROR error) + void OnFailureResponse_365(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_363() { NextTest(); } + void OnSuccessResponse_365() { NextTest(); } - CHIP_ERROR TestReportSubscribeToListAttribute_364() + CHIP_ERROR TestReportSubscribeToListAttribute_366() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - mTest_TestCluster_list_int8u_Reported = OnSuccessCallback_364; + mTest_TestCluster_list_int8u_Reported = OnSuccessCallback_366; return WaitForMs(0); } - void OnFailureResponse_364(CHIP_ERROR error) + void OnFailureResponse_366(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_364(const chip::app::DataModel::DecodableList & listInt8u) + void OnSuccessResponse_366(const chip::app::DataModel::DecodableList & listInt8u) { - mReceivedReport_364 = true; + mReceivedReport_366 = true; { auto iter_0 = listInt8u.begin(); @@ -67014,7 +67186,7 @@ class TestCluster : public TestCommand } } - CHIP_ERROR TestSubscribeToListAttribute_365() + CHIP_ERROR TestSubscribeToListAttribute_367() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67026,18 +67198,18 @@ class TestCluster : public TestCommand maxIntervalArgument = 10U; ReturnErrorOnFailure(cluster.SubscribeAttribute( - this, OnSuccessCallback_365, OnFailureCallback_365, minIntervalArgument, maxIntervalArgument, - OnSubscriptionEstablished_365)); + this, OnSuccessCallback_367, OnFailureCallback_367, minIntervalArgument, maxIntervalArgument, + OnSubscriptionEstablished_367)); return CHIP_NO_ERROR; } - void OnFailureResponse_365(CHIP_ERROR error) + void OnFailureResponse_367(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_365(const chip::app::DataModel::DecodableList & value) + void OnSuccessResponse_367(const chip::app::DataModel::DecodableList & value) { if (mTest_TestCluster_list_int8u_Reported) { @@ -67047,13 +67219,13 @@ class TestCluster : public TestCommand } } - void OnSubscriptionEstablishedResponse_365() + void OnSubscriptionEstablishedResponse_367() { - VerifyOrReturn(mReceivedReport_364, Exit("Initial report not received!")); + VerifyOrReturn(mReceivedReport_366, Exit("Initial report not received!")); NextTest(); } - CHIP_ERROR TestWriteSubscribedToListAttribute_366() + CHIP_ERROR TestWriteSubscribedToListAttribute_368() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67069,37 +67241,37 @@ class TestCluster : public TestCommand listInt8uArgument = listInt8uList_0; ReturnErrorOnFailure(cluster.WriteAttribute( - listInt8uArgument, this, OnSuccessCallback_366, OnFailureCallback_366)); + listInt8uArgument, this, OnSuccessCallback_368, OnFailureCallback_368)); return CHIP_NO_ERROR; } - void OnFailureResponse_366(CHIP_ERROR error) + void OnFailureResponse_368(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_366() { NextTest(); } + void OnSuccessResponse_368() { NextTest(); } - CHIP_ERROR TestCheckForListAttributeReport_367() + CHIP_ERROR TestCheckForListAttributeReport_369() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); - mTest_TestCluster_list_int8u_Reported = OnSuccessCallback_367; + mTest_TestCluster_list_int8u_Reported = OnSuccessCallback_369; return CHIP_NO_ERROR; } - void OnFailureResponse_367(CHIP_ERROR error) + void OnFailureResponse_369(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_367(const chip::app::DataModel::DecodableList & listInt8u) + void OnSuccessResponse_369(const chip::app::DataModel::DecodableList & listInt8u) { - mReceivedReport_367 = true; + mReceivedReport_369 = true; { auto iter_0 = listInt8u.begin(); @@ -67117,31 +67289,31 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadRangeRestrictedUnsigned8BitInteger_368() + CHIP_ERROR TestReadRangeRestrictedUnsigned8BitInteger_370() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_368, OnFailureCallback_368)); + this, OnSuccessCallback_370, OnFailureCallback_370)); return CHIP_NO_ERROR; } - void OnFailureResponse_368(CHIP_ERROR error) + void OnFailureResponse_370(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_368(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_370(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 70)); NextTest(); } - CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_369() + CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned8BitInteger_371() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67151,20 +67323,20 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 0; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_369, OnFailureCallback_369)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_371, OnFailureCallback_371)); return CHIP_NO_ERROR; } - void OnFailureResponse_369(CHIP_ERROR error) + void OnFailureResponse_371(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_369() { ThrowSuccessResponse(); } + void OnSuccessResponse_371() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_370() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned8BitInteger_372() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67174,20 +67346,20 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 19; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_370, OnFailureCallback_370)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_372, OnFailureCallback_372)); return CHIP_NO_ERROR; } - void OnFailureResponse_370(CHIP_ERROR error) + void OnFailureResponse_372(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_370() { ThrowSuccessResponse(); } + void OnSuccessResponse_372() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_371() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned8BitInteger_373() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67197,20 +67369,20 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 101; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_371, OnFailureCallback_371)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_373, OnFailureCallback_373)); return CHIP_NO_ERROR; } - void OnFailureResponse_371(CHIP_ERROR error) + void OnFailureResponse_373(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_371() { ThrowSuccessResponse(); } + void OnSuccessResponse_373() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_372() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned8BitInteger_374() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67220,44 +67392,44 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 255; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_372, OnFailureCallback_372)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_374, OnFailureCallback_374)); return CHIP_NO_ERROR; } - void OnFailureResponse_372(CHIP_ERROR error) + void OnFailureResponse_374(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_372() { ThrowSuccessResponse(); } + void OnSuccessResponse_374() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_373() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_375() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_373, OnFailureCallback_373)); + this, OnSuccessCallback_375, OnFailureCallback_375)); return CHIP_NO_ERROR; } - void OnFailureResponse_373(CHIP_ERROR error) + void OnFailureResponse_375(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_373(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_375(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 70)); NextTest(); } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_374() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned8BitInteger_376() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67267,43 +67439,43 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 20; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_374, OnFailureCallback_374)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_376, OnFailureCallback_376)); return CHIP_NO_ERROR; } - void OnFailureResponse_374(CHIP_ERROR error) + void OnFailureResponse_376(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_374() { NextTest(); } + void OnSuccessResponse_376() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_375() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_377() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_375, OnFailureCallback_375)); + this, OnSuccessCallback_377, OnFailureCallback_377)); return CHIP_NO_ERROR; } - void OnFailureResponse_375(CHIP_ERROR error) + void OnFailureResponse_377(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_375(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_377(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 20)); NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_376() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned8BitInteger_378() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67313,43 +67485,43 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 100; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_376, OnFailureCallback_376)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_378, OnFailureCallback_378)); return CHIP_NO_ERROR; } - void OnFailureResponse_376(CHIP_ERROR error) + void OnFailureResponse_378(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_376() { NextTest(); } + void OnSuccessResponse_378() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_377() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_379() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_377, OnFailureCallback_377)); + this, OnSuccessCallback_379, OnFailureCallback_379)); return CHIP_NO_ERROR; } - void OnFailureResponse_377(CHIP_ERROR error) + void OnFailureResponse_379(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_377(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_379(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 100)); NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_378() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned8BitInteger_380() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67359,67 +67531,67 @@ class TestCluster : public TestCommand rangeRestrictedInt8uArgument = 50; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8uArgument, this, OnSuccessCallback_378, OnFailureCallback_378)); + rangeRestrictedInt8uArgument, this, OnSuccessCallback_380, OnFailureCallback_380)); return CHIP_NO_ERROR; } - void OnFailureResponse_378(CHIP_ERROR error) + void OnFailureResponse_380(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_378() { NextTest(); } + void OnSuccessResponse_380() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_379() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_381() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_379, OnFailureCallback_379)); + this, OnSuccessCallback_381, OnFailureCallback_381)); return CHIP_NO_ERROR; } - void OnFailureResponse_379(CHIP_ERROR error) + void OnFailureResponse_381(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_379(uint8_t rangeRestrictedInt8u) + void OnSuccessResponse_381(uint8_t rangeRestrictedInt8u) { VerifyOrReturn(CheckValue("rangeRestrictedInt8u", rangeRestrictedInt8u, 50)); NextTest(); } - CHIP_ERROR TestReadRangeRestrictedUnsigned16BitInteger_380() + CHIP_ERROR TestReadRangeRestrictedUnsigned16BitInteger_382() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_380, OnFailureCallback_380)); + this, OnSuccessCallback_382, OnFailureCallback_382)); return CHIP_NO_ERROR; } - void OnFailureResponse_380(CHIP_ERROR error) + void OnFailureResponse_382(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_380(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_382(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 200U)); NextTest(); } - CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_381() + CHIP_ERROR TestWriteMinValueToARangeRestrictedUnsigned16BitInteger_383() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67429,20 +67601,20 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 0U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_381, OnFailureCallback_381)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_383, OnFailureCallback_383)); return CHIP_NO_ERROR; } - void OnFailureResponse_381(CHIP_ERROR error) + void OnFailureResponse_383(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_381() { ThrowSuccessResponse(); } + void OnSuccessResponse_383() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_382() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedUnsigned16BitInteger_384() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67452,20 +67624,20 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 99U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_382, OnFailureCallback_382)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_384, OnFailureCallback_384)); return CHIP_NO_ERROR; } - void OnFailureResponse_382(CHIP_ERROR error) + void OnFailureResponse_384(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_382() { ThrowSuccessResponse(); } + void OnSuccessResponse_384() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_383() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedUnsigned16BitInteger_385() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67475,20 +67647,20 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 1001U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_383, OnFailureCallback_383)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_385, OnFailureCallback_385)); return CHIP_NO_ERROR; } - void OnFailureResponse_383(CHIP_ERROR error) + void OnFailureResponse_385(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_383() { ThrowSuccessResponse(); } + void OnSuccessResponse_385() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_384() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedUnsigned16BitInteger_386() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67498,44 +67670,44 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 65535U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_384, OnFailureCallback_384)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_386, OnFailureCallback_386)); return CHIP_NO_ERROR; } - void OnFailureResponse_384(CHIP_ERROR error) + void OnFailureResponse_386(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_384() { ThrowSuccessResponse(); } + void OnSuccessResponse_386() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_385() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_387() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_385, OnFailureCallback_385)); + this, OnSuccessCallback_387, OnFailureCallback_387)); return CHIP_NO_ERROR; } - void OnFailureResponse_385(CHIP_ERROR error) + void OnFailureResponse_387(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_385(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_387(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 200U)); NextTest(); } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_386() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedUnsigned16BitInteger_388() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67545,43 +67717,43 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 100U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_386, OnFailureCallback_386)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_388, OnFailureCallback_388)); return CHIP_NO_ERROR; } - void OnFailureResponse_386(CHIP_ERROR error) + void OnFailureResponse_388(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_386() { NextTest(); } + void OnSuccessResponse_388() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_387() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_389() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_387, OnFailureCallback_387)); + this, OnSuccessCallback_389, OnFailureCallback_389)); return CHIP_NO_ERROR; } - void OnFailureResponse_387(CHIP_ERROR error) + void OnFailureResponse_389(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_387(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_389(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 100U)); NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_388() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedUnsigned16BitInteger_390() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67591,43 +67763,43 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 1000U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_388, OnFailureCallback_388)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_390, OnFailureCallback_390)); return CHIP_NO_ERROR; } - void OnFailureResponse_388(CHIP_ERROR error) + void OnFailureResponse_390(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_388() { NextTest(); } + void OnSuccessResponse_390() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_389() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_391() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_389, OnFailureCallback_389)); + this, OnSuccessCallback_391, OnFailureCallback_391)); return CHIP_NO_ERROR; } - void OnFailureResponse_389(CHIP_ERROR error) + void OnFailureResponse_391(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_389(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_391(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 1000U)); NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_390() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedUnsigned16BitInteger_392() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67637,67 +67809,67 @@ class TestCluster : public TestCommand rangeRestrictedInt16uArgument = 500U; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16uArgument, this, OnSuccessCallback_390, OnFailureCallback_390)); + rangeRestrictedInt16uArgument, this, OnSuccessCallback_392, OnFailureCallback_392)); return CHIP_NO_ERROR; } - void OnFailureResponse_390(CHIP_ERROR error) + void OnFailureResponse_392(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_390() { NextTest(); } + void OnSuccessResponse_392() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_391() + CHIP_ERROR TestVerifyRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_393() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_391, OnFailureCallback_391)); + this, OnSuccessCallback_393, OnFailureCallback_393)); return CHIP_NO_ERROR; } - void OnFailureResponse_391(CHIP_ERROR error) + void OnFailureResponse_393(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_391(uint16_t rangeRestrictedInt16u) + void OnSuccessResponse_393(uint16_t rangeRestrictedInt16u) { VerifyOrReturn(CheckValue("rangeRestrictedInt16u", rangeRestrictedInt16u, 500U)); NextTest(); } - CHIP_ERROR TestReadRangeRestrictedSigned8BitInteger_392() + CHIP_ERROR TestReadRangeRestrictedSigned8BitInteger_394() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_392, OnFailureCallback_392)); + this, OnSuccessCallback_394, OnFailureCallback_394)); return CHIP_NO_ERROR; } - void OnFailureResponse_392(CHIP_ERROR error) + void OnFailureResponse_394(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_392(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_394(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, -20)); NextTest(); } - CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned8BitInteger_393() + CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned8BitInteger_395() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67707,20 +67879,20 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = -128; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_393, OnFailureCallback_393)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_395, OnFailureCallback_395)); return CHIP_NO_ERROR; } - void OnFailureResponse_393(CHIP_ERROR error) + void OnFailureResponse_395(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_393() { ThrowSuccessResponse(); } + void OnSuccessResponse_395() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_394() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned8BitInteger_396() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67730,20 +67902,20 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = -41; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_394, OnFailureCallback_394)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_396, OnFailureCallback_396)); return CHIP_NO_ERROR; } - void OnFailureResponse_394(CHIP_ERROR error) + void OnFailureResponse_396(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_394() { ThrowSuccessResponse(); } + void OnSuccessResponse_396() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_395() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned8BitInteger_397() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67753,20 +67925,20 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = 51; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_395, OnFailureCallback_395)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_397, OnFailureCallback_397)); return CHIP_NO_ERROR; } - void OnFailureResponse_395(CHIP_ERROR error) + void OnFailureResponse_397(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_395() { ThrowSuccessResponse(); } + void OnSuccessResponse_397() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned8BitInteger_396() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned8BitInteger_398() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67776,44 +67948,44 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = 127; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_396, OnFailureCallback_396)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_398, OnFailureCallback_398)); return CHIP_NO_ERROR; } - void OnFailureResponse_396(CHIP_ERROR error) + void OnFailureResponse_398(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_396() { ThrowSuccessResponse(); } + void OnSuccessResponse_398() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_397() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueHasNotChanged_399() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_397, OnFailureCallback_397)); + this, OnSuccessCallback_399, OnFailureCallback_399)); return CHIP_NO_ERROR; } - void OnFailureResponse_397(CHIP_ERROR error) + void OnFailureResponse_399(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_397(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_399(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, -20)); NextTest(); } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_398() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned8BitInteger_400() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67823,43 +67995,43 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = -40; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_398, OnFailureCallback_398)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_400, OnFailureCallback_400)); return CHIP_NO_ERROR; } - void OnFailureResponse_398(CHIP_ERROR error) + void OnFailureResponse_400(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_398() { NextTest(); } + void OnSuccessResponse_400() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_399() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMinValid_401() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_399, OnFailureCallback_399)); + this, OnSuccessCallback_401, OnFailureCallback_401)); return CHIP_NO_ERROR; } - void OnFailureResponse_399(CHIP_ERROR error) + void OnFailureResponse_401(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_399(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_401(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, -40)); NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_400() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned8BitInteger_402() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67869,43 +68041,43 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = 50; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_400, OnFailureCallback_400)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_402, OnFailureCallback_402)); return CHIP_NO_ERROR; } - void OnFailureResponse_400(CHIP_ERROR error) + void OnFailureResponse_402(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_400() { NextTest(); } + void OnSuccessResponse_402() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_401() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_403() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_401, OnFailureCallback_401)); + this, OnSuccessCallback_403, OnFailureCallback_403)); return CHIP_NO_ERROR; } - void OnFailureResponse_401(CHIP_ERROR error) + void OnFailureResponse_403(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_401(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_403(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, 50)); NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_402() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned8BitInteger_404() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67915,67 +68087,67 @@ class TestCluster : public TestCommand rangeRestrictedInt8sArgument = 6; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt8sArgument, this, OnSuccessCallback_402, OnFailureCallback_402)); + rangeRestrictedInt8sArgument, this, OnSuccessCallback_404, OnFailureCallback_404)); return CHIP_NO_ERROR; } - void OnFailureResponse_402(CHIP_ERROR error) + void OnFailureResponse_404(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_402() { NextTest(); } + void OnSuccessResponse_404() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_403() + CHIP_ERROR TestVerifyRangeRestrictedSigned8BitIntegerValueIsAtMidValid_405() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_403, OnFailureCallback_403)); + this, OnSuccessCallback_405, OnFailureCallback_405)); return CHIP_NO_ERROR; } - void OnFailureResponse_403(CHIP_ERROR error) + void OnFailureResponse_405(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_403(int8_t rangeRestrictedInt8s) + void OnSuccessResponse_405(int8_t rangeRestrictedInt8s) { VerifyOrReturn(CheckValue("rangeRestrictedInt8s", rangeRestrictedInt8s, 6)); NextTest(); } - CHIP_ERROR TestReadRangeRestrictedSigned16BitInteger_404() + CHIP_ERROR TestReadRangeRestrictedSigned16BitInteger_406() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_404, OnFailureCallback_404)); + this, OnSuccessCallback_406, OnFailureCallback_406)); return CHIP_NO_ERROR; } - void OnFailureResponse_404(CHIP_ERROR error) + void OnFailureResponse_406(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_404(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_406(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, -100)); NextTest(); } - CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned16BitInteger_405() + CHIP_ERROR TestWriteMinValueToARangeRestrictedSigned16BitInteger_407() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -67985,20 +68157,20 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = -32768; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_405, OnFailureCallback_405)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_407, OnFailureCallback_407)); return CHIP_NO_ERROR; } - void OnFailureResponse_405(CHIP_ERROR error) + void OnFailureResponse_407(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_405() { ThrowSuccessResponse(); } + void OnSuccessResponse_407() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_406() + CHIP_ERROR TestWriteJustBelowRangeValueToARangeRestrictedSigned16BitInteger_408() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68008,20 +68180,20 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = -151; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_406, OnFailureCallback_406)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_408, OnFailureCallback_408)); return CHIP_NO_ERROR; } - void OnFailureResponse_406(CHIP_ERROR error) + void OnFailureResponse_408(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_406() { ThrowSuccessResponse(); } + void OnSuccessResponse_408() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_407() + CHIP_ERROR TestWriteJustAboveRangeValueToARangeRestrictedSigned16BitInteger_409() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68031,20 +68203,20 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = 201; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_407, OnFailureCallback_407)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_409, OnFailureCallback_409)); return CHIP_NO_ERROR; } - void OnFailureResponse_407(CHIP_ERROR error) + void OnFailureResponse_409(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_407() { ThrowSuccessResponse(); } + void OnSuccessResponse_409() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned16BitInteger_408() + CHIP_ERROR TestWriteMaxValueToARangeRestrictedSigned16BitInteger_410() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68054,44 +68226,44 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = 32767; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_408, OnFailureCallback_408)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_410, OnFailureCallback_410)); return CHIP_NO_ERROR; } - void OnFailureResponse_408(CHIP_ERROR error) + void OnFailureResponse_410(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_408() { ThrowSuccessResponse(); } + void OnSuccessResponse_410() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_409() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueHasNotChanged_411() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_409, OnFailureCallback_409)); + this, OnSuccessCallback_411, OnFailureCallback_411)); return CHIP_NO_ERROR; } - void OnFailureResponse_409(CHIP_ERROR error) + void OnFailureResponse_411(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_409(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_411(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, -100)); NextTest(); } - CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_410() + CHIP_ERROR TestWriteMinValidValueToARangeRestrictedSigned16BitInteger_412() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68101,43 +68273,43 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = -150; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_410, OnFailureCallback_410)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_412, OnFailureCallback_412)); return CHIP_NO_ERROR; } - void OnFailureResponse_410(CHIP_ERROR error) + void OnFailureResponse_412(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_410() { NextTest(); } + void OnSuccessResponse_412() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_411() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMinValid_413() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_411, OnFailureCallback_411)); + this, OnSuccessCallback_413, OnFailureCallback_413)); return CHIP_NO_ERROR; } - void OnFailureResponse_411(CHIP_ERROR error) + void OnFailureResponse_413(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_411(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_413(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, -150)); NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_412() + CHIP_ERROR TestWriteMaxValidValueToARangeRestrictedSigned16BitInteger_414() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68147,43 +68319,43 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = 200; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_412, OnFailureCallback_412)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_414, OnFailureCallback_414)); return CHIP_NO_ERROR; } - void OnFailureResponse_412(CHIP_ERROR error) + void OnFailureResponse_414(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_412() { NextTest(); } + void OnSuccessResponse_414() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_413() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_415() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_413, OnFailureCallback_413)); + this, OnSuccessCallback_415, OnFailureCallback_415)); return CHIP_NO_ERROR; } - void OnFailureResponse_413(CHIP_ERROR error) + void OnFailureResponse_415(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_413(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_415(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, 200)); NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_414() + CHIP_ERROR TestWriteMiddleValidValueToARangeRestrictedSigned16BitInteger_416() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68193,43 +68365,43 @@ class TestCluster : public TestCommand rangeRestrictedInt16sArgument = 7; ReturnErrorOnFailure(cluster.WriteAttribute( - rangeRestrictedInt16sArgument, this, OnSuccessCallback_414, OnFailureCallback_414)); + rangeRestrictedInt16sArgument, this, OnSuccessCallback_416, OnFailureCallback_416)); return CHIP_NO_ERROR; } - void OnFailureResponse_414(CHIP_ERROR error) + void OnFailureResponse_416(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_414() { NextTest(); } + void OnSuccessResponse_416() { NextTest(); } - CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_415() + CHIP_ERROR TestVerifyRangeRestrictedSigned16BitIntegerValueIsAtMidValid_417() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_415, OnFailureCallback_415)); + this, OnSuccessCallback_417, OnFailureCallback_417)); return CHIP_NO_ERROR; } - void OnFailureResponse_415(CHIP_ERROR error) + void OnFailureResponse_417(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_415(int16_t rangeRestrictedInt16s) + void OnSuccessResponse_417(int16_t rangeRestrictedInt16s) { VerifyOrReturn(CheckValue("rangeRestrictedInt16s", rangeRestrictedInt16s, 7)); NextTest(); } - CHIP_ERROR TestReadNullableRangeRestrictedUnsigned8BitInteger_416() + CHIP_ERROR TestReadNullableRangeRestrictedUnsigned8BitInteger_418() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68237,17 +68409,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_416, OnFailureCallback_416)); + this, OnSuccessCallback_418, OnFailureCallback_418)); return CHIP_NO_ERROR; } - void OnFailureResponse_416(CHIP_ERROR error) + void OnFailureResponse_418(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_416(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_418(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 70)); @@ -68255,7 +68427,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_417() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned8BitInteger_419() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68267,20 +68439,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_417, OnFailureCallback_417)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_419, OnFailureCallback_419)); return CHIP_NO_ERROR; } - void OnFailureResponse_417(CHIP_ERROR error) + void OnFailureResponse_419(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_417() { ThrowSuccessResponse(); } + void OnSuccessResponse_419() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_418() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned8BitInteger_420() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68292,20 +68464,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_418, OnFailureCallback_418)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_420, OnFailureCallback_420)); return CHIP_NO_ERROR; } - void OnFailureResponse_418(CHIP_ERROR error) + void OnFailureResponse_420(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_418() { ThrowSuccessResponse(); } + void OnSuccessResponse_420() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_419() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned8BitInteger_421() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68317,20 +68489,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_419, OnFailureCallback_419)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_421, OnFailureCallback_421)); return CHIP_NO_ERROR; } - void OnFailureResponse_419(CHIP_ERROR error) + void OnFailureResponse_421(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_419() { ThrowSuccessResponse(); } + void OnSuccessResponse_421() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_420() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned8BitInteger_422() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68342,20 +68514,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_420, OnFailureCallback_420)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_422, OnFailureCallback_422)); return CHIP_NO_ERROR; } - void OnFailureResponse_420(CHIP_ERROR error) + void OnFailureResponse_422(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_420() { ThrowSuccessResponse(); } + void OnSuccessResponse_422() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_421() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueHasNotChanged_423() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68363,17 +68535,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_421, OnFailureCallback_421)); + this, OnSuccessCallback_423, OnFailureCallback_423)); return CHIP_NO_ERROR; } - void OnFailureResponse_421(CHIP_ERROR error) + void OnFailureResponse_423(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_421(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_423(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 70)); @@ -68381,7 +68553,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_422() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned8BitInteger_424() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68393,19 +68565,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_422, OnFailureCallback_422)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_424, OnFailureCallback_424)); return CHIP_NO_ERROR; } - void OnFailureResponse_422(CHIP_ERROR error) + void OnFailureResponse_424(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_422() { NextTest(); } + void OnSuccessResponse_424() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_423() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMinValid_425() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68413,17 +68585,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_423, OnFailureCallback_423)); + this, OnSuccessCallback_425, OnFailureCallback_425)); return CHIP_NO_ERROR; } - void OnFailureResponse_423(CHIP_ERROR error) + void OnFailureResponse_425(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_423(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_425(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 20)); @@ -68431,7 +68603,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_424() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned8BitInteger_426() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68443,19 +68615,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_424, OnFailureCallback_424)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_426, OnFailureCallback_426)); return CHIP_NO_ERROR; } - void OnFailureResponse_424(CHIP_ERROR error) + void OnFailureResponse_426(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_424() { NextTest(); } + void OnSuccessResponse_426() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_425() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMaxValid_427() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68463,17 +68635,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_425, OnFailureCallback_425)); + this, OnSuccessCallback_427, OnFailureCallback_427)); return CHIP_NO_ERROR; } - void OnFailureResponse_425(CHIP_ERROR error) + void OnFailureResponse_427(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_425(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_427(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 100)); @@ -68481,7 +68653,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_426() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned8BitInteger_428() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68493,19 +68665,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_426, OnFailureCallback_426)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_428, OnFailureCallback_428)); return CHIP_NO_ERROR; } - void OnFailureResponse_426(CHIP_ERROR error) + void OnFailureResponse_428(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_426() { NextTest(); } + void OnSuccessResponse_428() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_427() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsAtMidValid_429() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68513,17 +68685,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_427, OnFailureCallback_427)); + this, OnSuccessCallback_429, OnFailureCallback_429)); return CHIP_NO_ERROR; } - void OnFailureResponse_427(CHIP_ERROR error) + void OnFailureResponse_429(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_427(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_429(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8u.Value()", nullableRangeRestrictedInt8u.Value(), 50)); @@ -68531,7 +68703,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_428() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned8BitInteger_430() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68542,19 +68714,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_428, OnFailureCallback_428)); + nullableRangeRestrictedInt8uArgument, this, OnSuccessCallback_430, OnFailureCallback_430)); return CHIP_NO_ERROR; } - void OnFailureResponse_428(CHIP_ERROR error) + void OnFailureResponse_430(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_428() { NextTest(); } + void OnSuccessResponse_430() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_429() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned8BitIntegerValueIsNull_431() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68562,24 +68734,24 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_429, OnFailureCallback_429)); + this, OnSuccessCallback_431, OnFailureCallback_431)); return CHIP_NO_ERROR; } - void OnFailureResponse_429(CHIP_ERROR error) + void OnFailureResponse_431(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_429(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) + void OnSuccessResponse_431(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8u) { VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt8u", nullableRangeRestrictedInt8u)); NextTest(); } - CHIP_ERROR TestReadNullableRangeRestrictedUnsigned16BitInteger_430() + CHIP_ERROR TestReadNullableRangeRestrictedUnsigned16BitInteger_432() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68587,17 +68759,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_430, OnFailureCallback_430)); + this, OnSuccessCallback_432, OnFailureCallback_432)); return CHIP_NO_ERROR; } - void OnFailureResponse_430(CHIP_ERROR error) + void OnFailureResponse_432(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_430(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_432(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 200U)); @@ -68605,7 +68777,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_431() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedUnsigned16BitInteger_433() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68617,20 +68789,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_431, OnFailureCallback_431)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_433, OnFailureCallback_433)); return CHIP_NO_ERROR; } - void OnFailureResponse_431(CHIP_ERROR error) + void OnFailureResponse_433(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_431() { ThrowSuccessResponse(); } + void OnSuccessResponse_433() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_432() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedUnsigned16BitInteger_434() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68642,20 +68814,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_432, OnFailureCallback_432)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_434, OnFailureCallback_434)); return CHIP_NO_ERROR; } - void OnFailureResponse_432(CHIP_ERROR error) + void OnFailureResponse_434(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_432() { ThrowSuccessResponse(); } + void OnSuccessResponse_434() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_433() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedUnsigned16BitInteger_435() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68667,20 +68839,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_433, OnFailureCallback_433)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_435, OnFailureCallback_435)); return CHIP_NO_ERROR; } - void OnFailureResponse_433(CHIP_ERROR error) + void OnFailureResponse_435(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_433() { ThrowSuccessResponse(); } + void OnSuccessResponse_435() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_434() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedUnsigned16BitInteger_436() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68692,20 +68864,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_434, OnFailureCallback_434)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_436, OnFailureCallback_436)); return CHIP_NO_ERROR; } - void OnFailureResponse_434(CHIP_ERROR error) + void OnFailureResponse_436(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_434() { ThrowSuccessResponse(); } + void OnSuccessResponse_436() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_435() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueHasNotChanged_437() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68713,17 +68885,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_435, OnFailureCallback_435)); + this, OnSuccessCallback_437, OnFailureCallback_437)); return CHIP_NO_ERROR; } - void OnFailureResponse_435(CHIP_ERROR error) + void OnFailureResponse_437(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_435(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_437(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 200U)); @@ -68731,7 +68903,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_436() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedUnsigned16BitInteger_438() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68743,19 +68915,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_436, OnFailureCallback_436)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_438, OnFailureCallback_438)); return CHIP_NO_ERROR; } - void OnFailureResponse_436(CHIP_ERROR error) + void OnFailureResponse_438(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_436() { NextTest(); } + void OnSuccessResponse_438() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_437() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMinValid_439() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68763,17 +68935,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_437, OnFailureCallback_437)); + this, OnSuccessCallback_439, OnFailureCallback_439)); return CHIP_NO_ERROR; } - void OnFailureResponse_437(CHIP_ERROR error) + void OnFailureResponse_439(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_437(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_439(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 100U)); @@ -68781,7 +68953,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_438() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedUnsigned16BitInteger_440() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68793,19 +68965,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_438, OnFailureCallback_438)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_440, OnFailureCallback_440)); return CHIP_NO_ERROR; } - void OnFailureResponse_438(CHIP_ERROR error) + void OnFailureResponse_440(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_438() { NextTest(); } + void OnSuccessResponse_440() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_439() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMaxValid_441() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68813,17 +68985,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_439, OnFailureCallback_439)); + this, OnSuccessCallback_441, OnFailureCallback_441)); return CHIP_NO_ERROR; } - void OnFailureResponse_439(CHIP_ERROR error) + void OnFailureResponse_441(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_439(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_441(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 1000U)); @@ -68831,7 +69003,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_440() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedUnsigned16BitInteger_442() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68843,19 +69015,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_440, OnFailureCallback_440)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_442, OnFailureCallback_442)); return CHIP_NO_ERROR; } - void OnFailureResponse_440(CHIP_ERROR error) + void OnFailureResponse_442(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_440() { NextTest(); } + void OnSuccessResponse_442() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_441() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsAtMidValid_443() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68863,17 +69035,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_441, OnFailureCallback_441)); + this, OnSuccessCallback_443, OnFailureCallback_443)); return CHIP_NO_ERROR; } - void OnFailureResponse_441(CHIP_ERROR error) + void OnFailureResponse_443(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_441(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_443(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16u.Value()", nullableRangeRestrictedInt16u.Value(), 500U)); @@ -68881,7 +69053,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_442() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedUnsigned16BitInteger_444() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68892,19 +69064,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_442, OnFailureCallback_442)); + nullableRangeRestrictedInt16uArgument, this, OnSuccessCallback_444, OnFailureCallback_444)); return CHIP_NO_ERROR; } - void OnFailureResponse_442(CHIP_ERROR error) + void OnFailureResponse_444(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_442() { NextTest(); } + void OnSuccessResponse_444() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_443() + CHIP_ERROR TestVerifyNullableRangeRestrictedUnsigned16BitIntegerValueIsNull_445() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68912,24 +69084,24 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_443, OnFailureCallback_443)); + this, OnSuccessCallback_445, OnFailureCallback_445)); return CHIP_NO_ERROR; } - void OnFailureResponse_443(CHIP_ERROR error) + void OnFailureResponse_445(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_443(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) + void OnSuccessResponse_445(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16u) { VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt16u", nullableRangeRestrictedInt16u)); NextTest(); } - CHIP_ERROR TestReadNullableRangeRestrictedSigned8BitInteger_444() + CHIP_ERROR TestReadNullableRangeRestrictedSigned8BitInteger_446() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68937,17 +69109,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_444, OnFailureCallback_444)); + this, OnSuccessCallback_446, OnFailureCallback_446)); return CHIP_NO_ERROR; } - void OnFailureResponse_444(CHIP_ERROR error) + void OnFailureResponse_446(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_444(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_446(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), -20)); @@ -68955,7 +69127,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_445() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned8BitInteger_447() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68967,20 +69139,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_445, OnFailureCallback_445)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_447, OnFailureCallback_447)); return CHIP_NO_ERROR; } - void OnFailureResponse_445(CHIP_ERROR error) + void OnFailureResponse_447(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_445() { ThrowSuccessResponse(); } + void OnSuccessResponse_447() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_446() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned8BitInteger_448() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -68992,20 +69164,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_446, OnFailureCallback_446)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_448, OnFailureCallback_448)); return CHIP_NO_ERROR; } - void OnFailureResponse_446(CHIP_ERROR error) + void OnFailureResponse_448(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_446() { ThrowSuccessResponse(); } + void OnSuccessResponse_448() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_447() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned8BitInteger_449() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69017,20 +69189,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_447, OnFailureCallback_447)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_449, OnFailureCallback_449)); return CHIP_NO_ERROR; } - void OnFailureResponse_447(CHIP_ERROR error) + void OnFailureResponse_449(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_447() { ThrowSuccessResponse(); } + void OnSuccessResponse_449() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_448() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned8BitInteger_450() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69042,20 +69214,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_448, OnFailureCallback_448)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_450, OnFailureCallback_450)); return CHIP_NO_ERROR; } - void OnFailureResponse_448(CHIP_ERROR error) + void OnFailureResponse_450(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_448() { ThrowSuccessResponse(); } + void OnSuccessResponse_450() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_449() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueHasNotChanged_451() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69063,17 +69235,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_449, OnFailureCallback_449)); + this, OnSuccessCallback_451, OnFailureCallback_451)); return CHIP_NO_ERROR; } - void OnFailureResponse_449(CHIP_ERROR error) + void OnFailureResponse_451(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_449(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_451(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), -20)); @@ -69081,7 +69253,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_450() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned8BitInteger_452() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69093,19 +69265,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_450, OnFailureCallback_450)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_452, OnFailureCallback_452)); return CHIP_NO_ERROR; } - void OnFailureResponse_450(CHIP_ERROR error) + void OnFailureResponse_452(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_450() { NextTest(); } + void OnSuccessResponse_452() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_451() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMinValid_453() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69113,17 +69285,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_451, OnFailureCallback_451)); + this, OnSuccessCallback_453, OnFailureCallback_453)); return CHIP_NO_ERROR; } - void OnFailureResponse_451(CHIP_ERROR error) + void OnFailureResponse_453(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_451(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_453(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), -40)); @@ -69131,7 +69303,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_452() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned8BitInteger_454() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69143,19 +69315,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_452, OnFailureCallback_452)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_454, OnFailureCallback_454)); return CHIP_NO_ERROR; } - void OnFailureResponse_452(CHIP_ERROR error) + void OnFailureResponse_454(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_452() { NextTest(); } + void OnSuccessResponse_454() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_453() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMaxValid_455() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69163,17 +69335,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_453, OnFailureCallback_453)); + this, OnSuccessCallback_455, OnFailureCallback_455)); return CHIP_NO_ERROR; } - void OnFailureResponse_453(CHIP_ERROR error) + void OnFailureResponse_455(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_453(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_455(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), 50)); @@ -69181,7 +69353,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_454() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned8BitInteger_456() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69193,19 +69365,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_454, OnFailureCallback_454)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_456, OnFailureCallback_456)); return CHIP_NO_ERROR; } - void OnFailureResponse_454(CHIP_ERROR error) + void OnFailureResponse_456(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_454() { NextTest(); } + void OnSuccessResponse_456() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_455() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtMidValid_457() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69213,17 +69385,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_455, OnFailureCallback_455)); + this, OnSuccessCallback_457, OnFailureCallback_457)); return CHIP_NO_ERROR; } - void OnFailureResponse_455(CHIP_ERROR error) + void OnFailureResponse_457(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_455(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_457(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt8s.Value()", nullableRangeRestrictedInt8s.Value(), 6)); @@ -69231,7 +69403,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_456() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned8BitInteger_458() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69242,19 +69414,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_456, OnFailureCallback_456)); + nullableRangeRestrictedInt8sArgument, this, OnSuccessCallback_458, OnFailureCallback_458)); return CHIP_NO_ERROR; } - void OnFailureResponse_456(CHIP_ERROR error) + void OnFailureResponse_458(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_456() { NextTest(); } + void OnSuccessResponse_458() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_457() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned8BitIntegerValueIsAtNull_459() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69262,24 +69434,24 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_457, OnFailureCallback_457)); + this, OnSuccessCallback_459, OnFailureCallback_459)); return CHIP_NO_ERROR; } - void OnFailureResponse_457(CHIP_ERROR error) + void OnFailureResponse_459(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_457(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) + void OnSuccessResponse_459(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt8s) { VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt8s", nullableRangeRestrictedInt8s)); NextTest(); } - CHIP_ERROR TestReadNullableRangeRestrictedSigned16BitInteger_458() + CHIP_ERROR TestReadNullableRangeRestrictedSigned16BitInteger_460() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69287,17 +69459,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_458, OnFailureCallback_458)); + this, OnSuccessCallback_460, OnFailureCallback_460)); return CHIP_NO_ERROR; } - void OnFailureResponse_458(CHIP_ERROR error) + void OnFailureResponse_460(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_458(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_460(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), -100)); @@ -69305,7 +69477,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_459() + CHIP_ERROR TestWriteMinValueToANullableRangeRestrictedSigned16BitInteger_461() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69317,20 +69489,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_459, OnFailureCallback_459)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_461, OnFailureCallback_461)); return CHIP_NO_ERROR; } - void OnFailureResponse_459(CHIP_ERROR error) + void OnFailureResponse_461(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_459() { ThrowSuccessResponse(); } + void OnSuccessResponse_461() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_460() + CHIP_ERROR TestWriteJustBelowRangeValueToANullableRangeRestrictedSigned16BitInteger_462() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69342,20 +69514,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_460, OnFailureCallback_460)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_462, OnFailureCallback_462)); return CHIP_NO_ERROR; } - void OnFailureResponse_460(CHIP_ERROR error) + void OnFailureResponse_462(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_460() { ThrowSuccessResponse(); } + void OnSuccessResponse_462() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_461() + CHIP_ERROR TestWriteJustAboveRangeValueToANullableRangeRestrictedSigned16BitInteger_463() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69367,20 +69539,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_461, OnFailureCallback_461)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_463, OnFailureCallback_463)); return CHIP_NO_ERROR; } - void OnFailureResponse_461(CHIP_ERROR error) + void OnFailureResponse_463(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_461() { ThrowSuccessResponse(); } + void OnSuccessResponse_463() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_462() + CHIP_ERROR TestWriteMaxValueToANullableRangeRestrictedSigned16BitInteger_464() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69392,20 +69564,20 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_462, OnFailureCallback_462)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_464, OnFailureCallback_464)); return CHIP_NO_ERROR; } - void OnFailureResponse_462(CHIP_ERROR error) + void OnFailureResponse_464(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_CONSTRAINT_ERROR)); NextTest(); } - void OnSuccessResponse_462() { ThrowSuccessResponse(); } + void OnSuccessResponse_464() { ThrowSuccessResponse(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_463() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueHasNotChanged_465() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69413,17 +69585,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_463, OnFailureCallback_463)); + this, OnSuccessCallback_465, OnFailureCallback_465)); return CHIP_NO_ERROR; } - void OnFailureResponse_463(CHIP_ERROR error) + void OnFailureResponse_465(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_463(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_465(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), -100)); @@ -69431,7 +69603,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_464() + CHIP_ERROR TestWriteMinValidValueToANullableRangeRestrictedSigned16BitInteger_466() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69443,19 +69615,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_464, OnFailureCallback_464)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_466, OnFailureCallback_466)); return CHIP_NO_ERROR; } - void OnFailureResponse_464(CHIP_ERROR error) + void OnFailureResponse_466(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_464() { NextTest(); } + void OnSuccessResponse_466() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_465() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMinValid_467() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69463,17 +69635,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_465, OnFailureCallback_465)); + this, OnSuccessCallback_467, OnFailureCallback_467)); return CHIP_NO_ERROR; } - void OnFailureResponse_465(CHIP_ERROR error) + void OnFailureResponse_467(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_465(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_467(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), -150)); @@ -69481,7 +69653,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_466() + CHIP_ERROR TestWriteMaxValidValueToANullableRangeRestrictedSigned16BitInteger_468() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69493,19 +69665,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_466, OnFailureCallback_466)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_468, OnFailureCallback_468)); return CHIP_NO_ERROR; } - void OnFailureResponse_466(CHIP_ERROR error) + void OnFailureResponse_468(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_466() { NextTest(); } + void OnSuccessResponse_468() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_467() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMaxValid_469() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69513,17 +69685,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_467, OnFailureCallback_467)); + this, OnSuccessCallback_469, OnFailureCallback_469)); return CHIP_NO_ERROR; } - void OnFailureResponse_467(CHIP_ERROR error) + void OnFailureResponse_469(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_467(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_469(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), 200)); @@ -69531,7 +69703,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_468() + CHIP_ERROR TestWriteMiddleValidValueToANullableRangeRestrictedSigned16BitInteger_470() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69543,19 +69715,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_468, OnFailureCallback_468)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_470, OnFailureCallback_470)); return CHIP_NO_ERROR; } - void OnFailureResponse_468(CHIP_ERROR error) + void OnFailureResponse_470(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_468() { NextTest(); } + void OnSuccessResponse_470() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_469() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsAtMidValid_471() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69563,17 +69735,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_469, OnFailureCallback_469)); + this, OnSuccessCallback_471, OnFailureCallback_471)); return CHIP_NO_ERROR; } - void OnFailureResponse_469(CHIP_ERROR error) + void OnFailureResponse_471(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_469(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_471(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNonNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); VerifyOrReturn(CheckValue("nullableRangeRestrictedInt16s.Value()", nullableRangeRestrictedInt16s.Value(), 7)); @@ -69581,7 +69753,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_470() + CHIP_ERROR TestWriteNullValueToANullableRangeRestrictedSigned16BitInteger_472() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69592,19 +69764,19 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.WriteAttribute( - nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_470, OnFailureCallback_470)); + nullableRangeRestrictedInt16sArgument, this, OnSuccessCallback_472, OnFailureCallback_472)); return CHIP_NO_ERROR; } - void OnFailureResponse_470(CHIP_ERROR error) + void OnFailureResponse_472(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_470() { NextTest(); } + void OnSuccessResponse_472() { NextTest(); } - CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_471() + CHIP_ERROR TestVerifyNullableRangeRestrictedSigned16BitIntegerValueIsNull_473() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69612,24 +69784,24 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_471, OnFailureCallback_471)); + this, OnSuccessCallback_473, OnFailureCallback_473)); return CHIP_NO_ERROR; } - void OnFailureResponse_471(CHIP_ERROR error) + void OnFailureResponse_473(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_471(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) + void OnSuccessResponse_473(const chip::app::DataModel::Nullable & nullableRangeRestrictedInt16s) { VerifyOrReturn(CheckValueNull("nullableRangeRestrictedInt16s", nullableRangeRestrictedInt16s)); NextTest(); } - CHIP_ERROR TestWriteAttributeThatReturnsGeneralStatusOnWrite_472() + CHIP_ERROR TestWriteAttributeThatReturnsGeneralStatusOnWrite_474() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69639,20 +69811,20 @@ class TestCluster : public TestCommand generalErrorBooleanArgument = false; ReturnErrorOnFailure(cluster.WriteAttribute( - generalErrorBooleanArgument, this, OnSuccessCallback_472, OnFailureCallback_472)); + generalErrorBooleanArgument, this, OnSuccessCallback_474, OnFailureCallback_474)); return CHIP_NO_ERROR; } - void OnFailureResponse_472(CHIP_ERROR error) + void OnFailureResponse_474(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_INVALID_DATA_TYPE)); NextTest(); } - void OnSuccessResponse_472() { ThrowSuccessResponse(); } + void OnSuccessResponse_474() { ThrowSuccessResponse(); } - CHIP_ERROR TestWriteAttributeThatReturnsClusterSpecificStatusOnWrite_473() + CHIP_ERROR TestWriteAttributeThatReturnsClusterSpecificStatusOnWrite_475() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69662,60 +69834,60 @@ class TestCluster : public TestCommand clusterErrorBooleanArgument = false; ReturnErrorOnFailure(cluster.WriteAttribute( - clusterErrorBooleanArgument, this, OnSuccessCallback_473, OnFailureCallback_473)); + clusterErrorBooleanArgument, this, OnSuccessCallback_475, OnFailureCallback_475)); return CHIP_NO_ERROR; } - void OnFailureResponse_473(CHIP_ERROR error) + void OnFailureResponse_475(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_FAILURE)); NextTest(); } - void OnSuccessResponse_473() { ThrowSuccessResponse(); } + void OnSuccessResponse_475() { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeThatReturnsGeneralStatusOnRead_474() + CHIP_ERROR TestReadAttributeThatReturnsGeneralStatusOnRead_476() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_474, OnFailureCallback_474)); + this, OnSuccessCallback_476, OnFailureCallback_476)); return CHIP_NO_ERROR; } - void OnFailureResponse_474(CHIP_ERROR error) + void OnFailureResponse_476(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_INVALID_DATA_TYPE)); NextTest(); } - void OnSuccessResponse_474(bool generalErrorBoolean) { ThrowSuccessResponse(); } + void OnSuccessResponse_476(bool generalErrorBoolean) { ThrowSuccessResponse(); } - CHIP_ERROR TestReadAttributeThatReturnsClusterSpecificStatusOnRead_475() + CHIP_ERROR TestReadAttributeThatReturnsClusterSpecificStatusOnRead_477() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_475, OnFailureCallback_475)); + this, OnSuccessCallback_477, OnFailureCallback_477)); return CHIP_NO_ERROR; } - void OnFailureResponse_475(CHIP_ERROR error) + void OnFailureResponse_477(CHIP_ERROR error) { chip::app::StatusIB status(error); VerifyOrReturn(CheckValue("status", chip::to_underlying(status.mStatus), EMBER_ZCL_STATUS_FAILURE)); NextTest(); } - void OnSuccessResponse_475(bool clusterErrorBoolean) { ThrowSuccessResponse(); } + void OnSuccessResponse_477(bool clusterErrorBoolean) { ThrowSuccessResponse(); } - CHIP_ERROR TestReadClientGeneratedCommandListAttribute_476() + CHIP_ERROR TestReadClientGeneratedCommandListAttribute_478() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69723,17 +69895,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_476, OnFailureCallback_476)); + this, OnSuccessCallback_478, OnFailureCallback_478)); return CHIP_NO_ERROR; } - void OnFailureResponse_476(CHIP_ERROR error) + void OnFailureResponse_478(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_476(const chip::app::DataModel::DecodableList & clientGeneratedCommandList) + void OnSuccessResponse_478(const chip::app::DataModel::DecodableList & clientGeneratedCommandList) { { auto iter_0 = clientGeneratedCommandList.begin(); @@ -69787,7 +69959,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestReadServerGeneratedCommandListAttribute_477() + CHIP_ERROR TestReadServerGeneratedCommandListAttribute_479() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69795,17 +69967,17 @@ class TestCluster : public TestCommand ReturnErrorOnFailure( cluster.ReadAttribute( - this, OnSuccessCallback_477, OnFailureCallback_477)); + this, OnSuccessCallback_479, OnFailureCallback_479)); return CHIP_NO_ERROR; } - void OnFailureResponse_477(CHIP_ERROR error) + void OnFailureResponse_479(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_477(const chip::app::DataModel::DecodableList & serverGeneratedCommandList) + void OnSuccessResponse_479(const chip::app::DataModel::DecodableList & serverGeneratedCommandList) { { auto iter_0 = serverGeneratedCommandList.begin(); @@ -69831,7 +70003,7 @@ class TestCluster : public TestCommand NextTest(); } - CHIP_ERROR TestWriteStructTypedAttribute_478() + CHIP_ERROR TestWriteStructTypedAttribute_480() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; @@ -69849,36 +70021,36 @@ class TestCluster : public TestCommand structAttrArgument.h = 3.14159265358979; ReturnErrorOnFailure(cluster.WriteAttribute( - structAttrArgument, this, OnSuccessCallback_478, OnFailureCallback_478)); + structAttrArgument, this, OnSuccessCallback_480, OnFailureCallback_480)); return CHIP_NO_ERROR; } - void OnFailureResponse_478(CHIP_ERROR error) + void OnFailureResponse_480(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_478() { NextTest(); } + void OnSuccessResponse_480() { NextTest(); } - CHIP_ERROR TestReadStructTypedAttribute_479() + CHIP_ERROR TestReadStructTypedAttribute_481() { const chip::EndpointId endpoint = mEndpoint.HasValue() ? mEndpoint.Value() : 1; chip::Controller::TestClusterClusterTest cluster; cluster.Associate(mDevices[kIdentityAlpha], endpoint); ReturnErrorOnFailure(cluster.ReadAttribute( - this, OnSuccessCallback_479, OnFailureCallback_479)); + this, OnSuccessCallback_481, OnFailureCallback_481)); return CHIP_NO_ERROR; } - void OnFailureResponse_479(CHIP_ERROR error) + void OnFailureResponse_481(CHIP_ERROR error) { chip::app::StatusIB status(error); ThrowFailureResponse(); } - void OnSuccessResponse_479(const chip::app::Clusters::TestCluster::Structs::SimpleStruct::DecodableType & structAttr) + void OnSuccessResponse_481(const chip::app::Clusters::TestCluster::Structs::SimpleStruct::DecodableType & structAttr) { VerifyOrReturn(CheckValue("structAttr.a", structAttr.a, 5)); VerifyOrReturn(CheckValue("structAttr.b", structAttr.b, true));