// 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:

// Example CTestStep derived implementation

// 

//

/**

 @file man4Step.cpp

*/

#include "man4Step.h"

#include "Te_manSuiteDefs.h"

#include "LbsInternalInterface.h"

#include <lbs/lbsassistancealmanac.h>

#include <lbs/lbsassistancereferencetime.h>

#include <lbs/lbsassistanceaquisitionassistance.h>

#include <lbs/lbsextendedsatellite.h>

#include "cprocesslaunch.h"

#include "lbsnetinternalapi.h"

//#include "lbsassistancedatacacheapi.h"

#include "LbsInternalInterface.h"

//-----------------------------------------------------------------------------------------

const TTimeIntervalMicroSeconds32 KNoModuleMsgTimeout = 5000000;//5s

const TTimeIntervalMicroSeconds32 KNoLocUpdTimeout    = 5000000;//5s

const TTimeIntervalMicroSeconds32 KFutureReqDelay     = 10000000;//10s

#if defined(__GCCXML__) || defined(__GCC__)

const TInt64 KLbsTestMaxFixTime	= 0x7FFFFFFFFFFFFFFFLL;	// GCC-XML expects LL appended to this long type

#else

const TInt64 KLbsTestMaxFixTime	= 0x7FFFFFFFFFFFFFFF;	// Setting Max Fix time for test 

#endif

const TLbsNetSessionCompleteAgpsMsg KSessionCompleteKErrBusy(KDummySessionId, KErrServerBusy);

const TLbsNetSessionCompleteAgpsMsg KSessionCompleteKErrHighPrior(KDummySessionId, KErrPositionHighPriorityReceive);

const TLbsNetSessionCompleteAgpsMsg KSessionCompleteKErrGeneral(KDummySessionId, KErrGeneral);

const TLbsNetSessionCompleteAgpsMsg KSessionCompleteKErrTimedOut(KDummySessionId, KErrTimedOut);

const TLbsNetAssistanceDataResponseMsg KAssistanceDataResponseErrNotFound(0, KErrNotFound);

TRequestStatus status;

TRequestStatus moduleMsgStatus;

TLbsPositionUpdateRequest LowAccurRequest;

TLbsPositionUpdateRequest HighAccurRequest;

TLbsPositionUpdateRequest absurdMaxFixTimeRequest;

TLbsPositionUpdateRequest TrackingNewClientRequest;

TLbsPositionUpdateRequestStatus StatusTrackingOffRequest;

TLbsPositionUpdateRequestStatus StatusTrackingOnRequest;

TLbsPositionUpdateRequestCancel CancelTrackingOffRequest;

TLbsPositionUpdateRequestCancel CancelTrackingOnRequest;

//-----------------------------------------------------------------------------------------

Cman4Step::~Cman4Step()

	{

	//TInt test = 6;

	}

Cman4Step::Cman4Step()

	{

	SetTestStepName(Kman4Step);

	}

TVerdict Cman4Step::doTestStepPreambleL()

