Google Git
Sign in
pigweed / third_party / github / project-chip / connectedhomeip / 23a961eef11014f697323465365e9c6f2744ecf7 / . / src / lib / core / tests / TestCHIPTLV.cpp
blob: 747aaff7d99a120100631322a5bfc308371274f1 [file] [log] [blame]
/*
*
* Copyright (c) 2020-2022 Project CHIP Authors
* Copyright (c) 2013-2017 Nest Labs, Inc.
* 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.
*/
/**
* @file
* This file implements unit tests for the CHIP TLV implementation.
*
*/
#include <nlbyteorder.h>
#include <nlunit-test.h>
#include <lib/core/CHIPCircularTLVBuffer.h>
#include <lib/core/CHIPCore.h>
#include <lib/core/CHIPTLV.h>
#include <lib/core/CHIPTLVData.hpp>
#include <lib/core/CHIPTLVDebug.hpp>
#include <lib/core/CHIPTLVUtilities.hpp>
#include <lib/support/CHIPMem.h>
#include <lib/support/CodeUtils.h>
#include <lib/support/ScopedBuffer.h>
#include <lib/support/UnitTestContext.h>
#include <lib/support/UnitTestExtendedAssertions.h>
#include <lib/support/UnitTestRegistration.h>
#include <lib/support/UnitTestUtils.h>
#include <lib/support/logging/Constants.h>
#include <system/TLVPacketBufferBackingStore.h>
#include <stdlib.h>
#include <string.h>
using namespace chip;
using namespace chip::TLV;
enum
{
TestProfile_1 = 0xAABBCCDD,
TestProfile_2 = 0x11223344,
TestProfile_3 = 0x11223355
};
// clang-format off
static const char sLargeString [] =
"START..."
"!123456789ABCDEF@123456789ABCDEF#123456789ABCDEF$123456789ABCDEF%123456789ABCDEF^123456789ABCDEF&123456789ABCDEF*123456789ABCDEF"
"01234567(9ABCDEF01234567)9ABCDEF01234567-9ABCDEF01234567=9ABCDEF01234567[9ABCDEF01234567]9ABCDEF01234567;9ABCDEF01234567'9ABCDEF"
"...END";
// clang-format on
void TestAndOpenContainer(nlTestSuite * inSuite, TLVReader & reader, TLVType type, Tag tag, TLVReader & containerReader)
{
NL_TEST_ASSERT(inSuite, reader.GetType() == type);
NL_TEST_ASSERT(inSuite, reader.GetTag() == tag);
NL_TEST_ASSERT(inSuite, reader.GetLength() == 0);
CHIP_ERROR err = reader.OpenContainer(containerReader);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, containerReader.GetContainerType() == type);
}
template <class T>
void TestAndEnterContainer(nlTestSuite * inSuite, T & t, TLVType type, Tag tag, TLVType & outerContainerType)
{
NL_TEST_ASSERT(inSuite, t.GetType() == type);
NL_TEST_ASSERT(inSuite, t.GetTag() == tag);
NL_TEST_ASSERT(inSuite, t.GetLength() == 0);
TLVType expectedContainerType = t.GetContainerType();
CHIP_ERROR err = t.EnterContainer(outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, outerContainerType == expectedContainerType);
NL_TEST_ASSERT(inSuite, t.GetContainerType() == type);
}
template <class T>
void TestNext(nlTestSuite * inSuite, T & t)
{
CHIP_ERROR err = t.Next();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
void TestSkip(nlTestSuite * inSuite, TLVReader & reader)
{
CHIP_ERROR err = reader.Skip();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
void TestMove(nlTestSuite * inSuite, TLVUpdater & updater)
{
CHIP_ERROR err = updater.Move();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
template <class T>
void TestEnd(nlTestSuite * inSuite, T & t)
{
CHIP_ERROR err;
err = t.Next();
NL_TEST_ASSERT(inSuite, err == CHIP_END_OF_TLV);
}
void TestEndAndCloseContainer(nlTestSuite * inSuite, TLVReader & reader, TLVReader & containerReader)
{
CHIP_ERROR err;
TestEnd<TLVReader>(inSuite, containerReader);
err = reader.CloseContainer(containerReader);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
template <class T>
void TestEndAndExitContainer(nlTestSuite * inSuite, T & t, TLVType outerContainerType)
{
CHIP_ERROR err;
TestEnd<T>(inSuite, t);
err = t.ExitContainer(outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, t.GetContainerType() == outerContainerType);
}
#define TEST_GET(inSuite, s, type, tag, expectedVal, expectedErr) \
do \
{ \
NL_TEST_ASSERT(inSuite, s.GetType() == type); \
NL_TEST_ASSERT(inSuite, s.GetTag() == tag); \
NL_TEST_ASSERT(inSuite, s.GetLength() == 0); \
\
decltype(expectedVal) __val; \
CHIP_ERROR __err = s.Get(__val); \
NL_TEST_ASSERT(inSuite, __err == expectedErr); \
if (__err == CHIP_NO_ERROR) \
{ \
NL_TEST_ASSERT(inSuite, __val == expectedVal); \
} \
} while (false)
#define TEST_GET_NOERROR(inSuite, s, type, tag, expectedVal) TEST_GET(inSuite, s, type, tag, expectedVal, CHIP_NO_ERROR)
void ForEachElement(nlTestSuite * inSuite, TLVReader & reader, void * context,
void (*cb)(nlTestSuite * inSuite, TLVReader & reader, void * context))
{
CHIP_ERROR err;
while (true)
{
err = reader.Next();
if (err == CHIP_END_OF_TLV)
{
return;
}
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
if (cb != nullptr)
{
cb(inSuite, reader, context);
}
if (TLVTypeIsContainer(reader.GetType()))
{
TLVType outerContainerType;
err = reader.EnterContainer(outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
ForEachElement(inSuite, reader, context, cb);
err = reader.ExitContainer(outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
}
}
/**
* context
*/
struct TestTLVContext
{
nlTestSuite * mSuite = nullptr;
int mEvictionCount = 0;
uint32_t mEvictedBytes = 0;
TestTLVContext(nlTestSuite * suite) : mSuite(suite) {}
};
void TestNull(nlTestSuite * inSuite, TLVReader & reader, Tag tag)
{
NL_TEST_ASSERT(inSuite, reader.GetType() == kTLVType_Null);
NL_TEST_ASSERT(inSuite, reader.GetTag() == tag);
NL_TEST_ASSERT(inSuite, reader.GetLength() == 0);
}
void TestString(nlTestSuite * inSuite, TLVReader & reader, Tag tag, const char * expectedVal)
{
NL_TEST_ASSERT(inSuite, reader.GetType() == kTLVType_UTF8String);
NL_TEST_ASSERT(inSuite, reader.GetTag() == tag);
size_t expectedLen = strlen(expectedVal);
NL_TEST_ASSERT(inSuite, reader.GetLength() == expectedLen);
chip::Platform::ScopedMemoryBuffer<char> valBuffer;
char * val = static_cast<char *>(valBuffer.Alloc(expectedLen + 1).Get());
CHIP_ERROR err = reader.GetString(val, static_cast<uint32_t>(expectedLen) + 1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, memcmp(val, expectedVal, expectedLen + 1) == 0);
}
void TestDupString(nlTestSuite * inSuite, TLVReader & reader, Tag tag, const char * expectedVal)
{
NL_TEST_ASSERT(inSuite, reader.GetType() == kTLVType_UTF8String);
NL_TEST_ASSERT(inSuite, reader.GetTag() == tag);
size_t expectedLen = strlen(expectedVal);
NL_TEST_ASSERT(inSuite, reader.GetLength() == expectedLen);
char * val = nullptr;
CHIP_ERROR err = reader.DupString(val);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, val != nullptr);
if (val != nullptr)
{
NL_TEST_ASSERT(inSuite, memcmp(val, expectedVal, expectedLen + 1) == 0);
}
chip::Platform::MemoryFree(val);
}
void TestDupBytes(nlTestSuite * inSuite, TLVReader & reader, Tag tag, const uint8_t * expectedVal, uint32_t expectedLen)
{
NL_TEST_ASSERT(inSuite, reader.GetType() == kTLVType_UTF8String);
NL_TEST_ASSERT(inSuite, reader.GetTag() == tag);
NL_TEST_ASSERT(inSuite, reader.GetLength() == expectedLen);
uint8_t * val = nullptr;
CHIP_ERROR err = reader.DupBytes(val, expectedLen);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, val != nullptr);
if (val != nullptr)
{
NL_TEST_ASSERT(inSuite, memcmp(val, expectedVal, expectedLen) == 0);
}
chip::Platform::MemoryFree(val);
}
void TestBufferContents(nlTestSuite * inSuite, const System::PacketBufferHandle & buffer, const uint8_t * expectedVal,
uint32_t expectedLen)
{
System::PacketBufferHandle buf = buffer.Retain();
while (!buf.IsNull())
{
uint16_t len = buf->DataLength();
NL_TEST_ASSERT(inSuite, len <= expectedLen);
NL_TEST_ASSERT(inSuite, memcmp(buf->Start(), expectedVal, len) == 0);
expectedVal += len;
expectedLen -= len;
buf.Advance();
}
NL_TEST_ASSERT(inSuite, expectedLen == 0);
}
// clang-format off
static const uint8_t Encoding1[] =
{
0xD5, 0xBB, 0xAA, 0xDD, 0xCC, 0x01, 0x00, 0xC9, 0xBB, 0xAA, 0xDD, 0xCC, 0x02, 0x00, 0x88, 0x02,
0x00, 0x36, 0x00, 0x00, 0x2A, 0x00, 0xEF, 0x02, 0xF0, 0x67, 0xFD, 0xFF, 0x07, 0x00, 0x90, 0x2F,
0x50, 0x09, 0x00, 0x00, 0x00, 0x15, 0x18, 0x17, 0xD4, 0xBB, 0xAA, 0xDD, 0xCC, 0x11, 0x00, 0xB4,
0xA0, 0xBB, 0x0D, 0x00, 0x14, 0xB5, 0x00, 0x28, 0x6B, 0xEE, 0x6D, 0x70, 0x11, 0x01, 0x00, 0x0E,
0x01, 0x53, 0x54, 0x41, 0x52, 0x54, 0x2E, 0x2E, 0x2E, 0x21, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x40, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x23, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x24, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x25, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x5E, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x26, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x2A, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
0x37, 0x28, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
0x37, 0x29, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
0x37, 0x2D, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
0x37, 0x3D, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
0x37, 0x5B, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
0x37, 0x5D, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
0x37, 0x3B, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
0x37, 0x27, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x2E, 0x2E, 0x2E, 0x45, 0x4E, 0x44, 0x18,
0x18, 0x18, 0xCC, 0xBB, 0xAA, 0xDD, 0xCC, 0x05, 0x00, 0x0E, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69,
0x73, 0x20, 0x61, 0x20, 0x74, 0x65, 0x73, 0x74, 0x8A, 0xFF, 0xFF, 0x33, 0x33, 0x8F, 0x41, 0xAB,
0x00, 0x00, 0x01, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0xE6, 0x31, 0x40, 0x18
};
// clang-format on
// clang-format off
static const uint8_t Encoding1_DataMacro [] =
{
CHIP_TLV_STRUCTURE(CHIP_TLV_TAG_FULLY_QUALIFIED_6Bytes(TestProfile_1, 1)),
CHIP_TLV_BOOL(CHIP_TLV_TAG_FULLY_QUALIFIED_6Bytes(TestProfile_1, 2), true),
CHIP_TLV_BOOL(CHIP_TLV_TAG_IMPLICIT_PROFILE_2Bytes(2), false),
CHIP_TLV_ARRAY(CHIP_TLV_TAG_CONTEXT_SPECIFIC(0)),
CHIP_TLV_INT8(CHIP_TLV_TAG_ANONYMOUS, 42),
CHIP_TLV_INT8(CHIP_TLV_TAG_ANONYMOUS, -17),
CHIP_TLV_INT32(CHIP_TLV_TAG_ANONYMOUS, -170000),
CHIP_TLV_UINT64(CHIP_TLV_TAG_ANONYMOUS, 40000000000ULL),
CHIP_TLV_STRUCTURE(CHIP_TLV_TAG_ANONYMOUS),
CHIP_TLV_END_OF_CONTAINER,
CHIP_TLV_LIST(CHIP_TLV_TAG_ANONYMOUS),
CHIP_TLV_NULL(CHIP_TLV_TAG_FULLY_QUALIFIED_6Bytes(TestProfile_1, 17)),
CHIP_TLV_NULL(CHIP_TLV_TAG_IMPLICIT_PROFILE_4Bytes(900000)),
CHIP_TLV_NULL(CHIP_TLV_TAG_ANONYMOUS),
CHIP_TLV_STRUCTURE(CHIP_TLV_TAG_IMPLICIT_PROFILE_4Bytes(4000000000ULL)),
CHIP_TLV_UTF8_STRING_2ByteLength(CHIP_TLV_TAG_COMMON_PROFILE_4Bytes(70000), sizeof(sLargeString) - 1,
'S', 'T', 'A', 'R', 'T', '.', '.', '.',
'!', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', '@',
'1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', '#', '1',
'2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', '$', '1', '2',
'3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', '%', '1', '2', '3',
'4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', '^', '1', '2', '3', '4',
'5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', '&', '1', '2', '3', '4', '5',
'6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', '*', '1', '2', '3', '4', '5', '6',
'7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
'0', '1', '2', '3', '4', '5', '6', '7', '(', '9', 'A', 'B', 'C', 'D', 'E', 'F', '0',
'1', '2', '3', '4', '5', '6', '7', ')', '9', 'A', 'B', 'C', 'D', 'E', 'F', '0', '1',
'2', '3', '4', '5', '6', '7', '-', '9', 'A', 'B', 'C', 'D', 'E', 'F', '0', '1', '2',
'3', '4', '5', '6', '7', '=', '9', 'A', 'B', 'C', 'D', 'E', 'F', '0', '1', '2', '3',
'4', '5', '6', '7', '[', '9', 'A', 'B', 'C', 'D', 'E', 'F', '0', '1', '2', '3', '4',
'5', '6', '7', ']', '9', 'A', 'B', 'C', 'D', 'E', 'F', '0', '1', '2', '3', '4', '5',
'6', '7', ';', '9', 'A', 'B', 'C', 'D', 'E', 'F', '0', '1', '2', '3', '4', '5', '6',
'7', '\'', '9', 'A', 'B', 'C', 'D', 'E', 'F',
'.', '.', '.', 'E', 'N', 'D'),
CHIP_TLV_END_OF_CONTAINER,
CHIP_TLV_END_OF_CONTAINER,
CHIP_TLV_END_OF_CONTAINER,
CHIP_TLV_UTF8_STRING_1ByteLength(CHIP_TLV_TAG_FULLY_QUALIFIED_6Bytes(TestProfile_1, 5), sizeof("This is a test") - 1,
'T', 'h', 'i', 's', ' ', 'i', 's', ' ', 'a', ' ', 't', 'e', 's', 't'),
CHIP_TLV_FLOAT32(CHIP_TLV_TAG_IMPLICIT_PROFILE_2Bytes(65535),
0x33, 0x33, 0x8f, 0x41), // (float)17.9
CHIP_TLV_FLOAT64(CHIP_TLV_TAG_IMPLICIT_PROFILE_4Bytes(65536),
0x66, 0x66, 0x66, 0x66, 0x66, 0xE6, 0x31, 0x40), // (double)17.9
CHIP_TLV_END_OF_CONTAINER
};
// clang-format on
static CHIP_ERROR WriteIntMinMax(nlTestSuite * inSuite, TLVWriter & writer)
{
CHIP_ERROR err;
err = writer.Put(AnonymousTag(), static_cast<int8_t>(INT8_MIN));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Put(AnonymousTag(), static_cast<int8_t>(INT8_MAX));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Put(AnonymousTag(), static_cast<int16_t>(INT16_MIN));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Put(AnonymousTag(), static_cast<int16_t>(INT16_MAX));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Put(AnonymousTag(), static_cast<int32_t>(INT32_MIN));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Put(AnonymousTag(), static_cast<int32_t>(INT32_MAX));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Put(AnonymousTag(), static_cast<int64_t>(INT64_MIN));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Put(AnonymousTag(), static_cast<int64_t>(INT64_MAX));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Put(AnonymousTag(), static_cast<uint8_t>(UINT8_MAX));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Put(AnonymousTag(), static_cast<uint16_t>(UINT16_MAX));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Put(AnonymousTag(), static_cast<uint32_t>(UINT32_MAX));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Put(AnonymousTag(), static_cast<uint64_t>(UINT64_MAX));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
return err;
}
static void CheckIntMinMax(nlTestSuite * inSuite, TLVReader & reader)
{
// Writer did Put(AnonymousTag(), static_cast<int8_t>(INT8_MIN))
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int8_t>(INT8_MIN));
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int16_t>(INT8_MIN));
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int32_t>(INT8_MIN));
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int64_t>(INT8_MIN));
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint8_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint16_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint32_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint64_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TestNext<TLVReader>(inSuite, reader);
// Writer did Put(AnonymousTag(), static_cast<int8_t>(INT8_MAX))
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int8_t>(INT8_MAX));
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int16_t>(INT8_MAX));
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int32_t>(INT8_MAX));
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int64_t>(INT8_MAX));
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint8_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint16_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint32_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint64_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TestNext<TLVReader>(inSuite, reader);
// Writer did Put(AnonymousTag(), static_cast<int16_t>(INT16_MIN))
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int8_t>(0), CHIP_ERROR_INVALID_INTEGER_VALUE);
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int16_t>(INT16_MIN));
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int32_t>(INT16_MIN));
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int64_t>(INT16_MIN));
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint8_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint16_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint32_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint64_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TestNext<TLVReader>(inSuite, reader);
// Writer did Put(AnonymousTag(), static_cast<int16_t>(INT16_MAX))
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int8_t>(0), CHIP_ERROR_INVALID_INTEGER_VALUE);
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int16_t>(INT16_MAX));
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int32_t>(INT16_MAX));
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int64_t>(INT16_MAX));
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint8_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint16_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint32_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint64_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TestNext<TLVReader>(inSuite, reader);
// Writer did Put(AnonymousTag(), static_cast<int32_t>(INT32_MIN))
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int8_t>(0), CHIP_ERROR_INVALID_INTEGER_VALUE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int16_t>(0), CHIP_ERROR_INVALID_INTEGER_VALUE);
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int32_t>(INT32_MIN));
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int64_t>(INT32_MIN));
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint8_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint16_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint32_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint64_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TestNext<TLVReader>(inSuite, reader);
// Writer did Put(AnonymousTag(), static_cast<int32_t>(INT32_MAX))
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int8_t>(0), CHIP_ERROR_INVALID_INTEGER_VALUE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int16_t>(0), CHIP_ERROR_INVALID_INTEGER_VALUE);
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int32_t>(INT32_MAX));
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int64_t>(INT32_MAX));
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint8_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint16_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint32_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint64_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TestNext<TLVReader>(inSuite, reader);
// Writer did Put(AnonymousTag(), static_cast<int64_t>(INT64_MIN))
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int8_t>(0), CHIP_ERROR_INVALID_INTEGER_VALUE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int16_t>(0), CHIP_ERROR_INVALID_INTEGER_VALUE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int32_t>(0), CHIP_ERROR_INVALID_INTEGER_VALUE);
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int64_t>(INT64_MIN));
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint8_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint16_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint32_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint64_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TestNext<TLVReader>(inSuite, reader);
// Writer did Put(AnonymousTag(), static_cast<int64_t>(INT64_MAX))
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int8_t>(0), CHIP_ERROR_INVALID_INTEGER_VALUE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int16_t>(0), CHIP_ERROR_INVALID_INTEGER_VALUE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int32_t>(0), CHIP_ERROR_INVALID_INTEGER_VALUE);
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<int64_t>(INT64_MAX));
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint8_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint16_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint32_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint64_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TestNext<TLVReader>(inSuite, reader);
// Writer did Put(AnonymousTag(), static_cast<uint8_t>(UINT8_MAX))
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<int8_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<int16_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<int32_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<int64_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET_NOERROR(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<uint8_t>(UINT8_MAX));
TEST_GET_NOERROR(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<uint16_t>(UINT8_MAX));
TEST_GET_NOERROR(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<uint32_t>(UINT8_MAX));
TEST_GET_NOERROR(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<uint64_t>(UINT8_MAX));
TestNext<TLVReader>(inSuite, reader);
// Writer did Put(AnonymousTag(), static_cast<uint16_t>(UINT16_MAX))
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<int8_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<int16_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<int32_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<int64_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<uint8_t>(0), CHIP_ERROR_INVALID_INTEGER_VALUE);
TEST_GET_NOERROR(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<uint16_t>(UINT16_MAX));
TEST_GET_NOERROR(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<uint32_t>(UINT16_MAX));
TEST_GET_NOERROR(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<uint64_t>(UINT16_MAX));
TestNext<TLVReader>(inSuite, reader);
// Writer did Put(AnonymousTag(), static_cast<uint32_t>(UINT32_MAX))
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<int8_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<int16_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<int32_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<int64_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<uint8_t>(0), CHIP_ERROR_INVALID_INTEGER_VALUE);
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<uint16_t>(0), CHIP_ERROR_INVALID_INTEGER_VALUE);
TEST_GET_NOERROR(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<uint32_t>(UINT32_MAX));
TEST_GET_NOERROR(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<uint64_t>(UINT32_MAX));
TestNext<TLVReader>(inSuite, reader);
// Writer did Put(AnonymousTag(), static_cast<uint64_t>(UINT64_MAX))
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<int8_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<int16_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<int32_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<int64_t>(0), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<uint8_t>(0), CHIP_ERROR_INVALID_INTEGER_VALUE);
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<uint16_t>(0), CHIP_ERROR_INVALID_INTEGER_VALUE);
TEST_GET(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<uint32_t>(0), CHIP_ERROR_INVALID_INTEGER_VALUE);
TEST_GET_NOERROR(inSuite, reader, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<uint64_t>(UINT64_MAX));
}
void WriteEncoding1(nlTestSuite * inSuite, TLVWriter & writer)
{
CHIP_ERROR err;
TLVWriter writer2;
err = writer.OpenContainer(ProfileTag(TestProfile_1, 1), kTLVType_Structure, writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.PutBoolean(ProfileTag(TestProfile_2, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
{
TLVWriter writer3;
err = writer2.OpenContainer(ContextTag(0), kTLVType_Array, writer3);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// TODO(#1306): expand coverage of inttype encoding tests.
err = writer3.Put(AnonymousTag(), static_cast<int32_t>(42));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer3.Put(AnonymousTag(), static_cast<int32_t>(-17));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer3.Put(AnonymousTag(), static_cast<int32_t>(-170000));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer3.Put(AnonymousTag(), static_cast<uint64_t>(40000000000ULL));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
{
TLVWriter writer4;
err = writer3.OpenContainer(AnonymousTag(), kTLVType_Structure, writer4);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer3.CloseContainer(writer4);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
{
TLVWriter writer5;
err = writer3.OpenContainer(AnonymousTag(), kTLVType_List, writer5);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer5.PutNull(ProfileTag(TestProfile_1, 17));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer5.PutNull(ProfileTag(TestProfile_2, 900000));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer5.PutNull(AnonymousTag());
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
{
TLVType outerContainerType;
err = writer5.StartContainer(ProfileTag(TestProfile_2, 4000000000ULL), kTLVType_Structure, outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer5.PutString(CommonTag(70000), sLargeString);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer5.EndContainer(outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
err = writer3.CloseContainer(writer5);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
err = writer2.CloseContainer(writer3);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
err = writer2.PutString(ProfileTag(TestProfile_1, 5), "This is a test");
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.Put(ProfileTag(TestProfile_2, 65535), static_cast<float>(17.9));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.Put(ProfileTag(TestProfile_2, 65536), 17.9);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.CloseContainer(writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
void WriteEmptyEncoding(nlTestSuite * inSuite, TLVWriter & writer)
{
CHIP_ERROR err;
TLVWriter writer2;
err = writer.OpenContainer(ProfileTag(TestProfile_1, 1), kTLVType_Structure, writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
{
TLVWriter writer3;
err = writer2.OpenContainer(ProfileTag(TestProfile_1, 256), kTLVType_Array, writer3);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.CloseContainer(writer3);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
err = writer.CloseContainer(writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
void ReadEncoding1(nlTestSuite * inSuite, TLVReader & reader)
{
TestNext<TLVReader>(inSuite, reader);
{
TLVReader reader2;
TestAndOpenContainer(inSuite, reader, kTLVType_Structure, ProfileTag(TestProfile_1, 1), reader2);
TestNext<TLVReader>(inSuite, reader2);
TEST_GET_NOERROR(inSuite, reader2, kTLVType_Boolean, ProfileTag(TestProfile_1, 2), true);
TestNext<TLVReader>(inSuite, reader2);
TEST_GET_NOERROR(inSuite, reader2, kTLVType_Boolean, ProfileTag(TestProfile_2, 2), false);
TestNext<TLVReader>(inSuite, reader2);
{
TLVReader reader3;
TestAndOpenContainer(inSuite, reader2, kTLVType_Array, ContextTag(0), reader3);
TestNext<TLVReader>(inSuite, reader3);
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int8_t>(42));
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int16_t>(42));
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int32_t>(42));
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int64_t>(42));
TEST_GET(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint8_t>(42), CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint16_t>(42),
CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint32_t>(42),
CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint64_t>(42),
CHIP_ERROR_WRONG_TLV_TYPE);
TestNext<TLVReader>(inSuite, reader3);
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int8_t>(-17));
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int16_t>(-17));
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int32_t>(-17));
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int64_t>(-17));
TEST_GET(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint64_t>(-17),
CHIP_ERROR_WRONG_TLV_TYPE);
TestNext<TLVReader>(inSuite, reader3);
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int32_t>(-170000));
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int64_t>(-170000));
TestNext<TLVReader>(inSuite, reader3);
TEST_GET(inSuite, reader3, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<int64_t>(40000000000ULL),
CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET_NOERROR(inSuite, reader3, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<uint64_t>(40000000000ULL));
TestNext<TLVReader>(inSuite, reader3);
{
TLVReader reader4;
TestAndOpenContainer(inSuite, reader3, kTLVType_Structure, AnonymousTag(), reader4);
TestEndAndCloseContainer(inSuite, reader3, reader4);
}
TestNext<TLVReader>(inSuite, reader3);
{
TLVReader reader5;
TestAndOpenContainer(inSuite, reader3, kTLVType_List, AnonymousTag(), reader5);
TestNext<TLVReader>(inSuite, reader5);
TestNull(inSuite, reader5, ProfileTag(TestProfile_1, 17));
TestNext<TLVReader>(inSuite, reader5);
TestNull(inSuite, reader5, ProfileTag(TestProfile_2, 900000));
TestNext<TLVReader>(inSuite, reader5);
TestNull(inSuite, reader5, AnonymousTag());
TestNext<TLVReader>(inSuite, reader5);
{
TLVType outerContainerType;
TestAndEnterContainer<TLVReader>(inSuite, reader5, kTLVType_Structure, ProfileTag(TestProfile_2, 4000000000ULL),
outerContainerType);
TestNext<TLVReader>(inSuite, reader5);
TestString(inSuite, reader5, CommonTag(70000), sLargeString);
TestEndAndExitContainer<TLVReader>(inSuite, reader5, outerContainerType);
}
TestEndAndCloseContainer(inSuite, reader3, reader5);
}
TestEndAndCloseContainer(inSuite, reader2, reader3);
}
TestNext<TLVReader>(inSuite, reader2);
TestString(inSuite, reader2, ProfileTag(TestProfile_1, 5), "This is a test");
TestNext<TLVReader>(inSuite, reader2);
TEST_GET_NOERROR(inSuite, reader2, kTLVType_FloatingPointNumber, ProfileTag(TestProfile_2, 65535), 17.9f);
TEST_GET_NOERROR(inSuite, reader2, kTLVType_FloatingPointNumber, ProfileTag(TestProfile_2, 65535),
static_cast<double>(17.9f));
TestNext<TLVReader>(inSuite, reader2);
TEST_GET_NOERROR(inSuite, reader2, kTLVType_FloatingPointNumber, ProfileTag(TestProfile_2, 65536), 17.9);
TestEndAndCloseContainer(inSuite, reader, reader2);
}
TestEnd<TLVReader>(inSuite, reader);
}
void WriteEncoding2(nlTestSuite * inSuite, TLVWriter & writer)
{
CHIP_ERROR err;
{ // Container 1
TLVWriter writer1;
err = writer.OpenContainer(ProfileTag(TestProfile_1, 1), kTLVType_Structure, writer1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer1.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer1.PutBoolean(ProfileTag(TestProfile_2, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.CloseContainer(writer1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
{ // Container 2
TLVWriter writer1;
err = writer.OpenContainer(ProfileTag(TestProfile_2, 1), kTLVType_Structure, writer1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer1.PutBoolean(ProfileTag(TestProfile_2, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer1.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.CloseContainer(writer1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
void WriteEncoding3(nlTestSuite * inSuite, TLVWriter & writer)
{
CHIP_ERROR err;
{ // Container 1
TLVWriter writer1;
err = writer.OpenContainer(ProfileTag(TestProfile_1, 1), kTLVType_Structure, writer1);
if (err != CHIP_NO_ERROR)
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer1.PutBoolean(ProfileTag(TestProfile_2, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.CloseContainer(writer1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
void ReadEncoding3(nlTestSuite * inSuite, TLVReader & reader)
{
TLVReader reader2;
TestAndOpenContainer(inSuite, reader, kTLVType_Structure, ProfileTag(TestProfile_1, 1), reader2);
TestNext<TLVReader>(inSuite, reader2);
TEST_GET_NOERROR(inSuite, reader2, kTLVType_Boolean, ProfileTag(TestProfile_2, 2), false);
TestEndAndCloseContainer(inSuite, reader, reader2);
}
// clang-format off
static const uint8_t Encoding5_DataMacro [] =
{
CHIP_TLV_STRUCTURE(CHIP_TLV_TAG_FULLY_QUALIFIED_6Bytes(TestProfile_1, 1)),
CHIP_TLV_BOOL(CHIP_TLV_TAG_FULLY_QUALIFIED_6Bytes(TestProfile_1, 2), true),
CHIP_TLV_BOOL(CHIP_TLV_TAG_IMPLICIT_PROFILE_2Bytes(2), false),
CHIP_TLV_BOOL(CHIP_TLV_TAG_FULLY_QUALIFIED_6Bytes(TestProfile_1, 2), false),
CHIP_TLV_BOOL(CHIP_TLV_TAG_IMPLICIT_PROFILE_2Bytes(2), true),
CHIP_TLV_STRUCTURE(CHIP_TLV_TAG_FULLY_QUALIFIED_6Bytes(TestProfile_1, 1)),
CHIP_TLV_BOOL(CHIP_TLV_TAG_FULLY_QUALIFIED_6Bytes(TestProfile_1, 2), true),
CHIP_TLV_BOOL(CHIP_TLV_TAG_IMPLICIT_PROFILE_2Bytes(2), false),
CHIP_TLV_END_OF_CONTAINER,
CHIP_TLV_STRUCTURE(CHIP_TLV_TAG_IMPLICIT_PROFILE_2Bytes(1)),
CHIP_TLV_BOOL(CHIP_TLV_TAG_IMPLICIT_PROFILE_2Bytes(2), false),
CHIP_TLV_BOOL(CHIP_TLV_TAG_FULLY_QUALIFIED_6Bytes(TestProfile_1, 2), true),
CHIP_TLV_END_OF_CONTAINER,
CHIP_TLV_END_OF_CONTAINER,
CHIP_TLV_STRUCTURE(CHIP_TLV_TAG_IMPLICIT_PROFILE_2Bytes(1)),
CHIP_TLV_BOOL(CHIP_TLV_TAG_IMPLICIT_PROFILE_2Bytes(2), false),
CHIP_TLV_BOOL(CHIP_TLV_TAG_FULLY_QUALIFIED_6Bytes(TestProfile_1, 2), true),
CHIP_TLV_END_OF_CONTAINER,
};
// clang-format on
void WriteEncoding5(nlTestSuite * inSuite, TLVWriter & writer)
{
CHIP_ERROR err;
{ // Container 1
TLVWriter writer1;
err = writer.OpenContainer(ProfileTag(TestProfile_1, 1), kTLVType_Structure, writer1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer1.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer1.PutBoolean(ProfileTag(TestProfile_2, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer1.PutBoolean(ProfileTag(TestProfile_1, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer1.PutBoolean(ProfileTag(TestProfile_2, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
{ // Inner Container 1
TLVWriter writer2;
err = writer1.OpenContainer(ProfileTag(TestProfile_1, 1), kTLVType_Structure, writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.PutBoolean(ProfileTag(TestProfile_2, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer1.CloseContainer(writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
{ // Inner Container 2
TLVWriter writer2;
err = writer1.OpenContainer(ProfileTag(TestProfile_2, 1), kTLVType_Structure, writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.PutBoolean(ProfileTag(TestProfile_2, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer1.CloseContainer(writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
err = writer.CloseContainer(writer1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
{ // Container 2
TLVWriter writer1;
err = writer.OpenContainer(ProfileTag(TestProfile_2, 1), kTLVType_Structure, writer1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer1.PutBoolean(ProfileTag(TestProfile_2, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer1.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.CloseContainer(writer1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
/**
* AppendEncoding2()
*
* This function appends two boolean types and two container types to the first
* container.
*
* The boolean types are-
* <TestProfile_1, 2, false>
* <TestProfile_2, 2, true>
*
* The two new container types are-
* <TestProfile_1, 1, kTLVType_Structure, <TestProfile_1, 2, true> <TestProfile_2, 2, false> >,
* <TestProfile_2, 1, kTLVType_Structure, <TestProfile_2, 2, false> <TestProfile_1, 2, true> >
*/
void AppendEncoding2(nlTestSuite * inSuite, uint8_t * buf, uint32_t dataLen, uint32_t maxLen, uint32_t & updatedLen)
{
CHIP_ERROR err;
TLVUpdater updater;
err = updater.Init(buf, dataLen, maxLen);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
updater.SetImplicitProfileId(TestProfile_2);
TestNext<TLVUpdater>(inSuite, updater);
{
TLVType outerContainerType;
TestAndEnterContainer<TLVUpdater>(inSuite, updater, kTLVType_Structure, ProfileTag(TestProfile_1, 1), outerContainerType);
TestNext<TLVUpdater>(inSuite, updater);
// Move the element without modification
TestMove(inSuite, updater);
TestNext<TLVUpdater>(inSuite, updater);
// Read and copy the element with/without modification
TEST_GET_NOERROR(inSuite, updater, kTLVType_Boolean, ProfileTag(TestProfile_2, 2), false);
err = updater.PutBoolean(ProfileTag(TestProfile_2, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// TestEnd and add data at the end of the container
TestEnd<TLVUpdater>(inSuite, updater);
// Put new values in the encoding using the updater
// Add <TestProfile_1, 2, false>
err = updater.PutBoolean(ProfileTag(TestProfile_1, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Add <TestProfile_2, 2, true>
err = updater.PutBoolean(ProfileTag(TestProfile_2, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Add a new container
{
TLVType outerContainerType1;
err = updater.StartContainer(ProfileTag(TestProfile_1, 1), kTLVType_Structure, outerContainerType1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Add <TestProfile_1, 2, true>
err = updater.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Add <TestProfile_1, 2, true>
err = updater.PutBoolean(ProfileTag(TestProfile_2, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Close the container
err = updater.EndContainer(outerContainerType1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
// Add another new container
{
TLVType outerContainerType1;
err = updater.StartContainer(ProfileTag(TestProfile_2, 1), kTLVType_Structure, outerContainerType1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Add <TestProfile_2, 2, false>
err = updater.PutBoolean(ProfileTag(TestProfile_2, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Add <TestProfile_1, 2, true>
err = updater.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Close the container
err = updater.EndContainer(outerContainerType1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
TestEndAndExitContainer<TLVUpdater>(inSuite, updater, outerContainerType);
}
TestNext<TLVUpdater>(inSuite, updater);
// Move the container unmodified
TestMove(inSuite, updater);
TestEnd<TLVUpdater>(inSuite, updater);
err = updater.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
updatedLen = updater.GetLengthWritten();
}
/**
* FindAppendEncoding2()
*
* This function appends two boolean types and two container types to the first
* container. It is very similar to AppendEncoding2() above except for the fact
* that it uses TLVUtilities::Find() to find the element of interest before
* appending new data.
*
* The boolean types are-
* <TestProfile_1, 2, false>
* <TestProfile_2, 2, true>
*
* The two new container types are-
* <TestProfile_1, 1, kTLVType_Structure, <TestProfile_1, 2, true> <TestProfile_2, 2, false> >,
* <TestProfile_2, 1, kTLVType_Structure, <TestProfile_2, 2, false> <TestProfile_1, 2, true> >
*/
void FindAppendEncoding2(nlTestSuite * inSuite, uint8_t * buf, uint32_t dataLen, uint32_t maxLen, uint32_t & updatedLen,
bool findContainer)
{
CHIP_ERROR err;
TLVReader reader;
TLVUpdater updater;
// Initialize a reader
reader.Init(buf, dataLen);
reader.ImplicitProfileId = TestProfile_2;
if (findContainer)
{
// Find the container
TLVReader tagReader;
TLVType outerContainerType;
err = chip::TLV::Utilities::Find(reader, ProfileTag(TestProfile_1, 1), tagReader);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = tagReader.EnterContainer(outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
do
{
err = tagReader.Next();
} while (err != CHIP_END_OF_TLV);
TestEnd<TLVReader>(inSuite, tagReader);
// Init a TLVUpdater using the TLVReader
err = updater.Init(tagReader, maxLen - dataLen);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
else
{
// Find
TLVReader tagReader;
err = chip::TLV::Utilities::Find(reader, ProfileTag(TestProfile_2, 2), tagReader);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Test Find(recurse = true)
TLVReader tagReader2;
err = chip::TLV::Utilities::Find(reader, ProfileTag(TestProfile_2, 2), tagReader2, true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
//
// Test Find(recurse = false)
TLVReader tagReader3;
err = chip::TLV::Utilities::Find(reader, ProfileTag(TestProfile_2, 2), tagReader3, false);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_TLV_TAG_NOT_FOUND);
// Init a TLVUpdater using the TLVReader
err = updater.Init(tagReader, maxLen - dataLen);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
TestNext<TLVUpdater>(inSuite, updater);
// Move the element without modification
TestMove(inSuite, updater);
}
// Put new values in the encoding using the updater
// Add <TestProfile_1, 2, false>
err = updater.PutBoolean(ProfileTag(TestProfile_1, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Add <TestProfile_2, 2, true>
err = updater.PutBoolean(ProfileTag(TestProfile_2, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Add a new container
{
TLVType outerContainerType1;
err = updater.StartContainer(ProfileTag(TestProfile_1, 1), kTLVType_Structure, outerContainerType1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Add <TestProfile_1, 2, true>
err = updater.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Add <TestProfile_1, 2, true>
err = updater.PutBoolean(ProfileTag(TestProfile_2, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Close the container
err = updater.EndContainer(outerContainerType1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
// Add another new container
{
TLVType outerContainerType1;
err = updater.StartContainer(ProfileTag(TestProfile_2, 1), kTLVType_Structure, outerContainerType1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Add <TestProfile_2, 2, false>
err = updater.PutBoolean(ProfileTag(TestProfile_2, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Add <TestProfile_1, 2, true>
err = updater.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Close the container
err = updater.EndContainer(outerContainerType1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
// Move everything else unmodified
updater.MoveUntilEnd();
TestEnd<TLVUpdater>(inSuite, updater);
err = updater.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
updatedLen = updater.GetLengthWritten();
}
void AppendEncoding3(nlTestSuite * inSuite, uint8_t * buf, uint32_t dataLen, uint32_t maxLen, uint32_t & updatedLen)
{
CHIP_ERROR err;
TLVUpdater updater;
err = updater.Init(buf, dataLen, maxLen);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
updater.SetImplicitProfileId(TestProfile_2);
TestNext<TLVUpdater>(inSuite, updater);
{
TLVType outerContainerType;
TestAndEnterContainer<TLVUpdater>(inSuite, updater, kTLVType_Structure, ProfileTag(TestProfile_1, 1), outerContainerType);
TestNext<TLVUpdater>(inSuite, updater);
// Move the element without modification
TestMove(inSuite, updater);
// Put new value in the encoding using the updater
// Add <TestProfile_2, 2, true>
err = updater.PutBoolean(ProfileTag(TestProfile_2, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
TestEndAndExitContainer<TLVUpdater>(inSuite, updater, outerContainerType);
}
TestEnd<TLVUpdater>(inSuite, updater);
err = updater.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
updatedLen = updater.GetLengthWritten();
}
void AppendEncoding4(nlTestSuite * inSuite, uint8_t * buf, uint32_t dataLen, uint32_t maxLen, uint32_t & updatedLen)
{
CHIP_ERROR err;
TLVUpdater updater;
err = updater.Init(buf, dataLen, maxLen);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
updater.SetImplicitProfileId(TestProfile_2);
// Add a new container
{
TLVType outerContainerType;
err = updater.StartContainer(ProfileTag(TestProfile_1, 1), kTLVType_Structure, outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Add <TestProfile_1, 2, true>
err = updater.PutBoolean(ProfileTag(TestProfile_2, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Close the container
err = updater.EndContainer(outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
err = updater.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
updatedLen = updater.GetLengthWritten();
}
void DeleteEncoding5(nlTestSuite * inSuite, uint8_t * buf, uint32_t dataLen, uint32_t maxLen, uint32_t & updatedLen)
{
CHIP_ERROR err;
TLVUpdater updater;
err = updater.Init(buf, dataLen, maxLen);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
updater.SetImplicitProfileId(TestProfile_2);
TestNext<TLVUpdater>(inSuite, updater);
{
TLVType outerContainerType;
TestAndEnterContainer<TLVUpdater>(inSuite, updater, kTLVType_Structure, ProfileTag(TestProfile_1, 1), outerContainerType);
TestNext<TLVUpdater>(inSuite, updater);
TestMove(inSuite, updater);
TestNext<TLVUpdater>(inSuite, updater);
TestMove(inSuite, updater);
TestNext<TLVUpdater>(inSuite, updater);
// Get the value to inspect and skip writing it
TEST_GET_NOERROR(inSuite, updater, kTLVType_Boolean, ProfileTag(TestProfile_1, 2), false);
TestNext<TLVUpdater>(inSuite, updater);
// Skip the next boolean type and don't copy by doing nothing
TestNext<TLVUpdater>(inSuite, updater);
// Read ahead into the next container and decide whether to skip or
// not based on elements in the container
{
TLVReader reader;
TLVType containerType;
updater.GetReader(reader);
TestAndEnterContainer<TLVReader>(inSuite, reader, kTLVType_Structure, ProfileTag(TestProfile_1, 1), containerType);
TestNext<TLVReader>(inSuite, reader);
// If the container's first element has the tag <TestProfile_1, 2>
// skip the whole container, and if NOT copy the container
if (reader.GetTag() != ProfileTag(TestProfile_1, 2))
TestMove(inSuite, updater);
}
TestNext<TLVUpdater>(inSuite, updater);
// Skip the next container and don't copy by doing nothing
TestEndAndExitContainer<TLVUpdater>(inSuite, updater, outerContainerType);
}
// Move everything else unmodified
updater.MoveUntilEnd();
TestEnd<TLVUpdater>(inSuite, updater);
err = updater.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
updatedLen = updater.GetLengthWritten();
}
void ReadAppendedEncoding2(nlTestSuite * inSuite, TLVReader & reader)
{
TestNext<TLVReader>(inSuite, reader);
{ // Container 1
TLVReader reader1;
TestAndOpenContainer(inSuite, reader, kTLVType_Structure, ProfileTag(TestProfile_1, 1), reader1);
TestNext<TLVReader>(inSuite, reader1);
TEST_GET_NOERROR(inSuite, reader1, kTLVType_Boolean, ProfileTag(TestProfile_1, 2), true);
TestNext<TLVReader>(inSuite, reader1);
TEST_GET_NOERROR(inSuite, reader1, kTLVType_Boolean, ProfileTag(TestProfile_2, 2), false);
TestNext<TLVReader>(inSuite, reader1);
TEST_GET_NOERROR(inSuite, reader1, kTLVType_Boolean, ProfileTag(TestProfile_1, 2), false);
TestNext<TLVReader>(inSuite, reader1);
TEST_GET_NOERROR(inSuite, reader1, kTLVType_Boolean, ProfileTag(TestProfile_2, 2), true);
TestNext<TLVReader>(inSuite, reader1);
{
TLVReader reader2;
TestAndOpenContainer(inSuite, reader1, kTLVType_Structure, ProfileTag(TestProfile_1, 1), reader2);
TestNext<TLVReader>(inSuite, reader2);
TEST_GET_NOERROR(inSuite, reader2, kTLVType_Boolean, ProfileTag(TestProfile_1, 2), true);
TestNext<TLVReader>(inSuite, reader2);
TEST_GET_NOERROR(inSuite, reader2, kTLVType_Boolean, ProfileTag(TestProfile_2, 2), false);
TestEndAndCloseContainer(inSuite, reader1, reader2);
}
TestNext<TLVReader>(inSuite, reader1);
{
TLVReader reader2;
TestAndOpenContainer(inSuite, reader1, kTLVType_Structure, ProfileTag(TestProfile_2, 1), reader2);
TestNext<TLVReader>(inSuite, reader2);
TEST_GET_NOERROR(inSuite, reader2, kTLVType_Boolean, ProfileTag(TestProfile_2, 2), false);
TestNext<TLVReader>(inSuite, reader2);
TEST_GET_NOERROR(inSuite, reader2, kTLVType_Boolean, ProfileTag(TestProfile_1, 2), true);
TestEndAndCloseContainer(inSuite, reader1, reader2);
}
TestEndAndCloseContainer(inSuite, reader, reader1);
}
TestNext<TLVReader>(inSuite, reader);
{ // Container 2
TLVReader reader1;
TestAndOpenContainer(inSuite, reader, kTLVType_Structure, ProfileTag(TestProfile_2, 1), reader1);
TestNext<TLVReader>(inSuite, reader1);
TEST_GET_NOERROR(inSuite, reader1, kTLVType_Boolean, ProfileTag(TestProfile_2, 2), false);
TestNext<TLVReader>(inSuite, reader1);
TEST_GET_NOERROR(inSuite, reader1, kTLVType_Boolean, ProfileTag(TestProfile_1, 2), true);
TestEndAndCloseContainer(inSuite, reader, reader1);
}
TestEnd<TLVReader>(inSuite, reader);
}
void ReadAppendedEncoding3(nlTestSuite * inSuite, TLVReader & reader)
{
TestNext<TLVReader>(inSuite, reader);
{ // Container 1
TLVReader reader1;
TestAndOpenContainer(inSuite, reader, kTLVType_Structure, ProfileTag(TestProfile_1, 1), reader1);
TestNext<TLVReader>(inSuite, reader1);
TEST_GET_NOERROR(inSuite, reader1, kTLVType_Boolean, ProfileTag(TestProfile_2, 2), false);
TestNext<TLVReader>(inSuite, reader1);
TEST_GET_NOERROR(inSuite, reader1, kTLVType_Boolean, ProfileTag(TestProfile_2, 2), true);
TestEndAndCloseContainer(inSuite, reader, reader1);
}
TestEnd<TLVReader>(inSuite, reader);
}
void ReadAppendedEncoding4(nlTestSuite * inSuite, TLVReader & reader)
{
TestNext<TLVReader>(inSuite, reader);
{ // Container 1
TLVReader reader1;
TestAndOpenContainer(inSuite, reader, kTLVType_Structure, ProfileTag(TestProfile_1, 1), reader1);
TestNext<TLVReader>(inSuite, reader1);
TEST_GET_NOERROR(inSuite, reader1, kTLVType_Boolean, ProfileTag(TestProfile_2, 2), false);
TestEndAndCloseContainer(inSuite, reader, reader1);
}
TestEnd<TLVReader>(inSuite, reader);
}
void ReadDeletedEncoding5(nlTestSuite * inSuite, TLVReader & reader)
{
TestNext<TLVReader>(inSuite, reader);
{ // Container 1
TLVReader reader1;
TestAndOpenContainer(inSuite, reader, kTLVType_Structure, ProfileTag(TestProfile_1, 1), reader1);
TestNext<TLVReader>(inSuite, reader1);
TEST_GET_NOERROR(inSuite, reader1, kTLVType_Boolean, ProfileTag(TestProfile_1, 2), true);
TestNext<TLVReader>(inSuite, reader1);
TEST_GET_NOERROR(inSuite, reader1, kTLVType_Boolean, ProfileTag(TestProfile_2, 2), false);
TestEndAndCloseContainer(inSuite, reader, reader1);
}
TestNext<TLVReader>(inSuite, reader);
{ // Container 2
TLVReader reader1;
TestAndOpenContainer(inSuite, reader, kTLVType_Structure, ProfileTag(TestProfile_2, 1), reader1);
TestNext<TLVReader>(inSuite, reader1);
TEST_GET_NOERROR(inSuite, reader1, kTLVType_Boolean, ProfileTag(TestProfile_2, 2), false);
TestNext<TLVReader>(inSuite, reader1);
TEST_GET_NOERROR(inSuite, reader1, kTLVType_Boolean, ProfileTag(TestProfile_1, 2), true);
TestEndAndCloseContainer(inSuite, reader, reader1);
}
TestEnd<TLVReader>(inSuite, reader);
}
/**
* Test Simple Write and Reader
*/
void CheckSimpleWriteRead(nlTestSuite * inSuite, void * inContext)
{
uint8_t buf[2048];
TLVWriter writer;
TLVReader reader;
uint32_t remainingFreedLen;
writer.Init(buf);
writer.ImplicitProfileId = TestProfile_2;
remainingFreedLen = writer.GetRemainingFreeLength();
NL_TEST_ASSERT(inSuite, sizeof(buf) == remainingFreedLen);
WriteEncoding1(inSuite, writer);
uint32_t encodedLen = writer.GetLengthWritten();
#ifdef DUMP_ENCODING
for (uint32_t i = 0; i < encodedLen; i++)
{
if (i != 0 && i % 16 == 0)
printf("\n");
printf("0x%02X, ", buf[i]);
}
printf("\n");
#endif
NL_TEST_ASSERT(inSuite, encodedLen == sizeof(Encoding1));
NL_TEST_ASSERT(inSuite, memcmp(buf, Encoding1, encodedLen) == 0);
reader.Init(buf, encodedLen);
reader.ImplicitProfileId = TestProfile_2;
ReadEncoding1(inSuite, reader);
}
static void TestIntMinMax(nlTestSuite * inSuite, void * inContext)
{
CHIP_ERROR err;
uint8_t buf[2048];
TLVWriter writer, writer1;
TLVReader reader, reader1;
writer.Init(buf, sizeof(buf));
writer.ImplicitProfileId = TestProfile_3;
err = writer.OpenContainer(ProfileTag(TestProfile_3, 1), kTLVType_Array, writer1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
WriteIntMinMax(inSuite, writer1);
err = writer.CloseContainer(writer1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
reader.Init(buf, sizeof(buf));
reader.ImplicitProfileId = TestProfile_3;
TestNext<TLVReader>(inSuite, reader);
TestAndOpenContainer(inSuite, reader, kTLVType_Array, ProfileTag(TestProfile_3, 1), reader1);
TestNext<TLVReader>(inSuite, reader1);
CheckIntMinMax(inSuite, reader1);
TestEndAndCloseContainer(inSuite, reader, reader1);
}
/**
* Log the specified message in the form of @a aFormat.
*
* @param[in] aFormat A pointer to a NULL-terminated C string with
* C Standard Library-style format specifiers
* containing the log message to be formatted and
* logged.
* @param[in] ... An argument list whose elements should correspond
* to the format specifiers in @a aFormat.
*
*/
void ENFORCE_FORMAT(1, 2) SimpleDumpWriter(const char * aFormat, ...)
{
va_list args;
va_start(args, aFormat);
vprintf(aFormat, args);
va_end(args);
}
/**
* Test Pretty Printer
*/
void CheckPrettyPrinter(nlTestSuite * inSuite, void * inContext)
{
uint8_t buf[2048];
TLVWriter writer;
TLVReader reader;
writer.Init(buf);
writer.ImplicitProfileId = TestProfile_2;
WriteEncoding1(inSuite, writer);
uint32_t encodedLen = writer.GetLengthWritten();
NL_TEST_ASSERT(inSuite, encodedLen == sizeof(Encoding1));
NL_TEST_ASSERT(inSuite, memcmp(buf, Encoding1, encodedLen) == 0);
reader.Init(buf, encodedLen);
reader.ImplicitProfileId = TestProfile_2;
chip::TLV::Debug::Dump(reader, SimpleDumpWriter);
}
static char gStringDumpWriterBuf[128] = { 0 };
static size_t gStringDumpWriterLengthWritten = 0;
/**
* Log the specified message in the form of @a aFormat.
*
* @param[in] aFormat A pointer to a NULL-terminated C string with
* C Standard Library-style format specifiers
* containing the log message to be formatted and
* logged.
* @param[in] ... An argument list whose elements should correspond
* to the format specifiers in @a aFormat.
*
*/
void ENFORCE_FORMAT(1, 2) StringDumpWriter(const char * aFormat, ...)
{
va_list args;
va_start(args, aFormat);
gStringDumpWriterLengthWritten +=
static_cast<size_t>(vsprintf(&gStringDumpWriterBuf[gStringDumpWriterLengthWritten], aFormat, args));
va_end(args);
}
/**
* Test Octet String Pretty Printer
*/
void CheckOctetStringPrettyPrinter(nlTestSuite * inSuite, void * inContext)
{
const uint8_t testOctetString[] = { 0x62, 0xFA, 0x82, 0x33, 0x59, 0xAC, 0xFA, 0xA9 };
const char expectedPrint[] =
"0x04, tag[Common Profile (2 Bytes)]: 0x0::0x0::0x0, type: Octet String (0x10), length: 8, value: hex:62FA823359ACFAA9\n";
uint8_t encodedBuf[128] = { 0 };
TLVWriter writer;
writer.Init(encodedBuf);
NL_TEST_ASSERT_SUCCESS(inSuite, writer.PutBytes(CommonTag(0), testOctetString, sizeof(testOctetString)));
NL_TEST_ASSERT_SUCCESS(inSuite, writer.Finalize());
TLVReader reader;
reader.Init(encodedBuf, writer.GetLengthWritten());
chip::TLV::Debug::Dump(reader, StringDumpWriter);
NL_TEST_ASSERT(inSuite, strlen(expectedPrint) == strlen(gStringDumpWriterBuf));
NL_TEST_ASSERT(inSuite, strcmp(expectedPrint, gStringDumpWriterBuf) == 0);
}
/**
* Test Data Macros
*/
void CheckDataMacro(nlTestSuite * inSuite, void * inContext)
{
NL_TEST_ASSERT(inSuite, sizeof(Encoding1_DataMacro) == sizeof(Encoding1));
NL_TEST_ASSERT(inSuite, memcmp(Encoding1, Encoding1_DataMacro, sizeof(Encoding1)) == 0);
uint8_t buf[2048];
TLVWriter writer;
writer.Init(buf);
writer.ImplicitProfileId = TestProfile_2;
WriteEncoding5(inSuite, writer);
uint32_t encodedLen = writer.GetLengthWritten();
NL_TEST_ASSERT(inSuite, sizeof(Encoding5_DataMacro) == encodedLen);
NL_TEST_ASSERT(inSuite, memcmp(buf, Encoding5_DataMacro, encodedLen) == 0);
}
static CHIP_ERROR NullIterateHandler(const TLVReader & aReader, size_t aDepth, void * aContext)
{
(void) aReader;
(void) aDepth;
(void) aContext;
return CHIP_NO_ERROR;
}
static CHIP_ERROR FindContainerWithElement(const TLVReader & aReader, size_t aDepth, void * aContext)
{
TLVReader reader;
TLVReader result;
Tag * tag = static_cast<Tag *>(aContext);
CHIP_ERROR err = CHIP_NO_ERROR;
TLVType containerType;
reader.Init(aReader);
if (TLVTypeIsContainer(reader.GetType()))
{
ReturnErrorOnFailure(reader.EnterContainer(containerType));
err = chip::TLV::Utilities::Find(reader, *tag, result, false);
// Map a successful find (CHIP_NO_ERROR) onto a signal that the element has been found.
if (err == CHIP_NO_ERROR)
{
err = CHIP_ERROR_SENTINEL;
}
// Map a failed find attempt to NO_ERROR
else if (err == CHIP_ERROR_TLV_TAG_NOT_FOUND)
{
err = CHIP_NO_ERROR;
}
}
return err;
}
/**
* Test CHIP TLV Utilities
*/
void CheckCHIPTLVUtilities(nlTestSuite * inSuite, void * inContext)
{
uint8_t buf[2048];
TLVWriter writer;
TLVReader reader, reader1;
CHIP_ERROR err = CHIP_NO_ERROR;
writer.Init(buf);
writer.ImplicitProfileId = TestProfile_2;
WriteEncoding1(inSuite, writer);
uint32_t encodedLen = writer.GetLengthWritten();
NL_TEST_ASSERT(inSuite, encodedLen == sizeof(Encoding1));
NL_TEST_ASSERT(inSuite, memcmp(buf, Encoding1, encodedLen) == 0);
reader.Init(buf, encodedLen);
reader.ImplicitProfileId = TestProfile_2;
reader1.Init(reader);
err = reader1.Next();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Find a tag
TLVReader tagReader;
err = chip::TLV::Utilities::Find(reader, ProfileTag(TestProfile_2, 65536), tagReader);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Find with reader positioned "on" the element of interest
err = chip::TLV::Utilities::Find(reader1, ProfileTag(TestProfile_1, 1), tagReader);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Find a tag that's not present
err = chip::TLV::Utilities::Find(reader, ProfileTag(TestProfile_2, 1024), tagReader);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_TLV_TAG_NOT_FOUND);
// Find with a predicate
{
uint8_t buf1[74];
writer.Init(buf1);
writer.ImplicitProfileId = TestProfile_2;
WriteEncoding2(inSuite, writer);
// Initialize a reader
reader1.Init(buf1, writer.GetLengthWritten());
reader1.ImplicitProfileId = TestProfile_2;
// position the reader on the first element
reader1.Next();
Tag tag = ProfileTag(TestProfile_1, 1);
err = chip::TLV::Utilities::Find(reader1, FindContainerWithElement, &tag, tagReader, false);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_TLV_TAG_NOT_FOUND);
tag = ProfileTag(TestProfile_2, 2);
err = chip::TLV::Utilities::Find(reader1, FindContainerWithElement, &tag, tagReader, false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, tagReader.GetType() == kTLVType_Structure);
NL_TEST_ASSERT(inSuite, tagReader.GetTag() == ProfileTag(TestProfile_1, 1));
// Position the reader on the second element
reader1.Next();
err = chip::TLV::Utilities::Find(reader1, FindContainerWithElement, &tag, tagReader, false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, tagReader.GetType() == kTLVType_Structure);
NL_TEST_ASSERT(inSuite, tagReader.GetTag() == ProfileTag(TestProfile_2, 1));
}
// Count
size_t count;
const size_t expectedCount = 18;
reader1.Init(reader);
reader1.Next();
err = chip::TLV::Utilities::Count(reader, count);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, count == expectedCount);
// Count with reader already positioned "on" the first element in the encoding
err = chip::TLV::Utilities::Count(reader1, count);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, count == expectedCount);
// Iterate
err = chip::TLV::Utilities::Iterate(reader, NullIterateHandler, nullptr);
NL_TEST_ASSERT(inSuite, err == CHIP_END_OF_TLV);
}
/**
* Test CHIP TLV Empty Find
*/
void CheckCHIPTLVEmptyFind(nlTestSuite * inSuite, void * inContext)
{
uint8_t buf[30];
TLVWriter writer;
TLVReader reader;
CHIP_ERROR err = CHIP_NO_ERROR;
writer.Init(buf);
writer.ImplicitProfileId = TestProfile_2;
WriteEmptyEncoding(inSuite, writer);
uint32_t encodedLen = writer.GetLengthWritten();
reader.Init(buf, encodedLen);
reader.ImplicitProfileId = TestProfile_2;
// Find the empty container
TLVReader tagReader;
err = chip::TLV::Utilities::Find(reader, ProfileTag(TestProfile_1, 256), tagReader);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
// clang-format off
uint8_t Encoding2[] =
{
// Container 1
0xD5, 0xBB, 0xAA, 0xDD, 0xCC, 0x01, 0x00,
0xC9, 0xBB, 0xAA, 0xDD, 0xCC, 0x02, 0x00,
0x88, 0x02, 0x00,
0x18,
// Container 2
0x95, 0x01, 0x00,
0x88, 0x02, 0x00,
0xC9, 0xBB, 0xAA, 0xDD, 0xCC, 0x02, 0x00,
0x18
};
uint8_t AppendedEncoding2[] =
{
// Container 1
0xD5, 0xBB, 0xAA, 0xDD, 0xCC, 0x01, 0x00,
0xC9, 0xBB, 0xAA, 0xDD, 0xCC, 0x02, 0x00,
0x88, 0x02, 0x00,
0xC8, 0xBB, 0xAA, 0xDD, 0xCC, 0x02, 0x00,
0x89, 0x02, 0x00,
0xD5, 0xBB, 0xAA, 0xDD, 0xCC, 0x01, 0x00,
0xC9, 0xBB, 0xAA, 0xDD, 0xCC, 0x02, 0x00,
0x88, 0x02, 0x00,
0x18,
0x95, 0x01, 0x00,
0x88, 0x02, 0x00,
0xC9, 0xBB, 0xAA, 0xDD, 0xCC, 0x02, 0x00,
0x18,
0x18,
// Container 2
0x95, 0x01, 0x00,
0x88, 0x02, 0x00,
0xC9, 0xBB, 0xAA, 0xDD, 0xCC, 0x02, 0x00,
0x18
};
// clang-format on
void WriteAppendReadTest0(nlTestSuite * inSuite)
{
uint8_t buf[74];
uint32_t updatedLen;
TLVWriter writer;
TLVReader reader;
writer.Init(buf);
writer.ImplicitProfileId = TestProfile_2;
WriteEncoding2(inSuite, writer);
uint32_t encodedLen = writer.GetLengthWritten();
#ifdef DUMP_ENCODING
printf("Initial encoding:\n");
for (uint32_t i = 0; i < encodedLen; i++)
{
if (i != 0 && i % 16 == 0)
printf("\n");
printf("0x%02X, ", buf[i]);
}
printf("\n");
#endif
NL_TEST_ASSERT(inSuite, encodedLen == sizeof(Encoding2));
NL_TEST_ASSERT(inSuite, memcmp(buf, Encoding2, encodedLen) == 0);
// Append new data into encoding
AppendEncoding2(inSuite, buf, encodedLen, sizeof(buf), updatedLen);
#ifdef DUMP_ENCODING
printf("Updated encoding:\n");
for (uint32_t i = 0; i < updatedLen; i++)
{
if (i != 0 && i % 16 == 0)
printf("\n");
printf("0x%02X, ", buf[i]);
}
printf("\n");
#endif
NL_TEST_ASSERT(inSuite, updatedLen == sizeof(AppendedEncoding2));
NL_TEST_ASSERT(inSuite, memcmp(buf, AppendedEncoding2, updatedLen) == 0);
reader.Init(buf, updatedLen);
reader.ImplicitProfileId = TestProfile_2;
ReadAppendedEncoding2(inSuite, reader);
}
void WriteFindAppendReadTest(nlTestSuite * inSuite, bool findContainer)
{
uint8_t buf[74];
uint32_t updatedLen;
TLVWriter writer;
TLVReader reader;
writer.Init(buf);
writer.ImplicitProfileId = TestProfile_2;
WriteEncoding2(inSuite, writer);
uint32_t encodedLen = writer.GetLengthWritten();
#ifdef DUMP_ENCODING
printf("Initial encoding:\n");
for (uint32_t i = 0; i < encodedLen; i++)
{
if (i != 0 && i % 16 == 0)
printf("\n");
printf("0x%02X, ", buf[i]);
}
printf("\n");
#endif
NL_TEST_ASSERT(inSuite, encodedLen == sizeof(Encoding2));
NL_TEST_ASSERT(inSuite, memcmp(buf, Encoding2, encodedLen) == 0);
// Append new data into encoding
FindAppendEncoding2(inSuite, buf, encodedLen, sizeof(buf), updatedLen, findContainer);
#ifdef DUMP_ENCODING
printf("Updated encoding:\n");
for (uint32_t i = 0; i < updatedLen; i++)
{
if (i != 0 && i % 16 == 0)
printf("\n");
printf("0x%02X, ", buf[i]);
}
printf("\n");
#endif
NL_TEST_ASSERT(inSuite, updatedLen == sizeof(AppendedEncoding2));
NL_TEST_ASSERT(inSuite, memcmp(buf, AppendedEncoding2, updatedLen) == 0);
reader.Init(buf, updatedLen);
reader.ImplicitProfileId = TestProfile_2;
ReadAppendedEncoding2(inSuite, reader);
}
// clang-format off
uint8_t Encoding3[] =
{
// Container 1
0xD5, 0xBB, 0xAA, 0xDD, 0xCC, 0x01, 0x00,
0x88, 0x02, 0x00,
0x18,
};
uint8_t AppendedEncoding3[] =
{
// Container 1
0xD5, 0xBB, 0xAA, 0xDD, 0xCC, 0x01, 0x00,
0x88, 0x02, 0x00,
0x89, 0x02, 0x00,
0x18
};
// clang-format on
void WriteAppendReadTest1(nlTestSuite * inSuite)
{
uint8_t buf[14];
uint32_t updatedLen;
TLVWriter writer;
TLVReader reader;
writer.Init(buf);
writer.ImplicitProfileId = TestProfile_2;
WriteEncoding3(inSuite, writer);
uint32_t encodedLen = writer.GetLengthWritten();
#ifdef DUMP_ENCODING
printf("Initial encoding:\n");
for (uint32_t i = 0; i < encodedLen; i++)
{
if (i != 0 && i % 16 == 0)
printf("\n");
printf("0x%02X, ", buf[i]);
}
printf("\n");
#endif
NL_TEST_ASSERT(inSuite, encodedLen == sizeof(Encoding3));
NL_TEST_ASSERT(inSuite, memcmp(buf, Encoding3, encodedLen) == 0);
// Append new data into encoding
AppendEncoding3(inSuite, buf, encodedLen, sizeof(buf), updatedLen);
#ifdef DUMP_ENCODING
printf("Updated encoding:\n");
for (uint32_t i = 0; i < updatedLen; i++)
{
if (i != 0 && i % 16 == 0)
printf("\n");
printf("0x%02X, ", buf[i]);
}
printf("\n");
#endif
NL_TEST_ASSERT(inSuite, updatedLen == sizeof(AppendedEncoding3));
NL_TEST_ASSERT(inSuite, memcmp(buf, AppendedEncoding3, updatedLen) == 0);
reader.Init(buf, updatedLen);
reader.ImplicitProfileId = TestProfile_2;
ReadAppendedEncoding3(inSuite, reader);
}
// clang-format off
uint8_t AppendedEncoding4[] =
{
// Container 1
0xD5, 0xBB, 0xAA, 0xDD, 0xCC, 0x01, 0x00,
0x88, 0x02, 0x00,
0x18,
};
// clang-format on
void AppendReadTest(nlTestSuite * inSuite)
{
uint8_t buf[11];
uint32_t updatedLen;
memset(buf, 0, sizeof(buf));
#ifdef DUMP_ENCODING
printf("Initial encoding:\n");
for (uint32_t i = 0; i < sizeof(buf); i++)
{
if (i != 0 && i % 16 == 0)
printf("\n");
printf("0x%02X, ", buf[i]);
}
printf("\n");
#endif
// Append new data to encoding
AppendEncoding4(inSuite, buf, 0, sizeof(buf), updatedLen);
#ifdef DUMP_ENCODING
printf("Updated encoding:\n");
for (uint32_t i = 0; i < updatedLen; i++)
{
if (i != 0 && i % 16 == 0)
printf("\n");
printf("0x%02X, ", buf[i]);
}
printf("\n");
#endif
NL_TEST_ASSERT(inSuite, updatedLen == sizeof(AppendedEncoding4));
NL_TEST_ASSERT(inSuite, memcmp(buf, AppendedEncoding4, updatedLen) == 0);
TLVReader reader;
reader.Init(buf, updatedLen);
reader.ImplicitProfileId = TestProfile_2;
ReadAppendedEncoding4(inSuite, reader);
}
// clang-format off
uint8_t Encoding5[] =
{
// Container 1
0xD5, 0xBB, 0xAA, 0xDD, 0xCC, 0x01, 0x00,
0xC9, 0xBB, 0xAA, 0xDD, 0xCC, 0x02, 0x00,
0x88, 0x02, 0x00,
0xC8, 0xBB, 0xAA, 0xDD, 0xCC, 0x02, 0x00,
0x89, 0x02, 0x00,
0xD5, 0xBB, 0xAA, 0xDD, 0xCC, 0x01, 0x00,
0xC9, 0xBB, 0xAA, 0xDD, 0xCC, 0x02, 0x00,
0x88, 0x02, 0x00,
0x18,
0x95, 0x01, 0x00,
0x88, 0x02, 0x00,
0xC9, 0xBB, 0xAA, 0xDD, 0xCC, 0x02, 0x00,
0x18,
0x18,
// Container 2
0x95, 0x01, 0x00,
0x88, 0x02, 0x00,
0xC9, 0xBB, 0xAA, 0xDD, 0xCC, 0x02, 0x00,
0x18
};
uint8_t DeletedEncoding5[] =
{
// Container 1
0xD5, 0xBB, 0xAA, 0xDD, 0xCC, 0x01, 0x00,
0xC9, 0xBB, 0xAA, 0xDD, 0xCC, 0x02, 0x00,
0x88, 0x02, 0x00,
0x18,
// Container 2
0x95, 0x01, 0x00,
0x88, 0x02, 0x00,
0xC9, 0xBB, 0xAA, 0xDD, 0xCC, 0x02, 0x00,
0x18
};
// clang-format on
void WriteDeleteReadTest(nlTestSuite * inSuite)
{
uint8_t buf[74];
uint32_t updatedLen;
TLVWriter writer;
TLVReader reader;
writer.Init(buf);
writer.ImplicitProfileId = TestProfile_2;
WriteEncoding5(inSuite, writer);
uint32_t encodedLen = writer.GetLengthWritten();
#ifdef DUMP_ENCODING
for (uint32_t i = 0; i < encodedLen; i++)
{
if (i != 0 && i % 16 == 0)
printf("\n");
printf("0x%02X, ", buf[i]);
}
printf("\n");
#endif
NL_TEST_ASSERT(inSuite, encodedLen == sizeof(Encoding5));
NL_TEST_ASSERT(inSuite, memcmp(buf, Encoding5, encodedLen) == 0);
// Delete some elements from the encoding
DeleteEncoding5(inSuite, buf, encodedLen, sizeof(buf), updatedLen);
NL_TEST_ASSERT(inSuite, updatedLen == sizeof(DeletedEncoding5));
NL_TEST_ASSERT(inSuite, memcmp(buf, DeletedEncoding5, updatedLen) == 0);
reader.Init(buf, updatedLen);
reader.ImplicitProfileId = TestProfile_2;
ReadDeletedEncoding5(inSuite, reader);
}
/**
* Test Packet Buffer
*/
void CheckPacketBuffer(nlTestSuite * inSuite, void * inContext)
{
System::PacketBufferHandle buf = System::PacketBufferHandle::New(sizeof(Encoding1), 0);
System::PacketBufferTLVWriter writer;
System::PacketBufferTLVReader reader;
writer.Init(buf.Retain());
writer.ImplicitProfileId = TestProfile_2;
WriteEncoding1(inSuite, writer);
TestBufferContents(inSuite, buf, Encoding1, sizeof(Encoding1));
reader.Init(buf.Retain());
reader.ImplicitProfileId = TestProfile_2;
ReadEncoding1(inSuite, reader);
reader.Init(buf.Retain());
reader.ImplicitProfileId = TestProfile_2;
ReadEncoding1(inSuite, reader);
}
CHIP_ERROR CountEvictedMembers(CHIPCircularTLVBuffer & inBuffer, void * inAppData, TLVReader & inReader)
{
TestTLVContext * context = static_cast<TestTLVContext *>(inAppData);
CHIP_ERROR err;
// "Process" the first element in the reader
err = inReader.Next();
NL_TEST_ASSERT(context->mSuite, err == CHIP_NO_ERROR);
err = inReader.Skip();
NL_TEST_ASSERT(context->mSuite, err == CHIP_NO_ERROR);
context->mEvictionCount++;
context->mEvictedBytes += inReader.GetLengthRead();
return CHIP_NO_ERROR;
}
void CheckCircularTLVBufferSimple(nlTestSuite * inSuite, void * inContext)
{
// Write 40 bytes as 4 separate events into a 30 byte buffer. On
// completion of the test, the buffer should contain 2 elements
// and 2 elements should have been evicted in the last call to
// WriteEncoding.
uint8_t backingStore[30];
CircularTLVWriter writer;
CircularTLVReader reader;
TestTLVContext * context = static_cast<TestTLVContext *>(inContext);
CHIPCircularTLVBuffer buffer(backingStore, 30);
writer.Init(buffer);
writer.ImplicitProfileId = TestProfile_2;
context->mEvictionCount = 0;
context->mEvictedBytes = 0;
buffer.mProcessEvictedElement = CountEvictedMembers;
buffer.mAppData = inContext;
writer.PutBoolean(ProfileTag(TestProfile_1, 2), true);
WriteEncoding3(inSuite, writer);
WriteEncoding3(inSuite, writer);
WriteEncoding3(inSuite, writer);
NL_TEST_ASSERT(inSuite, context->mEvictionCount == 2);
NL_TEST_ASSERT(inSuite, context->mEvictedBytes == 18);
NL_TEST_ASSERT(inSuite, buffer.DataLength() == 22);
NL_TEST_ASSERT(inSuite, (buffer.DataLength() + context->mEvictedBytes) == writer.GetLengthWritten());
// At this point the buffer should contain 2 instances of Encoding3.
reader.Init(buffer);
reader.ImplicitProfileId = TestProfile_2;
TestNext<TLVReader>(inSuite, reader);
ReadEncoding3(inSuite, reader);
TestNext<TLVReader>(inSuite, reader);
ReadEncoding3(inSuite, reader);
// Check that the reader is out of data
TestEnd<TLVReader>(inSuite, reader);
}
void CheckCircularTLVBufferStartMidway(nlTestSuite * inSuite, void * inContext)
{
// Write 40 bytes as 4 separate events into a 30 byte buffer. On
// completion of the test, the buffer should contain 2 elements
// and 2 elements should have been evicted in the last call to
// WriteEncoding.
uint8_t backingStore[30];
CircularTLVWriter writer;
CircularTLVReader reader;
TestTLVContext * context = static_cast<TestTLVContext *>(inContext);
CHIPCircularTLVBuffer buffer(backingStore, 30, &(backingStore[15]));
writer.Init(buffer);
writer.ImplicitProfileId = TestProfile_2;
context->mEvictionCount = 0;
context->mEvictedBytes = 0;
buffer.mProcessEvictedElement = CountEvictedMembers;
buffer.mAppData = inContext;
writer.PutBoolean(ProfileTag(TestProfile_1, 2), true);
WriteEncoding3(inSuite, writer);
WriteEncoding3(inSuite, writer);
WriteEncoding3(inSuite, writer);
NL_TEST_ASSERT(inSuite, context->mEvictionCount == 2);
NL_TEST_ASSERT(inSuite, context->mEvictedBytes == 18);
NL_TEST_ASSERT(inSuite, buffer.DataLength() == 22);
NL_TEST_ASSERT(inSuite, (buffer.DataLength() + context->mEvictedBytes) == writer.GetLengthWritten());
// At this point the buffer should contain 2 instances of Encoding3.
reader.Init(buffer);
reader.ImplicitProfileId = TestProfile_2;
TestNext<TLVReader>(inSuite, reader);
ReadEncoding3(inSuite, reader);
TestNext<TLVReader>(inSuite, reader);
ReadEncoding3(inSuite, reader);
// Check that the reader is out of data
TestEnd<TLVReader>(inSuite, reader);
}
void CheckCircularTLVBufferEvictStraddlingEvent(nlTestSuite * inSuite, void * inContext)
{
// Write 95 bytes to the buffer as 9 different TLV elements: 1
// 7-byte element and 8 11-byte elements.
// On completion of the test, the buffer should contain 2 elements
// and 7 elements should have been evicted in the last call to
// WriteEncoding.
TestTLVContext * context = static_cast<TestTLVContext *>(inContext);
uint8_t backingStore[30];
CircularTLVWriter writer;
CircularTLVReader reader;
CHIPCircularTLVBuffer buffer(backingStore, 30);
writer.Init(buffer);
writer.ImplicitProfileId = TestProfile_2;
context->mEvictionCount = 0;
context->mEvictedBytes = 0;
buffer.mProcessEvictedElement = CountEvictedMembers;
buffer.mAppData = inContext;
writer.PutBoolean(ProfileTag(TestProfile_1, 2), true);
WriteEncoding3(inSuite, writer);
WriteEncoding3(inSuite, writer);
WriteEncoding3(inSuite, writer);
WriteEncoding3(inSuite, writer);
// the write below will evict an element that straddles the buffer boundary.
WriteEncoding3(inSuite, writer);
WriteEncoding3(inSuite, writer);
WriteEncoding3(inSuite, writer);
WriteEncoding3(inSuite, writer);
NL_TEST_ASSERT(inSuite,
writer.GetLengthWritten() ==
(8 * 11 + 7)); // 8 writes of Encoding3 (11 bytes each) and 7 bytes for the initial boolean.
NL_TEST_ASSERT(inSuite, buffer.DataLength() == 22);
NL_TEST_ASSERT(inSuite, (buffer.DataLength() + context->mEvictedBytes) == writer.GetLengthWritten());
NL_TEST_ASSERT(inSuite, context->mEvictionCount == 7);
// At this point the buffer should contain 2 instances of Encoding3.
reader.Init(buffer);
reader.ImplicitProfileId = TestProfile_2;
TestNext<TLVReader>(inSuite, reader);
ReadEncoding3(inSuite, reader);
TestNext<TLVReader>(inSuite, reader);
ReadEncoding3(inSuite, reader);
// Check that the reader is out of data
TestEnd<TLVReader>(inSuite, reader);
}
void CheckCircularTLVBufferEdge(nlTestSuite * inSuite, void * inContext)
{
TestTLVContext * context = static_cast<TestTLVContext *>(inContext);
CHIP_ERROR err;
uint8_t backingStore[7];
uint8_t backingStore1[14];
CircularTLVWriter writer;
CircularTLVReader reader;
TLVWriter writer1;
CHIPCircularTLVBuffer buffer(backingStore, sizeof(backingStore));
CHIPCircularTLVBuffer buffer1(backingStore1, sizeof(backingStore1));
writer.Init(buffer);
writer.ImplicitProfileId = TestProfile_2;
context->mEvictionCount = 0;
context->mEvictedBytes = 0;
buffer.mProcessEvictedElement = CountEvictedMembers;
buffer.mAppData = inContext;
// Test eviction for an element that fits in the underlying buffer exactly
err = writer.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.PutBoolean(ProfileTag(TestProfile_1, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// At this point the buffer should contain only the boolean we just wrote
reader.Init(buffer);
reader.ImplicitProfileId = TestProfile_2;
TestNext<TLVReader>(inSuite, reader);
TEST_GET_NOERROR(inSuite, reader, kTLVType_Boolean, ProfileTag(TestProfile_1, 2), false);
// Check that the reader is out of data
TestEnd<TLVReader>(inSuite, reader);
// verify that an element larger than the underlying buffer fails out.
err = writer.OpenContainer(ProfileTag(TestProfile_1, 1), kTLVType_Structure, writer1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer1.PutBoolean(ProfileTag(TestProfile_2, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_END_OF_TLV);
// Verify reader correctness
// Write an element that takes half of the buffer, and evict it.
// Do it 2 times, so we test what happens when the head is at the
// middle and at the end of the buffer but the buffer is empty.
int i = 0;
for (i = 0; i < 2; i++)
{
writer.Init(buffer1);
writer.ImplicitProfileId = TestProfile_2;
err = writer.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
reader.Init(buffer1);
reader.ImplicitProfileId = TestProfile_2;
TestNext<TLVReader>(inSuite, reader);
TEST_GET_NOERROR(inSuite, reader, kTLVType_Boolean, ProfileTag(TestProfile_1, 2), true);
TestEnd<TLVReader>(inSuite, reader);
buffer1.EvictHead();
reader.Init(buffer1);
reader.ImplicitProfileId = TestProfile_2;
TestEnd<TLVReader>(inSuite, reader);
}
writer.Init(buffer1);
writer.ImplicitProfileId = TestProfile_2;
context->mEvictionCount = 0;
context->mEvictedBytes = 0;
buffer1.mProcessEvictedElement = CountEvictedMembers;
buffer1.mAppData = inContext;
// Two elements fit in the buffer exactly
err = writer.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.PutBoolean(ProfileTag(TestProfile_1, 2), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
// Verify that we can read out two elements from the buffer
reader.Init(buffer1);
reader.ImplicitProfileId = TestProfile_2;
TestNext<TLVReader>(inSuite, reader);
TEST_GET_NOERROR(inSuite, reader, kTLVType_Boolean, ProfileTag(TestProfile_1, 2), true);
TestNext<TLVReader>(inSuite, reader);
TEST_GET_NOERROR(inSuite, reader, kTLVType_Boolean, ProfileTag(TestProfile_1, 2), false);
TestEnd<TLVReader>(inSuite, reader);
// Check that the eviction works as expected
buffer1.EvictHead();
// At this point the buffer should contain only the second boolean
reader.Init(buffer1);
reader.ImplicitProfileId = TestProfile_2;
TestNext<TLVReader>(inSuite, reader);
TEST_GET_NOERROR(inSuite, reader, kTLVType_Boolean, ProfileTag(TestProfile_1, 2), false);
// Check that the reader is out of data
TestEnd<TLVReader>(inSuite, reader);
// Write another boolean, verify that the buffer is full and contains two booleans
writer.Init(buffer1);
writer.ImplicitProfileId = TestProfile_2;
err = writer.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Verify that we can read out two elements from the buffer
reader.Init(buffer1);
reader.ImplicitProfileId = TestProfile_2;
TestNext<TLVReader>(inSuite, reader);
TEST_GET_NOERROR(inSuite, reader, kTLVType_Boolean, ProfileTag(TestProfile_1, 2), false);
TestNext<TLVReader>(inSuite, reader);
TEST_GET_NOERROR(inSuite, reader, kTLVType_Boolean, ProfileTag(TestProfile_1, 2), true);
TestEnd<TLVReader>(inSuite, reader);
// Evict the elements from the buffer, verfiy that we have an
// empty reader on our hands
buffer1.EvictHead();
buffer1.EvictHead();
reader.Init(buffer1);
reader.ImplicitProfileId = TestProfile_2;
TestEnd<TLVReader>(inSuite, reader);
}
void CheckCHIPTLVPutStringF(nlTestSuite * inSuite, void * inContext)
{
const size_t bufsize = 24;
char strBuffer[bufsize];
char valStr[bufsize];
uint8_t backingStore[bufsize];
TLVWriter writer;
TLVReader reader;
size_t num = 1;
CHIP_ERROR err = CHIP_NO_ERROR;
writer.Init(backingStore, bufsize);
snprintf(strBuffer, sizeof(strBuffer), "Sample string %u", static_cast<unsigned int>(num));
err = writer.PutStringF(ProfileTag(TestProfile_1, 1), "Sample string %u", static_cast<unsigned int>(num));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
reader.Init(backingStore, writer.GetLengthWritten());
err = reader.Next();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = reader.GetString(valStr, bufsize);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, strncmp(valStr, strBuffer, bufsize) == 0);
}
void CheckCHIPTLVPutStringSpan(nlTestSuite * inSuite, void * inContext)
{
const size_t bufsize = 24;
char strBuffer[bufsize] = "Sample string";
char valStr[bufsize];
uint8_t backingStore[bufsize];
TLVWriter writer;
TLVReader reader;
CHIP_ERROR err = CHIP_NO_ERROR;
Span<char> strSpan;
//
// Write a string that has a size that exceeds 32-bits. This is only possible
// on platforms where size_t is bigger than uint32_t.
//
if (sizeof(size_t) > sizeof(uint32_t))
{
writer.Init(backingStore, bufsize);
snprintf(strBuffer, sizeof(strBuffer), "Sample string");
strSpan = { strBuffer, static_cast<size_t>(0xffffffffff) };
err = writer.PutString(ProfileTag(TestProfile_1, 1), strSpan);
NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
}
{
writer.Init(backingStore, bufsize);
snprintf(strBuffer, sizeof(strBuffer), "Sample string");
strSpan = { strBuffer, strlen("Sample string") };
err = writer.PutString(ProfileTag(TestProfile_1, 1), strSpan);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
reader.Init(backingStore, writer.GetLengthWritten());
err = reader.Next();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = reader.GetString(valStr, bufsize);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, strncmp(valStr, strBuffer, bufsize) == 0);
}
}
void CheckCHIPTLVPutStringFCircular(nlTestSuite * inSuite, void * inContext)
{
const size_t bufsize = 40;
char strBuffer[bufsize];
char valStr[bufsize];
uint8_t backingStore[bufsize];
CircularTLVWriter writer;
CircularTLVReader reader;
CHIPCircularTLVBuffer buffer(backingStore, bufsize);
size_t num = 1;
CHIP_ERROR err = CHIP_NO_ERROR;
// Initial test: Verify that a straight printf works as expected into continuous buffer.
writer.Init(buffer);
snprintf(strBuffer, sizeof(strBuffer), "Sample string %u", static_cast<unsigned int>(num));
err = writer.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.PutStringF(ProfileTag(TestProfile_1, 1), "Sample string %u", static_cast<unsigned int>(num));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
reader.Init(buffer);
// Skip over the initial element
err = reader.Next();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = reader.Next();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = reader.GetString(valStr, bufsize);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, strncmp(valStr, strBuffer, bufsize) == 0);
// Verify that the PutStringF will handle correctly the case with the discontinuous buffer
// This print will both stradle the boundary of the buffer and displace the previous two elements.
num = 2;
snprintf(strBuffer, sizeof(strBuffer), "Sample string %u", static_cast<unsigned int>(num));
err = writer.PutStringF(ProfileTag(TestProfile_1, 1), "Sample string %u", static_cast<unsigned int>(num));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
reader.Init(buffer);
err = reader.Next();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = reader.GetString(valStr, bufsize);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, strncmp(valStr, strBuffer, bufsize) == 0);
}
void CheckCHIPTLVByteSpan(nlTestSuite * inSuite, void * inContext)
{
const size_t bufSize = 14;
uint8_t bytesBuffer[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
uint8_t backingStore[bufSize];
TLVWriter writer;
TLVReader reader;
CHIP_ERROR err = CHIP_NO_ERROR;
writer.Init(backingStore);
ByteSpan writerSpan(bytesBuffer);
err = writer.Put(ProfileTag(TestProfile_1, 1), writerSpan);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
reader.Init(backingStore, writer.GetLengthWritten());
err = reader.Next();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
chip::ByteSpan readerSpan;
err = reader.Get(readerSpan);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, memcmp(readerSpan.data(), bytesBuffer, sizeof(bytesBuffer)) == 0);
}
void CheckCHIPTLVSkipCircular(nlTestSuite * inSuite, void * inContext)
{
const size_t bufsize = 40; // large enough s.t. 2 elements fit, 3rd causes eviction
uint8_t backingStore[bufsize];
char testString[] = "Sample string"; // 13 characters, without the trailing NULL, add 3 bytes for anon tag
// Any pair of reader and writer would work here, either PacketBuffer based or CircularTLV based.
CircularTLVWriter writer;
CircularTLVReader reader;
CHIPCircularTLVBuffer buffer(backingStore, bufsize);
CHIP_ERROR err = CHIP_NO_ERROR;
writer.Init(buffer);
err = writer.PutString(AnonymousTag(), testString);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.PutString(AnonymousTag(), testString);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.PutString(AnonymousTag(), testString); // This event straddles the boundary
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.PutString(AnonymousTag(), testString); // This one does not.
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
reader.Init(buffer);
err = reader.Next(); // position the reader at the straddling element
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = reader.Skip(); // // Test that the buf ptr is handled correctly within the ReadData() function.
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
/**
* Test Buffer Overflow
*/
void CheckBufferOverflow(nlTestSuite * inSuite, void * inContext)
{
System::PacketBufferTLVReader reader;
System::PacketBufferHandle buf = System::PacketBufferHandle::New(sizeof(Encoding1), 0);
uint16_t maxDataLen = buf->MaxDataLength();
uint16_t reserve = static_cast<uint16_t>((sizeof(Encoding1) < maxDataLen) ? (maxDataLen - sizeof(Encoding1)) + 2 : 0);
// Repeatedly write and read a TLV encoding to a chain of PacketBuffers. Use progressively larger
// and larger amounts of space in the first buffer to force the encoding to overlap the
// end of the buffer and the beginning of the next.
for (; reserve < maxDataLen; reserve++)
{
buf->SetStart(buf->Start() + reserve);
{
System::PacketBufferTLVWriter writer;
// Scope for writer because we want it to go out of scope before we
// mess with the chain after writing is done.
writer.Init(buf.Retain(), /* useChainedBuffers = */ true);
writer.ImplicitProfileId = TestProfile_2;
WriteEncoding1(inSuite, writer);
}
TestBufferContents(inSuite, buf, Encoding1, sizeof(Encoding1));
// Compact the buffer, since we don't allow reading from chained
// buffers.
buf->CompactHead();
reader.Init(buf.Retain());
reader.ImplicitProfileId = TestProfile_2;
ReadEncoding1(inSuite, reader);
buf = System::PacketBufferHandle::New(sizeof(Encoding1), 0);
}
}
/**
* Test case to verify the correctness of TLVReader::GetTag()
*
* TLVReader::GetTag() does not return the correct tag value when the
* the compiler optimization level contains strict aliasing. In the below
* example, the returned tag value would be 0xe, instead of 0xe00000001.
*
* The issue has been spotted on debug builds.
*
*/
// clang-format off
static const uint8_t sIdentifyResponseBuf[] =
{
0xD5, 0x00, 0x00, 0x0E, 0x00, 0x01, 0x00, 0x25,
0x00, 0x5A, 0x23, 0x24, 0x01, 0x07, 0x24, 0x02,
0x05, 0x25, 0x03, 0x22, 0x1E, 0x2C, 0x04, 0x10,
0x30, 0x34, 0x41, 0x41, 0x30, 0x31, 0x41, 0x43,
0x32, 0x33, 0x31, 0x34, 0x30, 0x30, 0x4C, 0x50,
0x2C, 0x09, 0x06, 0x31, 0x2E, 0x34, 0x72, 0x63,
0x35, 0x24, 0x0C, 0x01, 0x18,
};
// clang-format on
static const uint32_t kIdentifyResponseLen = 53;
void CheckStrictAliasing(nlTestSuite * inSuite, void * inContext)
{
const uint32_t kProfile_Id = 0x0000000e;
CHIP_ERROR err = CHIP_NO_ERROR;
TLVReader reader;
reader.Init(sIdentifyResponseBuf, kIdentifyResponseLen);
reader.ImplicitProfileId = kProfile_Id;
err = reader.Next();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, reader.GetTag() == ProfileTag(kProfile_Id, 1));
}
/**
* Test CHIP TLV Writer Copy Container
*/
void TestCHIPTLVWriterCopyContainer(nlTestSuite * inSuite)
{
uint8_t buf[2048];
{
TLVWriter writer;
TLVReader reader;
reader.Init(Encoding1);
reader.ImplicitProfileId = TestProfile_2;
TestNext<TLVReader>(inSuite, reader);
writer.Init(buf);
writer.ImplicitProfileId = TestProfile_2;
CHIP_ERROR err = writer.CopyContainer(reader);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
uint32_t encodedLen = writer.GetLengthWritten();
NL_TEST_ASSERT(inSuite, encodedLen == sizeof(Encoding1));
int memcmpRes = memcmp(buf, Encoding1, encodedLen);
NL_TEST_ASSERT(inSuite, memcmpRes == 0);
}
{
TLVWriter writer;
writer.Init(buf);
writer.ImplicitProfileId = TestProfile_2;
CHIP_ERROR err = writer.CopyContainer(ProfileTag(TestProfile_1, 1), Encoding1, sizeof(Encoding1));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
uint32_t encodedLen = writer.GetLengthWritten();
NL_TEST_ASSERT(inSuite, encodedLen == sizeof(Encoding1));
int memcmpRes = memcmp(buf, Encoding1, encodedLen);
NL_TEST_ASSERT(inSuite, memcmpRes == 0);
}
}
/**
* Test CHIP TLV Writer Copy Element
*/
void TestCHIPTLVWriterCopyElement(nlTestSuite * inSuite)
{
CHIP_ERROR err;
uint8_t expectedBuf[2048], testBuf[2048];
uint32_t expectedLen, testLen;
TLVWriter writer;
TLVType outerContainerType;
enum
{
kRepeatCount = 3
};
writer.Init(expectedBuf);
writer.ImplicitProfileId = TestProfile_2;
err = writer.StartContainer(AnonymousTag(), kTLVType_Structure, outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
for (int i = 0; i < kRepeatCount; i++)
{
WriteEncoding1(inSuite, writer);
}
err = writer.EndContainer(outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
expectedLen = writer.GetLengthWritten();
writer.Init(testBuf);
writer.ImplicitProfileId = TestProfile_2;
err = writer.StartContainer(AnonymousTag(), kTLVType_Structure, outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
for (int i = 0; i < kRepeatCount; i++)
{
TLVReader reader;
reader.Init(Encoding1);
reader.ImplicitProfileId = TestProfile_2;
TestNext<TLVReader>(inSuite, reader);
err = writer.CopyElement(reader);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
err = writer.EndContainer(outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
testLen = writer.GetLengthWritten();
NL_TEST_ASSERT(inSuite, testLen == expectedLen);
int memcmpRes = memcmp(testBuf, expectedBuf, testLen);
NL_TEST_ASSERT(inSuite, memcmpRes == 0);
}
void PreserveSizeWrite(nlTestSuite * inSuite, TLVWriter & writer, bool preserveSize)
{
CHIP_ERROR err;
TLVWriter writer2;
// TLVTagControl::FullyQualified_8Bytes
err = writer.Put(ProfileTag(TestProfile_1, 4000000000ULL), static_cast<int64_t>(40000000000ULL), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Put(ProfileTag(TestProfile_1, 4000000000ULL), static_cast<int16_t>(12345), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Put(ProfileTag(TestProfile_1, 4000000000ULL), static_cast<float>(1.0));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.OpenContainer(ProfileTag(TestProfile_1, 1), kTLVType_Structure, writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
{
TLVWriter writer3;
err = writer2.OpenContainer(ContextTag(0), kTLVType_Array, writer3);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer3.Put(AnonymousTag(), static_cast<uint8_t>(42), preserveSize);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer3.Put(AnonymousTag(), static_cast<uint16_t>(42), preserveSize);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer3.Put(AnonymousTag(), static_cast<uint32_t>(42), preserveSize);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer3.Put(AnonymousTag(), static_cast<uint64_t>(40000000000ULL), preserveSize);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer3.Put(AnonymousTag(), static_cast<int8_t>(-17), preserveSize);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer3.Put(AnonymousTag(), static_cast<int16_t>(-17), preserveSize);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer3.Put(AnonymousTag(), static_cast<int32_t>(-170000), preserveSize);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer3.Put(AnonymousTag(), static_cast<int64_t>(-170000), preserveSize);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// the below cases are for full coverage of PUTs
err = writer3.Put(AnonymousTag(), static_cast<uint64_t>(65535), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer3.Put(AnonymousTag(), static_cast<int64_t>(32767), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer3.Put(AnonymousTag(), static_cast<int64_t>(40000000000ULL), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.CloseContainer(writer3);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
err = writer.CloseContainer(writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
/**
* Test CHIP TLV Writer with Preserve Size
*/
void TestCHIPTLVWriterPreserveSize(nlTestSuite * inSuite)
{
uint8_t buf[2048];
TLVWriter writer;
writer.Init(buf);
writer.ImplicitProfileId = TestProfile_2;
PreserveSizeWrite(inSuite, writer, true);
uint32_t encodedLen = writer.GetLengthWritten();
NL_TEST_ASSERT(inSuite, encodedLen == 105);
}
/**
* Test error handling of CHIP TLV Writer
*/
void TestCHIPTLVWriterErrorHandling(nlTestSuite * inSuite)
{
CHIP_ERROR err;
uint8_t buf[2048];
TLVWriter writer, writer2, writer3;
writer.Init(buf);
writer.ImplicitProfileId = TestProfile_2;
// OpenContainer() for non-container
err = writer.OpenContainer(ProfileTag(TestProfile_1, 1), kTLVType_Boolean, writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_WRONG_TLV_TYPE);
// Since OpenContainer failed, writer2 remains uninitialized.
writer2.Init(nullptr, 0);
// CloseContainer() for non-container
err = writer.CloseContainer(writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
// OpenContainer() failure
err = writer.OpenContainer(ProfileTag(TestProfile_1, 1), kTLVType_Structure, writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.OpenContainer(ProfileTag(TestProfile_1, 1), kTLVType_Structure, writer3);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// CloseContainer() failure
err = writer.CloseContainer(writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_TLV_CONTAINER_OPEN);
// StartContainer()
TLVType outerContainerType;
err = writer.StartContainer(ProfileTag(TestProfile_2, 4000000000ULL), kTLVType_Boolean, outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_WRONG_TLV_TYPE);
// EndContainer()
outerContainerType = kTLVType_Boolean;
err = writer.EndContainer(outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
// PutPreEncodedContainer()
TLVReader reader;
reader.Init(buf, 2048);
err = writer.PutPreEncodedContainer(ProfileTag(TestProfile_2, 4000000000ULL), kTLVType_Boolean, reader.GetReadPoint(),
reader.GetRemainingLength());
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INVALID_ARGUMENT);
}
void TestCHIPTLVEmptyString(nlTestSuite * inSuite)
{
uint8_t buf[2];
TLVWriter writer;
CHIP_ERROR err;
ByteSpan s;
writer.Init(buf);
err = writer.PutString(AnonymousTag(), nullptr, 0);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
TLVReader reader;
reader.Init(buf);
err = reader.Next();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = reader.Get(s);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, s.data() == nullptr);
NL_TEST_ASSERT(inSuite, s.size() == 0);
}
/**
* Test CHIP TLV Writer
*/
void CheckCHIPTLVWriter(nlTestSuite * inSuite, void * inContext)
{
TestCHIPTLVWriterCopyContainer(inSuite);
TestCHIPTLVWriterCopyElement(inSuite);
TestCHIPTLVWriterPreserveSize(inSuite);
TestCHIPTLVWriterErrorHandling(inSuite);
TestCHIPTLVEmptyString(inSuite);
}
void SkipNonContainer(nlTestSuite * inSuite)
{
TLVReader reader;
const uint8_t * readpoint1 = nullptr;
const uint8_t * readpoint2 = nullptr;
reader.Init(Encoding1);
reader.ImplicitProfileId = TestProfile_2;
TestSkip(inSuite, reader);
readpoint1 = reader.GetReadPoint();
// Skip again, to check the operation is idempotent
TestSkip(inSuite, reader);
readpoint2 = reader.GetReadPoint();
NL_TEST_ASSERT(inSuite, readpoint1 == readpoint2);
}
void SkipContainer(nlTestSuite * inSuite)
{
TLVReader reader;
const uint8_t * readpoint1 = nullptr;
const uint8_t * readpoint2 = nullptr;
reader.Init(Encoding1);
reader.ImplicitProfileId = TestProfile_2;
TestNext<TLVReader>(inSuite, reader);
TestSkip(inSuite, reader);
readpoint1 = reader.GetReadPoint();
// Skip again, to check the operation is idempotent
TestSkip(inSuite, reader);
readpoint2 = reader.GetReadPoint();
NL_TEST_ASSERT(inSuite, readpoint1 == readpoint2);
}
void NextContainer(nlTestSuite * inSuite)
{
TLVReader reader;
reader.Init(Encoding1);
reader.ImplicitProfileId = TestProfile_2;
TestNext<TLVReader>(inSuite, reader);
CHIP_ERROR err = reader.Next();
NL_TEST_ASSERT(inSuite, err == CHIP_END_OF_TLV);
}
/**
* Test CHIP TLV Reader Skip functions
*/
void TestCHIPTLVReaderSkip(nlTestSuite * inSuite)
{
SkipNonContainer(inSuite);
SkipContainer(inSuite);
NextContainer(inSuite);
}
/**
* Test CHIP TLV Reader Dup functions
*/
void TestCHIPTLVReaderDup(nlTestSuite * inSuite)
{
TLVReader reader;
reader.Init(Encoding1);
reader.ImplicitProfileId = TestProfile_2;
TestNext<TLVReader>(inSuite, reader);
{
TLVReader reader2;
TestAndOpenContainer(inSuite, reader, kTLVType_Structure, ProfileTag(TestProfile_1, 1), reader2);
TestNext<TLVReader>(inSuite, reader2);
TEST_GET_NOERROR(inSuite, reader2, kTLVType_Boolean, ProfileTag(TestProfile_1, 2), true);
TestNext<TLVReader>(inSuite, reader2);
TEST_GET_NOERROR(inSuite, reader2, kTLVType_Boolean, ProfileTag(TestProfile_2, 2), false);
TestNext<TLVReader>(inSuite, reader2);
{
TLVReader reader3;
TestAndOpenContainer(inSuite, reader2, kTLVType_Array, ContextTag(0), reader3);
TestNext<TLVReader>(inSuite, reader3);
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int8_t>(42));
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int16_t>(42));
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int32_t>(42));
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int64_t>(42));
TEST_GET(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint32_t>(42),
CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<uint64_t>(42),
CHIP_ERROR_WRONG_TLV_TYPE);
TestNext<TLVReader>(inSuite, reader3);
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int8_t>(-17));
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int16_t>(-17));
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int32_t>(-17));
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int64_t>(-17));
TestNext<TLVReader>(inSuite, reader3);
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int32_t>(-170000));
TEST_GET_NOERROR(inSuite, reader3, kTLVType_SignedInteger, AnonymousTag(), static_cast<int64_t>(-170000));
TestNext<TLVReader>(inSuite, reader3);
TEST_GET(inSuite, reader3, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<int64_t>(40000000000ULL),
CHIP_ERROR_WRONG_TLV_TYPE);
TEST_GET_NOERROR(inSuite, reader3, kTLVType_UnsignedInteger, AnonymousTag(), static_cast<uint64_t>(40000000000ULL));
TestNext<TLVReader>(inSuite, reader3);
{
TLVReader reader4;
TestAndOpenContainer(inSuite, reader3, kTLVType_Structure, AnonymousTag(), reader4);
TestEndAndCloseContainer(inSuite, reader3, reader4);
}
TestNext<TLVReader>(inSuite, reader3);
{
TLVReader reader5;
TestAndOpenContainer(inSuite, reader3, kTLVType_List, AnonymousTag(), reader5);
TestNext<TLVReader>(inSuite, reader5);
TestNull(inSuite, reader5, ProfileTag(TestProfile_1, 17));
TestNext<TLVReader>(inSuite, reader5);
TestNull(inSuite, reader5, ProfileTag(TestProfile_2, 900000));
TestNext<TLVReader>(inSuite, reader5);
TestNull(inSuite, reader5, AnonymousTag());
TestNext<TLVReader>(inSuite, reader5);
{
TLVType outerContainerType;
TestAndEnterContainer<TLVReader>(inSuite, reader5, kTLVType_Structure, ProfileTag(TestProfile_2, 4000000000ULL),
outerContainerType);
TestNext<TLVReader>(inSuite, reader5);
TestDupString(inSuite, reader5, CommonTag(70000), sLargeString);
TestEndAndExitContainer<TLVReader>(inSuite, reader5, outerContainerType);
}
TestEndAndCloseContainer(inSuite, reader3, reader5);
}
TestEndAndCloseContainer(inSuite, reader2, reader3);
}
TestNext<TLVReader>(inSuite, reader2);
TestDupBytes(inSuite, reader2, ProfileTag(TestProfile_1, 5), reinterpret_cast<const uint8_t *>("This is a test"), 14);
TestNext<TLVReader>(inSuite, reader2);
TEST_GET_NOERROR(inSuite, reader2, kTLVType_FloatingPointNumber, ProfileTag(TestProfile_2, 65535), 17.9f);
TEST_GET_NOERROR(inSuite, reader2, kTLVType_FloatingPointNumber, ProfileTag(TestProfile_2, 65535),
static_cast<double>(17.9f));
TestNext<TLVReader>(inSuite, reader2);
TEST_GET_NOERROR(inSuite, reader2, kTLVType_FloatingPointNumber, ProfileTag(TestProfile_2, 65536), 17.9);
TestEndAndCloseContainer(inSuite, reader, reader2);
}
TestEnd<TLVReader>(inSuite, reader);
}
/**
* Test error handling of CHIP TLV Reader
*/
void TestCHIPTLVReaderErrorHandling(nlTestSuite * inSuite)
{
CHIP_ERROR err;
uint8_t buf[2048] = { 0 };
TLVReader reader;
reader.Init(buf);
reader.ImplicitProfileId = TestProfile_2;
// Get(bool&)
bool val;
err = reader.Get(val);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_WRONG_TLV_TYPE);
// Get(float&)
float numF;
err = reader.Get(numF);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_WRONG_TLV_TYPE);
// Get(double&)
double numD;
err = reader.Get(numD);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_WRONG_TLV_TYPE);
// Get(uint64_t&)
uint64_t num;
err = reader.Get(num);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_WRONG_TLV_TYPE);
// GetBytes()
uint8_t bBuf[16];
err = reader.GetBytes(bBuf, sizeof(bBuf));
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_WRONG_TLV_TYPE);
// GetString()
char sBuf[16];
err = reader.GetString(sBuf, sizeof(sBuf));
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_WRONG_TLV_TYPE);
// OpenContainer()
TLVReader reader2;
err = reader.OpenContainer(reader2);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
// CloseContainer()
err = reader.CloseContainer(reader2);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
// EnterContainer()
TLVType outerContainerType = kTLVType_Boolean;
err = reader.EnterContainer(outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
// DupString()
char * str = static_cast<char *>(chip::Platform::MemoryAlloc(16));
err = reader.DupString(str);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_WRONG_TLV_TYPE);
chip::Platform::MemoryFree(str);
// GetDataPtr()
const uint8_t * data = static_cast<uint8_t *>(chip::Platform::MemoryAlloc(16));
err = reader.GetDataPtr(data);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_WRONG_TLV_TYPE);
chip::Platform::MemoryFree(const_cast<uint8_t *>(data));
}
/**
* Test that CHIP TLV reader returns an error when a read is requested that
* would truncate the output.
*/
void TestCHIPTLVReaderTruncatedReads(nlTestSuite * inSuite)
{
uint8_t buf[2048];
TLVWriter writer;
TLVReader reader;
CHIP_ERROR err;
float outF;
// Setup: Write some values into the buffer
writer.Init(buf);
writer.ImplicitProfileId = TestProfile_2;
err = writer.Put(AnonymousTag(), double{ 12.5 });
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Test reading values from the buffer
reader.Init(buf);
TestNext<TLVReader>(inSuite, reader);
TEST_GET_NOERROR(inSuite, reader, kTLVType_FloatingPointNumber, AnonymousTag(), 12.5);
err = reader.Get(outF);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_WRONG_TLV_TYPE);
}
/**
* Test CHIP TLV Reader in a use case
*/
void TestCHIPTLVReaderInPractice(nlTestSuite * inSuite)
{
uint8_t buf[2048];
TLVWriter writer;
TLVReader reader;
writer.Init(buf);
writer.ImplicitProfileId = TestProfile_2;
PreserveSizeWrite(inSuite, writer, true);
reader.Init(buf);
TestNext<TLVReader>(inSuite, reader);
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, ProfileTag(TestProfile_1, 4000000000ULL),
static_cast<int64_t>(40000000000ULL));
TestNext<TLVReader>(inSuite, reader);
TEST_GET_NOERROR(inSuite, reader, kTLVType_SignedInteger, ProfileTag(TestProfile_1, 4000000000ULL),
static_cast<int64_t>(12345));
TestNext<TLVReader>(inSuite, reader);
TEST_GET_NOERROR(inSuite, reader, kTLVType_FloatingPointNumber, ProfileTag(TestProfile_1, 4000000000ULL),
static_cast<float>(1.0));
}
void TestCHIPTLVReader_NextOverContainer_ProcessElement(nlTestSuite * inSuite, TLVReader & reader, void * context)
{
CHIP_ERROR err, nextRes1, nextRes2;
TLVType outerContainerType;
// If the current element is a container...
if (TLVTypeIsContainer(reader.GetType()))
{
// Make two copies of the reader
TLVReader readerClone1 = reader;
TLVReader readerClone2 = reader;
// Manually advance one of the readers to the element immediately after the container (if any).
err = readerClone1.EnterContainer(outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
ForEachElement(inSuite, readerClone1, nullptr, nullptr);
err = readerClone1.ExitContainer(outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
nextRes1 = readerClone1.Next();
NL_TEST_ASSERT(inSuite, nextRes1 == CHIP_NO_ERROR || nextRes1 == CHIP_END_OF_TLV);
// For the other reader, skip over the entire container using the Next() method.
nextRes2 = readerClone2.Next();
NL_TEST_ASSERT(inSuite, nextRes2 == CHIP_NO_ERROR || nextRes2 == CHIP_END_OF_TLV);
// Verify the two readers end up in the same state/position.
NL_TEST_ASSERT(inSuite, nextRes1 == nextRes2);
NL_TEST_ASSERT(inSuite, readerClone1.GetType() == readerClone2.GetType());
NL_TEST_ASSERT(inSuite, readerClone1.GetReadPoint() == readerClone2.GetReadPoint());
}
}
/**
* Test using CHIP TLV Reader Next() method to skip over containers.
*/
void TestCHIPTLVReader_NextOverContainer(nlTestSuite * inSuite)
{
TLVReader reader;
reader.Init(Encoding1);
reader.ImplicitProfileId = TestProfile_2;
ForEachElement(inSuite, reader, nullptr, TestCHIPTLVReader_NextOverContainer_ProcessElement);
}
void TestCHIPTLVReader_SkipOverContainer_ProcessElement(nlTestSuite * inSuite, TLVReader & reader, void * context)
{
CHIP_ERROR err;
TLVType outerContainerType;
// If the current element is a container...
if (TLVTypeIsContainer(reader.GetType()))
{
// Make two copies of the reader
TLVReader readerClone1 = reader;
TLVReader readerClone2 = reader;
// Manually advance one of the readers to immediately after the container.
err = readerClone1.EnterContainer(outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
ForEachElement(inSuite, readerClone1, nullptr, nullptr);
err = readerClone1.ExitContainer(outerContainerType);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// For the other reader, skip over the entire container using the Skip() method.
err = readerClone2.Skip();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// Verify the two readers end up in the same state/position.
NL_TEST_ASSERT(inSuite, readerClone1.GetType() == readerClone2.GetType());
NL_TEST_ASSERT(inSuite, readerClone1.GetReadPoint() == readerClone2.GetReadPoint());
}
}
/**
* Test using CHIP TLV Reader Skip() method to skip over containers.
*/
void TestCHIPTLVReader_SkipOverContainer(nlTestSuite * inSuite)
{
TLVReader reader;
reader.Init(Encoding1);
reader.ImplicitProfileId = TestProfile_2;
ForEachElement(inSuite, reader, nullptr, TestCHIPTLVReader_SkipOverContainer_ProcessElement);
}
/**
* Test CHIP TLV Reader
*/
void CheckCHIPTLVReader(nlTestSuite * inSuite, void * inContext)
{
TestCHIPTLVReaderSkip(inSuite);
TestCHIPTLVReaderDup(inSuite);
TestCHIPTLVReaderErrorHandling(inSuite);
TestCHIPTLVReaderTruncatedReads(inSuite);
TestCHIPTLVReaderInPractice(inSuite);
TestCHIPTLVReader_NextOverContainer(inSuite);
TestCHIPTLVReader_SkipOverContainer(inSuite);
}
/**
* Test CHIP TLV Items
*/
static void TestItems(nlTestSuite * inSuite, void * inContext)
{
CHIP_ERROR err = CHIP_NO_ERROR;
uint8_t sBuffer[256];
TLVWriter writer;
writer.Init(sBuffer);
TLVWriter writer2;
err = writer.OpenContainer(AnonymousTag(), kTLVType_Array, writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
{
err = writer2.PutBoolean(AnonymousTag(), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.Put(AnonymousTag(), static_cast<int8_t>(-1));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.Put(AnonymousTag(), static_cast<int16_t>(-2));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.Put(AnonymousTag(), static_cast<int32_t>(-3));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.Put(AnonymousTag(), static_cast<int64_t>(-4));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.Put(AnonymousTag(), static_cast<float>(-5.5));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.Put(AnonymousTag(), static_cast<double>(-3.14159265358979323846));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
err = writer.CloseContainer(writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.OpenContainer(AnonymousTag(), kTLVType_Array, writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
{
err = writer2.PutBoolean(AnonymousTag(), false);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.Put(AnonymousTag(), static_cast<int8_t>(1));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.Put(AnonymousTag(), static_cast<int16_t>(2));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.Put(AnonymousTag(), static_cast<int32_t>(3));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.Put(AnonymousTag(), static_cast<int64_t>(4));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.Put(AnonymousTag(), static_cast<uint8_t>(5));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.Put(AnonymousTag(), static_cast<uint16_t>(6));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.Put(AnonymousTag(), static_cast<uint32_t>(7));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.Put(AnonymousTag(), static_cast<uint64_t>(8));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.Put(AnonymousTag(), static_cast<float>(9.9));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.Put(AnonymousTag(), static_cast<double>(3.14159265358979323846));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
err = writer.CloseContainer(writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
/**
* Test CHIP TLV Containers
*/
static void TestContainers(nlTestSuite * inSuite, void * inContext)
{
CHIP_ERROR err = CHIP_NO_ERROR;
TLVWriter writer;
uint8_t sBuffer[256];
writer.Init(sBuffer);
TLVWriter writer2;
err = writer.OpenContainer(AnonymousTag(), kTLVType_Array, writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
TLVType type = writer2.GetContainerType();
NL_TEST_ASSERT(inSuite, type == kTLVType_Array);
err = writer.CloseContainer(writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.OpenContainer(AnonymousTag(), kTLVType_Structure, writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
type = writer2.GetContainerType();
NL_TEST_ASSERT(inSuite, type == kTLVType_Structure);
err = writer.CloseContainer(writer2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
}
/**
* Test CHIP TLV Basics
*/
static void CheckCHIPTLVBasics(nlTestSuite * inSuite, void * inContext)
{
TestItems(inSuite, inContext);
TestContainers(inSuite, inContext);
}
/**
* Test CHIP TLV Updater
*/
static void CheckCHIPUpdater(nlTestSuite * inSuite, void * inContext)
{
WriteAppendReadTest0(inSuite);
WriteAppendReadTest1(inSuite);
WriteFindAppendReadTest(inSuite, false); // Find an element
WriteFindAppendReadTest(inSuite, true); // Find a container
AppendReadTest(inSuite);
WriteDeleteReadTest(inSuite);
}
/**
* Test TLV CloseContainer symbol reservations
*/
class OptimisticTLVWriter : public TLVWriter
{
public:
void Init(uint8_t * buf, size_t maxLen);
};
void OptimisticTLVWriter::Init(uint8_t * buf, size_t maxLen)
{
TLVWriter::Init(buf, maxLen);
SetCloseContainerReserved(false);
}
static void CheckCloseContainerReserve(nlTestSuite * inSuite, void * inContext)
{
// We are writing the structure looking like:
//
// [{TestProfile_1:2: true}]
//
// the above should consume 11 bytes in the TLV encoding. The
// chosen buffer is too small for that, this test verifies that we
// fail in the right places in the code. With the standard
// TLVWriter, we now make provisions to reserve the space for the
// CloseContainer tag in the OpenContainer call. As a result, we
// expect to error out when we attempt to write out the value for
// the TestProfile_1:2 tag. In contrast, the
// `OptimisticTLVWriter` implements the earlier TLVWriter behavior
// and fails out in the last CloseContainer call. The error
// caught there is different because we run up against the mMaxLen
// rather than mRemainingLen check.
uint8_t buf[10];
uint8_t buf1[7];
CHIP_ERROR err = CHIP_NO_ERROR;
TLVWriter writer1;
OptimisticTLVWriter writer2;
TLVWriter innerWriter1, innerWriter2;
TLVType container1, container2;
writer1.Init(buf);
err = writer1.OpenContainer(AnonymousTag(), kTLVType_Array, innerWriter1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = innerWriter1.OpenContainer(AnonymousTag(), kTLVType_Structure, innerWriter2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = innerWriter2.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_BUFFER_TOO_SMALL);
err = innerWriter1.CloseContainer(innerWriter2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer1.CloseContainer(innerWriter1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
writer2.Init(buf, sizeof(buf));
err = writer2.OpenContainer(AnonymousTag(), kTLVType_Array, innerWriter1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = innerWriter1.OpenContainer(AnonymousTag(), kTLVType_Structure, innerWriter2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = innerWriter2.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = innerWriter1.CloseContainer(innerWriter2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.CloseContainer(innerWriter1);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_BUFFER_TOO_SMALL);
// test the same scheme works on the Start/End container
writer1.Init(buf);
err = writer1.StartContainer(AnonymousTag(), kTLVType_Array, container1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer1.StartContainer(AnonymousTag(), kTLVType_Structure, container2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer1.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_BUFFER_TOO_SMALL);
err = writer1.EndContainer(container2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer1.EndContainer(container1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
writer2.Init(buf, sizeof(buf));
err = writer2.StartContainer(AnonymousTag(), kTLVType_Array, container1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.StartContainer(AnonymousTag(), kTLVType_Structure, container2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.PutBoolean(ProfileTag(TestProfile_1, 2), true);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.EndContainer(container2);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.EndContainer(container1);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_BUFFER_TOO_SMALL);
// Test that the reservations work for the empty containers
writer1.Init(buf1);
err = writer1.OpenContainer(ProfileTag(TestProfile_1, 2), kTLVType_Structure, innerWriter1);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_BUFFER_TOO_SMALL);
err = writer1.CloseContainer(innerWriter1);
NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
writer2.Init(buf1, sizeof(buf1));
err = writer2.OpenContainer(ProfileTag(TestProfile_1, 2), kTLVType_Structure, innerWriter1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.CloseContainer(innerWriter1);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_BUFFER_TOO_SMALL);
writer1.Init(buf1);
err = writer1.StartContainer(ProfileTag(TestProfile_1, 2), kTLVType_Structure, container1);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_BUFFER_TOO_SMALL);
err = writer1.EndContainer(container1);
NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
writer2.Init(buf1, sizeof(buf1));
err = writer2.StartContainer(ProfileTag(TestProfile_1, 2), kTLVType_Structure, container1);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer2.EndContainer(container1);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_BUFFER_TOO_SMALL);
// Test that the reservations work if the writer has a maxLen of 0.
writer1.Init(buf1, 0);
err = writer1.OpenContainer(ProfileTag(TestProfile_1, 2), kTLVType_Structure, innerWriter1);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_BUFFER_TOO_SMALL);
err = writer1.StartContainer(AnonymousTag(), kTLVType_Array, container1);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_BUFFER_TOO_SMALL);
// Test again all cases from 0 to the length of buf1
for (uint32_t maxLen = 0; maxLen <= sizeof(buf); maxLen++)
{
// Open/CloseContainer
writer1.Init(buf, maxLen);
err = writer1.OpenContainer(AnonymousTag(), kTLVType_Array, innerWriter1);
if (err == CHIP_NO_ERROR)
err = innerWriter1.OpenContainer(AnonymousTag(), kTLVType_Structure, innerWriter2);
if (err == CHIP_NO_ERROR)
err = innerWriter2.PutBoolean(ProfileTag(TestProfile_1, 2), true);
if (err == CHIP_NO_ERROR)
err = innerWriter1.CloseContainer(innerWriter2);
if (err == CHIP_NO_ERROR)
err = writer1.CloseContainer(innerWriter1);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_BUFFER_TOO_SMALL);
// Start/EndContainer
writer1.Init(buf, maxLen);
if (err == CHIP_NO_ERROR)
err = writer1.StartContainer(AnonymousTag(), kTLVType_Array, container1);
if (err == CHIP_NO_ERROR)
err = writer1.StartContainer(AnonymousTag(), kTLVType_Structure, container2);
if (err == CHIP_NO_ERROR)
err = writer1.PutBoolean(ProfileTag(TestProfile_1, 2), true);
if (err == CHIP_NO_ERROR)
err = writer1.EndContainer(container2);
if (err == CHIP_NO_ERROR)
err = writer1.EndContainer(container1);
NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_BUFFER_TOO_SMALL);
}
}
static CHIP_ERROR ReadFuzzedEncoding1(nlTestSuite * inSuite, TLVReader & reader)
{
CHIP_ERROR err = CHIP_NO_ERROR;
#define FUZZ_CHECK_VAL(TYPE, VAL) \
do \
{ \
TYPE val; \
ReturnErrorOnFailure(reader.Get(val)); \
VerifyOrReturnError(val == (VAL), CHIP_ERROR_INVALID_ARGUMENT); \
} while (0)
#define FUZZ_CHECK_STRING(VAL) \
do \
{ \
char buf[sizeof(VAL)]; \
VerifyOrReturnError(reader.GetLength() == strlen(VAL), CHIP_ERROR_INVALID_ADDRESS); \
ReturnErrorOnFailure(reader.GetString(buf, sizeof(buf))); \
VerifyOrReturnError(strcmp(buf, (VAL)) == 0, CHIP_ERROR_INVALID_ADDRESS); \
} while (0)
ReturnErrorOnFailure(reader.Next(kTLVType_Structure, ProfileTag(TestProfile_1, 1)));
{
TLVType outerContainer1Type;
ReturnErrorOnFailure(reader.EnterContainer(outerContainer1Type));
ReturnErrorOnFailure(reader.Next(kTLVType_Boolean, ProfileTag(TestProfile_1, 2)));
FUZZ_CHECK_VAL(bool, true);
ReturnErrorOnFailure(reader.Next(kTLVType_Boolean, ProfileTag(TestProfile_2, 2)));
FUZZ_CHECK_VAL(bool, false);
ReturnErrorOnFailure(reader.Next(kTLVType_Array, ContextTag(0)));
{
TLVType outerContainer2Type;
ReturnErrorOnFailure(reader.EnterContainer(outerContainer2Type));
ReturnErrorOnFailure(reader.Next(kTLVType_SignedInteger, AnonymousTag()));
FUZZ_CHECK_VAL(int8_t, 42);
FUZZ_CHECK_VAL(int16_t, 42);
FUZZ_CHECK_VAL(int32_t, 42);
FUZZ_CHECK_VAL(int64_t, 42);
FUZZ_CHECK_VAL(uint8_t, 42);
FUZZ_CHECK_VAL(uint16_t, 42);
FUZZ_CHECK_VAL(uint32_t, 42);
FUZZ_CHECK_VAL(uint64_t, 42);
ReturnErrorOnFailure(reader.Next(kTLVType_SignedInteger, AnonymousTag()));
FUZZ_CHECK_VAL(int8_t, -17);
FUZZ_CHECK_VAL(int16_t, -17);
FUZZ_CHECK_VAL(int32_t, -17);
FUZZ_CHECK_VAL(int64_t, -17);
ReturnErrorOnFailure(reader.Next(kTLVType_SignedInteger, AnonymousTag()));
FUZZ_CHECK_VAL(int32_t, -170000);
FUZZ_CHECK_VAL(int64_t, -170000);
ReturnErrorOnFailure(reader.Next(kTLVType_UnsignedInteger, AnonymousTag()));
FUZZ_CHECK_VAL(int64_t, 40000000000ULL);
FUZZ_CHECK_VAL(uint64_t, 40000000000ULL);
ReturnErrorOnFailure(reader.Next(kTLVType_Structure, AnonymousTag()));
{
TLVType outerContainer3Type;
ReturnErrorOnFailure(reader.EnterContainer(outerContainer3Type));
ReturnErrorOnFailure(reader.ExitContainer(outerContainer3Type));
}
ReturnErrorOnFailure(reader.Next(kTLVType_List, AnonymousTag()));
{
TLVType outerContainer3Type;
ReturnErrorOnFailure(reader.EnterContainer(outerContainer3Type));
ReturnErrorOnFailure(reader.Next(kTLVType_Null, ProfileTag(TestProfile_1, 17)));
ReturnErrorOnFailure(reader.Next(kTLVType_Null, ProfileTag(TestProfile_2, 900000)));
ReturnErrorOnFailure(reader.Next(kTLVType_Null, AnonymousTag()));
ReturnErrorOnFailure(reader.Next(kTLVType_Structure, ProfileTag(TestProfile_2, 4000000000ULL)));
{
TLVType outerContainer4Type;
ReturnErrorOnFailure(reader.EnterContainer(outerContainer4Type));
ReturnErrorOnFailure(reader.Next(kTLVType_UTF8String, CommonTag(70000)));
FUZZ_CHECK_STRING(sLargeString);
ReturnErrorOnFailure(reader.ExitContainer(outerContainer4Type));
}
ReturnErrorOnFailure(reader.ExitContainer(outerContainer3Type));
}
ReturnErrorOnFailure(reader.ExitContainer(outerContainer2Type));
}
ReturnErrorOnFailure(reader.Next(kTLVType_UTF8String, ProfileTag(TestProfile_1, 5)));
FUZZ_CHECK_STRING("This is a test");
ReturnErrorOnFailure(reader.Next(kTLVType_FloatingPointNumber, ProfileTag(TestProfile_2, 65535)));
FUZZ_CHECK_VAL(double, (float) 17.9);
ReturnErrorOnFailure(reader.Next(kTLVType_FloatingPointNumber, ProfileTag(TestProfile_2, 65536)));
FUZZ_CHECK_VAL(double, (double) 17.9);
ReturnErrorOnFailure(reader.ExitContainer(outerContainer1Type));
}
err = reader.Next();
if (err == CHIP_END_OF_TLV)
err = CHIP_NO_ERROR;
return CHIP_NO_ERROR;
}
static uint64_t sFuzzTestDurationMillis = 5000;
static uint8_t sFixedFuzzMask = 0;
static void TLVReaderFuzzTest(nlTestSuite * inSuite, void * inContext)
{
uint64_t now, endTime;
uint8_t fuzzedData[sizeof(Encoding1)];
// clang-format off
static uint8_t sFixedFuzzVals[] =
{
0x00,
0x01,
0xFF,
0x20, // 1-byte signed integer with context tag
0x21, // 2-byte signed integer with context tag
0x22, // 4-byte signed integer with context tag
0x23, // 8-byte signed integer with context tag
0x24, // 1-byte unsigned integer with context tag
0x25, // 1-byte unsigned integer with context tag
0x26, // 1-byte unsigned integer with context tag
0x27, // 1-byte unsigned integer with context tag
0x28, // Boolean false with context tag
0x29, // Boolean true with context tag
0x27, // UTF-8 string with 1-byte length and context tag
0x30, // Byte string with 1-byte length and context tag
0x35, // Structure with context tag
0x36, // Array with context tag
0x18, // End of container
};
// clang-format on
memcpy(fuzzedData, Encoding1, sizeof(fuzzedData));
now = chip::test_utils::TimeMonotonicMillis();
endTime = now + sFuzzTestDurationMillis + 1;
srand(static_cast<unsigned int>(now));
size_t m = 0;
while (true)
{
for (size_t i = 0; i < sizeof(fuzzedData); i++)
{
uint8_t origVal = fuzzedData[i];
if (m < sizeof(sFixedFuzzVals))
{
if (origVal == sFixedFuzzVals[m])
continue;
fuzzedData[i] = sFixedFuzzVals[m];
}
else
{
uint8_t fuzzMask = sFixedFuzzMask;
while (fuzzMask == 0)
fuzzMask = static_cast<uint8_t>(rand() & 0xFF);
fuzzedData[i] ^= fuzzMask;
}
TLVReader reader;
reader.Init(fuzzedData);
reader.ImplicitProfileId = TestProfile_2;
CHIP_ERROR readRes = ReadFuzzedEncoding1(inSuite, reader);
NL_TEST_ASSERT(inSuite, readRes != CHIP_NO_ERROR);
if (readRes == CHIP_NO_ERROR)
{
printf("Unexpected success of fuzz test: offset %u, original value 0x%02X, mutated value 0x%02X\n",
static_cast<unsigned>(i), static_cast<unsigned>(origVal), static_cast<unsigned>(fuzzedData[i]));
return;
}
now = chip::test_utils::TimeMonotonicMillis();
if (now >= endTime)
return;
fuzzedData[i] = origVal;
}
if (m < sizeof(sFixedFuzzVals))
m++;
}
}
static void AssertCanReadString(nlTestSuite * inSuite, ContiguousBufferTLVReader & reader, const char * expectedString)
{
Span<const char> str;
CHIP_ERROR err = reader.GetStringView(str);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, str.size() == strlen(expectedString));
NL_TEST_ASSERT(inSuite, strncmp(str.data(), expectedString, str.size()) == 0);
}
static void AssertCannotReadString(nlTestSuite * inSuite, ContiguousBufferTLVReader & reader)
{
Span<const char> str;
CHIP_ERROR err = reader.GetStringView(str);
NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
}
static void CheckGetStringView(nlTestSuite * inSuite, void * inContext)
{
uint8_t buf[256];
const char testString[] = "This is a test";
{
TLVWriter writer;
writer.Init(buf);
CHIP_ERROR err = writer.PutString(CommonTag(0), testString);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// First check that basic read from entire buffer works.
ContiguousBufferTLVReader reader;
reader.Init(buf);
reader.Next();
AssertCanReadString(inSuite, reader, testString);
// Now check that read from a buffer bounded by the number of bytes
// written works.
reader.Init(buf, writer.GetLengthWritten());
reader.Next();
AssertCanReadString(inSuite, reader, testString);
// Now check that read from a buffer bounded by fewer than the number of
// bytes written fails.
reader.Init(buf, writer.GetLengthWritten() - 1);
reader.Next();
AssertCannotReadString(inSuite, reader);
}
{
// Check that an integer cannot be read as a string.
TLVWriter writer;
writer.Init(buf);
CHIP_ERROR err = writer.Put(CommonTag(0), static_cast<uint8_t>(5));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
ContiguousBufferTLVReader reader;
reader.Init(buf);
reader.Next();
AssertCannotReadString(inSuite, reader);
}
{
// Check that an octet string cannot be read as a string.
TLVWriter writer;
writer.Init(buf);
CHIP_ERROR err =
writer.PutBytes(CommonTag(0), reinterpret_cast<const uint8_t *>(testString), static_cast<uint32_t>(strlen(testString)));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
ContiguousBufferTLVReader reader;
reader.Init(buf);
reader.Next();
AssertCannotReadString(inSuite, reader);
}
{
// Check that a manually constructed string can be read as a string.
const uint8_t shortString[] = { CHIP_TLV_UTF8_STRING_2ByteLength(CHIP_TLV_TAG_COMMON_PROFILE_2Bytes(0), 2, 'a', 'b') };
ContiguousBufferTLVReader reader;
reader.Init(shortString);
reader.Next();
AssertCanReadString(inSuite, reader, "ab");
}
{
// Check that a manually constructed string with bogus length cannot be read as a string.
const uint8_t shortString[] = { CHIP_TLV_UTF8_STRING_2ByteLength(CHIP_TLV_TAG_COMMON_PROFILE_2Bytes(0), 3, 'a', 'b') };
ContiguousBufferTLVReader reader;
reader.Init(shortString);
reader.Next();
AssertCannotReadString(inSuite, reader);
}
}
static void AssertCanReadBytes(nlTestSuite * inSuite, ContiguousBufferTLVReader & reader, const ByteSpan & expectedBytes)
{
ByteSpan bytes;
CHIP_ERROR err = reader.GetByteView(bytes);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, bytes.data_equal(expectedBytes));
}
static void AssertCannotReadBytes(nlTestSuite * inSuite, ContiguousBufferTLVReader & reader)
{
ByteSpan bytes;
CHIP_ERROR err = reader.GetByteView(bytes);
NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
}
static void CheckGetByteView(nlTestSuite * inSuite, void * inContext)
{
uint8_t buf[256];
const uint8_t testBytes[] = { 'T', 'h', 'i', 's', 'i', 's', 'a', 't', 'e', 's', 't', '\0' };
{
TLVWriter writer;
writer.Init(buf);
CHIP_ERROR err = writer.PutBytes(CommonTag(0), testBytes, sizeof(testBytes));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
// First check that basic read from entire buffer works.
ContiguousBufferTLVReader reader;
reader.Init(buf);
reader.Next();
AssertCanReadBytes(inSuite, reader, ByteSpan(testBytes));
// Now check that read from a buffer bounded by the number of bytes
// written works.
reader.Init(buf, writer.GetLengthWritten());
reader.Next();
AssertCanReadBytes(inSuite, reader, ByteSpan(testBytes));
// Now check that read from a buffer bounded by fewer than the number of
// bytes written fails.
reader.Init(buf, writer.GetLengthWritten() - 1);
reader.Next();
AssertCannotReadBytes(inSuite, reader);
}
{
// Check that an integer cannot be read as an octet string.
TLVWriter writer;
writer.Init(buf);
CHIP_ERROR err = writer.Put(CommonTag(0), static_cast<uint8_t>(5));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
ContiguousBufferTLVReader reader;
reader.Init(buf);
reader.Next();
AssertCannotReadBytes(inSuite, reader);
}
{
// Check that an string cannot be read as an octet string.
TLVWriter writer;
writer.Init(buf);
CHIP_ERROR err = writer.PutString(CommonTag(0), reinterpret_cast<const char *>(testBytes));
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
ContiguousBufferTLVReader reader;
reader.Init(buf);
reader.Next();
AssertCannotReadBytes(inSuite, reader);
}
{
// Check that a manually constructed octet string can be read as octet string.
const uint8_t shortBytes[] = { CHIP_TLV_BYTE_STRING_2ByteLength(CHIP_TLV_TAG_COMMON_PROFILE_2Bytes(0), 2, 1, 2) };
ContiguousBufferTLVReader reader;
reader.Init(shortBytes);
reader.Next();
const uint8_t expectedBytes[] = { 1, 2 };
AssertCanReadBytes(inSuite, reader, ByteSpan(expectedBytes));
}
{
// Check that a manually constructed octet string with bogus length
// cannot be read as an octet string.
const uint8_t shortBytes[] = { CHIP_TLV_BYTE_STRING_2ByteLength(CHIP_TLV_TAG_COMMON_PROFILE_2Bytes(0), 3, 1, 2) };
ContiguousBufferTLVReader reader;
reader.Init(shortBytes);
reader.Next();
AssertCannotReadBytes(inSuite, reader);
}
}
static void CheckCHIPTLVScopedBuffer(nlTestSuite * inSuite, void * inContext)
{
Platform::ScopedMemoryBuffer<uint8_t> buf;
CHIP_ERROR err;
buf.Calloc(64);
NL_TEST_ASSERT(inSuite, buf.Get() != nullptr);
{
ScopedBufferTLVWriter writer(std::move(buf), 64);
NL_TEST_ASSERT(inSuite, buf.Get() == nullptr); // // NOLINT(bugprone-use-after-move)
err = writer.Put(TLV::AnonymousTag(), (uint8_t) 33);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = writer.Finalize(buf);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, buf.Get() != nullptr);
err = writer.Put(TLV::AnonymousTag(), (uint8_t) 33);
NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
}
{
ScopedBufferTLVReader reader;
uint8_t val;
reader.Init(std::move(buf), 64);
err = reader.Next();
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
err = reader.Get(val);
NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
NL_TEST_ASSERT(inSuite, val == 33);
reader.TakeBuffer(buf);
NL_TEST_ASSERT(inSuite, buf.Get() != nullptr);
err = reader.Get(val);
NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
}
}
// Test Suite
/**
* Test Suite that lists all the test functions.
*/
// clang-format off
static const nlTest sTests[] =
{
NL_TEST_DEF("Simple Write Read Test", CheckSimpleWriteRead),
NL_TEST_DEF("Inet Buffer Test", CheckPacketBuffer),
NL_TEST_DEF("Buffer Overflow Test", CheckBufferOverflow),
NL_TEST_DEF("Pretty Print Test", CheckPrettyPrinter),
NL_TEST_DEF("Pretty Octet String Print Test", CheckOctetStringPrettyPrinter),
NL_TEST_DEF("Data Macro Test", CheckDataMacro),
NL_TEST_DEF("Strict Aliasing Test", CheckStrictAliasing),
NL_TEST_DEF("CHIP TLV Basics", CheckCHIPTLVBasics),
NL_TEST_DEF("CHIP TLV Writer", CheckCHIPTLVWriter),
NL_TEST_DEF("CHIP TLV Reader", CheckCHIPTLVReader),
NL_TEST_DEF("CHIP TLV Utilities", CheckCHIPTLVUtilities),
NL_TEST_DEF("CHIP TLV Updater", CheckCHIPUpdater),
NL_TEST_DEF("CHIP TLV Empty Find", CheckCHIPTLVEmptyFind),
NL_TEST_DEF("CHIP Circular TLV buffer, simple", CheckCircularTLVBufferSimple),
NL_TEST_DEF("CHIP Circular TLV buffer, mid-buffer start", CheckCircularTLVBufferStartMidway),
NL_TEST_DEF("CHIP Circular TLV buffer, straddle", CheckCircularTLVBufferEvictStraddlingEvent),
NL_TEST_DEF("CHIP Circular TLV buffer, edge", CheckCircularTLVBufferEdge),
NL_TEST_DEF("CHIP TLV Printf", CheckCHIPTLVPutStringF),
NL_TEST_DEF("CHIP TLV String Span", CheckCHIPTLVPutStringSpan),
NL_TEST_DEF("CHIP TLV Printf, Circular TLV buf", CheckCHIPTLVPutStringFCircular),
NL_TEST_DEF("CHIP TLV Skip non-contiguous", CheckCHIPTLVSkipCircular),
NL_TEST_DEF("CHIP TLV ByteSpan", CheckCHIPTLVByteSpan),
NL_TEST_DEF("CHIP TLV Scoped Buffer", CheckCHIPTLVScopedBuffer),
NL_TEST_DEF("CHIP TLV Check reserve", CheckCloseContainerReserve),
NL_TEST_DEF("CHIP TLV Reader Fuzz Test", TLVReaderFuzzTest),
NL_TEST_DEF("CHIP TLV GetStringView Test", CheckGetStringView),
NL_TEST_DEF("CHIP TLV GetByteView Test", CheckGetByteView),
NL_TEST_DEF("Int Min/Max Test", TestIntMinMax),
NL_TEST_SENTINEL()
};
// clang-format on
/**
* Set up the test suite.
*/
int TestCHIPTLV_Setup(void * inContext)
{
CHIP_ERROR error = chip::Platform::MemoryInit();
if (error != CHIP_NO_ERROR)
return FAILURE;
return SUCCESS;
}
/**
* Tear down the test suite.
*/
int TestCHIPTLV_Teardown(void * inContext)
{
chip::Platform::MemoryShutdown();
return SUCCESS;
}
int TestCHIPTLV(void)
{
// clang-format off
nlTestSuite theSuite =
{
"chip-tlv",
&sTests[0],
TestCHIPTLV_Setup,
TestCHIPTLV_Teardown
};
// clang-format on
return chip::ExecuteTestsWithContext<TestTLVContext>(&theSuite, &theSuite);
}
CHIP_REGISTER_TEST_SUITE(TestCHIPTLV)