src/test-apps/TestResourceIdentifier.cpp - third_party/openweave-core - Git at Google

 /*
  *
  *    Copyright (c) 2018 Google LLC.
  *    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 Weave TLV implementation.
  *
  */

 #include "ToolCommon.h"

 #include <nlbyteorder.h>
 #include <nlunit-test.h>

 #include <Weave/Core/WeaveCore.h>
 #include <Weave/Core/WeaveTLV.h>
 #include <Weave/Core/WeaveTLVDebug.hpp>
 #include <Weave/Core/WeaveTLVUtilities.hpp>
 #include <Weave/Core/WeaveTLVData.hpp>
 #include <Weave/Core/WeaveCircularTLVBuffer.h>
 #include <Weave/Support/RandUtils.h>
 #include <Weave/Support/ErrorStr.h>

 #include <Weave/Profiles/data-management/Current/WdmManagedNamespace.h>
 #include <Weave/Profiles/data-management/DataManagement.h>

 using namespace nl;
 using namespace nl::Weave::TLV;
 using namespace nl::Weave::Profiles::DataManagement;

 static void CheckDefaultConstructor(nlTestSuite * inSuite, void * inContext);
 static void CheckU64Constructor(nlTestSuite * inSuite, void * inContext);
 static void CheckTypeU64Constructor(nlTestSuite * inSuite, void * inContext);

 static void CheckByteArrayConstructor(nlTestSuite * inSuite, void * inContext);
 static void CheckTLVSerDes(nlTestSuite * inSuite, void * inContext);
 static void CheckStringSerDes(nlTestSuite * inSuite, void * inContext);
 static void CheckTLVDecodingErrors(nlTestSuite * inSuite, void * inContext);
 static void CheckEncoding(nlTestSuite * inSuite, ResourceIdentifier resource, const uint8_t * refBuffer, size_t refBufferLen,
                           uint8_t * buffer, size_t bufferLen);
 static void CheckEncoding(nlTestSuite * inSuite, ResourceIdentifier resource, uint64_t tag, const uint8_t * refBuffer,
                           size_t refBufferLen, uint8_t * buffer, size_t bufferLen);
 static void CheckDecoding(nlTestSuite * inSuite, const uint8_t * buffer, size_t bufferLen, ResourceIdentifier reference);
 static void CheckDecoding(nlTestSuite * inSuite, const uint8_t * buffer, size_t bufferLen, uint64_t nodeid,
                           ResourceIdentifier reference);

 static void CheckDefaultConstructor(nlTestSuite * inSuite, void * inContext)
 {
     ResourceIdentifier resource;
     ResourceIdentifier resource1;
     ResourceIdentifier resource_self(ResourceIdentifier::SELF_NODE_ID);

     // Unspecified Node ID

     NL_TEST_ASSERT(inSuite, resource.GetResourceId() == kNodeIdNotSpecified);
     NL_TEST_ASSERT(inSuite, resource.GetResourceType() == ResourceIdentifier::RESOURCE_TYPE_RESERVED);
     // it is different than a self node ID
     NL_TEST_ASSERT(inSuite, resource != resource_self);
     // it is equal to other uninitialized resources
     NL_TEST_ASSERT(inSuite, resource == resource1);
 }

 static void CheckU64Constructor(nlTestSuite * inSuite, void * inContext)
 {
     ResourceIdentifier resource(0x18b4300000000001ULL);
     ResourceIdentifier resource1(0x18b4300000000001ULL);
     ResourceIdentifier resource2(1ULL);
     ResourceIdentifier resource_self(ResourceIdentifier::SELF_NODE_ID);
     const char resource_type_string[] = "DEVICE";

     NL_TEST_ASSERT(inSuite, resource.GetResourceId() == 0x18b4300000000001ULL);
     NL_TEST_ASSERT(inSuite, resource.GetResourceType() == Schema::Weave::Common::RESOURCE_TYPE_DEVICE);
     NL_TEST_ASSERT(inSuite, strncmp(resource.ResourceTypeAsString(), resource_type_string, sizeof(resource_type_string)) == 0);

     // it is equal to another resource initialized in the same manner
     NL_TEST_ASSERT(inSuite, resource == resource1);

     // it is different than a self node ID
     NL_TEST_ASSERT(inSuite, resource != resource_self);
 }

 static void CheckTypeU64Constructor(nlTestSuite * inSuite, void * inContext)
 {
     ResourceIdentifier resource(Schema::Weave::Common::RESOURCE_TYPE_DEVICE, 0x18b4300000000001ULL);
     ResourceIdentifier resource1(0x18b4300000000001ULL);
     ResourceIdentifier resource2(Schema::Weave::Common::RESOURCE_TYPE_USER, 0x18b4300000000001ULL);
     ResourceIdentifier resource_self(ResourceIdentifier::SELF_NODE_ID);

     NL_TEST_ASSERT(inSuite, resource.GetResourceId() == 0x18b4300000000001ULL);
     NL_TEST_ASSERT(inSuite, resource.GetResourceType() == Schema::Weave::Common::RESOURCE_TYPE_DEVICE);

     // it is equal to another resource initialized just by u64
     NL_TEST_ASSERT(inSuite, resource == resource1);

     // it is different than a self node ID
     NL_TEST_ASSERT(inSuite, resource != resource_self);
     // it is different from a resource of the same ID with a different type
     NL_TEST_ASSERT(inSuite, resource != resource2);
 }

 static void CheckByteArrayConstructor(nlTestSuite * inSuite, void * inContext)
 {
     uint64_t id1        = 0x18b4300000000001ULL;
     const uint8_t id2[] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x30, 0xb4, 0x18 };
     ResourceIdentifier resource(0x18b4300000000001ULL);
     ResourceIdentifier resource1(Schema::Weave::Common::RESOURCE_TYPE_DEVICE, (uint8_t *) &id1, sizeof(id1));
     ResourceIdentifier resource2(Schema::Weave::Common::RESOURCE_TYPE_DEVICE, id2, sizeof(id2));
 }

 static void CheckTLVSerDes(nlTestSuite * inSuite, void * inContext)
 {
     ResourceIdentifier resource(Schema::Weave::Common::RESOURCE_TYPE_DEVICE, 0x18b4300000000001ULL);
     ResourceIdentifier resource1(0x18b4300000000001ULL);
     ResourceIdentifier resource2(Schema::Weave::Common::RESOURCE_TYPE_USER, 0x18b4300000000001ULL);
     ResourceIdentifier resource3(0x1ULL);
     ResourceIdentifier resource_self(ResourceIdentifier::SELF_NODE_ID);
     ResourceIdentifier resource_unknown_type(0xC001, 0x18b4300000000001ULL);
     ResourceIdentifier resource_uninitialized;

     const uint8_t resource_tlv[] = { nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS),
                                      nlWeaveTLV_BYTE_STRING_1ByteLength(nlWeaveTLV_TAG_CONTEXT_SPECIFIC(Path::kCsTag_ResourceID),
                                                                         // length:
                                                                         10,
                                                                         // type
                                                                         0x01, 0x00,
                                                                         // ID in LE order:
                                                                         0x01, 0x00, 0x00, 0x00, 0x00, 0x30, 0xb4, 0x18),
                                      nlWeaveTLV_END_OF_CONTAINER };

     const uint8_t resource_tag_tlv[] = { nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS),
                                          nlWeaveTLV_BYTE_STRING_1ByteLength(nlWeaveTLV_TAG_CONTEXT_SPECIFIC(kTag_EventResourceID),
                                                                             // length:
                                                                             10,
                                                                             // type
                                                                             0x01, 0x00,
                                                                             // ID in LE order:
                                                                             0x01, 0x00, 0x00, 0x00, 0x00, 0x30, 0xb4, 0x18),
                                          nlWeaveTLV_END_OF_CONTAINER };

     const uint8_t resource1_tlv[] = { nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS),
                                       nlWeaveTLV_UINT64(nlWeaveTLV_TAG_CONTEXT_SPECIFIC(Path::kCsTag_ResourceID),
                                                         0x18b4300000000001ULL),
                                       nlWeaveTLV_END_OF_CONTAINER };

     const uint8_t resource1_tag_tlv[] = {
         nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS),
         nlWeaveTLV_UINT64(nlWeaveTLV_TAG_CONTEXT_SPECIFIC(kTag_EventResourceID), 0x18b4300000000001ULL), nlWeaveTLV_END_OF_CONTAINER
     };

     const uint8_t resource2_tlv[] = { nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS),
                                       nlWeaveTLV_BYTE_STRING_1ByteLength(nlWeaveTLV_TAG_CONTEXT_SPECIFIC(Path::kCsTag_ResourceID),
                                                                          // length:
                                                                          10,
                                                                          // type
                                                                          0x02, 0x00,
                                                                          // ID in LE order:
                                                                          0x01, 0x00, 0x00, 0x00, 0x00, 0x30, 0xb4, 0x18),
                                       nlWeaveTLV_END_OF_CONTAINER };

     const uint8_t resource_self_tlv[] = { nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS), nlWeaveTLV_END_OF_CONTAINER };

     const uint8_t resource3_tlv[] = { nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS),
                                       nlWeaveTLV_UINT8(nlWeaveTLV_TAG_CONTEXT_SPECIFIC(Path::kCsTag_ResourceID), 0x1),
                                       nlWeaveTLV_END_OF_CONTAINER };

     const uint8_t resource_unknown_type_tlv[] = { nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS),
                                                   nlWeaveTLV_BYTE_STRING_1ByteLength(
                                                       nlWeaveTLV_TAG_CONTEXT_SPECIFIC(Path::kCsTag_ResourceID),
                                                       // length:
                                                       10,
                                                       // type
                                                       0x01, 0xc0,
                                                       // ID in LE order:
                                                       0x01, 0x00, 0x00, 0x00, 0x00, 0x30, 0xb4, 0x18),
                                                   nlWeaveTLV_END_OF_CONTAINER };

     uint8_t buffer[1024];

     // ENCODING

     // resource gets encoded as resource1_tlv
     CheckEncoding(inSuite, resource, resource1_tlv, sizeof(resource1_tlv), buffer, sizeof(buffer));
     // resource1 gets encoded as resource1_tlv
     CheckEncoding(inSuite, resource1, resource1_tlv, sizeof(resource1_tlv), buffer, sizeof(buffer));
     // resource2 gets encoded as resource2
     CheckEncoding(inSuite, resource2, resource2_tlv, sizeof(resource2_tlv), buffer, sizeof(buffer));
     // resource_unknown_type gets encoded as resource_unknown_type_tlv
     CheckEncoding(inSuite, resource_unknown_type, resource_unknown_type_tlv, sizeof(resource_unknown_type_tlv), buffer,
                   sizeof(buffer));
     // resource_self gets encoded as resource_self_tlv
     CheckEncoding(inSuite, resource_self, resource_self_tlv, sizeof(resource_self_tlv), buffer, sizeof(buffer));

     // encoding with a different tag
     CheckEncoding(inSuite, resource, ContextTag(kTag_EventResourceID), resource1_tag_tlv, sizeof(resource1_tag_tlv), buffer,
                   sizeof(buffer));

     // DECODING
     CheckDecoding(inSuite, resource_tlv, sizeof(resource_tlv), resource);
     CheckDecoding(inSuite, resource_tag_tlv, sizeof(resource_tag_tlv), resource);
     CheckDecoding(inSuite, resource1_tlv, sizeof(resource1_tlv), resource1);
     CheckDecoding(inSuite, resource2_tlv, sizeof(resource2_tlv), resource2);
     CheckDecoding(inSuite, resource3_tlv, sizeof(resource3_tlv), resource3);
     CheckDecoding(inSuite, resource_unknown_type_tlv, sizeof(resource_unknown_type_tlv), resource_unknown_type);

     // mapping onto self
     CheckDecoding(inSuite, resource_tlv, sizeof(resource_tlv), 0x18b4300000000001ULL, resource_self);
     CheckDecoding(inSuite, resource_tag_tlv, sizeof(resource_tag_tlv), 0x18b4300000000001ULL, resource_self);
     CheckDecoding(inSuite, resource1_tlv, sizeof(resource1_tlv), 0x18b4300000000001ULL, resource_self);
     // not a device type, does not get remapped
     CheckDecoding(inSuite, resource2_tlv, sizeof(resource2_tlv), 0x18b4300000000001ULL, resource2);
     // remapping a short ID
     CheckDecoding(inSuite, resource3_tlv, sizeof(resource3_tlv), 0x1ULL, resource_self);
     // not a device type, does not get remapped
     CheckDecoding(inSuite, resource_unknown_type_tlv, sizeof(resource_unknown_type_tlv), 0x18b4300000000001ULL,
                   resource_unknown_type);
 }

 static void CheckTLVDecodingErrors(nlTestSuite * inSuite, void * inContext)
 {
     const uint8_t resource_wrong_type_tlv[] = { nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS),
                                                 nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_CONTEXT_SPECIFIC(Path::kCsTag_ResourceID)),
                                                 nlWeaveTLV_UINT16(nlWeaveTLV_TAG_CONTEXT_SPECIFIC(1), 1),
                                                 nlWeaveTLV_UINT64(nlWeaveTLV_TAG_CONTEXT_SPECIFIC(2), 0x18b4300000000001ULL),
                                                 nlWeaveTLV_END_OF_CONTAINER,
                                                 nlWeaveTLV_END_OF_CONTAINER };

     const uint8_t resource_wrong_byte_array_length_tlv[] = { nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS),
                                                              nlWeaveTLV_BYTE_STRING_1ByteLength(
                                                                  nlWeaveTLV_TAG_CONTEXT_SPECIFIC(kTag_EventResourceID),
                                                                  // length:
                                                                  8,
                                                                  // ID in LE order:
                                                                  0x01, 0x00, 0x00, 0x00, 0x00, 0x30, 0xb4, 0x18),
                                                              nlWeaveTLV_END_OF_CONTAINER };
     nl::Weave::TLV::TLVReader reader;
     TLVType outer;
     WEAVE_ERROR err;
     ResourceIdentifier resource;

     // Decode a bogus encoding
     reader.Init(resource_wrong_type_tlv, sizeof(resource_wrong_type_tlv));
     reader.Next();
     reader.EnterContainer(outer);
     reader.Next();
     err = resource.FromTLV(reader);
     NL_TEST_ASSERT(inSuite, err == WEAVE_ERROR_WRONG_TLV_TYPE);

     // Decode a bogus encoding
     reader.Init(resource_wrong_byte_array_length_tlv, sizeof(resource_wrong_byte_array_length_tlv));
     reader.Next();
     reader.EnterContainer(outer);
     reader.Next();
     err = resource.FromTLV(reader);
     NL_TEST_ASSERT(inSuite, err == WEAVE_ERROR_WRONG_TLV_TYPE);
 }

 static void CheckDecoding(nlTestSuite * inSuite, const uint8_t * buffer, size_t bufferLen, ResourceIdentifier reference)
 {
     nl::Weave::TLV::TLVReader reader;
     TLVType outer;
     WEAVE_ERROR err;
     ResourceIdentifier resource;
 #if DEBUG_PRINT_ENABLE
     char buf[ResourceIdentifier::MAX_STRING_LENGTH];
 #endif

     reader.Init(buffer, bufferLen);
     reader.Next();
     reader.EnterContainer(outer);
     reader.Next();
     err = resource.FromTLV(reader);
 #if DEBUG_PRINT_ENABLE
     printf("ERR: %s\n", ErrorStr(err));
     printf("Buffer:\n");
     for (size_t i = 0; i < bufferLen; i++)
     {
         printf("%02x ", buffer[i]);
     }
     printf("\n");
     resource.ToString(buf, sizeof(buf));
     printf("ResourceId: %s\n", buf);
 #endif
     NL_TEST_ASSERT(inSuite, err == WEAVE_NO_ERROR);
     NL_TEST_ASSERT(inSuite, resource == reference);
 }

 static void CheckDecoding(nlTestSuite * inSuite, const uint8_t * buffer, size_t bufferLen, uint64_t nodeid,
                           ResourceIdentifier reference)
 {
     nl::Weave::TLV::TLVReader reader;
     TLVType outer;
     WEAVE_ERROR err;
     ResourceIdentifier resource;
 #if DEBUG_PRINT_ENABLE
     char buf[ResourceIdentifier::MAX_STRING_LENGTH];
 #endif

     reader.Init(buffer, bufferLen);
     reader.Next();
     reader.EnterContainer(outer);
     reader.Next();
     err = resource.FromTLV(reader, nodeid);

 #if DEBUG_PRINT_ENABLE
     printf("ERR: %s\n", ErrorStr(err));
     printf("Buffer:\n");
     for (size_t i = 0; i < bufferLen; i++)
     {
         printf("%02x ", buffer[i]);
     }
     printf("\n");
     resource.ToString(buf, sizeof(buf));
     printf("ResourceId: %s\n", buf);
 #endif

     NL_TEST_ASSERT(inSuite, err == WEAVE_NO_ERROR);
     NL_TEST_ASSERT(inSuite, resource == reference);
 }

 static void CheckEncoding(nlTestSuite * inSuite, ResourceIdentifier resource, const uint8_t * refBuffer, size_t refBufferLen,
                           uint8_t * buffer, size_t bufferLen)
 {
     nl::Weave::TLV::TLVWriter writer;
     WEAVE_ERROR err;
     TLVType outer;

     writer.Init(buffer, bufferLen);
     writer.StartContainer(AnonymousTag, kTLVType_Structure, outer);
     err = resource.ToTLV(writer);
     writer.EndContainer(outer);
     writer.Finalize();

 #if DEBUG_PRINT_ENABLE
     printf("ERR: %s\n", ErrorStr(err));
     printf("Wrote: %" PRIu32 " bytes, Expected: %zu bytes\n", writer.GetLengthWritten(), refBufferLen);
     printf("Wrote:\n");
     for (size_t i = 0; i < refBufferLen; i++)
     {
         printf("%02x ", buffer[i]);
     }
     printf("\n");
     printf("Expected:\n");
     for (size_t i = 0; i < refBufferLen; i++)
     {
         printf("%02x ", refBuffer[i]);
     }
     printf("\n");
 #endif
     NL_TEST_ASSERT(inSuite, err == WEAVE_NO_ERROR);
     NL_TEST_ASSERT(inSuite, writer.GetLengthWritten() == refBufferLen);
     NL_TEST_ASSERT(inSuite, memcmp(buffer, refBuffer, refBufferLen) == 0);
 }

 static void CheckEncoding(nlTestSuite * inSuite, ResourceIdentifier resource, uint64_t tag, const uint8_t * refBuffer,
                           size_t refBufferLen, uint8_t * buffer, size_t bufferLen)
 {
     nl::Weave::TLV::TLVWriter writer;
     WEAVE_ERROR err;
     TLVType outer;

     writer.Init(buffer, bufferLen);
     writer.StartContainer(AnonymousTag, kTLVType_Structure, outer);
     err = resource.ToTLV(writer, tag);
     writer.EndContainer(outer);
     writer.Finalize();

 #if DEBUG_PRINT_ENABLE
     printf("ERR: %s\n", ErrorStr(err));
     printf("Wrote: %" PRIu32 ", Expected: %zu\n", writer.GetLengthWritten(), refBufferLen);
     printf("Wrote:\n");
     for (size_t i = 0; i < refBufferLen; i++)
     {
         printf("%02x ", buffer[i]);
     }
     printf("\n");
     printf("Expected:\n");
     for (size_t i = 0; i < refBufferLen; i++)
     {
         printf("%02x ", refBuffer[i]);
     }
     printf("\n");
 #endif
     NL_TEST_ASSERT(inSuite, err == WEAVE_NO_ERROR);
     NL_TEST_ASSERT(inSuite, writer.GetLengthWritten() == refBufferLen);
     NL_TEST_ASSERT(inSuite, memcmp(buffer, refBuffer, refBufferLen) == 0);
 }

 static void CheckStringSerDes(nlTestSuite * inSuite, void * inContext)
 {
     ResourceIdentifier resource(Schema::Weave::Common::RESOURCE_TYPE_DEVICE, 0x18b4300000000001ULL);
     ResourceIdentifier resource1(0x18b4300000000001ULL);
     ResourceIdentifier resource2(Schema::Weave::Common::RESOURCE_TYPE_USER, 0x18b4300000000001ULL);
     ResourceIdentifier resource_self(ResourceIdentifier::SELF_NODE_ID);
     ResourceIdentifier resource_unknown_type(0xC001, 0x18b4300000000001ULL);
     ResourceIdentifier resource_uninitialized;

     const char * resource_str               = "DEVICE_18B4300000000001";
     const char * resource2_str              = "USER_18B4300000000001";
     const char * resource_self_str          = "RESERVED_DEVICE_SELF";
     const char * resource_uninitialized_str = "RESERVED_NOT_SPECIFIED";
     const char * resource_unknown_type_str  = "(C001)_18B4300000000001";
     const char * resource_unknown_str       = "WIDGET_18B4300000000001";

     char resource_buf[ResourceIdentifier::MAX_STRING_LENGTH];
     WEAVE_ERROR err;

     // To string conversions
     resource.ToString(resource_buf, sizeof(resource_buf));
     NL_TEST_ASSERT(inSuite, strcmp(resource_buf, resource_str) == 0);

     resource1.ToString(resource_buf, sizeof(resource_buf));
     NL_TEST_ASSERT(inSuite, strcmp(resource_buf, resource_str) == 0);

     resource2.ToString(resource_buf, sizeof(resource_buf));
     NL_TEST_ASSERT(inSuite, strcmp(resource_buf, resource2_str) == 0);

     resource_self.ToString(resource_buf, sizeof(resource_buf));
     NL_TEST_ASSERT(inSuite, strcmp(resource_buf, resource_self_str) == 0);

     resource_uninitialized.ToString(resource_buf, sizeof(resource_buf));
     NL_TEST_ASSERT(inSuite, strcmp(resource_buf, resource_uninitialized_str) == 0);

     resource_unknown_type.ToString(resource_buf, sizeof(resource_buf));
     NL_TEST_ASSERT(inSuite, strcmp(resource_buf, resource_unknown_type_str) == 0);

     // From string conversions

     err = resource_uninitialized.FromString(resource_str, sizeof(resource_str));
     NL_TEST_ASSERT(inSuite, err == WEAVE_NO_ERROR);
     NL_TEST_ASSERT(inSuite, resource_uninitialized == resource);
     NL_TEST_ASSERT(inSuite, resource_uninitialized != resource_self);

     // verify we map onto self node id
     err = resource_uninitialized.FromString(resource_str, sizeof(resource_str), 0x18b4300000000001ULL);
     NL_TEST_ASSERT(inSuite, err == WEAVE_NO_ERROR);
     NL_TEST_ASSERT(inSuite, resource_uninitialized != resource);
     NL_TEST_ASSERT(inSuite, resource_uninitialized == resource_self);

     err = resource_uninitialized.FromString(resource2_str, sizeof(resource2_str));
     NL_TEST_ASSERT(inSuite, err == WEAVE_NO_ERROR);
     NL_TEST_ASSERT(inSuite, resource_uninitialized == resource2);

     // Verify errors

     err = resource_uninitialized.FromString(resource_uninitialized_str, sizeof(resource_uninitialized_str));
     NL_TEST_ASSERT(inSuite, err == WEAVE_ERROR_INVALID_ARGUMENT);

     err = resource_uninitialized.FromString(resource_self_str, sizeof(resource_self_str));
     NL_TEST_ASSERT(inSuite, err == WEAVE_ERROR_INVALID_ARGUMENT);

     err = resource_uninitialized.FromString(resource_unknown_type_str, sizeof(resource_unknown_type_str));
     NL_TEST_ASSERT(inSuite, err == WEAVE_ERROR_INVALID_ARGUMENT);

     err = resource_uninitialized.FromString(resource_unknown_str, sizeof(resource_unknown_str));
     NL_TEST_ASSERT(inSuite, err == WEAVE_ERROR_INVALID_ARGUMENT);
 }

 static int TestSetup(void * inContext)
 {
     return (SUCCESS);
 }

 static int TestTeardown(void * inContext)
 {

     return (SUCCESS);
 }

 static const nlTest sTests[] = {
     NL_TEST_DEF("Test ResourceIdentifier -- default constructor", CheckDefaultConstructor),
     NL_TEST_DEF("Test ResourceIdentifier -- u64 constructor", CheckU64Constructor),
     NL_TEST_DEF("Test ResourceIdentifier -- Type + u64 constructor", CheckTypeU64Constructor),
     NL_TEST_DEF("Test ResourceIdentifier -- Type + byte array constructor", CheckByteArrayConstructor),
     NL_TEST_DEF("Test ResourceIdentifier -- string conversions", CheckStringSerDes),
     NL_TEST_DEF("Test ResourceIdentifier -- TLV conversions", CheckTLVSerDes),
     NL_TEST_DEF("Test ResourceIdentifier -- erroneous TLV", CheckTLVDecodingErrors),
     NL_TEST_SENTINEL(),
 };

 /**
  *  Main
  */
 int main(int argc, char * argv[])
 {
     nlTestSuite theSuite = { "weave-resource-identifier", &sTests[0], TestSetup, TestTeardown };

     // Generate machine-readable, comma-separated value (CSV) output.
     nl_test_set_output_style(OUTPUT_CSV);

     // Run test suit against one context
     nlTestRunner(&theSuite, NULL);

     return nlTestRunnerStats(&theSuite);
 }
	/*
	*
	* Copyright (c) 2018 Google LLC.
	* 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 Weave TLV implementation.
	*
	*/

	#include "ToolCommon.h"

	#include <nlbyteorder.h>
	#include <nlunit-test.h>

	#include <Weave/Core/WeaveCore.h>
	#include <Weave/Core/WeaveTLV.h>
	#include <Weave/Core/WeaveTLVDebug.hpp>
	#include <Weave/Core/WeaveTLVUtilities.hpp>
	#include <Weave/Core/WeaveTLVData.hpp>
	#include <Weave/Core/WeaveCircularTLVBuffer.h>
	#include <Weave/Support/RandUtils.h>
	#include <Weave/Support/ErrorStr.h>

	#include <Weave/Profiles/data-management/Current/WdmManagedNamespace.h>
	#include <Weave/Profiles/data-management/DataManagement.h>

	using namespace nl;
	using namespace nl::Weave::TLV;
	using namespace nl::Weave::Profiles::DataManagement;

	static void CheckDefaultConstructor(nlTestSuite * inSuite, void * inContext);
	static void CheckU64Constructor(nlTestSuite * inSuite, void * inContext);
	static void CheckTypeU64Constructor(nlTestSuite * inSuite, void * inContext);

	static void CheckByteArrayConstructor(nlTestSuite * inSuite, void * inContext);
	static void CheckTLVSerDes(nlTestSuite * inSuite, void * inContext);
	static void CheckStringSerDes(nlTestSuite * inSuite, void * inContext);
	static void CheckTLVDecodingErrors(nlTestSuite * inSuite, void * inContext);
	static void CheckEncoding(nlTestSuite * inSuite, ResourceIdentifier resource, const uint8_t * refBuffer, size_t refBufferLen,
	uint8_t * buffer, size_t bufferLen);
	static void CheckEncoding(nlTestSuite * inSuite, ResourceIdentifier resource, uint64_t tag, const uint8_t * refBuffer,
	size_t refBufferLen, uint8_t * buffer, size_t bufferLen);
	static void CheckDecoding(nlTestSuite * inSuite, const uint8_t * buffer, size_t bufferLen, ResourceIdentifier reference);
	static void CheckDecoding(nlTestSuite * inSuite, const uint8_t * buffer, size_t bufferLen, uint64_t nodeid,
	ResourceIdentifier reference);

	static void CheckDefaultConstructor(nlTestSuite * inSuite, void * inContext)
	{
	ResourceIdentifier resource;
	ResourceIdentifier resource1;
	ResourceIdentifier resource_self(ResourceIdentifier::SELF_NODE_ID);

	// Unspecified Node ID

	NL_TEST_ASSERT(inSuite, resource.GetResourceId() == kNodeIdNotSpecified);
	NL_TEST_ASSERT(inSuite, resource.GetResourceType() == ResourceIdentifier::RESOURCE_TYPE_RESERVED);
	// it is different than a self node ID
	NL_TEST_ASSERT(inSuite, resource != resource_self);
	// it is equal to other uninitialized resources
	NL_TEST_ASSERT(inSuite, resource == resource1);
	}

	static void CheckU64Constructor(nlTestSuite * inSuite, void * inContext)
	{
	ResourceIdentifier resource(0x18b4300000000001ULL);
	ResourceIdentifier resource1(0x18b4300000000001ULL);
	ResourceIdentifier resource2(1ULL);
	ResourceIdentifier resource_self(ResourceIdentifier::SELF_NODE_ID);
	const char resource_type_string[] = "DEVICE";

	NL_TEST_ASSERT(inSuite, resource.GetResourceId() == 0x18b4300000000001ULL);
	NL_TEST_ASSERT(inSuite, resource.GetResourceType() == Schema::Weave::Common::RESOURCE_TYPE_DEVICE);
	NL_TEST_ASSERT(inSuite, strncmp(resource.ResourceTypeAsString(), resource_type_string, sizeof(resource_type_string)) == 0);

	// it is equal to another resource initialized in the same manner
	NL_TEST_ASSERT(inSuite, resource == resource1);

	// it is different than a self node ID
	NL_TEST_ASSERT(inSuite, resource != resource_self);
	}

	static void CheckTypeU64Constructor(nlTestSuite * inSuite, void * inContext)
	{
	ResourceIdentifier resource(Schema::Weave::Common::RESOURCE_TYPE_DEVICE, 0x18b4300000000001ULL);
	ResourceIdentifier resource1(0x18b4300000000001ULL);
	ResourceIdentifier resource2(Schema::Weave::Common::RESOURCE_TYPE_USER, 0x18b4300000000001ULL);
	ResourceIdentifier resource_self(ResourceIdentifier::SELF_NODE_ID);

	NL_TEST_ASSERT(inSuite, resource.GetResourceId() == 0x18b4300000000001ULL);
	NL_TEST_ASSERT(inSuite, resource.GetResourceType() == Schema::Weave::Common::RESOURCE_TYPE_DEVICE);

	// it is equal to another resource initialized just by u64
	NL_TEST_ASSERT(inSuite, resource == resource1);

	// it is different than a self node ID
	NL_TEST_ASSERT(inSuite, resource != resource_self);
	// it is different from a resource of the same ID with a different type
	NL_TEST_ASSERT(inSuite, resource != resource2);
	}

	static void CheckByteArrayConstructor(nlTestSuite * inSuite, void * inContext)
	{
	uint64_t id1 = 0x18b4300000000001ULL;
	const uint8_t id2[] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x30, 0xb4, 0x18 };
	ResourceIdentifier resource(0x18b4300000000001ULL);
	ResourceIdentifier resource1(Schema::Weave::Common::RESOURCE_TYPE_DEVICE, (uint8_t *) &id1, sizeof(id1));
	ResourceIdentifier resource2(Schema::Weave::Common::RESOURCE_TYPE_DEVICE, id2, sizeof(id2));
	}

	static void CheckTLVSerDes(nlTestSuite * inSuite, void * inContext)
	{
	ResourceIdentifier resource(Schema::Weave::Common::RESOURCE_TYPE_DEVICE, 0x18b4300000000001ULL);
	ResourceIdentifier resource1(0x18b4300000000001ULL);
	ResourceIdentifier resource2(Schema::Weave::Common::RESOURCE_TYPE_USER, 0x18b4300000000001ULL);
	ResourceIdentifier resource3(0x1ULL);
	ResourceIdentifier resource_self(ResourceIdentifier::SELF_NODE_ID);
	ResourceIdentifier resource_unknown_type(0xC001, 0x18b4300000000001ULL);
	ResourceIdentifier resource_uninitialized;

	const uint8_t resource_tlv[] = { nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS),
	nlWeaveTLV_BYTE_STRING_1ByteLength(nlWeaveTLV_TAG_CONTEXT_SPECIFIC(Path::kCsTag_ResourceID),
	// length:
	10,
	// type
	0x01, 0x00,
	// ID in LE order:
	0x01, 0x00, 0x00, 0x00, 0x00, 0x30, 0xb4, 0x18),
	nlWeaveTLV_END_OF_CONTAINER };

	const uint8_t resource_tag_tlv[] = { nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS),
	nlWeaveTLV_BYTE_STRING_1ByteLength(nlWeaveTLV_TAG_CONTEXT_SPECIFIC(kTag_EventResourceID),
	// length:
	10,
	// type
	0x01, 0x00,
	// ID in LE order:
	0x01, 0x00, 0x00, 0x00, 0x00, 0x30, 0xb4, 0x18),
	nlWeaveTLV_END_OF_CONTAINER };

	const uint8_t resource1_tlv[] = { nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS),
	nlWeaveTLV_UINT64(nlWeaveTLV_TAG_CONTEXT_SPECIFIC(Path::kCsTag_ResourceID),
	0x18b4300000000001ULL),
	nlWeaveTLV_END_OF_CONTAINER };

	const uint8_t resource1_tag_tlv[] = {
	nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS),
	nlWeaveTLV_UINT64(nlWeaveTLV_TAG_CONTEXT_SPECIFIC(kTag_EventResourceID), 0x18b4300000000001ULL), nlWeaveTLV_END_OF_CONTAINER
	};

	const uint8_t resource2_tlv[] = { nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS),
	nlWeaveTLV_BYTE_STRING_1ByteLength(nlWeaveTLV_TAG_CONTEXT_SPECIFIC(Path::kCsTag_ResourceID),
	// length:
	10,
	// type
	0x02, 0x00,
	// ID in LE order:
	0x01, 0x00, 0x00, 0x00, 0x00, 0x30, 0xb4, 0x18),
	nlWeaveTLV_END_OF_CONTAINER };

	const uint8_t resource_self_tlv[] = { nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS), nlWeaveTLV_END_OF_CONTAINER };

	const uint8_t resource3_tlv[] = { nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS),
	nlWeaveTLV_UINT8(nlWeaveTLV_TAG_CONTEXT_SPECIFIC(Path::kCsTag_ResourceID), 0x1),
	nlWeaveTLV_END_OF_CONTAINER };

	const uint8_t resource_unknown_type_tlv[] = { nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS),
	nlWeaveTLV_BYTE_STRING_1ByteLength(
	nlWeaveTLV_TAG_CONTEXT_SPECIFIC(Path::kCsTag_ResourceID),
	// length:
	10,
	// type
	0x01, 0xc0,
	// ID in LE order:
	0x01, 0x00, 0x00, 0x00, 0x00, 0x30, 0xb4, 0x18),
	nlWeaveTLV_END_OF_CONTAINER };

	uint8_t buffer[1024];

	// ENCODING

	// resource gets encoded as resource1_tlv
	CheckEncoding(inSuite, resource, resource1_tlv, sizeof(resource1_tlv), buffer, sizeof(buffer));
	// resource1 gets encoded as resource1_tlv
	CheckEncoding(inSuite, resource1, resource1_tlv, sizeof(resource1_tlv), buffer, sizeof(buffer));
	// resource2 gets encoded as resource2
	CheckEncoding(inSuite, resource2, resource2_tlv, sizeof(resource2_tlv), buffer, sizeof(buffer));
	// resource_unknown_type gets encoded as resource_unknown_type_tlv
	CheckEncoding(inSuite, resource_unknown_type, resource_unknown_type_tlv, sizeof(resource_unknown_type_tlv), buffer,
	sizeof(buffer));
	// resource_self gets encoded as resource_self_tlv
	CheckEncoding(inSuite, resource_self, resource_self_tlv, sizeof(resource_self_tlv), buffer, sizeof(buffer));

	// encoding with a different tag
	CheckEncoding(inSuite, resource, ContextTag(kTag_EventResourceID), resource1_tag_tlv, sizeof(resource1_tag_tlv), buffer,
	sizeof(buffer));

	// DECODING
	CheckDecoding(inSuite, resource_tlv, sizeof(resource_tlv), resource);
	CheckDecoding(inSuite, resource_tag_tlv, sizeof(resource_tag_tlv), resource);
	CheckDecoding(inSuite, resource1_tlv, sizeof(resource1_tlv), resource1);
	CheckDecoding(inSuite, resource2_tlv, sizeof(resource2_tlv), resource2);
	CheckDecoding(inSuite, resource3_tlv, sizeof(resource3_tlv), resource3);
	CheckDecoding(inSuite, resource_unknown_type_tlv, sizeof(resource_unknown_type_tlv), resource_unknown_type);

	// mapping onto self
	CheckDecoding(inSuite, resource_tlv, sizeof(resource_tlv), 0x18b4300000000001ULL, resource_self);
	CheckDecoding(inSuite, resource_tag_tlv, sizeof(resource_tag_tlv), 0x18b4300000000001ULL, resource_self);
	CheckDecoding(inSuite, resource1_tlv, sizeof(resource1_tlv), 0x18b4300000000001ULL, resource_self);
	// not a device type, does not get remapped
	CheckDecoding(inSuite, resource2_tlv, sizeof(resource2_tlv), 0x18b4300000000001ULL, resource2);
	// remapping a short ID
	CheckDecoding(inSuite, resource3_tlv, sizeof(resource3_tlv), 0x1ULL, resource_self);
	// not a device type, does not get remapped
	CheckDecoding(inSuite, resource_unknown_type_tlv, sizeof(resource_unknown_type_tlv), 0x18b4300000000001ULL,
	resource_unknown_type);
	}

	static void CheckTLVDecodingErrors(nlTestSuite * inSuite, void * inContext)
	{
	const uint8_t resource_wrong_type_tlv[] = { nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS),
	nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_CONTEXT_SPECIFIC(Path::kCsTag_ResourceID)),
	nlWeaveTLV_UINT16(nlWeaveTLV_TAG_CONTEXT_SPECIFIC(1), 1),
	nlWeaveTLV_UINT64(nlWeaveTLV_TAG_CONTEXT_SPECIFIC(2), 0x18b4300000000001ULL),
	nlWeaveTLV_END_OF_CONTAINER,
	nlWeaveTLV_END_OF_CONTAINER };

	const uint8_t resource_wrong_byte_array_length_tlv[] = { nlWeaveTLV_STRUCTURE(nlWeaveTLV_TAG_ANONYMOUS),
	nlWeaveTLV_BYTE_STRING_1ByteLength(
	nlWeaveTLV_TAG_CONTEXT_SPECIFIC(kTag_EventResourceID),
	// length:
	8,
	// ID in LE order:
	0x01, 0x00, 0x00, 0x00, 0x00, 0x30, 0xb4, 0x18),
	nlWeaveTLV_END_OF_CONTAINER };
	nl::Weave::TLV::TLVReader reader;
	TLVType outer;
	WEAVE_ERROR err;
	ResourceIdentifier resource;

	// Decode a bogus encoding
	reader.Init(resource_wrong_type_tlv, sizeof(resource_wrong_type_tlv));
	reader.Next();
	reader.EnterContainer(outer);
	reader.Next();
	err = resource.FromTLV(reader);
	NL_TEST_ASSERT(inSuite, err == WEAVE_ERROR_WRONG_TLV_TYPE);

	// Decode a bogus encoding
	reader.Init(resource_wrong_byte_array_length_tlv, sizeof(resource_wrong_byte_array_length_tlv));
	reader.Next();
	reader.EnterContainer(outer);
	reader.Next();
	err = resource.FromTLV(reader);
	NL_TEST_ASSERT(inSuite, err == WEAVE_ERROR_WRONG_TLV_TYPE);
	}

	static void CheckDecoding(nlTestSuite * inSuite, const uint8_t * buffer, size_t bufferLen, ResourceIdentifier reference)
	{
	nl::Weave::TLV::TLVReader reader;
	TLVType outer;
	WEAVE_ERROR err;
	ResourceIdentifier resource;
	#if DEBUG_PRINT_ENABLE
	char buf[ResourceIdentifier::MAX_STRING_LENGTH];
	#endif

	reader.Init(buffer, bufferLen);
	reader.Next();
	reader.EnterContainer(outer);
	reader.Next();
	err = resource.FromTLV(reader);
	#if DEBUG_PRINT_ENABLE
	printf("ERR: %s\n", ErrorStr(err));
	printf("Buffer:\n");
	for (size_t i = 0; i < bufferLen; i++)
	{
	printf("%02x ", buffer[i]);
	}
	printf("\n");
	resource.ToString(buf, sizeof(buf));
	printf("ResourceId: %s\n", buf);
	#endif
	NL_TEST_ASSERT(inSuite, err == WEAVE_NO_ERROR);
	NL_TEST_ASSERT(inSuite, resource == reference);
	}

	static void CheckDecoding(nlTestSuite * inSuite, const uint8_t * buffer, size_t bufferLen, uint64_t nodeid,
	ResourceIdentifier reference)
	{
	nl::Weave::TLV::TLVReader reader;
	TLVType outer;
	WEAVE_ERROR err;
	ResourceIdentifier resource;
	#if DEBUG_PRINT_ENABLE
	char buf[ResourceIdentifier::MAX_STRING_LENGTH];
	#endif

	reader.Init(buffer, bufferLen);
	reader.Next();
	reader.EnterContainer(outer);
	reader.Next();
	err = resource.FromTLV(reader, nodeid);

	#if DEBUG_PRINT_ENABLE
	printf("ERR: %s\n", ErrorStr(err));
	printf("Buffer:\n");
	for (size_t i = 0; i < bufferLen; i++)
	{
	printf("%02x ", buffer[i]);
	}
	printf("\n");
	resource.ToString(buf, sizeof(buf));
	printf("ResourceId: %s\n", buf);
	#endif

	NL_TEST_ASSERT(inSuite, err == WEAVE_NO_ERROR);
	NL_TEST_ASSERT(inSuite, resource == reference);
	}

	static void CheckEncoding(nlTestSuite * inSuite, ResourceIdentifier resource, const uint8_t * refBuffer, size_t refBufferLen,
	uint8_t * buffer, size_t bufferLen)
	{
	nl::Weave::TLV::TLVWriter writer;
	WEAVE_ERROR err;
	TLVType outer;

	writer.Init(buffer, bufferLen);
	writer.StartContainer(AnonymousTag, kTLVType_Structure, outer);
	err = resource.ToTLV(writer);
	writer.EndContainer(outer);
	writer.Finalize();

	#if DEBUG_PRINT_ENABLE
	printf("ERR: %s\n", ErrorStr(err));
	printf("Wrote: %" PRIu32 " bytes, Expected: %zu bytes\n", writer.GetLengthWritten(), refBufferLen);
	printf("Wrote:\n");
	for (size_t i = 0; i < refBufferLen; i++)
	{
	printf("%02x ", buffer[i]);
	}
	printf("\n");
	printf("Expected:\n");
	for (size_t i = 0; i < refBufferLen; i++)
	{
	printf("%02x ", refBuffer[i]);
	}
	printf("\n");
	#endif
	NL_TEST_ASSERT(inSuite, err == WEAVE_NO_ERROR);
	NL_TEST_ASSERT(inSuite, writer.GetLengthWritten() == refBufferLen);
	NL_TEST_ASSERT(inSuite, memcmp(buffer, refBuffer, refBufferLen) == 0);
	}

	static void CheckEncoding(nlTestSuite * inSuite, ResourceIdentifier resource, uint64_t tag, const uint8_t * refBuffer,
	size_t refBufferLen, uint8_t * buffer, size_t bufferLen)
	{
	nl::Weave::TLV::TLVWriter writer;
	WEAVE_ERROR err;
	TLVType outer;

	writer.Init(buffer, bufferLen);
	writer.StartContainer(AnonymousTag, kTLVType_Structure, outer);
	err = resource.ToTLV(writer, tag);
	writer.EndContainer(outer);
	writer.Finalize();

	#if DEBUG_PRINT_ENABLE
	printf("ERR: %s\n", ErrorStr(err));
	printf("Wrote: %" PRIu32 ", Expected: %zu\n", writer.GetLengthWritten(), refBufferLen);
	printf("Wrote:\n");
	for (size_t i = 0; i < refBufferLen; i++)
	{
	printf("%02x ", buffer[i]);
	}
	printf("\n");
	printf("Expected:\n");
	for (size_t i = 0; i < refBufferLen; i++)
	{
	printf("%02x ", refBuffer[i]);
	}
	printf("\n");
	#endif
	NL_TEST_ASSERT(inSuite, err == WEAVE_NO_ERROR);
	NL_TEST_ASSERT(inSuite, writer.GetLengthWritten() == refBufferLen);
	NL_TEST_ASSERT(inSuite, memcmp(buffer, refBuffer, refBufferLen) == 0);
	}

	static void CheckStringSerDes(nlTestSuite * inSuite, void * inContext)
	{
	ResourceIdentifier resource(Schema::Weave::Common::RESOURCE_TYPE_DEVICE, 0x18b4300000000001ULL);
	ResourceIdentifier resource1(0x18b4300000000001ULL);
	ResourceIdentifier resource2(Schema::Weave::Common::RESOURCE_TYPE_USER, 0x18b4300000000001ULL);
	ResourceIdentifier resource_self(ResourceIdentifier::SELF_NODE_ID);
	ResourceIdentifier resource_unknown_type(0xC001, 0x18b4300000000001ULL);
	ResourceIdentifier resource_uninitialized;

	const char * resource_str = "DEVICE_18B4300000000001";
	const char * resource2_str = "USER_18B4300000000001";
	const char * resource_self_str = "RESERVED_DEVICE_SELF";
	const char * resource_uninitialized_str = "RESERVED_NOT_SPECIFIED";
	const char * resource_unknown_type_str = "(C001)_18B4300000000001";
	const char * resource_unknown_str = "WIDGET_18B4300000000001";

	char resource_buf[ResourceIdentifier::MAX_STRING_LENGTH];
	WEAVE_ERROR err;

	// To string conversions
	resource.ToString(resource_buf, sizeof(resource_buf));
	NL_TEST_ASSERT(inSuite, strcmp(resource_buf, resource_str) == 0);

	resource1.ToString(resource_buf, sizeof(resource_buf));
	NL_TEST_ASSERT(inSuite, strcmp(resource_buf, resource_str) == 0);

	resource2.ToString(resource_buf, sizeof(resource_buf));
	NL_TEST_ASSERT(inSuite, strcmp(resource_buf, resource2_str) == 0);

	resource_self.ToString(resource_buf, sizeof(resource_buf));
	NL_TEST_ASSERT(inSuite, strcmp(resource_buf, resource_self_str) == 0);

	resource_uninitialized.ToString(resource_buf, sizeof(resource_buf));
	NL_TEST_ASSERT(inSuite, strcmp(resource_buf, resource_uninitialized_str) == 0);

	resource_unknown_type.ToString(resource_buf, sizeof(resource_buf));
	NL_TEST_ASSERT(inSuite, strcmp(resource_buf, resource_unknown_type_str) == 0);

	// From string conversions

	err = resource_uninitialized.FromString(resource_str, sizeof(resource_str));
	NL_TEST_ASSERT(inSuite, err == WEAVE_NO_ERROR);
	NL_TEST_ASSERT(inSuite, resource_uninitialized == resource);
	NL_TEST_ASSERT(inSuite, resource_uninitialized != resource_self);

	// verify we map onto self node id
	err = resource_uninitialized.FromString(resource_str, sizeof(resource_str), 0x18b4300000000001ULL);
	NL_TEST_ASSERT(inSuite, err == WEAVE_NO_ERROR);
	NL_TEST_ASSERT(inSuite, resource_uninitialized != resource);
	NL_TEST_ASSERT(inSuite, resource_uninitialized == resource_self);

	err = resource_uninitialized.FromString(resource2_str, sizeof(resource2_str));
	NL_TEST_ASSERT(inSuite, err == WEAVE_NO_ERROR);
	NL_TEST_ASSERT(inSuite, resource_uninitialized == resource2);

	// Verify errors

	err = resource_uninitialized.FromString(resource_uninitialized_str, sizeof(resource_uninitialized_str));
	NL_TEST_ASSERT(inSuite, err == WEAVE_ERROR_INVALID_ARGUMENT);

	err = resource_uninitialized.FromString(resource_self_str, sizeof(resource_self_str));
	NL_TEST_ASSERT(inSuite, err == WEAVE_ERROR_INVALID_ARGUMENT);

	err = resource_uninitialized.FromString(resource_unknown_type_str, sizeof(resource_unknown_type_str));
	NL_TEST_ASSERT(inSuite, err == WEAVE_ERROR_INVALID_ARGUMENT);

	err = resource_uninitialized.FromString(resource_unknown_str, sizeof(resource_unknown_str));
	NL_TEST_ASSERT(inSuite, err == WEAVE_ERROR_INVALID_ARGUMENT);
	}

	static int TestSetup(void * inContext)
	{
	return (SUCCESS);
	}

	static int TestTeardown(void * inContext)
	{

	return (SUCCESS);
	}

	static const nlTest sTests[] = {
	NL_TEST_DEF("Test ResourceIdentifier -- default constructor", CheckDefaultConstructor),
	NL_TEST_DEF("Test ResourceIdentifier -- u64 constructor", CheckU64Constructor),
	NL_TEST_DEF("Test ResourceIdentifier -- Type + u64 constructor", CheckTypeU64Constructor),
	NL_TEST_DEF("Test ResourceIdentifier -- Type + byte array constructor", CheckByteArrayConstructor),
	NL_TEST_DEF("Test ResourceIdentifier -- string conversions", CheckStringSerDes),
	NL_TEST_DEF("Test ResourceIdentifier -- TLV conversions", CheckTLVSerDes),
	NL_TEST_DEF("Test ResourceIdentifier -- erroneous TLV", CheckTLVDecodingErrors),
	NL_TEST_SENTINEL(),
	};

	/**
	* Main
	*/
	int main(int argc, char * argv[])
	{
	nlTestSuite theSuite = { "weave-resource-identifier", &sTests[0], TestSetup, TestTeardown };

	// Generate machine-readable, comma-separated value (CSV) output.
	nl_test_set_output_style(OUTPUT_CSV);

	// Run test suit against one context
	nlTestRunner(&theSuite, NULL);

	return nlTestRunnerStats(&theSuite);
	}