weave/src/test-apps/TestWdm.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 unit-tests for the protocol side of WDM.
  *
  */

 #include "ToolCommon.h"

 #include <nlbyteorder.h>
 #include <nltest.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 <SystemLayer/SystemFaultInjection.h>

 #include <Weave/Profiles/service-directory/ServiceDirectory.h>

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

 #include "TestPlatformTime.h"

 #if WEAVE_SYSTEM_CONFIG_USE_LWIP
 #include <lwip/init.h>
 #endif // WEAVE_SYSTEM_CONFIG_USE_LWIP

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

 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // System/Platform definitions
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 namespace Private {

 static WEAVE_ERROR SetSystemTime(const nl::Weave::Profiles::Time::timesync_t timestamp_usec)
 {
 	return WEAVE_NO_ERROR;
 }

 static WEAVE_ERROR GetSystemTimeMs(nl::Weave::Profiles::Time::timesync_t *p_timestamp_msec)
 {
 	return WEAVE_NO_ERROR;
 }

 } // namespace Private


 namespace nl {
 namespace Weave {
 namespace Profiles {
 namespace WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Current) {
 namespace Platform {
     // for unit tests, the dummy critical section is sufficient.
     void CriticalSectionEnter()
     {
         return;
     }

     void CriticalSectionExit()
     {
         return;
     }
 } // Platform
 } // WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Current)
 }
 }
 }

 static SubscriptionEngine *gSubscriptionEngine;

 SubscriptionEngine * SubscriptionEngine::GetInstance()
 {
     return gSubscriptionEngine;
 }

 static void TestCounterSubscription_BufferAllocFailure(nlTestSuite *inSuite, void *inContext);

 // Test Suite

 /**
  *  Test Suite that lists all the test functions.
  */
 static const nlTest sTests[] = {
     NL_TEST_DEF("Test Counter Subscription -- Buffer Allocation Failure", TestCounterSubscription_BufferAllocFailure),

     NL_TEST_SENTINEL()
 };

 namespace nl {
 namespace Weave {
 namespace Profiles {
 namespace WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Current) {

 class TestWdm {
 public:
     TestWdm();

     int Setup();
     int Teardown();
     int Reset();
     int BuildAndProcessNotify();

     void TestCounterSubscription_BufferAllocFailure(nlTestSuite *inSuite);
     void SpoofPublisherSubscription();

     static void ClientSubscriptionEventCallback(void * const aAppState,
                                         SubscriptionClient::EventID aEvent,
                                         const SubscriptionClient::InEventParam & aInParam,
                                         SubscriptionClient::OutEventParam & aOutParam);

     static void BindingEventCallback(void * const apAppState, const nl::Weave::Binding::EventType aEventType,
                                             const nl::Weave::Binding::InEventParam & aInParam,
                                             nl::Weave::Binding::OutEventParam & aOutParam);

     static void PublisherEventCallback (void * const aAppState,
         SubscriptionHandler::EventID aEvent, const SubscriptionHandler::InEventParam & aInParam,
         SubscriptionHandler::OutEventParam & aOutParam);

 private:
     SubscriptionHandler *mSubHandler;
     SubscriptionClient *mSubClient;
     NotificationEngine *mNotificationEngine;

     SubscriptionEngine mSubscriptionEngine;
     WeaveExchangeManager mExchangeMgr;

     SingleResourceSourceTraitCatalog::CatalogItem mSourceCatalogStore[4];
     SingleResourceSourceTraitCatalog mSourceCatalog;
     SingleResourceSinkTraitCatalog::CatalogItem mSinkCatalogStore[4];
     SingleResourceSinkTraitCatalog mSinkCatalog;

     Binding *mClientBinding;
     uint64_t mPeerSubscriptionId;

     uint32_t mTestCase;
     bool mPublisherSubscriptionPresent;
     bool mClientSubscriptionPresent;
 };

 TestWdm *gTestWdm;

 TestWdm::TestWdm()
     : mSourceCatalog(ResourceIdentifier(ResourceIdentifier::SELF_NODE_ID), mSourceCatalogStore, 4),
       mSinkCatalog(ResourceIdentifier(ResourceIdentifier::SELF_NODE_ID), mSinkCatalogStore, 4),
       mClientBinding(NULL)
 {
     mTestCase = 0;
 }

 void TestWdm::SpoofPublisherSubscription()
 {
     mSubHandler->mRefCount = 1;
     mSubHandler->mLivenessTimeoutMsec = 2000;
     mSubHandler->mSubscriptionId = 1;
     mPeerSubscriptionId = 1;
     mSubHandler->mCurrentState = SubscriptionHandler::kState_SubscriptionEstablished_Idle;
 }

 void
 TestWdm::BindingEventCallback(void * const apAppState, const nl::Weave::Binding::EventType aEventType,
                                             const nl::Weave::Binding::InEventParam & aInParam,
                                             nl::Weave::Binding::OutEventParam & aOutParam)
 {
     TestWdm *_this = static_cast<TestWdm*>(apAppState);
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     switch (aEventType) {
         case Binding::kEvent_PrepareRequested:
         {
             err = _this->mClientBinding->BeginConfiguration()
                 .Target_ServiceEndpoint(kServiceEndpoint_Data_Management)
                 .TargetAddress_WeaveService()
                 .Transport_UDP_WRM()
                 .Security_None()
                 .PrepareBinding();
             SuccessOrExit(err);
             break;
         }

         case Binding::kEvent_BindingReady:
         {
             break;
         }

         case Binding::kEvent_PrepareFailed:
         {
             break;
         }

         case Binding::kEvent_BindingFailed:
             break;

         default:
             // Fall through.

         case Binding::kEvent_DefaultCheck:
             Binding::DefaultEventHandler(apAppState, aEventType, aInParam, aOutParam);
             break;
     }

 exit:
     return;
 }

 void
 TestWdm::ClientSubscriptionEventCallback (void * const aAppState,
                                         SubscriptionClient::EventID aEvent,
                                         const SubscriptionClient::InEventParam & aInParam,
                                         SubscriptionClient::OutEventParam & aOutParam)
 {
     TestWdm *_this = static_cast<TestWdm*>(aAppState);

     switch (aEvent) {
         case SubscriptionClient::kEvent_OnSubscribeRequestPrepareNeeded:
             {
                 SubscriptionClient* client = aInParam.mSubscribeRequestPrepareNeeded.mClient;
                 WeaveLogDetail(DataManagement, "Client->kEvent_OnSubscribeRequestPrepareNeeded\n");

                 aOutParam.mSubscribeRequestPrepareNeeded.mPathList = NULL;
                 aOutParam.mSubscribeRequestPrepareNeeded.mPathListSize = 0;
                 aOutParam.mSubscribeRequestPrepareNeeded.mSubscriptionId = _this->mPeerSubscriptionId;

                 aOutParam.mSubscribeRequestPrepareNeeded.mNeedAllEvents = false;
                 aOutParam.mSubscribeRequestPrepareNeeded.mLastObservedEventList = NULL;
                 aOutParam.mSubscribeRequestPrepareNeeded.mLastObservedEventListSize = 0;
                 break;
             }

         case SubscriptionClient::kEvent_OnSubscriptionTerminated:
             {
                 WeaveLogDetail(DataManagement, "Client->kEvent_OnSubscriptionTerminated\n");
                 _this->mClientSubscriptionPresent = false;
                 break;
             }
     }
 }

 void
 TestWdm::PublisherEventCallback (void * const aAppState,
         SubscriptionHandler::EventID aEvent, const SubscriptionHandler::InEventParam & aInParam,
         SubscriptionHandler::OutEventParam & aOutParam)
 {
     TestWdm *_this = static_cast<TestWdm *>(aAppState);

     switch (aEvent)
     {
         case SubscriptionHandler::kEvent_OnSubscriptionTerminated:
         {
             WeaveLogDetail(DataManagement, "Publisher->kEvent_OnSubscriptionTerminated\n");
             _this->mPublisherSubscriptionPresent = false;
         }

         default:
             break;
     }
 }

 int TestWdm::Setup()
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     SubscriptionHandler::TraitInstanceInfo *traitInstance = NULL;

     gSubscriptionEngine = &mSubscriptionEngine;

     InitSystemLayer();
     InitNetwork();
     InitWeaveStack(true, true);

     // Initialize SubEngine and set it up
     err = mSubscriptionEngine.Init(&ExchangeMgr, NULL, NULL);
     SuccessOrExit(err);

     err = mSubscriptionEngine.EnablePublisher(NULL, &mSourceCatalog);
     SuccessOrExit(err);

     // Get a sub handler and prime it to the right state
     err = mSubscriptionEngine.NewSubscriptionHandler(&mSubHandler);
     SuccessOrExit(err);

     mSubHandler->mBinding = ExchangeMgr.NewBinding();
     mSubHandler->mBinding->BeginConfiguration().Transport_UDP().Target_NodeId(kServiceEndpoint_Data_Management);

     mSubHandler->mAppState = gTestWdm;
     mSubHandler->mEventCallback = PublisherEventCallback;

     mClientBinding = ExchangeMgr.NewBinding(BindingEventCallback, gTestWdm);

     err = mSubscriptionEngine.NewClient(&mSubClient, mClientBinding, gTestWdm, TestWdm::ClientSubscriptionEventCallback, &mSinkCatalog, 0);
     SuccessOrExit(err);

     mNotificationEngine = &mSubscriptionEngine.mNotificationEngine;

 exit:
     if (err != WEAVE_NO_ERROR) {
         WeaveLogError(DataManagement, "Error setting up test: %d", err);
     }

     return err;
 }

 int TestWdm::Teardown()
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     if (mClientBinding != NULL)
     {
         mClientBinding->Release();
         mClientBinding = NULL;
     }

     return err;
 }

 int TestWdm::Reset()
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     mSubHandler->MoveToState(SubscriptionHandler::kState_SubscriptionEstablished_Idle);
     mNotificationEngine->mGraphSolver.ClearDirty();

     return err;
 }

 int TestWdm::BuildAndProcessNotify()
 {
     bool isSubscriptionClean;
     NotificationEngine::NotifyRequestBuilder notifyRequest;
     NotificationRequest::Parser notify;
     PacketBuffer *buf = NULL;
     TLVWriter writer;
     TLVReader reader;
     TLVType dummyType1, dummyType2;
     WEAVE_ERROR err;
     bool neWriteInProgress = false;

     notifyRequest.Init(&buf, &writer, mSubHandler);

     err = mNotificationEngine->BuildSingleNotifyRequestDataList(mSubHandler, notifyRequest, isSubscriptionClean, neWriteInProgress);
     SuccessOrExit(err);

     if (neWriteInProgress)
     {
         err = notifyRequest.MoveToState(NotificationEngine::kNotifyRequestBuilder_Idle);
         SuccessOrExit(err);

         reader.Init(buf);

         err = reader.Next();
         SuccessOrExit(err);

         notify.Init(reader);

         err = notify.CheckSchemaValidity();
         SuccessOrExit(err);

         // Enter the struct
         err = reader.EnterContainer(dummyType1);
         SuccessOrExit(err);

         // SubscriptionId
         err = reader.Next();
         SuccessOrExit(err);

         err = reader.Next();
         SuccessOrExit(err);

         VerifyOrExit(nl::Weave::TLV::kTLVType_Array == reader.GetType(), err = WEAVE_ERROR_WRONG_TLV_TYPE);

         err = reader.EnterContainer(dummyType2);
         SuccessOrExit(err);

         err = mSubClient->ProcessDataList(reader);
         SuccessOrExit(err);
     }
     else
     {
         WeaveLogDetail(DataManagement, "nothing has been written");
     }

 exit:
     if (buf) {
         PacketBuffer::Free(buf);
     }

     return err;
 }

 void TestWdm::TestCounterSubscription_BufferAllocFailure(nlTestSuite *inSuite)
 {
     Reset();

     // This spoofs a publisher-side subscription with SubscriptionId = 1
     SpoofPublisherSubscription();

     mPublisherSubscriptionPresent = true;
     mClientSubscriptionPresent = true;

     // Trigger a packet buffer fault so that the ensuing counter subscription request fails
     // because it cannot allocate a packet buffer.
     nl::Weave::System::FaultInjection::GetManager().FailAtFault(
             nl::Weave::System::FaultInjection::kFault_PacketBufferNew,
             0, 1);

     // Initiate a counter subscription request - this should trigger
     mSubClient->InitiateCounterSubscription(1000);

     // Ensure both client and publisher subscriptions are terminated.
     NL_TEST_ASSERT(inSuite, mClientSubscriptionPresent == false);
     NL_TEST_ASSERT(inSuite, mPublisherSubscriptionPresent == false);
 }

 } // WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Current)
 }
 }
 }

 /**
  *  Set up the test suite.
  */
 static int TestSetup(void *inContext)
 {
     static TestWdm testWdm;
     gTestWdm = &testWdm;

     return testWdm.Setup();
 }

 /**
  *  Tear down the test suite.
  */
 static int TestTeardown(void *inContext)
 {
     return gTestWdm->Teardown();
 }

 static void TestCounterSubscription_BufferAllocFailure(nlTestSuite *inSuite, void *inContext)
 {
     gTestWdm->TestCounterSubscription_BufferAllocFailure(inSuite);
 }

 /**
  *  Main
  */
 int main(int argc, char *argv[])
 {
 #if WEAVE_SYSTEM_CONFIG_USE_LWIP
     lwip_init();
 #endif // WEAVE_SYSTEM_CONFIG_USE_LWIP

     nlTestSuite theSuite = {
         "weave-wdm",
         &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) 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 protocol side of WDM.
	*
	*/

	#include "ToolCommon.h"

	#include <nlbyteorder.h>
	#include <nltest.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 <SystemLayer/SystemFaultInjection.h>

	#include <Weave/Profiles/service-directory/ServiceDirectory.h>

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

	#include "TestPlatformTime.h"

	#if WEAVE_SYSTEM_CONFIG_USE_LWIP
	#include <lwip/init.h>
	#endif // WEAVE_SYSTEM_CONFIG_USE_LWIP

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

	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// System/Platform definitions
	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	namespace Private {

	static WEAVE_ERROR SetSystemTime(const nl::Weave::Profiles::Time::timesync_t timestamp_usec)
	{
	return WEAVE_NO_ERROR;
	}

	static WEAVE_ERROR GetSystemTimeMs(nl::Weave::Profiles::Time::timesync_t *p_timestamp_msec)
	{
	return WEAVE_NO_ERROR;
	}

	} // namespace Private


	namespace nl {
	namespace Weave {
	namespace Profiles {
	namespace WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Current) {
	namespace Platform {
	// for unit tests, the dummy critical section is sufficient.
	void CriticalSectionEnter()
	{
	return;
	}

	void CriticalSectionExit()
	{
	return;
	}
	} // Platform
	} // WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Current)
	}
	}
	}

	static SubscriptionEngine *gSubscriptionEngine;

	SubscriptionEngine * SubscriptionEngine::GetInstance()
	{
	return gSubscriptionEngine;
	}

	static void TestCounterSubscription_BufferAllocFailure(nlTestSuite inSuite, void inContext);

	// Test Suite

	/**
	* Test Suite that lists all the test functions.
	*/
	static const nlTest sTests[] = {
	NL_TEST_DEF("Test Counter Subscription -- Buffer Allocation Failure", TestCounterSubscription_BufferAllocFailure),

	NL_TEST_SENTINEL()
	};

	namespace nl {
	namespace Weave {
	namespace Profiles {
	namespace WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Current) {

	class TestWdm {
	public:
	TestWdm();

	int Setup();
	int Teardown();
	int Reset();
	int BuildAndProcessNotify();

	void TestCounterSubscription_BufferAllocFailure(nlTestSuite *inSuite);
	void SpoofPublisherSubscription();

	static void ClientSubscriptionEventCallback(void * const aAppState,
	SubscriptionClient::EventID aEvent,
	const SubscriptionClient::InEventParam & aInParam,
	SubscriptionClient::OutEventParam & aOutParam);

	static void BindingEventCallback(void * const apAppState, const nl::Weave::Binding::EventType aEventType,
	const nl::Weave::Binding::InEventParam & aInParam,
	nl::Weave::Binding::OutEventParam & aOutParam);

	static void PublisherEventCallback (void * const aAppState,
	SubscriptionHandler::EventID aEvent, const SubscriptionHandler::InEventParam & aInParam,
	SubscriptionHandler::OutEventParam & aOutParam);

	private:
	SubscriptionHandler *mSubHandler;
	SubscriptionClient *mSubClient;
	NotificationEngine *mNotificationEngine;

	SubscriptionEngine mSubscriptionEngine;
	WeaveExchangeManager mExchangeMgr;

	SingleResourceSourceTraitCatalog::CatalogItem mSourceCatalogStore[4];
	SingleResourceSourceTraitCatalog mSourceCatalog;
	SingleResourceSinkTraitCatalog::CatalogItem mSinkCatalogStore[4];
	SingleResourceSinkTraitCatalog mSinkCatalog;

	Binding *mClientBinding;
	uint64_t mPeerSubscriptionId;

	uint32_t mTestCase;
	bool mPublisherSubscriptionPresent;
	bool mClientSubscriptionPresent;
	};

	TestWdm *gTestWdm;

	TestWdm::TestWdm()
	: mSourceCatalog(ResourceIdentifier(ResourceIdentifier::SELF_NODE_ID), mSourceCatalogStore, 4),
	mSinkCatalog(ResourceIdentifier(ResourceIdentifier::SELF_NODE_ID), mSinkCatalogStore, 4),
	mClientBinding(NULL)
	{
	mTestCase = 0;
	}

	void TestWdm::SpoofPublisherSubscription()
	{
	mSubHandler->mRefCount = 1;
	mSubHandler->mLivenessTimeoutMsec = 2000;
	mSubHandler->mSubscriptionId = 1;
	mPeerSubscriptionId = 1;
	mSubHandler->mCurrentState = SubscriptionHandler::kState_SubscriptionEstablished_Idle;
	}

	void
	TestWdm::BindingEventCallback(void * const apAppState, const nl::Weave::Binding::EventType aEventType,
	const nl::Weave::Binding::InEventParam & aInParam,
	nl::Weave::Binding::OutEventParam & aOutParam)
	{
	TestWdm _this = static_cast<TestWdm>(apAppState);
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	switch (aEventType) {
	case Binding::kEvent_PrepareRequested:
	{
	err = _this->mClientBinding->BeginConfiguration()
	.Target_ServiceEndpoint(kServiceEndpoint_Data_Management)
	.TargetAddress_WeaveService()
	.Transport_UDP_WRM()
	.Security_None()
	.PrepareBinding();
	SuccessOrExit(err);
	break;
	}

	case Binding::kEvent_BindingReady:
	{
	break;
	}

	case Binding::kEvent_PrepareFailed:
	{
	break;
	}

	case Binding::kEvent_BindingFailed:
	break;

	default:
	// Fall through.

	case Binding::kEvent_DefaultCheck:
	Binding::DefaultEventHandler(apAppState, aEventType, aInParam, aOutParam);
	break;
	}

	exit:
	return;
	}

	void
	TestWdm::ClientSubscriptionEventCallback (void * const aAppState,
	SubscriptionClient::EventID aEvent,
	const SubscriptionClient::InEventParam & aInParam,
	SubscriptionClient::OutEventParam & aOutParam)
	{
	TestWdm _this = static_cast<TestWdm>(aAppState);

	switch (aEvent) {
	case SubscriptionClient::kEvent_OnSubscribeRequestPrepareNeeded:
	{
	SubscriptionClient* client = aInParam.mSubscribeRequestPrepareNeeded.mClient;
	WeaveLogDetail(DataManagement, "Client->kEvent_OnSubscribeRequestPrepareNeeded\n");

	aOutParam.mSubscribeRequestPrepareNeeded.mPathList = NULL;
	aOutParam.mSubscribeRequestPrepareNeeded.mPathListSize = 0;
	aOutParam.mSubscribeRequestPrepareNeeded.mSubscriptionId = _this->mPeerSubscriptionId;

	aOutParam.mSubscribeRequestPrepareNeeded.mNeedAllEvents = false;
	aOutParam.mSubscribeRequestPrepareNeeded.mLastObservedEventList = NULL;
	aOutParam.mSubscribeRequestPrepareNeeded.mLastObservedEventListSize = 0;
	break;
	}

	case SubscriptionClient::kEvent_OnSubscriptionTerminated:
	{
	WeaveLogDetail(DataManagement, "Client->kEvent_OnSubscriptionTerminated\n");
	_this->mClientSubscriptionPresent = false;
	break;
	}
	}
	}

	void
	TestWdm::PublisherEventCallback (void * const aAppState,
	SubscriptionHandler::EventID aEvent, const SubscriptionHandler::InEventParam & aInParam,
	SubscriptionHandler::OutEventParam & aOutParam)
	{
	TestWdm _this = static_cast<TestWdm >(aAppState);

	switch (aEvent)
	{
	case SubscriptionHandler::kEvent_OnSubscriptionTerminated:
	{
	WeaveLogDetail(DataManagement, "Publisher->kEvent_OnSubscriptionTerminated\n");
	_this->mPublisherSubscriptionPresent = false;
	}

	default:
	break;
	}
	}

	int TestWdm::Setup()
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	SubscriptionHandler::TraitInstanceInfo *traitInstance = NULL;

	gSubscriptionEngine = &mSubscriptionEngine;

	InitSystemLayer();
	InitNetwork();
	InitWeaveStack(true, true);

	// Initialize SubEngine and set it up
	err = mSubscriptionEngine.Init(&ExchangeMgr, NULL, NULL);
	SuccessOrExit(err);

	err = mSubscriptionEngine.EnablePublisher(NULL, &mSourceCatalog);
	SuccessOrExit(err);

	// Get a sub handler and prime it to the right state
	err = mSubscriptionEngine.NewSubscriptionHandler(&mSubHandler);
	SuccessOrExit(err);

	mSubHandler->mBinding = ExchangeMgr.NewBinding();
	mSubHandler->mBinding->BeginConfiguration().Transport_UDP().Target_NodeId(kServiceEndpoint_Data_Management);

	mSubHandler->mAppState = gTestWdm;
	mSubHandler->mEventCallback = PublisherEventCallback;

	mClientBinding = ExchangeMgr.NewBinding(BindingEventCallback, gTestWdm);

	err = mSubscriptionEngine.NewClient(&mSubClient, mClientBinding, gTestWdm, TestWdm::ClientSubscriptionEventCallback, &mSinkCatalog, 0);
	SuccessOrExit(err);

	mNotificationEngine = &mSubscriptionEngine.mNotificationEngine;

	exit:
	if (err != WEAVE_NO_ERROR) {
	WeaveLogError(DataManagement, "Error setting up test: %d", err);
	}

	return err;
	}

	int TestWdm::Teardown()
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	if (mClientBinding != NULL)
	{
	mClientBinding->Release();
	mClientBinding = NULL;
	}

	return err;
	}

	int TestWdm::Reset()
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	mSubHandler->MoveToState(SubscriptionHandler::kState_SubscriptionEstablished_Idle);
	mNotificationEngine->mGraphSolver.ClearDirty();

	return err;
	}

	int TestWdm::BuildAndProcessNotify()
	{
	bool isSubscriptionClean;
	NotificationEngine::NotifyRequestBuilder notifyRequest;
	NotificationRequest::Parser notify;
	PacketBuffer *buf = NULL;
	TLVWriter writer;
	TLVReader reader;
	TLVType dummyType1, dummyType2;
	WEAVE_ERROR err;
	bool neWriteInProgress = false;

	notifyRequest.Init(&buf, &writer, mSubHandler);

	err = mNotificationEngine->BuildSingleNotifyRequestDataList(mSubHandler, notifyRequest, isSubscriptionClean, neWriteInProgress);
	SuccessOrExit(err);

	if (neWriteInProgress)
	{
	err = notifyRequest.MoveToState(NotificationEngine::kNotifyRequestBuilder_Idle);
	SuccessOrExit(err);

	reader.Init(buf);

	err = reader.Next();
	SuccessOrExit(err);

	notify.Init(reader);

	err = notify.CheckSchemaValidity();
	SuccessOrExit(err);

	// Enter the struct
	err = reader.EnterContainer(dummyType1);
	SuccessOrExit(err);

	// SubscriptionId
	err = reader.Next();
	SuccessOrExit(err);

	err = reader.Next();
	SuccessOrExit(err);

	VerifyOrExit(nl::Weave::TLV::kTLVType_Array == reader.GetType(), err = WEAVE_ERROR_WRONG_TLV_TYPE);

	err = reader.EnterContainer(dummyType2);
	SuccessOrExit(err);

	err = mSubClient->ProcessDataList(reader);
	SuccessOrExit(err);
	}
	else
	{
	WeaveLogDetail(DataManagement, "nothing has been written");
	}

	exit:
	if (buf) {
	PacketBuffer::Free(buf);
	}

	return err;
	}

	void TestWdm::TestCounterSubscription_BufferAllocFailure(nlTestSuite *inSuite)
	{
	Reset();

	// This spoofs a publisher-side subscription with SubscriptionId = 1
	SpoofPublisherSubscription();

	mPublisherSubscriptionPresent = true;
	mClientSubscriptionPresent = true;

	// Trigger a packet buffer fault so that the ensuing counter subscription request fails
	// because it cannot allocate a packet buffer.
	nl::Weave::System::FaultInjection::GetManager().FailAtFault(
	nl::Weave::System::FaultInjection::kFault_PacketBufferNew,
	0, 1);

	// Initiate a counter subscription request - this should trigger
	mSubClient->InitiateCounterSubscription(1000);

	// Ensure both client and publisher subscriptions are terminated.
	NL_TEST_ASSERT(inSuite, mClientSubscriptionPresent == false);
	NL_TEST_ASSERT(inSuite, mPublisherSubscriptionPresent == false);
	}

	} // WeaveMakeManagedNamespaceIdentifier(DataManagement, kWeaveManagedNamespaceDesignation_Current)
	}
	}
	}

	/**
	* Set up the test suite.
	*/
	static int TestSetup(void *inContext)
	{
	static TestWdm testWdm;
	gTestWdm = &testWdm;

	return testWdm.Setup();
	}

	/**
	* Tear down the test suite.
	*/
	static int TestTeardown(void *inContext)
	{
	return gTestWdm->Teardown();
	}

	static void TestCounterSubscription_BufferAllocFailure(nlTestSuite inSuite, void inContext)
	{
	gTestWdm->TestCounterSubscription_BufferAllocFailure(inSuite);
	}

	/**
	* Main
	*/
	int main(int argc, char *argv[])
	{
	#if WEAVE_SYSTEM_CONFIG_USE_LWIP
	lwip_init();
	#endif // WEAVE_SYSTEM_CONFIG_USE_LWIP

	nlTestSuite theSuite = {
	"weave-wdm",
	&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);
	}