diff -r e8c1ea2c6496 -r 8758140453c0 lbs/lbsclient/src/ctlbsclientstepupdateoptions.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lbs/lbsclient/src/ctlbsclientstepupdateoptions.cpp Thu Jan 21 12:53:44 2010 +0000 @@ -0,0 +1,1274 @@ +// 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 the License "Symbian Foundation License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// @file ctlbsclientstep_UpdateOptions.cpp +// This is the class implementation for the UpdateOptions Tests +// +// + +#include "ctlbsclientstepupdateoptions.h" + +#include +#include + +#include "tlbsutils.h" +#include "ctlbsasyncwaiter.h" + +#define EXPECTED_GPS_ACCURACY_HORIZONTAL 100 +#define EXPECTED_GPS_ACCURACY_VERTICAL 100 + +const TTimeIntervalMicroSeconds KTimestampMargin = 500000; //+/-0.5s + +/** + + */ +TBool CT_LbsClientStep_UpdateOptions::VerifyFirstPosTime(const TTime& aTimeRequested, const TPositionInfo& aPosInfo, const TPositionUpdateOptions& aUpdateOpts) + { + TTime timeReceived, timeStamp; + TPosition pos; + + TInt64 maxtime; + maxtime = aUpdateOpts.UpdateTimeOut().Int64(); + if(!maxtime) + { + #pragma message("TO DO: CT_LbsClientStep_UpdateOptions::VerifyFirstPosTime - Update when moduleinfo supported") + const TTimeIntervalMicroSeconds ttff = 90*1000000; // TO DO - this should be retrieved from the module info (currently hardcoded in locserver too) + maxtime = ttff.Int64(); + } + + // get current time + timeReceived.UniversalTime(); + + // get the position data: + aPosInfo.GetPosition(pos); + + INFO_PRINTF1(_L("First position received at: ")); + INFO_PRINTF4(_L("%d/%d/%d"), timeReceived.DateTime().Day() + 1, timeReceived.DateTime().Month() + 1, timeReceived.DateTime().Year()); + INFO_PRINTF5(_L("at %d :%d :%d :%d"), timeReceived.DateTime().Hour(), timeReceived.DateTime().Minute(), timeReceived.DateTime().Second(), timeReceived.DateTime().MicroSecond()); + + timeStamp = pos.Time(); + INFO_PRINTF1(_L("First position timeStamp: ")); + INFO_PRINTF4(_L("%d/%d/%d"), timeStamp.DateTime().Day() + 1, timeStamp.DateTime().Month() + 1, timeStamp.DateTime().Year()); + INFO_PRINTF5(_L("at %d :%d :%d :%d"), timeStamp.DateTime().Hour(), timeStamp.DateTime().Minute(), timeStamp.DateTime().Second(), timeStamp.DateTime().MicroSecond()); + + TInt64 timediff; + timediff = timeReceived.Int64() - aTimeRequested.Int64(); + + // *first* position received can arrive 'immediately' and up to timeout, or maxtimetofirstfix if timeout not specified + if(timediff > maxtime) + { + INFO_PRINTF1(_L("Failed: First Position received outside time range")); + return FALSE; + } + else + { + return TRUE; + } + + } + + +/** + aPosCount - which position in a set of periodic positions this is (first position = 0) + */ +TBool CT_LbsClientStep_UpdateOptions::VerifyPosTime(const TTime& aTimeFirstPosStamped, const TPositionUpdateOptions& aUpdateOpts, TPositionInfo& aPosInfo, TInt aPosCount) + { + TTime timeReceived, timeStamp; + TPosition pos; + TInt64 interval = aUpdateOpts.UpdateInterval().Int64(); + TTimeIntervalMicroSeconds timeout; + timeout = aUpdateOpts.UpdateTimeOut().Int64(); + + // should call different function for first position: + __ASSERT_ALWAYS(aPosCount > 0, User::Panic(_L("Update options test"), KErrArgument)); + + // get current time + timeReceived.UniversalTime(); + + // get the position data: + aPosInfo.GetPosition(pos); + + INFO_PRINTF1(_L("Position received at: ")); + INFO_PRINTF4(_L("%d/%d/%d"), timeReceived.DateTime().Day() + 1, timeReceived.DateTime().Month() + 1, timeReceived.DateTime().Year()); + INFO_PRINTF5(_L("at %d :%d :%d :%d"), timeReceived.DateTime().Hour(), timeReceived.DateTime().Minute(), timeReceived.DateTime().Second(), timeReceived.DateTime().MicroSecond()); + + timeStamp = pos.Time(); + INFO_PRINTF1(_L("Position timeStamp: ")); + INFO_PRINTF4(_L("%d/%d/%d"), timeStamp.DateTime().Day() + 1, timeStamp.DateTime().Month() + 1, timeStamp.DateTime().Year()); + INFO_PRINTF5(_L("at %d :%d :%d :%d"), timeStamp.DateTime().Hour(), timeStamp.DateTime().Minute(), timeStamp.DateTime().Second(), timeStamp.DateTime().MicroSecond()); + + TTime windowstart = aTimeFirstPosStamped + static_cast(aPosCount * interval) - KTimestampMargin; + TTime windowend = windowstart + timeout + KTimestampMargin; + + INFO_PRINTF1(_L("valid window start: ")); + INFO_PRINTF4(_L("%d/%d/%d"), windowstart.DateTime().Day() + 1, windowstart.DateTime().Month() + 1, windowstart.DateTime().Year()); + INFO_PRINTF5(_L("at %d :%d :%d :%d"), windowstart.DateTime().Hour(), windowstart.DateTime().Minute(), windowstart.DateTime().Second(), windowstart.DateTime().MicroSecond()); + + if(timeStamp < windowstart) + { + INFO_PRINTF1(_L("Failed: Position received outside time range")); + return FALSE; + } + if(timeout.Int64() && (timeStamp > windowend)) + { + INFO_PRINTF1(_L("valid window end: ")); + INFO_PRINTF4(_L("%d/%d/%d"), windowend.DateTime().Day() + 1, windowend.DateTime().Month() + 1, windowend.DateTime().Year()); + INFO_PRINTF5(_L("at %d :%d :%d :%d"), windowend.DateTime().Hour(), windowend.DateTime().Minute(), windowend.DateTime().Second(), windowend.DateTime().MicroSecond()); + + return FALSE; + } + else + { + return TRUE; + } + } + + + + +// constant definitions +_LIT(KLbsClientStepUpdateOptions, "LbsClientStepUpdateOptions"); + +/** + * Sets a Requestor for now - TO DO will be removed with new location server? + */ +void CT_LbsClientStep_UpdateOptions::TempSetRequestorL() + { + User::LeaveIfError(iPositioner.SetRequestor( CRequestor::ERequestorService, + CRequestor::EFormatApplication, + _L("Tom Tom"))); + } + + +/** + * Destructor + */ +CT_LbsClientStep_UpdateOptions::~CT_LbsClientStep_UpdateOptions() + { + delete iLbsAdmin; + } + + +/** + * Constructor + */ +CT_LbsClientStep_UpdateOptions::CT_LbsClientStep_UpdateOptions(CT_LbsClientServer& aParent) : CT_LbsClientStep(aParent), iLbsAdmin(NULL), iRequestedAssData(FALSE), iReceivedAssData(FALSE) + { + SetTestStepName(KLbsClientStep_UpdateOptions); + } + + +/** +Static Constructor +*/ +CT_LbsClientStep_UpdateOptions* CT_LbsClientStep_UpdateOptions::New(CT_LbsClientServer& aParent) + { + return new CT_LbsClientStep_UpdateOptions(aParent); + // Note the lack of ELeave. + // This means that having insufficient memory will return NULL; + } + + +/** +Compare UpdateOptions +*/ +TBool CT_LbsClientStep_UpdateOptions::CompareUpdateOptions(TPositionUpdateOptions aPosA, TPositionUpdateOptions aPosB) + { + TBool isEqual = ETrue; + + if(aPosA.AcceptPartialUpdates() != aPosB.AcceptPartialUpdates()) + { + return EFalse; + } + + if(aPosA.MaxUpdateAge() != aPosB.MaxUpdateAge()) + { + return EFalse; + } + + if(aPosA.PositionClassSize() != aPosB.PositionClassSize()) + { + return EFalse; + } + + if(aPosA.PositionClassType() != aPosB.PositionClassType()) + { + return EFalse; + } + + if(aPosA.UpdateInterval() != aPosB.UpdateInterval()) + { + return EFalse; + } + + if(aPosA.UpdateTimeOut() != aPosB.UpdateTimeOut()) + { + return EFalse; + } + + return isEqual; + + } + +/** + * @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. + */ +TVerdict CT_LbsClientStep_UpdateOptions::doTestStepL() + { + // Generic test step used to test the LBS SetUpdateOptions API. + INFO_PRINTF1(_L(">>CT_LbsClientStep_UpdateOptions::doTestStepL()")); + + if (TestStepResult()==EPass) + { + TInt err = KErrNone; + + // Connect to self locate server. + User::LeaveIfError(iServer.Connect()); + CleanupClosePushL(iServer); + + // Carryout unique test actions. + TInt testCaseId; + if (GetIntFromConfig(ConfigSection(), KTestCaseId, testCaseId)) + { + switch (testCaseId) + { + // Test case LBS-UpdateOptions-001 + case 1: + { + // Open positioner. + User::LeaveIfError(iPositioner.Open(iServer)); + CleanupClosePushL(iPositioner); + TPositionUpdateOptions optsA; + + TPositionUpdateOptions optsB; + iPositioner.SetUpdateOptions(optsA); + iPositioner.GetUpdateOptions(optsB); + if (!CompareUpdateOptions(optsA, optsB)) + { + SetTestStepResult(EFail); + } + + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + // Test case LBS-UpdateOptions-002 + case 2: + { + // Open positioner. + User::LeaveIfError(iPositioner.Open(iServer)); + CleanupClosePushL(iPositioner); + //(aInterval, aTimeOut, aMaxAge, TBool aAcceptPartialUpdates=EFalse) + TPositionUpdateOptions optsA(-1, 0, 0, EFalse); + + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + // Test case LBS-UpdateOptions-003 + case 3: + { + // Open positioner. + User::LeaveIfError(iPositioner.Open(iServer)); + CleanupClosePushL(iPositioner); + + TPositionUpdateOptions optsA(0, -1, 0, EFalse); + + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + // Test case LBS-UpdateOptions-004 + case 4: + { + // Open positioner. + User::LeaveIfError(iPositioner.Open(iServer)); + CleanupClosePushL(iPositioner); + + TPositionUpdateOptions optsA(0, 0, -1, EFalse); + + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + + // Test case LBS-UpdateOptions-005 + case 5: + { + // Open positioner. + User::LeaveIfError(iPositioner.Open(iServer)); + CleanupClosePushL(iPositioner); + + TPositionUpdateOptions& updateOpts = iParent.iSharedData->iVerifyUpdateOpts; + iPositioner.SetUpdateOptions(updateOpts); + + // Create a posinfo and store in our shared array for later verification. + RPointerArray& 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); + + TTime timeRequested; + timeRequested.UniversalTime(); + INFO_PRINTF1(_L("Position requested at: ")); + INFO_PRINTF4(_L("%d/%d/%d"), timeRequested.DateTime().Day() + 1, timeRequested.DateTime().Month() + 1, timeRequested.DateTime().Year()); + INFO_PRINTF5(_L("at %d :%d :%d :%d"), timeRequested.DateTime().Hour(), timeRequested.DateTime().Minute(), timeRequested.DateTime().Second(), timeRequested.DateTime().MicroSecond()); + + + // Get the actual position + err = DoNotifyUpdateL(*posInfo); + if (KErrNone != err || !VerifyFirstPosTime(timeRequested, *posInfo, updateOpts)) + { + SetTestStepResult(EFail); + } + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + + // Test case LBS-UpdateOptions-006 + case 6: + { + // Open positioner. + User::LeaveIfError(iPositioner.Open(iServer)); + CleanupClosePushL(iPositioner); + + RPointerArray& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr; + T_LbsUtils utils; + utils.ResetAndDestroy_PosInfoArr(posInfoArr); // Clear previous entries before new entry is appended. + + // Create a posinfo and store in our shared array for later verification. + TPositionInfo* posInfo = new(ELeave) TPositionInfo(); + posInfoArr.Append(posInfo); + + TRequestStatus status; + + TPositionUpdateOptions tempOpts; + // set a fairly long interval (1 minute) to ensure the 2nd request doesn't complete too quicky: + tempOpts.SetUpdateInterval(60*1000000); + tempOpts.SetUpdateTimeOut(300*1000000); + iPositioner.SetUpdateOptions(tempOpts); + iPositioner.GetUpdateOptions(tempOpts); + + TempSetRequestorL(); + + TTime timeRequested; + TTime timeFirstStamped; + + INFO_PRINTF2(_L("Requesting position (current interval set to %d): "),tempOpts.UpdateInterval().Int64() ); + timeRequested.UniversalTime(); + err = DoNotifyUpdateL(*posInfo); + if (KErrNone != err) + { + INFO_PRINTF2(_L("Failed: Position Update failed with %d"), err); + SetTestStepResult(EFail); + } + else + { + TPosition pos; + posInfo->GetPosition(pos); + + // need to remember the time we received this one: + timeFirstStamped = pos.Time(); + if(!VerifyFirstPosTime(timeRequested, *posInfo, tempOpts)) + { + SetTestStepResult(EFail); + } + } + + // Create another posinfo and store in our shared array for later verification. + posInfo = new(ELeave) TPositionInfo(); + posInfoArr.Append(posInfo); + + INFO_PRINTF2(_L("Requesting position (current interval set to %d): "), tempOpts.UpdateInterval().Int64()); + + // this should complete after original interval (1 min), despite setting a new interval while it's outstanding: + iPositioner.NotifyPositionUpdate(*posInfo, status); + + // set configured update options while update still outstanding: + TPositionUpdateOptions& updateOpts = iParent.iSharedData->iVerifyUpdateOpts; + iPositioner.SetUpdateOptions(updateOpts); + iPositioner.GetUpdateOptions(updateOpts); + + INFO_PRINTF2(_L("Interval now set to %d microseconds"), updateOpts.UpdateInterval().Int64()); + + User::WaitForRequest(status); + + // verify time for 'outstanding when interval changed' position + if(!VerifyPosTime(timeFirstStamped, tempOpts, *posInfo, 1)) + { + INFO_PRINTF1(_L("CT_LbsClientStep_UpdateOptions::doTestStepL() Failed: Time received outside valid range")); + SetTestStepResult(EFail); + } + else + { + TInt numOfPosInfos = iParent.iSharedData->iVerifyPosInfoArr.Count() - 2; // -2 because first 2 positions used above + for(TInt i = 0 ; i < numOfPosInfos ; i++) + { + // get current time + timeRequested.UniversalTime(); + INFO_PRINTF1(_L("Position requested at: ")); + INFO_PRINTF4(_L("%d/%d/%d"), timeRequested.DateTime().Day() + 1, timeRequested.DateTime().Month() + 1, timeRequested.DateTime().Year()); + INFO_PRINTF5(_L("at %d :%d :%d :%d"), timeRequested.DateTime().Hour(), timeRequested.DateTime().Minute(), timeRequested.DateTime().Second(), timeRequested.DateTime().MicroSecond()); + + //Do request to position update + posInfo = new(ELeave) TPositionInfo(); + posInfoArr.Append(posInfo); + + err = DoNotifyUpdateL(*posInfo); + if (KErrNone != err) + { + INFO_PRINTF2(_L("Failed: Position Update failed with %d"), err); + SetTestStepResult(EFail); + } + else + { + if(i > 0) + { + if(!VerifyPosTime(timeFirstStamped, updateOpts, *posInfo, i)) + { + INFO_PRINTF1(_L("Failed: Position received outside time range")); + SetTestStepResult(EFail); + } + } + else // first position + { + TPosition pos; + + posInfo->GetPosition(pos); + + // need to remember the time we received this one: + timeFirstStamped = pos.Time(); + if(!VerifyFirstPosTime(timeRequested, *posInfo, updateOpts)) + { + SetTestStepResult(EFail); + } + } + } + } + } + + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + + // Test case LBS-UpdateOptions-007 + case 7: + case 107: + { + // Open positioner. + User::LeaveIfError(iPositioner.Open(iServer)); + CleanupClosePushL(iPositioner); + + + // For this test an additional reference position will be returned. + if (testCaseId == 107) + { + // Setup netsim. + User::LeaveIfError(OpenNetSim()); + + // Request notify for the expected reference position. + TPositionInfo actualRefPosInfo; + + err = DoNotifyUpdateL(actualRefPosInfo); + if (err) + { + INFO_PRINTF2(_L("Failed test, reference position request returned err %d."), err); + + SetTestStepResult(EFail); + } + + // Verify reference position. + T_LbsUtils utils; + TPositionInfo verifyRefPosInfo; + + verifyRefPosInfo.SetPosition(iRefPos); + if (!utils.Compare_PosInfo(verifyRefPosInfo, actualRefPosInfo)) + { + INFO_PRINTF1(_L("Failed test, reference position incorrect.")); + SetTestStepResult(EFail); + } + } + + + TPositionUpdateOptions& updateOpts = iParent.iSharedData->iVerifyUpdateOpts; + + iPositioner.SetUpdateOptions(updateOpts); + + // verify that the set worked: + ASSERT(updateOpts.UpdateInterval() == iParent.iSharedData->iVerifyUpdateOpts.UpdateInterval()); + + // Create a posinfo and store in our shared array for later verification. + RPointerArray& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr; + T_LbsUtils utils; + utils.ResetAndDestroy_PosInfoArr(posInfoArr); // Clear previous entries before new entry is appended. + + TPositionInfo* posInfo; + TTime timeRequested; + + iPositioner.GetUpdateOptions(updateOpts); + + TInt numOfPosInfos = iParent.iSharedData->iVerifyPosInfoArr.Count(); + TTime timeFirstStamped; + for(TInt i = 0 ; i < numOfPosInfos ; i++) + { + // get current time + timeRequested.UniversalTime(); + INFO_PRINTF1(_L("Position requested at: ")); + INFO_PRINTF4(_L("%d/%d/%d"), timeRequested.DateTime().Day() + 1, timeRequested.DateTime().Month() + 1, timeRequested.DateTime().Year()); + INFO_PRINTF5(_L("at %d :%d :%d :%d"), timeRequested.DateTime().Hour(), timeRequested.DateTime().Minute(), timeRequested.DateTime().Second(), timeRequested.DateTime().MicroSecond()); + + //Do request to position update + posInfo = new(ELeave) TPositionInfo(); + posInfoArr.Append(posInfo); + + err = DoNotifyUpdateL(*posInfo); + if (KErrNone != err) + { + INFO_PRINTF2(_L("NotifyUpdate failed with %d "), err); + SetTestStepResult(EFail); + } + else + { + if(i > 0) + { + if(!VerifyPosTime(timeFirstStamped, updateOpts, *posInfo, i)) + { + INFO_PRINTF1(_L("Failed: Position received outside time range")); + SetTestStepResult(EFail); + } + } + else // first position + { + TPosition pos; + + posInfo->GetPosition(pos); + + // need to remember the time we received this one: + timeFirstStamped = pos.Time(); + if(!VerifyFirstPosTime(timeRequested, *posInfo, updateOpts)) + { + SetTestStepResult(EFail); + } + } + } + } + + // Clean up. + CleanupStack::PopAndDestroy(&iPositioner); + if (testCaseId == 107) + { + CloseNetSim(); + } + + break; + } + + // Test case LBS-UpdateOptions-008 + case 8: + { + // Open positioner. + User::LeaveIfError(iPositioner.Open(iServer)); + CleanupClosePushL(iPositioner); + + //2 second interval + TPositionUpdateOptions optsA(2000000, 0, 0, EFalse); + optsA.SetUpdateInterval(-1); + + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + // Test case LBS-UpdateOptions-009 + case 9: + { + // Open positioner. + User::LeaveIfError(iPositioner.Open(iServer)); + CleanupClosePushL(iPositioner); + + + //10 second interval + TPositionUpdateOptions posUpdateOptsA(10000000, 0, 0, EFalse); + TPositionUpdateOptions posUpdateOptsB; + iPositioner.SetUpdateOptions(posUpdateOptsA); + iPositioner.GetUpdateOptions(posUpdateOptsB); + + if(!CompareUpdateOptions(posUpdateOptsA, posUpdateOptsB)) + { + INFO_PRINTF1(_L("SetUpdate and GetUpdate comparison didn't match")); + SetTestStepResult(EFail); + } + + //5 second timeout + posUpdateOptsA.SetUpdateTimeOut(5000000); + iPositioner.SetUpdateOptions(posUpdateOptsA); + iPositioner.GetUpdateOptions(posUpdateOptsB); + + if(!CompareUpdateOptions(posUpdateOptsA, posUpdateOptsB)) + { + INFO_PRINTF1(_L("SetUpdate and GetUpdate comparison didn't match")); + SetTestStepResult(EFail); + } + + TPositionInfo posInfo; + + // TO DO - is this sufficient, or should we really be testing how long it takes to timeout? + + // Get the actual position, should time out on AGPS side + // ** Configure test gps module to cause a timeout + err = DoNotifyUpdateL(posInfo); + if (KErrTimedOut != err) + { + INFO_PRINTF1(_L("AGPS module didn't timeout as expected.")); + SetTestStepResult(EFail); + } + + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + + // Test case LBS-UpdateOptions-010 + case 10: + { + // Open positioner. + User::LeaveIfError(iPositioner.Open(iServer)); + CleanupClosePushL(iPositioner); + + TPositionUpdateOptions optsA; + optsA.SetUpdateTimeOut(-1); + + CleanupStack::PopAndDestroy(&iPositioner); + break; + } + + + // Test case LBS-UpdateOptions-011 + case 11: + { + // Open positioner with + // configured required quality + TPositionCriteria criteria; + TPositionQuality quality; + + // set up the required accuracy + quality.SetHorizontalAccuracy(EXPECTED_GPS_ACCURACY_HORIZONTAL); + quality.SetVerticalAccuracy(EXPECTED_GPS_ACCURACY_VERTICAL); + + criteria.SetRequiredQuality(quality); + User::LeaveIfError(iPositioner.Open(iServer, criteria)); + CleanupClosePushL(iPositioner); + + //Configure partial Updates + TPositionUpdateOptions optsA; + optsA.SetAcceptPartialUpdates(EFalse); + if(EFalse != optsA.AcceptPartialUpdates()) + { + INFO_PRINTF1(_L("Partial Updates not set.")); + SetTestStepResult(EFail); + } + + iPositioner.SetUpdateOptions(optsA); + + + // NOTE: + // -Expect to call NPU once, and have module return 2 partial updates + // before finally returning the complete update. + // -We need a way to inform the module that it nedes to return partial updates + // When we have AcceptPartialUpdates SwitchedOff. + + // ** Test AGPS manager must already be configured to return partial location info + // ** We should only see the full location info to required accuracy etc + TPositionInfo positionInfo; + TPositionInfo positionInfoTemp = reinterpret_cast(iParent.iSharedData->iVerifyPosInfoArr[2]); + + // Get the actual position + err = DoNotifyUpdateL(positionInfo); + if (KErrNone != err) + { + SetTestStepResult(EFail); + } + else + { + //Compare posInfo with Moduledata 3 + T_LbsUtils utils; + if(!utils.Compare_PosInfo(positionInfo, positionInfoTemp)) + { + INFO_PRINTF1(_L("We didn't recieve complete update.")); + SetTestStepResult(EFail); + } + } + + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + // Test case LBS-UpdateOptions-012 + case 12: + { + // Open positioner with + // configured required quality + TPositionCriteria criteria; + TPositionQuality quality; + + // set up the required accuracy + quality.SetHorizontalAccuracy(EXPECTED_GPS_ACCURACY_HORIZONTAL); + quality.SetVerticalAccuracy(EXPECTED_GPS_ACCURACY_VERTICAL); + + criteria.SetRequiredQuality(quality); + err = iPositioner.Open(iServer, criteria); + User::LeaveIfError(err); + CleanupClosePushL(iPositioner); + + //Configure partial Updates + TPositionUpdateOptions optsA; + optsA.SetAcceptPartialUpdates(ETrue); + if(!optsA.AcceptPartialUpdates()) + { + INFO_PRINTF1(_L("Partial Updates not set.")); + SetTestStepResult(EFail); + } + + err = iPositioner.SetUpdateOptions(optsA); + User::LeaveIfError(err); + + // NOTE: + // -Expect to call NPU repeatedly to recieve each partial update + // -We need a way to inform the module that it nedes to return partial updates + // When we have AcceptPartialUpdates SwitchedOff. + + // ** Test AGPS manager must already be configured to return partial location info + // ** We should only see the full location info to required accuracy etc + + // Create a posinfo and store in our shared array for later verification. + RPointerArray& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr; + T_LbsUtils utils; + utils.ResetAndDestroy_PosInfoArr(posInfoArr); // Clear previous entries before new entry is appended. + + TInt loopCount = iParent.iSharedData->iCurrentPosInfoArr.Count()-1; + // Get the actual position + for(int i = 0 ; i < loopCount ; i++ ) + { + TPositionInfo* positionInfo = new(ELeave) TPositionInfo(); + posInfoArr.Append(positionInfo); + + err = DoNotifyUpdateL(*positionInfo); + if (KErrNone != err) + { + SetTestStepResult(EFail); + } + } + + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + // Test case LBS-UpdateOptions-013 + case 13: + { + // Open positioner. + User::LeaveIfError(iPositioner.Open(iServer)); + CleanupClosePushL(iPositioner); + + TPositionInfo posInfo; + TPositionInfo posInfob; + + // This call to NPU puts a location in cache + err = DoNotifyUpdateL(posInfo); + if (KErrNone != err) + { + SetTestStepResult(EFail); + } + + // TO DO - read these from config? + TPositionUpdateOptions posOpts; + posOpts.SetMaxUpdateAge(1*1000000); + posOpts.SetUpdateInterval(5*1000000); + + if((posOpts.MaxUpdateAge() != 1000000) || (posOpts.UpdateInterval() != 5000000)) + { + SetTestStepResult(EFail); + } + + iPositioner.SetUpdateOptions(posOpts); + + //Retrieve cached location with second call to NPU + err = DoNotifyUpdateL(posInfob); + if (KErrNone != err) + { + SetTestStepResult(EFail); + } + + //INTERNAL COMPARISON + //Make sure we've retrieved the cached location + T_LbsUtils utils; + if(!utils.Compare_PosInfo(posInfo, posInfob)) + { + SetTestStepResult(EFail); + } + + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + + + + + // Test case LBS-UpdateOptions-014 + case 14: + { + T_LbsUtils utils; + TPositionModuleId networkModId = utils.GetNetworkModuleIdL(iServer); + + // Open positioners. + User::LeaveIfError(iPositioner.Open(iServer, networkModId)); + CleanupClosePushL(iPositioner); + + RPositionServer server2; + RPositioner positioner2; + + // Connect to self locate servers. + User::LeaveIfError(server2.Connect()); + CleanupClosePushL(server2); + + TPositionModuleId aGpsModId = utils.GetAGpsModuleIdL(server2); + + User::LeaveIfError(positioner2.Open(server2, aGpsModId)); + CleanupClosePushL(positioner2); + + + TPositionUpdateOptions optsA; + TPositionUpdateOptions optsB; + + optsA.SetMaxUpdateAge(10000000); + optsA.SetUpdateInterval(5000000); + + optsB.SetMaxUpdateAge(0); + optsB.SetUpdateInterval(2000000); + + TPositionInfo posInfo; + TPositionInfo posInfob; + + + // Get the actual position + err = DoNotifyUpdateL(posInfo); + if (KErrNone != err) + { + SetTestStepResult(EFail); + } + + err = DoNotifyUpdateL(posInfob); + if (KErrNone != err) + { + SetTestStepResult(EFail); + } + + CleanupStack::PopAndDestroy(&positioner2); + CleanupStack::PopAndDestroy(&server2); + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + + + + // Test case LBS-UpdateOptions-015 + case 15: + { + T_LbsUtils utils; + TPositionModuleId networkModId = utils.GetNetworkModuleIdL(iServer); + + // Open positioners. + User::LeaveIfError(iPositioner.Open(iServer, networkModId)); + CleanupClosePushL(iPositioner); + + RPositionServer server2; + RPositioner positioner2; + + // Connect to self locate servers. + User::LeaveIfError(server2.Connect()); + CleanupClosePushL(server2); + + User::LeaveIfError(positioner2.Open(server2, networkModId)); + CleanupClosePushL(positioner2); + + + TPositionUpdateOptions optsA; + TPositionUpdateOptions optsB; + + optsA.SetMaxUpdateAge(10000000); + optsA.SetUpdateInterval(5000000); + + optsB.SetMaxUpdateAge(0); + optsB.SetUpdateInterval(2000000); + + TPositionInfo posInfo; + TPositionInfo posInfob; + + + // Get the actual position + err = DoNotifyUpdateL(posInfo); + if (KErrNone != err) + { + SetTestStepResult(EFail); + } + + // Loop? Keep calling until full info recieved. + err = DoNotifyUpdateL(posInfob); + if (KErrNone != err) + { + SetTestStepResult(EFail); + } + + CleanupStack::PopAndDestroy(&positioner2); + CleanupStack::PopAndDestroy(&server2); + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + + + + + // Test case LBS-UpdateOptions-016 + case 16: + { + T_LbsUtils utils; + TPositionModuleId networkModId = utils.GetNetworkModuleIdL(iServer); + + // Open positioners. + User::LeaveIfError(iPositioner.Open(iServer, networkModId)); + CleanupClosePushL(iPositioner); + + RPositionServer server2; + RPositioner positioner2; + + //Connect to self locate server + TPositionModuleId aGpsModId = utils.GetAGpsModuleIdL(server2); + + User::LeaveIfError(positioner2.Open(iServer, aGpsModId)); + CleanupClosePushL(positioner2); + + TPositionUpdateOptions optsA; + TPositionUpdateOptions optsB; + + optsA.SetMaxUpdateAge(10000000); + optsA.SetUpdateInterval(5000000); + + optsB.SetMaxUpdateAge(0); + optsB.SetUpdateInterval(2000000); + + TPositionInfo posInfo; + TPositionInfo posInfob; + + // Get the actual position + err = DoNotifyUpdateL(posInfo); + if (KErrNone != err) + { + SetTestStepResult(EFail); + } + + // Loop? Keep calling until full info recieved. + err = DoNotifyUpdateL(posInfob); + if (KErrNone != err) + { + SetTestStepResult(EFail); + } + + CleanupStack::PopAndDestroy(&positioner2); + CleanupStack::PopAndDestroy(&server2); + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + + + // Test case LBS-UpdateOptions-017 + case 17: + { + // Open positioner. + User::LeaveIfError(iPositioner.Open(iServer)); + CleanupClosePushL(iPositioner); + + + TPositionUpdateOptions optsA; + optsA.SetUpdateInterval(1000000); + optsA.SetMaxUpdateAge(5000000); + + if((optsA.MaxUpdateAge() != 5000000) || (optsA.UpdateInterval() != 1000000)) + { + SetTestStepResult(EFail); + } + + iPositioner.SetUpdateOptions(optsA); + // Test AGPS manager must already be configured to return partial location info + + TPositionInfo posInfo; + + // This call to NPU puts a location in cache + err = DoNotifyUpdateL(posInfo); + if (KErrNone != err) + { + SetTestStepResult(EFail); + } + + /* + MaxUpdateAge () returns the current age limit for + information returned by NotifyPositionUpdate(). + Zero is returned when there is no acceptable age limit. + */ + + if(optsA.MaxUpdateAge() != 0) + { + SetTestStepResult(EFail); + } + + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + // Test case LBS-UpdateOptions-018 + case 18: + { + // Open positioner. + User::LeaveIfError(iPositioner.Open(iServer)); + CleanupClosePushL(iPositioner); + + TPositionUpdateOptions optsA; + optsA.SetMaxUpdateAge(-1); + + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + + // Test case LBS-UpdateOptions-019 + case 19: + { + // Open positioner. + User::LeaveIfError(iPositioner.Open(iServer)); + CleanupClosePushL(iPositioner); + + //MaxUpdateAge comparision replacede by verify data step + TPositionUpdateOptions& updateOpts = iParent.iSharedData->iVerifyUpdateOpts; + + TPositionInfo posInfoA, posInfoB; + + //Get fresh location and have it in cache + err = DoNotifyUpdateL(posInfoA); + if (KErrNone != err) + { + SetTestStepResult(EFail); + } + + //Second call to NPU should have maxupdateage set. + iPositioner.SetUpdateOptions(updateOpts); + + err = DoNotifyUpdateL(posInfoB); + if (KErrNone != err) + { + SetTestStepResult(EFail); + } + + T_LbsUtils utils; + + if(!utils.Compare_PosInfo(posInfoA, posInfoB)) + { + //Cached copy doesnt match retrieved copy. + SetTestStepResult(EFail); + } + + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + // Test case LBS-UpdateOptions-020 + case 20: + { + // Open positioner. + User::LeaveIfError(iPositioner.Open(iServer)); + CleanupClosePushL(iPositioner); + + TPositionInfo cachedInfo, firstposInfo, secondposInfo; + + TPositionUpdateOptions& updateOpts = iParent.iSharedData->iVerifyUpdateOpts; + updateOpts.SetUpdateInterval(0); + updateOpts.SetMaxUpdateAge(0); + //Second call to NPU should have maxupdateage set. + iPositioner.SetUpdateOptions(updateOpts); + + // Get fresh location and have it in cache + err = DoNotifyUpdateL(cachedInfo); + if (KErrNone != err) + { + SetTestStepResult(EFail); + } + + // Change the max fix time + updateOpts.SetMaxUpdateAge(5000000); + iPositioner.SetUpdateOptions(updateOpts); + + // Wait 4 seconds + User::After(4000000); + + // Get a position should be the same as in the cache + err = DoNotifyUpdateL(firstposInfo); + if (KErrNone != err) + { + SetTestStepResult(EFail); + } + + // Wait 2 seconds + User::After(2000000); + // Get a position should not be the same as the cache + err = DoNotifyUpdateL(secondposInfo); + if (KErrNone != err) + { + SetTestStepResult(EFail); + } + + T_LbsUtils utils; + + TBool a = utils.Compare_PosInfo(cachedInfo, firstposInfo); + TBool b = utils.Compare_PosInfo(firstposInfo, secondposInfo); + + if(!a || b) + { + //Cached copy doesnt match retrieved copy. + SetTestStepResult(EFail); + } + + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + + // Test case LBS-UpdateOptions-101 (for DEF118183) + case 101: + { + // Open positioner. + User::LeaveIfError(iPositioner.Open(iServer)); + CleanupClosePushL(iPositioner); + + TPositionInfo posInfoa; + TPositionInfo posInfob; + TPositionInfo posInfoc; + + // This call to NPU puts a location in cache + err = DoNotifyUpdateL(posInfoa); + if (KErrNone != err) + { + INFO_PRINTF2(_L("Failed: During first call to NPU err is %d"), err); + SetTestStepResult(EFail); + } + + TPositionUpdateOptions posOpts; + posOpts.SetMaxUpdateAge(1*1000000); + posOpts.SetUpdateInterval(5*1000000); + + if((posOpts.MaxUpdateAge() != 1000000) || (posOpts.UpdateInterval() != 5000000)) + { + INFO_PRINTF1(_L("Failed: During check of options values")); + SetTestStepResult(EFail); + } + + iPositioner.SetUpdateOptions(posOpts); + + //Retrieve cached location with second call to NPU + err = DoNotifyUpdateL(posInfob); + if (KErrNone != err) + { + INFO_PRINTF2(_L("Failed: During NPU 2 value is %d"), err); + SetTestStepResult(EFail); + } + + //INTERNAL COMPARISON + //Make sure we've retrieved the cached location + T_LbsUtils utils; + if(!utils.Compare_PosInfo(posInfoa, posInfob)) + { + INFO_PRINTF1(_L("Failed: During comparison of pos info values")); + SetTestStepResult(EFail); + } + + // Make 3rd call to NPU - this one to be cancelled + TRequestStatus status; + iPositioner.NotifyPositionUpdate(posInfoc, status); + + // Wait 2 seconds and then cancel + User::After(2000000); + err = iPositioner.CancelRequest(EPositionerNotifyPositionUpdate); + if (KErrNone != err) + { + // Pre-DefectFix code would return -1 at this point since there would have been no request to cancel + INFO_PRINTF2(_L("Failed: Cancel request was rejected with error %d"), err); + SetTestStepResult(EFail); + } + + User::WaitForRequest(status); + if (KErrCancel != status.Int()) + { + // Pre-DefectFix code would return 0 at this point to indicate a successfully returned position + INFO_PRINTF2(_L("Failed: Expected NPU to complete with KErrCancel but actual value is %d"), status.Int()); + SetTestStepResult(EFail); + } + + CleanupStack::PopAndDestroy(&iPositioner); + + break; + } + + + + default: + User::Panic(KLbsClientStepUpdateOptions, KErrUnknown); + + } + + } + + + // All done, clean up. + CleanupStack::PopAndDestroy(&iServer); + } + + INFO_PRINTF1(_L("<<CT_LbsClientStep_UpdateOptions::doTestStepL()")); + + return TestStepResult(); + }