/*

* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

* Example CTestStep derived implementation

*

*/

/**

 @file ServerTestStep.cpp

 @internalTechnology

*/

#include "serverteststep.h"

//To launch the test version of the location server that uses the test location monitor API

#include "tserverstartparams.h" // for TServerStartParams

#include "cserverlaunch.h"

CServerTestStep::~CServerTestStep()

/**

 * Destructor

 */

	{

	}

CServerTestStep::CServerTestStep()

/**

 * Constructor

 */

	{

	SetTestStepName(KServerTestStep);

	}

TInt CServerTestStep::StartEposServer()

	{

	// Start the unit-test version of the Location Server that uses

	// the test locaiton monitor API.

	// Note: The server name still actually needs to be the same

	//       as the 'real' Location server, otherwise clients will not

	//       be able to connect it (and they will then start the 

	//		 'real' one, which messes up this test).

	_LIT(KPositionServerName, "!PosServer.exe"); 

	_LIT(KTestLocServerFileName, "testlocserver.exe"); 

	TServerStartParams params;

	params.SetServerFileName(KTestLocServerFileName);

	params.SetServerName(KPositionServerName);

	params.SetNumberOfServerSlots(KServerFrameworkDefaultMessageSlots);

	params.SetServerUids(KNullUid, KNullUid, TUid::Uid(0x102869E5));

	TRAPD(err,User::LeaveIfError(CServerLaunch::ServerLaunch(params)));

	return err;

	}

TVerdict CServerTestStep::doTestStepPreambleL()

