diff -r e8c1ea2c6496 -r 8758140453c0 lbs/lbsclient/src/ctlbsclientstep_reset_assistance.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lbs/lbsclient/src/ctlbsclientstep_reset_assistance.cpp Thu Jan 21 12:53:44 2010 +0000 @@ -0,0 +1,258 @@ +// Copyright (c) 2008-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: +// This is the class implementation for the Notify Position Update Tests +// +// + +#include "ctlbsclientstep_reset_assistance.h" + +#include +#include + +#include "tlbsutils.h" +#include "ctlbsasyncwaiter.h" + + +const TTimeIntervalMicroSeconds KModuleTimeout = 6000000;//makes test module time out(which should be more than the Maxtime in lbsprofile.ini) + +const TInt KNumberOfRequests = 10; // the number of requests to do to be near the average + +const TInt KWaitTimeForCoolDown = 10 * 1000 * 1000; // how long to wait to make sure the integration module gets turned off + +/** + * Sets a Requestor for now - TODO will be removed with new location server + */ +void CT_LbsClientStep_ResetAssistance::TempSetRequestorL() + { + User::LeaveIfError(iPositioner.SetRequestor( CRequestor::ERequestorService, + CRequestor::EFormatApplication, + _L("Tom Tom"))); + } + + +/** + * Destructor + */ +CT_LbsClientStep_ResetAssistance::~CT_LbsClientStep_ResetAssistance() + { + delete iLbsAdmin; + } + + +/** + * Constructor + */ +CT_LbsClientStep_ResetAssistance::CT_LbsClientStep_ResetAssistance(CT_LbsClientServer& aParent) : CT_LbsClientStep(aParent),iLbsAdmin(NULL),iRequestedAssData(FALSE), iReceivedAssData(FALSE) + { + + SetTestStepName(KLbsClientStep_ResetAssistance); + } + + +/** +Static Constructor +*/ +CT_LbsClientStep_ResetAssistance* CT_LbsClientStep_ResetAssistance::New(CT_LbsClientServer& aParent) + { + + // Note the lack of ELeave. + // This means that having insufficient memory will return NULL; + + CT_LbsClientStep_ResetAssistance* testStep = new CT_LbsClientStep_ResetAssistance(aParent); + if (testStep) + { + TInt err = KErrNone; + + TRAP(err, testStep->ConstructL()); + if (err) + { + delete testStep; + testStep = NULL; + } + } + return testStep; + } + + +void CT_LbsClientStep_ResetAssistance::ConstructL() + { + // create the admin + iLbsAdmin = CLbsAdmin::NewL(); + + } + +//from MT_NotifyPosUpdateObserver: +/** + * Callback - called when NotifyPositionUpdate request completes + */ + +void CT_LbsClientStep_ResetAssistance::NotifyPositionUpdateCallback(TRequestStatus& aStatus) + { + TInt err = aStatus.Int(); + if (KErrCancel != err) + { + SetTestStepResult(EFail); // the request always gets cancelled (see test 0122) + } + CActiveScheduler::Stop(); + } + +/** + * @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_ResetAssistance::doTestStepL() + { + // Generic test step used to test the LBS Client Notify position update API. + INFO_PRINTF1(_L(">>CT_LbsClientStep_ResetAssistance::doTestStepL()")); + + if (TestStepResult()==EPass) + { + TInt err = KErrNone; + + iParent.iSharedData->iTestModuleInUse = EFalse; + + // Connect to self locate server. + err = iServer.Connect(); + User::LeaveIfError(err); + CleanupClosePushL(iServer); + + // Setup netsim. + User::LeaveIfError(OpenNetSim()); + + TTimeIntervalMicroSeconds resetRequestTime; + resetRequestTime = DoRequests(EFalse, ETrue); + INFO_PRINTF2(_L("Requests from warm with reset assistance data took on average %d miliseconds to complete."), (resetRequestTime.Int64()/KNumberOfRequests)/1000); + + + TTimeIntervalMicroSeconds coldRequestTime; + coldRequestTime = DoRequests(ETrue, EFalse); + INFO_PRINTF2(_L("Requests from cold took on average %d miliseconds to complete."), (coldRequestTime.Int64()/KNumberOfRequests)/1000); + + TTimeIntervalMicroSeconds warmRequestTime; + warmRequestTime = DoRequests(EFalse, EFalse); + INFO_PRINTF2(_L("Requests from warm took on average %d miliseconds to complete."), (warmRequestTime.Int64()/KNumberOfRequests)/1000); + + INFO_PRINTF2(_L("Requests from warm with reset assistance data took on average %d miliseconds to complete."), (resetRequestTime.Int64()/KNumberOfRequests)/1000); + INFO_PRINTF2(_L("Requests from cold took on average %d miliseconds to complete."), (coldRequestTime.Int64()/KNumberOfRequests)/1000); +/* if(warmRequestTime >= resetRequestTime/2 || resetRequestTime < (coldRequestTime*3)/4) + { + INFO_PRINTF1(_L("Reseting assistance data didn't fit into the right time frame")); + SetTestStepResult(EFail); + } +*/ + CloseNetSim(); + + // All done, clean up. + CleanupStack::PopAndDestroy(&iServer); + } + + INFO_PRINTF1(_L("<<CT_LbsClientStep_ResetAssistance::doTestStepL()")); + + return TestStepResult(); + } + +TInt64 CT_LbsClientStep_ResetAssistance::DoRequests(TBool aCold, TBool aReset) + { + if(!aCold) + { + // *** Warming up module + // Open positioner. + TInt err = iPositioner.Open(iServer); + User::LeaveIfError(err); + CleanupClosePushL(iPositioner); + + // Request notify for the expected reference position. + TPositionInfo actualRefPosInfo; + err = DoNotifyUpdateL(actualRefPosInfo); + if (KErrNone != err) + { + INFO_PRINTF2(_L("Failed test, reference position request returned err %d."), err); + SetTestStepResult(EFail); + } + + TPositionInfo posInfo; + // Get the actual position + err = DoNotifyUpdateL(posInfo); + if (KErrNone != err) + { + INFO_PRINTF2(_L("Failed test, position request returned err %d."), err); + SetTestStepResult(EFail); + } + } + + TTimeIntervalMicroSeconds requestTime; + requestTime = 0; + // *** Doing the repeated requests with reset assistance data in between if it's requested so + for(TInt count = 0; count < KNumberOfRequests; ++count) + { + if(aReset) + { + SendResetAssistanceData(0xFFFFFFFF); + } + + if(aCold) + { + // Open positioner. + TInt err = iPositioner.Open(iServer); + User::LeaveIfError(err); + CleanupClosePushL(iPositioner); + } + + TTime startTime; + startTime.UniversalTime(); // start the clock + + if(aCold) + { + // Request notify for the expected reference position. + TPositionInfo actualRefPosInfo; + TInt err = DoNotifyUpdateL(actualRefPosInfo); + if (KErrNone != err) + { + INFO_PRINTF2(_L("Failed test, reference position request returned err %d."), err); + SetTestStepResult(EFail); + } + } + TPositionInfo posInfo; + // Get the actual position + TInt err = DoNotifyUpdateL(posInfo); + if (KErrNone != err) + { + INFO_PRINTF2(_L("Failed test, position request returned err %d."), err); + SetTestStepResult(EFail); + } + + TTime endTime; + endTime.UniversalTime(); // stop the clock + TTimeIntervalMicroSeconds interval; + interval = endTime.MicroSecondsFrom(startTime); + INFO_PRINTF2(_L("Request took %d microseconds to complete."), interval.Int64()); + requestTime = requestTime.Int64() + interval.Int64(); + + if(aCold) + { + CleanupStack::PopAndDestroy(&iPositioner); + User::After(KWaitTimeForCoolDown); + } + } + + if(!aCold) + { + // Cleanup. + CleanupStack::PopAndDestroy(&iPositioner); + User::After(KWaitTimeForCoolDown); + } + return requestTime.Int64(); + }