Changed record separator in delproxy.pl from default to LF.
// 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 "Eclipse Public License v1.0"// which accompanies this distribution, and is available// at the URL "http://www.eclipse.org/legal/epl-v10.html".//// Initial Contributors:// Nokia Corporation - initial contribution.//// Contributors://// Description:// @file ctlbsclientstep_cellbasednpud.cpp// This is the class implementation for the Notify Position Update Tests// //#include "ctlbsclientstepcellbasednpud.h"#include <lbs.h>#include <lbssatellite.h>#include "tlbsutils.h"#include "ctlbsasyncwaiter.h"// constant definitions_LIT(KLbsClientStepCellBasedNotifyPosUpdate, "LbsClientStepCellBasedNotifyPosUpdate");// by default, a test case will abort after this time if all callbacks not completed:// Note that this must be less than the TEF timeout in the script to be of any valueTTimeIntervalMicroSeconds32 KDefaultAbortTimerPeriod = 90*1000000; // 1.5 mins // by default, a test case running with real gps hardware will abort after this time // Note that this must be less than the TEF timeout in the script to be of any valueTTimeIntervalMicroSeconds32 KDefaultAbortTimerPeriod_real = 100*1000000; // 5 mins/** * Destructor */CT_LbsClientStep_CellBasedNotifyPosUpdate::~CT_LbsClientStep_CellBasedNotifyPosUpdate() { iDoPosUpdate->Cancel(); delete iDoPosUpdate; }/** * Constructor */CT_LbsClientStep_CellBasedNotifyPosUpdate::CT_LbsClientStep_CellBasedNotifyPosUpdate(CT_LbsClientServer& aParent) : iParent(aParent) { SetTestStepName(KLbsClientStep_CellBasedNotifyPosUpdate); }/**Static Constructor*/CT_LbsClientStep_CellBasedNotifyPosUpdate* CT_LbsClientStep_CellBasedNotifyPosUpdate::New(CT_LbsClientServer& aParent) { // Can't leave, so return NULL if insufficient memory CT_LbsClientStep_CellBasedNotifyPosUpdate* testStep = new CT_LbsClientStep_CellBasedNotifyPosUpdate(aParent); if (testStep) { TInt err = KErrNone; TRAP(err, testStep->ConstructL()); if (err) { delete testStep; testStep = NULL; } } return testStep; } void CT_LbsClientStep_CellBasedNotifyPosUpdate::ConstructL() { // Create the base class object. CT_LbsNetSimStep::ConstructL(); // Active object wrapper for the notify position update. iDoPosUpdate = CT_LbsDoPosUpdate::NewL(this, TPositionModuleInfo::ETechnologyNetwork); }/** * @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_CellBasedNotifyPosUpdate::doTestStepL() { // Generic test step used to test the LBS Client Notify position update API. INFO_PRINTF1(_L(">>CT_LbsClientStep_CellBasedNotifyPosUpdate::doTestStepL()")); if (TestStepResult()==EPass) // TODO still don't see why we need this... { iNetworkUnavailable = FALSE; iIsCancelTest = FALSE; iCancel = FALSE; iCancelOnPosUpdate = FALSE; iCancelBeforePosUpdate = FALSE; iMultiReq = EFalse; iNumNPUDs = iParent.iSharedData->iVerifyPosInfoArr.Count(); // how many NPUDs to do // Expected callbacks flags iFlagsToHaltOn = KLbsCallback_NetSim_Got_Connect | KLbsCallback_NetworkBasedLocation | KLbsCallback_Got_NotifyPositionUpdate; // notifypositionupdate completed. TTimeIntervalMicroSeconds32 abortInterval; if(iParent.iSharedData->iTestModuleInUse) { abortInterval = KDefaultAbortTimerPeriod; } else { abortInterval = KDefaultAbortTimerPeriod_real; } // Carryout unique test actions. TInt testCaseId; if (GetIntFromConfig(ConfigSection(), KTestCaseId, testCaseId)) { switch (testCaseId) { case 1: // LBS-NotifyPosUpdateCellBased-0001 Request a cell-based location { // nothing to do } break; case 2: // LBS-NotifyPosUpdateCellBased-0002 Request a cell-based location and cancel before it completes { iCancel = ETrue; iFlagsToHaltOn = KLbsCallback_NetSim_Got_Connect | KLbsCallback_Got_NotifyPositionUpdate; } break; case 3: // LBS-NotifyPosUpdateCellBased-0003 Request a cell-based location, when network unavailable { iNetworkUnavailable = ETrue; // TO DO - are these the right flags (get NO NetSIm callbacks while network unavailable)? iFlagsToHaltOn &= ~KLbsCallback_NetworkBasedLocation; } break; case 4: // LBS-NotifyPosUpdateCellBased-0004 multiple sequential npuds { iMultiReq = ETrue; } break; case 5: // LBS-NotifyPosUpdateCellBased-0005 Request a cell-based location and attempt to cancel when the update is received { iCancelOnPosUpdate = ETrue; iFlagsToHaltOn = KLbsCallback_NetSim_Got_Connect | KLbsCallback_Got_NotifyPositionUpdate; } break; case 6: // LBS-NotifyPosUpdateCellBased-0006 Request a cell-based location and cancel before a position update is generated { iCancelBeforePosUpdate = ETrue; iFlagsToHaltOn = KLbsCallback_NetSim_Got_Connect | KLbsCallback_Got_NotifyPositionUpdate; } break; default: User::Panic(KLbsClientStepCellBasedNotifyPosUpdate, KErrUnknown); } } else { User::Panic(KLbsClientStepCellBasedNotifyPosUpdate, KErrUnknown); } iIsCancelTest = (iCancel || iCancelBeforePosUpdate || iCancelOnPosUpdate); // Steps common to all tests: // Connect to net sim iNetSim.ConnectL(this); // Configure NetSim: // Set reference location: RPointerArray<TAny>& srcPosInfoArr = iParent.iSharedData->iVerifyPosInfoArr; TPositionInfo* srcPosInfo = reinterpret_cast<TPositionInfo*>(srcPosInfoArr[0]); TPosition srcPos; srcPosInfo->GetPosition(srcPos); if (!iNetSim.SetReferenceLocation(srcPos)) { INFO_PRINTF1(_L("CT_LbsClientStep_CellBasedNotifyPosUpdate::doTestStepL() Failed: Can't set NetSim's reference location.")); SetTestStepResult(EFail); } // Set plugin to use for getting assistance data: TUid pluginUid; if(iParent.iSharedData->iTestModuleInUse) { pluginUid = TUid::Uid(KSimpleAssistanceDataProviderPluginUidValue); } else { pluginUid = TUid::Uid(KSuplAssistanceDataProviderPluginUidValue); } if (!iNetSim.SetAssistanceDataProvider(pluginUid)) { INFO_PRINTF1(_L("Can't set NetSim's assistance data plugin uid.")); SetTestStepResult(EFail); } // make network unavailable if appropriate: if(iNetworkUnavailable) { // Tell netsim to make network unavailable until further notice: if(!iNetSim.SetResponseError(RLbsNetSimTest::KNetSimNetworkNotAvailable, ETrue)) //sticky { INFO_PRINTF1(_L("CT_LbsClientStep_CellBasedNotifyPosUpdate::doTestStepL() Failed: Can't set NetSim's response error.")); SetTestStepResult(EFail); } } // Kick off the keep alive timer - do last to ensure NetSim is ready otherwise the // timer callback may start a MO-LR if the NetSim connected too early. TTimeIntervalMicroSeconds32 interval(KLbsKeepAlivePeriod); iKeepAliveTimer->SetTimer(interval); // don't wait for TEF to timeout and abort iAbortTimer->SetTimer(abortInterval); // Kick off test. CActiveScheduler::Start(); if(EDone != iState) { INFO_PRINTF2(_L("Failed test, finished in state %d"), iState); INFO_PRINTF3(_L("Callback flags currently set = 0x%x. Expecting 0x%x"), iCallbackFlags, iFlagsToHaltOn); SetTestStepResult(EFail); } else { INFO_PRINTF2(_L("Got all expected callbacks (0x%x)"), iCallbackFlags); } iNetSim.Close(); } INFO_PRINTF1(_L("<<CT_LbsClientStep_CellBasedNotifyPosUpdate::doTestStepL()")); return TestStepResult(); }void CT_LbsClientStep_CellBasedNotifyPosUpdate::Connected() { // Call base implementation. CT_LbsNetSimStep::Connected(); if(iCancelBeforePosUpdate) { TPositionInfo* posInfo = new(ELeave) TPositionInfo(); iDoPosUpdate->StartL(*posInfo); iNumNPUDs--; // Wait for all expected callback flags to be set: iState = CT_LbsNetSimStep::EWaiting; // Cancel the request for the cancel test. iDoPosUpdate->CancelRequest(); delete posInfo; } else { T_LbsUtils utils; // Create a posinfo and store in our shared array for later verification. RPointerArray<TAny>& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr; TPositionInfo* posInfo = new(ELeave) TPositionInfo(); utils.ResetAndDestroy_PosInfoArr(posInfoArr); // Clear previous entries before new entry is appended. posInfoArr.Append(posInfo); iDoPosUpdate->StartL(*posInfo); iNumNPUDs--; // Wait for all expected callback flags to be set: iState = CT_LbsNetSimStep::EWaiting; // Cancel the request for the cancel test. if(iCancel) { User::After((TTimeIntervalMicroSeconds32)100000); // arbitrary delay as workaround for DEF107349 iDoPosUpdate->CancelRequest(); } } }void CT_LbsClientStep_CellBasedNotifyPosUpdate::Disconnected() { // Call base implementation. CT_LbsNetSimStep::Disconnected(); }void CT_LbsClientStep_CellBasedNotifyPosUpdate::NotifyRegisterLcsMoLr(const TDesC& aData) { if (!iIsCancelTest) { // Call base implementation. CT_LbsNetSimStep::NotifyRegisterLcsMoLr(aData); } }void CT_LbsClientStep_CellBasedNotifyPosUpdate::NotifyReleaseLcsMoLr(TInt aReason) { if (!iIsCancelTest) { // Call base implementation. CT_LbsNetSimStep::NotifyReleaseLcsMoLr(aReason); } }// Measurement Control has been received from Network:void CT_LbsClientStep_CellBasedNotifyPosUpdate::NotifyMeasurementControlLocation(const TPositionInfo& aPosition, const RLbsAssistanceDataBuilderSet& aData, const TLbsNetPosRequestQuality& aQuality) { if (!iIsCancelTest) { // Call base implementation. CT_LbsNetSimStep::NotifyMeasurementControlLocation(aPosition, aData, aQuality); } }void CT_LbsClientStep_CellBasedNotifyPosUpdate::NotifyReleaseLcsLocationNotification(const CLbsNetworkProtocolBase::TLbsPrivacyResponse& aResult) { if (!iIsCancelTest) { // Call base implementation. CT_LbsNetSimStep::NotifyReleaseLcsLocationNotification(aResult); } }void CT_LbsClientStep_CellBasedNotifyPosUpdate::NotifyFacilityLcsMoLrResult(TInt aReason, const TPositionInfo& aPosition) { if (!iIsCancelTest) { // Call base implementation. CT_LbsNetSimStep::NotifyFacilityLcsMoLrResult(aReason, aPosition); } }// Our position has been reported to networkvoid CT_LbsClientStep_CellBasedNotifyPosUpdate::NotifyMeasurementReportLocation(const TPositionInfo& aPosition) { if(iCancelOnPosUpdate) { iDoPosUpdate->CancelRequest(); } if (!iIsCancelTest) { // Call base implementation. CT_LbsNetSimStep::NotifyMeasurementReportLocation(aPosition); } }void CT_LbsClientStep_CellBasedNotifyPosUpdate::NotifyMeasurementReportRequestMoreAssistanceData(const TLbsAssistanceDataGroup& aFilter) { if (!iIsCancelTest) { // Call base implementation. CT_LbsNetSimStep::NotifyMeasurementReportRequestMoreAssistanceData(aFilter); } }void CT_LbsClientStep_CellBasedNotifyPosUpdate::NotifyMeasurementReportControlFailure(TInt aReason) { if (!iIsCancelTest && !iMultiReq) { // Call base implementation. CT_LbsNetSimStep::NotifyMeasurementReportControlFailure(aReason); } else if (iMultiReq && ! ((aReason == KErrPositionHighPriorityReceive) || (aReason == KErrServerBusy))) { INFO_PRINTF2(_L("FAILED: NotifyMeasurementReportControlFailure with reason = %d"), aReason); SetTestStepResult(EFail); } }void CT_LbsClientStep_CellBasedNotifyPosUpdate::NotifyError(MLbsNetSimTestObserver::EFunction aFunction, int aError) { // Call base implementation. CT_LbsNetSimStep::NotifyError(aFunction, aError); }void CT_LbsClientStep_CellBasedNotifyPosUpdate::ProcessMeasurementControlLocationError(TInt aError) { // Call base implementation. CT_LbsNetSimStep::ProcessMeasurementControlLocationError(aError); }/** Notify position update callback.*/void CT_LbsClientStep_CellBasedNotifyPosUpdate::MT_LbsDoPosUpdateCallback(TRequestStatus& aStatus) { TInt err = aStatus.Int(); INFO_PRINTF2(_L("CT_LbsClientStep_CellBasedNotifyPosUpdate::MT_LbsDoPosUpdateCallback: Got - Notify Update - Callback Event. Error = %d"), err); if(!iNumNPUDs) // only set the flag when we've got them all { SetCallbackFlag(KLbsCallback_Got_NotifyPositionUpdate); } if(iNetworkUnavailable) { if(KErrTimedOut != err && KErrDisconnected != err) { INFO_PRINTF2(_L("FAILED: MT_LbsDoPosUpdateCallback with error %d, expecting KErrTimedOut"), err); SetTestStepResult(EFail); } } else { if(iCancel) { if(KErrCancel != err && KErrNone != err) { INFO_PRINTF2(_L("FAILED: MT_LbsDoPosUpdateCallback with error = %d"), err); SetTestStepResult(EFail); } } else { if(iCancelBeforePosUpdate) { if(KErrCancel != err) { INFO_PRINTF2(_L("FAILED: MT_LbsDoPosUpdateCallback with error = %d"), err); SetTestStepResult(EFail); } } else { if(KErrNone != err) { INFO_PRINTF2(_L("FAILED: MT_LbsDoPosUpdateCallback with error = %d"), err); SetTestStepResult(EFail); } } } } if(iNumNPUDs--) { // Create another posinfo and store in our shared array for later verification. RPointerArray<TAny>& posInfoArr = iParent.iSharedData->iCurrentPosInfoArr; TPositionInfo* posInfo = new(ELeave) TPositionInfo(); posInfoArr.Append(posInfo); iDoPosUpdate->StartL(*posInfo); } }