// Copyright (c) 2006-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:

// @file ctlbsassdatastepcanceltrackingconflict.cpp

// This is the class implementation for the Module Information Tests

// EPOC includes.

// 

//

// LBS includes. 

#include <lbs.h>

#include <lbs/lbsnetcommon.h>

#include <lbssatellite.h>

#include <lbs/lbsnetprotocolbase.h>

#include <lbs/lbsassistancedatabuilderset.h>

#include <e32math.h>

// LBS test includes.

#include "ctlbsconflictstepcanceltrackingconflict.h"

#include <lbs/test/tlbsutils.h>

/**	Test case development notes

	===========================

	It was decided to aid readablity each test class shall only support a single test case.

	This canceltrackingconflict has been produced to show how a typical conflict test case should be coded.

	Net Sim and Sequence Events

	---------------------------

	Every test case implementation will use the ctlbsconflictstep class which supports Net Sim

	interactions and a way to ensure Net Sim events and client completion events have a occured

	in the correct order. An array is used to hold the expected sequence event values, and a second

	array contains the actual events produced during the test. Once the test moves into the EWaiting

	state typically after all the client requests have been made, the event arrays are compared to

	ensure the correct events were given.

	To set the expected sequence events populate the array in the SetExpectedSeq() function.

	Async wappers

	-------------

	Each Lbs client async request is wappared in a active object class, to allow a number of

	outstanding async requests during the test. Any async calls you wish to make should also

	be wrapped in the same way, see CT_LbsDoX3P and CT_LbsDoPosUpdate for canceltrackingconflicts.

	These classes are constructed in the test class ConstructL, and maybe started or cancelled

	during the test at any point.

	Verify Position Information

	---------------------------

	A test should verify each client call which expected a location to be returned. The

	location data should be validation to ensure it's correct. See VerifyPosInfos.

*/

/**

Static Constructor

*/

CT_LbsConflictStep_canceltrackingconflict* CT_LbsConflictStep_canceltrackingconflict::New(CT_LbsConflictServer& aParent)

	{

	// Note the lack of ELeave.

	// This means that having insufficient memory will return NULL;

	CT_LbsConflictStep_canceltrackingconflict* testStep = new CT_LbsConflictStep_canceltrackingconflict(aParent);

	if (testStep)

		{

		TInt err = KErrNone;

		TRAP(err, testStep->ConstructL());

		if (err)

			{

			delete testStep;

			testStep = NULL;

			}

		}

	return testStep;

	}

/**

 * Constructor

 */

CT_LbsConflictStep_canceltrackingconflict::CT_LbsConflictStep_canceltrackingconflict(CT_LbsConflictServer& aParent) : CT_LbsConflictStep(aParent)

	{

	SetTestStepName(KLbsConflictStep_canceltrackingconflict);

	}

void CT_LbsConflictStep_canceltrackingconflict::ConstructL()

	{

	// Create the base class objects.

	CT_LbsConflictStep::ConstructL();

	// Self locate async wrapper.

	iDoPosUpdate = CT_LbsDoPosUpdate::NewL(this);

	// X3P async wrapper.

	iDoX3P = CT_LbsDoX3P::NewL(this);

	}

/**

 * Destructor

 */

CT_LbsConflictStep_canceltrackingconflict::~CT_LbsConflictStep_canceltrackingconflict()

	{

	iDoPosUpdate->Cancel();

	delete iDoPosUpdate;

	iDoX3P->Cancel();

	delete iDoX3P;

	}

/** Called at the start of the test...

	Each test case MUST implement this.

	The table below describes the expected order that the callbacks should be called

	during the test.

	Note that the tests deliberateley do NOT check the order that the client requests

	are completed. This is because the delivery order is not guaranteed by LBS.

	The tests will check that all client requests are completed with the correct error

	code and position at the end of the test.

*/

// Test 0013

// here we do a tracking NPUD and wait for it to finish

// Then we start a second NPUD in the  NotifyReleaseLcsMoLr callback

// followed by  a X3P Push. Conflict!

// When the first X3P completes (in the RunL()) we do a X3P (Timer) request.

// The first NPUD and both X3P requests should complte  with KErrNone

// The second NPUD should complete with KErrHighPriorityRec

