diff -r 000000000000 -r 9cfd9a3ee49c locationmgmt/agpslocationmgr/test/te_man/src/man4Step.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/locationmgmt/agpslocationmgr/test/te_man/src/man4Step.cpp Tue Feb 02 01:50:39 2010 +0200 @@ -0,0 +1,1169 @@ +// 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 +#include +#include +#include +#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(" incorrect tracking timeout.")); + } + + //------------------------------------------------------------------------------------------------ + 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(" Incorrect target time.")); + } + // 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(" Incorrect fix time.")); + } + + 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(" Incorrect target time.")); + } + // 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(" Incorrect fix time.")); + } + + 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(" Incorrect target time.")); + } + // 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(" Incorrect fix time.")); + } + + 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(" Incorrect target time.")); + } + // 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(" Incorrect fix time.")); + } + + 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(" Incorrect target time.")); + } + // 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(" Incorrect fix time.")); + } + + 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(" Incorrect fix time.")); + } + 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(" Incorrect target time.")); + } + // 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(" Incorrect fix time.")); + } + + 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(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) + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::EAssistanceDataRequest); + WaitAndValidateLocUpd(status); + + // The update has satisfied the NRH but not the LS whose target time is + // in the future. Therefore a new request is sent to the module with + // just LS requirements. We expect to continue the ongoing + // Self Location session and receive EAssistanceDataRequest + // rather than ESelfLocationRequest. + iLocUpdInt.NotifyPositionUpdate(status); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::EAssistanceDataRequest); + //Location Update for the LS Request + WaitAndValidateLocUpd(status); + + + SendNgMsg(KSessionCompleteKErrNone); + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 7 - Location requests from NRH followed by LS. Different time windows.")); + // Expected message flow as in test 6 + iLocUpdInt.NotifyPositionUpdate(status); + LowAccurRequest.TargetTime().UniversalTime(); + iNRHInt.SetPositionUpdateRequest(LowAccurRequest); + LowAccurRequest.TargetTime() += static_cast(10); + iLSInt.SetPositionUpdateRequest(LowAccurRequest); + + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::EAssistanceDataRequest); + WaitAndValidateLocUpd(status); + + iLocUpdInt.NotifyPositionUpdate(status); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest); + WaitAndValidateLocUpd(status); + SendNgMsg(KSessionCompleteKErrNone); + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 8 - Location requests from LS. Session Complete before Location Update.")); + iLocUpdInt.NotifyPositionUpdate(status); + LowAccurRequest.TargetTime().UniversalTime(); + iLSInt.SetPositionUpdateRequest(LowAccurRequest); + + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest); + SendNgMsg(KSessionCompleteKErrNone); + WaitAndValidateLocUpd(status); + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 9 - Location requests from LS. Session Complete after Location Update.")); + iLocUpdInt.NotifyPositionUpdate(status); + LowAccurRequest.TargetTime().UniversalTime(); + iLSInt.SetPositionUpdateRequest(LowAccurRequest); + + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest); + WaitAndValidateLocUpd(status); + SendNgMsg(KSessionCompleteKErrNone); + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 10 - Location requests from LS. Session Complete(KErrServerBusy)")); + iModuleInt.Subscribe(moduleMsgStatus); + iLocUpdInt.NotifyPositionUpdate(status); + LowAccurRequest.TargetTime().UniversalTime(); + LowAccurRequest.TargetTime() += static_cast(2); + iLSInt.SetPositionUpdateRequest(LowAccurRequest); + + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + + iModuleInt.Subscribe(moduleMsgStatus); + SendNgMsg(KSessionCompleteKErrBusy); + + // The error goes to the LS and a Cancel to the AGPS Module + WaitAndValidateLocUpd(status, KErrServerBusy, ETrue); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgCancelLocationRequest); + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 11 - Location requests from LS. Session Complete(KErrPositionHighPriorityReceive)")); + iModuleInt.Subscribe(moduleMsgStatus); + iLocUpdInt.NotifyPositionUpdate(status); + LowAccurRequest.TargetTime().UniversalTime(); + LowAccurRequest.TargetTime() += static_cast(5); + iLSInt.SetPositionUpdateRequest(LowAccurRequest); + + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + iModuleInt.Subscribe(moduleMsgStatus); + + SendNgMsg(KSessionCompleteKErrHighPrior); + WaitAndValidateLocUpd(status, KErrPositionHighPriorityReceive, ETrue); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgCancelLocationRequest); + + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 11a - Location requests from LS. Session Complete(KErrGeneral). Not a special error.")); + iModuleInt.Subscribe(moduleMsgStatus); + iLocUpdInt.NotifyPositionUpdate(status); + LowAccurRequest.TargetTime().UniversalTime(); + LowAccurRequest.TargetTime() += static_cast(5); + iLSInt.SetPositionUpdateRequest(LowAccurRequest); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + iModuleInt.Subscribe(moduleMsgStatus); + + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest); + + SendNgMsg(KSessionCompleteKErrGeneral); + WaitAndValidateLocUpd(status); + WaitNoModuleMsg(moduleMsgStatus);// Make sure KErrGeneral does not calcel the location request + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 12 - Location requests from LS followed by NRH. Different time windows. Session Complete(KErrPositionHighPriorityReceive) before Self Location Request")); + iModuleInt.Subscribe(moduleMsgStatus); + iLocUpdInt.NotifyPositionUpdate(status); + // LS request + LowAccurRequest.TargetTime().UniversalTime(); + LowAccurRequest.TargetTime() += static_cast(10); + iLSInt.SetPositionUpdateRequest(LowAccurRequest); + + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + iModuleInt.Subscribe(moduleMsgStatus); + + // Wait for advice and send error. + SendNgMsg(KSessionCompleteKErrHighPrior); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgCancelLocationRequest); + iModuleInt.Subscribe(moduleMsgStatus); + + // Expect the error to be published + WaitAndValidateLocUpd(status, KErrPositionHighPriorityReceive, ETrue); + + // Send NRH request + LowAccurRequest.TargetTime().UniversalTime(); + iNRHInt.SetPositionUpdateRequest(LowAccurRequest); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + + // Process the NRH request + iLocUpdInt.NotifyPositionUpdate(status); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::EAssistanceDataRequest); + WaitAndValidateLocUpd(status); + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 13 - Location requests from LS followed by NRH. Different time windows. Session Complete(KErrServerBusy) after Self Location Request")); + iModuleInt.Subscribe(moduleMsgStatus); + iLocUpdInt.NotifyPositionUpdate(status); + // LS request + LowAccurRequest.TargetTime().UniversalTime(); + LowAccurRequest.TargetTime() += static_cast(10); + iLSInt.SetPositionUpdateRequest(LowAccurRequest); + + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + iModuleInt.Subscribe(moduleMsgStatus); + + // Wait for advice and Self Loc Request. Send error. + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest); + + SendNgMsg(KSessionCompleteKErrBusy); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgCancelLocationRequest); + iModuleInt.Subscribe(moduleMsgStatus); + + // Expect the error to be published + WaitAndValidateLocUpd(status, KErrServerBusy, ETrue); + + // Send NRH request + LowAccurRequest.TargetTime().UniversalTime(); + iNRHInt.SetPositionUpdateRequest(LowAccurRequest); + + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + + // Process the NRH request + iLocUpdInt.NotifyPositionUpdate(status); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::EAssistanceDataRequest); + WaitAndValidateLocUpd(status); + + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 13a - Location requests from LS followed by NRH. Different time windows. Session Complete(KErrServerBusy) after Self Location Request. Race condition.")); + // NRH request gets to AGPS Manager before session complete. + iModuleInt.Subscribe(moduleMsgStatus); + iLocUpdInt.NotifyPositionUpdate(status); + // LS request + LowAccurRequest.TargetTime().UniversalTime(); + LowAccurRequest.TargetTime() += static_cast(10); + iLSInt.SetPositionUpdateRequest(LowAccurRequest); + + // Wait for advice and Self Loc Request. Send error. + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + iModuleInt.Subscribe(moduleMsgStatus); + + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest); + + // Send NRH request + LowAccurRequest.TargetTime().UniversalTime(); + iNRHInt.SetPositionUpdateRequest(LowAccurRequest); + + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + iModuleInt.Subscribe(moduleMsgStatus); + + SendNgMsg(KSessionCompleteKErrBusy); + + // The Server busy cancels SL req, but we still have the NRH req. + // Because of that we expect a new Loc Req instead of a Cancel + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + + // Expect the error to be published + WaitAndValidateLocUpd(status, KErrServerBusy, ETrue); + + // Process the NRH request + iLocUpdInt.NotifyPositionUpdate(status); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::EAssistanceDataRequest); + WaitAndValidateLocUpd(status); + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 14 - Location requests from LS. Tracking and NewClient flags check.")); + iLocUpdInt.NotifyPositionUpdate(status); + TrackingNewClientRequest.TargetTime().UniversalTime(); + iLSInt.SetPositionUpdateRequest(TrackingNewClientRequest); + + // Wait for advice and Self Loc Request. Send error. + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESystemStatusAdvice, ETrue); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest, ETrue); + WaitAndValidateLocUpd(status); + SendNgMsg(KSessionCompleteKErrNone); + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 15 - Tracking On/Off using Status message.")); + + iLSInt.SetPositionUpdateRequest(StatusTrackingOffRequest); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESystemStatusAdvice, EFalse); + + iLSInt.SetPositionUpdateRequest(StatusTrackingOnRequest); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESystemStatusAdvice, ETrue); + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 16 - Tracking On/Off using Cancel message.")); + + iLSInt.SetPositionUpdateRequest(CancelTrackingOffRequest); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESystemStatusAdvice, EFalse); + + iLSInt.SetPositionUpdateRequest(CancelTrackingOnRequest); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESystemStatusAdvice, ETrue); + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 17 - Location requests from LS followed by Cancel before Self Location Request")); + iModuleInt.Subscribe(moduleMsgStatus); + LowAccurRequest.TargetTime().UniversalTime(); + LowAccurRequest.TargetTime() += static_cast(10); + iLSInt.SetPositionUpdateRequest(LowAccurRequest); + + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESystemStatusAdvice); + + iModuleInt.Subscribe(moduleMsgStatus); + iLSInt.SetPositionUpdateRequest(CancelTrackingOffRequest); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgCancelLocationRequest); + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 18 - Location requests from LS followed by Cancel after Self Location Request")); + iModuleInt.Subscribe(moduleMsgStatus); + LowAccurRequest.TargetTime().UniversalTime(); + LowAccurRequest.TargetTime() += static_cast(10); + iLSInt.SetPositionUpdateRequest(LowAccurRequest); + + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest); + + iModuleInt.Subscribe(moduleMsgStatus); + iLSInt.SetPositionUpdateRequest(CancelTrackingOffRequest); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationCancel); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgCancelLocationRequest); + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 19 - Status Trackin On msg. Tracking Off due to no Location Requests")); + iLSInt.SetPositionUpdateRequest(StatusTrackingOnRequest); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESystemStatusAdvice, ETrue); + + //Tracking off because we haven't sent any Loc Req + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESystemStatusAdvice, EFalse); + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 20 - LS Request with Tracking msg. Tracking Off due to no Location Requests")); + iLocUpdInt.NotifyPositionUpdate(status); + TrackingNewClientRequest.TargetTime().UniversalTime(); + iLSInt.SetPositionUpdateRequest(TrackingNewClientRequest); + + // Wait for advice and Self Loc Request. Send error. + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESystemStatusAdvice, ETrue); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest, ETrue); + WaitAndValidateLocUpd(status); + + //Tracking off because we haven't sent a new Loc Req + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESystemStatusAdvice, EFalse); + SendNgMsg(KSessionCompleteKErrNone); + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 21 - Location requests from LS and NRH followed by AssistanceDataEvent(KErrNotFound).")); + INFO_PRINTF1(_L(" LocationUpdate(KErrNotFound) expected. AGPS should internally invalidate all outstanding requests.")); + iModuleInt.Subscribe(moduleMsgStatus); + iLocUpdInt.NotifyPositionUpdate(status); + HighAccurRequest.TargetTime().UniversalTime(); + iLSInt.SetPositionUpdateRequest(HighAccurRequest); + + INFO_PRINTF1(_L(" LS -> AGPS Manager. High Accuracy Request. Target Time: now.")); + + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + iModuleInt.Subscribe(moduleMsgStatus); + + HighAccurRequest.TargetTime().UniversalTime(); + iNRHInt.SetPositionUpdateRequest(HighAccurRequest); + + INFO_PRINTF1(_L(" NRH -> AGPS Manager. High Accuracy Request. Target Time: now.")); + + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + iModuleInt.Subscribe(moduleMsgStatus); + + INFO_PRINTF1(_L(" AGPS Manager -> Network Gateway. Self Location Request.")); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest); + + // Set the error code that should be returned in the locationUpdate + iUpdateCodeProperty.Set(KErrNotFound); + + INFO_PRINTF1(_L(" Network Gateway -> AGPS Manager. Response: KAssistanceDataResponseErrNotFound")); + SendNgMsg(KAssistanceDataResponseErrNotFound); + + INFO_PRINTF1(_L(" AGPS Manager -> Test GPS Integration Module. AssistanceDataEvent")); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgAssistanceDataEvent); + iModuleInt.Subscribe(moduleMsgStatus); + + INFO_PRINTF1(_L("Test GPS Integration Module -> AGPS Manager. Location Update with KErrNotFound")); + + WaitAndValidateLocUpd(status, KErrNotFound); + + // Test that the recent location update invalidated all requests in the AGPS Manager + // If it did, then the following call should cause explicit Cancel to be sent to the + // AGPS Module. + iLSInt.SetPositionUpdateRequest(CancelTrackingOffRequest); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgCancelLocationRequest); + iModuleInt.Subscribe(moduleMsgStatus); + + WaitNoModuleMsg(moduleMsgStatus); + iUpdateCodeProperty.Set(KErrNone); + + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 21a - Location requests from LS and NRH followed by AssistanceDataEvent(KErrNotFound).")); + INFO_PRINTF1(_L(" LocationUpdate(KErrNotFound) expected. AGPS should internally invalidate all outstanding requests.")); + // It is like test 21, just we send a Cancel using the NRH channel + iModuleInt.Subscribe(moduleMsgStatus); + iLocUpdInt.NotifyPositionUpdate(status); + HighAccurRequest.TargetTime().UniversalTime(); + iLSInt.SetPositionUpdateRequest(HighAccurRequest); + + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + iModuleInt.Subscribe(moduleMsgStatus); + + iNRHInt.SetPositionUpdateRequest(HighAccurRequest); + + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + iModuleInt.Subscribe(moduleMsgStatus); + + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest); + // Set the error code that should be returned in the locationUpdate + iUpdateCodeProperty.Set(KErrNotFound); + SendNgMsg(KAssistanceDataResponseErrNotFound); + + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgAssistanceDataEvent); + iModuleInt.Subscribe(moduleMsgStatus); + + WaitAndValidateLocUpd(status, KErrNotFound); + + // Test that the recent location update invalidated all requests in the AGPS Manager + // If it did, then the following call should cause explicit Cancel to be sent to the + // AGPS Mdoule. + iNRHInt.SetPositionUpdateRequest(CancelTrackingOffRequest); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgCancelLocationRequest); + iModuleInt.Subscribe(moduleMsgStatus); + + WaitNoModuleMsg(moduleMsgStatus); + SendNgMsg(KSessionCompleteKErrNone); + iUpdateCodeProperty.Set(KErrNone); + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 22 - Two back-to-back location requests from LS (only one SessionComplete). SelfLoc and AsistData requests expected")); + iModuleInt.Subscribe(moduleMsgStatus); + iLocUpdInt.NotifyPositionUpdate(status); + LowAccurRequest.TargetTime().UniversalTime(); + + // 1st req + iLSInt.SetPositionUpdateRequest(LowAccurRequest); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + iModuleInt.Subscribe(moduleMsgStatus); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest); + + // 2nd req + iLSInt.SetPositionUpdateRequest(LowAccurRequest); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::EAssistanceDataRequest); + + WaitAndValidateLocUpd(status); + SendNgMsg(KSessionCompleteKErrNone); + + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 22a - Two location requests from LS (only one SessionComplete). SelfLoc and AsistData requests expected")); + iModuleInt.Subscribe(moduleMsgStatus); + iLocUpdInt.NotifyPositionUpdate(status); + + // 1st req + LowAccurRequest.TargetTime().UniversalTime(); + iLSInt.SetPositionUpdateRequest(LowAccurRequest); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + iModuleInt.Subscribe(moduleMsgStatus); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest); + + WaitAndValidateLocUpd(status); + iLocUpdInt.NotifyPositionUpdate(status); + + // 2nd req + LowAccurRequest.TargetTime().UniversalTime(); + iLSInt.SetPositionUpdateRequest(LowAccurRequest); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::EAssistanceDataRequest); + + WaitAndValidateLocUpd(status); + SendNgMsg(KSessionCompleteKErrNone); + + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 23 - Two back-to-back New Client location requests from LS (only one SessionComplete). Two SelfLocs expected")); + iModuleInt.Subscribe(moduleMsgStatus); + iLocUpdInt.NotifyPositionUpdate(status); + TrackingNewClientRequest.TargetTime().UniversalTime(); + + // 1st req + iLSInt.SetPositionUpdateRequest(TrackingNewClientRequest); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESystemStatusAdvice, ETrue); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest, ETrue); + iModuleInt.Subscribe(moduleMsgStatus); + + // 2nd req + iLSInt.SetPositionUpdateRequest(TrackingNewClientRequest); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest, ETrue); + + WaitAndValidateLocUpd(status); + SendNgMsg(KSessionCompleteKErrNone); + + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 23a - Two New Client location requests from LS (only one SessionComplete). Two SelfLocs expected")); + iModuleInt.Subscribe(moduleMsgStatus); + iLocUpdInt.NotifyPositionUpdate(status); + + // 1st req + TrackingNewClientRequest.TargetTime().UniversalTime(); + iLSInt.SetPositionUpdateRequest(TrackingNewClientRequest); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + iModuleInt.Subscribe(moduleMsgStatus); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest, ETrue); + + WaitAndValidateLocUpd(status); + iLocUpdInt.NotifyPositionUpdate(status); + + // 2nd req + TrackingNewClientRequest.TargetTime().UniversalTime(); + iLSInt.SetPositionUpdateRequest(TrackingNewClientRequest); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest, ETrue); + + WaitAndValidateLocUpd(status); + SendNgMsg(KSessionCompleteKErrNone); + + //------------------------------------------------------------------------------------------------ + INFO_PRINTF1(_L("Test 24 - Location request from LS (absurd MaxFixTime)")); + iModuleInt.Subscribe(moduleMsgStatus); + iLocUpdInt.NotifyPositionUpdate(status); + absurdMaxFixTimeRequest.TargetTime().UniversalTime(); + absurdMaxFixTimeRequest.TargetTime() = absurdMaxFixTimeRequest.TargetTime() + KFutureReqDelay; + iLSInt.SetPositionUpdateRequest(absurdMaxFixTimeRequest); + + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESystemStatusAdvice, EFalse); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationRequest); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgRequestLocationUpdate); + iModuleInt.Subscribe(moduleMsgStatus); + WaitAndValidateNoLocUpd(status); + iLSInt.SetPositionUpdateRequest(CancelTrackingOffRequest); + WaitAndValidateModuleMsg(moduleMsgStatus, RAgpsModuleTestChannel::ETestMsgCancelLocationRequest); + WaitAndValidateNgMsg(TLbsNetInternalMsgBase::ESelfLocationCancel); + SendNgMsg(KSessionCompleteKErrNone); + //------------------------------------------------------------------------------------------------ + iUpdateCodeProperty.Set(KErrNone); + return TestStepResult(); + } + + + +TVerdict Cman4Step::doTestStepPostambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + CTe_manSuiteStepBase::doTestStepPostambleL(); + // Open interfaces + INFO_PRINTF1(_L("Closing Interfaces")); + //iADCache.Close(); + iMSInt.Close();; + iLSInt.Close(); + iNRHInt.Close(); + iLocUpdInt.Close(); + iModuleInt.Close(); + iUpdateCodeProperty.Close(); + iUpdateFixTimeProperty.Close(); + INFO_PRINTF1(_L("Interfaces Closed OK")); + + return TestStepResult(); + } + +//----------------------------------------------------------------------------------------- +void Cman4Step::WaitAndValidateLocUpd(TRequestStatus& aStatus, TInt aError, TBool aConflictControl) + { + User::WaitForRequest(aStatus); + + if (aStatus.Int() == KErrNone) + { + INFO_PRINTF1(_L(" Location update received")); + + TPositionExtendedSatelliteInfo satInfo; + TTime actualTime; + TBool conflictControl; + TInt err = iLocUpdInt.GetPositionInfo(conflictControl, &satInfo, sizeof(satInfo), iRcvdTargetTime, actualTime); + INFO_PRINTF2(_L(" Exp error code: %d"), aError); + INFO_PRINTF2(_L(" Rcv error code: %d"), err); + + if (aError != err) + { + SetTestStepResult(EFail); + ERR_PRINTF1(_L(" Actual location update error does not match the expected one.")); + } + + INFO_PRINTF2(_L(" Exp conflict control flag: %d"), aConflictControl); + INFO_PRINTF2(_L(" Rcv conflict control flag: %d"), conflictControl); + + if (aConflictControl != conflictControl) + { + SetTestStepResult(EFail); + ERR_PRINTF1(_L(" Actual conflict control flag does not match the expected one.")); + } + + iUpdateFixTimeProperty.Get(iRcvdFixTime); + } + else + { + SetTestStepResult(EFail); + ERR_PRINTF2(_L(" Location update status error: %d"), aStatus.Int()); + } + } + + +//----------------------------------------------------------------------------------------- +void Cman4Step::WaitAndValidateNoLocUpd(TRequestStatus& aStatus) + { + User::After(KNoLocUpdTimeout); + + if (aStatus.Int() != KRequestPending) + { + ERR_PRINTF1(_L(" Unexpected location update received")); + + TPositionExtendedSatelliteInfo satInfo; + TTime actualTime; + TBool conflictControl; + TInt err = iLocUpdInt.GetPositionInfo(conflictControl, &satInfo, sizeof(satInfo), iRcvdTargetTime, actualTime); + INFO_PRINTF2(_L(" Rcv error code: %d"), err); + INFO_PRINTF2(_L(" Rcv conflict control flag: %d"), conflictControl); + SetTestStepResult(EFail); + } + else + { + INFO_PRINTF1(_L(" No location update received (as expected)")); + iLocUpdInt.CancelNotifyPositionUpdate(); + User::WaitForRequest(aStatus); + } + } + + +//----------------------------------------------------------------------------------------- +void Cman4Step::WaitAndValidateModuleMsg(TRequestStatus& aStatus, const RAgpsModuleTestChannel::TTestMsgType& aMsg) + { + User::WaitForRequest(aStatus); + + if (aStatus.Int() == KErrNone) + { + INFO_PRINTF1(_L(" Module message received")); + + RAgpsModuleTestChannel::TTestMsgType msg; + TInt err = iModuleInt.GetMsg(msg); + INFO_PRINTF2(_L(" Exp error code: %d"), KErrNone); + INFO_PRINTF2(_L(" Rcv error code: %d"), err); + + if (KErrNone != err) + { + SetTestStepResult(EFail); + ERR_PRINTF1(_L(" Actual error code does not match the expected one.")); + } + + INFO_PRINTF2(_L(" Exp msg type: %d"), aMsg); + INFO_PRINTF2(_L(" Rcv msg type: %d"), msg); + + if (msg != aMsg) + { + SetTestStepResult(EFail); + ERR_PRINTF1(_L(" Actual msg type does not match the expected one.")); + } + + } + else + { + SetTestStepResult(EFail); + ERR_PRINTF2(_L(" Status error: %d"), aStatus.Int()); + } + } + + +//----------------------------------------------------------------------------------------- +/** Make sure the module does not report any message */ +void Cman4Step::WaitNoModuleMsg(TRequestStatus& aStatus) + { + User::After(KNoModuleMsgTimeout); + + if (aStatus != KRequestPending) + { + ERR_PRINTF1(_L(" Unexpected module message received")); + INFO_PRINTF2(_L(" Status error: %d"), aStatus.Int()); + + RAgpsModuleTestChannel::TTestMsgType msg; + TInt err = iModuleInt.GetMsg(msg); + INFO_PRINTF2(_L(" Rcv error code: %d"), err); + INFO_PRINTF2(_L(" Rcv msg type: %d"), msg); + + SetTestStepResult(EFail); + } + else + { + INFO_PRINTF1(_L(" No Module msg received (as expected)")); + iModuleInt.Cancel(); + User::WaitForRequest(aStatus); + } + }