| /* |
| * |
| * Copyright (c) 2020-2021 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/AppConfig.h> |
| #include <app/MessageDef/EventFilterIBs.h> |
| #include <app/MessageDef/EventStatusIB.h> |
| #include <app/MessageDef/InvokeRequestMessage.h> |
| #include <app/MessageDef/InvokeResponseMessage.h> |
| #include <app/MessageDef/ReadRequestMessage.h> |
| #include <app/MessageDef/ReportDataMessage.h> |
| #include <app/MessageDef/SubscribeRequestMessage.h> |
| #include <app/MessageDef/SubscribeResponseMessage.h> |
| #include <app/MessageDef/TimedRequestMessage.h> |
| #include <app/MessageDef/WriteRequestMessage.h> |
| #include <app/MessageDef/WriteResponseMessage.h> |
| #include <lib/core/CHIPError.h> |
| #include <lib/core/TLVDebug.h> |
| #include <lib/support/CHIPMem.h> |
| #include <lib/support/EnforceFormat.h> |
| #include <lib/support/logging/Constants.h> |
| #include <lib/support/tests/ExtraPwTestMacros.h> |
| #include <system/TLVPacketBufferBackingStore.h> |
| |
| #include <lib/core/StringBuilderAdapters.h> |
| #include <pw_unit_test/framework.h> |
| |
| namespace { |
| |
| using namespace chip::app; |
| |
| class TestMessageDef : public ::testing::Test |
| { |
| public: |
| static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); } |
| static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); } |
| }; |
| |
| void ENFORCE_FORMAT(1, 2) TLVPrettyPrinter(const char * aFormat, ...) |
| { |
| va_list args; |
| |
| va_start(args, aFormat); |
| |
| vprintf(aFormat, args); |
| |
| va_end(args); |
| } |
| |
| template <typename T> |
| void DebugPrettyPrint(const T & parser) |
| { |
| #if CHIP_CONFIG_IM_PRETTY_PRINT |
| EXPECT_SUCCESS(parser.PrettyPrint()); |
| #endif |
| } |
| |
| template <> |
| void DebugPrettyPrint(const chip::System::PacketBufferHandle & aMsgBuf) |
| { |
| chip::System::PacketBufferTLVReader reader; |
| reader.Init(aMsgBuf.Retain()); |
| EXPECT_SUCCESS(reader.Next()); |
| EXPECT_SUCCESS(chip::TLV::Debug::Dump(reader, TLVPrettyPrinter)); |
| } |
| |
| void BuildStatusIB(StatusIB::Builder & aStatusIBBuilder) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| |
| StatusIB statusIB; |
| statusIB.mStatus = chip::Protocols::InteractionModel::Status::InvalidSubscription; |
| aStatusIBBuilder.EncodeStatusIB(statusIB); |
| err = aStatusIBBuilder.GetError(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| } |
| |
| void ParseStatusIB(StatusIB::Parser & aStatusIBParser) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| StatusIB::Parser StatusIBParser; |
| StatusIB statusIB; |
| |
| DebugPrettyPrint(aStatusIBParser); |
| |
| err = aStatusIBParser.DecodeStatusIB(statusIB); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(statusIB.mStatus, chip::Protocols::InteractionModel::Status::InvalidSubscription); |
| EXPECT_FALSE(statusIB.mClusterStatus.has_value()); |
| } |
| |
| void BuildClusterPathIB(ClusterPathIB::Builder & aClusterPathBuilder) |
| { |
| EXPECT_SUCCESS(aClusterPathBuilder.Node(1).Endpoint(2).Cluster(3).EndOfClusterPathIB()); |
| EXPECT_SUCCESS(aClusterPathBuilder.GetError()); |
| } |
| |
| void ParseClusterPathIB(chip::TLV::TLVReader & aReader) |
| { |
| ClusterPathIB::Parser clusterPathParser; |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::NodeId node = 0; |
| chip::EndpointId endpoint = 0; |
| chip::ClusterId cluster = 0; |
| |
| err = clusterPathParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| DebugPrettyPrint(clusterPathParser); |
| |
| err = clusterPathParser.GetNode(&node); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(node, 1u); |
| |
| err = clusterPathParser.GetEndpoint(&endpoint); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(endpoint, 2u); |
| |
| err = clusterPathParser.GetCluster(&cluster); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(cluster, 3u); |
| } |
| |
| void BuildDataVersionFilterIB(DataVersionFilterIB::Builder & aDataVersionFilterIBBuilder) |
| { |
| ClusterPathIB::Builder & clusterPathBuilder = aDataVersionFilterIBBuilder.CreatePath(); |
| EXPECT_EQ(clusterPathBuilder.GetError(), CHIP_NO_ERROR); |
| BuildClusterPathIB(clusterPathBuilder); |
| EXPECT_SUCCESS(aDataVersionFilterIBBuilder.DataVersion(2).EndOfDataVersionFilterIB()); |
| EXPECT_EQ(aDataVersionFilterIBBuilder.GetError(), CHIP_NO_ERROR); |
| } |
| |
| void ParseDataVersionFilterIB(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| DataVersionFilterIB::Parser dataVersionFilterIBParser; |
| ClusterPathIB::Parser clusterPath; |
| chip::DataVersion dataVersion = 2; |
| |
| err = dataVersionFilterIBParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| DebugPrettyPrint(dataVersionFilterIBParser); |
| |
| err = dataVersionFilterIBParser.GetPath(&clusterPath); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = dataVersionFilterIBParser.GetDataVersion(&dataVersion); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(dataVersion, 2u); |
| } |
| |
| void BuildDataVersionFilterIBs(DataVersionFilterIBs::Builder & aDataVersionFilterIBsBuilder) |
| { |
| DataVersionFilterIB::Builder & dataVersionFilterIBBuilder = aDataVersionFilterIBsBuilder.CreateDataVersionFilter(); |
| EXPECT_EQ(aDataVersionFilterIBsBuilder.GetError(), CHIP_NO_ERROR); |
| BuildDataVersionFilterIB(dataVersionFilterIBBuilder); |
| EXPECT_SUCCESS(aDataVersionFilterIBsBuilder.EndOfDataVersionFilterIBs()); |
| EXPECT_EQ(aDataVersionFilterIBsBuilder.GetError(), CHIP_NO_ERROR); |
| } |
| |
| void ParseDataVersionFilterIBs(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| DataVersionFilterIBs::Parser dataVersionFilterIBsParser; |
| |
| err = dataVersionFilterIBsParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| DebugPrettyPrint(dataVersionFilterIBsParser); |
| } |
| |
| void BuildEventFilterIB(EventFilterIB::Builder & aEventFilterIBBuilder) |
| { |
| EXPECT_SUCCESS(aEventFilterIBBuilder.Node(1).EventMin(2).EndOfEventFilterIB()); |
| EXPECT_SUCCESS(aEventFilterIBBuilder.GetError()); |
| } |
| |
| void ParseEventFilterIB(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| EventFilterIB::Parser eventFilterIBParser; |
| chip::NodeId node = 1; |
| uint64_t eventMin = 2; |
| |
| err = eventFilterIBParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| DebugPrettyPrint(eventFilterIBParser); |
| err = eventFilterIBParser.GetNode(&node); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| EXPECT_EQ(node, 1u); |
| |
| err = eventFilterIBParser.GetEventMin(&eventMin); |
| EXPECT_EQ(eventMin, 2u); |
| } |
| |
| void BuildEventFilters(EventFilterIBs::Builder & aEventFiltersBuilder) |
| { |
| EventFilterIB::Builder & eventFilterBuilder = aEventFiltersBuilder.CreateEventFilter(); |
| EXPECT_EQ(aEventFiltersBuilder.GetError(), CHIP_NO_ERROR); |
| BuildEventFilterIB(eventFilterBuilder); |
| EXPECT_SUCCESS(aEventFiltersBuilder.EndOfEventFilters()); |
| EXPECT_EQ(aEventFiltersBuilder.GetError(), CHIP_NO_ERROR); |
| } |
| |
| void ParseEventFilters(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| EventFilterIBs::Parser eventFiltersParser; |
| |
| err = eventFiltersParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| DebugPrettyPrint(eventFiltersParser); |
| } |
| |
| void BuildAttributePathIB(AttributePathIB::Builder & aAttributePathBuilder) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| err = aAttributePathBuilder.EnableTagCompression(false) |
| .Node(1) |
| .Endpoint(2) |
| .Cluster(3) |
| .Attribute(4) |
| .ListIndex(5) |
| .EndOfAttributePathIB(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| } |
| |
| void ParseAttributePathIB(chip::TLV::TLVReader & aReader) |
| { |
| AttributePathIB::Parser attributePathParser; |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| bool enableTagCompression = true; |
| chip::NodeId node = 1; |
| chip::EndpointId endpoint = 2; |
| chip::ClusterId cluster = 3; |
| chip::AttributeId attribute = 4; |
| chip::ListIndex listIndex = 5; |
| |
| err = attributePathParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| DebugPrettyPrint(attributePathParser); |
| |
| err = attributePathParser.GetEnableTagCompression(&enableTagCompression); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_FALSE(enableTagCompression); |
| |
| err = attributePathParser.GetNode(&node); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(node, 1u); |
| |
| err = attributePathParser.GetEndpoint(&endpoint); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(endpoint, 2u); |
| |
| err = attributePathParser.GetCluster(&cluster); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(cluster, 3u); |
| |
| err = attributePathParser.GetAttribute(&attribute); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(attribute, 4u); |
| |
| err = attributePathParser.GetListIndex(&listIndex); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(listIndex, 5u); |
| } |
| |
| void BuildAttributePathList(AttributePathIBs::Builder & aAttributePathListBuilder) |
| { |
| AttributePathIB::Builder & attributePathBuilder = aAttributePathListBuilder.CreatePath(); |
| EXPECT_EQ(attributePathBuilder.GetError(), CHIP_NO_ERROR); |
| BuildAttributePathIB(attributePathBuilder); |
| |
| EXPECT_SUCCESS(aAttributePathListBuilder.EndOfAttributePathIBs()); |
| EXPECT_SUCCESS(aAttributePathListBuilder.GetError()); |
| } |
| |
| void ParseAttributePathList(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| AttributePathIBs::Parser attributePathListParser; |
| AttributePathIB::Parser attributePathParser; |
| |
| err = attributePathListParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(attributePathListParser); |
| } |
| |
| void BuildEventPath(EventPathIB::Builder & aEventPathBuilder) |
| { |
| EXPECT_SUCCESS(aEventPathBuilder.Node(1).Endpoint(2).Cluster(3).Event(4).IsUrgent(true).EndOfEventPathIB()); |
| EXPECT_SUCCESS(aEventPathBuilder.GetError()); |
| } |
| |
| void ParseEventPath(EventPathIB::Parser & aEventPathParser) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::NodeId node = 1; |
| chip::EndpointId endpoint = 2; |
| chip::ClusterId cluster = 3; |
| chip::EventId event = 4; |
| bool isUrgent = false; |
| |
| DebugPrettyPrint(aEventPathParser); |
| err = aEventPathParser.GetNode(&node); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(node, 1u); |
| |
| err = aEventPathParser.GetEndpoint(&endpoint); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(endpoint, 2u); |
| |
| err = aEventPathParser.GetCluster(&cluster); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(cluster, 3u); |
| |
| err = aEventPathParser.GetEvent(&event); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(event, 4u); |
| |
| err = aEventPathParser.GetIsUrgent(&isUrgent); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_TRUE(isUrgent); |
| } |
| |
| void BuildEventPaths(EventPathIBs::Builder & aEventPathsBuilder) |
| { |
| EventPathIB::Builder & eventPathBuilder = aEventPathsBuilder.CreatePath(); |
| EXPECT_EQ(eventPathBuilder.GetError(), CHIP_NO_ERROR); |
| BuildEventPath(eventPathBuilder); |
| |
| EXPECT_SUCCESS(aEventPathsBuilder.EndOfEventPaths()); |
| EXPECT_SUCCESS(aEventPathsBuilder.GetError()); |
| } |
| |
| void ParseEventPaths(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| EventPathIBs::Parser eventPathListParser; |
| |
| err = eventPathListParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| DebugPrettyPrint(eventPathListParser); |
| } |
| |
| void BuildCommandPath(CommandPathIB::Builder & aCommandPathBuilder) |
| { |
| EXPECT_SUCCESS(aCommandPathBuilder.EndpointId(1).ClusterId(3).CommandId(4).EndOfCommandPathIB()); |
| EXPECT_SUCCESS(aCommandPathBuilder.GetError()); |
| } |
| |
| void ParseCommandPath(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| CommandPathIB::Parser commandPathParser; |
| chip::EndpointId endpointId = 0; |
| chip::ClusterId clusterId = 0; |
| chip::CommandId commandId = 0; |
| |
| err = commandPathParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(commandPathParser); |
| err = commandPathParser.GetEndpointId(&endpointId); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(endpointId, 1u); |
| |
| err = commandPathParser.GetClusterId(&clusterId); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(clusterId, 3u); |
| |
| err = commandPathParser.GetCommandId(&commandId); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(commandId, 4u); |
| } |
| |
| void BuildEventDataIB(EventDataIB::Builder & aEventDataIBBuilder) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| |
| EventPathIB::Builder & eventPathBuilder = aEventDataIBBuilder.CreatePath(); |
| EXPECT_EQ(eventPathBuilder.GetError(), CHIP_NO_ERROR); |
| BuildEventPath(eventPathBuilder); |
| |
| aEventDataIBBuilder.EventNumber(2).Priority(3).EpochTimestamp(4).SystemTimestamp(5).DeltaEpochTimestamp(6).DeltaSystemTimestamp( |
| 7); |
| err = aEventDataIBBuilder.GetError(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| // Construct test event data |
| { |
| chip::TLV::TLVWriter * pWriter = aEventDataIBBuilder.GetWriter(); |
| chip::TLV::TLVType dummyType = chip::TLV::kTLVType_NotSpecified; |
| err = pWriter->StartContainer(chip::TLV::ContextTag(chip::to_underlying(EventDataIB::Tag::kData)), |
| chip::TLV::kTLVType_Structure, dummyType); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = pWriter->PutBoolean(chip::TLV::ContextTag(1), true); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = pWriter->EndContainer(dummyType); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| } |
| |
| EXPECT_SUCCESS(aEventDataIBBuilder.EndOfEventDataIB()); |
| } |
| |
| void ParseEventDataIB(EventDataIB::Parser & aEventDataIBParser) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| uint8_t priorityLevel = 0; |
| chip::EventNumber number = 0; |
| uint64_t EpochTimestamp = 0; |
| uint64_t systemTimestamp = 0; |
| uint64_t deltaUTCTimestamp = 0; |
| uint64_t deltaSystemTimestamp = 0; |
| |
| DebugPrettyPrint(aEventDataIBParser); |
| { |
| { |
| EventPathIB::Parser eventPath; |
| err = aEventDataIBParser.GetPath(&eventPath); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| } |
| err = aEventDataIBParser.GetEventNumber(&number); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(number, 2u); |
| |
| err = aEventDataIBParser.GetPriority(&priorityLevel); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(priorityLevel, 3u); |
| |
| err = aEventDataIBParser.GetEpochTimestamp(&EpochTimestamp); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(EpochTimestamp, 4u); |
| |
| err = aEventDataIBParser.GetSystemTimestamp(&systemTimestamp); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(systemTimestamp, 5u); |
| |
| err = aEventDataIBParser.GetDeltaEpochTimestamp(&deltaUTCTimestamp); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(deltaUTCTimestamp, 6u); |
| |
| err = aEventDataIBParser.GetDeltaSystemTimestamp(&deltaSystemTimestamp); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(deltaSystemTimestamp, 7u); |
| |
| { |
| chip::TLV::TLVReader reader; |
| bool val = false; |
| chip::TLV::TLVType container; |
| EXPECT_SUCCESS(aEventDataIBParser.GetData(&reader)); |
| err = reader.EnterContainer(container); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = reader.Get(val); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_TRUE(val); |
| |
| err = reader.ExitContainer(container); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| } |
| } |
| } |
| |
| void BuildEventStatusIB(EventStatusIB::Builder & aEventStatusIBBuilder) |
| { |
| EventPathIB::Builder & eventPathBuilder = aEventStatusIBBuilder.CreatePath(); |
| EXPECT_EQ(aEventStatusIBBuilder.GetError(), CHIP_NO_ERROR); |
| BuildEventPath(eventPathBuilder); |
| |
| StatusIB::Builder & statusIBBuilder = aEventStatusIBBuilder.CreateErrorStatus(); |
| EXPECT_EQ(statusIBBuilder.GetError(), CHIP_NO_ERROR); |
| BuildStatusIB(statusIBBuilder); |
| |
| EXPECT_SUCCESS(aEventStatusIBBuilder.EndOfEventStatusIB()); |
| EXPECT_SUCCESS(aEventStatusIBBuilder.GetError()); |
| } |
| |
| void ParseEventStatusIB(EventStatusIB::Parser & aEventStatusIBParser) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| EventPathIB::Parser eventPathParser; |
| StatusIB::Parser statusParser; |
| DebugPrettyPrint(aEventStatusIBParser); |
| err = aEventStatusIBParser.GetPath(&eventPathParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = aEventStatusIBParser.GetErrorStatus(&statusParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| } |
| |
| void BuildEventReportIB(EventReportIB::Builder & aEventReportIBBuilder) |
| { |
| EventDataIB::Builder & eventDataIBBuilder = aEventReportIBBuilder.CreateEventData(); |
| EXPECT_EQ(aEventReportIBBuilder.GetError(), CHIP_NO_ERROR); |
| BuildEventDataIB(eventDataIBBuilder); |
| |
| EXPECT_SUCCESS(aEventReportIBBuilder.EndOfEventReportIB()); |
| EXPECT_SUCCESS(aEventReportIBBuilder.GetError()); |
| } |
| |
| void ParseEventReportIB(EventReportIB::Parser & aEventReportIBParser) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| EventStatusIB::Parser eventStatusParser; |
| EventDataIB::Parser eventDataParser; |
| |
| DebugPrettyPrint(aEventReportIBParser); |
| |
| err = aEventReportIBParser.GetEventData(&eventDataParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| } |
| |
| void BuildEventReports(EventReportIBs::Builder & aEventReportsBuilder) |
| { |
| EventReportIB::Builder & eventReportIBBuilder = aEventReportsBuilder.CreateEventReport(); |
| EXPECT_EQ(aEventReportsBuilder.GetError(), CHIP_NO_ERROR); |
| BuildEventReportIB(eventReportIBBuilder); |
| EXPECT_SUCCESS(aEventReportsBuilder.EndOfEventReports()); |
| EXPECT_SUCCESS(aEventReportsBuilder.GetError()); |
| } |
| |
| void ParseEventReports(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| EventReportIBs::Parser eventReportsParser; |
| |
| err = eventReportsParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| DebugPrettyPrint(eventReportsParser); |
| } |
| |
| void BuildAttributeStatusIB(AttributeStatusIB::Builder & aAttributeStatusIBBuilder) |
| { |
| AttributePathIB::Builder & attributePathBuilder = aAttributeStatusIBBuilder.CreatePath(); |
| EXPECT_EQ(attributePathBuilder.GetError(), CHIP_NO_ERROR); |
| BuildAttributePathIB(attributePathBuilder); |
| |
| StatusIB::Builder & statusIBBuilder = aAttributeStatusIBBuilder.CreateErrorStatus(); |
| EXPECT_EQ(statusIBBuilder.GetError(), CHIP_NO_ERROR); |
| BuildStatusIB(statusIBBuilder); |
| |
| EXPECT_SUCCESS(aAttributeStatusIBBuilder.EndOfAttributeStatusIB()); |
| EXPECT_SUCCESS(aAttributeStatusIBBuilder.GetError()); |
| } |
| |
| void ParseAttributeStatusIB(AttributeStatusIB::Parser & aAttributeStatusIBParser) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| AttributePathIB::Parser attributePathParser; |
| StatusIB::Parser StatusIBParser; |
| |
| DebugPrettyPrint(aAttributeStatusIBParser); |
| err = aAttributeStatusIBParser.GetPath(&attributePathParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = aAttributeStatusIBParser.GetErrorStatus(&StatusIBParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| } |
| |
| void BuildAttributeStatuses(AttributeStatusIBs::Builder & aAttributeStatusesBuilder) |
| { |
| AttributeStatusIB::Builder & aAttributeStatusIBBuilder = aAttributeStatusesBuilder.CreateAttributeStatus(); |
| EXPECT_EQ(aAttributeStatusesBuilder.GetError(), CHIP_NO_ERROR); |
| BuildAttributeStatusIB(aAttributeStatusIBBuilder); |
| |
| EXPECT_SUCCESS(aAttributeStatusesBuilder.EndOfAttributeStatuses()); |
| EXPECT_SUCCESS(aAttributeStatusesBuilder.GetError()); |
| } |
| |
| void ParseAttributeStatuses(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| AttributeStatusIBs::Parser attributeStatusParser; |
| |
| err = attributeStatusParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(attributeStatusParser); |
| } |
| |
| void BuildAttributeDataIB(AttributeDataIB::Builder & aAttributeDataIBBuilder) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| |
| aAttributeDataIBBuilder.DataVersion(2); |
| AttributePathIB::Builder & attributePathBuilder = aAttributeDataIBBuilder.CreatePath(); |
| EXPECT_EQ(aAttributeDataIBBuilder.GetError(), CHIP_NO_ERROR); |
| BuildAttributePathIB(attributePathBuilder); |
| |
| // Construct attribute data |
| { |
| chip::TLV::TLVWriter * pWriter = aAttributeDataIBBuilder.GetWriter(); |
| chip::TLV::TLVType dummyType = chip::TLV::kTLVType_NotSpecified; |
| err = pWriter->StartContainer(chip::TLV::ContextTag(chip::to_underlying(AttributeDataIB::Tag::kData)), |
| chip::TLV::kTLVType_Structure, dummyType); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = pWriter->PutBoolean(chip::TLV::ContextTag(1), true); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = pWriter->EndContainer(dummyType); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| } |
| |
| EXPECT_SUCCESS(aAttributeDataIBBuilder.GetError()); |
| EXPECT_SUCCESS(aAttributeDataIBBuilder.EndOfAttributeDataIB()); |
| EXPECT_SUCCESS(aAttributeDataIBBuilder.GetError()); |
| } |
| |
| void ParseAttributeDataIB(AttributeDataIB::Parser & aAttributeDataIBParser) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| AttributePathIB::Parser attributePathParser; |
| chip::DataVersion version = 0; |
| DebugPrettyPrint(aAttributeDataIBParser); |
| err = aAttributeDataIBParser.GetPath(&attributePathParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = aAttributeDataIBParser.GetDataVersion(&version); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(version, 2u); |
| |
| { |
| chip::TLV::TLVReader reader; |
| bool val = false; |
| chip::TLV::TLVType container; |
| EXPECT_SUCCESS(aAttributeDataIBParser.GetData(&reader)); |
| err = reader.EnterContainer(container); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = reader.Get(val); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_TRUE(val); |
| |
| err = reader.ExitContainer(container); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| } |
| } |
| |
| void BuildAttributeDataIBs(AttributeDataIBs::Builder & aAttributeDataIBsBuilder) |
| { |
| AttributeDataIB::Builder & attributeDataIBBuilder = aAttributeDataIBsBuilder.CreateAttributeDataIBBuilder(); |
| EXPECT_EQ(aAttributeDataIBsBuilder.GetError(), CHIP_NO_ERROR); |
| BuildAttributeDataIB(attributeDataIBBuilder); |
| |
| EXPECT_SUCCESS(aAttributeDataIBsBuilder.EndOfAttributeDataIBs()); |
| EXPECT_SUCCESS(aAttributeDataIBsBuilder.GetError()); |
| } |
| |
| void ParseAttributeDataIBs(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| AttributeDataIBs::Parser AttributeDataIBsParser; |
| |
| err = AttributeDataIBsParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| DebugPrettyPrint(AttributeDataIBsParser); |
| } |
| |
| void BuildAttributeReportIB(AttributeReportIB::Builder & aAttributeReportIBBuilder) |
| { |
| AttributeDataIB::Builder & attributeDataIBBuilder = aAttributeReportIBBuilder.CreateAttributeData(); |
| EXPECT_EQ(aAttributeReportIBBuilder.GetError(), CHIP_NO_ERROR); |
| BuildAttributeDataIB(attributeDataIBBuilder); |
| |
| EXPECT_SUCCESS(aAttributeReportIBBuilder.EndOfAttributeReportIB()); |
| EXPECT_SUCCESS(aAttributeReportIBBuilder.GetError()); |
| } |
| |
| void ParseAttributeReportIB(AttributeReportIB::Parser & aAttributeReportIBParser) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| AttributeStatusIB::Parser attributeStatusParser; |
| AttributeDataIB::Parser attributeDataParser; |
| |
| DebugPrettyPrint(aAttributeReportIBParser); |
| err = aAttributeReportIBParser.GetAttributeData(&attributeDataParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| } |
| |
| void BuildAttributeReportIBs(AttributeReportIBs::Builder & aAttributeReportIBsBuilder) |
| { |
| AttributeReportIB::Builder & attributeReportIBBuilder = aAttributeReportIBsBuilder.CreateAttributeReport(); |
| EXPECT_EQ(aAttributeReportIBsBuilder.GetError(), CHIP_NO_ERROR); |
| BuildAttributeReportIB(attributeReportIBBuilder); |
| |
| EXPECT_SUCCESS(aAttributeReportIBsBuilder.EndOfAttributeReportIBs()); |
| EXPECT_SUCCESS(aAttributeReportIBsBuilder.GetError()); |
| } |
| |
| void ParseAttributeReportIBs(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| AttributeReportIBs::Parser attributeReportIBsParser; |
| |
| err = attributeReportIBsParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| #if CHIP_CONFIG_IM_PRETTY_PRINT |
| EXPECT_SUCCESS(attributeReportIBsParser.PrettyPrint()); |
| #endif |
| } |
| |
| void BuildCommandDataIB(CommandDataIB::Builder & aCommandDataIBBuilder) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| |
| CommandPathIB::Builder & commandPathBuilder = aCommandDataIBBuilder.CreatePath(); |
| EXPECT_EQ(aCommandDataIBBuilder.GetError(), CHIP_NO_ERROR); |
| BuildCommandPath(commandPathBuilder); |
| |
| // Construct command data |
| { |
| chip::TLV::TLVWriter * pWriter = aCommandDataIBBuilder.GetWriter(); |
| chip::TLV::TLVType dummyType = chip::TLV::kTLVType_NotSpecified; |
| err = pWriter->StartContainer(chip::TLV::ContextTag(chip::to_underlying(CommandDataIB::Tag::kFields)), |
| chip::TLV::kTLVType_Structure, dummyType); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = pWriter->PutBoolean(chip::TLV::ContextTag(1), true); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = pWriter->EndContainer(dummyType); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| } |
| |
| EXPECT_SUCCESS(aCommandDataIBBuilder.EndOfCommandDataIB()); |
| EXPECT_SUCCESS(aCommandDataIBBuilder.GetError()); |
| } |
| |
| void ParseCommandDataIB(CommandDataIB::Parser & aCommandDataIBParser) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| CommandPathIB::Parser commandPathParser; |
| DebugPrettyPrint(aCommandDataIBParser); |
| err = aCommandDataIBParser.GetPath(&commandPathParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| { |
| chip::TLV::TLVReader reader; |
| bool val = false; |
| chip::TLV::TLVType container; |
| EXPECT_SUCCESS(aCommandDataIBParser.GetFields(&reader)); |
| err = reader.EnterContainer(container); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = reader.Get(val); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_TRUE(val); |
| |
| err = reader.ExitContainer(container); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| } |
| } |
| |
| void BuildCommandStatusIB(CommandStatusIB::Builder & aCommandStatusIBBuilder) |
| { |
| CommandPathIB::Builder & commandPathBuilder = aCommandStatusIBBuilder.CreatePath(); |
| EXPECT_EQ(aCommandStatusIBBuilder.GetError(), CHIP_NO_ERROR); |
| BuildCommandPath(commandPathBuilder); |
| |
| StatusIB::Builder & statusIBBuilder = aCommandStatusIBBuilder.CreateErrorStatus(); |
| EXPECT_EQ(statusIBBuilder.GetError(), CHIP_NO_ERROR); |
| BuildStatusIB(statusIBBuilder); |
| |
| EXPECT_SUCCESS(aCommandStatusIBBuilder.EndOfCommandStatusIB()); |
| } |
| |
| void ParseCommandStatusIB(CommandStatusIB::Parser & aCommandStatusIBParser) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| CommandPathIB::Parser commandPathParser; |
| StatusIB::Parser statusParser; |
| DebugPrettyPrint(aCommandStatusIBParser); |
| err = aCommandStatusIBParser.GetPath(&commandPathParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = aCommandStatusIBParser.GetErrorStatus(&statusParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| } |
| |
| void BuildWrongInvokeResponseIB(InvokeResponseIB::Builder & aInvokeResponseIBBuilder) |
| { |
| aInvokeResponseIBBuilder.CreateCommand(); |
| EXPECT_EQ(aInvokeResponseIBBuilder.GetError(), CHIP_NO_ERROR); |
| } |
| |
| void BuildInvokeResponseIBWithCommandDataIB(InvokeResponseIB::Builder & aInvokeResponseIBBuilder) |
| { |
| CommandDataIB::Builder & commandDataBuilder = aInvokeResponseIBBuilder.CreateCommand(); |
| EXPECT_EQ(aInvokeResponseIBBuilder.GetError(), CHIP_NO_ERROR); |
| BuildCommandDataIB(commandDataBuilder); |
| EXPECT_SUCCESS(aInvokeResponseIBBuilder.EndOfInvokeResponseIB()); |
| EXPECT_SUCCESS(aInvokeResponseIBBuilder.GetError()); |
| } |
| |
| void BuildInvokeResponseIBWithCommandStatusIB(InvokeResponseIB::Builder & aInvokeResponseIBBuilder) |
| { |
| CommandStatusIB::Builder & commandStatusBuilder = aInvokeResponseIBBuilder.CreateStatus(); |
| EXPECT_EQ(aInvokeResponseIBBuilder.GetError(), CHIP_NO_ERROR); |
| BuildCommandStatusIB(commandStatusBuilder); |
| EXPECT_SUCCESS(aInvokeResponseIBBuilder.EndOfInvokeResponseIB()); |
| EXPECT_SUCCESS(aInvokeResponseIBBuilder.GetError()); |
| } |
| |
| void ParseInvokeResponseIBWithCommandDataIB(InvokeResponseIB::Parser & aInvokeResponseIBParser) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| CommandDataIB::Parser commandDataParser; |
| CommandStatusIB::Parser statusIBParser; |
| DebugPrettyPrint(aInvokeResponseIBParser); |
| err = aInvokeResponseIBParser.GetCommand(&commandDataParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| } |
| |
| void ParseInvokeResponseIBWithCommandStatusIB(InvokeResponseIB::Parser & aInvokeResponseIBParser) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| CommandDataIB::Parser commandDataParser; |
| CommandStatusIB::Parser statusIBParser; |
| DebugPrettyPrint(aInvokeResponseIBParser); |
| err = aInvokeResponseIBParser.GetStatus(&statusIBParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| } |
| |
| void BuildInvokeRequests(InvokeRequests::Builder & aInvokeRequestsBuilder) |
| { |
| CommandDataIB::Builder & aCommandDataIBBuilder = aInvokeRequestsBuilder.CreateCommandData(); |
| EXPECT_EQ(aInvokeRequestsBuilder.GetError(), CHIP_NO_ERROR); |
| BuildCommandDataIB(aCommandDataIBBuilder); |
| |
| EXPECT_SUCCESS(aInvokeRequestsBuilder.EndOfInvokeRequests()); |
| EXPECT_SUCCESS(aInvokeRequestsBuilder.GetError()); |
| } |
| |
| void ParseInvokeRequests(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| InvokeRequests::Parser invokeRequestsParser; |
| err = invokeRequestsParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(invokeRequestsParser); |
| } |
| |
| void BuildInvokeResponses(InvokeResponseIBs::Builder & aInvokeResponsesBuilder) |
| { |
| InvokeResponseIB::Builder & invokeResponseIBBuilder = aInvokeResponsesBuilder.CreateInvokeResponse(); |
| EXPECT_EQ(aInvokeResponsesBuilder.GetError(), CHIP_NO_ERROR); |
| BuildInvokeResponseIBWithCommandDataIB(invokeResponseIBBuilder); |
| |
| EXPECT_SUCCESS(aInvokeResponsesBuilder.EndOfInvokeResponses()); |
| EXPECT_SUCCESS(aInvokeResponsesBuilder.GetError()); |
| } |
| |
| void ParseInvokeResponses(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| InvokeResponseIBs::Parser invokeResponsesParser; |
| err = invokeResponsesParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(invokeResponsesParser); |
| } |
| |
| void BuildInvokeRequestMessage(chip::TLV::TLVWriter & aWriter) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| InvokeRequestMessage::Builder invokeRequestMessageBuilder; |
| err = invokeRequestMessageBuilder.Init(&aWriter); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| invokeRequestMessageBuilder.SuppressResponse(true); |
| invokeRequestMessageBuilder.TimedRequest(true); |
| InvokeRequests::Builder & invokeRequestsBuilder = invokeRequestMessageBuilder.CreateInvokeRequests(); |
| EXPECT_EQ(invokeRequestsBuilder.GetError(), CHIP_NO_ERROR); |
| |
| BuildInvokeRequests(invokeRequestsBuilder); |
| |
| EXPECT_SUCCESS(invokeRequestMessageBuilder.EndOfInvokeRequestMessage()); |
| EXPECT_SUCCESS(invokeRequestMessageBuilder.GetError()); |
| } |
| |
| void ParseInvokeRequestMessage(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| InvokeRequestMessage::Parser invokeRequestMessageParser; |
| err = invokeRequestMessageParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| bool suppressResponse = false; |
| bool timedRequest = false; |
| EXPECT_SUCCESS(invokeRequestMessageParser.GetSuppressResponse(&suppressResponse)); |
| EXPECT_SUCCESS(invokeRequestMessageParser.GetTimedRequest(&timedRequest)); |
| EXPECT_TRUE(suppressResponse); |
| EXPECT_TRUE(timedRequest); |
| DebugPrettyPrint(invokeRequestMessageParser); |
| EXPECT_EQ(invokeRequestMessageParser.ExitContainer(), CHIP_NO_ERROR); |
| } |
| |
| void BuildInvokeResponseMessage(chip::TLV::TLVWriter & aWriter) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| InvokeResponseMessage::Builder invokeResponseMessageBuilder; |
| err = invokeResponseMessageBuilder.Init(&aWriter); |
| |
| invokeResponseMessageBuilder.SuppressResponse(true); |
| InvokeResponseIBs::Builder & invokeResponsesBuilder = invokeResponseMessageBuilder.CreateInvokeResponses(); |
| EXPECT_EQ(invokeResponseMessageBuilder.GetError(), CHIP_NO_ERROR); |
| |
| BuildInvokeResponses(invokeResponsesBuilder); |
| |
| invokeResponseMessageBuilder.MoreChunkedMessages(true); |
| EXPECT_EQ(invokeResponseMessageBuilder.GetError(), CHIP_NO_ERROR); |
| |
| EXPECT_SUCCESS(invokeResponseMessageBuilder.EndOfInvokeResponseMessage()); |
| EXPECT_SUCCESS(invokeResponseMessageBuilder.GetError()); |
| } |
| |
| void ParseInvokeResponseMessage(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| InvokeResponseMessage::Parser invokeResponseMessageParser; |
| err = invokeResponseMessageParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| bool suppressResponse = false; |
| err = invokeResponseMessageParser.GetSuppressResponse(&suppressResponse); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_TRUE(suppressResponse); |
| |
| bool moreChunkedMessages = true; |
| err = invokeResponseMessageParser.GetMoreChunkedMessages(&suppressResponse); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_TRUE(moreChunkedMessages); |
| |
| DebugPrettyPrint(invokeResponseMessageParser); |
| EXPECT_EQ(invokeResponseMessageParser.ExitContainer(), CHIP_NO_ERROR); |
| } |
| |
| void BuildReportDataMessage(chip::TLV::TLVWriter & aWriter) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| ReportDataMessage::Builder reportDataMessageBuilder; |
| |
| err = reportDataMessageBuilder.Init(&aWriter); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| reportDataMessageBuilder.SubscriptionId(2); |
| EXPECT_EQ(reportDataMessageBuilder.GetError(), CHIP_NO_ERROR); |
| |
| AttributeReportIBs::Builder & attributeReportIBs = reportDataMessageBuilder.CreateAttributeReportIBs(); |
| EXPECT_EQ(reportDataMessageBuilder.GetError(), CHIP_NO_ERROR); |
| BuildAttributeReportIBs(attributeReportIBs); |
| |
| EventReportIBs::Builder & eventReportIBs = reportDataMessageBuilder.CreateEventReports(); |
| EXPECT_EQ(reportDataMessageBuilder.GetError(), CHIP_NO_ERROR); |
| BuildEventReports(eventReportIBs); |
| |
| reportDataMessageBuilder.MoreChunkedMessages(true).SuppressResponse(true); |
| EXPECT_EQ(reportDataMessageBuilder.GetError(), CHIP_NO_ERROR); |
| |
| EXPECT_SUCCESS(reportDataMessageBuilder.EndOfReportDataMessage()); |
| EXPECT_SUCCESS(reportDataMessageBuilder.GetError()); |
| } |
| |
| void ParseReportDataMessage(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| ReportDataMessage::Parser reportDataParser; |
| |
| bool suppressResponse = false; |
| chip::SubscriptionId subscriptionId = 0; |
| AttributeReportIBs::Parser attributeReportIBsParser; |
| EventReportIBs::Parser eventReportsParser; |
| bool moreChunkedMessages = false; |
| EXPECT_SUCCESS(reportDataParser.Init(aReader)); |
| |
| DebugPrettyPrint(reportDataParser); |
| err = reportDataParser.GetSuppressResponse(&suppressResponse); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_TRUE(suppressResponse); |
| |
| err = reportDataParser.GetSubscriptionId(&subscriptionId); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(subscriptionId, 2u); |
| |
| err = reportDataParser.GetAttributeReportIBs(&attributeReportIBsParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = reportDataParser.GetEventReports(&eventReportsParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = reportDataParser.GetMoreChunkedMessages(&moreChunkedMessages); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_TRUE(moreChunkedMessages); |
| EXPECT_EQ(reportDataParser.ExitContainer(), CHIP_NO_ERROR); |
| } |
| |
| void BuildReadRequestMessage(chip::TLV::TLVWriter & aWriter) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| ReadRequestMessage::Builder readRequestBuilder; |
| |
| err = readRequestBuilder.Init(&aWriter); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| AttributePathIBs::Builder & attributePathIBs = readRequestBuilder.CreateAttributeRequests(); |
| EXPECT_EQ(readRequestBuilder.GetError(), CHIP_NO_ERROR); |
| BuildAttributePathList(attributePathIBs); |
| |
| EventPathIBs::Builder & eventPathList = readRequestBuilder.CreateEventRequests(); |
| |
| EXPECT_EQ(readRequestBuilder.GetError(), CHIP_NO_ERROR); |
| BuildEventPaths(eventPathList); |
| |
| EventFilterIBs::Builder & eventFilters = readRequestBuilder.CreateEventFilters(); |
| EXPECT_EQ(readRequestBuilder.GetError(), CHIP_NO_ERROR); |
| BuildEventFilters(eventFilters); |
| |
| readRequestBuilder.IsFabricFiltered(true); |
| EXPECT_EQ(readRequestBuilder.GetError(), CHIP_NO_ERROR); |
| |
| DataVersionFilterIBs::Builder & dataVersionFilters = readRequestBuilder.CreateDataVersionFilters(); |
| EXPECT_EQ(readRequestBuilder.GetError(), CHIP_NO_ERROR); |
| BuildDataVersionFilterIBs(dataVersionFilters); |
| |
| EXPECT_SUCCESS(readRequestBuilder.EndOfReadRequestMessage()); |
| EXPECT_SUCCESS(readRequestBuilder.GetError()); |
| } |
| |
| void ParseReadRequestMessage(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| |
| ReadRequestMessage::Parser readRequestParser; |
| AttributePathIBs::Parser attributePathListParser; |
| DataVersionFilterIBs::Parser dataVersionFilterIBsParser; |
| EventPathIBs::Parser eventPathListParser; |
| EventFilterIBs::Parser eventFiltersParser; |
| bool isFabricFiltered = false; |
| |
| err = readRequestParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| DebugPrettyPrint(readRequestParser); |
| err = readRequestParser.GetAttributeRequests(&attributePathListParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = readRequestParser.GetDataVersionFilters(&dataVersionFilterIBsParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = readRequestParser.GetEventRequests(&eventPathListParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = readRequestParser.GetEventFilters(&eventFiltersParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = readRequestParser.GetIsFabricFiltered(&isFabricFiltered); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_TRUE(isFabricFiltered); |
| EXPECT_EQ(readRequestParser.ExitContainer(), CHIP_NO_ERROR); |
| } |
| |
| void BuildWriteRequestMessage(chip::TLV::TLVWriter & aWriter) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| WriteRequestMessage::Builder writeRequestBuilder; |
| |
| err = writeRequestBuilder.Init(&aWriter); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| writeRequestBuilder.SuppressResponse(true); |
| EXPECT_EQ(writeRequestBuilder.GetError(), CHIP_NO_ERROR); |
| |
| writeRequestBuilder.TimedRequest(true); |
| EXPECT_EQ(writeRequestBuilder.GetError(), CHIP_NO_ERROR); |
| |
| AttributeDataIBs::Builder & attributeDataIBs = writeRequestBuilder.CreateWriteRequests(); |
| EXPECT_EQ(writeRequestBuilder.GetError(), CHIP_NO_ERROR); |
| BuildAttributeDataIBs(attributeDataIBs); |
| |
| writeRequestBuilder.MoreChunkedMessages(true); |
| EXPECT_EQ(writeRequestBuilder.GetError(), CHIP_NO_ERROR); |
| |
| EXPECT_SUCCESS(writeRequestBuilder.EndOfWriteRequestMessage()); |
| EXPECT_SUCCESS(writeRequestBuilder.GetError()); |
| } |
| |
| void ParseWriteRequestMessage(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| |
| WriteRequestMessage::Parser writeRequestParser; |
| bool suppressResponse = false; |
| bool timeRequest = false; |
| AttributeDataIBs::Parser writeRequests; |
| bool moreChunkedMessages = false; |
| |
| err = writeRequestParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| DebugPrettyPrint(writeRequestParser); |
| err = writeRequestParser.GetSuppressResponse(&suppressResponse); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_TRUE(suppressResponse); |
| |
| err = writeRequestParser.GetTimedRequest(&timeRequest); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_TRUE(timeRequest); |
| |
| err = writeRequestParser.GetWriteRequests(&writeRequests); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writeRequestParser.GetMoreChunkedMessages(&moreChunkedMessages); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_TRUE(moreChunkedMessages); |
| } |
| |
| void BuildWriteResponseMessage(chip::TLV::TLVWriter & aWriter) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| WriteResponseMessage::Builder writeResponseBuilder; |
| |
| err = writeResponseBuilder.Init(&aWriter); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| AttributeStatusIBs::Builder & attributeStatuses = writeResponseBuilder.CreateWriteResponses(); |
| EXPECT_EQ(writeResponseBuilder.GetError(), CHIP_NO_ERROR); |
| BuildAttributeStatuses(attributeStatuses); |
| |
| EXPECT_SUCCESS(writeResponseBuilder.EndOfWriteResponseMessage()); |
| EXPECT_SUCCESS(writeResponseBuilder.GetError()); |
| } |
| |
| void ParseWriteResponseMessage(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| |
| WriteResponseMessage::Parser writeResponseParser; |
| AttributeStatusIBs::Parser attributeStatusesParser; |
| err = writeResponseParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| DebugPrettyPrint(writeResponseParser); |
| err = writeResponseParser.GetWriteResponses(&attributeStatusesParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(writeResponseParser.ExitContainer(), CHIP_NO_ERROR); |
| } |
| |
| void BuildSubscribeRequestMessage(chip::TLV::TLVWriter & aWriter) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| SubscribeRequestMessage::Builder subscribeRequestBuilder; |
| |
| err = subscribeRequestBuilder.Init(&aWriter); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| subscribeRequestBuilder.KeepSubscriptions(true); |
| EXPECT_EQ(subscribeRequestBuilder.GetError(), CHIP_NO_ERROR); |
| |
| subscribeRequestBuilder.MinIntervalFloorSeconds(2); |
| EXPECT_EQ(subscribeRequestBuilder.GetError(), CHIP_NO_ERROR); |
| |
| subscribeRequestBuilder.MaxIntervalCeilingSeconds(3); |
| EXPECT_EQ(subscribeRequestBuilder.GetError(), CHIP_NO_ERROR); |
| |
| AttributePathIBs::Builder & attributePathIBs = subscribeRequestBuilder.CreateAttributeRequests(); |
| EXPECT_EQ(subscribeRequestBuilder.GetError(), CHIP_NO_ERROR); |
| BuildAttributePathList(attributePathIBs); |
| |
| EventPathIBs::Builder & eventPathList = subscribeRequestBuilder.CreateEventRequests(); |
| |
| EXPECT_EQ(subscribeRequestBuilder.GetError(), CHIP_NO_ERROR); |
| BuildEventPaths(eventPathList); |
| |
| EventFilterIBs::Builder & eventFilters = subscribeRequestBuilder.CreateEventFilters(); |
| EXPECT_EQ(subscribeRequestBuilder.GetError(), CHIP_NO_ERROR); |
| BuildEventFilters(eventFilters); |
| |
| subscribeRequestBuilder.IsFabricFiltered(true); |
| EXPECT_EQ(subscribeRequestBuilder.GetError(), CHIP_NO_ERROR); |
| |
| DataVersionFilterIBs::Builder & dataVersionFilters = subscribeRequestBuilder.CreateDataVersionFilters(); |
| EXPECT_EQ(subscribeRequestBuilder.GetError(), CHIP_NO_ERROR); |
| BuildDataVersionFilterIBs(dataVersionFilters); |
| |
| EXPECT_SUCCESS(subscribeRequestBuilder.EndOfSubscribeRequestMessage()); |
| EXPECT_SUCCESS(subscribeRequestBuilder.GetError()); |
| } |
| |
| void ParseSubscribeRequestMessage(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| |
| SubscribeRequestMessage::Parser subscribeRequestParser; |
| AttributePathIBs::Parser attributePathListParser; |
| DataVersionFilterIBs::Parser dataVersionFilterIBsParser; |
| EventPathIBs::Parser eventPathListParser; |
| EventFilterIBs::Parser eventFiltersParser; |
| uint16_t minIntervalFloorSeconds = 0; |
| uint16_t maxIntervalCeilingSeconds = 0; |
| bool keepExistingSubscription = false; |
| bool isFabricFiltered = false; |
| |
| err = subscribeRequestParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| DebugPrettyPrint(subscribeRequestParser); |
| err = subscribeRequestParser.GetAttributeRequests(&attributePathListParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = subscribeRequestParser.GetDataVersionFilters(&dataVersionFilterIBsParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = subscribeRequestParser.GetEventRequests(&eventPathListParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = subscribeRequestParser.GetEventFilters(&eventFiltersParser); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = subscribeRequestParser.GetMinIntervalFloorSeconds(&minIntervalFloorSeconds); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(minIntervalFloorSeconds, 2u); |
| |
| err = subscribeRequestParser.GetMaxIntervalCeilingSeconds(&maxIntervalCeilingSeconds); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(maxIntervalCeilingSeconds, 3u); |
| |
| err = subscribeRequestParser.GetKeepSubscriptions(&keepExistingSubscription); |
| EXPECT_TRUE(keepExistingSubscription); |
| |
| err = subscribeRequestParser.GetIsFabricFiltered(&isFabricFiltered); |
| EXPECT_TRUE(isFabricFiltered); |
| EXPECT_EQ(subscribeRequestParser.ExitContainer(), CHIP_NO_ERROR); |
| } |
| |
| void BuildSubscribeResponseMessage(chip::TLV::TLVWriter & aWriter) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| SubscribeResponseMessage::Builder subscribeResponseBuilder; |
| |
| err = subscribeResponseBuilder.Init(&aWriter); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| subscribeResponseBuilder.SubscriptionId(1); |
| EXPECT_EQ(subscribeResponseBuilder.GetError(), CHIP_NO_ERROR); |
| |
| subscribeResponseBuilder.MaxInterval(2); |
| EXPECT_EQ(subscribeResponseBuilder.GetError(), CHIP_NO_ERROR); |
| |
| EXPECT_SUCCESS(subscribeResponseBuilder.EndOfSubscribeResponseMessage()); |
| EXPECT_SUCCESS(subscribeResponseBuilder.GetError()); |
| } |
| |
| void ParseSubscribeResponseMessage(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| |
| SubscribeResponseMessage::Parser subscribeResponseParser; |
| chip::SubscriptionId subscriptionId = 0; |
| uint16_t maxInterval = 0; |
| err = subscribeResponseParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| DebugPrettyPrint(subscribeResponseParser); |
| err = subscribeResponseParser.GetSubscriptionId(&subscriptionId); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(subscriptionId, 1u); |
| |
| err = subscribeResponseParser.GetMaxInterval(&maxInterval); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| EXPECT_EQ(maxInterval, 2u); |
| |
| EXPECT_EQ(subscribeResponseParser.ExitContainer(), CHIP_NO_ERROR); |
| } |
| |
| void BuildTimedRequestMessage(chip::TLV::TLVWriter & aWriter) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| TimedRequestMessage::Builder TimedRequestMessageBuilder; |
| |
| err = TimedRequestMessageBuilder.Init(&aWriter); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| TimedRequestMessageBuilder.TimeoutMs(1); |
| EXPECT_EQ(TimedRequestMessageBuilder.GetError(), CHIP_NO_ERROR); |
| } |
| |
| void ParseTimedRequestMessage(chip::TLV::TLVReader & aReader) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| |
| TimedRequestMessage::Parser timedRequestMessageParser; |
| uint16_t timeout = 0; |
| |
| err = timedRequestMessageParser.Init(aReader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| DebugPrettyPrint(timedRequestMessageParser); |
| err = timedRequestMessageParser.GetTimeoutMs(&timeout); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| EXPECT_EQ(timeout, 1u); |
| |
| EXPECT_EQ(timedRequestMessageParser.ExitContainer(), CHIP_NO_ERROR); |
| } |
| |
| TEST_F(TestMessageDef, TestDataVersionFilterIB) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| DataVersionFilterIB::Builder dataVersionFilterIBBuilder; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(dataVersionFilterIBBuilder.Init(&writer)); |
| BuildDataVersionFilterIB(dataVersionFilterIBBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| ParseDataVersionFilterIB(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestDataVersionFilterIBs) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| DataVersionFilterIBs::Builder dataVersionFilterIBsBuilder; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| |
| err = dataVersionFilterIBsBuilder.Init(&writer); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| BuildDataVersionFilterIBs(dataVersionFilterIBsBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| ParseDataVersionFilterIBs(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestEventFilter) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| EventFilterIB::Builder eventFilterBuilder; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(eventFilterBuilder.Init(&writer)); |
| BuildEventFilterIB(eventFilterBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| ParseEventFilterIB(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestEventFilters) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| EventFilterIBs::Builder eventFiltersBuilder; |
| EventFilterIBs::Parser eventFiltersParser; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| |
| err = eventFiltersBuilder.Init(&writer); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| BuildEventFilters(eventFiltersBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| ParseEventFilters(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestClusterPathIB) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| ClusterPathIB::Builder clusterPathBuilder; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(clusterPathBuilder.Init(&writer)); |
| BuildClusterPathIB(clusterPathBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| ParseClusterPathIB(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestAttributePath) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| AttributePathIB::Builder attributePathBuilder; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(attributePathBuilder.Init(&writer)); |
| BuildAttributePathIB(attributePathBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| ParseAttributePathIB(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestAttributePathList) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| AttributePathIBs::Builder attributePathListBuilder; |
| |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| |
| err = attributePathListBuilder.Init(&writer); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| BuildAttributePathList(attributePathListBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| ParseAttributePathList(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestEventPath) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| EventPathIB::Parser eventPathParser; |
| EventPathIB::Builder eventPathBuilder; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(eventPathBuilder.Init(&writer)); |
| BuildEventPath(eventPathBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| EXPECT_SUCCESS(eventPathParser.Init(reader)); |
| ParseEventPath(eventPathParser); |
| } |
| |
| TEST_F(TestMessageDef, TestEventPaths) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| EventPathIBs::Builder eventPathListBuilder; |
| |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| |
| err = eventPathListBuilder.Init(&writer); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| BuildEventPaths(eventPathListBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| ParseEventPaths(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestCommandPathIB) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| CommandPathIB::Builder commandPathBuilder; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| err = commandPathBuilder.Init(&writer); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| BuildCommandPath(commandPathBuilder); |
| |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| ParseCommandPath(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestEventDataIB) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| EventDataIB::Builder eventDataIBBuilder; |
| EventDataIB::Parser eventDataIBParser; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(eventDataIBBuilder.Init(&writer)); |
| BuildEventDataIB(eventDataIBBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| EXPECT_SUCCESS(eventDataIBParser.Init(reader)); |
| ParseEventDataIB(eventDataIBParser); |
| } |
| |
| TEST_F(TestMessageDef, TestEventReportIB) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| EventReportIB::Builder eventReportIBBuilder; |
| EventReportIB::Parser eventReportIBParser; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(eventReportIBBuilder.Init(&writer)); |
| BuildEventReportIB(eventReportIBBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| EXPECT_EQ(eventReportIBParser.Init(reader), CHIP_NO_ERROR); |
| ParseEventReportIB(eventReportIBParser); |
| } |
| |
| TEST_F(TestMessageDef, TestEventReports) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| EventReportIBs::Builder eventReportsBuilder; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(eventReportsBuilder.Init(&writer)); |
| BuildEventReports(eventReportsBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| ParseEventReports(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestEmptyEventReports) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| EventReportIBs::Builder eventReportsBuilder; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(eventReportsBuilder.Init(&writer)); |
| EXPECT_SUCCESS(eventReportsBuilder.EndOfEventReports()); |
| EXPECT_EQ(eventReportsBuilder.GetError(), CHIP_NO_ERROR); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| ParseEventReports(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestAttributeReportIB) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| AttributeReportIB::Builder attributeReportIBBuilder; |
| AttributeReportIB::Parser attributeReportIBParser; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(attributeReportIBBuilder.Init(&writer)); |
| BuildAttributeReportIB(attributeReportIBBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| EXPECT_SUCCESS(attributeReportIBParser.Init(reader)); |
| ParseAttributeReportIB(attributeReportIBParser); |
| } |
| |
| TEST_F(TestMessageDef, TestAttributeReportIBs) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| AttributeReportIBs::Builder attributeReportIBsBuilder; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(attributeReportIBsBuilder.Init(&writer)); |
| BuildAttributeReportIBs(attributeReportIBsBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| ParseAttributeReportIBs(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestEmptyAttributeReportIBs) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| AttributeReportIBs::Builder attributeReportIBsBuilder; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(attributeReportIBsBuilder.Init(&writer)); |
| EXPECT_SUCCESS(attributeReportIBsBuilder.EndOfAttributeReportIBs()); |
| EXPECT_EQ(attributeReportIBsBuilder.GetError(), CHIP_NO_ERROR); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| ParseAttributeReportIBs(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestStatusIB) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| StatusIB::Builder statusIBBuilder; |
| StatusIB::Parser StatusIBParser; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(statusIBBuilder.Init(&writer)); |
| BuildStatusIB(statusIBBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| EXPECT_SUCCESS(StatusIBParser.Init(reader)); |
| ParseStatusIB(StatusIBParser); |
| } |
| |
| TEST_F(TestMessageDef, TestEventStatusIB) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| EventStatusIB::Builder eventStatusIBBuilder; |
| EventStatusIB::Parser eventStatusIBParser; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(eventStatusIBBuilder.Init(&writer)); |
| BuildEventStatusIB(eventStatusIBBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| EXPECT_SUCCESS(eventStatusIBParser.Init(reader)); |
| ParseEventStatusIB(eventStatusIBParser); |
| } |
| |
| TEST_F(TestMessageDef, TestAttributeStatusIB) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| AttributeStatusIB::Builder attributeStatusIBBuilder; |
| AttributeStatusIB::Parser attributeStatusIBParser; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(attributeStatusIBBuilder.Init(&writer)); |
| BuildAttributeStatusIB(attributeStatusIBBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| EXPECT_SUCCESS(attributeStatusIBParser.Init(reader)); |
| ParseAttributeStatusIB(attributeStatusIBParser); |
| } |
| |
| TEST_F(TestMessageDef, TestAttributeStatuses) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| AttributeStatusIBs::Builder attributeStatusesBuilder; |
| err = attributeStatusesBuilder.Init(&writer); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| BuildAttributeStatuses(attributeStatusesBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| ParseAttributeStatuses(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestAttributeDataIB) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| AttributeDataIB::Builder AttributeDataIBBuilder; |
| AttributeDataIB::Parser AttributeDataIBParser; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(AttributeDataIBBuilder.Init(&writer)); |
| BuildAttributeDataIB(AttributeDataIBBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| EXPECT_SUCCESS(AttributeDataIBParser.Init(reader)); |
| ParseAttributeDataIB(AttributeDataIBParser); |
| } |
| |
| TEST_F(TestMessageDef, TestAttributeDataIBs) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| AttributeDataIBs::Builder AttributeDataIBsBuilder; |
| EXPECT_SUCCESS(AttributeDataIBsBuilder.Init(&writer)); |
| BuildAttributeDataIBs(AttributeDataIBsBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| ParseAttributeDataIBs(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestCommandDataIB) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| CommandDataIB::Builder commandDataIBBuilder; |
| CommandDataIB::Parser commandDataIBParser; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(commandDataIBBuilder.Init(&writer)); |
| BuildCommandDataIB(commandDataIBBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| EXPECT_SUCCESS(commandDataIBParser.Init(reader)); |
| ParseCommandDataIB(commandDataIBParser); |
| } |
| |
| TEST_F(TestMessageDef, TestCommandStatusIB) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| CommandStatusIB::Builder commandStatusIBBuilder; |
| CommandStatusIB::Parser commandStatusIBParser; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(commandStatusIBBuilder.Init(&writer)); |
| BuildCommandStatusIB(commandStatusIBBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| EXPECT_SUCCESS(commandStatusIBParser.Init(reader)); |
| ParseCommandStatusIB(commandStatusIBParser); |
| } |
| |
| TEST_F(TestMessageDef, TestInvokeResponseIBWithCommandDataIB) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| InvokeResponseIB::Builder invokeResponseIBBuilder; |
| InvokeResponseIB::Parser invokeResponseIBParser; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(invokeResponseIBBuilder.Init(&writer)); |
| BuildInvokeResponseIBWithCommandDataIB(invokeResponseIBBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| EXPECT_SUCCESS(invokeResponseIBParser.Init(reader)); |
| ParseInvokeResponseIBWithCommandDataIB(invokeResponseIBParser); |
| } |
| |
| TEST_F(TestMessageDef, TestInvokeResponseIBWithCommandStatusIB) |
| { |
| InvokeResponseIB::Builder invokeResponseIBBuilder; |
| InvokeResponseIB::Parser invokeResponseIBParser; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(invokeResponseIBBuilder.Init(&writer)); |
| BuildInvokeResponseIBWithCommandStatusIB(invokeResponseIBBuilder); |
| chip::System::PacketBufferHandle buf; |
| EXPECT_SUCCESS(writer.Finalize(&buf)); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| EXPECT_SUCCESS(reader.Next()); |
| |
| EXPECT_SUCCESS(invokeResponseIBParser.Init(reader)); |
| ParseInvokeResponseIBWithCommandStatusIB(invokeResponseIBParser); |
| } |
| |
| TEST_F(TestMessageDef, TestInvokeResponseIBWithMalformData) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| InvokeResponseIB::Builder invokeResponseIBBuilder; |
| InvokeResponseIB::Parser invokeResponseIBParser; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(invokeResponseIBBuilder.Init(&writer)); |
| BuildWrongInvokeResponseIB(invokeResponseIBBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = invokeResponseIBParser.Init(reader); |
| EXPECT_NE(err, CHIP_NO_ERROR); |
| } |
| |
| TEST_F(TestMessageDef, TestInvokeRequests) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| InvokeRequests::Builder invokeRequestsBuilder; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(invokeRequestsBuilder.Init(&writer)); |
| BuildInvokeRequests(invokeRequestsBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| ParseInvokeRequests(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestInvokeResponses) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| InvokeResponseIBs::Builder invokeResponsesBuilder; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| EXPECT_SUCCESS(invokeResponsesBuilder.Init(&writer)); |
| BuildInvokeResponses(invokeResponsesBuilder); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| ParseInvokeResponses(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestInvokeInvokeRequestMessage) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| BuildInvokeRequestMessage(writer); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| ParseInvokeRequestMessage(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestInvokeRequestMessageEndOfMessageReservation) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| InvokeRequestMessage::Builder invokeRequestMessageBuilder; |
| const uint32_t kSmallBufferSize = 100; |
| writer.Init(chip::System::PacketBufferHandle::New(kSmallBufferSize, /* aReservedSize = */ 0), /* useChainedBuffers = */ false); |
| err = invokeRequestMessageBuilder.InitWithEndBufferReserved(&writer); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| uint32_t remainingLengthAfterInitWithReservation = writer.GetRemainingFreeLength(); |
| |
| err = invokeRequestMessageBuilder.EndOfInvokeRequestMessage(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| uint32_t remainingLengthAfterEndingInvokeRequestMessage = writer.GetRemainingFreeLength(); |
| EXPECT_EQ(remainingLengthAfterInitWithReservation, remainingLengthAfterEndingInvokeRequestMessage); |
| } |
| |
| TEST_F(TestMessageDef, TestInvokeRequestsEndOfRequestReservation) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| InvokeRequestMessage::Builder invokeRequestMessageBuilder; |
| const uint32_t kSmallBufferSize = 100; |
| writer.Init(chip::System::PacketBufferHandle::New(kSmallBufferSize, /* aReservedSize = */ 0), /* useChainedBuffers = */ false); |
| err = invokeRequestMessageBuilder.InitWithEndBufferReserved(&writer); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| invokeRequestMessageBuilder.CreateInvokeRequests(/* aReserveEndBuffer = */ true); |
| InvokeRequests::Builder & invokeRequestsBuilder = invokeRequestMessageBuilder.GetInvokeRequests(); |
| err = invokeRequestsBuilder.GetError(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| auto * invokeRequestsWriter = invokeRequestsBuilder.GetWriter(); |
| uint32_t remainingLengthAfterInitWithReservation = invokeRequestsWriter->GetRemainingFreeLength(); |
| |
| err = invokeRequestsBuilder.EndOfInvokeRequests(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| uint32_t remainingLengthAfterEndingInvokeRequests = invokeRequestsWriter->GetRemainingFreeLength(); |
| EXPECT_EQ(remainingLengthAfterInitWithReservation, remainingLengthAfterEndingInvokeRequests); |
| } |
| |
| TEST_F(TestMessageDef, TestInvokeInvokeResponseMessage) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| BuildInvokeResponseMessage(writer); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| ParseInvokeResponseMessage(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestInvokeResponseMessageEndOfMessageReservation) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| InvokeResponseMessage::Builder invokeResponseMessageBuilder; |
| const uint32_t kSmallBufferSize = 100; |
| writer.Init(chip::System::PacketBufferHandle::New(kSmallBufferSize, /* aReservedSize = */ 0), /* useChainedBuffers = */ false); |
| err = invokeResponseMessageBuilder.InitWithEndBufferReserved(&writer); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| uint32_t remainingLengthAfterInitWithReservation = writer.GetRemainingFreeLength(); |
| err = invokeResponseMessageBuilder.EndOfInvokeResponseMessage(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| uint32_t remainingLengthAfterEndingInvokeResponseMessage = writer.GetRemainingFreeLength(); |
| EXPECT_EQ(remainingLengthAfterInitWithReservation, remainingLengthAfterEndingInvokeResponseMessage); |
| } |
| |
| TEST_F(TestMessageDef, TestInvokeResponseMessageReservationForEndandMoreChunk) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| InvokeResponseMessage::Builder invokeResponseMessageBuilder; |
| const uint32_t kSmallBufferSize = 100; |
| writer.Init(chip::System::PacketBufferHandle::New(kSmallBufferSize, /* aReservedSize = */ 0), /* useChainedBuffers = */ false); |
| err = invokeResponseMessageBuilder.InitWithEndBufferReserved(&writer); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| err = invokeResponseMessageBuilder.ReserveSpaceForMoreChunkedMessages(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| uint32_t remainingLengthAllReservations = writer.GetRemainingFreeLength(); |
| |
| invokeResponseMessageBuilder.MoreChunkedMessages(/* aMoreChunkedMessages = */ true); |
| EXPECT_EQ(invokeResponseMessageBuilder.GetError(), CHIP_NO_ERROR); |
| err = invokeResponseMessageBuilder.EndOfInvokeResponseMessage(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| uint32_t remainingLengthAfterEndingInvokeResponseMessage = writer.GetRemainingFreeLength(); |
| EXPECT_EQ(remainingLengthAllReservations, remainingLengthAfterEndingInvokeResponseMessage); |
| } |
| |
| TEST_F(TestMessageDef, TestInvokeResponsesEndOfResponseReservation) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| InvokeResponseMessage::Builder invokeResponseMessageBuilder; |
| const uint32_t kSmallBufferSize = 100; |
| writer.Init(chip::System::PacketBufferHandle::New(kSmallBufferSize, /* aReservedSize = */ 0), /* useChainedBuffers = */ false); |
| err = invokeResponseMessageBuilder.InitWithEndBufferReserved(&writer); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| invokeResponseMessageBuilder.CreateInvokeResponses(/* aReserveEndBuffer = */ true); |
| InvokeResponseIBs::Builder & invokeResponsesBuilder = invokeResponseMessageBuilder.GetInvokeResponses(); |
| err = invokeResponsesBuilder.GetError(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| auto * invokeResponsesWriter = invokeResponsesBuilder.GetWriter(); |
| uint32_t remainingLengthAfterInitWithReservation = invokeResponsesWriter->GetRemainingFreeLength(); |
| err = invokeResponsesBuilder.EndOfInvokeResponses(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| uint32_t remainingLengthAfterEndingInvokeResponses = invokeResponsesWriter->GetRemainingFreeLength(); |
| EXPECT_EQ(remainingLengthAfterInitWithReservation, remainingLengthAfterEndingInvokeResponses); |
| } |
| |
| TEST_F(TestMessageDef, TestReportDataMessage) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| BuildReportDataMessage(writer); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| ParseReportDataMessage(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestReadRequestMessage) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| BuildReadRequestMessage(writer); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| ParseReadRequestMessage(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestWriteRequestMessage) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| BuildWriteRequestMessage(writer); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| ParseWriteRequestMessage(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestWriteResponseMessage) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| BuildWriteResponseMessage(writer); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| ParseWriteResponseMessage(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestSubscribeRequestMessage) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| BuildSubscribeRequestMessage(writer); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| ParseSubscribeRequestMessage(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestSubscribeResponseMessage) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| BuildSubscribeResponseMessage(writer); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| ParseSubscribeResponseMessage(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestTimedRequestMessage) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| BuildTimedRequestMessage(writer); |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| ParseTimedRequestMessage(reader); |
| } |
| |
| TEST_F(TestMessageDef, TestCheckPointRollback) |
| { |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| size_t NumDataElement = 0; |
| chip::System::PacketBufferTLVWriter writer; |
| chip::System::PacketBufferTLVReader reader; |
| AttributeDataIBs::Parser AttributeDataIBsParser; |
| chip::TLV::TLVWriter checkpoint; |
| writer.Init(chip::System::PacketBufferHandle::New(chip::System::PacketBuffer::kMaxSize)); |
| AttributeDataIBs::Builder attributeDataIBsBuilder; |
| EXPECT_SUCCESS(attributeDataIBsBuilder.Init(&writer)); |
| |
| // encode one attribute element |
| AttributeDataIB::Builder & attributeDataIBBuilder1 = attributeDataIBsBuilder.CreateAttributeDataIBBuilder(); |
| EXPECT_EQ(attributeDataIBsBuilder.GetError(), CHIP_NO_ERROR); |
| BuildAttributeDataIB(attributeDataIBBuilder1); |
| // checkpoint |
| attributeDataIBsBuilder.Checkpoint(checkpoint); |
| // encode another attribute element |
| AttributeDataIB::Builder & attributeDataIBBuilder2 = attributeDataIBsBuilder.CreateAttributeDataIBBuilder(); |
| EXPECT_EQ(attributeDataIBsBuilder.GetError(), CHIP_NO_ERROR); |
| BuildAttributeDataIB(attributeDataIBBuilder2); |
| // rollback to previous checkpoint |
| attributeDataIBsBuilder.Rollback(checkpoint); |
| |
| EXPECT_SUCCESS(attributeDataIBsBuilder.EndOfAttributeDataIBs()); |
| EXPECT_EQ(attributeDataIBsBuilder.GetError(), CHIP_NO_ERROR); |
| |
| chip::System::PacketBufferHandle buf; |
| err = writer.Finalize(&buf); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(buf); |
| |
| reader.Init(std::move(buf)); |
| err = reader.Next(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = AttributeDataIBsParser.Init(reader); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| DebugPrettyPrint(AttributeDataIBsParser); |
| while (CHIP_NO_ERROR == (err = AttributeDataIBsParser.Next())) |
| { |
| ++NumDataElement; |
| } |
| |
| EXPECT_EQ(NumDataElement, 1u); |
| } |
| |
| } // namespace |