/**

 * @return - TVerdict code

 * Override of base class virtual

 */

	{

	// The Property is used the modify the behaviour of the testLocMonitorApi for different

	// test cases

	TInt err;

	static _LIT_SECURITY_POLICY_PASS(KAllowAllPolicy);

	err = RProperty::Define(KLocSrvTestSuite, KLbsLocMonitorTestSessionKey,

			RProperty::EInt, KAllowAllPolicy, KAllowAllPolicy);

	if (err != KErrNone && err != KErrAlreadyExists)

		{

		User::Leave(err);

		}

	CTe_locsrvSuiteStepBase::doTestStepPreambleL();

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TVerdict CServerTestStep::doTestStepL()

/**

 * @return - TVerdict code

 * Override of base class pure virtual

 * Our implementation only gets called if the base class doTestStepPreambleL() did

 * not leave. That being the case, the current test result value will be EPass.

 */

	{

	if (TestStepResult()==EPass)

		{

		TInt testIndex = KErrNotFound;

		if(!GetIntFromConfig(ConfigSection(),KTe_locsrvSuiteInt,testIndex))

			{

			User::Leave(KErrNotFound);

			}

		else

			{

			// Check if the test location server is running

			_LIT(KPositionServerName, "!PosServer"); 

			TFindServer findServer(KPositionServerName);

			TInt err;

			TFullName name;

			err = findServer.Next(name);

			if (err != KErrNone)

				{

				// If it is not running, then start the test version of the 

				// location server

				err = StartEposServer();

				}

			// If the test location server has been started successfully or is already 

			// running then run the teststep.

			if ((err==KErrNone)||(err==KErrAlreadyExists))

				{

				TestByIndexL(testIndex);

				}

			else

				{

				SetTestStepResult(EFail);

				}

			}

		}

	    return TestStepResult();

	    }

void CServerTestStep::TestByIndexL(TInt aIndex)

    {

    switch (aIndex)

        {

         case 1:

        	_LIT(KTestName1, "Close Session with outstanding Clear database request");

        	INFO_PRINTF1(KTestName1);

        	TdLocSrv_Server_ClearDBPending_CloseSessionHandleL(aIndex);

        	break;

        case 2:

        	_LIT(KTestName2, "Clear database - LocMonitor SessionOpen Fail");

        	INFO_PRINTF1(KTestName2);

        	TdLocSrv_Server_ClearDB_LocMonitor_SessionOpenFailL(aIndex);

        	break;

        case 3:

        	_LIT(KTestName3, "Two Clear database requests");

        	INFO_PRINTF1(KTestName3);

        	TdLocSrv_Server_ClearDB_2ClientsL(aIndex);

        	break;

        case 4:

        	_LIT(KTestName4, "Clear database followed by cancel");

        	INFO_PRINTF1(KTestName4);

        	TdLocSrv_Server_ClearDB_AndCancelL(aIndex);

        	break;

        case 5:

        	_LIT(KTestName5, "Two Clear database requests followed by cancel from one client ");

        	INFO_PRINTF1(KTestName5);

        	TdLocSrv_Server_ClearDB_AndCancel_2ClientsL(aIndex);

        	break;

        case 6:

        	_LIT(KTestName6, "Clear database request times out ");

        	INFO_PRINTF1(KTestName6);

        	TdLocSrv_Server_ClearDB_TimedOutL(aIndex);

        	break;

        case 7:

        	_LIT(KTestName7, "Clear database request 10Clients ");

        	INFO_PRINTF1(KTestName7);

        	TdLocSrv_Server_ClearDB_10ClientsL(aIndex);

        	break;

        default: 

            _LIT(KTestName15, "This test step doesn't exist");

            ERR_PRINTF1(KTestName15);

            SetTestStepResult(EFail);

            break;

        }

    }

TVerdict CServerTestStep::doTestStepPostambleL()

/**

 * @return - TVerdict code

 * Override of base class virtual

 */

	{

	// Delete the keys property used to configure the test location monitor

	// to respond to different test cases

	RProperty property;

	TInt err = property.Delete(KLocSrvTestSuite,KLbsLocMonitorTestSessionKey);

	if (err != KErrNone)

		{

		User::Leave(err);

		}

	return TestStepResult();

	}

extern TInt SetAuthenticRequestor(RPositioner& aPositioner);

///////////////////////////////////////////////////

// 

// RPositionServer

//

///////////////////////////////////////////////////

void SetServerTestCasePropertyL(const TUid TestServerUid, const TUint KeyType, TInt aIndex)

	{

	// The Property is used the modify the behaviour of the testLocMonitorApi for different

	// test cases

	TInt err = RProperty::Set(TestServerUid, KeyType, aIndex);

	if (err != KErrNone)

		{

		User::Leave(err);

		}

	}

TInt CloseSessionWithClearDBReqsL(TAny* /*aPtr*/)

	{

	RPositionServer server;

	User::LeaveIfError(server.Connect());

	CleanupClosePushL(server);

	TRequestStatus reqStatus;

	server.EmptyLastKnownPositionStore(reqStatus);

	User::After(KClearDBReqPropagateDelay);

    TBool otherReqPending = (reqStatus.Int()==KRequestPending);

    _LIT(KIncorrectTestSetup,"Test timing fault");

    if (!otherReqPending)

    	{

    	// Increase the delay in the test location monitor as we require the above 

    	// requests to be outstanding when an emptylastknownpositionstore request 

    	// is issued [the panic occurs when the above requests have been completed before

    	// an emptylastknownpositionstore request ]

    	User::Panic(KIncorrectTestSetup, KErrGeneral);

    	}

	server.Close(); // Has to PANIC as there is an outstanding request

	User::After(KHalfSecond);

	CleanupStack::Pop(&server);

	return KErrGeneral;

	}

TVerdict CServerTestStep::TdLocSrv_Server_ClearDBPending_CloseSessionHandleL(TInt aIndex)

	{

	SetServerTestCasePropertyL(KLocSrvTestSuite, KLbsLocMonitorTestSessionKey, aIndex);

    DO_PANIC_TEST_L(CloseSessionWithClearDBReqsL, KPosClientFault, 

    		EPositionRequestsNotCancelled, KDefaultTestTimeout);

    return TestStepResult();

	}

TInt ClearDBLocMonitorSessionFailL(TAny* /*aPtr*/)

	{

	// Check the correct message is always sent to the server upon a call

	// to this function and that the return value is always that of the

	// completed message.

	RPositionServer server;

	User::LeaveIfError(server.Connect());

	CleanupClosePushL(server);

	TRequestStatus reqStatus;

	server.EmptyLastKnownPositionStore(reqStatus);

	User::WaitForRequest(reqStatus);

//	server.Close();

	CleanupStack::PopAndDestroy(&server);

	return KErrGeneral;

	}

TVerdict CServerTestStep::TdLocSrv_Server_ClearDB_10ClientsL(TInt aIndex)

	{

	SetServerTestCasePropertyL(KLocSrvTestSuite, KLbsLocMonitorTestSessionKey, aIndex);

	RPositionServer server1;

	RPositionServer server2;

	RPositionServer server3;

	RPositionServer server4;

	RPositionServer server5;

	RPositionServer server6;

	RPositionServer server7;

	RPositionServer server8;

	RPositionServer server9;

	RPositionServer server10;

	User::LeaveIfError(server1.Connect());

	CleanupClosePushL(server1);

	User::LeaveIfError(server2.Connect());

	CleanupClosePushL(server2);

	User::LeaveIfError(server3.Connect());

	CleanupClosePushL(server3);

	User::LeaveIfError(server4.Connect());

	CleanupClosePushL(server4);

	User::LeaveIfError(server5.Connect());

	CleanupClosePushL(server5);

	User::LeaveIfError(server6.Connect());

	CleanupClosePushL(server6);

	User::LeaveIfError(server7.Connect());

	CleanupClosePushL(server7);

	User::LeaveIfError(server8.Connect());

	CleanupClosePushL(server8);

	User::LeaveIfError(server9.Connect());

	CleanupClosePushL(server9);

	User::LeaveIfError(server10.Connect());

	CleanupClosePushL(server10);

	TRequestStatus reqStatus1,reqStatus2,reqStatus3,reqStatus4,reqStatus5,reqStatus6,reqStatus7,

						reqStatus8,reqStatus9,reqStatus10;

	server1.EmptyLastKnownPositionStore(reqStatus1);

	User::After(KClearDBMultipleReqDelay);

	server2.EmptyLastKnownPositionStore(reqStatus2);

	User::After(KClearDBMultipleReqDelay);

	server3.EmptyLastKnownPositionStore(reqStatus3);

	User::After(KClearDBMultipleReqDelay);

	server4.EmptyLastKnownPositionStore(reqStatus4);

	User::After(KClearDBMultipleReqDelay);

	server5.EmptyLastKnownPositionStore(reqStatus5);

	User::After(KClearDBMultipleReqDelay);

	server6.EmptyLastKnownPositionStore(reqStatus6);

	User::After(KClearDBMultipleReqDelay);

	server7.EmptyLastKnownPositionStore(reqStatus7);

	User::After(KClearDBMultipleReqDelay);

	server8.EmptyLastKnownPositionStore(reqStatus8);

	User::After(KClearDBMultipleReqDelay);

	server9.EmptyLastKnownPositionStore(reqStatus9);

	User::After(KClearDBMultipleReqDelay);

	server10.EmptyLastKnownPositionStore(reqStatus10);

	User::After(KClearDBMultipleReqDelay);

	User::WaitForRequest(reqStatus1);

	User::WaitForRequest(reqStatus2);

	User::WaitForRequest(reqStatus3);

	User::WaitForRequest(reqStatus4);

	User::WaitForRequest(reqStatus5);

	User::WaitForRequest(reqStatus6);

	User::WaitForRequest(reqStatus7);

	User::WaitForRequest(reqStatus8);

	User::WaitForRequest(reqStatus9);

	User::WaitForRequest(reqStatus10);

	CheckExpectedResult(KErrNone, reqStatus1.Int(), KFailedClearDB);

	CheckExpectedResult(KErrNone, reqStatus2.Int(), KFailedClearDB);

	CheckExpectedResult(KErrNone, reqStatus3.Int(), KFailedClearDB);

	CheckExpectedResult(KErrNone, reqStatus4.Int(), KFailedClearDB);

	CheckExpectedResult(KErrNone, reqStatus5.Int(), KFailedClearDB);

	CheckExpectedResult(KErrNone, reqStatus6.Int(), KFailedClearDB);

	CheckExpectedResult(KErrNone, reqStatus7.Int(), KFailedClearDB);

	CheckExpectedResult(KErrNone, reqStatus8.Int(), KFailedClearDB);

	CheckExpectedResult(KErrNone, reqStatus9.Int(), KFailedClearDB);

	CheckExpectedResult(KErrNone, reqStatus10.Int(), KFailedClearDB);

	server1.EmptyLastKnownPositionStore(reqStatus1);

	User::After(KClearDBMultipleReqDelay);

	server2.EmptyLastKnownPositionStore(reqStatus2);

	User::After(KClearDBMultipleReqDelay);

	User::WaitForRequest(reqStatus1);

	User::WaitForRequest(reqStatus2);

	CheckExpectedResult(KErrNone, reqStatus1.Int(), KFailedClearDB);

	CheckExpectedResult(KErrNone, reqStatus2.Int(), KFailedClearDB);

	CleanupStack::PopAndDestroy(10,&server1);

	return TestStepResult();

	}

TVerdict  CServerTestStep::TdLocSrv_Server_ClearDB_LocMonitor_SessionOpenFailL(TInt aIndex)

	{

	SetServerTestCasePropertyL(KLocSrvTestSuite, KLbsLocMonitorTestSessionKey, aIndex);

    DO_PANIC_TEST_L(ClearDBLocMonitorSessionFailL, KLeaveInPanicThread, KErrServerTerminated, KDefaultTestTimeout);

	return TestStepResult();

	}

TVerdict  CServerTestStep::TdLocSrv_Server_ClearDB_2ClientsL(TInt aIndex)

	{

	SetServerTestCasePropertyL(KLocSrvTestSuite, KLbsLocMonitorTestSessionKey, aIndex);

	RPositionServer server1;

	TInt err = server1.Connect();

	CleanupClosePushL(server1);

	if(err != KErrNone)

		{

		ERR_PRINTF1(KFailedConnectServer);

		SetTestStepResult(EFail);

		return TestStepResult();

		}

	RPositionServer server2;

	err = server2.Connect();

	CleanupClosePushL(server2);

	if(err != KErrNone)

		{

		ERR_PRINTF1(KFailedConnectServer);

		SetTestStepResult(EFail);

		return TestStepResult();

		}

	TRequestStatus reqStatus1;

	server1.EmptyLastKnownPositionStore(reqStatus1);

	User::After(KClearDBMultipleReqDelay);

	TRequestStatus reqStatus2;

	server2.EmptyLastKnownPositionStore(reqStatus2);

	User::WaitForRequest(reqStatus1);

	User::WaitForRequest(reqStatus2);

	CheckExpectedResult(KErrNone, reqStatus1.Int(), KFailedClearDB);

	CheckExpectedResult(KErrNone, reqStatus2.Int(), KFailedClearDB);

	//	    server1.Close();

	//	    server2.Close();

	CleanupStack::PopAndDestroy(2,&server1);

	return TestStepResult();

	}

TVerdict CServerTestStep::TdLocSrv_Server_ClearDB_AndCancelL(TInt aIndex)

	{

	SetServerTestCasePropertyL(KLocSrvTestSuite, KLbsLocMonitorTestSessionKey, aIndex);

	RPositionServer server1;

	TInt err = server1.Connect();

	CleanupClosePushL(server1);

	if(err != KErrNone)

		{

		ERR_PRINTF1(KFailedConnectServer);

		SetTestStepResult(EFail);

		return TestStepResult();

		}

	TRequestStatus reqStatus1;

	server1.EmptyLastKnownPositionStore(reqStatus1);

	User::After(KClearDBReqPropagateDelay);

    TBool otherReqPending = (reqStatus1.Int()==KRequestPending);

    _LIT(KIncorrectTestSetup,"Test timing fault");

    if (!otherReqPending)

    	{

    	// Increase the delay in the test location monitor as we require the above 

    	// requests to be outstanding when an emptylastknownpositionstore request 

    	// is issued [the panic occurs when the above requests have been completed before

    	// an emptylastknownpositionstore request ]

    	User::Panic(KIncorrectTestSetup, KErrGeneral);

    	}

	TInt cancelresult = server1.CancelRequest(RPositionServer::EReqEmptyLastKnownPositionStore);

	User::WaitForRequest(reqStatus1);

	CheckExpectedResult(KErrNone, cancelresult, KFailedCancelClearDB);

	CheckExpectedResult(KErrCancel, reqStatus1.Int(), KFailedClearDBCancel);

	//	    server1.Close();

	//	    server2.Close();

	CleanupStack::PopAndDestroy(&server1);

	return TestStepResult();

	}

TVerdict CServerTestStep::TdLocSrv_Server_ClearDB_AndCancel_2ClientsL(TInt aIndex)

	{

	SetServerTestCasePropertyL(KLocSrvTestSuite, KLbsLocMonitorTestSessionKey, aIndex);

	RPositionServer server1;

	TInt err = server1.Connect();

	CleanupClosePushL(server1);

	if(err != KErrNone)

		{

		ERR_PRINTF1(KFailedConnectServer);

		SetTestStepResult(EFail);

		return TestStepResult();

		}

	RPositionServer server2;

	err = server2.Connect();

	CleanupClosePushL(server2);

	if(err != KErrNone)

		{

		ERR_PRINTF1(KFailedConnectServer);

		SetTestStepResult(EFail);

		return TestStepResult();

		}