diff -r e8c1ea2c6496 -r 8758140453c0 lbs/lbsclient/src/ctlbsclientsteptracking.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lbs/lbsclient/src/ctlbsclientsteptracking.cpp Thu Jan 21 12:53:44 2010 +0000 @@ -0,0 +1,668 @@ +// Copyright (c) 2007-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_tracking.cpp +// This is the class implementation for the Tracking Tests +// +// + +#include "ctlbsclientsteptracking.h" + +#include +#include + +#include "tlbsutils.h" +#include "ctlbsasyncwaiter.h" + + +/** + * Construction. + */ +CT_LbsClientStep_Tracking* CT_LbsClientStep_Tracking::New(CT_LbsClientServer& aParent) + { + // Note the lack of ELeave. + // This means that having insufficient memory will return NULL; + CT_LbsClientStep_Tracking* testStep = new CT_LbsClientStep_Tracking(aParent); + if (testStep) + { + TInt err = KErrNone; + + TRAP(err, testStep->ConstructL()); + if (err) + { + delete testStep; + testStep = NULL; + } + } + + return testStep; + } + + +CT_LbsClientStep_Tracking::CT_LbsClientStep_Tracking(CT_LbsClientServer& aParent) : CT_LbsClientStep(aParent), + iVerifyInterval(ETrue), iExpectedErr(KErrNone), iUpdateIndex(0) + { + SetTestStepName(KLbsClientStep_Tracking); + } + + +void CT_LbsClientStep_Tracking::ConstructL() + { + // Setup netsim. + User::LeaveIfError(OpenNetSim()); + + // Connect server. + User::LeaveIfError(iServer.Connect()); + + // Open positioner. + User::LeaveIfError(iPositioner.Open(iServer)); + } + + +/** + * Destructor + */ +CT_LbsClientStep_Tracking::~CT_LbsClientStep_Tracking() + { + iPositioner.Close(); + iServer.Close(); + CloseNetSim(); + } + + +const TTimeIntervalMicroSeconds KTimestampMargin = 500000; //+/-0.5s + +TBool CT_LbsClientStep_Tracking::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_Tracking::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_Tracking::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 && timeReceived < windowstart) + { + INFO_PRINTF1(_L("Failed: Position received outside time range")); + return FALSE; + } + if(timeout.Int64() && (timeStamp > windowend || timeReceived > 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; + } + } + + +/** + * @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_Tracking::doTestStepL() + { + // Generic test step used to test the LBS SetUpdateOptions API. + INFO_PRINTF1(_L(">>CT_LbsClientStep_Tracking::doTestStepL()")); + + if (TestStepResult()==EPass) + { + // Determine the test case id. + TInt testCaseId; + if (GetIntFromConfig(ConfigSection(), KTestCaseId, testCaseId)) + { + // Set the update options. + T_LbsUtils utils; + TPtrC configFileName; + _LIT(KUpdateOptionsFile, "agps_module_update_file"); + + GetStringFromConfig(ConfigSection(), KUpdateOptionsFile, configFileName); + + utils.GetConfigured_ModuleUpdateOptionsL(configFileName, ConfigSection(), iUpdateOpts); + iPositioner.SetUpdateOptions(iUpdateOpts); + + // count the number of updates from the .ini file + RPointerArray posInfoArray; + utils.GetConfigured_UpdateArrayL(configFileName, ConfigSection(), posInfoArray); + TInt numOfPosInfos = posInfoArray.Count(); + posInfoArray.ResetAndDestroy(); + + // Perfom test. + TInt err = KErrNone; + TPosition pos; + TTime timeFirstStamped; + TTime timeRequested; + iUpdateWindowIndex = 0; + if(testCaseId == 8) + { + iCheckIfSameAsPreviousPosition = ETrue; + } + else + { + iCheckIfSameAsPreviousPosition = EFalse; + } + + + for (iUpdateIndex = 0 ; iUpdateIndex < numOfPosInfos; iUpdateIndex++) + { + // Get and log 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. + err = DoNotifyUpdateL(iPosInfo); + + iPosInfo.GetPosition(pos); + + // First update, ref pos, KErrNone. + if (iUpdateIndex == 0) + { + // Verify time taken for first update. + timeFirstStamped = pos.Time(); // Need to remember the time we received this update. + if(!VerifyFirstPosTime(timeRequested, iPosInfo, iUpdateOpts)) + { + SetTestStepResult(EFail); + } + + // Verify reference position. + TPositionInfo verifyRefPosInfo; + + verifyRefPosInfo.SetPosition(iRefPos); + if (!utils.Compare_PosInfo(verifyRefPosInfo, iPosInfo)) + { + INFO_PRINTF1(_L("Failed test, reference position incorrect.")); + SetTestStepResult(EFail); + } + + // Expected error. + iExpectedErr = KErrNone; + + // Expect to verify interval time, for other updates. + iVerifyInterval = ETrue; + iPreviousPos = iPosInfo; + } + + // Remaining updates. + else + { + // Increment the expected time interval 'window' the update is expected to arrive in + iUpdateWindowIndex++; + + // Determine expected err, and any special test actions. + switch (iUpdateIndex) + { + // Second update, gps accurate, KErrNone, after n * intervals. + case 1: + { + iExpectedErr = KErrNone; + + if(testCaseId == 7) + { + DoInterval_TestCaseId_07(); + } + else if(testCaseId == 8) + { + DoInterval_TestCaseId_08(); + } + else + { + // Got the first accurate gps update, switch on partial updates. + iUpdateOpts.SetAcceptPartialUpdates(ETrue); + iPositioner.SetUpdateOptions(iUpdateOpts); + } + + break; + } + + // Remaining updates as per test case. + default: + { + switch (testCaseId) + { + // Test case LBS-Tracking-001 + case 1: + { + DoInterval_TestCaseId_01(); + + break; + } + + // Test case LBS-Tracking-002 + case 2: + { + DoInterval_TestCaseId_02(); + + break; + } + + // Test case LBS-Tracking-003 + case 3: + { + DoInterval_TestCaseId_03(); + + break; + } + + // Test case LBS-Tracking-004 + case 4: + { + DoInterval_TestCaseId_04(); + + break; + } + + // Test case LBS-Tracking-005 + case 5: + { + DoInterval_TestCaseId_05(); + + break; + } + + // Test case LBS-Tracking-006 + case 6: + { + DoInterval_TestCaseId_06(); + + break; + } + + // Test case LBS-Tracking-007 + case 7: + { + DoInterval_TestCaseId_07(); + + break; + } + + // Test case LBS-Tracking-008 + case 8: + { + DoInterval_TestCaseId_08(); + + break; + } + } + } + break; + } + + // Verify correct interval for update, if required. + if (iVerifyInterval) + { + if(!VerifyPosTime(timeFirstStamped, iUpdateOpts, iPosInfo, iUpdateWindowIndex)) + { + INFO_PRINTF1(_L("Failed: Position received outside time range")); + SetTestStepResult(EFail); + } + } + + if(iCheckIfSameAsPreviousPosition) + { + if(iSameAsPreviousPos && !utils.Compare_PosInfo(iPreviousPos, iPosInfo)) + { + INFO_PRINTF1(_L("Failed test, position different from previous, when it should be same.")); + SetTestStepResult(EFail); + } + if(!iSameAsPreviousPos && utils.Compare_PosInfo(iPreviousPos, iPosInfo)) + { + INFO_PRINTF1(_L("Failed test, position same as previous, when it should be different.")); + SetTestStepResult(EFail); + } + } + iPreviousPos = iPosInfo; + } + + // Verify err. + if (err != iExpectedErr) + { + SetTestStepResult(EFail); + } + } + + } + + } + + INFO_PRINTF1(_L("<<CT_LbsClientStep_Tracking::doTestStepL()")); + + return TestStepResult(); + } + + +// Test 1 - expected updates +// +// Ref pos, KErrNone, before interval +// Gps pos (accurate), KErrNone, after n * intervals +// Gps pos (accurate), KErrNone, after interval +// Gps pos (partial), KPositionPartialUpdate, after interval +// +void CT_LbsClientStep_Tracking::DoInterval_TestCaseId_01() +{ + + switch (iUpdateIndex) + { + case 2: // Third update, gps accurate, KErrNone. + { + iExpectedErr = KErrNone; + + break; + } + + case 3: // Last update, gps inaccurate, KPositionPartialUpdate. + { + iExpectedErr = KPositionPartialUpdate; + + break; + } + } + } + + +// Test 2 - expected updates +// +// Ref pos, KErrNone, before interval +// Gps pos (accurate), KErrNone, after n * intervals +// Gps pos (accurate), KErrNone, after interval +// Gps pos (accurate), KErrNone, after interval +// +void CT_LbsClientStep_Tracking::DoInterval_TestCaseId_02() +{ + + switch (iUpdateIndex) + { + case 2: // Third update, gps accurate, KErrNone. + case 3: // Last update, gps accurate, KErrNone. + { + iExpectedErr = KErrNone; + + break; + } + } + } + + +// Test 3 - expected updates +// +// Ref pos, KErrNone, before interval +// Gps pos (accurate), KErrNone, after n * intervals +// Gps pos (NAN), KPositionPartialUpdate, after interval +// Gps pos (NAN), KPositionPartialUpdate, after interval +// +void CT_LbsClientStep_Tracking::DoInterval_TestCaseId_03() +{ + + switch (iUpdateIndex) + { + case 2: // Third update, gps NAN, KPositionPartialUpdate. + case 3: // Last update, gps NAN, KPositionPartialUpdate. + { + iExpectedErr = KPositionPartialUpdate; + + break; + } + } + } + + +// Test 4 - expected updates +// +// Ref pos, KErrNone, before interval +// Gps pos (accurate), KErrNone, after n * intervals +// Gps pos (inaccurate), KPositionPartialUpdate, after interval +// Gps pos (inaccurate), KPositionPartialUpdate, after interval +// +void CT_LbsClientStep_Tracking::DoInterval_TestCaseId_04() +{ + + switch (iUpdateIndex) + { + case 2: // Third update, gps accurate, KPositionPartialUpdate. + case 3: // Last update, gps inaccurate, KPositionPartialUpdate. + { + iExpectedErr = KPositionPartialUpdate; + + break; + } + } + } + + +// Test 5 - expected updates +// +// Ref pos, KErrNone, before interval +// Gps pos (accurate), KErrNone, after n * intervals +// Gps pos (accurate), KErrNonee, after interval +// Gps pos (not delivered), KErrTimedOut, after interval +// +void CT_LbsClientStep_Tracking::DoInterval_TestCaseId_05() +{ + + switch (iUpdateIndex) + { + case 2: // Third update, gps accurate, KErrNone. + { + iExpectedErr = KErrNone; + + // Send timeout to the A-GPS hybrid module - we expect further updates to timeout. + TTimeIntervalMicroSeconds timeOutVal(40000000); + + ConfigureModuleTimeOut(timeOutVal); + + break; + } + + case 3: // Last update, gps inaccurate, KPositionPartialUpdate. + { + iExpectedErr = KErrTimedOut; + iVerifyInterval = EFalse; + + // Reset the timeout in the A-GPS module. + TTimeIntervalMicroSeconds timeOutVal(0); + ConfigureModuleTimeOut(timeOutVal); + break; + } + } + } + +// Test 6 - expected updates +// +// Ref pos, KErrNone, before interval +// Gps pos (accurate), KErrNone, after n * intervals +// Gps pos (inaccurate), KPositionPartialUpdate, after interval +// Gps pos (NAN), KPositionQualityLoss, before interval (because of futile udpate) +// Gps pos (inaccurate), KPositionPartialUpdate, after interval +// +void CT_LbsClientStep_Tracking::DoInterval_TestCaseId_06() +{ + + switch (iUpdateIndex) + { + case 2: // Third update, gps inaccurate, KPositionPartialUpdate. + { + iExpectedErr = KPositionPartialUpdate; + break; + } + + case 3: // Fourth update, gps NAN, KPositionQualityLoss. + { + iExpectedErr = KPositionQualityLoss; + + // This update should have happened before the next expected + // interval window (because it's a futile update from the + // GPS module), so it will be in the previous 'window' + iUpdateWindowIndex--; + break; + } + + case 4: // Last update, gps inaccurate, KPositionPartialUpdate. + { + iExpectedErr = KPositionPartialUpdate; + break; + } + } + } + +// Test 7 - expected updates +// +// Ref pos, KErrNone, before interval +// Gps pos (accurate), KErrNone, after n * intervals +// Gps pos (inaccurate), KPositionQualityLoss, after timeout +// +void CT_LbsClientStep_Tracking::DoInterval_TestCaseId_07() + { + switch (iUpdateIndex) + { + case 1: + { + iExpectedErr = KErrNone; + break; + } + case 2: + { + iVerifyInterval = EFalse; + iExpectedErr = KPositionQualityLoss; + break; + } + } + } + +void CT_LbsClientStep_Tracking::DoInterval_TestCaseId_08() + { + iExpectedErr = KErrNone; + switch (iUpdateIndex) + { + case 1: + case 3: + { + iSameAsPreviousPos = EFalse; + break; + } + case 2: + { + iSameAsPreviousPos = ETrue; + break; + } + } + } + +// A-GPS hybrid module configuration function. +void CT_LbsClientStep_Tracking::ConfigureModuleTimeOut(TTimeIntervalMicroSeconds& aTimeOut) + { + CT_LbsAGpsHandler* modHandler; + modHandler = CT_LbsAGpsHandler::NewL(this); + + // Send timeout request. + modHandler->SendRequestTimeOutMsg(aTimeOut); + + // Wait for response from module. + CActiveScheduler::Start(); + + delete modHandler; + } + + +// Response back from A-GPS hybrid module to notify the test it has got the timeout request. +void CT_LbsClientStep_Tracking::ProcessAGpsResponseMessage(const TT_LbsAGpsResponseMsg::TModuleResponseType aResponse) + { + if (TT_LbsAGpsResponseMsg::EModuleResponseOk != aResponse) + { + // fail test could not config module! + INFO_PRINTF2(_L("Unable to configure hybrid module, err %d."), aResponse); + SetTestStepResult(EFail); + } + + // Return back to test. + CActiveScheduler::Stop(); + }