src/cppcache/integration-test/ThinClientVersionedOps.hpp - geode-native - Git at Google

 #pragma once

 #ifndef GEODE_INTEGRATION_TEST_THINCLIENTVERSIONEDOPS_H_
 #define GEODE_INTEGRATION_TEST_THINCLIENTVERSIONEDOPS_H_

 /*
  * 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 "testThinClientVersionedOps"

 #include "ThinClientSecurityHelper.hpp"

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

 // This is the test for tracking work. bug#304

 putThread *thread1 = NULL;
 putThread *thread2 = NULL;
 putThread *thread3 = NULL;
 putThread *thread4 = NULL;

 const char *regNames[] = {"DistRegionAck", "DistRegionNoAck"};
 const char *group1 = "A";
 const char *group2 = "B";
 // const char * endPoints1 = CacheHelper::getTcrEndpoints( isLocalServer1, 3 );
 std::string gfendpoints1 = "localhost:";
 std::string gfendpoints2 = "localhost:";

 bool isLocalServer1 = false;

 static bool isLocator1 = false;
 const char *locatorsG =
     CacheHelper::getLocatorHostPort(isLocator1, isLocalServer1, 1);

 CacheableStringPtr c1v11;
 CacheableStringPtr c1v12;
 CacheableStringPtr c1v13;
 CacheableStringPtr c1v14;
 CacheableStringPtr c1v15;

 CacheableStringPtr s1v11;
 CacheableStringPtr s1v12;
 CacheableStringPtr s1v13;
 CacheableStringPtr s1v14;
 CacheableStringPtr s1v15;

 CacheableStringPtr c2v11;
 CacheableStringPtr c2v12;
 CacheableStringPtr c2v13;
 CacheableStringPtr c2v14;
 CacheableStringPtr c2v15;

 CacheableStringPtr s2v11;
 CacheableStringPtr s2v12;
 CacheableStringPtr s2v13;
 CacheableStringPtr s2v14;
 CacheableStringPtr s2v15;

 void verifyAllValues() {
   LOGINFO("verifyAllValues TEST-1");
   /*LOGINFO("c1v11 = %s", c1v11->asChar());
   LOGINFO("verifyAllValues TEST-2");
   LOGINFO("c1v12 = %s", c1v12->asChar());
   LOGINFO("c1v13 = %s", c1v13->asChar());
   LOGINFO("c1v14 = %s", c1v14->asChar());
   LOGINFO("c1v15 = %s", c1v15->asChar());

   LOGINFO("s1v11 = %s", s1v11->asChar());
   LOGINFO("s1v12 = %s", s1v12->asChar());
   LOGINFO("s1v13 = %s", s1v13->asChar());
   LOGINFO("s1v14 = %s", s1v14->asChar());
   LOGINFO("s1v15 = %s", s1v15->asChar());

   LOGINFO("c2v11 = %s", c2v11->asChar());
   LOGINFO("c2v12 = %s", c2v12->asChar());
   LOGINFO("c2v13 = %s", c2v13->asChar());
   LOGINFO("c2v14 = %s", c2v14->asChar());
   LOGINFO("c2v15 = %s", c2v15->asChar());

   LOGINFO("s2v11 = %s", s2v11->asChar());
   LOGINFO("s2v12 = %s", s2v12->asChar());
   LOGINFO("s2v13 = %s", s2v13->asChar());
   LOGINFO("s2v14 = %s", s2v14->asChar());
   LOGINFO("s2v15 = %s", s2v15->asChar());*/
 }

 // added
 DUNIT_TASK_DEFINITION(SERVER1, StartServer1)
   {
     LOG("starting SERVER1...");
     if (isLocalServer1) {
       CacheHelper::initServer(1, "cacheserver_concurrency_enabled1.xml");
     }
     LOG("SERVER1 started");
   }
 END_TASK_DEFINITION

 // added
 DUNIT_TASK_DEFINITION(SERVER2, StartServer2)
   {
     LOG("starting SERVER2...");
     if (isLocalServer1) {
       CacheHelper::initServer(2, "cacheserver_concurrency_enabled2.xml");
     }
     LOG("SERVER2 started");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT1, StartClient1)
   {
     // TOOD::check for poolwithendpoints or locators

     // By default poolwithendpoints
     // char tmp1[100];
     // sprintf( tmp1, "%d", CacheHelper::staticHostPort1 );
     // gfendpoints1 += tmp1;

     // initClientWithPool(true/*isthinClient*/, NULL/*poolName*/,
     // NULL/*locators*/,serverGroup1, NULL/*servers*/,
     // NULLPTR/*PropertiesPtr&*/,
     // 0/*redundancy*/, true/*clientNotification*/,
     // -1/*subscriptionAckInterval*/,
     // 5/*connections*/, 60000/*loadConditioningInterval*/);
     // RegionPtr regPtr0 = createRegionAndAttachPool(regNames[0],USE_ACK, NULL);

     initClient(true);
     getHelper()->createPoolWithLocators("__TEST_POOL1__", locatorsG, true, -1,
                                         -1, -1, false, group1);
     RegionPtr regPtr0 = getHelper()->createRegionAndAttachPool(
         regNames[0], USE_ACK, "__TEST_POOL1__", true);
     LOG("StepOne_Pooled_Locator1 complete.");

     regPtr0->registerAllKeys();

     LOG("Client-1 Init complete.");
   }
 END_TASK_DEFINITION

 // startClient-2
 DUNIT_TASK_DEFINITION(CLIENT2, StartClient2)
   {
     // TOOD::check for poolwithendpoints or locators
     /*	LOG( "Client-2 Init -1" );
     //By default poolwithendpoints
           char tmp2[100];
           LOG( "Client-2 Init -2" );
           sprintf( tmp2, "%d", CacheHelper::staticHostPort2 );
           LOG( "Client-2 Init -3" );
           gfendpoints2 += tmp2;
           LOG( "Client-2 Init -4" );
     initClientWithPool(true, NULL, NULL, serverGroup2, gfendpoints2.c_str(),
     NULLPTR, 0, true, -1, 5, 60000);
     LOG( "Client-2 Init -5" );

     RegionPtr regPtr0 = createRegionAndAttachPool(regNames[0],USE_ACK, NULL);
     LOG( "Client-2 Init -6" );

     */
     initClient(true);
     getHelper()->createPoolWithLocators("__TEST_POOL1__", locatorsG, true, -1,
                                         -1, -1, false, group2);
     RegionPtr regPtr0 = getHelper()->createRegionAndAttachPool(
         regNames[0], USE_ACK, "__TEST_POOL1__", true);
     LOG("StepOne_Pooled_Locator1 complete.");

     regPtr0->registerAllKeys();
     LOG("Client-2 StartClient2 complete.");
   }
 END_TASK_DEFINITION

 // threadPutonClient1
 DUNIT_TASK_DEFINITION(CLIENT1, threadPutonClient1)
   {
     RegionPtr rptr = getHelper()->getRegion(regNames[0]);
     thread4 = new putThread(rptr, false);
     thread4->setParams(0, 10, 1, true, false, 0);
     thread4->start();
     LOG("Task: threadPutonClient1 Done");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT2, transactionPutOnClient2)
   {
     RegionPtr rptr = getHelper()->getRegion(regNames[0]);
     CacheTransactionManagerPtr txManager =
         getHelper()->getCache()->getCacheTransactionManager();

     txManager->begin();
     CacheableKeyPtr keyPtr1 = CacheableKey::create("key-1");
     CacheableStringPtr valPtr = CacheableString::create("client2-value1");
     rptr->put(keyPtr1, valPtr);

     CacheableKeyPtr keyPtr2 = CacheableKey::create("key-2");
     valPtr = CacheableString::create("client2-value2");
     rptr->put(keyPtr2, valPtr);

     CacheableKeyPtr keyPtr3 = CacheableKey::create("key-3");
     valPtr = CacheableString::create("client2-value3");
     rptr->put(keyPtr3, valPtr);
     txManager->commit();

     dunit::sleep(1000);

     // localGet

     c2v11 = dynCast<CacheableStringPtr>(rptr->get(keyPtr1));
     c2v12 = dynCast<CacheableStringPtr>(rptr->get(keyPtr2));
     c2v13 = dynCast<CacheableStringPtr>(rptr->get(keyPtr3));

     // localDestroy
     rptr->localDestroy(keyPtr1);
     rptr->localDestroy(keyPtr2);
     rptr->localDestroy(keyPtr3);

     // remoteGet
     c2v11 = dynCast<CacheableStringPtr>(rptr->get(keyPtr1));
     s2v12 = dynCast<CacheableStringPtr>(rptr->get(keyPtr2));
     s2v13 = dynCast<CacheableStringPtr>(rptr->get(keyPtr3));

     // Print remoteGet Values
     LOGINFO(
         "CLIENT-2 :: TASK:transactionPutOnClient2: localGet Val1 = %s "
         "remoteGet "
         "Val1 = %s ",
         c2v11->asChar(), s2v11->asChar());
     LOGINFO(
         "CLIENT-2 :: TASK:transactionPutOnClient2: localGet Val2 = %s "
         "remoteGet "
         "Val2 = %s ",
         c2v12->asChar(), s2v12->asChar());
     LOGINFO(
         "CLIENT-2 :: TASK:transactionPutOnClient2: localGet Val3 = %s "
         "remoteGet "
         "Val3 = %s ",
         c2v13->asChar(), s2v13->asChar());

     ASSERT(*c2v11.ptr() == *c2v11.ptr(),
            "transactionPutOnClient2:Values should be equal-1");
     ASSERT(*c2v12.ptr() == *c2v12.ptr(),
            "transactionPutOnClient2:Values should be equal-2");
     ASSERT(*c2v13.ptr() == *c2v13.ptr(),
            "transactionPutOnClient2:Values should be equal-3");

     LOG("CLIENT-2 :: TASK: transactionPutOnClient2 completed successfully");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT1, verifyGetonClient1)
   {
     thread4->stop();
     delete thread4;

     RegionPtr rptr = getHelper()->getRegion(regNames[0]);

     CacheableKeyPtr keyPtr1 = CacheableKey::create("key-1");
     CacheableKeyPtr keyPtr2 = CacheableKey::create("key-2");
     CacheableKeyPtr keyPtr3 = CacheableKey::create("key-3");

     // localGet
     c1v11 = dynCast<CacheableStringPtr>(rptr->get(keyPtr1));
     c1v12 = dynCast<CacheableStringPtr>(rptr->get(keyPtr2));
     c1v13 = dynCast<CacheableStringPtr>(rptr->get(keyPtr3));

     // localDestroy
     rptr->localDestroy(keyPtr1);
     rptr->localDestroy(keyPtr2);
     rptr->localDestroy(keyPtr3);

     // remoteGet
     s1v11 = dynCast<CacheableStringPtr>(rptr->get(keyPtr1));
     s1v12 = dynCast<CacheableStringPtr>(rptr->get(keyPtr2));
     s1v13 = dynCast<CacheableStringPtr>(rptr->get(keyPtr3));

     // Print remoteGet Values
     LOGINFO(
         "CLIENT-2 :: verifyGetonClient1: localGet Val1 = %s remoteGet Val1 = "
         "%s ",
         c1v11->asChar(), s1v11->asChar());
     LOGINFO(
         "CLIENT-2 :: verifyGetonClient1: localGet Val2 = %s remoteGet Val2 = "
         "%s ",
         c1v12->asChar(), s1v12->asChar());
     LOGINFO(
         "CLIENT-2 :: verifyGetonClient1: localGet Val3 = %s remoteGet Val3 = "
         "%s ",
         c1v13->asChar(), s1v13->asChar());

     ASSERT(*c1v11.ptr() == *s1v11.ptr(),
            "verifyGetonClient1:Values should be equal-1");
     ASSERT(*c1v12.ptr() == *s1v12.ptr(),
            "verifyGetonClient1:Values should be equal-2");
     ASSERT(*c1v13.ptr() == *s1v13.ptr(),
            "verifyGetonClient1:Values should be equal-3");

     LOG("CLIENT-2 :: TASK: verifyGetonClient1 completed successfully");
   }
 END_TASK_DEFINITION

 //
 DUNIT_TASK_DEFINITION(CLIENT1, PutOnClient1)
   {
     RegionPtr rptr = getHelper()->getRegion(regNames[0]);
     thread1 = new putThread(rptr, false);
     thread1->setParams(0, 5, 1, true, false, 1);
     thread1->start();
     LOG("PUT ops done on client 1");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT2, PutOnClient2)
   {
     RegionPtr rptr = getHelper()->getRegion(regNames[0]);
     thread2 = new putThread(rptr, false);
     thread2->setParams(0, 5, 1, false, false, 0);  // 0, 5, 1, false, false, 0
     thread2->start();
     LOG("PUT ops done on client 2");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT1, testServerGC)
   {
     RegionPtr rptr = getHelper()->getRegion(regNames[0]);
     thread3 = new putThread(rptr, false);
     thread3->setParams(0, 5000, 1, true, false, 0);  // 0, 5, 1, false, false, 0
     thread3->start();
     LOG("5000 PUT ops done on client 1");

     // set thread to destroy entries.
     thread3->setParams(7, 5000, 1, true, false, 0);  // Destroy
     thread3->start();
     LOG("5000 entries destroyed successfully");

     dunit::sleep(10000);

     thread3->stop();
     delete thread3;
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT1, GetOnClient1)
   {
     LOG("CLIENT-1 :: local GET operation -1");
     thread1->stop();
     delete thread1;
     dunit::sleep(3000);
     RegionPtr regPtr = getHelper()->getRegion(regNames[0]);
     // localGet
     CacheableKeyPtr keyPtr1 = CacheableKey::create("key-1");
     CacheableKeyPtr keyPtr2 = CacheableKey::create("key-2");
     CacheableKeyPtr keyPtr3 = CacheableKey::create("key-3");
     CacheableKeyPtr keyPtr4 = CacheableKey::create("key-4");
     CacheableKeyPtr keyPtr5 = CacheableKey::create("key-5");

     c1v11 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr1));
     c1v12 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr2));
     c1v13 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr3));
     c1v14 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr4));
     c1v15 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr5));

     // Print local Get Values
     LOGINFO("CLIENT-1 :: local GET operation -6 c1v11 = %s", c1v11->asChar());
     LOGINFO("CLIENT-1 :: local GET operation -7 c1v12 = %s", c1v12->asChar());
     LOGINFO("CLIENT-1 :: local GET operation -8 c1v13 = %s", c1v13->asChar());
     LOGINFO("CLIENT-1 :: local GET operation -9 c1v14=%s", c1v14->asChar());
     LOGINFO("CLIENT-1 :: local GET operation....Done c1v15=%s",
             c1v15->asChar());

     // localDestroy
     regPtr->localDestroy(keyPtr1);
     regPtr->localDestroy(keyPtr2);
     regPtr->localDestroy(keyPtr3);
     regPtr->localDestroy(keyPtr4);
     regPtr->localDestroy(keyPtr5);

     LOG("CLIENT-1 :: localDestroy() operation....Done");

     // remoteGet
     s1v11 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr1));
     s1v12 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr2));
     s1v13 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr3));
     s1v14 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr4));
     s1v15 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr5));

     // Print remoteGet Values
     LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v11 = %s", s1v11->asChar());
     LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v12 = %s", s1v12->asChar());
     LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v13 = %s", s1v13->asChar());
     LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v14 = %s", s1v14->asChar());
     LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v15 = %s", s1v15->asChar());

     ASSERT(*c1v11.ptr() == *s1v11.ptr(),
            "GetOnClient1:Values should be equal-1");
     ASSERT(*c1v12.ptr() == *s1v12.ptr(),
            "GetOnClient1:Values should be equal-2");
     ASSERT(*c1v13.ptr() == *s1v13.ptr(),
            "GetOnClient1:Values should be equal-3");
     ASSERT(*c1v14.ptr() == *s1v14.ptr(),
            "GetOnClient1:Values should be equal-4");
     ASSERT(*c1v15.ptr() == *s1v15.ptr(),
            "GetOnClient1:Values should be equal-5");
     LOG("CLIENT-1 ::local GET operation....Done");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT2, GetOnClient2)
   {
     RegionPtr regPtr = getHelper()->getRegion(regNames[0]);
     thread2->stop();
     delete thread2;

     dunit::sleep(3000);
     // localGet
     CacheableKeyPtr keyPtr1 = CacheableKey::create("key-1");
     CacheableKeyPtr keyPtr2 = CacheableKey::create("key-2");
     CacheableKeyPtr keyPtr3 = CacheableKey::create("key-3");
     CacheableKeyPtr keyPtr4 = CacheableKey::create("key-4");
     CacheableKeyPtr keyPtr5 = CacheableKey::create("key-5");

     c2v11 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr1));
     c2v12 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr2));
     c2v13 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr3));
     c2v14 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr4));
     c2v15 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr5));

     // Print localGets
     // Print local Get Values
     LOGINFO("CLIENT-2 :: local GET operation  c2v11 = %s", c2v11->asChar());
     LOGINFO("CLIENT-2 :: local GET operation  c2v12 = %s", c2v12->asChar());
     LOGINFO("CLIENT-2 :: local GET operation  c2v13 = %s", c2v13->asChar());
     LOGINFO("CLIENT-2 :: local GET operation  c2v14=%s", c2v14->asChar());
     LOGINFO("CLIENT-2 :: local GET operation....Done c2v15=%s",
             c2v15->asChar());

     LOG("CLIENT-2 :: local GET operation....Done");

     // localDestroy
     regPtr->localDestroy(keyPtr1);
     regPtr->localDestroy(keyPtr2);
     regPtr->localDestroy(keyPtr3);
     regPtr->localDestroy(keyPtr4);
     regPtr->localDestroy(keyPtr5);
     LOG("CLIENT-2 :: localDestroy() operation....Done");

     // remoteGet
     s2v11 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr1));
     s2v12 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr2));
     s2v13 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr3));
     s2v14 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr4));
     s2v15 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr5));

     // Print remoteGet Values
     LOGINFO("CLIENT-2 :: remoteGet operation  s2v11 = %s", s2v11->asChar());
     LOGINFO("CLIENT-2 :: remoteGet operation  s2v12 = %s", s2v12->asChar());
     LOGINFO("CLIENT-2 :: remoteGet operation  s2v13 = %s", s2v13->asChar());
     LOGINFO("CLIENT-2 :: remoteGet operation  s2v14 = %s", s2v14->asChar());
     LOGINFO("CLIENT-2 :: remoteGet operation  s2v15 = %s", s2v15->asChar());

     ASSERT(*c2v11.ptr() == *s2v11.ptr(),
            "GetOnClient2:Values should be equal-1");
     ASSERT(*c2v12.ptr() == *s2v12.ptr(),
            "GetOnClient2:Values should be equal-2");
     ASSERT(*c2v13.ptr() == *s2v13.ptr(),
            "GetOnClient2:Values should be equal-3");
     ASSERT(*c2v14.ptr() == *s2v14.ptr(),
            "GetOnClient2:Values should be equal-4");
     ASSERT(*c2v15.ptr() == *s2v15.ptr(),
            "GetOnClient2:Values should be equal-5");

     LOG("GetOnClient2 completed");
   }
 END_TASK_DEFINITION

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

 DUNIT_TASK_DEFINITION(CLIENT1, CloseClient1)
   { cleanProc(); }
 END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(CLIENT2, CloseClient2)
   { cleanProc(); }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(SERVER1, CreateServers_With_Locator)
   {
     // starting locator
     if (isLocator1) CacheHelper::initLocator(1);
     LOG(": Locator1 started");

     // starting servers
     if (isLocalServer1) {
       CacheHelper::initServer(1, "cacheserver_concurrency_enabled1.xml",
                               locatorsG, NULL, false, true, false, true);
       LOG(":SERVER1 started");
     }
     // starting servers
     if (isLocalServer1) {
       CacheHelper::initServer(2, "cacheserver_concurrency_enabled2.xml",
                               locatorsG, NULL, false, true, false, true);
       LOG(":SERVER2 started");
     }
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(SERVER1, CreateServers_With_Locator_Disk)
   {
     // starting locator
     if (isLocator1) CacheHelper::initLocator(1);
     LOG(": Locator1 started");

     // starting servers
     if (isLocalServer1) {
       CacheHelper::initServer(
           1, "cacheserver_concurrency_enabled_disk_replicate1.xml", locatorsG,
           NULL, false, true, false, true);
       LOG(":SERVER1 started");
     }
     // starting servers
     if (isLocalServer1) {
       CacheHelper::initServer(
           2, "cacheserver_concurrency_enabled_disk_replicate2.xml", locatorsG,
           NULL, false, true, false, true);
       LOG(":SERVER2 started");
     }
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(SERVER1, CreateServers_With_Locator_Partition)
   {
     // starting locator
     if (isLocator1) CacheHelper::initLocator(1);
     LOG(": Locator1 started");

     // starting servers
     if (isLocalServer1) {
       CacheHelper::initServer(1, "cacheserver_concurrency_enabled_disk1.xml",
                               locatorsG, NULL, false, true, false, true);
       LOG(":SERVER1 started");
     }
     // starting servers
     if (isLocalServer1) {
       CacheHelper::initServer(2, "cacheserver_concurrency_enabled_disk2.xml",
                               locatorsG, NULL, false, true, false, true);
       LOG(":SERVER2 started");
     }
   }
 END_TASK_DEFINITION
 DUNIT_TASK_DEFINITION(SERVER1, CloseServers_With_Locator)
   {
     if (isLocalServer1) {
       CacheHelper::closeServer(1);
       LOG("SERVER1 stopped");
     }

     if (isLocalServer1) {
       CacheHelper::closeServer(2);
       LOG("SERVER2 stopped");
     }

     if (isLocator1) {
       CacheHelper::closeLocator(1);
       LOG("Locator1 stopped");
     }
   }
 END_TASK_DEFINITION

 #endif // GEODE_INTEGRATION_TEST_THINCLIENTVERSIONEDOPS_H_
	#pragma once

	#ifndef GEODE_INTEGRATION_TEST_THINCLIENTVERSIONEDOPS_H_
	#define GEODE_INTEGRATION_TEST_THINCLIENTVERSIONEDOPS_H_

	/*
	* 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 "testThinClientVersionedOps"

	#include "ThinClientSecurityHelper.hpp"

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

	// This is the test for tracking work. bug#304

	putThread *thread1 = NULL;
	putThread *thread2 = NULL;
	putThread *thread3 = NULL;
	putThread *thread4 = NULL;

	const char *regNames[] = {"DistRegionAck", "DistRegionNoAck"};
	const char *group1 = "A";
	const char *group2 = "B";
	// const char * endPoints1 = CacheHelper::getTcrEndpoints( isLocalServer1, 3 );
	std::string gfendpoints1 = "localhost:";
	std::string gfendpoints2 = "localhost:";

	bool isLocalServer1 = false;

	static bool isLocator1 = false;
	const char *locatorsG =
	CacheHelper::getLocatorHostPort(isLocator1, isLocalServer1, 1);

	CacheableStringPtr c1v11;
	CacheableStringPtr c1v12;
	CacheableStringPtr c1v13;
	CacheableStringPtr c1v14;
	CacheableStringPtr c1v15;

	CacheableStringPtr s1v11;
	CacheableStringPtr s1v12;
	CacheableStringPtr s1v13;
	CacheableStringPtr s1v14;
	CacheableStringPtr s1v15;

	CacheableStringPtr c2v11;
	CacheableStringPtr c2v12;
	CacheableStringPtr c2v13;
	CacheableStringPtr c2v14;
	CacheableStringPtr c2v15;

	CacheableStringPtr s2v11;
	CacheableStringPtr s2v12;
	CacheableStringPtr s2v13;
	CacheableStringPtr s2v14;
	CacheableStringPtr s2v15;

	void verifyAllValues() {
	LOGINFO("verifyAllValues TEST-1");
	/*LOGINFO("c1v11 = %s", c1v11->asChar());
	LOGINFO("verifyAllValues TEST-2");
	LOGINFO("c1v12 = %s", c1v12->asChar());
	LOGINFO("c1v13 = %s", c1v13->asChar());
	LOGINFO("c1v14 = %s", c1v14->asChar());
	LOGINFO("c1v15 = %s", c1v15->asChar());

	LOGINFO("s1v11 = %s", s1v11->asChar());
	LOGINFO("s1v12 = %s", s1v12->asChar());
	LOGINFO("s1v13 = %s", s1v13->asChar());
	LOGINFO("s1v14 = %s", s1v14->asChar());
	LOGINFO("s1v15 = %s", s1v15->asChar());

	LOGINFO("c2v11 = %s", c2v11->asChar());
	LOGINFO("c2v12 = %s", c2v12->asChar());
	LOGINFO("c2v13 = %s", c2v13->asChar());
	LOGINFO("c2v14 = %s", c2v14->asChar());
	LOGINFO("c2v15 = %s", c2v15->asChar());

	LOGINFO("s2v11 = %s", s2v11->asChar());
	LOGINFO("s2v12 = %s", s2v12->asChar());
	LOGINFO("s2v13 = %s", s2v13->asChar());
	LOGINFO("s2v14 = %s", s2v14->asChar());
	LOGINFO("s2v15 = %s", s2v15->asChar());*/
	}

	// added
	DUNIT_TASK_DEFINITION(SERVER1, StartServer1)
	{
	LOG("starting SERVER1...");
	if (isLocalServer1) {
	CacheHelper::initServer(1, "cacheserver_concurrency_enabled1.xml");
	}
	LOG("SERVER1 started");
	}
	END_TASK_DEFINITION

	// added
	DUNIT_TASK_DEFINITION(SERVER2, StartServer2)
	{
	LOG("starting SERVER2...");
	if (isLocalServer1) {
	CacheHelper::initServer(2, "cacheserver_concurrency_enabled2.xml");
	}
	LOG("SERVER2 started");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT1, StartClient1)
	{
	// TOOD::check for poolwithendpoints or locators

	// By default poolwithendpoints
	// char tmp1[100];
	// sprintf( tmp1, "%d", CacheHelper::staticHostPort1 );
	// gfendpoints1 += tmp1;

	// initClientWithPool(true/isthinClient/, NULL/poolName/,
	// NULL/locators/,serverGroup1, NULL/servers/,
	// NULLPTR/PropertiesPtr&/,
	// 0/redundancy/, true/clientNotification/,
	// -1/subscriptionAckInterval/,
	// 5/connections/, 60000/loadConditioningInterval/);
	// RegionPtr regPtr0 = createRegionAndAttachPool(regNames[0],USE_ACK, NULL);

	initClient(true);
	getHelper()->createPoolWithLocators("__TEST_POOL1__", locatorsG, true, -1,
	-1, -1, false, group1);
	RegionPtr regPtr0 = getHelper()->createRegionAndAttachPool(
	regNames[0], USE_ACK, "__TEST_POOL1__", true);
	LOG("StepOne_Pooled_Locator1 complete.");

	regPtr0->registerAllKeys();

	LOG("Client-1 Init complete.");
	}
	END_TASK_DEFINITION

	// startClient-2
	DUNIT_TASK_DEFINITION(CLIENT2, StartClient2)
	{
	// TOOD::check for poolwithendpoints or locators
	/* LOG( "Client-2 Init -1" );
	//By default poolwithendpoints
	char tmp2[100];
	LOG( "Client-2 Init -2" );
	sprintf( tmp2, "%d", CacheHelper::staticHostPort2 );
	LOG( "Client-2 Init -3" );
	gfendpoints2 += tmp2;
	LOG( "Client-2 Init -4" );
	initClientWithPool(true, NULL, NULL, serverGroup2, gfendpoints2.c_str(),
	NULLPTR, 0, true, -1, 5, 60000);
	LOG( "Client-2 Init -5" );

	RegionPtr regPtr0 = createRegionAndAttachPool(regNames[0],USE_ACK, NULL);
	LOG( "Client-2 Init -6" );

	*/
	initClient(true);
	getHelper()->createPoolWithLocators("__TEST_POOL1__", locatorsG, true, -1,
	-1, -1, false, group2);
	RegionPtr regPtr0 = getHelper()->createRegionAndAttachPool(
	regNames[0], USE_ACK, "__TEST_POOL1__", true);
	LOG("StepOne_Pooled_Locator1 complete.");

	regPtr0->registerAllKeys();
	LOG("Client-2 StartClient2 complete.");
	}
	END_TASK_DEFINITION

	// threadPutonClient1
	DUNIT_TASK_DEFINITION(CLIENT1, threadPutonClient1)
	{
	RegionPtr rptr = getHelper()->getRegion(regNames[0]);
	thread4 = new putThread(rptr, false);
	thread4->setParams(0, 10, 1, true, false, 0);
	thread4->start();
	LOG("Task: threadPutonClient1 Done");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT2, transactionPutOnClient2)
	{
	RegionPtr rptr = getHelper()->getRegion(regNames[0]);
	CacheTransactionManagerPtr txManager =
	getHelper()->getCache()->getCacheTransactionManager();

	txManager->begin();
	CacheableKeyPtr keyPtr1 = CacheableKey::create("key-1");
	CacheableStringPtr valPtr = CacheableString::create("client2-value1");
	rptr->put(keyPtr1, valPtr);

	CacheableKeyPtr keyPtr2 = CacheableKey::create("key-2");
	valPtr = CacheableString::create("client2-value2");
	rptr->put(keyPtr2, valPtr);

	CacheableKeyPtr keyPtr3 = CacheableKey::create("key-3");
	valPtr = CacheableString::create("client2-value3");
	rptr->put(keyPtr3, valPtr);
	txManager->commit();

	dunit::sleep(1000);

	// localGet

	c2v11 = dynCast<CacheableStringPtr>(rptr->get(keyPtr1));
	c2v12 = dynCast<CacheableStringPtr>(rptr->get(keyPtr2));
	c2v13 = dynCast<CacheableStringPtr>(rptr->get(keyPtr3));

	// localDestroy
	rptr->localDestroy(keyPtr1);
	rptr->localDestroy(keyPtr2);
	rptr->localDestroy(keyPtr3);

	// remoteGet
	c2v11 = dynCast<CacheableStringPtr>(rptr->get(keyPtr1));
	s2v12 = dynCast<CacheableStringPtr>(rptr->get(keyPtr2));
	s2v13 = dynCast<CacheableStringPtr>(rptr->get(keyPtr3));

	// Print remoteGet Values
	LOGINFO(
	"CLIENT-2 :: TASK:transactionPutOnClient2: localGet Val1 = %s "
	"remoteGet "
	"Val1 = %s ",
	c2v11->asChar(), s2v11->asChar());
	LOGINFO(
	"CLIENT-2 :: TASK:transactionPutOnClient2: localGet Val2 = %s "
	"remoteGet "
	"Val2 = %s ",
	c2v12->asChar(), s2v12->asChar());
	LOGINFO(
	"CLIENT-2 :: TASK:transactionPutOnClient2: localGet Val3 = %s "
	"remoteGet "
	"Val3 = %s ",
	c2v13->asChar(), s2v13->asChar());

	ASSERT(c2v11.ptr() == c2v11.ptr(),
	"transactionPutOnClient2:Values should be equal-1");
	ASSERT(c2v12.ptr() == c2v12.ptr(),
	"transactionPutOnClient2:Values should be equal-2");
	ASSERT(c2v13.ptr() == c2v13.ptr(),
	"transactionPutOnClient2:Values should be equal-3");

	LOG("CLIENT-2 :: TASK: transactionPutOnClient2 completed successfully");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT1, verifyGetonClient1)
	{
	thread4->stop();
	delete thread4;

	RegionPtr rptr = getHelper()->getRegion(regNames[0]);

	CacheableKeyPtr keyPtr1 = CacheableKey::create("key-1");
	CacheableKeyPtr keyPtr2 = CacheableKey::create("key-2");
	CacheableKeyPtr keyPtr3 = CacheableKey::create("key-3");

	// localGet
	c1v11 = dynCast<CacheableStringPtr>(rptr->get(keyPtr1));
	c1v12 = dynCast<CacheableStringPtr>(rptr->get(keyPtr2));
	c1v13 = dynCast<CacheableStringPtr>(rptr->get(keyPtr3));

	// localDestroy
	rptr->localDestroy(keyPtr1);
	rptr->localDestroy(keyPtr2);
	rptr->localDestroy(keyPtr3);

	// remoteGet
	s1v11 = dynCast<CacheableStringPtr>(rptr->get(keyPtr1));
	s1v12 = dynCast<CacheableStringPtr>(rptr->get(keyPtr2));
	s1v13 = dynCast<CacheableStringPtr>(rptr->get(keyPtr3));

	// Print remoteGet Values
	LOGINFO(
	"CLIENT-2 :: verifyGetonClient1: localGet Val1 = %s remoteGet Val1 = "
	"%s ",
	c1v11->asChar(), s1v11->asChar());
	LOGINFO(
	"CLIENT-2 :: verifyGetonClient1: localGet Val2 = %s remoteGet Val2 = "
	"%s ",
	c1v12->asChar(), s1v12->asChar());
	LOGINFO(
	"CLIENT-2 :: verifyGetonClient1: localGet Val3 = %s remoteGet Val3 = "
	"%s ",
	c1v13->asChar(), s1v13->asChar());

	ASSERT(c1v11.ptr() == s1v11.ptr(),
	"verifyGetonClient1:Values should be equal-1");
	ASSERT(c1v12.ptr() == s1v12.ptr(),
	"verifyGetonClient1:Values should be equal-2");
	ASSERT(c1v13.ptr() == s1v13.ptr(),
	"verifyGetonClient1:Values should be equal-3");

	LOG("CLIENT-2 :: TASK: verifyGetonClient1 completed successfully");
	}
	END_TASK_DEFINITION

	//
	DUNIT_TASK_DEFINITION(CLIENT1, PutOnClient1)
	{
	RegionPtr rptr = getHelper()->getRegion(regNames[0]);
	thread1 = new putThread(rptr, false);
	thread1->setParams(0, 5, 1, true, false, 1);
	thread1->start();
	LOG("PUT ops done on client 1");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT2, PutOnClient2)
	{
	RegionPtr rptr = getHelper()->getRegion(regNames[0]);
	thread2 = new putThread(rptr, false);
	thread2->setParams(0, 5, 1, false, false, 0); // 0, 5, 1, false, false, 0
	thread2->start();
	LOG("PUT ops done on client 2");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT1, testServerGC)
	{
	RegionPtr rptr = getHelper()->getRegion(regNames[0]);
	thread3 = new putThread(rptr, false);
	thread3->setParams(0, 5000, 1, true, false, 0); // 0, 5, 1, false, false, 0
	thread3->start();
	LOG("5000 PUT ops done on client 1");

	// set thread to destroy entries.
	thread3->setParams(7, 5000, 1, true, false, 0); // Destroy
	thread3->start();
	LOG("5000 entries destroyed successfully");

	dunit::sleep(10000);

	thread3->stop();
	delete thread3;
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT1, GetOnClient1)
	{
	LOG("CLIENT-1 :: local GET operation -1");
	thread1->stop();
	delete thread1;
	dunit::sleep(3000);
	RegionPtr regPtr = getHelper()->getRegion(regNames[0]);
	// localGet
	CacheableKeyPtr keyPtr1 = CacheableKey::create("key-1");
	CacheableKeyPtr keyPtr2 = CacheableKey::create("key-2");
	CacheableKeyPtr keyPtr3 = CacheableKey::create("key-3");
	CacheableKeyPtr keyPtr4 = CacheableKey::create("key-4");
	CacheableKeyPtr keyPtr5 = CacheableKey::create("key-5");

	c1v11 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr1));
	c1v12 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr2));
	c1v13 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr3));
	c1v14 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr4));
	c1v15 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr5));

	// Print local Get Values
	LOGINFO("CLIENT-1 :: local GET operation -6 c1v11 = %s", c1v11->asChar());
	LOGINFO("CLIENT-1 :: local GET operation -7 c1v12 = %s", c1v12->asChar());
	LOGINFO("CLIENT-1 :: local GET operation -8 c1v13 = %s", c1v13->asChar());
	LOGINFO("CLIENT-1 :: local GET operation -9 c1v14=%s", c1v14->asChar());
	LOGINFO("CLIENT-1 :: local GET operation....Done c1v15=%s",
	c1v15->asChar());

	// localDestroy
	regPtr->localDestroy(keyPtr1);
	regPtr->localDestroy(keyPtr2);
	regPtr->localDestroy(keyPtr3);
	regPtr->localDestroy(keyPtr4);
	regPtr->localDestroy(keyPtr5);

	LOG("CLIENT-1 :: localDestroy() operation....Done");

	// remoteGet
	s1v11 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr1));
	s1v12 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr2));
	s1v13 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr3));
	s1v14 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr4));
	s1v15 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr5));

	// Print remoteGet Values
	LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v11 = %s", s1v11->asChar());
	LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v12 = %s", s1v12->asChar());
	LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v13 = %s", s1v13->asChar());
	LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v14 = %s", s1v14->asChar());
	LOGINFO("CLIENT-1 :: remoteGet operation -6 s1v15 = %s", s1v15->asChar());

	ASSERT(c1v11.ptr() == s1v11.ptr(),
	"GetOnClient1:Values should be equal-1");
	ASSERT(c1v12.ptr() == s1v12.ptr(),
	"GetOnClient1:Values should be equal-2");
	ASSERT(c1v13.ptr() == s1v13.ptr(),
	"GetOnClient1:Values should be equal-3");
	ASSERT(c1v14.ptr() == s1v14.ptr(),
	"GetOnClient1:Values should be equal-4");
	ASSERT(c1v15.ptr() == s1v15.ptr(),
	"GetOnClient1:Values should be equal-5");
	LOG("CLIENT-1 ::local GET operation....Done");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT2, GetOnClient2)
	{
	RegionPtr regPtr = getHelper()->getRegion(regNames[0]);
	thread2->stop();
	delete thread2;

	dunit::sleep(3000);
	// localGet
	CacheableKeyPtr keyPtr1 = CacheableKey::create("key-1");
	CacheableKeyPtr keyPtr2 = CacheableKey::create("key-2");
	CacheableKeyPtr keyPtr3 = CacheableKey::create("key-3");
	CacheableKeyPtr keyPtr4 = CacheableKey::create("key-4");
	CacheableKeyPtr keyPtr5 = CacheableKey::create("key-5");

	c2v11 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr1));
	c2v12 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr2));
	c2v13 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr3));
	c2v14 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr4));
	c2v15 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr5));

	// Print localGets
	// Print local Get Values
	LOGINFO("CLIENT-2 :: local GET operation c2v11 = %s", c2v11->asChar());
	LOGINFO("CLIENT-2 :: local GET operation c2v12 = %s", c2v12->asChar());
	LOGINFO("CLIENT-2 :: local GET operation c2v13 = %s", c2v13->asChar());
	LOGINFO("CLIENT-2 :: local GET operation c2v14=%s", c2v14->asChar());
	LOGINFO("CLIENT-2 :: local GET operation....Done c2v15=%s",
	c2v15->asChar());

	LOG("CLIENT-2 :: local GET operation....Done");

	// localDestroy
	regPtr->localDestroy(keyPtr1);
	regPtr->localDestroy(keyPtr2);
	regPtr->localDestroy(keyPtr3);
	regPtr->localDestroy(keyPtr4);
	regPtr->localDestroy(keyPtr5);
	LOG("CLIENT-2 :: localDestroy() operation....Done");

	// remoteGet
	s2v11 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr1));
	s2v12 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr2));
	s2v13 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr3));
	s2v14 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr4));
	s2v15 = dynCast<CacheableStringPtr>(regPtr->get(keyPtr5));

	// Print remoteGet Values
	LOGINFO("CLIENT-2 :: remoteGet operation s2v11 = %s", s2v11->asChar());
	LOGINFO("CLIENT-2 :: remoteGet operation s2v12 = %s", s2v12->asChar());
	LOGINFO("CLIENT-2 :: remoteGet operation s2v13 = %s", s2v13->asChar());
	LOGINFO("CLIENT-2 :: remoteGet operation s2v14 = %s", s2v14->asChar());
	LOGINFO("CLIENT-2 :: remoteGet operation s2v15 = %s", s2v15->asChar());

	ASSERT(c2v11.ptr() == s2v11.ptr(),
	"GetOnClient2:Values should be equal-1");
	ASSERT(c2v12.ptr() == s2v12.ptr(),
	"GetOnClient2:Values should be equal-2");
	ASSERT(c2v13.ptr() == s2v13.ptr(),
	"GetOnClient2:Values should be equal-3");
	ASSERT(c2v14.ptr() == s2v14.ptr(),
	"GetOnClient2:Values should be equal-4");
	ASSERT(c2v15.ptr() == s2v15.ptr(),
	"GetOnClient2:Values should be equal-5");

	LOG("GetOnClient2 completed");
	}
	END_TASK_DEFINITION

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

	DUNIT_TASK_DEFINITION(CLIENT1, CloseClient1)
	{ cleanProc(); }
	END_TASK_DEFINITION
	DUNIT_TASK_DEFINITION(CLIENT2, CloseClient2)
	{ cleanProc(); }
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(SERVER1, CreateServers_With_Locator)
	{
	// starting locator
	if (isLocator1) CacheHelper::initLocator(1);
	LOG(": Locator1 started");

	// starting servers
	if (isLocalServer1) {
	CacheHelper::initServer(1, "cacheserver_concurrency_enabled1.xml",
	locatorsG, NULL, false, true, false, true);
	LOG(":SERVER1 started");
	}
	// starting servers
	if (isLocalServer1) {
	CacheHelper::initServer(2, "cacheserver_concurrency_enabled2.xml",
	locatorsG, NULL, false, true, false, true);
	LOG(":SERVER2 started");
	}
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(SERVER1, CreateServers_With_Locator_Disk)
	{
	// starting locator
	if (isLocator1) CacheHelper::initLocator(1);
	LOG(": Locator1 started");

	// starting servers
	if (isLocalServer1) {
	CacheHelper::initServer(
	1, "cacheserver_concurrency_enabled_disk_replicate1.xml", locatorsG,
	NULL, false, true, false, true);
	LOG(":SERVER1 started");
	}
	// starting servers
	if (isLocalServer1) {
	CacheHelper::initServer(
	2, "cacheserver_concurrency_enabled_disk_replicate2.xml", locatorsG,
	NULL, false, true, false, true);
	LOG(":SERVER2 started");
	}
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(SERVER1, CreateServers_With_Locator_Partition)
	{
	// starting locator
	if (isLocator1) CacheHelper::initLocator(1);
	LOG(": Locator1 started");

	// starting servers
	if (isLocalServer1) {
	CacheHelper::initServer(1, "cacheserver_concurrency_enabled_disk1.xml",
	locatorsG, NULL, false, true, false, true);
	LOG(":SERVER1 started");
	}
	// starting servers
	if (isLocalServer1) {
	CacheHelper::initServer(2, "cacheserver_concurrency_enabled_disk2.xml",
	locatorsG, NULL, false, true, false, true);
	LOG(":SERVER2 started");
	}
	}
	END_TASK_DEFINITION
	DUNIT_TASK_DEFINITION(SERVER1, CloseServers_With_Locator)
	{
	if (isLocalServer1) {
	CacheHelper::closeServer(1);
	LOG("SERVER1 stopped");
	}

	if (isLocalServer1) {
	CacheHelper::closeServer(2);
	LOG("SERVER2 stopped");
	}

	if (isLocator1) {
	CacheHelper::closeLocator(1);
	LOG("Locator1 stopped");
	}
	}
	END_TASK_DEFINITION

	#endif // GEODE_INTEGRATION_TEST_THINCLIENTVERSIONEDOPS_H_