cppcache/integration-test/testThinClientListenerCallbackArgTest.cpp - geode-native - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You 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.
  */

 #define ROOT_NAME "testThinClientListenerCallbackArgTest"

 #include "fw_dunit.hpp"
 #include "ThinClientHelper.hpp"
 #include "TallyListener.hpp"
 #include "TallyWriter.hpp"
 #include "testobject/PdxType.hpp"
 #include "testobject/VariousPdxTypes.hpp"

 #include "SerializationRegistry.hpp"
 #include "CacheRegionHelper.hpp"
 #include "CacheImpl.hpp"

 #define CLIENT1 s1p1
 #define CLIENT2 s1p2
 #define SERVER1 s2p1

 #include "testobject/Portfolio.hpp"

 using apache::geode::client::Cacheable;
 using apache::geode::client::ClassCastException;
 using apache::geode::client::EntryEvent;
 using apache::geode::client::RegionEvent;

 using apache::geode::client::testing::TallyListener;
 using apache::geode::client::testing::TallyWriter;

 bool isLocalServer = true;
 static bool isLocator = false;
 const char *locatorsG =
     CacheHelper::getLocatorHostPort(isLocator, isLocalServer, 1);
 #include "LocatorHelper.hpp"

 using testobject::Portfolio;
 using testobject::Position;

 class CallbackListener : public CacheListener {
  private:
   int m_creates;
   int m_updates;
   int m_invalidates;
   int m_destroys;
   int m_regionInvalidate;
   int m_regionDestroy;
   int m_regionClear;
   // std::shared_ptr<CacheableString> m_callbackArg;
   std::shared_ptr<Cacheable> m_callbackArg;

  public:
   CallbackListener()
       : CacheListener(),
         m_creates(0),
         m_updates(0),
         m_invalidates(0),
         m_destroys(0),
         m_regionInvalidate(0),
         m_regionDestroy(0),
         m_regionClear(0),
         m_callbackArg(nullptr) {
     LOG("CallbackListener contructor called");
   }

   virtual ~CallbackListener() {}

   int getCreates() { return m_creates; }

   int getUpdates() { return m_updates; }
   int getInvalidates() { return m_invalidates; }
   int getDestroys() { return m_destroys; }
   int getRegionInvalidates() { return m_regionInvalidate; }
   int getRegionDestroys() { return m_regionDestroy; }
   int getRegionClear() { return m_regionClear; }
   void setCallBackArg(const std::shared_ptr<Cacheable> &callbackArg) {
     m_callbackArg = callbackArg;
   }

   void check(std::shared_ptr<Cacheable> eventCallback, int &updateEvent) {
     if (m_callbackArg != nullptr) {
       try {
         auto mCallbkArg = std::dynamic_pointer_cast<Portfolio>(m_callbackArg);

         auto callbkArg = std::dynamic_pointer_cast<Portfolio>(eventCallback);

         auto fromCallback = callbkArg->getPkid();
         auto mCallback = mCallbkArg->getPkid();

         LOGFINE(" values are %s === %s ", fromCallback->value().c_str(),
                 mCallback->value().c_str());

         if (*(fromCallback.get()) == *(mCallback.get())) {
           LOGFINE("values are same");
           updateEvent++;
         } else {
           LOGFINE("values are NOT same");
         }
       } catch (const ClassCastException &ex) {
         LOGFINE(" in class cast exception %s ", ex.what());
         try {
           auto fromCallback =
               std::dynamic_pointer_cast<CacheableString>(eventCallback);
           auto mCallback =
               std::dynamic_pointer_cast<CacheableString>(m_callbackArg);

           LOGFINE(" values are %s === %s ", fromCallback->value().c_str(),
                   mCallback->value().c_str());

           if (*(fromCallback.get()) == *(mCallback.get())) {
             LOGFINE("values are same");
             updateEvent++;
           } else {
             LOGFINE("values are NOT same");
           }
         } catch (const ClassCastException &ex2) {
           LOGFINE(" in class cast second exception %s ", ex2.what());
         }
       }
     }
   }

   void checkcallbackArg(const EntryEvent &event, int &updateEvent) {
     check(event.getCallbackArgument(), updateEvent);
   }

   void checkcallbackArg(const RegionEvent &event, int &updateEvent) {
     check(event.getCallbackArgument(), updateEvent);
   }

   virtual void afterCreate(const EntryEvent &event) {
     checkcallbackArg(event, m_creates);
   }

   virtual void afterUpdate(const EntryEvent &event) {
     checkcallbackArg(event, m_updates);
   }

   virtual void afterInvalidate(const EntryEvent &event) {
     checkcallbackArg(event, m_invalidates);
   }

   virtual void afterDestroy(const EntryEvent &event) {
     checkcallbackArg(event, m_destroys);
   }

   virtual void afterRegionInvalidate(const RegionEvent &event) {
     checkcallbackArg(event, m_regionInvalidate);
   }

   virtual void afterRegionDestroy(const RegionEvent &event) {
     checkcallbackArg(event, m_regionDestroy);
   }
   virtual void afterRegionClear(const RegionEvent &event) {
     checkcallbackArg(event, m_regionClear);
   }
 };
 //---------------------------------------------------------------------------------
 std::shared_ptr<CallbackListener> reg1Listener1 = nullptr;
 std::shared_ptr<CacheableString> callBackStrPtr;
 std::shared_ptr<Cacheable> callBackPortFolioPtr;

 void setCacheListener(const char *regName,
                       std::shared_ptr<CallbackListener> regListener) {
   auto reg = getHelper()->getRegion(regName);
   auto attrMutator = reg->getAttributesMutator();
   attrMutator->setCacheListener(regListener);
 }

 void validateEventCount(int line) {
   LOGINFO("ValidateEvents called from line (%d).", line);
   int num = reg1Listener1->getCreates();
   char buf[1024];
   sprintf(buf, "Didn't get expected callback arg in aftercreate event");
   ASSERT(7 == num, buf);
   num = reg1Listener1->getUpdates();
   sprintf(buf, "Didn't get expected callback arg in afterupdate events");
   ASSERT(3 == num, buf);
   num = reg1Listener1->getInvalidates();
   sprintf(buf, "Didn't get expected callback arg in afterInvalidates events");
   ASSERT(2 == num, buf);
   num = reg1Listener1->getDestroys();
   sprintf(buf, "Didn't get expected callback arg in afterdestroy events");
   ASSERT(5 == num, buf);
   num = reg1Listener1->getRegionInvalidates();
   sprintf(buf,
           "Didn't get expected callback arg in afterRegionInvalidates events");
   ASSERT(1 == num, buf);
   num = reg1Listener1->getRegionDestroys();
   sprintf(buf, "Didn't get expected callback arg in afterRegiondestroy events");
   ASSERT(1 == num, buf);
   num = reg1Listener1->getRegionClear();
   sprintf(buf, "Didn't get expected callback arg in afterRegionClear events");
   ASSERT(1 == num, buf);
 }

 DUNIT_TASK_DEFINITION(SERVER1, StartServer)
   {
     if (isLocalServer) {
       CacheHelper::initServer(1, "cacheserver_notify_subscription5.xml");
     }
     LOG("SERVER started");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT1, SetupClient1_Pool_Locator)
   {
     initClient(true);

     callBackStrPtr = CacheableString::create("Gemstone's Callback");

     createPooledRegion(regionNames[0], false /*ack mode*/, locatorsG,
                        "__TEST_POOL1__", true /*client notification*/);
     auto serializationRegistry =
         CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
             ->getSerializationRegistry();
     serializationRegistry->addDataSerializableType(
         Portfolio::createDeserializable, 3);
     serializationRegistry->addDataSerializableType(
         Position::createDeserializable, 2);
     reg1Listener1 = std::make_shared<CallbackListener>();
     callBackPortFolioPtr = std::make_shared<Portfolio>(1, 0, nullptr);

     reg1Listener1->setCallBackArg(callBackPortFolioPtr);
     setCacheListener(regionNames[0], reg1Listener1);
     auto regPtr = getHelper()->getRegion(regionNames[0]);
     regPtr->registerAllKeys();
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT2, SetupClient2_Pool_Locator)
   {
     initClient(true);

     callBackStrPtr = CacheableString::create("Gemstone's Callback");

     auto serializationRegistry =
         CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
             ->getSerializationRegistry();
     serializationRegistry->addDataSerializableType(
         Portfolio::createDeserializable, 3);
     serializationRegistry->addDataSerializableType(
         Position::createDeserializable, 2);

     createPooledRegion(regionNames[0], false /*ack mode*/, locatorsG,
                        "__TEST_POOL1__", true /*client notification*/);
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT2, testCreatesAndUpdates)
   {
     auto regPtr = getHelper()->getRegion(regionNames[0]);

     callBackPortFolioPtr = std::make_shared<Portfolio>(1, 0, nullptr);
     regPtr->create("aaa", "bbb", callBackPortFolioPtr);
     regPtr->create(keys[1], vals[1], callBackPortFolioPtr);
     regPtr->put(keys[1], nvals[1], callBackPortFolioPtr);
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT1, testInvalidates)
   {
     auto regPtr = getHelper()->getRegion(regionNames[0]);

     callBackPortFolioPtr = std::make_shared<Portfolio>(1, 0, nullptr);
     regPtr->localCreate(1234, 1234, callBackPortFolioPtr);
     regPtr->localCreate(12345, 12345, callBackPortFolioPtr);
     regPtr->localCreate(12346, 12346, callBackPortFolioPtr);
     regPtr->localPut(1234, vals[1], callBackPortFolioPtr);
     regPtr->localInvalidate(1234, callBackPortFolioPtr);
     ASSERT(regPtr->localRemove(12345, 12345, callBackPortFolioPtr) == true,
            "Result of remove should be true, as this value exists locally.");
     ASSERT(regPtr->containsKey(12345) == false, "containsKey should be false");
     ASSERT(regPtr->localRemoveEx(12346, callBackPortFolioPtr) == true,
            "Result of remove should be true, as this value exists locally.");
     ASSERT(regPtr->containsKey(12346) == false, "containsKey should be false");
     regPtr->invalidate(keys[1], callBackPortFolioPtr);
     regPtr->invalidateRegion(callBackPortFolioPtr);
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT2, testDestroy)
   {
     auto regPtr = getHelper()->getRegion(regionNames[0]);

     callBackPortFolioPtr = std::make_shared<Portfolio>(1, 0, nullptr);
     regPtr->destroy(keys[1], callBackPortFolioPtr);
     ASSERT(regPtr->removeEx("aaa", callBackPortFolioPtr) == true,
            "Result of remove should be true, as this value exists.");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT2, testRemove)
   {
     auto regPtr = getHelper()->getRegion(regionNames[0]);
     regPtr->remove(keys[1], nvals[1], callBackPortFolioPtr);
     regPtr->destroyRegion(callBackPortFolioPtr);
   }
 END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT1, testlocalClear)
   {
     auto regPtr = getHelper()->getRegion(regionNames[0]);
     regPtr->localClear(callBackPortFolioPtr);
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT1, testValidate)
   {
     dunit::sleep(10000);
     validateEventCount(__LINE__);
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT1, StopClient1)
   {
     cleanProc();
     LOG("CLIENT1 stopped");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT2, StopClient2)
   {
     cleanProc();
     LOG("CLIENT2 stopped");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(SERVER1, StopServer)
   {
     if (isLocalServer) CacheHelper::closeServer(1);
     LOG("SERVER stopped");
   }
 END_TASK_DEFINITION

 DUNIT_MAIN
   {
     CALL_TASK(CreateLocator1);
     CALL_TASK(CreateServer1_With_Locator_XML5)

     CALL_TASK(SetupClient1_Pool_Locator);
     CALL_TASK(SetupClient2_Pool_Locator);
     CALL_TASK(testCreatesAndUpdates);
     CALL_TASK(testInvalidates);
     CALL_TASK(testDestroy);
     CALL_TASK(testCreatesAndUpdates);
     CALL_TASK(testlocalClear);
     CALL_TASK(testRemove);
     CALL_TASK(testValidate);
     CALL_TASK(StopClient1);
     CALL_TASK(StopClient2);
     CALL_TASK(StopServer);
     CALL_TASK(CloseLocator1);
   }
 END_MAIN
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You 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.
	*/

	#define ROOT_NAME "testThinClientListenerCallbackArgTest"

	#include "fw_dunit.hpp"
	#include "ThinClientHelper.hpp"
	#include "TallyListener.hpp"
	#include "TallyWriter.hpp"
	#include "testobject/PdxType.hpp"
	#include "testobject/VariousPdxTypes.hpp"

	#include "SerializationRegistry.hpp"
	#include "CacheRegionHelper.hpp"
	#include "CacheImpl.hpp"

	#define CLIENT1 s1p1
	#define CLIENT2 s1p2
	#define SERVER1 s2p1

	#include "testobject/Portfolio.hpp"

	using apache::geode::client::Cacheable;
	using apache::geode::client::ClassCastException;
	using apache::geode::client::EntryEvent;
	using apache::geode::client::RegionEvent;

	using apache::geode::client::testing::TallyListener;
	using apache::geode::client::testing::TallyWriter;

	bool isLocalServer = true;
	static bool isLocator = false;
	const char *locatorsG =
	CacheHelper::getLocatorHostPort(isLocator, isLocalServer, 1);
	#include "LocatorHelper.hpp"

	using testobject::Portfolio;
	using testobject::Position;

	class CallbackListener : public CacheListener {
	private:
	int m_creates;
	int m_updates;
	int m_invalidates;
	int m_destroys;
	int m_regionInvalidate;
	int m_regionDestroy;
	int m_regionClear;
	// std::shared_ptr<CacheableString> m_callbackArg;
	std::shared_ptr<Cacheable> m_callbackArg;

	public:
	CallbackListener()
	: CacheListener(),
	m_creates(0),
	m_updates(0),
	m_invalidates(0),
	m_destroys(0),
	m_regionInvalidate(0),
	m_regionDestroy(0),
	m_regionClear(0),
	m_callbackArg(nullptr) {
	LOG("CallbackListener contructor called");
	}

	virtual ~CallbackListener() {}

	int getCreates() { return m_creates; }

	int getUpdates() { return m_updates; }
	int getInvalidates() { return m_invalidates; }
	int getDestroys() { return m_destroys; }
	int getRegionInvalidates() { return m_regionInvalidate; }
	int getRegionDestroys() { return m_regionDestroy; }
	int getRegionClear() { return m_regionClear; }
	void setCallBackArg(const std::shared_ptr<Cacheable> &callbackArg) {
	m_callbackArg = callbackArg;
	}

	void check(std::shared_ptr<Cacheable> eventCallback, int &updateEvent) {
	if (m_callbackArg != nullptr) {
	try {
	auto mCallbkArg = std::dynamic_pointer_cast<Portfolio>(m_callbackArg);

	auto callbkArg = std::dynamic_pointer_cast<Portfolio>(eventCallback);

	auto fromCallback = callbkArg->getPkid();
	auto mCallback = mCallbkArg->getPkid();

	LOGFINE(" values are %s === %s ", fromCallback->value().c_str(),
	mCallback->value().c_str());

	if ((fromCallback.get()) == (mCallback.get())) {
	LOGFINE("values are same");
	updateEvent++;
	} else {
	LOGFINE("values are NOT same");
	}
	} catch (const ClassCastException &ex) {
	LOGFINE(" in class cast exception %s ", ex.what());
	try {
	auto fromCallback =
	std::dynamic_pointer_cast<CacheableString>(eventCallback);
	auto mCallback =
	std::dynamic_pointer_cast<CacheableString>(m_callbackArg);

	LOGFINE(" values are %s === %s ", fromCallback->value().c_str(),
	mCallback->value().c_str());

	if ((fromCallback.get()) == (mCallback.get())) {
	LOGFINE("values are same");
	updateEvent++;
	} else {
	LOGFINE("values are NOT same");
	}
	} catch (const ClassCastException &ex2) {
	LOGFINE(" in class cast second exception %s ", ex2.what());
	}
	}
	}
	}

	void checkcallbackArg(const EntryEvent &event, int &updateEvent) {
	check(event.getCallbackArgument(), updateEvent);
	}

	void checkcallbackArg(const RegionEvent &event, int &updateEvent) {
	check(event.getCallbackArgument(), updateEvent);
	}

	virtual void afterCreate(const EntryEvent &event) {
	checkcallbackArg(event, m_creates);
	}

	virtual void afterUpdate(const EntryEvent &event) {
	checkcallbackArg(event, m_updates);
	}

	virtual void afterInvalidate(const EntryEvent &event) {
	checkcallbackArg(event, m_invalidates);
	}

	virtual void afterDestroy(const EntryEvent &event) {
	checkcallbackArg(event, m_destroys);
	}

	virtual void afterRegionInvalidate(const RegionEvent &event) {
	checkcallbackArg(event, m_regionInvalidate);
	}

	virtual void afterRegionDestroy(const RegionEvent &event) {
	checkcallbackArg(event, m_regionDestroy);
	}
	virtual void afterRegionClear(const RegionEvent &event) {
	checkcallbackArg(event, m_regionClear);
	}
	};
	//---------------------------------------------------------------------------------
	std::shared_ptr<CallbackListener> reg1Listener1 = nullptr;
	std::shared_ptr<CacheableString> callBackStrPtr;
	std::shared_ptr<Cacheable> callBackPortFolioPtr;

	void setCacheListener(const char *regName,
	std::shared_ptr<CallbackListener> regListener) {
	auto reg = getHelper()->getRegion(regName);
	auto attrMutator = reg->getAttributesMutator();
	attrMutator->setCacheListener(regListener);
	}

	void validateEventCount(int line) {
	LOGINFO("ValidateEvents called from line (%d).", line);
	int num = reg1Listener1->getCreates();
	char buf[1024];
	sprintf(buf, "Didn't get expected callback arg in aftercreate event");
	ASSERT(7 == num, buf);
	num = reg1Listener1->getUpdates();
	sprintf(buf, "Didn't get expected callback arg in afterupdate events");
	ASSERT(3 == num, buf);
	num = reg1Listener1->getInvalidates();
	sprintf(buf, "Didn't get expected callback arg in afterInvalidates events");
	ASSERT(2 == num, buf);
	num = reg1Listener1->getDestroys();
	sprintf(buf, "Didn't get expected callback arg in afterdestroy events");
	ASSERT(5 == num, buf);
	num = reg1Listener1->getRegionInvalidates();
	sprintf(buf,
	"Didn't get expected callback arg in afterRegionInvalidates events");
	ASSERT(1 == num, buf);
	num = reg1Listener1->getRegionDestroys();
	sprintf(buf, "Didn't get expected callback arg in afterRegiondestroy events");
	ASSERT(1 == num, buf);
	num = reg1Listener1->getRegionClear();
	sprintf(buf, "Didn't get expected callback arg in afterRegionClear events");
	ASSERT(1 == num, buf);
	}

	DUNIT_TASK_DEFINITION(SERVER1, StartServer)
	{
	if (isLocalServer) {
	CacheHelper::initServer(1, "cacheserver_notify_subscription5.xml");
	}
	LOG("SERVER started");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT1, SetupClient1_Pool_Locator)
	{
	initClient(true);

	callBackStrPtr = CacheableString::create("Gemstone's Callback");

	createPooledRegion(regionNames[0], false /ack mode/, locatorsG,
	"__TEST_POOL1__", true /client notification/);
	auto serializationRegistry =
	CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
	->getSerializationRegistry();
	serializationRegistry->addDataSerializableType(
	Portfolio::createDeserializable, 3);
	serializationRegistry->addDataSerializableType(
	Position::createDeserializable, 2);
	reg1Listener1 = std::make_shared<CallbackListener>();
	callBackPortFolioPtr = std::make_shared<Portfolio>(1, 0, nullptr);

	reg1Listener1->setCallBackArg(callBackPortFolioPtr);
	setCacheListener(regionNames[0], reg1Listener1);
	auto regPtr = getHelper()->getRegion(regionNames[0]);
	regPtr->registerAllKeys();
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT2, SetupClient2_Pool_Locator)
	{
	initClient(true);

	callBackStrPtr = CacheableString::create("Gemstone's Callback");

	auto serializationRegistry =
	CacheRegionHelper::getCacheImpl(cacheHelper->getCache().get())
	->getSerializationRegistry();
	serializationRegistry->addDataSerializableType(
	Portfolio::createDeserializable, 3);
	serializationRegistry->addDataSerializableType(
	Position::createDeserializable, 2);

	createPooledRegion(regionNames[0], false /ack mode/, locatorsG,
	"__TEST_POOL1__", true /client notification/);
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT2, testCreatesAndUpdates)
	{
	auto regPtr = getHelper()->getRegion(regionNames[0]);

	callBackPortFolioPtr = std::make_shared<Portfolio>(1, 0, nullptr);
	regPtr->create("aaa", "bbb", callBackPortFolioPtr);
	regPtr->create(keys[1], vals[1], callBackPortFolioPtr);
	regPtr->put(keys[1], nvals[1], callBackPortFolioPtr);
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT1, testInvalidates)
	{
	auto regPtr = getHelper()->getRegion(regionNames[0]);

	callBackPortFolioPtr = std::make_shared<Portfolio>(1, 0, nullptr);
	regPtr->localCreate(1234, 1234, callBackPortFolioPtr);
	regPtr->localCreate(12345, 12345, callBackPortFolioPtr);
	regPtr->localCreate(12346, 12346, callBackPortFolioPtr);
	regPtr->localPut(1234, vals[1], callBackPortFolioPtr);
	regPtr->localInvalidate(1234, callBackPortFolioPtr);
	ASSERT(regPtr->localRemove(12345, 12345, callBackPortFolioPtr) == true,
	"Result of remove should be true, as this value exists locally.");
	ASSERT(regPtr->containsKey(12345) == false, "containsKey should be false");
	ASSERT(regPtr->localRemoveEx(12346, callBackPortFolioPtr) == true,
	"Result of remove should be true, as this value exists locally.");
	ASSERT(regPtr->containsKey(12346) == false, "containsKey should be false");
	regPtr->invalidate(keys[1], callBackPortFolioPtr);
	regPtr->invalidateRegion(callBackPortFolioPtr);
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT2, testDestroy)
	{
	auto regPtr = getHelper()->getRegion(regionNames[0]);

	callBackPortFolioPtr = std::make_shared<Portfolio>(1, 0, nullptr);
	regPtr->destroy(keys[1], callBackPortFolioPtr);
	ASSERT(regPtr->removeEx("aaa", callBackPortFolioPtr) == true,
	"Result of remove should be true, as this value exists.");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT2, testRemove)
	{
	auto regPtr = getHelper()->getRegion(regionNames[0]);
	regPtr->remove(keys[1], nvals[1], callBackPortFolioPtr);
	regPtr->destroyRegion(callBackPortFolioPtr);
	}
	END_TASK_DEFINITION
	DUNIT_TASK_DEFINITION(CLIENT1, testlocalClear)
	{
	auto regPtr = getHelper()->getRegion(regionNames[0]);
	regPtr->localClear(callBackPortFolioPtr);
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT1, testValidate)
	{
	dunit::sleep(10000);
	validateEventCount(__LINE__);
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT1, StopClient1)
	{
	cleanProc();
	LOG("CLIENT1 stopped");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT2, StopClient2)
	{
	cleanProc();
	LOG("CLIENT2 stopped");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(SERVER1, StopServer)
	{
	if (isLocalServer) CacheHelper::closeServer(1);
	LOG("SERVER stopped");
	}
	END_TASK_DEFINITION

	DUNIT_MAIN
	{
	CALL_TASK(CreateLocator1);
	CALL_TASK(CreateServer1_With_Locator_XML5)

	CALL_TASK(SetupClient1_Pool_Locator);
	CALL_TASK(SetupClient2_Pool_Locator);
	CALL_TASK(testCreatesAndUpdates);
	CALL_TASK(testInvalidates);
	CALL_TASK(testDestroy);
	CALL_TASK(testCreatesAndUpdates);
	CALL_TASK(testlocalClear);
	CALL_TASK(testRemove);
	CALL_TASK(testValidate);
	CALL_TASK(StopClient1);
	CALL_TASK(StopClient2);
	CALL_TASK(StopServer);
	CALL_TASK(CloseLocator1);
	}
	END_MAIN