/**

 * @return - TVerdict code

 * Override of base class virtual

 */

	{

	SetupNGInterface();

	// Open interfaces

	INFO_PRINTF1(_L("Openning Interfaces"));

	//iADCache.OpenL();

	//CleanupClosePushL(iADCache);

	iMSInt.OpenL(KLbsGpsLocManagerUid);

	CleanupClosePushL(iMSInt);

	iLSInt.OpenL(KChannelArray[0]);

	CleanupClosePushL(iLSInt);

	iNRHInt.OpenL(KChannelArray[2]);

	CleanupClosePushL(iNRHInt);

	iLocUpdInt.OpenL(KLbsGpsLocManagerUid);

	CleanupClosePushL(iLocUpdInt);

	iModuleInt.OpenL();

	CleanupClosePushL(iModuleInt);

	// Subscribe to the property where the test GPS module reads the desired error code for

	// the location update

	const TInt KTestLocSourceVal= 0x1028226E;// Secure ID of the test AGPS Manager

	const TUid KTestLocSourceUid= {KTestLocSourceVal};

	const TInt KUpdateCodePropertyKey = 0x11110100;

	User::LeaveIfError(iUpdateCodeProperty.Attach(KTestLocSourceUid, 

                                             KUpdateCodePropertyKey));

	const TInt KUpdateFixTimePropertyKey = 0x11110101;

	User::LeaveIfError(iUpdateFixTimeProperty.Attach(KTestLocSourceUid, 

                                             KUpdateFixTimePropertyKey));

	CleanupStack::Pop(5);

	INFO_PRINTF1(_L("Openning Interfaces OK"));

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TVerdict Cman4Step::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.

 */

	{

	// Add this 'TerminalBased' Request Method to the Low/HighAccurRequest

	// to ensure that when the NRH issues either request it will get an

	// update with conflict flag set to zero. 

	TLbsNetPosRequestMethodInt methods;

	TLbsNetPosMethodInt posMethods[1];

	posMethods[0].SetPosMethod(KLbsRootUid, (TPositionModuleInfo::ETechnologyTerminal|TPositionModuleInfo::ETechnologyAssisted));

	//posMethods[1].SetPosMethod(KLbsRootUid, (TPositionModuleInfo::ETechnologyNetwork | TPositionModuleInfo::ETechnologyAssisted));

	methods.SetPosMethods(posMethods, 1);

	LowAccurRequest.NewClient()  = EFalse;

	LowAccurRequest.Tracking()   = EFalse;

	LowAccurRequest.RequestQuality().SetMaxFixTime(5000000);

	LowAccurRequest.RequestQuality().SetMinHorizontalAccuracy(100);

	LowAccurRequest.RequestQuality().SetMinVerticalAccuracy(100);

	LowAccurRequest.RequestMethod() = methods;

	LowAccurRequest.TargetTime() = 0;

	HighAccurRequest.NewClient()  = EFalse;

	HighAccurRequest.Tracking()   = EFalse;

	HighAccurRequest.RequestQuality().SetMaxFixTime(5000000);

	HighAccurRequest.RequestQuality().SetMinHorizontalAccuracy(1);

	HighAccurRequest.RequestQuality().SetMinVerticalAccuracy(1);

	HighAccurRequest.TargetTime() = 0;

	HighAccurRequest.RequestMethod() = methods;

	absurdMaxFixTimeRequest.NewClient()  = EFalse;

	absurdMaxFixTimeRequest.Tracking()   = EFalse;

	absurdMaxFixTimeRequest.RequestQuality().SetMaxFixTime(KLbsTestMaxFixTime);

	absurdMaxFixTimeRequest.RequestQuality().SetMinHorizontalAccuracy(100);

	absurdMaxFixTimeRequest.RequestQuality().SetMinVerticalAccuracy(100);

	absurdMaxFixTimeRequest.TargetTime() = 0;

	absurdMaxFixTimeRequest.RequestMethod() = methods;

	TrackingNewClientRequest = LowAccurRequest;

	TrackingNewClientRequest.NewClient()  = ETrue;

	TrackingNewClientRequest.Tracking()   = ETrue;

	StatusTrackingOffRequest.Tracking()   = EFalse;

	StatusTrackingOnRequest.Tracking()   = ETrue;

	CancelTrackingOffRequest.Tracking()   = EFalse;

	CancelTrackingOnRequest.Tracking()   = ETrue;

	//------------------------------------------------------------------------------------------------	

	SetTestStepResult(EPass);

	iUpdateCodeProperty.Set(KErrNone);

	//------------------------------------------------------------------------------------------------	

	INFO_PRINTF1(_L("Test0 - manager sends tracking status on then off"));

	// Location request from LS. Tracking and NewClient flags check

	iLocUpdInt.NotifyPositionUpdate(status);

	TrackingNewClientRequest.TargetTime().UniversalTime();

	TTime start;

	start.UniversalTime(); 	// actually, timeout starts when NPUD is completed - so this 

							// is a little arlier than that

	iLSInt.SetPositionUpdateRequest(TrackingNewClientRequest);

	// Wait for advice and Self Loc Request. Send error.

	WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest, ETrue);

	WaitAndValidateLocUpd(status);

	SendNgMsg(KSessionCompleteKErrNone);

	INFO_PRINTF1(_L("Test 0 - Wait for Tracking to be set to Off"));

	// now wait for tracking off after and not before 

	// the timeout period (hardwired in agps manager to 30s 

   	WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESystemStatusAdvice, EFalse);

	TTime end;

	end.UniversalTime();

	TTimeIntervalMicroSeconds diff = 0;

	diff = end.Int64()-start.Int64();

	if ( (diff < 30*1000*1000) || (diff > 35*1000*1000)) // approx!

		{

		SetTestStepResult(EFail);

		ERR_PRINTF1(_L(" <font color=FF0000><b>incorrect tracking timeout.</b></font>"));

		}

	//------------------------------------------------------------------------------------------------	

	INFO_PRINTF1(_L("Test 1 - Location request from LS"));

	iModuleInt.Subscribe(moduleMsgStatus);

	iLocUpdInt.NotifyPositionUpdate(status);

	LowAccurRequest.TargetTime().UniversalTime();

	iLSInt.SetPositionUpdateRequest(LowAccurRequest);

	WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest);

	WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate);

	WaitAndValidateLocUpd(status);

	SendNgMsg(KSessionCompleteKErrNone);

	//------------------------------------------------------------------------------------------------	

	INFO_PRINTF1(_L("Test 2 - Location request from NRH"));

	iModuleInt.Subscribe(moduleMsgStatus);

	iLocUpdInt.NotifyPositionUpdate(status);

	LowAccurRequest.TargetTime().UniversalTime();

	iNRHInt.SetPositionUpdateRequest(LowAccurRequest);

	WaitAndValidateNgMsg(TLbsNetInternalMsgBase::EAssistanceDataRequest);

	WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate);

	WaitAndValidateLocUpd(status);

	//------------------------------------------------------------------------------------------------	

	INFO_PRINTF1(_L("Test 2a - Location request from NRH followed by a Cancel"));

	LowAccurRequest.TargetTime().UniversalTime();

	iModuleInt.Subscribe(moduleMsgStatus);

	iNRHInt.SetPositionUpdateRequest(LowAccurRequest);

	WaitAndValidateNgMsg(TLbsNetInternalMsgBase::EAssistanceDataRequest);

	WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate);

	iModuleInt.Subscribe(moduleMsgStatus);

	iNRHInt.SetPositionUpdateRequest(CancelTrackingOffRequest);// Tracking flag not used by this interface

	WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgCancelLocationRequest);

	//------------------------------------------------------------------------------------------------	

	INFO_PRINTF1(_L("Test 3 - Location requests from LS followed by NRH. Same time window."));

	iModuleInt.Subscribe(moduleMsgStatus);

	iLocUpdInt.NotifyPositionUpdate(status);

	LowAccurRequest.TargetTime().UniversalTime();

	LowAccurRequest.RequestQuality().SetMaxFixTime(10000000);

	iLSInt.SetPositionUpdateRequest(LowAccurRequest);

	WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate);

	User::After(300000);	//0.3s

	LowAccurRequest.RequestQuality().SetMaxFixTime(5000000);

	LowAccurRequest.TargetTime().UniversalTime();

	iModuleInt.Subscribe(moduleMsgStatus);

	iNRHInt.SetPositionUpdateRequest(LowAccurRequest);

	WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate);

	WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest);

	WaitAndValidateLocUpd(status);

	// Validate the target time in the combined request.

	// In this case, should take NRH request time

	if (iRcvdTargetTime != LowAccurRequest.TargetTime())

		{

		SetTestStepResult(EFail);

		ERR_PRINTF1(_L(" <font color=FF0000><b>Incorrect target time.</b></font>"));

		}

	// Check fix time in combined request

	// In this case, should be around 9.7 secs

	if ((iRcvdFixTime > 9700000) || (iRcvdFixTime < 9500000))

		{

		SetTestStepResult(EFail);

		ERR_PRINTF1(_L(" <font color=FF0000><b>Incorrect fix time.</b></font>"));

		}

	SendNgMsg(KSessionCompleteKErrNone);

	//------------------------------------------------------------------------------------------------	

	INFO_PRINTF1(_L("Test 3a - Location requests from NRH followed by LS. Same time window."));

	iModuleInt.Subscribe(moduleMsgStatus);

	iLocUpdInt.NotifyPositionUpdate(status);

	LowAccurRequest.TargetTime().UniversalTime();

	TTime expectedTT(LowAccurRequest.TargetTime());

	LowAccurRequest.RequestQuality().SetMaxFixTime(10000000);

	iNRHInt.SetPositionUpdateRequest(LowAccurRequest);

	WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate);

	User::After(300000);	//0.3s

	LowAccurRequest.RequestQuality().SetMaxFixTime(5000000);

	LowAccurRequest.TargetTime().UniversalTime();

	iModuleInt.Subscribe(moduleMsgStatus);

	iLSInt.SetPositionUpdateRequest(LowAccurRequest);

	WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate);

	WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest);

	WaitAndValidateLocUpd(status);

	if (iRcvdTargetTime != expectedTT)

		{

		SetTestStepResult(EFail);

		ERR_PRINTF1(_L(" <font color=FF0000><b>Incorrect target time.</b></font>"));

		}

	// Check fix time in combined request

	// In this case, should be around 9.7 secs

	if ((iRcvdFixTime > 9700000) || (iRcvdFixTime < 9500000))

		{

		SetTestStepResult(EFail);

		ERR_PRINTF1(_L(" <font color=FF0000><b>Incorrect fix time.</b></font>"));

		}

	SendNgMsg(KSessionCompleteKErrNone);

	//------------------------------------------------------------------------------------------------	

	INFO_PRINTF1(_L("Test 3b - Immediate Location requests from LS followed by NRH. Same time window."));

	iModuleInt.Subscribe(moduleMsgStatus);

	iLocUpdInt.NotifyPositionUpdate(status);

	LowAccurRequest.TargetTime() = 0;

	LowAccurRequest.RequestQuality().SetMaxFixTime(10000000);

	iLSInt.SetPositionUpdateRequest(LowAccurRequest);

	WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate);

	User::After(300000);	//0.3s

	LowAccurRequest.RequestQuality().SetMaxFixTime(5000000);

	iModuleInt.Subscribe(moduleMsgStatus);

	iNRHInt.SetPositionUpdateRequest(LowAccurRequest);

	WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate);

	WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest);

	WaitAndValidateLocUpd(status);

	if (iRcvdTargetTime != 0)

		{

		SetTestStepResult(EFail);

		ERR_PRINTF1(_L(" <font color=FF0000><b>Incorrect target time.</b></font>"));

		}

	// Check fix time in combined request

	// In this case, should be around 9.7 secs

	if ((iRcvdFixTime > 9700000) || (iRcvdFixTime < 9500000))

		{

		SetTestStepResult(EFail);

		ERR_PRINTF1(_L(" <font color=FF0000><b>Incorrect fix time.</b></font>"));

		}

	SendNgMsg(KSessionCompleteKErrNone);

	//------------------------------------------------------------------------------------------------	

	INFO_PRINTF1(_L("Test 3c - Location requests from LS followed by immediate NRH request. Same time window."));

	iModuleInt.Subscribe(moduleMsgStatus);

	iLocUpdInt.NotifyPositionUpdate(status);

	LowAccurRequest.TargetTime().UniversalTime();

	LowAccurRequest.RequestQuality().SetMaxFixTime(10000000);

	iLSInt.SetPositionUpdateRequest(LowAccurRequest);

	WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate);

	User::After(300000);	//0.3s

	LowAccurRequest.RequestQuality().SetMaxFixTime(5000000);

	LowAccurRequest.TargetTime() = 0;

	iModuleInt.Subscribe(moduleMsgStatus);

	iNRHInt.SetPositionUpdateRequest(LowAccurRequest);

	WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate);

	WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest);

	WaitAndValidateLocUpd(status);

	if (iRcvdTargetTime != 0)

		{

		SetTestStepResult(EFail);

		ERR_PRINTF1(_L(" <font color=FF0000><b>Incorrect target time.</b></font>"));

		}

	// Check fix time in combined request

	// In this case, should be around 9.7 secs

	if ((iRcvdFixTime > 9700000) || (iRcvdFixTime < 9500000))

		{

		SetTestStepResult(EFail);

		ERR_PRINTF1(_L(" <font color=FF0000><b>Incorrect fix time.</b></font>"));

		}

	SendNgMsg(KSessionCompleteKErrNone);

	//------------------------------------------------------------------------------------------------	

	INFO_PRINTF1(_L("Test 3d - Location requests from NRH (immediate) followed by LS. Same time window."));

	iModuleInt.Subscribe(moduleMsgStatus);

	iLocUpdInt.NotifyPositionUpdate(status);

	LowAccurRequest.TargetTime() = 0;

	LowAccurRequest.RequestQuality().SetMaxFixTime(10000000);

	iNRHInt.SetPositionUpdateRequest(LowAccurRequest);

	WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate);

	User::After(300000);	//0.3s

	LowAccurRequest.RequestQuality().SetMaxFixTime(5000000);

	LowAccurRequest.TargetTime().UniversalTime();

	iModuleInt.Subscribe(moduleMsgStatus);

	iLSInt.SetPositionUpdateRequest(LowAccurRequest);

	WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate);

	WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest);

	WaitAndValidateLocUpd(status);

	if (iRcvdTargetTime != 0)

		{

		SetTestStepResult(EFail);

		ERR_PRINTF1(_L(" <font color=FF0000><b>Incorrect target time.</b></font>"));

		}

	// Check fix time in combined request

	// In this case, should be around 9.7 secs

	if ((iRcvdFixTime > 9700000) || (iRcvdFixTime < 9500000))

		{

		SetTestStepResult(EFail);

		ERR_PRINTF1(_L(" <font color=FF0000><b>Incorrect fix time.</b></font>"));

		}

	SendNgMsg(KSessionCompleteKErrNone);

	//------------------------------------------------------------------------------------------------	

	INFO_PRINTF1(_L("Test 3e - LS Req followed by timed out NRH req. Same time window."));

	// Tests that fix time gets updated correctly

	// This test uses a very short fix time for the NRH request.

	// This is to allow it to time-out before the test gps module returns

	// a location update (which is done after a 0.5 second timeout)

	// Could have increased the timeout used by the test gps module

	// but that would have meant the whole test takes way too long to run

	iModuleInt.Subscribe(moduleMsgStatus);

	iLocUpdInt.NotifyPositionUpdate(status);

	LowAccurRequest.TargetTime().UniversalTime();

	expectedTT = LowAccurRequest.TargetTime();

	LowAccurRequest.RequestQuality().SetMaxFixTime(3000000);//3 secs

	iLSInt.SetPositionUpdateRequest(LowAccurRequest);

	WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate);

	User::After(300000); // 0.3s

	LowAccurRequest.TargetTime() = 0;//Immediate request

	LowAccurRequest.RequestQuality().SetMaxFixTime(200000);//0.2s

	iModuleInt.Subscribe(moduleMsgStatus);

	iNRHInt.SetPositionUpdateRequest(LowAccurRequest);

	WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate);

	// Allow time for combined request to be issued

	User::After(100000);//0.1s

	// Check fix time in combined request

	// In this case, should be around 2.7 secs

	iUpdateFixTimeProperty.Get(iRcvdFixTime);

	if ((iRcvdFixTime > 2700000) || (iRcvdFixTime < 2500000))

		{

		SetTestStepResult(EFail);

		ERR_PRINTF1(_L(" <font color=FF0000><b>Incorrect fix time.</b></font>"));

		}

	WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest);

	// Should now get an update based on the original LS request

	// because the NRH request has timed out

	WaitAndValidateLocUpd(status);

	if (iRcvdTargetTime != expectedTT)

		{

		SetTestStepResult(EFail);

		ERR_PRINTF1(_L(" <font color=FF0000><b>Incorrect target time.</b></font>"));

		}

	// Check fix time in combined request

	// In this case, should be around 2.5 secs

	if ((iRcvdFixTime > 2500000) || (iRcvdFixTime < 2300000))

		{

		SetTestStepResult(EFail);

		ERR_PRINTF1(_L(" <font color=FF0000><b>Incorrect fix time.</b></font>"));

		}

	SendNgMsg(KSessionCompleteKErrNone);

	//------------------------------------------------------------------------------------------------	

	INFO_PRINTF1(_L("Test 4 - Location requests from LS. Cancel to the NG due to a timeout"));

	iModuleInt.Subscribe(moduleMsgStatus);

	iLocUpdInt.NotifyPositionUpdate(status);

	HighAccurRequest.TargetTime().UniversalTime();

	iLSInt.SetPositionUpdateRequest(HighAccurRequest);

	WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest);

	WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationCancel);// Cancel due to a timeout

	WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate);

	iModuleInt.Subscribe(moduleMsgStatus);

	WaitNoModuleMsg(moduleMsgStatus);

	WaitAndValidateLocUpd(status); // The low accuracy location update

	SendNgMsg(KSessionCompleteKErrTimedOut);

	//------------------------------------------------------------------------------------------------	

	INFO_PRINTF1(_L("Test 5 - Location requests from NRH. No cancel due to a timeout"));

	iModuleInt.Subscribe(moduleMsgStatus);

	iLocUpdInt.NotifyPositionUpdate(status);

	HighAccurRequest.TargetTime().UniversalTime();

	iNRHInt.SetPositionUpdateRequest(HighAccurRequest);

	// We do not expect the Assistance Data Cancel

	WaitAndValidateNgMsg(TLbsNetInternalMsgBase::EAssistanceDataRequest);

	WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate);

	iModuleInt.Subscribe(moduleMsgStatus);

	WaitNoModuleMsg(moduleMsgStatus);

	WaitAndValidateLocUpd(status); // The low accuracy location update

	//------------------------------------------------------------------------------------------------	

	INFO_PRINTF1(_L("Test 6 - Location requests from LS followed by NRH. Different time windows."));

	iLocUpdInt.NotifyPositionUpdate(status);

	LowAccurRequest.TargetTime().UniversalTime();

	LowAccurRequest.TargetTime() += static_cast<TTimeIntervalSeconds>(10);

	LowAccurRequest.RequestQuality().SetMaxFixTime(5000000);

	iLSInt.SetPositionUpdateRequest(LowAccurRequest);

	LowAccurRequest.TargetTime().UniversalTime();

//	iNRHInt.SetPositionUpdateRequest(LowAccurRequest);

	// First time window - NRH request, but LS request is active as well

	// so we expect ESelfLocationRequest rather than EAssistanceDataRequest

	WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest);

	iNRHInt.SetPositionUpdateRequest(LowAccurRequest);

	// Combined request sent to GPS module that requests assistance data again

	// (our test module follows that with a notify position update)