| /* |
| * |
| * Copyright (c) 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 <optional> |
| |
| #include <lib/core/StringBuilderAdapters.h> |
| #include <pw_unit_test/framework.h> |
| |
| #include <app-common/zap-generated/cluster-objects.h> |
| #include <app/AttributeValueEncoder.h> |
| #include <app/MessageDef/AttributeDataIB.h> |
| #include <app/data-model/FabricScopedPreEncodedValue.h> |
| #include <app/data-model/PreEncodedValue.h> |
| #include <lib/core/TLVTags.h> |
| #include <lib/core/TLVWriter.h> |
| #include <lib/support/CodeUtils.h> |
| |
| using namespace chip; |
| using namespace chip::app; |
| using namespace chip::TLV; |
| |
| // TODO: This unit tests contains hard code TLV data, they should be replaced with some decoding code to improve readability. |
| |
| namespace { |
| |
| // These values are easier to be recognized in the encoded buffer |
| constexpr EndpointId kRandomEndpointId = 0x55; |
| constexpr ClusterId kRandomClusterId = 0xaa; |
| constexpr AttributeId kRandomAttributeId = 0xcc; |
| constexpr DataVersion kRandomDataVersion = 0x99; |
| constexpr FabricIndex kTestFabricIndex = 1; |
| constexpr NodeId kFakeNodeId = 1; |
| constexpr TLV::Tag kFabricIndexTag = TLV::ContextTag(254); |
| |
| Access::SubjectDescriptor DescriptorWithFabric(FabricIndex fabricIndex) |
| { |
| Access::SubjectDescriptor result; |
| |
| result.fabricIndex = fabricIndex; |
| result.subject = kFakeNodeId; |
| |
| if (fabricIndex == kUndefinedFabricIndex) |
| { |
| // Make it seem somewhat valid: a fabric index is not available in PASE |
| // before AddNOC |
| result.authMode = Access::AuthMode::kPase; |
| } |
| else |
| { |
| result.authMode = Access::AuthMode::kCase; |
| } |
| return result; |
| } |
| |
| template <size_t N> |
| struct LimitedTestSetup |
| { |
| LimitedTestSetup(const FabricIndex aFabricIndex = kUndefinedFabricIndex, |
| const AttributeEncodeState & aState = AttributeEncodeState()) : |
| encoder(builder, DescriptorWithFabric(aFabricIndex), |
| ConcreteAttributePath(kRandomEndpointId, kRandomClusterId, kRandomAttributeId), kRandomDataVersion, |
| aFabricIndex != kUndefinedFabricIndex, aState) |
| { |
| writer.Init(buf); |
| { |
| TLVType ignored; |
| CHIP_ERROR err = writer.StartContainer(AnonymousTag(), kTLVType_Structure, ignored); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| } |
| { |
| CHIP_ERROR err = builder.Init(&writer, 1); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| } |
| } |
| |
| AttributeReportIBs::Builder builder; |
| AttributeValueEncoder encoder; |
| uint8_t buf[N]; |
| TLVWriter writer; |
| }; |
| |
| using TestSetup = LimitedTestSetup<1024>; |
| |
| // Macro so we get better error reporting in terms of which test failed, because |
| // the reporting uses __LINE__. |
| #define VERIFY_BUFFER_STATE(aSetup, aExpected) \ |
| do \ |
| { \ |
| EXPECT_EQ(aSetup.writer.GetLengthWritten(), sizeof(aExpected)); \ |
| EXPECT_EQ(memcmp(aSetup.buf, aExpected, sizeof(aExpected)), 0); \ |
| if (aSetup.writer.GetLengthWritten() != sizeof(aExpected) || memcmp(aSetup.buf, aExpected, sizeof(aExpected)) != 0) \ |
| { \ |
| printf("Encoded: \n"); \ |
| for (size_t i = 0; i < aSetup.writer.GetLengthWritten(); i++) \ |
| { \ |
| printf("0x%02x,", aSetup.buf[i]); \ |
| } \ |
| printf("\n"); \ |
| printf("Expected: \n"); \ |
| for (size_t i = 0; i < sizeof(aExpected); i++) \ |
| { \ |
| printf("0x%02x,", aExpected[i]); \ |
| } \ |
| printf("\n"); \ |
| } \ |
| } while (0) |
| |
| TEST(TestAttributeValueEncoder, TestEncodeNothing) |
| { |
| TestSetup test{}; |
| // Just have an anonymous struct marker, and the AttributeReportIBs opened. |
| const uint8_t expected[] = { 0x15, 0x36, 0x01 }; |
| VERIFY_BUFFER_STATE(test, expected); |
| } |
| |
| TEST(TestAttributeValueEncoder, TestEncodeBool) |
| { |
| TestSetup test{}; |
| CHIP_ERROR err = test.encoder.Encode(true); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| const uint8_t expected[] = { |
| // clang-format off |
| 0x15, 0x36, 0x01, // Test overhead, Start Anonymous struct + Start 1 byte Tag Array + Tag (01) |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x18, // End of container |
| 0x29, 0x02, // Tag (02) Value True (Attribute Value) |
| 0x18, // End of container |
| 0x18, // End of container |
| // clang-format on |
| }; |
| VERIFY_BUFFER_STATE(test, expected); |
| } |
| |
| TEST(TestAttributeValueEncoder, TestEncodeListOfBools1) |
| { |
| TestSetup test{}; |
| bool list[] = { true, false }; |
| CHIP_ERROR err = test.encoder.Encode(DataModel::List<bool>(list)); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| const uint8_t expected[] = { |
| // clang-format off |
| 0x15, 0x36, 0x01, // Test overhead, Start Anonymous struct + Start 1 byte Tag Array + Tag (01) |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x18, // End of container |
| 0x36, 0x02, // Start 1 byte tag array + Tag (02) (Attribute Value) |
| 0x09, // True |
| 0x08, // False |
| 0x18, // End of array |
| 0x18, // End of attribute data structure |
| 0x18, // End of attribute structure |
| // clang-format on |
| }; |
| VERIFY_BUFFER_STATE(test, expected); |
| } |
| |
| TEST(TestAttributeValueEncoder, TestEncodeListOfBools2) |
| { |
| TestSetup test{}; |
| bool list[] = { true, false }; |
| CHIP_ERROR err = test.encoder.EncodeList([&list](const auto & encoder) -> CHIP_ERROR { |
| for (auto & item : list) |
| { |
| ReturnErrorOnFailure(encoder.Encode(item)); |
| } |
| return CHIP_NO_ERROR; |
| }); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| const uint8_t expected[] = { |
| // clang-format off |
| 0x15, 0x36, 0x01, // Test overhead, Start Anonymous struct + Start 1 byte Tag Array + Tag (01) |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x18, // End of container |
| 0x36, 0x02, // Start 1 byte tag array + Tag (02) (Attribute Value) |
| 0x09, // True |
| 0x08, // False |
| 0x18, // End of array |
| 0x18, // End of attribute data structure |
| 0x18, // End of attribute structure |
| // clang-format on |
| }; |
| VERIFY_BUFFER_STATE(test, expected); |
| } |
| |
| constexpr uint8_t emptyListExpected[] = { |
| // clang-format off |
| 0x15, 0x36, 0x01, // Test overhead, Start Anonymous struct + Start 1 byte Tag Array + Tag (01) |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x18, // End of container |
| // Intended empty array |
| 0x36, 0x02, // Start 1 byte tag array + Tag (02) (Attribute Value) |
| 0x18, // End of container |
| 0x18, // End of container |
| 0x18, // End of container |
| // clang-format on |
| }; |
| |
| TEST(TestAttributeValueEncoder, TestEncodeEmptyList1) |
| { |
| TestSetup test{}; |
| CHIP_ERROR err = test.encoder.EncodeList([](const auto & encoder) -> CHIP_ERROR { return CHIP_NO_ERROR; }); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| VERIFY_BUFFER_STATE(test, emptyListExpected); |
| } |
| |
| TEST(TestAttributeValueEncoder, TestEncodeEmptyList2) |
| { |
| TestSetup test{}; |
| CHIP_ERROR err = test.encoder.EncodeEmptyList(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| VERIFY_BUFFER_STATE(test, emptyListExpected); |
| } |
| |
| TEST(TestAttributeValueEncoder, TestEncodeFabricScoped) |
| { |
| TestSetup test(kTestFabricIndex); |
| Clusters::AccessControl::Structs::AccessControlExtensionStruct::Type items[3]; |
| items[0].fabricIndex = 1; |
| items[1].fabricIndex = 2; |
| items[2].fabricIndex = 3; |
| |
| // We tried to encode three items, however, the encoder should only put the item with matching fabric index into the final list. |
| CHIP_ERROR err = test.encoder.EncodeList([items](const auto & encoder) -> CHIP_ERROR { |
| for (const auto & item : items) |
| { |
| ReturnErrorOnFailure(encoder.Encode(item)); |
| } |
| return CHIP_NO_ERROR; |
| }); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| const uint8_t expected[] = { |
| // clang-format off |
| 0x15, 0x36, 0x01, // Test overhead, Start Anonymous struct + Start 1 byte Tag Array + Tag (01) |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x18, // End of container |
| 0x36, 0x02, // Start 1 byte tag array + Tag (02) (Attribute Value) |
| 0x15, // Start anonymous structure |
| 0x30, 0x01, 0x00, // Tag 1, OCTET_STRING length 0 (data) |
| 0x24, 0xFE, 0x01, // Tag 0xFE, UINT8 Value 1 (fabric index) |
| 0x18, // End of array element (structure) |
| 0x18, // End of array |
| 0x18, // End of attribute data structure |
| 0x18, // End of attribute structure |
| // clang-format on |
| }; |
| VERIFY_BUFFER_STATE(test, expected); |
| } |
| |
| TEST(TestAttributeValueEncoder, TestEncodeListChunking) |
| { |
| AttributeEncodeState state; |
| |
| bool list[] = { true, false, false, true, true, false }; |
| auto listEncoder = [&list](const auto & encoder) -> CHIP_ERROR { |
| for (auto & item : list) |
| { |
| ReturnErrorOnFailure(encoder.Encode(item)); |
| } |
| return CHIP_NO_ERROR; |
| }; |
| |
| { |
| // Use 30 bytes buffer to force chunking after the first "false". The kTestFabricIndex is |
| // not effective in this test. |
| // |
| // We only encode 28 bytes, because we don't encode our last two "close container" bits |
| // corresponding to the "test overhead" container starts. But TLVWriter automatically |
| // reserves space when containers are opened, so we have to have enough space to have |
| // encoded those last two close containers. |
| LimitedTestSetup<30> test1(kTestFabricIndex); |
| CHIP_ERROR err = test1.encoder.EncodeList(listEncoder); |
| EXPECT_TRUE(err == CHIP_ERROR_NO_MEMORY || err == CHIP_ERROR_BUFFER_TOO_SMALL); |
| state = test1.encoder.GetState(); |
| |
| const uint8_t expected[] = { |
| // clang-format off |
| 0x15, 0x36, 0x01, // Test overhead, Start Anonymous struct + Start 1 byte Tag Array + Tag (01) |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x18, // End of container |
| 0x36, 0x02, // Start 1 byte tag array + Tag (02) (Attribute Value) |
| 0x09, // True |
| 0x08, // False |
| 0x18, // End of array |
| 0x18, // End of attribute data structure |
| 0x18, // End of attribute structure |
| // clang-format on |
| }; |
| VERIFY_BUFFER_STATE(test1, expected); |
| } |
| { |
| // Use 30 bytes buffer to force chunking after the second "false". The kTestFabricIndex is |
| // not effective in this test. |
| LimitedTestSetup<30> test2(0, state); |
| CHIP_ERROR err = test2.encoder.EncodeList(listEncoder); |
| EXPECT_TRUE(err == CHIP_ERROR_NO_MEMORY || err == CHIP_ERROR_BUFFER_TOO_SMALL); |
| state = test2.encoder.GetState(); |
| |
| const uint8_t expected[] = { |
| // clang-format off |
| 0x15, 0x36, 0x01, // Test overhead, Start Anonymous struct + Start 1 byte Tag Array + Tag (01) |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x34, 0x05, // Tag (05) Null |
| 0x18, // End of container |
| 0x28, 0x02, // Tag (02) Value False (Attribute Value) |
| 0x18, // End of container |
| 0x18, // End of container |
| // clang-format on |
| }; |
| VERIFY_BUFFER_STATE(test2, expected); |
| } |
| { |
| // Allow encoding everything else. The kTestFabricIndex is not effective in this test. |
| TestSetup test3(0, state); |
| CHIP_ERROR err = test3.encoder.EncodeList(listEncoder); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| const uint8_t expected[] = { |
| // clang-format off |
| 0x15, 0x36, 0x01, // Test overhead, Start Anonymous struct + Start 1 byte Tag Array + Tag (01) |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x34, 0x05, // Tag (05) Null |
| 0x18, // End of container |
| 0x29, 0x02, // Tag (02) Value True (Attribute Value) |
| 0x18, // End of container |
| 0x18, // End of container |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x34, 0x05, // Tag (05) Null |
| 0x18, // End of container |
| 0x29, 0x02, // Tag (02) Value True (Attribute Value) |
| 0x18, // End of container |
| 0x18, // End of container |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x34, 0x05, // Tag (05) Null |
| 0x18, // End of container |
| 0x28, 0x02, // Tag (02) Value False (Attribute Value) |
| 0x18, // End of container |
| 0x18, // End of container |
| // clang-format on |
| }; |
| VERIFY_BUFFER_STATE(test3, expected); |
| } |
| } |
| |
| TEST(TestAttributeValueEncoder, TestEncodeListChunking2) |
| { |
| AttributeEncodeState state; |
| |
| bool list[] = { true, false, false, true, true, false }; |
| auto listEncoder = [&list](const auto & encoder) -> CHIP_ERROR { |
| for (auto & item : list) |
| { |
| ReturnErrorOnFailure(encoder.Encode(item)); |
| } |
| return CHIP_NO_ERROR; |
| }; |
| |
| { |
| // Use 28 bytes buffer to force chunking right after we start the list. kTestFabricIndex is |
| // not effective in this test. |
| // |
| // We only encode 26 bytes, because we don't encode our last two "close container" bits |
| // corresponding to the "test overhead" container starts. But TLVWriter automatically |
| // reserves space when containers are opened, so we have to have enough space to have |
| // encoded those last two close containers. |
| LimitedTestSetup<28> test1(kTestFabricIndex); |
| CHIP_ERROR err = test1.encoder.EncodeList(listEncoder); |
| EXPECT_TRUE(err == CHIP_ERROR_NO_MEMORY || err == CHIP_ERROR_BUFFER_TOO_SMALL); |
| state = test1.encoder.GetState(); |
| |
| const uint8_t expected[] = { |
| // clang-format off |
| 0x15, 0x36, 0x01, // Test overhead, Start Anonymous struct + Start 1 byte Tag Array + Tag (01) |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x18, // End of container |
| 0x36, 0x02, // Start 1 byte tag array + Tag (02) (Attribute Value) |
| 0x18, // End of array |
| 0x18, // End of attribute data structure |
| 0x18, // End of attribute structure |
| // clang-format on |
| }; |
| VERIFY_BUFFER_STATE(test1, expected); |
| } |
| { |
| // Use 30 bytes buffer to force chunking after the first "true". The kTestFabricIndex is not |
| // effective in this test. |
| LimitedTestSetup<30> test2(0, state); |
| CHIP_ERROR err = test2.encoder.EncodeList(listEncoder); |
| EXPECT_TRUE(err == CHIP_ERROR_NO_MEMORY || err == CHIP_ERROR_BUFFER_TOO_SMALL); |
| state = test2.encoder.GetState(); |
| |
| const uint8_t expected[] = { |
| // clang-format off |
| 0x15, 0x36, 0x01, // Test overhead, Start Anonymous struct + Start 1 byte Tag Array + Tag (01) |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x34, 0x05, // Tag (05) Null |
| 0x18, // End of container |
| 0x29, 0x02, // Tag (02) Value True (Attribute Value) |
| 0x18, // End of container |
| 0x18, // End of container |
| // clang-format on |
| }; |
| VERIFY_BUFFER_STATE(test2, expected); |
| } |
| { |
| // Use 60 bytes buffer to force chunking after the second "false". The kTestFabricIndex is not |
| // effective in this test. |
| LimitedTestSetup<60> test3(0, state); |
| CHIP_ERROR err = test3.encoder.EncodeList(listEncoder); |
| EXPECT_TRUE(err == CHIP_ERROR_NO_MEMORY || err == CHIP_ERROR_BUFFER_TOO_SMALL); |
| state = test3.encoder.GetState(); |
| |
| const uint8_t expected[] = { |
| // clang-format off |
| 0x15, 0x36, 0x01, // Test overhead, Start Anonymous struct + Start 1 byte Tag Array + Tag (01) |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x34, 0x05, // Tag (05) Null |
| 0x18, // End of container |
| 0x28, 0x02, // Tag (02) Value False (Attribute Value) |
| 0x18, // End of container |
| 0x18, // End of container |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x34, 0x05, // Tag (05) Null |
| 0x18, // End of container |
| 0x28, 0x02, // Tag (02) Value False (Attribute Value) |
| 0x18, // End of container |
| 0x18, // End of container |
| // clang-format on |
| }; |
| VERIFY_BUFFER_STATE(test3, expected); |
| } |
| { |
| // Allow encoding everything else. The kTestFabricIndex is not effective in this test. |
| TestSetup test4(0, state); |
| CHIP_ERROR err = test4.encoder.EncodeList(listEncoder); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| const uint8_t expected[] = { |
| // clang-format off |
| 0x15, 0x36, 0x01, // Test overhead, Start Anonymous struct + Start 1 byte Tag Array + Tag (01) |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x34, 0x05, // Tag (05) Null |
| 0x18, // End of container |
| 0x29, 0x02, // Tag (02) Value True (Attribute Value) |
| 0x18, // End of container |
| 0x18, // End of container |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x34, 0x05, // Tag (05) Null |
| 0x18, // End of container |
| 0x29, 0x02, // Tag (02) Value True (Attribute Value) |
| 0x18, // End of container |
| 0x18, // End of container |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x34, 0x05, // Tag (05) Null |
| 0x18, // End of container |
| 0x28, 0x02, // Tag (02) Value False (Attribute Value) |
| 0x18, // End of container |
| 0x18, // End of container |
| // clang-format on |
| }; |
| VERIFY_BUFFER_STATE(test4, expected); |
| } |
| } |
| |
| TEST(TestAttributeValueEncoder, TestEncodePreEncoded) |
| { |
| TestSetup test{}; |
| |
| uint8_t buffer[128]; |
| TLV::TLVWriter writer; |
| writer.Init(buffer); |
| // Use a random tag that is not the right tag. |
| CHIP_ERROR err = writer.PutString(TLV::ProfileTag(0x1234abcd, 0x5678fedc), "hello"); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.Finalize(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| ByteSpan value(buffer, writer.GetLengthWritten()); |
| err = test.encoder.Encode(DataModel::PreEncodedValue(value)); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| const uint8_t expected[] = { |
| // clang-format off |
| 0x15, 0x36, 0x01, // Test overhead, Start Anonymous struct + Start 1 byte Tag Array + Tag (01) |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x18, // End of container |
| 0x2C, 0x02, 0x05, 0x68, 0x65, 0x6C, 0x6C, 0x6F, // Tag (02) Value "hello", with 1-byte length of 0x05 (Attribute Value) |
| 0x18, // End of container |
| 0x18, // End of container |
| // clang-format on |
| }; |
| VERIFY_BUFFER_STATE(test, expected); |
| } |
| |
| TEST(TestAttributeValueEncoder, TestEncodeListOfPreEncoded) |
| { |
| TestSetup test{}; |
| |
| uint8_t buffers[2][128]; |
| std::optional<DataModel::PreEncodedValue> values[2]; |
| |
| { |
| TLV::TLVWriter writer; |
| writer.Init(buffers[0]); |
| // Use a random tag that is not the right tag. |
| CHIP_ERROR err = writer.PutString(TLV::ProfileTag(0x1234abcd, 0x5678fedc), "hello"); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.Finalize(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| values[0].emplace(ByteSpan(buffers[0], writer.GetLengthWritten())); |
| } |
| |
| { |
| TLV::TLVWriter writer; |
| writer.Init(buffers[1]); |
| // Use a random tag that is not the right tag. |
| CHIP_ERROR err = writer.PutString(TLV::ProfileTag(0x1234abcd, 0x00010002), "bye"); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.Finalize(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| values[1].emplace(ByteSpan(buffers[1], writer.GetLengthWritten())); |
| } |
| |
| CHIP_ERROR err = test.encoder.EncodeList([&values](const auto & encoder) { |
| for (auto & value : values) |
| { |
| ReturnErrorOnFailure(encoder.Encode(value.value())); |
| } |
| return CHIP_NO_ERROR; |
| }); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| const uint8_t expected[] = { |
| // clang-format off |
| 0x15, 0x36, 0x01, // Test overhead, Start Anonymous struct + Start 1 byte Tag Array + Tag (01) |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x18, // End of container |
| 0x36, 0x02, // Start 1 byte tag array + Tag (02) (Attribute Value) |
| 0x0C, 0x05, 0x68, 0x65, 0x6C, 0x6C, 0x6F, // "hello", with 1-byte length of 0x05 |
| 0x0C, 0x03, 0x62, 0x79, 0x65, // "bye", with 1-byte length of 0x03 |
| 0x18, // End of array |
| 0x18, // End of container |
| 0x18, // End of container |
| // clang-format on |
| }; |
| VERIFY_BUFFER_STATE(test, expected); |
| } |
| |
| TEST(TestAttributeValueEncoder, TestEncodeListOfFabricScopedPreEncoded) |
| { |
| TestSetup test{}; |
| |
| uint8_t buffers[2][128]; |
| std::optional<DataModel::FabricScopedPreEncodedValue> values[2]; |
| |
| { |
| TLV::TLVWriter writer; |
| writer.Init(buffers[0]); |
| // Use a random tag that is not the right tag. |
| TLV::TLVType outerContainerType; |
| CHIP_ERROR err = |
| writer.StartContainer(TLV::ProfileTag(0x1234abcd, 0x5678fedc), TLV::kTLVType_Structure, outerContainerType); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.PutString(TLV::ContextTag(7), "hello"); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.Put(kFabricIndexTag, kTestFabricIndex); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.EndContainer(outerContainerType); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.Finalize(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| values[0].emplace(ByteSpan(buffers[0], writer.GetLengthWritten())); |
| } |
| |
| { |
| TLV::TLVWriter writer; |
| writer.Init(buffers[1]); |
| // Use a random tag that is not the right tag. |
| TLV::TLVType outerContainerType; |
| CHIP_ERROR err = |
| writer.StartContainer(TLV::ProfileTag(0x1234abcd, 0x00010002), TLV::kTLVType_Structure, outerContainerType); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.PutString(TLV::ContextTag(7), "bye"); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.Put(kFabricIndexTag, static_cast<FabricIndex>(kTestFabricIndex + 1)); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.EndContainer(outerContainerType); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.Finalize(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| values[1].emplace(ByteSpan(buffers[1], writer.GetLengthWritten())); |
| } |
| |
| CHIP_ERROR err = test.encoder.EncodeList([&values](const auto & encoder) { |
| for (auto & value : values) |
| { |
| ReturnErrorOnFailure(encoder.Encode(value.value())); |
| } |
| return CHIP_NO_ERROR; |
| }); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| const uint8_t expected[] = { |
| // clang-format off |
| 0x15, 0x36, 0x01, // Test overhead, Start Anonymous struct + Start 1 byte Tag Array + Tag (01) |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x18, // End of container |
| 0x36, 0x02, // Start 1 byte tag array + Tag (02) (Attribute Value) |
| 0x15, // Start of struct |
| 0x2C, 0x07, 0x05, 0x68, 0x65, 0x6C, 0x6C, 0x6F, // "hello", with tag 07 and 1-byte length of 0x05 |
| 0x24, 0xFE, 0x01, // Fabric index, tag 254, value 1 |
| 0x18, // End of struct |
| 0x15, // Start of struct |
| 0x2C, 0x07, 0x03, 0x62, 0x79, 0x65, // "bye", with tag 07 and 1-byte length of 0x03 |
| 0x24, 0xFE, 0x02, // Fabric index, tag 254, value 2 |
| 0x18, // End of struct |
| 0x18, // End of array |
| 0x18, // End of container |
| 0x18, // End of container |
| // clang-format on |
| }; |
| VERIFY_BUFFER_STATE(test, expected); |
| } |
| |
| TEST(TestAttributeValueEncoder, TestEncodeFabricFilteredListOfPreEncoded) |
| { |
| TestSetup test(kTestFabricIndex); |
| |
| uint8_t buffers[2][128]; |
| std::optional<DataModel::FabricScopedPreEncodedValue> values[2]; |
| |
| { |
| TLV::TLVWriter writer; |
| writer.Init(buffers[0]); |
| // Use a random tag that is not the right tag. |
| TLV::TLVType outerContainerType; |
| CHIP_ERROR err = |
| writer.StartContainer(TLV::ProfileTag(0x1234abcd, 0x5678fedc), TLV::kTLVType_Structure, outerContainerType); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.PutString(TLV::ContextTag(7), "hello"); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.Put(kFabricIndexTag, kTestFabricIndex); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.EndContainer(outerContainerType); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.Finalize(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| values[0].emplace(ByteSpan(buffers[0], writer.GetLengthWritten())); |
| } |
| |
| { |
| TLV::TLVWriter writer; |
| writer.Init(buffers[1]); |
| // Use a random tag that is not the right tag. |
| TLV::TLVType outerContainerType; |
| CHIP_ERROR err = |
| writer.StartContainer(TLV::ProfileTag(0x1234abcd, 0x00010002), TLV::kTLVType_Structure, outerContainerType); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.PutString(TLV::ContextTag(7), "bye"); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.Put(kFabricIndexTag, static_cast<FabricIndex>(kTestFabricIndex + 1)); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.EndContainer(outerContainerType); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| err = writer.Finalize(); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| values[1].emplace(ByteSpan(buffers[1], writer.GetLengthWritten())); |
| } |
| |
| CHIP_ERROR err = test.encoder.EncodeList([&values](const auto & encoder) { |
| for (auto & value : values) |
| { |
| ReturnErrorOnFailure(encoder.Encode(value.value())); |
| } |
| return CHIP_NO_ERROR; |
| }); |
| EXPECT_EQ(err, CHIP_NO_ERROR); |
| |
| const uint8_t expected[] = { |
| // clang-format off |
| 0x15, 0x36, 0x01, // Test overhead, Start Anonymous struct + Start 1 byte Tag Array + Tag (01) |
| 0x15, // Start anonymous struct |
| 0x35, 0x01, // Start 1 byte tag struct + Tag (01) |
| 0x24, 0x00, 0x99, // Tag (00) Value (1 byte uint) 0x99 (Attribute Version) |
| 0x37, 0x01, // Start 1 byte tag list + Tag (01) (Attribute Path) |
| 0x24, 0x02, 0x55, // Tag (02) Value (1 byte uint) 0x55 |
| 0x24, 0x03, 0xaa, // Tag (03) Value (1 byte uint) 0xaa |
| 0x24, 0x04, 0xcc, // Tag (04) Value (1 byte uint) 0xcc |
| 0x18, // End of container |
| 0x36, 0x02, // Start 1 byte tag array + Tag (02) (Attribute Value) |
| 0x15, // Start of struct |
| 0x2C, 0x07, 0x05, 0x68, 0x65, 0x6C, 0x6C, 0x6F, // "hello", with tag 07 and 1-byte length of 0x05 |
| 0x24, 0xFE, 0x01, // Fabric index, tag 254, value 1 |
| 0x18, // End of struct |
| // No second struct, because we are doing fabric filtering |
| 0x18, // End of array |
| 0x18, // End of container |
| 0x18, // End of container |
| // clang-format on |
| }; |
| VERIFY_BUFFER_STATE(test, expected); |
| } |
| |
| #undef VERIFY_BUFFER_STATE |
| |
| } // anonymous namespace |
