diff -r e8c1ea2c6496 -r 8758140453c0 lbs/lbsclient/src/ctlbsclientstepcellbasednpud.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lbs/lbsclient/src/ctlbsclientstepcellbasednpud.cpp	Thu Jan 21 12:53:44 2010 +0000
@@ -0,0 +1,474 @@
+// 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_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 value
+TTimeIntervalMicroSeconds32 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 value
+TTimeIntervalMicroSeconds32 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("&gt;&gt;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("&lt;&lt;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 network
+void 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);
+		}	
+	}