cppcache/integration-test/testThinClientPRPutAllFailover.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 "testThinClientPRPutAllFailover"
 #define ROOT_SCOPE DISTRIBUTED_ACK

 #include "fw_dunit.hpp"
 #include "BuiltinCacheableWrappers.hpp"
 #include "Utils.hpp"

 #include <ace/OS.h>
 #include <ace/High_Res_Timer.h>
 #include "TallyListener.hpp"
 #include <string>
 #include "CacheHelper.hpp"

 // Include these 2 headers for access to CacheImpl for test hooks.
 #include "CacheImplHelper.hpp"
 #include "testUtils.hpp"

 #include "ThinClientHelper.hpp"

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

 using apache::geode::client::Exception;
 using apache::geode::client::HashMapOfCacheable;

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

 std::shared_ptr<TallyListener> reg1Listener1;
 bool isLocalServer = false;
 static bool isLocator = false;
 const char *locatorsG =
     CacheHelper::getLocatorHostPort(isLocator, isLocalServer, 1);

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

 DUNIT_TASK_DEFINITION(SERVER1, CreateServer1)
   {
     if (isLocalServer) CacheHelper::initServer(1, "cacheserver1_pr_putall.xml");
     LOG("SERVER1 started");
     if (isLocalServer) CacheHelper::initServer(2, "cacheserver2_pr_putall.xml");
     LOG("SERVER2 started");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(SERVER2, CreateServer2)
   {
     if (isLocalServer) CacheHelper::initServer(3, "cacheserver3_pr_putall.xml");
     LOG("SERVER3 started");
     if (isLocalServer) CacheHelper::initServer(4, "cacheserver4_pr_putall.xml");
     LOG("SERVER4 started");
   }
 END_TASK_DEFINITION

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

     getHelper()->createPoolWithLocators("__TEST_POOL1__", locatorsG);
     getHelper()->createRegionAndAttachPool(regionNames[0], USE_ACK,
                                            "__TEST_POOL1__");
     getHelper()->createRegionAndAttachPool(regionNames[1], NO_ACK,
                                            "__TEST_POOL1__");

     reg1Listener1 = std::make_shared<TallyListener>();
     setCacheListener(regionNames[0], reg1Listener1);
     LOG("StepOne_Pooled_Locator_Client1 complete.");
   }
 END_TASK_DEFINITION

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

     getHelper()->createPoolWithLocators("__TEST_POOL1__", locatorsG, true, 2);
     getHelper()->createRegionAndAttachPool(regionNames[0], USE_ACK,
                                            "__TEST_POOL1__");
     getHelper()->createRegionAndAttachPool(regionNames[1], NO_ACK,
                                            "__TEST_POOL1__");

     reg1Listener1 = std::make_shared<TallyListener>();
     setCacheListener(regionNames[0], reg1Listener1);
     LOG("StepOne_Pooled_Locator_Client2 complete.");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT2, StepTwo_RegisterAllKeys)
   {
     auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     regPtr0->registerAllKeys();
     auto regPtr1 = getHelper()->getRegion(regionNames[1]);
     regPtr1->registerAllKeys();
     LOG("StepTwo_Pooled_EndPoint_RegisterAllKeys complete.");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT1, PutAllOneTask)
   {
     LOG("PutAllOneTask started.");
     auto dataReg = getHelper()->getRegion(regionNames[0]);
     HashMapOfCacheable entryMap;
     entryMap.clear();
     char key[256];
     char value[256];
     for (int32_t item = 0; item < 1000; item++) {
       sprintf(key, "key-%d", item);
       sprintf(value, "%d", item);
       entryMap.emplace(CacheableKey::create(key),
                        CacheableString::create(value));
       LOGDEBUG(
           "CPPTEST:PutAllOneTask Doing PutAll on key using key: = %s: & value: "
           "= "
           "%s",
           key, value);
     }
     try {
       dataReg->putAll(entryMap);
     } catch (Exception &ex) {
       LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
       FAIL(ex.what());
     } catch (...) {
       LOGERROR("CPPTEST: PutAll caused random exception in PutAllOneTask");
       cleanProc();
       FAIL("PutAll caused unexpected exception");
     }
     LOG("PutAllOneTask completed.");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT1, PutAllTwoTask)
   {
     LOG("PutAllTwoTask started.");
     auto dataReg = getHelper()->getRegion(regionNames[0]);
     HashMapOfCacheable entryMap;
     entryMap.clear();
     char key[256];
     char value[256];
     for (int32_t item = 1000; item < 2000; item++) {
       sprintf(key, "key-%d", item);
       sprintf(value, "%d", item);
       LOGDEBUG(
           "CPPTEST:PutAllTwoTask Doing PutAll on key using key: = %s: & value: "
           "= "
           "%s",
           key, value);
       entryMap.emplace(CacheableKey::create(key),
                        CacheableString::create(value));
     }
     try {
       dataReg->putAll(entryMap);
     } catch (Exception &ex) {
       LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
       FAIL(ex.what());
     } catch (...) {
       LOGERROR("CPPTEST: PutAll caused random exception in PutAllTwoTask");
       cleanProc();
       FAIL("PutAll caused unexpected exception");
     }
     LOG("PutAllTwoTask completed.");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT1, PutAllThreeTask)
   {
     LOG("PutAllThreeTask started.");
     auto dataReg = getHelper()->getRegion(regionNames[0]);
     HashMapOfCacheable entryMap;
     entryMap.clear();
     char key[256];
     char value[256];
     for (int32_t item = 2000; item < 3000; item++) {
       sprintf(key, "key-%d", item);
       sprintf(value, "%d", item);
       LOGDEBUG(
           "CPPTEST:PutAllThreeTask Doing PutAll on key using key: = %s: & "
           "value: "
           "= %s",
           key, value);
       entryMap.emplace(CacheableKey::create(key),
                        CacheableString::create(value));
     }
     try {
       dataReg->putAll(entryMap);
     } catch (Exception &ex) {
       LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
       FAIL(ex.what());
     } catch (...) {
       LOGERROR("CPPTEST: PutAll caused random exception in PutAllThreeTask");
       cleanProc();
       FAIL("PutAll caused unexpected exception");
     }
     LOG("PutAllThreeTask completed.");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT1, PutAllFourTask)
   {
     LOG("PutAllFourTask started.");
     auto dataReg = getHelper()->getRegion(regionNames[0]);
     HashMapOfCacheable entryMap;
     entryMap.clear();
     char key[256];
     char value[256];
     for (int32_t item = 3000; item < 4000; item++) {
       sprintf(key, "key-%d", item);
       sprintf(value, "%d", item);
       LOGDEBUG(
           "CPPTEST:PutAllFourTask Doing PutAll on key using key: = %s: & "
           "value: "
           "= %s",
           key, value);
       entryMap.emplace(CacheableKey::create(key),
                        CacheableString::create(value));
     }
     try {
       dataReg->putAll(entryMap);
     } catch (Exception &ex) {
       LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
       FAIL(ex.what());
     } catch (...) {
       LOGERROR("CPPTEST: PutAll caused random exception in PutAllFourTask");
       cleanProc();
       FAIL("PutAll caused unexpected exception");
     }
     LOG("PutAllFourTask completed.");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT2, VerifyAllPutAllTask)
   {
     LOG("VerifyAllPutAllTask started.");

     auto dataReg = getHelper()->getRegion(regionNames[0]);
     ASSERT(dataReg != nullptr, "Region not found.");
     LOGINFO("dataregion size is %d: ", dataReg->size());
     LOGINFO("dataregion getCreates is %d: ", reg1Listener1->getCreates());
     ASSERT(reg1Listener1->getCreates() == 4000,
            "Got wrong number of creation events.");

     ASSERT(dataReg->size() == 4000, "Expected 4000 entries in region");
     char key[256];
     char value[256];
     for (int32_t item = 0; item < 4000; item++) {
       sprintf(key, "key-%d", item);
       sprintf(value, "%d", item);
       LOGDEBUG("CPPTEST:VerifyAllPutAllTask Doing get on key using: = %s: ",
                key);
       auto checkPtr = std::dynamic_pointer_cast<CacheableString>(
           dataReg->get(CacheableKey::create(key)));
       ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
       LOGDEBUG("CPPTEST:VerifyAllPutAllTask value is: = %s: ",
                checkPtr->value().c_str());
       ASSERT(atoi(checkPtr->value().c_str()) == item, "Value did not match.");
     }
     LOG("VerifyAllPutAllTask completed.");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllOneTask)
   {
     LOG("RemoveAllOneTask started.");
     auto dataReg = getHelper()->getRegion(regionNames[0]);
     HashMapOfCacheable entryMap;
     std::vector<std::shared_ptr<CacheableKey>> keys;
     entryMap.clear();
     char key[256];
     char value[256];
     for (int32_t item = 0; item < 1000; item++) {
       sprintf(key, "key-%d", item);
       sprintf(value, "%d", item);
       entryMap.emplace(CacheableKey::create(key),
                        CacheableString::create(value));
       keys.push_back(CacheableKey::create(key));
       LOGDEBUG(
           "CPPTEST:RemoveAllOneTask Doing PutAll on key using key: = %s: & "
           "value: = %s",
           key, value);
     }
     try {
       dataReg->putAll(entryMap);
       dataReg->removeAll(keys);
     } catch (Exception &ex) {
       LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
       FAIL(ex.what());
     } catch (...) {
       LOGERROR("CPPTEST: RemoveAll caused random exception in PutAllOneTask");
       cleanProc();
       FAIL("RemoveAll caused unexpected exception");
     }
     LOG("RemoveAllOneTask completed.");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllTwoTask)
   {
     LOG("RemoveAllTwoTask started.");
     auto dataReg = getHelper()->getRegion(regionNames[0]);
     HashMapOfCacheable entryMap;
     std::vector<std::shared_ptr<CacheableKey>> keys;
     entryMap.clear();
     char key[256];
     char value[256];
     for (int32_t item = 1000; item < 2000; item++) {
       sprintf(key, "key-%d", item);
       sprintf(value, "%d", item);
       entryMap.emplace(CacheableKey::create(key),
                        CacheableString::create(value));
       keys.push_back(CacheableKey::create(key));
       LOGDEBUG(
           "CPPTEST:RemoveAllTwoTask Doing RemoveAll on key using key: = %s: & "
           "value: = %s",
           key, value);
     }
     try {
       dataReg->putAll(entryMap);
       dataReg->removeAll(keys);
     } catch (Exception &ex) {
       LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
       FAIL(ex.what());
     } catch (...) {
       LOGERROR("CPPTEST: RemoveAll caused random exception in PutAllTwoTask");
       cleanProc();
       FAIL("RemoveAll caused unexpected exception");
     }
     LOG("RemoveAllTwoTask completed.");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllThreeTask)
   {
     LOG("RemoveAllThreeTask started.");
     auto dataReg = getHelper()->getRegion(regionNames[0]);
     HashMapOfCacheable entryMap;
     std::vector<std::shared_ptr<CacheableKey>> keys;
     entryMap.clear();
     char key[256];
     char value[256];
     for (int32_t item = 2000; item < 3000; item++) {
       sprintf(key, "key-%d", item);
       sprintf(value, "%d", item);
       entryMap.emplace(CacheableKey::create(key),
                        CacheableString::create(value));
       keys.push_back(CacheableKey::create(key));
       LOGDEBUG(
           "CPPTEST:RemoveAllThreeTask Doing RemoveAll on key using key: = %s: "
           "& "
           "value: = %s",
           key, value);
     }
     try {
       dataReg->putAll(entryMap);
       dataReg->removeAll(keys);
     } catch (Exception &ex) {
       LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
       FAIL(ex.what());
     } catch (...) {
       LOGERROR(
           "CPPTEST: RemoveAll caused random exception in RemoveAllThreeTask");
       cleanProc();
       FAIL("RemoveAll caused unexpected exception");
     }
     LOG("RemoveAllThreeTask completed.");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllFourTask)
   {
     LOG("RemoveAllFourTask started.");
     auto dataReg = getHelper()->getRegion(regionNames[0]);
     HashMapOfCacheable entryMap;
     std::vector<std::shared_ptr<CacheableKey>> keys;
     entryMap.clear();
     char key[256];
     char value[256];
     for (int32_t item = 3000; item < 4000; item++) {
       sprintf(key, "key-%d", item);
       sprintf(value, "%d", item);
       entryMap.emplace(CacheableKey::create(key),
                        CacheableString::create(value));
       keys.push_back(CacheableKey::create(key));
       LOGDEBUG(
           "CPPTEST:RemoveAllFourTask Doing RemoveAll on key using key: = %s: & "
           "value: = %s",
           key, value);
     }
     try {
       dataReg->putAll(entryMap);
       dataReg->removeAll(keys);
     } catch (Exception &ex) {
       LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
       FAIL(ex.what());
     } catch (...) {
       LOGERROR(
           "CPPTEST: RemoveAll caused random exception in RemoveAllFourTask");
       cleanProc();
       FAIL("RemoveAll caused unexpected exception");
     }
     LOG("RemoveAllFourTask completed.");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT2, VerifyAllRemoveAllTask)
   {
     LOG("VerifyAllRemoveAllTask started.");

     auto dataReg = getHelper()->getRegion(regionNames[0]);
     ASSERT(dataReg != nullptr, "Region not found.");
     LOGINFO("dataregion size is %d: ", dataReg->size());
     LOGINFO("dataregion getDestroys is %d: ", reg1Listener1->getDestroys());
     ASSERT(reg1Listener1->getDestroys() == 4000,
            "Got wrong number of destroy events.");
     ASSERT(dataReg->size() == 0, "Expected 0 entries in region");
     LOG("VerifyAllRemoveAllTask completed.");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT1, CloseCache1)
   { cleanProc(); }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT2, CloseCache2)
   { cleanProc(); }
 END_TASK_DEFINITION

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

 DUNIT_TASK_DEFINITION(SERVER1, CloseServer2)
   {
     if (isLocalServer) {
       CacheHelper::closeServer(2);
       LOG("SERVER2 stopped");
     }
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(SERVER2, CloseServer3)
   {
     if (isLocalServer) {
       CacheHelper::closeServer(3);
       LOG("SERVER3 stopped");
     }
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(SERVER2, CloseServer4)
   {
     if (isLocalServer) {
       CacheHelper::closeServer(4);
       LOG("SERVER4 stopped");
     }
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(SERVER1, CreateLocator1)
   {
     // starting locator
     if (isLocator) CacheHelper::initLocator(1);
     LOG("Locator1 started");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(SERVER1, CloseLocator1)
   {
     // stop locator
     if (isLocator) {
       CacheHelper::closeLocator(1);
       LOG("Locator1 stopped");
     }
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(SERVER1, CreateServer1_With_Locator_PR)
   {
     // starting servers
     if (isLocalServer) {
       CacheHelper::initServer(1, "cacheserver1_pr_putall.xml", locatorsG);
     }
     if (isLocalServer) {
       CacheHelper::initServer(2, "cacheserver2_pr_putall.xml", locatorsG);
     }
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(SERVER2, CreateServer2_With_Locator_PR)
   {
     // starting servers
     if (isLocalServer) {
       CacheHelper::initServer(3, "cacheserver3_pr_putall.xml", locatorsG);
     }
     if (isLocalServer) {
       CacheHelper::initServer(4, "cacheserver4_pr_putall.xml", locatorsG);
     }
   }
 END_TASK_DEFINITION

 DUNIT_MAIN
   {
     CALL_TASK(CreateLocator1);

     CALL_TASK(CreateServer1_With_Locator_PR);

     CALL_TASK(StepOne_Pooled_Locator_Client1);
     CALL_TASK(StepOne_Pooled_Locator_Client2);

     CALL_TASK(StepTwo_RegisterAllKeys);

     CALL_TASK(PutAllOneTask);
     CALL_TASK(CreateServer2_With_Locator_PR);

     CALL_TASK(CloseServer1);
     CALL_TASK(CloseServer2);

     CALL_TASK(PutAllTwoTask);
     CALL_TASK(CreateServer1_With_Locator_PR);

     CALL_TASK(CloseServer3);
     CALL_TASK(CloseServer4);

     CALL_TASK(PutAllThreeTask);

     CALL_TASK(CreateServer2_With_Locator_PR);
     CALL_TASK(PutAllFourTask);

     CALL_TASK(VerifyAllPutAllTask);

     CALL_TASK(CloseCache1);
     CALL_TASK(CloseCache2);

     CALL_TASK(CloseServer1);
     CALL_TASK(CloseServer2);
     CALL_TASK(CloseServer3);
     CALL_TASK(CloseServer4);

     CALL_TASK(CloseLocator1);
   }
 END_MAIN

 DUNIT_MAIN
   {
     CALL_TASK(CreateLocator1);

     CALL_TASK(CreateServer1_With_Locator_PR);

     CALL_TASK(StepOne_Pooled_Locator_Client1);
     CALL_TASK(StepOne_Pooled_Locator_Client2);

     CALL_TASK(StepTwo_RegisterAllKeys);

     CALL_TASK(RemoveAllOneTask);
     CALL_TASK(CreateServer2_With_Locator_PR);

     CALL_TASK(CloseServer1);
     CALL_TASK(CloseServer2);

     CALL_TASK(RemoveAllTwoTask);
     CALL_TASK(CreateServer1_With_Locator_PR);

     CALL_TASK(CloseServer3);
     CALL_TASK(CloseServer4);

     CALL_TASK(RemoveAllThreeTask);

     CALL_TASK(CreateServer2_With_Locator_PR);
     CALL_TASK(RemoveAllFourTask);

     CALL_TASK(VerifyAllRemoveAllTask);

     CALL_TASK(CloseCache1);
     CALL_TASK(CloseCache2);

     CALL_TASK(CloseServer1);
     CALL_TASK(CloseServer2);
     CALL_TASK(CloseServer3);
     CALL_TASK(CloseServer4);

     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 "testThinClientPRPutAllFailover"
	#define ROOT_SCOPE DISTRIBUTED_ACK

	#include "fw_dunit.hpp"
	#include "BuiltinCacheableWrappers.hpp"
	#include "Utils.hpp"

	#include <ace/OS.h>
	#include <ace/High_Res_Timer.h>
	#include "TallyListener.hpp"
	#include <string>
	#include "CacheHelper.hpp"

	// Include these 2 headers for access to CacheImpl for test hooks.
	#include "CacheImplHelper.hpp"
	#include "testUtils.hpp"

	#include "ThinClientHelper.hpp"

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

	using apache::geode::client::Exception;
	using apache::geode::client::HashMapOfCacheable;

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

	std::shared_ptr<TallyListener> reg1Listener1;
	bool isLocalServer = false;
	static bool isLocator = false;
	const char *locatorsG =
	CacheHelper::getLocatorHostPort(isLocator, isLocalServer, 1);

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

	DUNIT_TASK_DEFINITION(SERVER1, CreateServer1)
	{
	if (isLocalServer) CacheHelper::initServer(1, "cacheserver1_pr_putall.xml");
	LOG("SERVER1 started");
	if (isLocalServer) CacheHelper::initServer(2, "cacheserver2_pr_putall.xml");
	LOG("SERVER2 started");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(SERVER2, CreateServer2)
	{
	if (isLocalServer) CacheHelper::initServer(3, "cacheserver3_pr_putall.xml");
	LOG("SERVER3 started");
	if (isLocalServer) CacheHelper::initServer(4, "cacheserver4_pr_putall.xml");
	LOG("SERVER4 started");
	}
	END_TASK_DEFINITION

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

	getHelper()->createPoolWithLocators("__TEST_POOL1__", locatorsG);
	getHelper()->createRegionAndAttachPool(regionNames[0], USE_ACK,
	"__TEST_POOL1__");
	getHelper()->createRegionAndAttachPool(regionNames[1], NO_ACK,
	"__TEST_POOL1__");

	reg1Listener1 = std::make_shared<TallyListener>();
	setCacheListener(regionNames[0], reg1Listener1);
	LOG("StepOne_Pooled_Locator_Client1 complete.");
	}
	END_TASK_DEFINITION

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

	getHelper()->createPoolWithLocators("__TEST_POOL1__", locatorsG, true, 2);
	getHelper()->createRegionAndAttachPool(regionNames[0], USE_ACK,
	"__TEST_POOL1__");
	getHelper()->createRegionAndAttachPool(regionNames[1], NO_ACK,
	"__TEST_POOL1__");

	reg1Listener1 = std::make_shared<TallyListener>();
	setCacheListener(regionNames[0], reg1Listener1);
	LOG("StepOne_Pooled_Locator_Client2 complete.");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT2, StepTwo_RegisterAllKeys)
	{
	auto regPtr0 = getHelper()->getRegion(regionNames[0]);
	regPtr0->registerAllKeys();
	auto regPtr1 = getHelper()->getRegion(regionNames[1]);
	regPtr1->registerAllKeys();
	LOG("StepTwo_Pooled_EndPoint_RegisterAllKeys complete.");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT1, PutAllOneTask)
	{
	LOG("PutAllOneTask started.");
	auto dataReg = getHelper()->getRegion(regionNames[0]);
	HashMapOfCacheable entryMap;
	entryMap.clear();
	char key[256];
	char value[256];
	for (int32_t item = 0; item < 1000; item++) {
	sprintf(key, "key-%d", item);
	sprintf(value, "%d", item);
	entryMap.emplace(CacheableKey::create(key),
	CacheableString::create(value));
	LOGDEBUG(
	"CPPTEST:PutAllOneTask Doing PutAll on key using key: = %s: & value: "
	"= "
	"%s",
	key, value);
	}
	try {
	dataReg->putAll(entryMap);
	} catch (Exception &ex) {
	LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
	FAIL(ex.what());
	} catch (...) {
	LOGERROR("CPPTEST: PutAll caused random exception in PutAllOneTask");
	cleanProc();
	FAIL("PutAll caused unexpected exception");
	}
	LOG("PutAllOneTask completed.");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT1, PutAllTwoTask)
	{
	LOG("PutAllTwoTask started.");
	auto dataReg = getHelper()->getRegion(regionNames[0]);
	HashMapOfCacheable entryMap;
	entryMap.clear();
	char key[256];
	char value[256];
	for (int32_t item = 1000; item < 2000; item++) {
	sprintf(key, "key-%d", item);
	sprintf(value, "%d", item);
	LOGDEBUG(
	"CPPTEST:PutAllTwoTask Doing PutAll on key using key: = %s: & value: "
	"= "
	"%s",
	key, value);
	entryMap.emplace(CacheableKey::create(key),
	CacheableString::create(value));
	}
	try {
	dataReg->putAll(entryMap);
	} catch (Exception &ex) {
	LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
	FAIL(ex.what());
	} catch (...) {
	LOGERROR("CPPTEST: PutAll caused random exception in PutAllTwoTask");
	cleanProc();
	FAIL("PutAll caused unexpected exception");
	}
	LOG("PutAllTwoTask completed.");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT1, PutAllThreeTask)
	{
	LOG("PutAllThreeTask started.");
	auto dataReg = getHelper()->getRegion(regionNames[0]);
	HashMapOfCacheable entryMap;
	entryMap.clear();
	char key[256];
	char value[256];
	for (int32_t item = 2000; item < 3000; item++) {
	sprintf(key, "key-%d", item);
	sprintf(value, "%d", item);
	LOGDEBUG(
	"CPPTEST:PutAllThreeTask Doing PutAll on key using key: = %s: & "
	"value: "
	"= %s",
	key, value);
	entryMap.emplace(CacheableKey::create(key),
	CacheableString::create(value));
	}
	try {
	dataReg->putAll(entryMap);
	} catch (Exception &ex) {
	LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
	FAIL(ex.what());
	} catch (...) {
	LOGERROR("CPPTEST: PutAll caused random exception in PutAllThreeTask");
	cleanProc();
	FAIL("PutAll caused unexpected exception");
	}
	LOG("PutAllThreeTask completed.");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT1, PutAllFourTask)
	{
	LOG("PutAllFourTask started.");
	auto dataReg = getHelper()->getRegion(regionNames[0]);
	HashMapOfCacheable entryMap;
	entryMap.clear();
	char key[256];
	char value[256];
	for (int32_t item = 3000; item < 4000; item++) {
	sprintf(key, "key-%d", item);
	sprintf(value, "%d", item);
	LOGDEBUG(
	"CPPTEST:PutAllFourTask Doing PutAll on key using key: = %s: & "
	"value: "
	"= %s",
	key, value);
	entryMap.emplace(CacheableKey::create(key),
	CacheableString::create(value));
	}
	try {
	dataReg->putAll(entryMap);
	} catch (Exception &ex) {
	LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
	FAIL(ex.what());
	} catch (...) {
	LOGERROR("CPPTEST: PutAll caused random exception in PutAllFourTask");
	cleanProc();
	FAIL("PutAll caused unexpected exception");
	}
	LOG("PutAllFourTask completed.");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT2, VerifyAllPutAllTask)
	{
	LOG("VerifyAllPutAllTask started.");

	auto dataReg = getHelper()->getRegion(regionNames[0]);
	ASSERT(dataReg != nullptr, "Region not found.");
	LOGINFO("dataregion size is %d: ", dataReg->size());
	LOGINFO("dataregion getCreates is %d: ", reg1Listener1->getCreates());
	ASSERT(reg1Listener1->getCreates() == 4000,
	"Got wrong number of creation events.");

	ASSERT(dataReg->size() == 4000, "Expected 4000 entries in region");
	char key[256];
	char value[256];
	for (int32_t item = 0; item < 4000; item++) {
	sprintf(key, "key-%d", item);
	sprintf(value, "%d", item);
	LOGDEBUG("CPPTEST:VerifyAllPutAllTask Doing get on key using: = %s: ",
	key);
	auto checkPtr = std::dynamic_pointer_cast<CacheableString>(
	dataReg->get(CacheableKey::create(key)));
	ASSERT(checkPtr != nullptr, "Value Ptr should not be null.");
	LOGDEBUG("CPPTEST:VerifyAllPutAllTask value is: = %s: ",
	checkPtr->value().c_str());
	ASSERT(atoi(checkPtr->value().c_str()) == item, "Value did not match.");
	}
	LOG("VerifyAllPutAllTask completed.");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllOneTask)
	{
	LOG("RemoveAllOneTask started.");
	auto dataReg = getHelper()->getRegion(regionNames[0]);
	HashMapOfCacheable entryMap;
	std::vector<std::shared_ptr<CacheableKey>> keys;
	entryMap.clear();
	char key[256];
	char value[256];
	for (int32_t item = 0; item < 1000; item++) {
	sprintf(key, "key-%d", item);
	sprintf(value, "%d", item);
	entryMap.emplace(CacheableKey::create(key),
	CacheableString::create(value));
	keys.push_back(CacheableKey::create(key));
	LOGDEBUG(
	"CPPTEST:RemoveAllOneTask Doing PutAll on key using key: = %s: & "
	"value: = %s",
	key, value);
	}
	try {
	dataReg->putAll(entryMap);
	dataReg->removeAll(keys);
	} catch (Exception &ex) {
	LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
	FAIL(ex.what());
	} catch (...) {
	LOGERROR("CPPTEST: RemoveAll caused random exception in PutAllOneTask");
	cleanProc();
	FAIL("RemoveAll caused unexpected exception");
	}
	LOG("RemoveAllOneTask completed.");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllTwoTask)
	{
	LOG("RemoveAllTwoTask started.");
	auto dataReg = getHelper()->getRegion(regionNames[0]);
	HashMapOfCacheable entryMap;
	std::vector<std::shared_ptr<CacheableKey>> keys;
	entryMap.clear();
	char key[256];
	char value[256];
	for (int32_t item = 1000; item < 2000; item++) {
	sprintf(key, "key-%d", item);
	sprintf(value, "%d", item);
	entryMap.emplace(CacheableKey::create(key),
	CacheableString::create(value));
	keys.push_back(CacheableKey::create(key));
	LOGDEBUG(
	"CPPTEST:RemoveAllTwoTask Doing RemoveAll on key using key: = %s: & "
	"value: = %s",
	key, value);
	}
	try {
	dataReg->putAll(entryMap);
	dataReg->removeAll(keys);
	} catch (Exception &ex) {
	LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
	FAIL(ex.what());
	} catch (...) {
	LOGERROR("CPPTEST: RemoveAll caused random exception in PutAllTwoTask");
	cleanProc();
	FAIL("RemoveAll caused unexpected exception");
	}
	LOG("RemoveAllTwoTask completed.");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllThreeTask)
	{
	LOG("RemoveAllThreeTask started.");
	auto dataReg = getHelper()->getRegion(regionNames[0]);
	HashMapOfCacheable entryMap;
	std::vector<std::shared_ptr<CacheableKey>> keys;
	entryMap.clear();
	char key[256];
	char value[256];
	for (int32_t item = 2000; item < 3000; item++) {
	sprintf(key, "key-%d", item);
	sprintf(value, "%d", item);
	entryMap.emplace(CacheableKey::create(key),
	CacheableString::create(value));
	keys.push_back(CacheableKey::create(key));
	LOGDEBUG(
	"CPPTEST:RemoveAllThreeTask Doing RemoveAll on key using key: = %s: "
	"& "
	"value: = %s",
	key, value);
	}
	try {
	dataReg->putAll(entryMap);
	dataReg->removeAll(keys);
	} catch (Exception &ex) {
	LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
	FAIL(ex.what());
	} catch (...) {
	LOGERROR(
	"CPPTEST: RemoveAll caused random exception in RemoveAllThreeTask");
	cleanProc();
	FAIL("RemoveAll caused unexpected exception");
	}
	LOG("RemoveAllThreeTask completed.");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT1, RemoveAllFourTask)
	{
	LOG("RemoveAllFourTask started.");
	auto dataReg = getHelper()->getRegion(regionNames[0]);
	HashMapOfCacheable entryMap;
	std::vector<std::shared_ptr<CacheableKey>> keys;
	entryMap.clear();
	char key[256];
	char value[256];
	for (int32_t item = 3000; item < 4000; item++) {
	sprintf(key, "key-%d", item);
	sprintf(value, "%d", item);
	entryMap.emplace(CacheableKey::create(key),
	CacheableString::create(value));
	keys.push_back(CacheableKey::create(key));
	LOGDEBUG(
	"CPPTEST:RemoveAllFourTask Doing RemoveAll on key using key: = %s: & "
	"value: = %s",
	key, value);
	}
	try {
	dataReg->putAll(entryMap);
	dataReg->removeAll(keys);
	} catch (Exception &ex) {
	LOGERROR("CPPTEST: Unexpected %s: %s", ex.getName().c_str(), ex.what());
	FAIL(ex.what());
	} catch (...) {
	LOGERROR(
	"CPPTEST: RemoveAll caused random exception in RemoveAllFourTask");
	cleanProc();
	FAIL("RemoveAll caused unexpected exception");
	}
	LOG("RemoveAllFourTask completed.");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT2, VerifyAllRemoveAllTask)
	{
	LOG("VerifyAllRemoveAllTask started.");

	auto dataReg = getHelper()->getRegion(regionNames[0]);
	ASSERT(dataReg != nullptr, "Region not found.");
	LOGINFO("dataregion size is %d: ", dataReg->size());
	LOGINFO("dataregion getDestroys is %d: ", reg1Listener1->getDestroys());
	ASSERT(reg1Listener1->getDestroys() == 4000,
	"Got wrong number of destroy events.");
	ASSERT(dataReg->size() == 0, "Expected 0 entries in region");
	LOG("VerifyAllRemoveAllTask completed.");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT1, CloseCache1)
	{ cleanProc(); }
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT2, CloseCache2)
	{ cleanProc(); }
	END_TASK_DEFINITION

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

	DUNIT_TASK_DEFINITION(SERVER1, CloseServer2)
	{
	if (isLocalServer) {
	CacheHelper::closeServer(2);
	LOG("SERVER2 stopped");
	}
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(SERVER2, CloseServer3)
	{
	if (isLocalServer) {
	CacheHelper::closeServer(3);
	LOG("SERVER3 stopped");
	}
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(SERVER2, CloseServer4)
	{
	if (isLocalServer) {
	CacheHelper::closeServer(4);
	LOG("SERVER4 stopped");
	}
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(SERVER1, CreateLocator1)
	{
	// starting locator
	if (isLocator) CacheHelper::initLocator(1);
	LOG("Locator1 started");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(SERVER1, CloseLocator1)
	{
	// stop locator
	if (isLocator) {
	CacheHelper::closeLocator(1);
	LOG("Locator1 stopped");
	}
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(SERVER1, CreateServer1_With_Locator_PR)
	{
	// starting servers
	if (isLocalServer) {
	CacheHelper::initServer(1, "cacheserver1_pr_putall.xml", locatorsG);
	}
	if (isLocalServer) {
	CacheHelper::initServer(2, "cacheserver2_pr_putall.xml", locatorsG);
	}
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(SERVER2, CreateServer2_With_Locator_PR)
	{
	// starting servers
	if (isLocalServer) {
	CacheHelper::initServer(3, "cacheserver3_pr_putall.xml", locatorsG);
	}
	if (isLocalServer) {
	CacheHelper::initServer(4, "cacheserver4_pr_putall.xml", locatorsG);
	}
	}
	END_TASK_DEFINITION

	DUNIT_MAIN
	{
	CALL_TASK(CreateLocator1);

	CALL_TASK(CreateServer1_With_Locator_PR);

	CALL_TASK(StepOne_Pooled_Locator_Client1);
	CALL_TASK(StepOne_Pooled_Locator_Client2);

	CALL_TASK(StepTwo_RegisterAllKeys);

	CALL_TASK(PutAllOneTask);
	CALL_TASK(CreateServer2_With_Locator_PR);

	CALL_TASK(CloseServer1);
	CALL_TASK(CloseServer2);

	CALL_TASK(PutAllTwoTask);
	CALL_TASK(CreateServer1_With_Locator_PR);

	CALL_TASK(CloseServer3);
	CALL_TASK(CloseServer4);

	CALL_TASK(PutAllThreeTask);

	CALL_TASK(CreateServer2_With_Locator_PR);
	CALL_TASK(PutAllFourTask);

	CALL_TASK(VerifyAllPutAllTask);

	CALL_TASK(CloseCache1);
	CALL_TASK(CloseCache2);

	CALL_TASK(CloseServer1);
	CALL_TASK(CloseServer2);
	CALL_TASK(CloseServer3);
	CALL_TASK(CloseServer4);

	CALL_TASK(CloseLocator1);
	}
	END_MAIN

	DUNIT_MAIN
	{
	CALL_TASK(CreateLocator1);

	CALL_TASK(CreateServer1_With_Locator_PR);

	CALL_TASK(StepOne_Pooled_Locator_Client1);
	CALL_TASK(StepOne_Pooled_Locator_Client2);

	CALL_TASK(StepTwo_RegisterAllKeys);

	CALL_TASK(RemoveAllOneTask);
	CALL_TASK(CreateServer2_With_Locator_PR);

	CALL_TASK(CloseServer1);
	CALL_TASK(CloseServer2);

	CALL_TASK(RemoveAllTwoTask);
	CALL_TASK(CreateServer1_With_Locator_PR);

	CALL_TASK(CloseServer3);
	CALL_TASK(CloseServer4);

	CALL_TASK(RemoveAllThreeTask);

	CALL_TASK(CreateServer2_With_Locator_PR);
	CALL_TASK(RemoveAllFourTask);

	CALL_TASK(VerifyAllRemoveAllTask);

	CALL_TASK(CloseCache1);
	CALL_TASK(CloseCache2);

	CALL_TASK(CloseServer1);
	CALL_TASK(CloseServer2);
	CALL_TASK(CloseServer3);
	CALL_TASK(CloseServer4);

	CALL_TASK(CloseLocator1);
	}

	END_MAIN