//!		Client:SetUpdateOptions(interval=4 seconds)			->LBS

//!		Client:NotifyPositionUpdate								->LBS

//!		Client:RunL(NotifyPositionUpdate(KErrNone))				<-LBS	// when it completes

//!		Client:NotifyPositionUpdate								->LBS	// request now outstanding!

//!		The next steps replaces original test 0009!	

//!		Client:TransmitPosition(PUSH)							->LBS

//!		Client:RunL(NotifyPositionUpdate(KErrHighPriorityRec))	<-LBS	// conflict! // this action causes end of tracking

//!		Client:RunL(TransmitPosition(PUSH,pos,KErrNone))		->LBS	

//!		Client:TransmitPosition(TIMER)							->LBS

//!		Client:RunL(TransmitPosition(PUSH,pos,KErrNone))		->LBS	// checks that tracking is stopped

//!

void CT_LbsConflictStep_canceltrackingconflict::SetExpectedSeq()

	{

	// Self locate MOLR (iState = ERegPosUpdate)

	SetVerifySeqEvent(ESelf_MOLR_NetSim_Got_NotifyRegisterLcsMoLr);				// --> To Net

	SetVerifySeqEvent(ESelf_MOLR_NetSim_Got_NotifyMeasurementControlLocation);	// <-- From Net

	SetVerifySeqEvent(ESelf_MOLR_NetSim_Got_NotifyMeasurementReportLocation);	// --> To Net

	SetVerifySeqEvent(ESelf_MOLR_NetSim_Got_NotifyFacilityLcsMoLrResult);		// <-- From Net

	SetVerifySeqEvent(ESelf_MOLR_NetSim_Got_NotifyReleaseLcsMoLr);				// --> To Net

	// above client request completes KErrNone

	// in the ReleaseLcsMoLr call back do asecond tracking Self locate MOLR 

	// note that the test integration module only dies a MoLr for the first request

	// and then do a X3PPush in the above callback

	// second NUPD should complete with KErrHighPriorityRec

	// X3P Push (iState = EReqX3PPush) - NPUD above will complete with KErrHighPriorityRec

	SetVerifySeqEvent(EX3P_PUSH_MOLR_NetSim_Got_NotifyRegisterLcsMoLr);				// --> To Net

	SetVerifySeqEvent(EX3P_PUSH_MOLR_NetSim_Got_NotifyMeasurementControlLocation);	// <-- From Net

	SetVerifySeqEvent(EX3P_PUSH_MOLR_NetSim_Got_NotifyMeasurementReportLocation);	// --> To Net

	SetVerifySeqEvent(EX3P_PUSH_MOLR_NetSim_Got_NotifyFacilityLcsMoLrResult);		// <-- From Net

	SetVerifySeqEvent(EX3P_PUSH_MOLR_NetSim_Got_NotifyReleaseLcsMoLr);				// --> To Net

	// followed by a X3P Timer (after X3P Timer register iState = ERegX3PTimer),

	// X3P(Timer) should be queued and handled after the X3P(Push)

	SetVerifySeqEvent(EX3P_TIMER_MOLR_NetSim_Got_NotifyRegisterLcsMoLr);			// --> To Net	

	SetVerifySeqEvent(EX3P_TIMER_MOLR_NetSim_Got_NotifyMeasurementControlLocation);	// <-- From Net

	SetVerifySeqEvent(EX3P_TIMER_MOLR_NetSim_Got_NotifyMeasurementReportLocation);	// --> To Net

	SetVerifySeqEvent(EX3P_TIMER_MOLR_NetSim_Got_NotifyFacilityLcsMoLrResult);		// <-- From Net

	SetVerifySeqEvent(EX3P_TIMER_MOLR_NetSim_Got_NotifyReleaseLcsMoLr);				// --> To Net

	// both X3P's should complete with KerrNone

	// (after X3P release iState = EWaiting).

	SetVerifyAdhocEvent(EClient_Got_PosUpdate_Complete);

	SetVerifyAdhocEvent(EClient_Got_X3P_Complete);

	// We have 2 self locate requests and 2 x3p requests so must record them both

	SetVerifyAdhocEvent(EClient_Got_PosUpdate_Complete);

	SetVerifyAdhocEvent(EClient_Got_X3P_Complete);

	}

