--- /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 <lbs.h>
+#include <lbssatellite.h>
+
+#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<TTimeIntervalMicroSeconds>(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<TAny>& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr;
+ TPositionInfo* posInfo = new(ELeave) TPositionInfo();
+
+ T_LbsUtils utils;
+ utils.ResetAndDestroy_PosInfoArr(posInfoArr); // Clear previous entries before new entry is appended.
+
+ posInfoArr.Append(posInfo);
+
+ 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<TAny>& 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<TAny>& 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("<FONT><B>AGPS module didn't timeout as expected.</B></FONT>"));
+ 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<TPositionInfo&>(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("<FONT><B>We didn't recieve complete update.</B></FONT>"));
+ 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<TAny>& 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();
+ }