diff -r 000000000000 -r 9cfd9a3ee49c lbstest/lbstestproduct/lbshybridcombined/src/ctlbsnetprotocol.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lbstest/lbstestproduct/lbshybridcombined/src/ctlbsnetprotocol.cpp	Tue Feb 02 01:50:39 2010 +0200
@@ -0,0 +1,1050 @@
+// 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 "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:
+// This is the class implementation for the Module Information Tests
+// 
+//
+
+
+// LBS includes. 
+#include <lbssatellite.h>
+#include <lbs/lbsnetprotocolbase.h>
+#include <lbs/lbsassistancedatabuilderset.h>
+#include <e32math.h>
+#include <lbs/lbsloccommon.h>
+#include <lbs/lbsx3p.h>
+#include <lbs/lbsnetprotocolbase.h>
+#include <lbs/lbslocdatasourceclasstypes.h>
+#include <lbs/lbslocdatasourcegpsbase.h>
+#include <e32property.h>
+#include <lbs/lbslocerrors.h>
+#include "lbsnetinternalapi.h"
+#include "LbsInternalInterface.h"
+#include "LbsExtendModuleInfo.h"
+#include "lbsdevloggermacros.h"
+
+// LBS test includes.
+#include "ctlbsnetprotocol.h"
+#include <lbs/test/tlbsutils.h>
+#include "argutils.h"
+
+#include <lbs/test/activeyield.h>
+
+const TInt KTimeOut = 2*1000*1000; // 2 secs
+const TInt KSmallTimeOut = 500*1000; // 0.5 secs
+const TInt KDelta = 1000;
+const TInt KT = 2 * 1000 * 1000; // 2 secs.
+const TInt KAlphaTimer = ArgUtils::Alpha2()/12;
+
+/**
+Static Constructor
+*/
+CT_LbsNetProtocol* CT_LbsNetProtocol::NewL(MTestFlowObserver& aObserver, CTestStep& aStep)
+	{
+	CT_LbsNetProtocol* self = new CT_LbsNetProtocol(aObserver, aStep);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+void CT_LbsNetProtocol::StartNetworkL()
+	{
+	iProxy->WaitForResponseL(KTimeOut, iStatus);
+	SetActive();
+	iObserver.OnSignalNetworkStep(iRelativeSessionId, iNetworkProtocolProxyStep);
+	}
+
+void CT_LbsNetProtocol::SignalClientsFinished()
+	{
+	iClientsFinished = ETrue;
+	}
+
+CT_LbsNetProtocol::TPlannedPositionOriginator CT_LbsNetProtocol::PlannedPositionOriginator()
+	{
+	return iPlannedPositionOriginator;
+	}
+
+void CT_LbsNetProtocol::SetPlannedPositionOriginator(TInt aOriginator)
+	{
+	iPlannedPositionOriginator = static_cast<TPlannedPositionOriginator>(aOriginator);
+	iStep.TEST(iPlannedPositionOriginator != EPositionOriginatorUnkown);
+	}
+
+
+void CT_LbsNetProtocol::SetNetworkMethod(TInt aMethod)
+	{
+	iNetworkMethod = static_cast<TChosenNetworkMethod>(aMethod);
+	iStep.TEST(iNetworkMethod != ENetworkMethodNotSet);
+	}
+
+
+/**
+ * Constructor
+ */
+CT_LbsNetProtocol::CT_LbsNetProtocol(MTestFlowObserver& aObserver, CTestStep& aStep) 
+	: CActive(EPriorityHigh), iObserver(aObserver), iStep(aStep), iNetworkMethod(ENetworkMethodNotSet), 
+		iNetworkProtocolProxyStep(ENetworkProtocolProxyStepInitial), iRelativeSessionId(0), 
+		iClientsFinished(EFalse), iPlannedPositionOriginator(EPositionOriginatorUnkown)
+	{
+	iSessionId.SetSessionOwner(KRequestUid);
+	iSessionId.SetSessionNum(0x0001);
+	CActiveScheduler::Add(this);
+	}
+
+
+void CT_LbsNetProtocol::ConstructL()
+	{
+	iProxy = CNetProtocolProxy::NewL();
+	}
+
+/**
+ * Destructor
+ */
+CT_LbsNetProtocol::~CT_LbsNetProtocol()
+	{
+	Cancel();
+	delete iProxy;
+	}
+
+TLbsNetPosRequestMethod CT_LbsNetProtocol::RequestNetworkMethod()
+/**
+ This method will chose the appropiate method requested by the network, depending 
+ on the test settings
+ 
+ @return The network method
+ */
+	{
+	TLbsNetPosRequestMethod method;
+	switch(iNetworkMethod)
+		{
+		case ETerminalBasedNetworkMethod:
+			{
+			iStep.INFO_PRINTF1(_L("The network requests TB"));
+			iNetworkExpectsPositions = ETrue;
+			method = ArgUtils::RequestTerminalBasedMethod();
+			break;
+			}
+		case ETerminalBasedTerminalAssistedNetworkMethod:
+			{
+			iStep.INFO_PRINTF1(_L("The network requests hybrid"));
+			iNetworkExpectsMeasurments = ETrue;
+			iNetworkExpectsPositions = ETrue;
+			method = ArgUtils::RequestHybridMethod();
+			break;
+			}
+		case ETerminalAssistedNetworkMethod:
+			{
+			iStep.INFO_PRINTF1(_L("The network requests TAP"));
+			iNetworkExpectsMeasurments = ETrue;
+			method = ArgUtils::RequestTAPMethod();
+			break;
+			}
+		case ETerminalAssistedTerminalBasedNetworkMethod:
+			{
+			iStep.INFO_PRINTF1(_L("The network requests hybrid"));
+			iNetworkExpectsMeasurments = ETrue;
+			iNetworkExpectsPositions = ETrue;
+			method = ArgUtils::RequestTerminalAssistedAndTerminalBasedMethod();
+			break;
+			}
+		default:
+			{
+			User::Invariant();
+			}
+		}
+	return method;
+	}
+
+void CT_LbsNetProtocol::DecideWhatNetworkDoesntReceive()
+/**
+ This method checks what the module was finally set to and decides if the network 
+ should not expect measuments, or positions
+ */
+	{
+	TLbsGpsOptionsArray options;
+	TPckg<TLbsGpsOptionsArray> pckgOptions(options);
+	iStep.TEST(KErrNone == RProperty::Get(KUidSystemCategory, ELbsTestAGpsModuleModeChanges,pckgOptions));
+
+	if(options.ClassType() & ELbsGpsOptionsArrayClass)
+		{ 
+		if(options.NumOptionItems() > 1)
+			{// don't change anything, the module is running in hybrid
+			iStep.INFO_PRINTF1(_L("The module is running in hybrid"));
+			return;
+			}
+		}
+	switch(options.GpsMode())
+		{
+		case CLbsAdmin::EGpsAutonomous:
+			{
+			iNetworkExpectsPositions = EFalse;
+			iNetworkExpectsMeasurments = EFalse;
+			iStep.INFO_PRINTF1(_L("The module is running in autonomous"));
+			break;
+			}
+		case CLbsAdmin::EGpsPreferTerminalBased:
+		case CLbsAdmin::EGpsAlwaysTerminalBased:
+			{
+			iStep.INFO_PRINTF1(_L("The module is running in terminal based"));
+			iNetworkExpectsMeasurments = EFalse;
+			break;
+			}
+		case CLbsAdmin::EGpsPreferTerminalAssisted:
+		case CLbsAdmin::EGpsAlwaysTerminalAssisted:
+			{
+			iStep.INFO_PRINTF1(_L("The module is running in terminal assisted"));
+			iNetworkExpectsPositions = EFalse;
+			break;
+			}
+		default:
+			{
+			// change nothing
+			}
+		return;
+		}
+	}
+
+
+
+void CT_LbsNetProtocol::Process_RequestSelfLocationL()
+	{
+	// >> RequestSelfLocation()
+	iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RequestSelfLocation()"));
+	TLbsNetSessionId* sessionId = NULL;
+	TLbsNetPosRequestOptionsAssistance*	opts = NULL;
+	TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestSelfLocation, &sessionId, &opts);
+	++iRelativeSessionId;
+	iSessionId.SetSessionNum(sessionId->SessionNum());
+	iSessionId.SetSessionOwner(sessionId->SessionOwner());
+
+	iStep.INFO_PRINTF2(_L("NetworkProtocolProxy >> RequestSelfLocation() mode = 0x%x"), opts->PosMode());
+	if(opts->PosMode() == TPositionModuleInfo::ETechnologyTerminal)	// autonomous request, just complete the session
+		{
+		// << ProcessSessionComplete()
+		TInt reason = KErrNone;
+		iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessSessionComplete()"));			
+		iProxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason);
+
+		// << ProcessStatusUpdate()
+		MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask = MLbsNetworkProtocolObserver::EServiceNone;	
+		iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessStatusUpdate(EServiceNone)"));			
+		iProxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask);						
+		iNetworkProtocolProxyStep = ENetworkProtocolProxyStepNoSessionRunning;
+		}					
+	else
+		{
+		// << ProcessStatusUpdate(EServiceSelfLocation)
+		iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessStatusUpdate(EServiceSelfLocation)"));
+		MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask1 = MLbsNetworkProtocolObserver::EServiceSelfLocation;
+		iProxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask1);
+
+		if(opts->DataRequestMask() != EAssistanceDataNone)
+			{
+			// << ProcessAssistanceData()
+			iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessAssistanceData"));
+			TLbsAsistanceDataGroup dataMask = EAssistanceDataReferenceTime;
+			RLbsAssistanceDataBuilderSet assistanceData;
+			ArgUtils::PopulateLC(assistanceData);
+			TInt reason = KErrNone;
+			iProxy->CallL(ENetMsgProcessAssistanceData, &dataMask, &assistanceData, &reason);
+			CleanupStack::PopAndDestroy(&assistanceData);
+			}
+
+		// << ProcessLocationRequest()
+		iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessLocationRequest"));			
+		TBool emergency = EFalse;
+		MLbsNetworkProtocolObserver::TLbsNetProtocolService	service = MLbsNetworkProtocolObserver::EServiceSelfLocation;
+		TLbsNetPosRequestQuality quality = ArgUtils::Quality();
+		quality.SetMaxFixTime(KAlphaTimer);
+		TLbsNetPosRequestMethod method  = RequestNetworkMethod();
+		iProxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method);
+		
+		// Now that the hybrid/alpha2 has been requested, record current time to verify alpha2 timer expires correctly.
+		iAlpha2StartTime.HomeTime();
+		
+		iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionNrhRequestSent;
+		}	
+	CleanupStack::PopAndDestroy(cleanupCnt);
+	}
+
+void CT_LbsNetProtocol::RunL()
+	{
+	TInt response(iStatus.Int());
+	switch(iNetworkProtocolProxyStep)
+		{
+		case ENetworkProtocolProxyStepInitial:
+			{
+			switch(response)
+				{
+				case ENetMsgCancelSelfLocation:
+					{
+					// >> CancelSelfLocation()
+					iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> CancelSelfLocation() for an older session"));
+					iProxy->WaitForResponseL(KTimeOut, iStatus);
+					SetActive();
+					break;
+					}
+				case ENetMsgGetCurrentCapabilitiesResponse:
+					{
+					// >> AdviceSystemStatus()
+					CLbsNetworkProtocolBase::TLbsSystemStatus status;
+					TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status);
+					iStep.TESTL(status == CLbsNetworkProtocolBase::ESystemStatusNone || status == CLbsNetworkProtocolBase::ESystemStatusClientTracking);
+					if(status == CLbsNetworkProtocolBase::ESystemStatusClientTracking)
+						{
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusClientTracking)"));
+						}
+					else if(status == CLbsNetworkProtocolBase::ESystemStatusNone)
+						{
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusNone)"));
+						}
+					CleanupStack::PopAndDestroy(cleanupCnt);
+					
+					iNetworkProtocolProxyStep = ENetworkProtocolProxyStepNoSessionRunning;
+					iProxy->WaitForResponseL(KTimeOut, iStatus);
+					SetActive();
+					break;
+					}
+				case ENetMsgRequestAssistanceData:
+					{
+					// >> RequestAssistanceData(0)
+					iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RequestAssistanceData(0)"));
+					TLbsAsistanceDataGroup dataMask;
+					TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
+					iStep.TESTL(dataMask == EAssistanceDataNone);
+					CleanupStack::PopAndDestroy(cleanupCnt);
+					
+					iNetworkProtocolProxyStep = ENetworkProtocolProxyStepNoSessionRunning;
+					iProxy->WaitForResponseL(KTimeOut, iStatus);
+					SetActive();
+					break;
+					}
+				case ENetMsgTimeoutExpired:
+					{ // can happen that no request has been sent through, so start waiting again
+					if(iClientsFinished)
+						{
+						iObserver.StopTest();						
+						}
+					else
+						{
+						iProxy->WaitForResponseL(KTimeOut, iStatus);
+						SetActive();
+						}
+					break;
+					}
+				case ENetMsgRequestSelfLocation:
+					{
+					Process_RequestSelfLocationL();
+					iProxy->WaitForResponseL(KTimeOut, iStatus);
+					SetActive();
+					break;
+					}
+				default:
+					{
+					iStep.INFO_PRINTF2(_L("Network in state ENetworkProtocolProxyStepInitial received unexpected response: %d"), response);
+					User::Leave(KErrNotSupported);
+					}
+				}
+			break;
+			}
+
+		case ENetworkProtocolProxyStepSessionNrhRequestSent:
+			{
+			switch(response)
+				{
+				case ENetMsgRequestAssistanceData:
+					{
+					// >> RequestAssistanceData(0)
+					iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RequestAssistanceData(0)"));
+					TLbsAsistanceDataGroup dataMask;
+					TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
+					iStep.TESTL(dataMask == EAssistanceDataNone);
+					CleanupStack::PopAndDestroy(cleanupCnt);
+
+					DecideWhatNetworkDoesntReceive();
+					
+					if(iNetworkExpectsMeasurments)
+						{ // measurements should be sent to the network
+						// Determine the value to take off the alpha2 value. This is required because we had to wait for the assistance data response.
+						TTimeIntervalMicroSeconds microseconds;
+						TTime stopTime;
+						stopTime.HomeTime();
+						microseconds = stopTime.MicroSecondsFrom(iAlpha2StartTime); 
+						TInt64 timeElapsed = microseconds.Int64();
+
+						// Test that we do not get response before alpha2 has expired:
+						TInt timeOut = KAlphaTimer - timeElapsed - KDelta > 0 ? KAlphaTimer - timeElapsed - KDelta : 0;
+						iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionWaitingForFirstMeasurmentsTimeOut;
+						iProxy->WaitForResponseL(timeOut, iStatus);
+						SetActive();
+						}
+					else
+						{
+						iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionMeasurmentsReceived;
+						iProxy->WaitForResponseL(KTimeOut, iStatus);
+						SetActive();
+						}
+
+					break;
+					}
+				case ENetMsgCancelSelfLocation:
+					{
+					// >> CancelSelfLocation()
+					TLbsNetSessionId* sessionId = NULL;
+					TInt cancelReason = KErrNone;
+					TInt cleanupCnt;
+					
+					cleanupCnt = iProxy->GetArgsLC(ENetMsgCancelSelfLocation, &sessionId, &cancelReason);
+					if(sessionId->SessionNum() == iSessionId.SessionNum())
+						{ // should complete the session
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> CancelSelfLocation()"));
+						CleanupStack::PopAndDestroy(cleanupCnt);
+						
+						// << ProcessSessionComplete()
+						TInt reason = KErrNone;
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessSessionComplete()"));			
+						iProxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason);
+
+						// << ProcessStatusUpdate()
+						MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask2 = MLbsNetworkProtocolObserver::EServiceNone;	
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessStatusUpdate(EServiceNone)"));			
+						iProxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask2);
+
+						iNetworkProtocolProxyStep = ENetworkProtocolProxyStepNoSessionRunning;
+						iProxy->WaitForResponseL(KTimeOut, iStatus);
+						SetActive();						
+						}
+					else
+						{
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> CancelSelfLocation() for an older session"));
+						iStep.TESTL(sessionId->SessionNum() < iSessionId.SessionNum());
+						CleanupStack::PopAndDestroy(cleanupCnt);
+						sessionId = NULL;
+		
+						iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionWaitingForFirstMeasurments;
+						iProxy->WaitForResponseL(KTimeOut, iStatus);
+						SetActive();
+						}
+					break;
+					}
+				case ENetMsgGetCurrentCapabilitiesResponse:
+					{
+					// >> AdviceSystemStatus()
+					CLbsNetworkProtocolBase::TLbsSystemStatus status;
+					TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status);
+					if(status == CLbsNetworkProtocolBase::ESystemStatusClientTracking)
+						{
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusClientTracking)"));
+						}
+					else if(status == CLbsNetworkProtocolBase::ESystemStatusNone)
+						{
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusNone)"));
+						}
+					else
+						{
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus() with wrong status"));
+						User::Leave(KErrNotSupported);
+						}
+					CleanupStack::PopAndDestroy(cleanupCnt);
+					
+					iProxy->WaitForResponseL(KSmallTimeOut, iStatus);
+					SetActive();
+					break;
+					}					
+				case ENetMsgRequestSelfLocation:
+					{
+					Process_RequestSelfLocationL();
+					iProxy->WaitForResponseL(KTimeOut, iStatus);
+					SetActive();
+					break;
+					}
+				default:
+					{
+					iStep.INFO_PRINTF2(_L("Network in state ENetworkProtocolProxyStepSessionNrhRequestSent received unexpected response: %d"), response);
+					User::Leave(KErrNotSupported);
+					}
+				}
+			break;
+			}
+		case ENetworkProtocolProxyStepSessionWaitingForFirstMeasurmentsTimeOut:
+			{
+			switch(response)
+				{
+				case ENetMsgRequestAssistanceData:
+					{
+					// >> RequestAssistanceData(0)
+					iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RequestAssistanceData(0)"));
+					TLbsAsistanceDataGroup dataMask;
+					TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
+					iStep.TESTL(dataMask == EAssistanceDataNone);
+					CleanupStack::PopAndDestroy(cleanupCnt);
+					
+					TTimeIntervalMicroSeconds microseconds;
+					TTime stopTime;
+					stopTime.HomeTime();
+					microseconds = stopTime.MicroSecondsFrom(iAlpha2StartTime); 
+					TInt64 timeElapsed = microseconds.Int64();
+
+					// Test that we do not get response before alpha2 has expired:
+					TInt timeOut = KAlphaTimer - timeElapsed - KDelta > 0 ? KAlphaTimer - timeElapsed - KDelta : 0;
+					iProxy->WaitForResponseL(timeOut, iStatus);
+					SetActive();
+					break;
+					}
+				case ENetMsgGetCurrentCapabilitiesResponse:
+					{
+					// >> AdviceSystemStatus()
+					CLbsNetworkProtocolBase::TLbsSystemStatus status;
+					TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status);
+					if(status == CLbsNetworkProtocolBase::ESystemStatusClientTracking)
+						{
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusClientTracking)"));
+						}
+					else if(status == CLbsNetworkProtocolBase::ESystemStatusNone)
+						{
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusNone)"));
+						}
+					else
+						{
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus() with wrong status"));
+						User::Leave(KErrNotSupported);
+						}
+					CleanupStack::PopAndDestroy(cleanupCnt);
+					
+					TTimeIntervalMicroSeconds microseconds;
+					TTime stopTime;
+					stopTime.HomeTime();
+					microseconds = stopTime.MicroSecondsFrom(iAlpha2StartTime); 
+					TInt64 timeElapsed = microseconds.Int64();
+
+					// Test that we do not get response before alpha2 has expired:
+					TInt timeOut = KAlphaTimer - timeElapsed - KDelta > 0 ? KAlphaTimer - timeElapsed - KDelta : 0;
+					iProxy->WaitForResponseL(timeOut, iStatus);
+					SetActive();
+					break;
+					}
+				case ENetMsgCancelSelfLocation:
+					{
+					// >> CancelSelfLocation()
+					TLbsNetSessionId* sessionId = NULL;
+					TInt cancelReason = KErrNone;
+					TInt cleanupCnt;
+					
+					cleanupCnt = iProxy->GetArgsLC(ENetMsgCancelSelfLocation, &sessionId, &cancelReason);
+					if(sessionId->SessionNum() == iSessionId.SessionNum())
+						{ // should complete the session
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> CancelSelfLocation()"));
+						CleanupStack::PopAndDestroy(cleanupCnt);
+						
+						// << ProcessSessionComplete()
+						TInt reason = KErrNone;
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessSessionComplete()"));			
+						iProxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason);
+
+						// << ProcessStatusUpdate()
+						MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask2 = MLbsNetworkProtocolObserver::EServiceNone;	
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessStatusUpdate(EServiceNone)"));			
+						iProxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask2);
+
+						iNetworkProtocolProxyStep = ENetworkProtocolProxyStepNoSessionRunning;
+						iProxy->WaitForResponseL(KTimeOut, iStatus);
+						SetActive();						
+						}
+					else
+						{
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> CancelSelfLocation() for an older session"));
+						iStep.TESTL(sessionId->SessionNum() < iSessionId.SessionNum());
+						CleanupStack::PopAndDestroy(cleanupCnt);
+						sessionId = NULL;
+		
+						TTimeIntervalMicroSeconds microseconds;
+						TTime stopTime;
+						stopTime.HomeTime();
+						microseconds = stopTime.MicroSecondsFrom(iAlpha2StartTime); 
+						TInt64 timeElapsed = microseconds.Int64();
+	
+						// Test that we do not get response before alpha2 has expired:
+						TInt timeOut = KAlphaTimer - timeElapsed - KDelta > 0 ? KAlphaTimer - timeElapsed - KDelta : 0;
+						iProxy->WaitForResponseL(timeOut, iStatus);
+						SetActive();
+						}
+					break;
+					}
+				case ENetMsgTimeoutExpired:
+					{
+					// >> Alpha2 timeout
+					iStep.INFO_PRINTF1(_L("NetworkProtocolProxy - Network expecting measurements after timeout"));
+					
+					iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionWaitingForFirstMeasurments;
+					iProxy->WaitForResponseL(2 * 1000* KDelta, iStatus);
+					SetActive();
+					break;
+					}
+				case ENetMsgRespondLocationRequest:
+					{ // If the module sends an accurate enough position then the Alpha2 timer might not time-out so check we received positions
+					// >> RespondLocationRequest(gpspos)
+					iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RespondLocationRequest(gpspos)"));
+					RequestNetworkMethod();
+					DecideWhatNetworkDoesntReceive();
+					iStep.TESTL(iNetworkExpectsPositions);
+					TLbsNetSessionId* sessionId = NULL;
+					TPositionInfo* positionInfo = NULL;
+					TInt reason;
+					TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &positionInfo);
+					
+					// check it is a position
+					iStep.TESTL(positionInfo->PositionClassType() == (EPositionInfoClass|EPositionCourseInfoClass|EPositionSatelliteInfoClass|EPositionExtendedSatelliteInfoClass));
+					iStep.TESTL(sessionId->SessionNum() == iSessionId.SessionNum());
+					iStep.TESTL(reason == KErrNone);
+					
+					// << ProcessLocationUpdate(FNP)
+					iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessLocationUpdate(SessionId, FinalNetworkPosition)"));
+					iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, positionInfo);
+					CleanupStack::PopAndDestroy(cleanupCnt);
+
+					iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionPositionSent;
+					iProxy->WaitForResponseL(KSmallTimeOut, iStatus);
+					SetActive();
+					break;
+					}
+				default:
+					{
+					iStep.INFO_PRINTF2(_L("Network in state ENetworkProtocolProxyStepSessionWaitingForFirstMeasurmentsTimeOut received unexpected response: %d"), response);
+					User::Leave(KErrNotSupported);
+					}
+				}
+			break;
+			}
+		case ENetworkProtocolProxyStepSessionWaitingForFirstMeasurments:
+			{
+			switch(response)
+				{
+				case ENetMsgRequestAssistanceData:
+					{
+					// >> RequestAssistanceData(0)
+					iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RequestAssistanceData(0)"));
+					TLbsAsistanceDataGroup dataMask;
+					TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
+					iStep.TESTL(dataMask == EAssistanceDataNone);
+					CleanupStack::PopAndDestroy(cleanupCnt);
+					
+					iProxy->WaitForResponseL(KTimeOut, iStatus);
+					SetActive();
+					break;
+					}
+				case ENetMsgCancelSelfLocation:
+					{
+					// >> CancelSelfLocation()
+					TLbsNetSessionId* sessionId = NULL;
+					TInt cancelReason = KErrNone;
+					TInt cleanupCnt;
+					
+					cleanupCnt = iProxy->GetArgsLC(ENetMsgCancelSelfLocation, &sessionId, &cancelReason);
+					if(sessionId->SessionNum() == iSessionId.SessionNum())
+						{ // should complete the session
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> CancelSelfLocation()"));
+						CleanupStack::PopAndDestroy(cleanupCnt);
+						
+						// << ProcessSessionComplete()
+						TInt reason = KErrNone;
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessSessionComplete()"));			
+						iProxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason);
+
+						// << ProcessStatusUpdate()
+						MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask2 = MLbsNetworkProtocolObserver::EServiceNone;	
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessStatusUpdate(EServiceNone)"));			
+						iProxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask2);
+
+						iNetworkProtocolProxyStep = ENetworkProtocolProxyStepNoSessionRunning;
+						iProxy->WaitForResponseL(KTimeOut, iStatus);
+						SetActive();						
+						}
+					else
+						{
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> CancelSelfLocation() for an older session"));
+						iStep.TESTL(sessionId->SessionNum() < iSessionId.SessionNum());
+						CleanupStack::PopAndDestroy(cleanupCnt);
+						sessionId = NULL;
+		
+						iProxy->WaitForResponseL(KTimeOut, iStatus);
+						SetActive();
+						}
+					break;
+					}
+				case ENetMsgRespondLocationRequest:
+					{
+					// >> RespondLocationRequest(meas)
+					TLbsNetSessionId* sessionId = NULL;
+					TPositionInfo* positionInfo = NULL;
+					TInt reason;
+					TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &positionInfo);
+					RequestNetworkMethod();
+					DecideWhatNetworkDoesntReceive();
+
+					// check it is a position
+					if(positionInfo->PositionClassType() == EPositionGpsMeasurementInfoClass)
+						{
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RespondLocationRequest(meas)"));
+						iStep.TESTL(iNetworkExpectsMeasurments);
+						iStep.TESTL(sessionId->SessionNum() == iSessionId.SessionNum());	// module sends NAN measurement first
+						if(reason != KErrNone)
+							{
+							iStep.INFO_PRINTF2(_L("NetworkProtocolProxy reason = 0x%x"), reason);
+							}
+						iStep.TESTL(reason == KErrNone);
+						CleanupStack::PopAndDestroy(cleanupCnt);
+						if(iPlannedPositionOriginator == EPositionOriginatorModule)
+							{
+							if(iNetworkExpectsPositions)
+								{
+								// << ProcessLocationRequest(SessionId, HybridMode, t)
+								iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessLocationRequest(SessionId, HybridMode, t)"));
+								TBool emergency = EFalse;
+								MLbsNetworkProtocolObserver::TLbsNetProtocolService	service = MLbsNetworkProtocolObserver::EServiceSelfLocation;
+								TLbsNetPosRequestQuality quality = ArgUtils::Quality();
+								quality.SetMaxFixTime(KT);
+								TLbsNetPosRequestMethod method  = RequestNetworkMethod();
+								iProxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method);
+			
+								iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionMeasurmentsReceived;
+								iProxy->WaitForResponseL(KTimeOut, iStatus);
+								SetActive();
+								}
+							else
+								{
+								iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionPositionSent;
+								iProxy->WaitForResponseL(KSmallTimeOut, iStatus);
+								SetActive();
+								}
+							}
+						else if(iPlannedPositionOriginator == EPositionOriginatorNetwork)
+							{
+							TPositionInfo positionInfo = ArgUtils::AccurateNetworkPositionInfo();
+							// << ProcessLocationUpdate(SessionId, FinalNetworkPosition)
+							// Return FinalNetworkPosition
+							iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessLocationUpdate(SessionId, FNP)"));
+							iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, &positionInfo);
+							
+							iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionPositionSent;
+							iProxy->WaitForResponseL(KSmallTimeOut, iStatus);
+							SetActive();
+							}
+						}
+					else
+						{
+						// >> RespondLocationRequest(gpspos)
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RespondLocationRequest(gpspos)"));
+						// check it is a position
+						iStep.TESTL(positionInfo->PositionClassType() == (EPositionInfoClass|EPositionCourseInfoClass|EPositionSatelliteInfoClass));
+						iStep.TESTL(sessionId->SessionNum() == iSessionId.SessionNum());
+						iStep.INFO_PRINTF3(_L("NetworkProtocolProxy reason = %d(0x%x)"), reason,reason);
+						if(reason != KErrPositionNoGpsUpdate)
+							{
+							iStep.TESTL(reason == KErrNone);
+							}
+						iStep.TESTL(iNetworkExpectsPositions);
+						
+						// << ProcessLocationUpdate(FNP)
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessLocationUpdate(SessionId, FinalNetworkPosition)"));
+						iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, positionInfo);
+						CleanupStack::PopAndDestroy(cleanupCnt);
+
+						iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionPositionSent;
+						iProxy->WaitForResponseL(KSmallTimeOut, iStatus);
+						SetActive();
+						}
+					break;
+					}
+				default:
+					{
+					iStep.INFO_PRINTF2(_L("Network in state ENetworkProtocolProxyStepSessionWaitingForFirstMeasurments received unexpected response: %d"), response);
+					User::Leave(KErrNotSupported);
+					}
+				}
+			break;
+			}
+		case ENetworkProtocolProxyStepSessionMeasurmentsReceived:
+			{
+			switch(response)
+				{
+				case ENetMsgRequestAssistanceData:
+					{
+					// >> RequestAssistanceData(0)
+					iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RequestAssistanceData(0)"));
+					TLbsAsistanceDataGroup dataMask;
+					TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
+					iStep.TESTL(dataMask == EAssistanceDataNone);
+					CleanupStack::PopAndDestroy(cleanupCnt);
+					
+					iProxy->WaitForResponseL(KTimeOut, iStatus);
+					SetActive();
+					break;
+					}
+				case ENetMsgRespondLocationRequest:
+					{ // If the module sends an accurate enough position then the Alpha2 timer might not time-out so check we received positions
+					// >> RespondLocationRequest(gpspos/meas)
+					TLbsNetSessionId* sessionId = NULL;
+					TPositionInfo* positionInfo = NULL;
+					TInt reason;
+					TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRespondLocationRequest, &sessionId, &reason, &positionInfo);
+					RequestNetworkMethod();
+					DecideWhatNetworkDoesntReceive();
+					
+					// check it is a position
+					if(positionInfo->PositionClassType() == EPositionGpsMeasurementInfoClass)
+						{ // received more measurments
+						// >> RespondLocationRequest(meas)
+						iStep.TESTL(iNetworkExpectsMeasurments);
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RespondLocationRequest(meas)"));
+						iStep.TESTL(iNetworkExpectsMeasurments);
+						iStep.TESTL(sessionId->SessionNum() == iSessionId.SessionNum());	// module sends NAN measurement first
+						if(reason != KErrNone)
+							{
+							iStep.INFO_PRINTF2(_L("NetworkProtocolProxy reason = 0x%x"), reason);
+							}
+						iStep.TESTL(reason == KErrNone);
+						iStep.TESTL(iPlannedPositionOriginator == EPositionOriginatorModule);
+						iStep.TESTL(iNetworkExpectsPositions);
+						// << ProcessLocationRequest(SessionId, HybridMode, t)
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessLocationRequest(SessionId, HybridMode, t)"));
+						TBool emergency = EFalse;
+						MLbsNetworkProtocolObserver::TLbsNetProtocolService	service = MLbsNetworkProtocolObserver::EServiceSelfLocation;
+						TLbsNetPosRequestQuality quality = ArgUtils::Quality();
+						quality.SetMaxFixTime(KT);
+						TLbsNetPosRequestMethod method  = RequestNetworkMethod();
+						iProxy->CallL(ENetMsgProcessLocationRequest, &iSessionId, &emergency, &service, &quality, &method);
+	
+						iProxy->WaitForResponseL(KTimeOut, iStatus);
+						SetActive();
+						}
+					else
+						{ // received a position
+						iStep.TESTL(iNetworkExpectsPositions);
+						iStep.TESTL(positionInfo->PositionClassType() == (EPositionInfoClass|EPositionCourseInfoClass|EPositionSatelliteInfoClass));
+						iStep.TESTL(sessionId->SessionNum() == iSessionId.SessionNum());
+						iStep.TESTL(reason == KErrNone);
+						
+						// << ProcessLocationUpdate(FNP)
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessLocationUpdate(SessionId, FinalNetworkPosition)"));
+						iProxy->CallL(ENetMsgProcessLocationUpdate, &iSessionId, positionInfo);
+
+						iNetworkProtocolProxyStep = ENetworkProtocolProxyStepSessionPositionSent;
+						iProxy->WaitForResponseL(KSmallTimeOut, iStatus);
+						SetActive();
+						}
+					CleanupStack::PopAndDestroy(cleanupCnt);
+					break;
+					}
+				default:
+					{
+					iStep.INFO_PRINTF2(_L("Network in state ENetworkProtocolProxyStepSessionMeasurmentsReceived received unexpected response: %d"), response);
+					User::Leave(KErrNotSupported);
+					}
+				}
+			break;
+			}
+
+		case ENetworkProtocolProxyStepSessionPositionSent:
+			{
+			switch(response)
+				{
+				case ENetMsgRequestAssistanceData:
+					{
+					// >> RequestAssistanceData(0)
+					iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RequestAssistanceData(0)"));
+					TLbsAsistanceDataGroup dataMask;
+					TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
+					iStep.TESTL(dataMask == EAssistanceDataNone);
+					CleanupStack::PopAndDestroy(cleanupCnt);
+					
+					iProxy->WaitForResponseL(KSmallTimeOut, iStatus);
+					SetActive();
+					break;
+					}
+				case ENetMsgGetCurrentCapabilitiesResponse:
+					{
+					// >> AdviceSystemStatus()
+					CLbsNetworkProtocolBase::TLbsSystemStatus status;
+					TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status);
+					if(status == CLbsNetworkProtocolBase::ESystemStatusClientTracking)
+						{
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusClientTracking)"));
+						}
+					else if(status == CLbsNetworkProtocolBase::ESystemStatusNone)
+						{
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusNone)"));
+						}
+					else
+						{
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus() with wrong status"));
+						User::Leave(KErrNotSupported);
+						}
+					CleanupStack::PopAndDestroy(cleanupCnt);
+					
+					iProxy->WaitForResponseL(KSmallTimeOut, iStatus);
+					SetActive();
+					break;
+					}
+				case ENetMsgCancelSelfLocation:
+					{
+					// >> CancelSelfLocation()
+					iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> CancelSelfLocation() - as result of FNP"));
+
+					// << ProcessSessionComplete()
+					TInt reason = KErrNone;
+					iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessSessionComplete()"));			
+					iProxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason);
+
+					// << ProcessStatusUpdate()
+					MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask2 = MLbsNetworkProtocolObserver::EServiceNone;	
+					iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessStatusUpdate(EServiceNone)"));			
+					iProxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask2);
+
+					iNetworkProtocolProxyStep = ENetworkProtocolProxyStepNoSessionRunning;
+					iProxy->WaitForResponseL(KTimeOut, iStatus);
+					SetActive();
+					break;
+					}
+				case ENetMsgTimeoutExpired:
+					{
+					// << ProcessSessionComplete()
+					TInt reason = KErrNone;
+					iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessSessionComplete()"));			
+					iProxy->CallL(ENetMsgProcessSessionComplete, &iSessionId, &reason);
+
+					// << ProcessStatusUpdate()
+					MLbsNetworkProtocolObserver::TLbsNetProtocolServiceMask activeServiceMask2 = MLbsNetworkProtocolObserver::EServiceNone;	
+					iStep.INFO_PRINTF1(_L("NetworkProtocolProxy << ProcessStatusUpdate(EServiceNone)"));			
+					iProxy->CallL(ENetMsgProcessStatusUpdate, &activeServiceMask2);
+
+					iNetworkProtocolProxyStep = ENetworkProtocolProxyStepNoSessionRunning;
+					iProxy->WaitForResponseL(KTimeOut, iStatus);
+					SetActive();
+					break;
+					}
+				case ENetMsgRequestSelfLocation:
+					{
+					Process_RequestSelfLocationL();
+					iProxy->WaitForResponseL(KTimeOut, iStatus);
+					SetActive();
+					break;
+					}
+				default:
+					{
+					iStep.INFO_PRINTF2(_L("Network in state ENetworkProtocolProxyStepSessionPositionSent received unexpected response: %d"), response);
+					User::Leave(KErrNotSupported);
+					}
+				}
+			break;
+			}
+
+		case ENetworkProtocolProxyStepNoSessionRunning:
+			{
+			switch(response)
+				{
+				case ENetMsgCancelSelfLocation:
+					{
+					// >> CancelSelfLocation()
+					iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> CancelSelfLocation() for an older session"));
+					iProxy->WaitForResponseL(KTimeOut, iStatus);
+					SetActive();
+					break;
+					}
+				case ENetMsgTimeoutExpired:
+					{ // can happen that no request has been sent through, so start waiting again
+					if(iClientsFinished)
+						{
+						iObserver.StopTest();						
+						}
+					else
+						{
+						iProxy->WaitForResponseL(KTimeOut, iStatus);
+						SetActive();
+						}
+					break;
+					}
+				case ENetMsgRequestAssistanceData:
+					{
+					// >> RequestAssistanceData(0)
+					iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> RequestAssistanceData(0)"));
+					TLbsAsistanceDataGroup dataMask;
+					TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgRequestAssistanceData, &dataMask);
+					iStep.TESTL(dataMask == EAssistanceDataNone);
+					CleanupStack::PopAndDestroy(cleanupCnt);
+					
+					iProxy->WaitForResponseL(KTimeOut, iStatus);
+					SetActive();
+					break;
+					}
+				case ENetMsgGetCurrentCapabilitiesResponse:
+					{
+					// >> AdviceSystemStatus()
+					CLbsNetworkProtocolBase::TLbsSystemStatus status;
+					TInt cleanupCnt = iProxy->GetArgsLC(ENetMsgGetCurrentCapabilitiesResponse, &status);
+					if(status == CLbsNetworkProtocolBase::ESystemStatusClientTracking)
+						{
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusClientTracking)"));
+						}
+					else if(status == CLbsNetworkProtocolBase::ESystemStatusNone)
+						{
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus(ESystemStatusNone)"));
+						}
+					else
+						{
+						iStep.INFO_PRINTF1(_L("NetworkProtocolProxy >> AdviceSystemStatus() with wrong status"));
+						User::Leave(KErrNotSupported);
+						}
+					CleanupStack::PopAndDestroy(cleanupCnt);
+					
+					iProxy->WaitForResponseL(KTimeOut, iStatus);
+					SetActive();
+					break;
+					}
+				case ENetMsgRequestSelfLocation:
+					{
+					Process_RequestSelfLocationL();
+					iProxy->WaitForResponseL(KTimeOut, iStatus);
+					SetActive();
+					break;
+					}
+				default:
+					{
+					iStep.INFO_PRINTF2(_L("Network in state ENetworkProtocolProxyStepNoSessionRunning received unexpected response: %d"), response);
+					User::Leave(KErrNotSupported);
+					}
+				}
+			break;
+			}
+
+		default:
+			{
+			iStep.INFO_PRINTF1(_L("Network in unexpected state"));
+			User::Leave(KErrCorrupt);
+			}
+		}
+	iObserver.OnSignalNetworkStep(iRelativeSessionId, iNetworkProtocolProxyStep);
+	}
+
+TInt CT_LbsNetProtocol::RunError(TInt aError)
+	{
+	iStep.SetTestStepError(aError);
+	iStep.SetTestStepResult(EFail);
+	iObserver.StopTest();
+	return KErrNone;
+	}
+
+void CT_LbsNetProtocol::DoCancel()
+	{
+	iProxy->CancelWait();
+	}