/** Called at the end of the test to verify the correct position data has been returned to the

	client.

	Each test case SHOULD implement a version of this.

*/

void CT_LbsConflictStep_canceltrackingconflict::VerifyPosInfos()

	{

	T_LbsUtils utils;

    RPointerArray<TAny>& verifyPosInfoArr = iParent.iSharedData->iVerifyPosInfoArr;

	RPointerArray<TAny>& currPosInfoArr = iParent.iSharedData->iCurrentPosInfoArr;

	TPositionInfo* currPosInfo;

	// Verify the received self locate and X3P MOLR positions.

	// position [0] is used to hold the first NPUD position result

	// position [1] is used to hold the second NPUD position result

	// position [2] is used to hold the X3P Push position result

	// position [3] is used to hold the X3P Timer position result

	// position [0] is used to hold the first NPUD position result

	TPositionInfo* verifyPosInfo = reinterpret_cast<TPositionInfo*>(verifyPosInfoArr[0]);

	currPosInfo = reinterpret_cast<TPositionInfo*>(currPosInfoArr[0]);

	// It was a new client so verify got the reference position.

	TPositionInfo verifyRefPosInfo;

	verifyRefPosInfo.SetPosition(iRefPos);

	if (!utils.Compare_PosInfo(verifyRefPosInfo, *currPosInfo))

		{

		INFO_PRINTF1(_L("Failed test, position incorrect."));

		SetTestStepResult(EFail);

		}

	// position [1] is used to hold the second NPUD position result

	// We expect a position containing NaNs.

	currPosInfo = reinterpret_cast<TPositionInfo*>(currPosInfoArr[1]);

	TPosition pos;

	currPosInfo->GetPosition(pos);

	if (!Math::IsNaN(pos.Latitude()))

		{

		INFO_PRINTF1(_L("Failed test, Second NPUD Position does not contain NANs"));

		INFO_PRINTF1(_L("It should have been completed with KErrHighPriorityRec"));

		SetTestStepResult(EFail);

		}

	if (!Math::IsNaN(pos.Longitude()))

		{

		INFO_PRINTF1(_L("Failed test, Second NPUD Position does not contain NANs"));

		INFO_PRINTF1(_L("It should have been completed with KErrHighPriorityRec"));

		SetTestStepResult(EFail);

		}

	// position [2] is used to hold the X3P Push position result

	currPosInfo = reinterpret_cast<TPositionInfo*>(currPosInfoArr[2]);

	if (!utils.Compare_PosInfo(*verifyPosInfo, *currPosInfo))

		{

		INFO_PRINTF1(_L("Failed test, X3P Push position incorrect."));

		SetTestStepResult(EFail);

		}

	// position [3] is used to hold the X3P Timer position result

	currPosInfo = reinterpret_cast<TPositionInfo*>(currPosInfoArr[3]);

	if (!utils.Compare_PosInfo(*verifyPosInfo, *currPosInfo))

		{

		INFO_PRINTF1(_L("Failed test, X3P Timerposition incorrect."));

		SetTestStepResult(EFail);

		}

	}

/** A standard TEF test case doTestStepL, this SHOULD only support a single test case.

	Typically the function will look much like this.

 */

TVerdict CT_LbsConflictStep_canceltrackingconflict::doTestStepL()

	{

	// Generic test step used to test the LBS Client Notify position update API.

	INFO_PRINTF1(_L(">>CT_LbsConflictStep_canceltrackingconflict::doTestStepL()"));

	if (TestStepResult() == EPass)

		{		

		// Setup the expected sequence events for the test.

		SetExpectedSeq();

		// Open and setup net sim.

		OpenNetSim(this);

		// Kick off the test abort and keep alive timers.

		TTimeIntervalMicroSeconds32 abortInterval(KLbsAbortPeriod);

		TTimeIntervalMicroSeconds32 keepAliveInterval(KLbsKeepAlivePeriod);

		iAbortTimer->SetTimer(abortInterval);

		iKeepAliveTimer->SetTimer(keepAliveInterval);

		// Kick off test.

		CActiveScheduler::Start();

		// Verify location data.

		VerifyPosInfos();

		// Clean up.

		CloseNetSim();

		}

	INFO_PRINTF1(_L("<<CT_LbsConflictStep_canceltrackingconflict::doTestStepL()"));

	return TestStepResult();

	}

