weave/src/test-apps/MockTestBTrait.cpp - nest-cam/4320010/weave - Git at Google

 /*
  *
  *    Copyright (c) 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 TestB Sink and Source for use in TestTDM.
  */

 // Note that the choice of namespace alias must be made up front for each and every compile unit
 // This is because many include paths could set the default alias to unintended target.
 #include <Weave/Profiles/bulk-data-transfer/Development/BDXManagedNamespace.hpp>
 #include <Weave/Profiles/data-management/Current/WdmManagedNamespace.h>

 #include <Weave/Support/CodeUtils.h>
 #include "MockTestBTrait.h"

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

 using namespace Schema::Nest::Test::Trait;

 #define MAX_ARRAY_LEN 10

 TestBTraitDataSource::TestBTraitDataSource(void)
     : TraitDataSource(&TestBTrait::TraitSchema),
     tag_use_ref(false)
 {
 }

 void TestBTraitDataSource::Reset(void)
 {
     mVersion = 200;
     taa = TestATrait::ENUM_A_VALUE_1;
     tab = TestCommonTrait::COMMON_ENUM_A_VALUE_1;
     tac = 3;
     tad_saa = 4;
     tad_sab = true;

     for (size_t i = 0; i < (sizeof(tae) / sizeof(tae[0])); i++) {
         tae[i] = i + 5;
     }

     tba = 200;
     tbb_sbb = 201;
     tag_use_ref = !tag_use_ref;
     tag_ref = 10;
     tam_resourceid = 0x18b4300000beefULL;

     tap = 1491859262000;

     taq = -3000;
     tar = 3000;
     tas = 3000;

     tbc_saa = 202;
     tbc_sab = false;

     memset(nullified_path, false, sizeof(nullified_path));
     memset(ephemeral_path, true, sizeof(ephemeral_path));
 }


 WEAVE_ERROR TestBTraitDataSource::GetData(PropertyPathHandle aHandle,
                                           uint64_t aTagToWrite,
                                           TLVWriter &aWriter,
                                           bool &aIsNull,
                                           bool &aIsPresent)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     switch (aHandle)
     {
         // only handle nullable path handles
         // if the handle is a leaf, we should call GetLeafData
         case TestBTrait::kPropertyHandle_TaD:
             aIsNull = nullified_path[aHandle - 1];
             aIsPresent = ephemeral_path[aHandle - 1];
             break;

         default:
             aIsNull = nullified_path[aHandle - 1];
             aIsPresent = ephemeral_path[aHandle - 1];
             break;
     }

     // TDM will handle writing null
     if ((!aIsNull) && (aIsPresent) && (mSchemaEngine->IsLeaf(aHandle)))
     {
         err = GetLeafData(aHandle, aTagToWrite, aWriter);
     }

     return err;
 }

 void TestBTraitDataSource::SetNullifiedPath(PropertyPathHandle aHandle, bool isNull)
 {
     if (aHandle <= TestBTrait::kPropertyHandle_TaJ_Value_SaB)
     {
         if (nullified_path[aHandle - 1] != isNull)
         {
             nullified_path[aHandle - 1] = isNull;
             IncrementVersion();
         }
     }
 }

 void TestBTraitDataSource::SetPresentPath(PropertyPathHandle aHandle, bool isPresent)
 {
     if (aHandle <= TestBTrait::kPropertyHandle_TaJ_Value_SaB)
     {
         if (ephemeral_path[aHandle - 1] != isPresent)
         {
             ephemeral_path[aHandle - 1] = isPresent;
             IncrementVersion();
         }
     }
 }

 WEAVE_ERROR TestBTraitDataSource::SetLeafData(PropertyPathHandle aLeafHandle, TLVReader &aReader)
 {
     return WEAVE_ERROR_UNSUPPORTED_WEAVE_FEATURE;
 }

 WEAVE_ERROR TestBTraitDataSource::GetLeafData(PropertyPathHandle aLeafHandle, uint64_t aTagToWrite, TLVWriter &aWriter)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     switch (aLeafHandle) {
         //
         // TestATrait
         //

         case TestBTrait::kPropertyHandle_TaA:
             err = aWriter.Put(aTagToWrite, taa);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, ">>  ta_a = %u", taa);
             break;

         case TestBTrait::kPropertyHandle_TaB:
             err = aWriter.Put(aTagToWrite, tab);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, ">>  ta_b = %u", tab);
             break;

         case TestBTrait::kPropertyHandle_TaC:
             err = aWriter.Put(aTagToWrite, tac);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, ">>  ta_c = %u", tac);
             break;

         case TestBTrait::kPropertyHandle_TaD_SaA:
             if (nullified_path[aLeafHandle - 1])
             {
                 err = aWriter.PutNull(aTagToWrite);
                 SuccessOrExit(err);
             }
             else if (ephemeral_path[aLeafHandle - 1] == false)
             {
                 /* no op */
             }
             else
             {
                 err = aWriter.Put(aTagToWrite, tad_saa);
                 SuccessOrExit(err);
             }

             WeaveLogDetail(DataManagement, ">>  ta_d.sa_a = %u, null = %s", tad_saa, nullified_path[aLeafHandle - 1] ? "true" : "false");
             break;

         case TestBTrait::kPropertyHandle_TaD_SaB:
             err = aWriter.PutBoolean(aTagToWrite, tad_sab);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, ">>  ta_d.sa_b = %s", tad_sab ? "true" : "false");
             break;

         case TestBTrait::kPropertyHandle_TaE:
         {
             TLVType outerType;

             err = aWriter.StartContainer(aTagToWrite, kTLVType_Array, outerType);
             SuccessOrExit(err);

             for (size_t i = 0; i < (sizeof(tae) / sizeof(tae[0])); i++) {
                 err = aWriter.Put(AnonymousTag, tae[i]);
                 SuccessOrExit(err);

                 WeaveLogDetail(DataManagement, ">>  ta_e[%u] = %u", i, tae[i]);
             }

             err = aWriter.EndContainer(outerType);
             break;
         }

         case TestBTrait::kPropertyHandle_TaG:
             if (tag_use_ref)
             {
                 err = aWriter.Put(aTagToWrite, tag_ref);
                 SuccessOrExit(err);

                 WeaveLogDetail(DataManagement, ">>  ta_g.ref = %u", tag_ref);
             }
             else
             {
                 err = aWriter.PutString(aTagToWrite, tag_string);
                 SuccessOrExit(err);

                 WeaveLogDetail(DataManagement, ">>  ta_g.string = %s", tag_string);
             }
             break;

         case TestBTrait::kPropertyHandle_TaL:
         {
             TLVType outerType;
             tal = 0;

             err = aWriter.StartContainer(aTagToWrite, kTLVType_Array, outerType);
             SuccessOrExit(err);

             for (size_t i = 0; i < 7; i++)
             {
                 tal = (1 << i);
                 err = aWriter.Put(AnonymousTag, tal);
                 SuccessOrExit(err);

                 WeaveLogDetail(DataManagement, ">> tal[%u] = %u", i, tal);
             }

             err = aWriter.EndContainer(outerType);
             break;
         }

         case TestBTrait::kPropertyHandle_TaM:
             err = aWriter.Put(aTagToWrite, tam_resourceid);
             SuccessOrExit(err);
             break;

         case TestBTrait::kPropertyHandle_TaN:
         {
             uint8_t *tmp = &tan[0];
             nl::Weave::Encoding::LittleEndian::Write16(tmp, 1);
             nl::Weave::Encoding::LittleEndian::Write64(tmp, tam_resourceid);
             err = aWriter.PutBytes(aTagToWrite, &tan[0], sizeof(tan));
             SuccessOrExit(err);
             break;
         }

         case TestATrait::kPropertyHandle_TaP:
             aWriter.Put(aTagToWrite, tap);
             SuccessOrExit(err);
             break;

         case TestBTrait::kPropertyHandle_TaQ:
             aWriter.Put(aTagToWrite, taq);
             SuccessOrExit(err);
             break;

         case TestBTrait::kPropertyHandle_TaR:
             aWriter.Put(aTagToWrite, tar);
             SuccessOrExit(err);
             break;

         case TestBTrait::kPropertyHandle_TaS:
             aWriter.Put(aTagToWrite, tas);
             SuccessOrExit(err);
             break;

         case TestBTrait::kPropertyHandle_TaW:
             aWriter.PutString(aTagToWrite, taw);
             SuccessOrExit(err);
             break;


         //
         // TestBTrait
         //

         case TestBTrait::kPropertyHandle_TbA:
             err = aWriter.Put(aTagToWrite, tba);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, ">>  tb_a = %u", tba);
             break;

         case TestBTrait::kPropertyHandle_TbB_SbA:
             err = aWriter.PutString(aTagToWrite, tbb_sba);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, ">>  tb_b.sb_a = \"%s\"", tbb_sba);
             break;

         case TestBTrait::kPropertyHandle_TbB_SbB:
             err = aWriter.Put(aTagToWrite, tbb_sbb);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, ">>  tb_b.sb_b = %u", tbb_sbb);
             break;

         case TestBTrait::kPropertyHandle_TbC_SaA:
             err = aWriter.Put(aTagToWrite, tbc_saa);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, ">>  tb_c.sa_a = %u", tbc_saa);
             break;

         case TestBTrait::kPropertyHandle_TbC_SaB:
             err = aWriter.PutBoolean(aTagToWrite, tbc_sab);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, ">>  tb_c.sa_b = %s", tbc_sab ? "true" : "false");
             break;

         case TestBTrait::kPropertyHandle_TbC_SeaC:
             err = aWriter.PutString(aTagToWrite, tbc_seac);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, ">>  tb_c.sea_c = %u", tbc_seac);
             break;

         default:
             WeaveLogDetail(DataManagement, ">> %u  UNKNOWN!", aLeafHandle);
     }

 exit:
     WeaveLogFunctError(err);
     return err;
 }

 WEAVE_ERROR TestBTraitDataSource::GetNextDictionaryItemKey(PropertyPathHandle aDictionaryHandle, uintptr_t &aContext, PropertyDictionaryKey &aKey)
 {
     return WEAVE_END_OF_INPUT;
 }

 TestBTraitDataSink::TestBTraitDataSink()
     : TraitDataSink(&TestBTrait::TraitSchema)
 {
 }

 void TestBTraitDataSink::Reset(void)
 {
     ClearVersion();

     memset(set_path, 0, sizeof(set_path));
     memset(nullified_path, 0, sizeof(nullified_path));
 }

 void TestBTraitDataSink::SetDataCalled(PropertyPathHandle aHandle)
 {
     if (aHandle <= TestBTrait::kPropertyHandle_TaJ_Value_SaB)
     {
         set_path[aHandle - 1] = true;
     }
 }

 void TestBTraitDataSink::SetPathHandleNull(PropertyPathHandle aHandle, bool aIsNull)
 {
     if (aHandle <= TestBTrait::kPropertyHandle_TaJ_Value_SaB)
     {
         nullified_path[aHandle - 1] = aIsNull;
     }
 }

 bool TestBTraitDataSink::IsPathHandleSet(PropertyPathHandle aHandle)
 {
     bool retval = false;
     if (aHandle <= TestBTrait::kPropertyHandle_TaJ_Value_SaB)
     {
         retval = set_path[aHandle - 1];
     }
     return retval;
 }

 bool TestBTraitDataSink::IsPathHandleNull(PropertyPathHandle aHandle)
 {
     bool retval = false;
     if (aHandle <= TestBTrait::kPropertyHandle_TaJ_Value_SaB)
     {
         retval = nullified_path[aHandle - 1];
     }
     return retval;
 }

 WEAVE_ERROR
 TestBTraitDataSink::SetData(PropertyPathHandle aHandle, TLVReader &aReader, bool aIsNull)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     SetDataCalled(aHandle);
     SetPathHandleNull(aHandle, aIsNull);

     if ((!aIsNull) && (mSchemaEngine->IsLeaf(aHandle)))
     {
         err = SetLeafData(aHandle, aReader);
     }
     return err;
 }

 WEAVE_ERROR
 TestBTraitDataSink::SetLeafData(PropertyPathHandle aLeafHandle, TLVReader &aReader)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     SetDataCalled(aLeafHandle);

     switch (aLeafHandle) {
         //
         // TestATrait
         //

         case TestBTrait::kPropertyHandle_TaA:
             err = aReader.Get(taa);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, "<< ta_a = %u", taa);
             break;

         case TestBTrait::kPropertyHandle_TaB:
             err = aReader.Get(tab);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, "<< ta_b = %u", tab);
             break;

         case TestBTrait::kPropertyHandle_TaC:
             err = aReader.Get(tac);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, "<< ta_c = %u", tac);
             break;

         case TestBTrait::kPropertyHandle_TaD_SaA:
             err = aReader.Get(tad_saa);
             SuccessOrExit(err);
             SetPathHandleNull(aLeafHandle, false);
             // the parent of this field is also now non-null
             SetPathHandleNull(TestBTrait::kPropertyHandle_TaD, false);

             WeaveLogDetail(DataManagement, "<< ta_d.sa_a = %u", tad_saa);

             break;

         case TestBTrait::kPropertyHandle_TaD_SaB:
             err = aReader.Get(tad_sab);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, "<< ta_d.sa_b = %u", tad_sab);
             break;

         case TestBTrait::kPropertyHandle_TaE:
         {
             TLVType outerType;
             uint32_t i = 0;

             err = aReader.EnterContainer(outerType);
             SuccessOrExit(err);

             while (((err = aReader.Next()) == WEAVE_NO_ERROR) && (i < (sizeof(tae) / sizeof(tae[0]))))
             {
                 err = aReader.Get(tae[i]);
                 SuccessOrExit(err);

                 WeaveLogDetail(DataManagement, "<< ta_e[%u] = %u", i, tae[i]);
                 i++;
             }

             err = aReader.ExitContainer(outerType);
             break;
         }

         //
         // TestBTrait
         //

         case TestBTrait::kPropertyHandle_TbA:
             err = aReader.Get(tba);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, "<< tb_a = %u", tba);
             break;

         case TestBTrait::kPropertyHandle_TbB_SbA:
             err = aReader.GetString(tbb_sba, MAX_ARRAY_LEN);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, "<< tb_b.sb_a = %s", tbb_sba);
             break;

         case TestBTrait::kPropertyHandle_TbB_SbB:
             err = aReader.Get(tbb_sbb);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, "<< tb_b.sb_b = %u", tbb_sbb);
             break;

         case TestBTrait::kPropertyHandle_TbC_SaA:
             err = aReader.Get(tbc_saa);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, "<< tb_c.sa_a = %u", tbc_saa);
             break;

         case TestBTrait::kPropertyHandle_TbC_SaB:
             err = aReader.Get(tbc_sab);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, "<< tb_c.sa_b = %u", tbc_sab);
             break;

         case TestBTrait::kPropertyHandle_TbC_SeaC:
             err = aReader.GetString(tbc_seac, MAX_ARRAY_LEN);
             SuccessOrExit(err);

             WeaveLogDetail(DataManagement, "<< tb_c.sea_c = \"%s\"", tbc_seac);
             break;

         default:
             WeaveLogDetail(DataManagement, "<< UNKNOWN!");
     }

 exit:
     return err;
 }
	/*
	*
	* Copyright (c) 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 TestB Sink and Source for use in TestTDM.
	*/

	// Note that the choice of namespace alias must be made up front for each and every compile unit
	// This is because many include paths could set the default alias to unintended target.
	#include <Weave/Profiles/bulk-data-transfer/Development/BDXManagedNamespace.hpp>
	#include <Weave/Profiles/data-management/Current/WdmManagedNamespace.h>

	#include <Weave/Support/CodeUtils.h>
	#include "MockTestBTrait.h"

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

	using namespace Schema::Nest::Test::Trait;

	#define MAX_ARRAY_LEN 10

	TestBTraitDataSource::TestBTraitDataSource(void)
	: TraitDataSource(&TestBTrait::TraitSchema),
	tag_use_ref(false)
	{
	}

	void TestBTraitDataSource::Reset(void)
	{
	mVersion = 200;
	taa = TestATrait::ENUM_A_VALUE_1;
	tab = TestCommonTrait::COMMON_ENUM_A_VALUE_1;
	tac = 3;
	tad_saa = 4;
	tad_sab = true;

	for (size_t i = 0; i < (sizeof(tae) / sizeof(tae[0])); i++) {
	tae[i] = i + 5;
	}

	tba = 200;
	tbb_sbb = 201;
	tag_use_ref = !tag_use_ref;
	tag_ref = 10;
	tam_resourceid = 0x18b4300000beefULL;

	tap = 1491859262000;

	taq = -3000;
	tar = 3000;
	tas = 3000;

	tbc_saa = 202;
	tbc_sab = false;

	memset(nullified_path, false, sizeof(nullified_path));
	memset(ephemeral_path, true, sizeof(ephemeral_path));
	}


	WEAVE_ERROR TestBTraitDataSource::GetData(PropertyPathHandle aHandle,
	uint64_t aTagToWrite,
	TLVWriter &aWriter,
	bool &aIsNull,
	bool &aIsPresent)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	switch (aHandle)
	{
	// only handle nullable path handles
	// if the handle is a leaf, we should call GetLeafData
	case TestBTrait::kPropertyHandle_TaD:
	aIsNull = nullified_path[aHandle - 1];
	aIsPresent = ephemeral_path[aHandle - 1];
	break;

	default:
	aIsNull = nullified_path[aHandle - 1];
	aIsPresent = ephemeral_path[aHandle - 1];
	break;
	}

	// TDM will handle writing null
	if ((!aIsNull) && (aIsPresent) && (mSchemaEngine->IsLeaf(aHandle)))
	{
	err = GetLeafData(aHandle, aTagToWrite, aWriter);
	}

	return err;
	}

	void TestBTraitDataSource::SetNullifiedPath(PropertyPathHandle aHandle, bool isNull)
	{
	if (aHandle <= TestBTrait::kPropertyHandle_TaJ_Value_SaB)
	{
	if (nullified_path[aHandle - 1] != isNull)
	{
	nullified_path[aHandle - 1] = isNull;
	IncrementVersion();
	}
	}
	}

	void TestBTraitDataSource::SetPresentPath(PropertyPathHandle aHandle, bool isPresent)
	{
	if (aHandle <= TestBTrait::kPropertyHandle_TaJ_Value_SaB)
	{
	if (ephemeral_path[aHandle - 1] != isPresent)
	{
	ephemeral_path[aHandle - 1] = isPresent;
	IncrementVersion();
	}
	}
	}

	WEAVE_ERROR TestBTraitDataSource::SetLeafData(PropertyPathHandle aLeafHandle, TLVReader &aReader)
	{
	return WEAVE_ERROR_UNSUPPORTED_WEAVE_FEATURE;
	}

	WEAVE_ERROR TestBTraitDataSource::GetLeafData(PropertyPathHandle aLeafHandle, uint64_t aTagToWrite, TLVWriter &aWriter)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	switch (aLeafHandle) {
	//
	// TestATrait
	//

	case TestBTrait::kPropertyHandle_TaA:
	err = aWriter.Put(aTagToWrite, taa);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, ">> ta_a = %u", taa);
	break;

	case TestBTrait::kPropertyHandle_TaB:
	err = aWriter.Put(aTagToWrite, tab);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, ">> ta_b = %u", tab);
	break;

	case TestBTrait::kPropertyHandle_TaC:
	err = aWriter.Put(aTagToWrite, tac);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, ">> ta_c = %u", tac);
	break;

	case TestBTrait::kPropertyHandle_TaD_SaA:
	if (nullified_path[aLeafHandle - 1])
	{
	err = aWriter.PutNull(aTagToWrite);
	SuccessOrExit(err);
	}
	else if (ephemeral_path[aLeafHandle - 1] == false)
	{
	/* no op */
	}
	else
	{
	err = aWriter.Put(aTagToWrite, tad_saa);
	SuccessOrExit(err);
	}

	WeaveLogDetail(DataManagement, ">> ta_d.sa_a = %u, null = %s", tad_saa, nullified_path[aLeafHandle - 1] ? "true" : "false");
	break;

	case TestBTrait::kPropertyHandle_TaD_SaB:
	err = aWriter.PutBoolean(aTagToWrite, tad_sab);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, ">> ta_d.sa_b = %s", tad_sab ? "true" : "false");
	break;

	case TestBTrait::kPropertyHandle_TaE:
	{
	TLVType outerType;

	err = aWriter.StartContainer(aTagToWrite, kTLVType_Array, outerType);
	SuccessOrExit(err);

	for (size_t i = 0; i < (sizeof(tae) / sizeof(tae[0])); i++) {
	err = aWriter.Put(AnonymousTag, tae[i]);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, ">> ta_e[%u] = %u", i, tae[i]);
	}

	err = aWriter.EndContainer(outerType);
	break;
	}

	case TestBTrait::kPropertyHandle_TaG:
	if (tag_use_ref)
	{
	err = aWriter.Put(aTagToWrite, tag_ref);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, ">> ta_g.ref = %u", tag_ref);
	}
	else
	{
	err = aWriter.PutString(aTagToWrite, tag_string);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, ">> ta_g.string = %s", tag_string);
	}
	break;

	case TestBTrait::kPropertyHandle_TaL:
	{
	TLVType outerType;
	tal = 0;

	err = aWriter.StartContainer(aTagToWrite, kTLVType_Array, outerType);
	SuccessOrExit(err);

	for (size_t i = 0; i < 7; i++)
	{
	tal = (1 << i);
	err = aWriter.Put(AnonymousTag, tal);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, ">> tal[%u] = %u", i, tal);
	}

	err = aWriter.EndContainer(outerType);
	break;
	}

	case TestBTrait::kPropertyHandle_TaM:
	err = aWriter.Put(aTagToWrite, tam_resourceid);
	SuccessOrExit(err);
	break;

	case TestBTrait::kPropertyHandle_TaN:
	{
	uint8_t *tmp = &tan[0];
	nl::Weave::Encoding::LittleEndian::Write16(tmp, 1);
	nl::Weave::Encoding::LittleEndian::Write64(tmp, tam_resourceid);
	err = aWriter.PutBytes(aTagToWrite, &tan[0], sizeof(tan));
	SuccessOrExit(err);
	break;
	}

	case TestATrait::kPropertyHandle_TaP:
	aWriter.Put(aTagToWrite, tap);
	SuccessOrExit(err);
	break;

	case TestBTrait::kPropertyHandle_TaQ:
	aWriter.Put(aTagToWrite, taq);
	SuccessOrExit(err);
	break;

	case TestBTrait::kPropertyHandle_TaR:
	aWriter.Put(aTagToWrite, tar);
	SuccessOrExit(err);
	break;

	case TestBTrait::kPropertyHandle_TaS:
	aWriter.Put(aTagToWrite, tas);
	SuccessOrExit(err);
	break;

	case TestBTrait::kPropertyHandle_TaW:
	aWriter.PutString(aTagToWrite, taw);
	SuccessOrExit(err);
	break;


	//
	// TestBTrait
	//

	case TestBTrait::kPropertyHandle_TbA:
	err = aWriter.Put(aTagToWrite, tba);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, ">> tb_a = %u", tba);
	break;

	case TestBTrait::kPropertyHandle_TbB_SbA:
	err = aWriter.PutString(aTagToWrite, tbb_sba);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, ">> tb_b.sb_a = \"%s\"", tbb_sba);
	break;

	case TestBTrait::kPropertyHandle_TbB_SbB:
	err = aWriter.Put(aTagToWrite, tbb_sbb);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, ">> tb_b.sb_b = %u", tbb_sbb);
	break;

	case TestBTrait::kPropertyHandle_TbC_SaA:
	err = aWriter.Put(aTagToWrite, tbc_saa);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, ">> tb_c.sa_a = %u", tbc_saa);
	break;

	case TestBTrait::kPropertyHandle_TbC_SaB:
	err = aWriter.PutBoolean(aTagToWrite, tbc_sab);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, ">> tb_c.sa_b = %s", tbc_sab ? "true" : "false");
	break;

	case TestBTrait::kPropertyHandle_TbC_SeaC:
	err = aWriter.PutString(aTagToWrite, tbc_seac);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, ">> tb_c.sea_c = %u", tbc_seac);
	break;

	default:
	WeaveLogDetail(DataManagement, ">> %u UNKNOWN!", aLeafHandle);
	}

	exit:
	WeaveLogFunctError(err);
	return err;
	}

	WEAVE_ERROR TestBTraitDataSource::GetNextDictionaryItemKey(PropertyPathHandle aDictionaryHandle, uintptr_t &aContext, PropertyDictionaryKey &aKey)
	{
	return WEAVE_END_OF_INPUT;
	}

	TestBTraitDataSink::TestBTraitDataSink()
	: TraitDataSink(&TestBTrait::TraitSchema)
	{
	}

	void TestBTraitDataSink::Reset(void)
	{
	ClearVersion();

	memset(set_path, 0, sizeof(set_path));
	memset(nullified_path, 0, sizeof(nullified_path));
	}

	void TestBTraitDataSink::SetDataCalled(PropertyPathHandle aHandle)
	{
	if (aHandle <= TestBTrait::kPropertyHandle_TaJ_Value_SaB)
	{
	set_path[aHandle - 1] = true;
	}
	}

	void TestBTraitDataSink::SetPathHandleNull(PropertyPathHandle aHandle, bool aIsNull)
	{
	if (aHandle <= TestBTrait::kPropertyHandle_TaJ_Value_SaB)
	{
	nullified_path[aHandle - 1] = aIsNull;
	}
	}

	bool TestBTraitDataSink::IsPathHandleSet(PropertyPathHandle aHandle)
	{
	bool retval = false;
	if (aHandle <= TestBTrait::kPropertyHandle_TaJ_Value_SaB)
	{
	retval = set_path[aHandle - 1];
	}
	return retval;
	}

	bool TestBTraitDataSink::IsPathHandleNull(PropertyPathHandle aHandle)
	{
	bool retval = false;
	if (aHandle <= TestBTrait::kPropertyHandle_TaJ_Value_SaB)
	{
	retval = nullified_path[aHandle - 1];
	}
	return retval;
	}

	WEAVE_ERROR
	TestBTraitDataSink::SetData(PropertyPathHandle aHandle, TLVReader &aReader, bool aIsNull)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	SetDataCalled(aHandle);
	SetPathHandleNull(aHandle, aIsNull);

	if ((!aIsNull) && (mSchemaEngine->IsLeaf(aHandle)))
	{
	err = SetLeafData(aHandle, aReader);
	}
	return err;
	}

	WEAVE_ERROR
	TestBTraitDataSink::SetLeafData(PropertyPathHandle aLeafHandle, TLVReader &aReader)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	SetDataCalled(aLeafHandle);

	switch (aLeafHandle) {
	//
	// TestATrait
	//

	case TestBTrait::kPropertyHandle_TaA:
	err = aReader.Get(taa);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, "<< ta_a = %u", taa);
	break;

	case TestBTrait::kPropertyHandle_TaB:
	err = aReader.Get(tab);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, "<< ta_b = %u", tab);
	break;

	case TestBTrait::kPropertyHandle_TaC:
	err = aReader.Get(tac);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, "<< ta_c = %u", tac);
	break;

	case TestBTrait::kPropertyHandle_TaD_SaA:
	err = aReader.Get(tad_saa);
	SuccessOrExit(err);
	SetPathHandleNull(aLeafHandle, false);
	// the parent of this field is also now non-null
	SetPathHandleNull(TestBTrait::kPropertyHandle_TaD, false);

	WeaveLogDetail(DataManagement, "<< ta_d.sa_a = %u", tad_saa);

	break;

	case TestBTrait::kPropertyHandle_TaD_SaB:
	err = aReader.Get(tad_sab);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, "<< ta_d.sa_b = %u", tad_sab);
	break;

	case TestBTrait::kPropertyHandle_TaE:
	{
	TLVType outerType;
	uint32_t i = 0;

	err = aReader.EnterContainer(outerType);
	SuccessOrExit(err);

	while (((err = aReader.Next()) == WEAVE_NO_ERROR) && (i < (sizeof(tae) / sizeof(tae[0]))))
	{
	err = aReader.Get(tae[i]);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, "<< ta_e[%u] = %u", i, tae[i]);
	i++;
	}

	err = aReader.ExitContainer(outerType);
	break;
	}

	//
	// TestBTrait
	//

	case TestBTrait::kPropertyHandle_TbA:
	err = aReader.Get(tba);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, "<< tb_a = %u", tba);
	break;

	case TestBTrait::kPropertyHandle_TbB_SbA:
	err = aReader.GetString(tbb_sba, MAX_ARRAY_LEN);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, "<< tb_b.sb_a = %s", tbb_sba);
	break;

	case TestBTrait::kPropertyHandle_TbB_SbB:
	err = aReader.Get(tbb_sbb);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, "<< tb_b.sb_b = %u", tbb_sbb);
	break;

	case TestBTrait::kPropertyHandle_TbC_SaA:
	err = aReader.Get(tbc_saa);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, "<< tb_c.sa_a = %u", tbc_saa);
	break;

	case TestBTrait::kPropertyHandle_TbC_SaB:
	err = aReader.Get(tbc_sab);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, "<< tb_c.sa_b = %u", tbc_sab);
	break;

	case TestBTrait::kPropertyHandle_TbC_SeaC:
	err = aReader.GetString(tbc_seac, MAX_ARRAY_LEN);
	SuccessOrExit(err);

	WeaveLogDetail(DataManagement, "<< tb_c.sea_c = \"%s\"", tbc_seac);
	break;

	default:
	WeaveLogDetail(DataManagement, "<< UNKNOWN!");
	}

	exit:
	return err;
	}