cppcache/integration-test/ThinClientDurableConnect.hpp - 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.
  */

 #pragma once

 #ifndef GEODE_INTEGRATION_TEST_THINCLIENTDURABLECONNECT_H_
 #define GEODE_INTEGRATION_TEST_THINCLIENTDURABLECONNECT_H_

 #include "fw_dunit.hpp"
 #include "ThinClientHelper.hpp"
 #include "CacheImplHelper.hpp"
 #include "testUtils.hpp"

 /* Test case covered:
 With Four Servers
 1-  ( R = 1 ) All Server Up, Check if client reconnect to either of server
 having queue.
 2-  (  R = 1 ) One Redundant Server down, Check if client reconnect to another
 server having queue.
 3-  (  R = 1 ) Both Redundant Server down, Check if client reconnect to both non
 redundant server and all events are lost.
 4-  (  R = 1 ) Both Non-Redundant Server down, Check if client reconnect to both
 redundant server.
 5-  ( R = 1 ) All Server Up, Check if client reconnect to either of server after
 timeout period and all the events are lost.
 */

 #define CLIENT s1p1
 #define SERVER_SET1 s1p2
 #define SERVER_SET2 s2p1
 #define SERVER_SET3 s2p2
 #define SERVER1 s1p2

 bool isLocalServerList = false;
 const std::string endPointsList = CacheHelper::getTcrEndpoints(isLocalServerList, 4);
 const char* durableId = "DurableId";

 #include "ThinClientDurableInit.hpp"
 #include "ThinClientTasks_C2S2.hpp"

 const char* g_Locators = locatorsG;

 std::string getServerEndPoint(int instance) {
   char instanceStr[16];
   int port;
   if (instance == 1) {
     port = CacheHelper::staticHostPort1;
   } else if (instance == 2) {
     port = CacheHelper::staticHostPort2;
   } else if (instance == 3) {
     port = CacheHelper::staticHostPort3;
   } else {
     port = CacheHelper::staticHostPort4;
   }

   std::string retVal(ACE_OS::itoa(port, instanceStr, 10));
   return retVal;

   std::string allEndPts(endPointsList);
   std::string::size_type start_idx = 0;
   std::string::size_type end_idx = 0;

   for (int i = 0; i < instance - 1; i++) {
     start_idx = allEndPts.find(',', start_idx) + 1;
   }

   end_idx = allEndPts.find(',', start_idx);
   if (end_idx == std::string::npos) { /* asking for last endpoint */
     end_idx = allEndPts.size();
   }

   return (std::string(allEndPts, start_idx, end_idx - start_idx));
 }

 DUNIT_TASK_DEFINITION(SERVER_SET1, S1Up)
   {
     if (isLocalServer) {
       CacheHelper::initServer(1, "cacheserver_notify_subscription.xml",
                               g_Locators);
     }
     LOG("SERVER 1 started");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(SERVER_SET1, S2Up)
   {
     if (isLocalServer) {
       CacheHelper::initServer(2, "cacheserver_notify_subscription2.xml",
                               g_Locators);
     }
     LOG("SERVER 2 started");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(SERVER_SET2, S3Up)
   {
     if (isLocalServer) {
       CacheHelper::initServer(3, "cacheserver_notify_subscription3.xml",
                               g_Locators);
     }
     LOG("SERVER 3 started");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(SERVER_SET2, S4Up)
   {
     if (isLocalServer) {
       CacheHelper::initServer(4, "cacheserver_notify_subscription4.xml",
                               g_Locators);
     }
     LOG("SERVER 4 started");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(SERVER_SET1, S1Down)
   {
     CacheHelper::closeServer(1);
     LOG("SERVER 1 closed");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(SERVER_SET1, S2Down)
   {
     CacheHelper::closeServer(2);
     LOG("SERVER 2 closed");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(SERVER_SET2, S3Down)
   {
     CacheHelper::closeServer(3);
     LOG("SERVER 3 closed");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(SERVER_SET2, S4Down)
   {
     CacheHelper::closeServer(4);
     LOG("SERVER 4 closed");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT, ClntUp)
   {
     initClientAndRegion(1, 0);
     getHelper()->cachePtr->readyForEvents();

     auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     regPtr0->registerAllKeys(true);

     LOG("Clnt1Init complete.");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT, ClntUpNonHA)
   {
     initClientAndRegion(0, 0);
     getHelper()->cachePtr->readyForEvents();

     auto regPtr0 = getHelper()->getRegion(regionNames[0]);
     regPtr0->registerAllKeys(true);

     LOG("Clnt1Init complete.");
   }
 END_TASK_DEFINITION

 /* Close Client 1 with option keep alive = true*/
 DUNIT_TASK_DEFINITION(CLIENT, ClntDown)
   {
     getHelper()->disconnect(true);
     cleanProc();
     LOG("Client Down complete: Keepalive = True");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT, ClntSleep)
   {
     LOG(" Sleeping for 100 seconds");
     SLEEP(100000); /* 100 seconds for timeout*/
     LOG(" Finished sleep of 100 seconds");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT, VerifyNonHA)
   {
     /*Test case 4 , 1 */
     LOG("Verify 1: Verify that Client has queue on S1");

     ASSERT(TestUtils::getCacheImpl(getHelper()->cachePtr)
                ->getEndpointStatus(getServerEndPoint(1)),
            "Server 1 should have queue");
     ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
                 ->getEndpointStatus(getServerEndPoint(2)),
            "Server 2 should not have queue");
     ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
                 ->getEndpointStatus(getServerEndPoint(3)),
            "Server 3 should not have queue/connection");
     ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
                 ->getEndpointStatus(getServerEndPoint(4)),
            "Server 4 should not have queue/connection");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT, Verify1)
   {
     /*Test case 4 , 1 */
     LOG("Verify 1: Verify that Client has queues on S1 and S2");

     ASSERT(TestUtils::getCacheImpl(getHelper()->cachePtr)
                ->getEndpointStatus(getServerEndPoint(1)),
            "Server 1 should have queue");
     ASSERT(TestUtils::getCacheImpl(getHelper()->cachePtr)
                ->getEndpointStatus(getServerEndPoint(2)),
            "Server 2 should have queue");
     ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
                 ->getEndpointStatus(getServerEndPoint(3)),
            "Server 3 should not have queue/connection");
     ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
                 ->getEndpointStatus(getServerEndPoint(4)),
            "Server 4 should not have queue/connection");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT, Verify2)
   {
     /*Test case 2*/
     LOG("Verify 2: Verify that Client has queues on S2 and either S3 or S4 and "
         "not both");

     ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
                 ->getEndpointStatus(getServerEndPoint(1)),
            "Server 1 should not have queue");
     ASSERT(TestUtils::getCacheImpl(getHelper()->cachePtr)
                ->getEndpointStatus(getServerEndPoint(2)),
            "Server 2 should have queue");
     bool server3_hasQueue = TestUtils::getCacheImpl(getHelper()->cachePtr)
                                 ->getEndpointStatus(getServerEndPoint(3));
     bool server4_hasQueue = TestUtils::getCacheImpl(getHelper()->cachePtr)
                                 ->getEndpointStatus(getServerEndPoint(4));
     ASSERT(((server3_hasQueue && !server4_hasQueue) ||
             (!server3_hasQueue && server4_hasQueue)),
            "Either Server 3 or Server 4 should have queue");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT, Verify3)
   {
     /*Test case 3*/
     LOG("Verify 3: Verify that Client has queues on S3 and S4");

     ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
                 ->getEndpointStatus(getServerEndPoint(1)),
            "Server 1 should not have queue/connection");
     ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
                 ->getEndpointStatus(getServerEndPoint(2)),
            "Server 2 should not have queue/connection");
     ASSERT(TestUtils::getCacheImpl(getHelper()->cachePtr)
                ->getEndpointStatus(getServerEndPoint(3)),
            "Server 3 should have queue/connection");
     ASSERT(TestUtils::getCacheImpl(getHelper()->cachePtr)
                ->getEndpointStatus(getServerEndPoint(4)),
            "Server 4 should have queue/connection");
   }
 END_TASK_DEFINITION

 DUNIT_TASK_DEFINITION(CLIENT, Verify4)
   {
     /*Test case 5*/
     LOG("Verify 4: Verify that no servers have queues");

     ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
                 ->getEndpointStatus(getServerEndPoint(1)),
            "Server 1 should not have queue/connection");
     ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
                 ->getEndpointStatus(getServerEndPoint(2)),
            "Server 2 should not have queue/connection");
     ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
                 ->getEndpointStatus(getServerEndPoint(3)),
            "Server 3 should not have queue/connection");
     ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
                 ->getEndpointStatus(getServerEndPoint(4)),
            "Server 4 should not have queue/connection");
   }
 END_TASK_DEFINITION

 void doThinClientDurableConnect() {
   CALL_TASK(StartLocator);

   CALL_TASK(S1Up);
   CALL_TASK(ClntUpNonHA);
   CALL_TASK(S2Up);
   CALL_TASK(ClntDown);
   CALL_TASK(ClntUp);
   CALL_TASK(VerifyNonHA);
   CALL_TASK(ClntDown);
   CALL_TASK(S1Down);
   /* Presently for 4 servers only */
   /* Test case 4 */
   CALL_TASK(S1Up);
   CALL_TASK(ClntUp);
   /* Test case 1 */
   CALL_TASK(S3Up);
   CALL_TASK(S4Up);
   CALL_TASK(ClntDown);
   CALL_TASK(ClntUp);
   CALL_TASK(Verify1);
   /* Test case 2 */
   CALL_TASK(ClntDown);
   CALL_TASK(S1Down);
   CALL_TASK(ClntUp);
   CALL_TASK(ClntDown);
   CALL_TASK(ClntUp);
   CALL_TASK(Verify2);
   /* Test case 3 */
   CALL_TASK(ClntDown);
   CALL_TASK(S2Down);
   CALL_TASK(ClntUp);
   CALL_TASK(ClntDown);
   CALL_TASK(ClntUp);
   CALL_TASK(Verify3);
   CALL_TASK(ClntDown);
   CALL_TASK(ClntSleep);
   CALL_TASK(ClntUp);
   CALL_TASK(Verify4);
   /* Close Everything */
   CALL_TASK(ClntDown);
   CALL_TASK(S3Down);
   CALL_TASK(S4Down);

   CALL_TASK(CloseLocator);
 }

 #endif  // GEODE_INTEGRATION_TEST_THINCLIENTDURABLECONNECT_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.
	*/

	#pragma once

	#ifndef GEODE_INTEGRATION_TEST_THINCLIENTDURABLECONNECT_H_
	#define GEODE_INTEGRATION_TEST_THINCLIENTDURABLECONNECT_H_

	#include "fw_dunit.hpp"
	#include "ThinClientHelper.hpp"
	#include "CacheImplHelper.hpp"
	#include "testUtils.hpp"

	/* Test case covered:
	With Four Servers
	1- ( R = 1 ) All Server Up, Check if client reconnect to either of server
	having queue.
	2- ( R = 1 ) One Redundant Server down, Check if client reconnect to another
	server having queue.
	3- ( R = 1 ) Both Redundant Server down, Check if client reconnect to both non
	redundant server and all events are lost.
	4- ( R = 1 ) Both Non-Redundant Server down, Check if client reconnect to both
	redundant server.
	5- ( R = 1 ) All Server Up, Check if client reconnect to either of server after
	timeout period and all the events are lost.
	*/

	#define CLIENT s1p1
	#define SERVER_SET1 s1p2
	#define SERVER_SET2 s2p1
	#define SERVER_SET3 s2p2
	#define SERVER1 s1p2

	bool isLocalServerList = false;
	const std::string endPointsList = CacheHelper::getTcrEndpoints(isLocalServerList, 4);
	const char* durableId = "DurableId";

	#include "ThinClientDurableInit.hpp"
	#include "ThinClientTasks_C2S2.hpp"

	const char* g_Locators = locatorsG;

	std::string getServerEndPoint(int instance) {
	char instanceStr[16];
	int port;
	if (instance == 1) {
	port = CacheHelper::staticHostPort1;
	} else if (instance == 2) {
	port = CacheHelper::staticHostPort2;
	} else if (instance == 3) {
	port = CacheHelper::staticHostPort3;
	} else {
	port = CacheHelper::staticHostPort4;
	}

	std::string retVal(ACE_OS::itoa(port, instanceStr, 10));
	return retVal;

	std::string allEndPts(endPointsList);
	std::string::size_type start_idx = 0;
	std::string::size_type end_idx = 0;

	for (int i = 0; i < instance - 1; i++) {
	start_idx = allEndPts.find(',', start_idx) + 1;
	}

	end_idx = allEndPts.find(',', start_idx);
	if (end_idx == std::string::npos) { /* asking for last endpoint */
	end_idx = allEndPts.size();
	}

	return (std::string(allEndPts, start_idx, end_idx - start_idx));
	}

	DUNIT_TASK_DEFINITION(SERVER_SET1, S1Up)
	{
	if (isLocalServer) {
	CacheHelper::initServer(1, "cacheserver_notify_subscription.xml",
	g_Locators);
	}
	LOG("SERVER 1 started");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(SERVER_SET1, S2Up)
	{
	if (isLocalServer) {
	CacheHelper::initServer(2, "cacheserver_notify_subscription2.xml",
	g_Locators);
	}
	LOG("SERVER 2 started");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(SERVER_SET2, S3Up)
	{
	if (isLocalServer) {
	CacheHelper::initServer(3, "cacheserver_notify_subscription3.xml",
	g_Locators);
	}
	LOG("SERVER 3 started");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(SERVER_SET2, S4Up)
	{
	if (isLocalServer) {
	CacheHelper::initServer(4, "cacheserver_notify_subscription4.xml",
	g_Locators);
	}
	LOG("SERVER 4 started");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(SERVER_SET1, S1Down)
	{
	CacheHelper::closeServer(1);
	LOG("SERVER 1 closed");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(SERVER_SET1, S2Down)
	{
	CacheHelper::closeServer(2);
	LOG("SERVER 2 closed");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(SERVER_SET2, S3Down)
	{
	CacheHelper::closeServer(3);
	LOG("SERVER 3 closed");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(SERVER_SET2, S4Down)
	{
	CacheHelper::closeServer(4);
	LOG("SERVER 4 closed");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT, ClntUp)
	{
	initClientAndRegion(1, 0);
	getHelper()->cachePtr->readyForEvents();

	auto regPtr0 = getHelper()->getRegion(regionNames[0]);
	regPtr0->registerAllKeys(true);

	LOG("Clnt1Init complete.");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT, ClntUpNonHA)
	{
	initClientAndRegion(0, 0);
	getHelper()->cachePtr->readyForEvents();

	auto regPtr0 = getHelper()->getRegion(regionNames[0]);
	regPtr0->registerAllKeys(true);

	LOG("Clnt1Init complete.");
	}
	END_TASK_DEFINITION

	/* Close Client 1 with option keep alive = true*/
	DUNIT_TASK_DEFINITION(CLIENT, ClntDown)
	{
	getHelper()->disconnect(true);
	cleanProc();
	LOG("Client Down complete: Keepalive = True");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT, ClntSleep)
	{
	LOG(" Sleeping for 100 seconds");
	SLEEP(100000); /* 100 seconds for timeout*/
	LOG(" Finished sleep of 100 seconds");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT, VerifyNonHA)
	{
	/Test case 4 , 1 /
	LOG("Verify 1: Verify that Client has queue on S1");

	ASSERT(TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(1)),
	"Server 1 should have queue");
	ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(2)),
	"Server 2 should not have queue");
	ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(3)),
	"Server 3 should not have queue/connection");
	ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(4)),
	"Server 4 should not have queue/connection");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT, Verify1)
	{
	/Test case 4 , 1 /
	LOG("Verify 1: Verify that Client has queues on S1 and S2");

	ASSERT(TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(1)),
	"Server 1 should have queue");
	ASSERT(TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(2)),
	"Server 2 should have queue");
	ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(3)),
	"Server 3 should not have queue/connection");
	ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(4)),
	"Server 4 should not have queue/connection");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT, Verify2)
	{
	/Test case 2/
	LOG("Verify 2: Verify that Client has queues on S2 and either S3 or S4 and "
	"not both");

	ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(1)),
	"Server 1 should not have queue");
	ASSERT(TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(2)),
	"Server 2 should have queue");
	bool server3_hasQueue = TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(3));
	bool server4_hasQueue = TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(4));
	ASSERT(((server3_hasQueue && !server4_hasQueue) \|\|
	(!server3_hasQueue && server4_hasQueue)),
	"Either Server 3 or Server 4 should have queue");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT, Verify3)
	{
	/Test case 3/
	LOG("Verify 3: Verify that Client has queues on S3 and S4");

	ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(1)),
	"Server 1 should not have queue/connection");
	ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(2)),
	"Server 2 should not have queue/connection");
	ASSERT(TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(3)),
	"Server 3 should have queue/connection");
	ASSERT(TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(4)),
	"Server 4 should have queue/connection");
	}
	END_TASK_DEFINITION

	DUNIT_TASK_DEFINITION(CLIENT, Verify4)
	{
	/Test case 5/
	LOG("Verify 4: Verify that no servers have queues");

	ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(1)),
	"Server 1 should not have queue/connection");
	ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(2)),
	"Server 2 should not have queue/connection");
	ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(3)),
	"Server 3 should not have queue/connection");
	ASSERT(!TestUtils::getCacheImpl(getHelper()->cachePtr)
	->getEndpointStatus(getServerEndPoint(4)),
	"Server 4 should not have queue/connection");
	}
	END_TASK_DEFINITION

	void doThinClientDurableConnect() {
	CALL_TASK(StartLocator);

	CALL_TASK(S1Up);
	CALL_TASK(ClntUpNonHA);
	CALL_TASK(S2Up);
	CALL_TASK(ClntDown);
	CALL_TASK(ClntUp);
	CALL_TASK(VerifyNonHA);
	CALL_TASK(ClntDown);
	CALL_TASK(S1Down);
	/* Presently for 4 servers only */
	/* Test case 4 */
	CALL_TASK(S1Up);
	CALL_TASK(ClntUp);
	/* Test case 1 */
	CALL_TASK(S3Up);
	CALL_TASK(S4Up);
	CALL_TASK(ClntDown);
	CALL_TASK(ClntUp);
	CALL_TASK(Verify1);
	/* Test case 2 */
	CALL_TASK(ClntDown);
	CALL_TASK(S1Down);
	CALL_TASK(ClntUp);
	CALL_TASK(ClntDown);
	CALL_TASK(ClntUp);
	CALL_TASK(Verify2);
	/* Test case 3 */
	CALL_TASK(ClntDown);
	CALL_TASK(S2Down);
	CALL_TASK(ClntUp);
	CALL_TASK(ClntDown);
	CALL_TASK(ClntUp);
	CALL_TASK(Verify3);
	CALL_TASK(ClntDown);
	CALL_TASK(ClntSleep);
	CALL_TASK(ClntUp);
	CALL_TASK(Verify4);
	/* Close Everything */
	CALL_TASK(ClntDown);
	CALL_TASK(S3Down);
	CALL_TASK(S4Down);

	CALL_TASK(CloseLocator);
	}

	#endif // GEODE_INTEGRATION_TEST_THINCLIENTDURABLECONNECT_H_