/** NetSim callbacks given for a MoLr, which we invoke as a result of the notify position update.

*/

void CT_LbsConflictStep_canceltrackingconflict::Connected()

	{

	// Call base implementation.

	CT_LbsConflictStep::Connected();

	// Kick off first pos update.

	// Create a posinfo and store in our shared array for later verification.

	RPointerArray<TAny>& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr;

	TPositionInfo* posInfo = new(ELeave) TPositionInfo();

	T_LbsUtils utils;

	utils.ResetAndDestroy_PosInfoArr(posInfoArr);	// Clear previous entries before new entry is appended.

	posInfoArr.Append(posInfo); // position [0] is used to hold the first NPUD postion result

	// Kick off pos update.

	TPositionUpdateOptions tempOpts;

	// set a 4 second tracking interval to ensure the 2nd request doesn't 

	// complete too quicky:

	tempOpts.SetUpdateInterval(4*1000000);

	tempOpts.SetUpdateTimeOut(2*1000000);

	iDoPosUpdate->SetOptions(tempOpts);

 	INFO_PRINTF1(_L("Start first tracking NPUD"));

	iDoPosUpdate->StartL(*posInfo);

	iState = EReqPosUpdate;

	}

void CT_LbsConflictStep_canceltrackingconflict::Disconnected()

	{

	// Call base implementation.

	CT_LbsConflictStep::Disconnected();

	}

void CT_LbsConflictStep_canceltrackingconflict::NotifyRegisterLcsMoLr(const TDesC& aData)

	{

	// Determine and record the sequence event. A blank aData indicates a self locate

	// MOLR, otherwise we have a X3P MOLR. Also the current test state indicates which

	// type MOLR is being carried out.

	if (aData != KNullDesC)

		{

	 	if (iX3PPush)

	 		{

	 		INFO_PRINTF1(_L("Got - X3P MOLR PUSH- NetSim Notify Register Lcs MoLr - Event."));

			SetCurrentSeqEvent(EX3P_PUSH_MOLR_NetSim_Got_NotifyRegisterLcsMoLr);

	 		if (aData.Compare(KTransmitPushDestination))

				{

				INFO_PRINTF1(_L("Failed test, bad X3P register data."));

				SetTestStepResult(EFail);

				}

		 	}

		else

			{

			INFO_PRINTF1(_L("Got - X3P MOLR TIMER - NetSim Notify Register Lcs MoLr - Event."));

			SetCurrentSeqEvent(EX3P_TIMER_MOLR_NetSim_Got_NotifyRegisterLcsMoLr);

			if (aData.Compare(KTransmitTimerDestination))

				{

				INFO_PRINTF1(_L("Failed test, bad X3P register data."));

				SetTestStepResult(EFail);

				}

			}

		// Mark as started now it has, to ensure the self MOLR are not recorded incorrectly.

		iState = EReqX3P;

		}

	else if ((aData == KNullDesC) && (iState == EReqPosUpdate))

		{

		INFO_PRINTF1(_L("Got - Self MOLR - NetSim Notify Register Lcs MoLr - Event."));

		SetCurrentSeqEvent(ESelf_MOLR_NetSim_Got_NotifyRegisterLcsMoLr);

		}

	}

void CT_LbsConflictStep_canceltrackingconflict::NotifyReleaseLcsMoLr(TInt aReason)

	{

	TInt expectedErr = KErrNone;

	// Determine and set sequence event.

	if (iKDoASecondNPUD)

		{

		iKDoASecondNPUD = EFalse;

		INFO_PRINTF1(_L("self MOLR - NetSim Notify Release Lcs MoLr - Event."));

		SetCurrentSeqEvent(ESelf_MOLR_NetSim_Got_NotifyReleaseLcsMoLr);

		// Create a posinfo and store in our shared array for later verification.

		T_LbsUtils utils;

		RPointerArray<TAny>& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr;

		TPositionInfo* posInfo = new(ELeave) TPositionInfo();

		posInfoArr.Append(posInfo); // position [1] is used to hold the second NPUD postion result

		INFO_PRINTF1(_L("Start a second tracking NPUD"));

		iDoPosUpdate->StartL(*posInfo);

		iState = EReqPosUpdate2;

		posInfo = new(ELeave) TPositionInfo();

		posInfoArr.Append(posInfo); // position [2] is used to hold the X3P Push result

		// create a conflict by Starting  Push X3P.

		TLbsTransmitPositionOptions transOpts;

		iDoX3P->SetOptions(transOpts);	// Set timeout value to 0, to disable the timeout.

		// now make a conflict occur by doing a high priority X3P

		// the  outstanding NPUD should be completed with  KErrPositionHighPriorityReceive

		iKErrHighPriorityRecExpected = ETrue;

		iState = EReqX3P;

		iX3PPush = ETrue;

		INFO_PRINTF1(_L("Start X3P Push"));

		iDoX3P->StartL(KTransmitPushDestination, KTransmitPushPriority, *posInfo);

		iDoAX3PTimer = ETrue;	// when PUSH X3P completes

		}

	else

	if (iState == EReqPosUpdate)

		{

		INFO_PRINTF1(_L("Got - Self MOLR - NetSim Notify Release Lcs MoLr - Event."));

		SetCurrentSeqEvent(ESelf_MOLR_NetSim_Got_NotifyReleaseLcsMoLr);

        expectedErr = KErrPositionHighPriorityReceive;

        }

	else if(iState == EReqX3P)

		{

			if (iX3PPush)

				{

				INFO_PRINTF1(_L("Got - X3P PUSHMOLR - NetSim Notify Release Lcs MoLr - Event."));

				SetCurrentSeqEvent(EX3P_PUSH_MOLR_NetSim_Got_NotifyReleaseLcsMoLr);

				}

			else

				{

				INFO_PRINTF1(_L("Got - X3P TIMER MOLR - NetSim Notify Release Lcs MoLr - Event."));

				SetCurrentSeqEvent(EX3P_TIMER_MOLR_NetSim_Got_NotifyReleaseLcsMoLr);

				// Now we have had the last callback

				// but don't end the test until

				// until/unless had 2nd NPUD has finshed

				iHadLastCallBack = ETrue;

				if (!iKErrHighPriorityRecExpected)

					{

					iState = EWaiting;

					}

				}

			expectedErr = KErrNone;

			iX3PPush = EFalse; // next is a X3P Timer! 

		}

	// Verify reason code.

	if (aReason != expectedErr)

		{	

		INFO_PRINTF2(_L("Failed test, bad release reason %d."), aReason);

		SetTestStepResult(EFail);

		}

	}

void CT_LbsConflictStep_canceltrackingconflict::NotifyMeasurementControlLocation(const TPositionInfo& aPosition, 

															  const RLbsAssistanceDataBuilderSet& aData, 

															  const TLbsNetPosRequestQuality& aQuality)

	{

	T_LbsUtils utils;	

	TInt err;

	// Determine and record sequence event.

	if (iState == EReqPosUpdate)

		{

		INFO_PRINTF1(_L("Got - Self MOLR - NetSim Notify Measurement Control Location - Event."));

		SetCurrentSeqEvent(ESelf_MOLR_NetSim_Got_NotifyMeasurementControlLocation);

		}

	else if(iState == EReqX3P)

		{

		if (iX3PPush)

			{

			INFO_PRINTF1(_L("Got - X3P MOLR PUSH- NetSim Notify Measurement Control Location - Event."));

			SetCurrentSeqEvent(EX3P_PUSH_MOLR_NetSim_Got_NotifyMeasurementControlLocation);

			}

		else

			{

			INFO_PRINTF1(_L("Got - X3P MOLR TIMER- NetSim Notify Measurement Control Location - Event."));

			SetCurrentSeqEvent(EX3P_TIMER_MOLR_NetSim_Got_NotifyMeasurementControlLocation);

			}

		}

	// Verify the reference position.

	TPositionInfo verifyRefPosInfo;

	verifyRefPosInfo.SetPosition(iRefPos);

	if (!utils.Compare_PosInfo(verifyRefPosInfo, aPosition))