--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/datacommsserver/esockserver/test/TE_EsockTestSteps/src/EsockTestBase.cpp	Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,2303 @@
+// Copyright (c) 2004-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:
+//
+
+/**
+ @file EsockTestBase.cpp
+*/
+
+#include <e32debug.h>
+#include "EsockTestBase.h"
+#include <e32std.h>
+#include <commdbconnpref.h>
+#include <cs_subconevents.h>
+#include <es_prot.h>
+#include <comms-infras/esock_params.h>
+#include <dummynif_params.h>
+
+#include <comms-infras/es_parameterbundle.h>
+#include <comms-infras/provinfoqueryset.h>
+#include "ConnectionServer.TestSteps.h"
+
+#include <dummynifvar.h>
+
+
+#ifdef _DEBUG
+// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module
+// (if it could happen through user error then you should give it an explicit, documented, category + code)
+_LIT(KSpecAssert_ESockTestEsckTst, "ESockTestEsckTst");
+#endif
+
+static const TInt KProtocolInetDummy = 253;
+
+// Temporary measure to configure the rconnserv stuff before its backported to 9.4
+
+using namespace ConnectionServ;
+
+
+namespace ConnectionServ
+{
+	class RConnectionServ;
+	class CConnectionServParameterBundle;
+}
+
+class CConnServStatusQuery : public CActive
+	{
+public:
+	CConnServStatusQuery(ConnectionServ::RConnectionServ* aConnServ);
+	static CConnServStatusQuery* NewLC(	ConnectionServ::RConnectionServ* aConnServ,
+							const ConnectionServ::CConnectionServParameterBundle& aQueryBundle,
+							ConnectionServ::CConnectionServParameterBundle& aStatusBundle);
+	void ConstructL(const ConnectionServ::CConnectionServParameterBundle& aQueryBundle,
+					ConnectionServ::CConnectionServParameterBundle& aStatusBundle);
+	void RunL();
+	void DoCancel();
+
+	TInt ErrCode() const { return iStatus.Int(); }
+
+public:	
+	ConnectionServ::RConnectionServ* iConnServ;
+	};
+
+
+CConnServStatusQuery::CConnServStatusQuery(RConnectionServ* aConnServ)
+	: CActive(0), iConnServ(aConnServ)
+		{
+		}
+
+CConnServStatusQuery* CConnServStatusQuery::NewLC(	ConnectionServ::RConnectionServ* aConnServ,
+									const ConnectionServ::CConnectionServParameterBundle& aQueryBundle,
+									ConnectionServ::CConnectionServParameterBundle& aStatusBundle)
+	{
+	CConnServStatusQuery* inst = new CConnServStatusQuery(aConnServ);
+	CleanupStack::PushL(inst);
+	inst->ConstructL(aQueryBundle, aStatusBundle);
+	return inst;
+	}
+
+void CConnServStatusQuery::ConstructL(const ConnectionServ::CConnectionServParameterBundle& aQueryBundle,
+									ConnectionServ::CConnectionServParameterBundle& aStatusBundle)
+	{
+	iConnServ->AccessPointStatusQuery(aQueryBundle, aStatusBundle, iStatus );
+
+	// add self to scheduler
+	CActiveScheduler::Add(this);
+	SetActive();
+	}
+	
+
+void CConnServStatusQuery::RunL()
+	{
+	CActiveScheduler::Current()->Stop();
+	}
+
+void CConnServStatusQuery::DoCancel()
+	{
+	iConnServ->CancelAccessPointStatusQuery();
+	}
+	
+	
+
+//
+// TMigrateToPreferredCarrierParams - container for parameters for accepting a 
+// move for mobility
+//
+
+void TMigrateToPreferredCarrierParams::Reset()
+	{
+	iName.Set(KNullDesC);
+	iMobilityApiName.Set(KNullDesC);
+	}
+
+
+//
+// TCompareIntegersParams - parameters for comparing to saved integer values
+//
+void TCompareIntegersParams::Reset()
+	{
+	iValue1.Set(KNullDesC);
+	iValue2.Set(KNullDesC);
+    iDifference = 0;
+	}
+
+//
+//TSocketDataCheckParams - container for parameters for checking data on a socket
+void TSocketDataCheckParams::Reset()
+	{
+	iSocketCheckName.Set(KNullDesC);
+    iSocketName.Set(KNullDesC);
+    iTransformType = ETransformDataNone;
+    iErrorExpected = EFalse;
+	}
+	
+//
+//TSocketServerNumProtocolsParams - container for parameters for checking the number of procotols on a socket server instance
+
+void TSocketServerNumProtocolsParams::Reset()
+	{
+	iSocketServName.Set(KNullDesC);
+	iNumberExpected = 0;
+	iSavedAsName.Set(KNullDesC);
+	iExpected = EFalse;
+	iToBeSaved = EFalse;
+	}
+
+void TSocketServStartStopProtocolParams::Reset()
+	{
+	iSocketServName.Set(KNullDesC);
+	iAddrFamily = 0;
+	iProtocol = 0;
+	iSockType = 0;
+	}
+
+//
+//TRSocketParams - container for parameters (from an .ini file)
+//needed for operations on a sockets
+
+void TRSocketParams::Reset()
+    {
+    iSockServName.Set(KNullDesC);
+    iConnectionName.Set(KNullDesC);
+    iSocketName.Set(KNullDesC);
+    iSubconnectionName.Set(KNullDesC);
+
+    iSocketType = 0;
+   	iProtocol = 0;
+	iPacketSize = 0;
+	iNrOfPackets = 0;
+	iLocalIP.FillZ();
+   	iRemoteIP.FillZ();
+   	iShutdownType = (RSocket::TShutdown)0;
+
+    // Payload colouring
+    iPayloadColouringIsEnabled = EFalse;
+    iPayloadColour = 0;
+    }
+
+void TRSocketGetOptParams::Reset()
+	{
+    iSocketName.Set(KNullDesC);
+	iOptionName = 0;
+	iOptionLevel = 0;
+	iExpectedOptionOutputText.Set(KNullDesC);
+	iTextExpected = EFalse;
+	iValueExpected = EFalse;
+	}
+
+void TRSocketIoctlParams::Reset()
+	{
+    iSocketName.Set(KNullDesC);
+	iIoctlCommand = 0;
+	iIoctlLevel = 0;
+	iExpectedIoctlOutput.Set(KNullDesC);
+	}
+
+TProtocolDescriptionParams::TProtocolDescriptionParams()
+	{
+	Mem::FillZ(this, sizeof(this));
+	}
+
+void TProtocolDescriptionParams::Reset()
+	{
+	iValuesGiven.Reset();
+	}
+
+void TProtocolDescriptionParams::TProtocolDescParamsExpected::Reset()
+	{
+	iName = EFalse;
+	iAddrFamily = EFalse;
+	iProtocol = EFalse;
+	iSockType = EFalse;
+	iVersion = EFalse;
+	iByteOrder = EFalse;
+	iServiceInfo = EFalse;
+	iNamingServices = EFalse;
+	iSecurity = EFalse;
+	iMessageSize = EFalse;
+	}
+
+TBool TProtocolDescriptionParams::MatchesExpected(TProtocolDesc& aProtocolDescription)
+	{
+	TBool verdict = ETrue;
+	
+	// Default to pass and then just need to find a single one that does not match
+	if(iValuesGiven.iName && (iValues.iName != aProtocolDescription.iName)) verdict = EFalse;
+	if(iValuesGiven.iAddrFamily && (iValues.iAddrFamily != aProtocolDescription.iAddrFamily)) verdict = EFalse;
+	if(iValuesGiven.iProtocol && (iValues.iProtocol != aProtocolDescription.iProtocol)) verdict = EFalse;
+	if(iValuesGiven.iSockType && (iValues.iSockType != aProtocolDescription.iSockType)) verdict = EFalse;
+	if(iValuesGiven.iVersion &&
+		(
+			iValues.iVersion.iMajor != aProtocolDescription.iVersion.iMajor ||
+			iValues.iVersion.iMinor != aProtocolDescription.iVersion.iMinor ||
+			iValues.iVersion.iBuild != aProtocolDescription.iVersion.iBuild
+		))
+		verdict = EFalse;
+	if(iValuesGiven.iByteOrder && (iValues.iByteOrder != aProtocolDescription.iByteOrder)) verdict = EFalse;
+	if(iValuesGiven.iServiceInfo && (iValues.iServiceInfo != aProtocolDescription.iServiceInfo)) verdict = EFalse;
+	if(iValuesGiven.iNamingServices && (iValues.iNamingServices != aProtocolDescription.iNamingServices)) verdict = EFalse;
+	if(iValuesGiven.iSecurity && (iValues.iSecurity != aProtocolDescription.iSecurity)) verdict = EFalse;
+	if(iValuesGiven.iMessageSize && (iValues.iMessageSize != aProtocolDescription.iMessageSize)) verdict = EFalse;
+
+	return verdict;		
+	}
+
+_LIT(KName, "Name");
+_LIT(KAddrFamily, "AddrFamily");
+_LIT(KProtocol, "Protocol");
+_LIT(KSockType, "SockType");
+_LIT(KVersionMajor, "VersionMajor");
+_LIT(KVersionMinor, "VersionMinor");
+_LIT(KVersionBuild, "VersionBuild");
+_LIT(KByteOrder, "ByteOrder");
+_LIT(KServiceInfo, "ServiceInfo");
+_LIT(KNamingServices, "NamingServices");
+_LIT(KSecurity, "Security");
+_LIT(KMessageSize, "MessageSize");
+
+TInt TProtocolDescriptionParams::FetchDescription(TProtocolDescriptionParams& aParams, CTestStep& aTestStep)
+	{
+    // Protocol name
+    TPtrC name;
+	if (aTestStep.GetStringFromConfig(aTestStep.ConfigSection(), KName, name) == 1)
+        {
+		aParams.iValues.iName.Copy(name);
+		aParams.iValuesGiven.iName = ETrue;
+        }
+
+	// Address family
+	if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KAddrFamily, (TInt&)aParams.iValues.iAddrFamily) == 1)
+        {
+		aParams.iValuesGiven.iAddrFamily = ETrue;
+        }
+
+	// Protocol
+	if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KProtocol, (TInt&)aParams.iValues.iProtocol) == 1)
+        {
+		aParams.iValuesGiven.iProtocol = ETrue;
+        }
+
+	// Socket type
+	if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KSockType, (TInt&)aParams.iValues.iSockType) == 1)
+        {
+		aParams.iValuesGiven.iSockType = ETrue;
+        }
+
+	// Version
+	TInt versionMajor;
+	if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KVersionMajor, versionMajor) == 1)
+        {
+		aParams.iValues.iVersion.iMajor = (TInt8)versionMajor;
+
+		TInt versionMinor;
+		if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KVersionMinor, versionMinor) == 1)
+			{
+			aParams.iValues.iVersion.iMinor = (TInt8)versionMinor;
+
+			TInt versionBuild;
+			if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KVersionBuild, versionBuild) == 1)
+				{
+				aParams.iValues.iVersion.iBuild = (TInt16)versionBuild;
+
+				// Got all the version info
+				aParams.iValuesGiven.iVersion = ETrue;
+				}
+			}
+        }
+
+	// Byte order
+	if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KByteOrder, (TInt&)aParams.iValues.iByteOrder) == 1)
+        {
+		aParams.iValuesGiven.iByteOrder = ETrue;
+        }
+
+	// Service info
+	if (aTestStep.GetHexFromConfig(aTestStep.ConfigSection(), KServiceInfo, (TInt&)aParams.iValues.iServiceInfo) == 1)
+        {
+		aParams.iValuesGiven.iServiceInfo = ETrue;
+        }
+
+	// Naming services
+	if (aTestStep.GetHexFromConfig(aTestStep.ConfigSection(), KNamingServices, (TInt&)aParams.iValues.iNamingServices) == 1)
+        {
+		aParams.iValuesGiven.iNamingServices = ETrue;
+        }
+
+	// Security
+	if (aTestStep.GetHexFromConfig(aTestStep.ConfigSection(), KSecurity, (TInt&)aParams.iValues.iSecurity) == 1)
+        {
+		aParams.iValuesGiven.iSecurity = ETrue;
+        }
+
+	// Message size
+	if (aTestStep.GetIntFromConfig(aTestStep.ConfigSection(), KMessageSize, (TInt&)aParams.iValues.iMessageSize) == 1)
+        {
+		aParams.iValuesGiven.iMessageSize = ETrue;
+        }
+
+	return aParams.iValuesGiven.AllExpected() ? KErrNone : KErrNotFound;
+	}
+
+TBool TProtocolDescriptionParams::TProtocolDescParamsExpected::NoneExpected()
+	{
+	return (!iName && !iAddrFamily && !iProtocol && !iSockType && !iVersion && !iByteOrder && !iServiceInfo && !iNamingServices && !iSecurity && !iMessageSize) ?
+		ETrue :
+		EFalse;
+	}
+	
+TBool TProtocolDescriptionParams::TProtocolDescParamsExpected::AllExpected()
+	{
+	return (iName && iAddrFamily && iProtocol && iSockType && iVersion && iByteOrder && iServiceInfo && iNamingServices && iSecurity && iMessageSize) ?
+		ETrue :
+		EFalse;
+	}
+
+void TSocketProtocolDescriptionParams::Reset()
+	{
+	iSocketName.Set(KNullDesC);
+	iProtocolDescParams.Reset();
+	}
+
+void TSocketServFindProtocolParams::Reset()
+	{
+	iSocketServName.Set(KNullDesC);
+	iProtocolDescParams.Reset();
+	}
+
+void TSocketServGetProtocolInfoParams::Reset()
+	{
+	iSocketServName.Set(KNullDesC);
+	iProtocolIndex = 0;
+	iProtocolDescParams.Reset();
+	}
+
+
+//
+//TRConnectionParams - container for parameters (from an .ini file)
+//needed for operations on a connections
+
+void TRConnectionParams::Reset()
+    {
+    iSockServName.Set(KNullDesC);
+    iConnectionName.Set(KNullDesC);
+    iAttachToConnectionName.Set(KNullDesC);
+
+	iBearer = 0;
+	iIAP = 0;
+	iNET = 0;
+	iSNAP = 0;
+
+    iConnStopType = (RConnection::TConnStopType)0;
+    iConnAttachType = (RConnection::TConnAttachType)0;
+    iStartWithOldPreferences = 0;
+    iStartWithSnapPreferences = 0;
+    iAsynch = EFalse;
+    }
+
+//
+//TRSubConnectionParams - container for parameters (from an .ini file)
+//needed for operations on a subconnections
+
+void TRSubConnectionParams::Reset()
+    {
+    iSockServName.Set(KNullDesC);
+	iConnectionName.Set(KNullDesC);
+	iSubConnectionName.Set(KNullDesC);
+	iSocketName.Set(KNullDesC);
+
+	iSubConnectionParamsName.Set(KNullDesC);
+	iSubConnectionEventName.Set(KNullDesC);
+
+    iSubConnType = (RSubConnection::TSubConnType)0;
+    }
+
+//
+//TEsockTestEventContainer - encapsulates all necessary RConnection
+//or RSubConnection event data so that it can be conveniently stored in a map.
+
+void TEventContainerParams::Reset()
+    {
+    iEventName.Set(KNullDesC);
+	iSubConnectionName.Set(KNullDesC);
+	iConnectionName.Set(KNullDesC);
+	iAvailabilityExtName.Set(KNullDesC);
+	iConnectionManagerExtName.Set(KNullDesC);
+	iExtensionName.Set(KNullDesC);
+	iMobilityExtName.Set(KNullDesC);
+	iAllEvents = EFalse;
+	iGenericEvents = EFalse;
+	iEventMask = 0;
+	iTimeoutMiliSecs = 0;
+    }
+
+TEsockTestEventContainer::~TEsockTestEventContainer()
+    {
+    iEventNotifBuf.Zero();
+    }
+
+//
+// TEsockTestDataMonitoringEventContainer - encapsulates all necessary data monitoring
+// event data so that it can be conveniently stored in a map.    
+
+void TDataMonitorEventParams::Reset()
+	{
+	iEventName.Copy(KNullDesC);
+	iConnectionName.Set(KNullDesC);
+	iSubConnectionName.Set(KNullDesC);
+	iDataMonitorName.Set(KNullDesC);
+	
+	iDelta = 0;
+	iMinExpectedVolume = 0;
+	}
+
+TPtrC& TDataMonitorEventParams::ConnOrSubConnName()
+	{
+	if(iConnectionName.Length() > 0)
+		{
+		return iConnectionName;
+		}
+	else 
+		{
+		// We return this regardless and consider the default KNullDesC
+		// to represent an error
+		return iSubConnectionName;
+		}
+	}
+
+//
+//TRSimtsyEventParams - container for parameters (from an .ini file)
+void TSimTsyEventParams::Reset()
+    {
+
+	iConnectionName.Set(KNullDesC);
+	iSimTsyEventName.Set(KNullDesC);
+	iEventName.Set(KNullDesC);
+	iEventKey=0;
+	iEventIndex=0;
+
+    }
+
+
+//
+//CCEsockTestBase
+
+CCEsockTestBase::~CCEsockTestBase()
+	{
+	CleanAll();
+	}
+
+//
+//socket server functions library
+
+TInt CCEsockTestBase::CreateSocketServer(const TDesC& aSockServName)
+	{
+    //check if this secket server hasn't been created already
+    if (iSockServs.Find(aSockServName)!=NULL)
+    	return KErrAlreadyExists;
+
+    RSocketServ* ss = new RSocketServ;
+    if (ss==NULL)
+    	return KErrNoMemory;
+
+	TInt error = iSockServs.Add(ss,aSockServName);
+	if (error!=KErrNone)
+		delete ss;
+
+
+	return error;
+	}
+
+TInt CCEsockTestBase::ConnectSocketServer(const TDesC& aSockServName)
+	{
+    //check if this secket server hasn't been created already
+    RSocketServ* ss = iSockServs.Find(aSockServName);
+    if (ss==NULL)
+    	return KErrNotFound;
+
+	return ss->Connect();
+	}
+
+TInt CCEsockTestBase::CloseSocketServer(const TDesC& aSockServName)
+	{
+    //check if this secket server hasn't been created already
+    RSocketServ* ss = iSockServs.Find(aSockServName);
+    if (ss==NULL)
+    	return KErrNotFound;
+
+	ss->Close();
+	return KErrNone;
+	}
+
+TInt CCEsockTestBase::SocketServerNumProtocols(TSocketServerNumProtocolsParams& aParams, TInt& aNumProtocols)
+	{
+    // Fetch the socket server instance which must already exist
+    RSocketServ* ss = iSockServs.Find(aParams.iSocketServName);
+    if (ss == NULL)
+    	return KErrNotFound;
+
+	TInt error = ss->NumProtocols((TUint&)aNumProtocols);
+	if(error != KErrNone)
+		{
+		return error;
+		}
+	
+	if(aParams.iToBeSaved)
+		{
+		// If we are saving the value then do so
+		// If it exists already then update it
+		TInt* currentValue = NULL;
+		currentValue = iIntegerValues.Find(aParams.iSavedAsName);
+		if(currentValue != NULL)
+			{
+			*currentValue = aNumProtocols;
+			return KErrNone;
+			}
+
+		// Else create the new variable
+		currentValue = new TInt(aNumProtocols);
+		if (currentValue == NULL)
+			return KErrNoMemory;
+
+		error = iIntegerValues.Add(currentValue, aParams.iSavedAsName);
+		}
+
+	return error;
+	}
+
+TInt CCEsockTestBase::SocketServerFindProtocol(TSocketServFindProtocolParams& aParams, TProtocolDesc& aProtocolDescription)
+	{
+    // Fetch the socket server instance which must already exist
+    RSocketServ* ss = iSockServs.Find(aParams.iSocketServName);
+    if (ss == NULL)
+    	return KErrNotFound;
+
+	return ss->FindProtocol(aParams.iProtocolDescParams.iValues.iName, aProtocolDescription);
+	}
+
+TInt CCEsockTestBase::SocketServerGetProtocolInfo(TSocketServGetProtocolInfoParams& aParams, TProtocolDesc& aProtocolDescription)
+	{
+    // Fetch the socket server instance which must already exist
+    RSocketServ* ss = iSockServs.Find(aParams.iSocketServName);
+    if (ss == NULL)
+    	return KErrNotFound;
+
+	return ss->GetProtocolInfo(aParams.iProtocolIndex, aProtocolDescription);
+	}
+
+
+TInt CCEsockTestBase::SocketServerStartProtocol(TSocketServStartStopProtocolParams& aParams, TRequestStatus& aStatus)
+	{
+    // Fetch the socket server instance which must already exist
+    RSocketServ* ss = iSockServs.Find(aParams.iSocketServName);
+    if (ss == NULL)
+    	return KErrNotFound;
+
+	// Start the protocol
+	ss->StartProtocol(
+		aParams.iAddrFamily,
+		aParams.iSockType,
+		aParams.iProtocol,
+		aStatus);
+	return KErrNone;	
+	}
+
+
+TInt CCEsockTestBase::SocketServerStopProtocol(TSocketServStartStopProtocolParams& aParams, TRequestStatus& aStatus)
+	{
+    // Fetch the socket server instance which must already exist
+    RSocketServ* ss = iSockServs.Find(aParams.iSocketServName);
+    if (ss == NULL)
+    	return KErrNotFound;
+
+	// Stop the protocol
+	ss->StopProtocol(
+		aParams.iAddrFamily,
+		aParams.iSockType,
+		aParams.iProtocol,
+		aStatus);
+	return KErrNone;	
+	}
+
+
+TInt CCEsockTestBase::__DbgFailNext(const TDesC& aSockServName, TInt aCount)
+	{
+	RSocketServ* ss = iSockServs.Find(aSockServName);
+    if (ss==NULL)
+		return KErrNotFound;
+
+	return ss->__DbgFailNext(aCount);
+	}	
+
+TBool CCEsockTestBase::__DbgCheckFailNext(const TDesC& aSockServName)
+    {
+	RSocketServ* ss = iSockServs.Find(aSockServName);
+    if (ss==NULL)
+		return KErrNotFound;
+
+	return ss->__DbgCheckFailNext();
+    }
+
+
+//
+//connection server functions library
+TInt CCEsockTestBase::CreateConnectionServer(const TDesC& aConnectionServName)
+	{
+    if (iConnectionServs.Find(aConnectionServName) != NULL)
+    	return KErrAlreadyExists;
+
+    RConnectionServ* connServ = new RConnectionServ;
+    if (connServ == NULL)
+    	return KErrNoMemory;
+
+	TInt error = iConnectionServs.Add(connServ, aConnectionServName);
+	if (error != KErrNone)
+		delete connServ;
+
+	return error;
+	}
+
+TInt CCEsockTestBase::ConnectConnectionServer(const TDesC& aConnectionServName, TUint aTierId)
+	{
+    //check if this secket server hasn't been created already
+    RConnectionServ* connServ = iConnectionServs.Find(aConnectionServName);
+    if (connServ == NULL)
+    	return KErrNotFound;
+
+	return connServ->Connect(aTierId);
+	}
+
+TInt CCEsockTestBase::CloseConnectionServer(const TDesC& aConnectionServName)
+	{
+    // Find the connection server we are referring to
+    RConnectionServ* connServ = iConnectionServs.Find(aConnectionServName);
+    if (connServ == NULL)
+    	return KErrNotFound;
+
+	connServ->Close();
+	return KErrNone;
+	}
+
+TInt CCEsockTestBase::ConnectionAccessPointStatusQuery(
+		const TDesC& aConnectionServName,
+		const ConnectionServ::CConnectionServParameterBundle& aQueryBundle,
+		ConnectionServ::CConnectionServParameterBundle& aResultBundle)
+	{
+	RConnectionServ* connServ = iConnectionServs.Find(aConnectionServName);
+
+	if(connServ == NULL)
+		return KErrNotFound;
+		
+	// Need a local active scheduler for the RConnectionServ API
+	CActiveScheduler* as = new(ELeave) CActiveScheduler;
+	CleanupStack::PushL(as);
+	CActiveScheduler::Install(as);
+
+	CConnServStatusQuery* sq = CConnServStatusQuery::NewLC(connServ, aQueryBundle, aResultBundle);
+
+	TRAP_IGNORE(CActiveScheduler::Start())
+
+	TInt res2 = sq->ErrCode();
+
+	CleanupStack::PopAndDestroy(sq);	
+	CleanupStack::PopAndDestroy(as);
+
+	return res2;
+	}
+
+class CMyTimer : public CTimer
+	{
+public:
+	static CMyTimer* NewL()
+		{
+		CMyTimer* timer = new CMyTimer();
+		if(timer)
+			{
+			timer->ConstructL();
+			CActiveScheduler::Add(timer);
+			}
+		return timer;
+		}
+		
+	CMyTimer() : CTimer(EPriorityStandard)
+		{
+		}
+	void RunL()
+		{
+		// Simply stop the scheduler as this will force the cancellation we are after
+		CActiveScheduler::Current()->Stop();		
+		}
+	};
+
+const TInt KHalfASecondInMicroSeconds = 500000;
+
+TInt CCEsockTestBase::CancelAccessPointStatusQuery(
+		const TDesC& aConnectionServName,
+		const ConnectionServ::CConnectionServParameterBundle& aQueryBundle,
+		ConnectionServ::CConnectionServParameterBundle& aResultBundle)
+	{
+	RConnectionServ* connServ = iConnectionServs.Find(aConnectionServName);
+
+	if(connServ == NULL)
+		return KErrNotFound;
+		
+	// Need a local active scheduler for the RConnectionServ API
+	CActiveScheduler* as = new(ELeave) CActiveScheduler;
+	CleanupStack::PushL(as);
+	CActiveScheduler::Install(as);
+
+	// Create a timer that will complete almost immediately and stop the scheduler
+	// thereby canceling the query while it is in progress
+	// This all requires a long running query
+	CMyTimer* timer = CMyTimer::NewL();
+	CleanupStack::PushL(timer);
+	timer->After(KHalfASecondInMicroSeconds);
+	
+	// Create active object to manage the query
+	CConnServStatusQuery* sq = CConnServStatusQuery::NewLC(connServ, aQueryBundle, aResultBundle);
+	
+	// Start the scheduler
+	TRAP_IGNORE(CActiveScheduler::Start())
+
+	sq->Cancel();
+	timer->Cancel();
+
+	// Check that the cancel status is what we expected
+	TInt res2 = sq->ErrCode();
+
+	CleanupStack::PopAndDestroy(sq);
+	CleanupStack::PopAndDestroy(timer);
+	CleanupStack::PopAndDestroy(as);
+	
+	return res2;
+	}
+
+
+//
+//socket functions library
+
+RSocket* CCEsockTestBase::FindSocket(const TDesC& aSocketName)
+    {
+    return iSocks.Find(aSocketName);
+    }
+
+TInt CCEsockTestBase::CreateSocket(const TDesC& aSocketName)
+	{
+    //check if this socket hasn't been created already
+    if (iSocks.Find(aSocketName)!=NULL)
+    	return KErrAlreadyExists;
+
+    RSocket* s = new RSocket;
+    if (s==NULL)
+    	return KErrNoMemory;
+
+	TInt error = iSocks.Add(s,aSocketName);
+	if (error!=KErrNone)
+		delete s;
+
+	return error;
+	}
+
+TInt CCEsockTestBase::OpenSocket(const TRSocketParams& aParams)
+	{
+    RSocketServ* ss = iSockServs.Find(aParams.iSockServName);
+    if (ss==NULL)
+		return KErrNotFound;
+
+    RSocket* s = iSocks.Find(aParams.iSocketName);
+	if (s==NULL)
+		return KErrNotFound;
+
+    TInt error;
+
+    //try to find the connection (if specified)
+    if (aParams.iConnectionName.Length()>0)
+    	{
+		RConnection* c = iConns.Find(aParams.iConnectionName);
+		if (c==NULL)
+			return KErrNotFound;
+		error = s->Open(*ss, KAfInet, aParams.iSocketType, aParams.iProtocol, *c);
+		}
+	else if (aParams.iSubconnectionName.Length()>0)
+    	{
+		RSubConnection* sc = iSubConns.Find(aParams.iSubconnectionName);
+		if (sc==NULL)
+			{
+			return KErrNotFound;
+			}
+		error = s->Open(*ss, KAfInet, aParams.iSocketType, aParams.iProtocol, *sc);
+		}
+	else if (aParams.iProtocolName.Length()>0)
+		{
+		error = s->Open(*ss,aParams.iProtocolName);
+		}
+	else
+		{
+		error = s->Open(*ss, KAfInet, aParams.iSocketType, aParams.iProtocol);
+		}
+
+
+	return error;
+	}
+
+TInt CCEsockTestBase::BindSocket(const TRSocketParams& /*aParams*/)
+	{
+    return KErrNotSupported;
+    /*
+    RSocket* s = iSocks.Find(aSockeSParams.iSocketName);
+	if (s==NULL)
+		return KErrNotFound;
+
+	TInt error = KErrNone;
+	if (aSockeSParams.iProtocol==KProtocolInetUdp)
+	    error = s->SetOpt(KSoUdpSynchronousSend,KSolInetUdp,1);
+	if (error!=KErrNone)
+		return error;
+
+	//bind to Local address for TCP or UDP
+	return s->Bind(aSockeSParams.iLocalIP);
+	*/
+	}
+
+TInt CCEsockTestBase::ConnectSocket(TRSocketParams& aParams, TRequestStatus& aRequestStatus)
+	{
+    RSocket* s = iSocks.Find(aParams.iSocketName);
+	if (s==NULL)
+	    {
+		return KErrNotFound;
+	    }
+
+    TInt err = KErrNone;
+
+    if (aParams.iProtocol==KProtocolInetUdp)
+        {
+        err = s->SetOpt(KSoUdpSynchronousSend,KSolInetUdp,1);
+        if (err != KErrNone)
+            {
+            return err;
+            }
+        }
+
+    if (!aParams.iLocalIP.IsUnspecified() || !aParams.iLocalIP.IsWildPort())
+        {
+        err = s->Bind(aParams.iLocalIP);
+        }
+
+    if (err == KErrNone)
+        {
+        s->Connect(aParams.iRemoteIP, aRequestStatus);
+        }
+
+    return err;
+	}
+
+TInt CCEsockTestBase::CancelConnectSocket(const TRSocketParams& aParams)
+	{
+    RSocket* s = iSocks.Find(aParams.iSocketName);
+	if (s==NULL)
+		return KErrNotFound;
+
+    s->CancelConnect();
+    return KErrNone;
+	}
+
+void CCEsockTestBase::SendAndReceiveDataL(const TRSocketParams& aParams)
+	{
+    RSocket* s = iSocks.Find(aParams.iSocketName);
+	if (s==NULL)
+		User::Leave(KErrNotFound);
+
+	TInt recvCount = 0;
+	TRequestStatus stat;
+	TBuf8<50> Data;
+
+	//set up buffers
+	HBufC8* writebuf = HBufC8::NewMaxLC(aParams.iPacketSize);
+	HBufC8* readbuf  = HBufC8::NewMaxLC(aParams.iPacketSize);
+	
+	// In the case of armv5, HBufC8 MaxLength is set as 1504 or 1512
+	// To sort it out we use TPtr8(TUint8* ,MaxLenghth) constructor
+	// instead of using
+	// TPtr8 ptrwritebuf = writebuf->Des();
+	// TPtr8 ptrreadbuf = readbuf->Des();
+	TPtr8 ptrwritebuf(const_cast<TUint8*>(writebuf->Ptr()), aParams.iPacketSize);
+	TPtr8 ptrreadbuf(const_cast<TUint8*>(readbuf->Ptr()), aParams.iPacketSize);
+	
+	// NewMaxLC may give a max size bigger than specified. Make sure length and max length are in sync so that
+	// the Read will complete. For example, NewMaxLC(1500) may give back a buffer 1504 as the max size. if you Write
+	// then Read on that, it'll write the length (1500) but try to read the max length (1504). this'll never complete
+	// because we'll only get back as many bytes as we wrote the the echo server.
+	ptrwritebuf.SetLength(ptrwritebuf.MaxLength());
+	ptrreadbuf.SetLength(ptrreadbuf.MaxLength());
+
+    if (aParams.iProtocol==KProtocolInetTcp)
+        {
+   		for (TInt i = 0; i < aParams.iNrOfPackets; i++)
+    		{
+	    	// initialise data
+		    Data.Format(_L8("TCP-packet:%d helloworld"),i);
+		    ptrwritebuf.Repeat( Data );
+
+		    // write data
+		    s->Write(ptrwritebuf,stat);
+		    User::WaitForRequest(stat);
+		    User::LeaveIfError(stat.Int());
+
+		    // read data
+		    s->Read(ptrreadbuf, stat);
+		    User::WaitForRequest(stat);
+			User::LeaveIfError(stat.Int());
+
+		    // compare the data
+		    if (ptrwritebuf.Compare(ptrreadbuf) != 0)
+		    	User::Leave(KErrGeneral);
+
+		    recvCount+=ptrreadbuf.Length();
+	    	}
+		}
+	else if (aParams.iProtocol==KProtocolInetUdp || aParams.iProtocol == KProtocolInetDummy)
+		{
+        for (TInt i = 0; i < aParams.iNrOfPackets; i++)
+		    {
+		    // initialise data
+		    Data.Format(_L8("UDP-packet:%d helloworld"),i);
+		    ptrwritebuf.Repeat( Data );
+
+		    // If we are colouring the payload then first prefix outgoing payload with command byte to tell the stack so
+		    if(aParams.iPayloadColouringIsEnabled)
+		    	{
+				ptrwritebuf[0] = 0xF9; // KColourDataByLinkTierAccessPointId; TODO_CDG
+				}
+		    
+		    // write data
+		    s->Send(ptrwritebuf, 0, stat);
+		    User::WaitForRequest(stat);
+		    User::LeaveIfError(stat.Int());
+
+		    // If the returned data will be coloured by the IP stack for test purposes
+		    // then we had better change what we compare it with
+		    if(aParams.iPayloadColouringIsEnabled)
+		    	{
+		    	ptrwritebuf[0] += static_cast<TUint8>(aParams.iPayloadColour);
+				}
+		    
+		    s->Recv(ptrreadbuf, 0, stat);
+		    User::WaitForRequest(stat);
+		    User::LeaveIfError(stat.Int());
+
+		    // compare the data
+		    if (ptrwritebuf.Compare(ptrreadbuf) != 0 )
+		    	User::Leave(KErrGeneral);
+
+		    recvCount += ptrreadbuf.Length();
+		    }
+		}
+	else
+        User::Leave(KErrNotFound);
+
+    CleanupStack::PopAndDestroy(2, writebuf);	//	writebuf and readbuf
+
+	// check the total received (95 per cent is allowable for us)
+	if (recvCount*aParams.iPacketSize < (0.95*(aParams.iNrOfPackets*aParams.iPacketSize)))
+		User::Leave(KErrGeneral);
+	}
+
+TInt CCEsockTestBase::CloseSocket(const TDesC& aSocketName)
+	{
+    RSocket* s = iSocks.Find(aSocketName);
+	if (s==NULL)
+		return KErrNotFound;
+
+	s->Close();
+    return KErrNone;
+	}
+
+TInt CCEsockTestBase::ShutdownSocket(const TRSocketParams& aParams, TRequestStatus& aRequestStatus)
+	{
+    RSocket* s = iSocks.Find(aParams.iSocketName);
+	if (s==NULL)
+		return KErrNotFound;
+
+	s->Shutdown(aParams.iShutdownType,aRequestStatus);
+    return KErrNone;
+	}
+
+TInt CCEsockTestBase::IoctlSocket(const TRSocketIoctlParams& aParams, TDes8& aIoctlOutput, TRequestStatus& aRequestStatus)
+	{
+    RSocket* s = iSocks.Find(aParams.iSocketName);
+	if (s == NULL)
+		return KErrNotFound;
+
+	s->Ioctl(aParams.iIoctlCommand, aRequestStatus, &aIoctlOutput, aParams.iIoctlLevel);
+	User::WaitForRequest(aRequestStatus);
+
+    return KErrNone;
+	}
+
+TInt CCEsockTestBase::GetOptSocket(const TRSocketGetOptParams& aParams, TDes8& aGetOptOutput)
+	{
+    RSocket* s = iSocks.Find(aParams.iSocketName);
+	if (s == NULL)
+		return KErrNotFound;
+
+	return s->GetOpt(aParams.iOptionName, aParams.iOptionLevel, aGetOptOutput);
+	}
+
+TInt CCEsockTestBase::GetOptSocket(const TRSocketGetOptParams& aParams, TInt& aGetOptOutput)
+	{
+    RSocket* s = iSocks.Find(aParams.iSocketName);
+	if (s == NULL)
+		return KErrNotFound;
+
+	return s->GetOpt(aParams.iOptionName, aParams.iOptionLevel, aGetOptOutput);
+	}
+
+TInt CCEsockTestBase::ProtocolDescription(
+	const TSocketProtocolDescriptionParams& aParams,
+	TProtocolDesc& aProtocolDescriptionOutput)
+	{
+    RSocket* s = iSocks.Find(aParams.iSocketName);
+	if (s == NULL)
+		return KErrNotFound;
+
+	return s->Info(aProtocolDescriptionOutput);
+	}
+
+
+//
+//connection functions library
+
+RConnection* CCEsockTestBase::FindConnection(const TDesC& aConnectionName)
+    {
+    return iConns.Find(aConnectionName);
+    }
+
+TInt CCEsockTestBase::CreateConnection(const TDesC& aConnectionName)
+	{
+    //check if this connection hasn't been created already
+    if (iConns.Find(aConnectionName)!=NULL)
+    	return KErrAlreadyExists;
+
+    RConnection* c = new RConnection;
+    if (c==NULL)
+    	return KErrNoMemory;
+
+	TInt error = iConns.Add(c,aConnectionName);
+	if (error!=KErrNone)
+		delete c;
+
+	return error;
+	}
+
+TInt CCEsockTestBase::OpenConnection(const TRConnectionParams& aParams)
+	{
+    RSocketServ* ss = iSockServs.Find(aParams.iSockServName);
+    if (ss==NULL)
+		return KErrNotFound;
+
+    RConnection* c = iConns.Find(aParams.iConnectionName);
+	if (c==NULL)
+		return KErrNotFound;
+
+	if(aParams.iConnectionType != -1)
+	   return c->Open(*ss,aParams.iConnectionType);
+
+	return c->Open(*ss);
+	}
+
+TInt CCEsockTestBase::WaitforIncomingConnection(const TRSubConnectionParams& aParams)
+	{
+    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
+	if (sc==NULL)
+		return KErrNotFound;
+
+	RConnection* c = iConns.Find(aParams.iConnectionName);
+	if (c==NULL)
+		return KErrNotFound;
+
+	return c->WaitForIncoming(*sc);
+	}
+
+TInt CCEsockTestBase::WaitforIncomingConnection(const TRSubConnectionParams& aParams,TRequestStatus& reqStat)
+	{
+    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
+	if (sc==NULL)
+		return KErrNotFound;
+
+	RConnection* c = iConns.Find(aParams.iConnectionName);
+	if (c==NULL)
+		return KErrNotFound;
+
+	c->WaitForIncoming(*sc,reqStat);
+
+	return KErrNone;
+	}
+
+TInt CCEsockTestBase::AcceptIncomingConnection(const TRSubConnectionParams& aParams)
+	{
+    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
+	if (sc==NULL)
+		return KErrNotFound;
+
+	sc->Start();
+	
+	return KErrNone;
+	}
+	
+TInt CCEsockTestBase::AsyncAcceptIncomingConnection(const TRSubConnectionParams& aParams, TRequestStatus& reqStat)
+	{
+    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
+	if (sc==NULL)
+		return KErrNotFound;
+
+	sc->Start(reqStat);
+	
+	return KErrNone;
+	}
+	
+TInt CCEsockTestBase::RejectIncomingConnection(const TRSubConnectionParams& aParams)
+	{
+    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
+	if (sc==NULL)
+		return KErrNotFound;
+
+	sc->Stop();
+
+	return KErrNone;
+	}
+
+TInt CCEsockTestBase::CancelIncomingConnection(const TRSubConnectionParams& aParams)
+	{
+    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
+	if (sc==NULL)
+		return KErrNotFound;
+
+	RConnection* c = iConns.Find(aParams.iConnectionName);
+	if (c==NULL)
+		return KErrNotFound;
+
+	c->CancelWaitForIncoming();
+
+	return KErrNone;
+	}
+
+
+TInt CCEsockTestBase::StartConnection(RConnection& aConn, TConnPref& aPrefs, TRequestStatus* aRequestStatus)
+	{
+	if (aRequestStatus)
+		{
+		aConn.Start(aPrefs, *aRequestStatus);
+		}
+	else
+		{
+		return aConn.Start(aPrefs);
+		}
+	return KErrNone;
+	}
+
+TInt CCEsockTestBase::StartConnection(TRConnectionParams& aParams)
+	{
+    RConnection* c = iConns.Find(aParams.iConnectionName);
+	if (c==NULL)
+		return KErrNotFound;
+	TRequestStatus* requestStatus = NULL;
+	if (aParams.iAsynch)
+		{
+		requestStatus = new TRequestStatus;
+	    if (requestStatus==NULL)
+	    	return KErrNoMemory;
+	    
+		TInt error = iRequestStatuses.Add(requestStatus, aParams.iConnectionName);
+		if (error!=KErrNone)
+			{
+			delete requestStatus;
+			return error;
+			}
+		}
+
+	TInt error;
+	if (aParams.iStartWithSnapPreferences)
+		{
+		TCommSnapPref prefs;
+		prefs.SetSnap(aParams.iSNAP);
+
+		error = StartConnection(*c, prefs, requestStatus);
+		}
+	else if (aParams.iStartWithOldPreferences)
+		{
+		TCommDbConnPref prefs;
+		prefs.SetBearerSet(aParams.iBearer);
+		prefs.SetIapId(aParams.iIAP);
+		error = StartConnection(*c, prefs, requestStatus);
+		}
+	else if(aParams.iStartWithConPrefList)
+		{
+		TConnPrefList* prefs = TConnPrefList::NewL();
+		CleanupStack::PushL(prefs);
+		TConnAPPref* APPref = TConnAPPref::NewL(aParams.iSNAP);
+		CleanupStack::PushL(APPref);
+		TDummyPref* dummyPref = TDummyPref::NewL(aParams.iDummy);
+		CleanupStack::PushL(dummyPref);
+		if(aParams.iStartWithDummy)
+			prefs->AppendL(dummyPref);
+		
+		TConnAutoStartPref* autoPref = TConnAutoStartPref::NewL();
+		CleanupStack::PushL(autoPref);
+		if(aParams.iStartAuto)
+			prefs->AppendL(autoPref);
+		
+		prefs->AppendL(APPref);
+		error = StartConnection(*c, *prefs, requestStatus);
+		
+		delete APPref;
+		delete dummyPref;
+		delete autoPref;
+		if (aParams.iStartAuto)
+			prefs->Remove(0);
+		if (aParams.iStartWithDummy)
+			prefs->Remove(0);
+		prefs->Remove(0);
+		delete prefs;
+		
+		CleanupStack::Pop(4);
+		}
+	else
+		{
+		if (requestStatus)
+			{
+			c->Start(*requestStatus);
+			}
+		else
+			{
+			error = c->Start();
+			}
+		}
+	
+	return error;
+	}
+
+TInt CCEsockTestBase::AttachToConnection(const TRConnectionParams& aParams)
+	{
+	RConnection* c = iConns.Find(aParams.iConnectionName);
+	if (c==NULL)
+		return KErrNotFound;
+
+	TUint count = 0;
+		c->EnumerateConnections(count);
+	
+	if(count < 1)
+		return KErrNotFound;
+
+	//
+	TInt error = KErrNotSupported;
+	RConnection* atc = iConns.Find(aParams.iAttachToConnectionName);
+	if (atc!=NULL)
+		{ //Currently this is only for the new attach (TConnProviderInfo)
+		//If you want to extend this test step for legacy attach (TConnectionInfo),
+		//you need to add a parameter to recognise which attach it is.
+
+		ESock::XProviderInfoQuerySet* querySet = ESock::XProviderInfoQuerySet::NewL();
+		CleanupDeletePushL(querySet);
+		
+		// CProviderInfoQuerySet takes ownership of the X-class
+		ESock::CProviderInfoQuerySet* queryContainer = ESock::CProviderInfoQuerySet::NewL(querySet);
+		CleanupStack::Pop(querySet);
+		CleanupStack::PushL(queryContainer);
+		
+		error = atc->GetParameters(*queryContainer);
+		if (error != KErrNone)
+			return error;
+
+		ESock::XProviderInfoQuerySet& outputQuerySet = queryContainer->DataObject();
+
+		TPckg<TConnProviderInfo> pkgConnInfo(outputQuerySet.ConnProviderInfo());
+		error = c->Attach(pkgConnInfo, aParams.iConnAttachType);
+		
+		CleanupStack::PopAndDestroy(queryContainer);
+		}
+	else
+		{
+		TConnectionInfo connInfo;
+		TPckg<TConnectionInfo> pkgConnInfo(connInfo);
+
+		TBool found = EFalse;
+		for(TInt index = 1; index <= count; ++index)
+			{
+			error = c->GetConnectionInfo(index, pkgConnInfo);
+			if(error != KErrNone)
+				return error;
+			
+			if(aParams.iIAP == 0 && aParams.iNET == 0)
+				{
+				found = ETrue;
+				}
+			else if(aParams.iIAP > 0 && aParams.iNET > 0)	
+				{
+				found = (aParams.iIAP == connInfo.iIapId && aParams.iNET == connInfo.iNetId) ? ETrue : EFalse;
+				}
+			else if(aParams.iIAP > 0)
+				{
+				found = aParams.iIAP == connInfo.iIapId ? ETrue : EFalse;
+				}
+			else if(aParams.iNET > 0)	
+				{
+				found = aParams.iNET == connInfo.iNetId ? ETrue : EFalse;
+				}
+			
+			if(found) 
+				break;	
+			}
+			if(!found)	
+				return KErrNotFound;
+			
+			error = c->Attach(pkgConnInfo,aParams.iConnAttachType);
+		}
+	
+	return error;
+	}
+
+TInt CCEsockTestBase::StopConnection(const TRConnectionParams& aParams)
+    {
+    RConnection* c = iConns.Find(aParams.iConnectionName);
+	if (c==NULL)
+		return KErrNotFound;
+
+	c->Stop(aParams.iConnStopType);
+	return KErrNone;
+    }
+
+TInt CCEsockTestBase::CloseConnection(const TDesC& aConnectionName)
+	{
+    RConnection* c = iConns.Find(aConnectionName);
+	if (c==NULL)
+		return KErrNotFound;
+
+	c->Close();
+	return KErrNone;
+	}
+
+//
+//connection events
+//(each event notification request is encapsulated in a "EventContainer" that can easily be stored in a map.)
+
+TInt CCEsockTestBase::RegisterForProgressNotificationEvent(const TEventContainerParams& aParams)
+	{
+	TEsockTestEventContainer* ec = iConnEvents.Find(aParams.iEventName);
+	if (ec==NULL)
+		{
+		ec = new TEsockTestEventContainer;
+		if (ec==NULL)
+			return KErrNoMemory;
+
+		TInt error = iConnEvents.Add(ec,aParams.iEventName);
+		if (error!=KErrNone)
+			{
+			delete ec;
+			return error;
+			}
+		}
+
+	__ASSERT_DEBUG(ec->iEventReceived != KRequestPending, User::Panic(KSpecAssert_ESockTestEsckTst, 1));
+	RConnection* conn = iConns.Find(aParams.iConnectionName);
+	if (conn==NULL)
+		{
+		return KErrNotFound;
+		}
+	
+	if (aParams.iEventMask == 0)
+		return KErrArgument;
+
+	conn->ProgressNotification(ec->iProgressBuf, ec->iEventReceived, aParams.iEventMask);
+	return KErrNone;
+	}
+
+TInt CCEsockTestBase::ReceiveProgressNotificationEvent(TNifProgress*&aNifProgress, const TDesC& aEventName, TUint aTimeoutInMiliSec)
+	{
+	TEsockTestEventContainer* ec = iConnEvents.Find(aEventName);
+	if (ec==NULL)
+		return KErrNotFound;
+	if (aTimeoutInMiliSec)
+	    {
+	    RTimer timer;
+	    timer.CreateLocal();	    
+	    TRequestStatus timerStatus;
+	    timer.After(timerStatus, aTimeoutInMiliSec * 1000);
+	    User::WaitForRequest(ec->iEventReceived, timerStatus);
+	    }
+	else
+	    {
+	    User::WaitForRequest(ec->iEventReceived);
+	    }
+	aNifProgress = (ec->iEventReceived.Int()==KErrNone)? &ec->iProgressBuf() : NULL;
+	return ec->iEventReceived.Int();
+	}
+
+
+//mobility extensions
+RCommsMobilityApiExt* CCEsockTestBase::FindMobilityExtension(const TDesC& aMobilityExtensionName)
+    {
+    return iMobilityExts.Find(aMobilityExtensionName);
+    }
+
+TInt CCEsockTestBase::CreateMobilityExtension(const TDesC& aMobilityExtensionName)
+    {
+    //check if this extension hasn't been created already
+    if (iMobilityExts.Find(aMobilityExtensionName)!=NULL)
+    	return KErrAlreadyExists;
+
+    RCommsMobilityApiExt* me = new RCommsMobilityApiExt;
+    if (me==NULL)
+    	return KErrNoMemory;
+
+	TInt error = iMobilityExts.Add(me,aMobilityExtensionName);
+	if (error!=KErrNone)
+		delete me;
+
+	return error;
+    }
+
+
+// Data monitoring
+//----------------
+
+RCommsDataMonitoringApiExt* CCEsockTestBase::FindDataMonitoringExtension(const TDataMonitorEventParams& aParams)
+   {
+   return iDataMonitoringExts.Find(aParams.iDataMonitorName);
+   }
+
+
+TEsockTestDataMonitoringResponse* CCEsockTestBase::FindDataMonitoringResponder(const TDataMonitorEventParams& aParams)
+	{
+	return iDataMonitoringEvents.Find(aParams.iEventName);
+	}
+
+TInt CCEsockTestBase::CreateDataMonitoringExtension(const TDataMonitorEventParams& aParams)
+   {
+   if(iDataMonitoringExts.Find(aParams.iDataMonitorName) != NULL)
+      {
+      return KErrAlreadyExists;
+      }
+
+   RCommsDataMonitoringApiExt* ext = new RCommsDataMonitoringApiExt();
+
+   if(!ext)
+      {
+    	return KErrNoMemory;
+      }
+
+   TInt error = iDataMonitoringExts.Add(ext, aParams.iDataMonitorName);
+   
+	if (error != KErrNone)
+      {
+      delete ext;
+      }
+
+	return error;
+   }
+
+TEsockTestDataMonitoringResponse* CCEsockTestBase::FindOrCreateDataMonitoringResponder(const TDataMonitorEventParams& aParams)
+	{
+	TEsockTestDataMonitoringResponse* response = FindDataMonitoringResponder(aParams);
+	if(response)
+		{
+		return response;
+		}
+	
+	if(NULL == (response = new TEsockTestDataMonitoringResponse()))
+		{
+		return NULL;
+		}
+
+	TInt err = iDataMonitoringEvents.Add(response, aParams.iEventName);
+	if(err != KErrNone)
+		{
+		delete response;
+		response = NULL;
+		}
+		
+	return response;
+	}
+	
+TInt CCEsockTestBase::OpenDataMonitoringExtension(const TDataMonitorEventParams& aParams)
+	{
+	RCommsSubSession* connOrSubConn = NULL;
+	
+	if(aParams.iConnectionName.Length() > 0)
+		{ // Open extension on an RConnection if specified
+		connOrSubConn = iConns.Find(aParams.iConnectionName);
+		if(!connOrSubConn) 
+			{
+			return KErrNotFound;
+			}
+		}
+	else if(aParams.iSubConnectionName.Length() > 0)
+		{ // Otherwise open extension on an RSubConnection
+		connOrSubConn = iSubConns.Find(aParams.iSubConnectionName);
+		if(!connOrSubConn) 
+			{
+			return KErrNotFound;
+			}
+		}
+	else
+		{ // Neither an RConnection or an RSubConnection was specified
+		return KErrArgument;
+		}
+	
+	RCommsDataMonitoringApiExt* ext = iDataMonitoringExts.Find(aParams.iDataMonitorName);
+	if(!ext)
+		{
+		return KErrNotFound;
+		}
+		
+	return ext->Open(*connOrSubConn);
+	}
+
+TInt CCEsockTestBase::CloseDataMonitoringExtension(const TDataMonitorEventParams& aParams)
+	{
+	RCommsDataMonitoringApiExt* ext = iDataMonitoringExts.Find(aParams.iDataMonitorName);
+	if(!ext)
+		{
+		return KErrNotFound;
+		}
+		
+	ext->Close();
+	
+	return KErrNone;
+	}
+
+TInt CCEsockTestBase::RequestDataTransferred(const TDataMonitorEventParams& aParams, TDes8& aResponseBuf)
+	{
+	RCommsDataMonitoringApiExt* ext = iDataMonitoringExts.Find(aParams.iDataMonitorName);
+	if(!ext)
+		{
+		return KErrNotFound;
+		}
+
+	TRequestStatus status;	
+	ext->RequestDataTransferred(aResponseBuf, status);
+	User::WaitForRequest(status);
+	
+	return KErrNone;
+	}
+
+// Find saved stats from a previous DataTransferred request
+TDataMonitorStats* CCEsockTestBase::FetchSavedDataMonitorStats(const TDesC& aDataMonitorStatsSavedName)
+	{
+	return iSavedDataMonitorStats.Find(aDataMonitorStatsSavedName);
+	}
+
+// Save data monitor stats for future reference
+TInt CCEsockTestBase::SaveDataMonitorStats(const TDesC& aSavedName, TDataMonitorStats& aStatsToSave)
+	{
+	TInt err;
+	
+	// Simply add if doesn't already exist
+	if(iSavedDataMonitorStats.Find(aSavedName) == NULL)
+		{
+		err = iSavedDataMonitorStats.Add(&aStatsToSave, aSavedName);
+		}
+	else
+		{
+		// Already exists so delete and add in order to replace
+		iSavedDataMonitorStats.Remove(aSavedName);
+		err = iSavedDataMonitorStats.Add(&aStatsToSave, aSavedName);
+		}
+		
+	return err;
+	}
+
+TInt CCEsockTestBase::RequestDataReceivedNotification(const TDataMonitorEventParams& aParams)
+	{
+	RCommsDataMonitoringApiExt* ext = FindDataMonitoringExtension(aParams);
+	if(!ext)
+		{
+		return KErrNotFound;
+		}
+
+	TEsockTestDataMonitoringResponse* response =	FindOrCreateDataMonitoringResponder(aParams);
+	if(!response)
+		{
+		return KErrNoMemory;
+		}
+
+	ext->RequestDataReceivedNotification(aParams.iDelta, aParams.iMinExpectedVolume, response->iBuffer, response->iStatus);
+	
+	return KErrNone;
+	}
+
+TInt CCEsockTestBase::CancelDataReceivedNotificationRequest(const TDataMonitorEventParams& aParams)
+	{
+	RCommsDataMonitoringApiExt* ext = FindDataMonitoringExtension(aParams);	
+	if(!ext)
+		{
+		return KErrNotFound;
+		}
+
+	TEsockTestDataMonitoringResponse* response = FindOrCreateDataMonitoringResponder(aParams);
+	if(!response)
+		{
+		return KErrNoMemory;
+		}
+
+	ext->CancelDataReceivedNotificationRequest();
+	User::WaitForRequest(response->iStatus);
+	
+	// Return the status code from the cancellation
+	return response->iStatus.Int();
+	}
+
+TInt CCEsockTestBase::ReceiveDataReceivedNotification(const TDataMonitorEventParams& aParams, TDesC8*& aResponseBuf)
+	{
+	TEsockTestDataMonitoringResponse* response =	FindDataMonitoringResponder(aParams);
+	if(!response)
+		{
+		return KErrNotFound;
+		}
+
+	// Check that its not complete already
+	if(response->iComplete)
+		{
+		return KErrGeneral;
+		}
+
+	RTimer timer;
+	timer.CreateLocal();
+	
+	TRequestStatus timerStatus;
+	timer.After(timerStatus, response->iTimeout * 1000000);
+	
+	User::WaitForRequest(response->iStatus, timerStatus);
+	
+	TInt result;
+	if(response->iStatus.Int() != KErrNone)
+		{
+		result = KErrTimedOut;
+		}
+	else
+		{
+		timer.Cancel();
+		User::WaitForRequest(timerStatus);
+
+	   aResponseBuf = NULL;
+	   if(response->iStatus.Int() == KErrNone) 
+	   	{
+	   	aResponseBuf = &response->iBuffer;
+	   	}
+   	result = response->iStatus.Int();
+   	response->iComplete = ETrue;
+		}
+		
+	timer.Close();
+	
+	return result;
+	}
+
+TInt CCEsockTestBase::RequestDataSentNotification(const TDataMonitorEventParams& aParams)
+	{
+	// Find the data monitoring extension to start with
+	RCommsDataMonitoringApiExt* ext = FindDataMonitoringExtension(aParams);
+	if(!ext)
+		{
+		return KErrNotFound;
+		}
+		
+	// Find the data monitoring responder that goes with it
+	TEsockTestDataMonitoringResponse* response =	FindDataMonitoringResponder(aParams);
+	if(!response)
+		{
+		return KErrNotFound;
+		}
+
+	// Make the request on the data monitor
+	ext->RequestDataSentNotification(aParams.iDelta, aParams.iMinExpectedVolume, response->iBuffer, response->iStatus);
+	
+	return KErrNone;
+	}
+
+TInt CCEsockTestBase::CancelDataSentNotificationRequest(const TDataMonitorEventParams& aParams)
+	{
+	RCommsDataMonitoringApiExt* ext = FindDataMonitoringExtension(aParams);
+	if(!ext)
+		{
+		return KErrNotFound;
+		}
+
+	TEsockTestDataMonitoringResponse* response =	FindDataMonitoringResponder(aParams);
+	if(!response)
+		{
+		return KErrNotFound;
+		}
+
+	ext->CancelDataSentNotificationRequest();
+	User::WaitForRequest(response->iStatus);
+	
+	// Return the status code from the cancellation
+	return response->iStatus.Int();
+	}
+
+TInt CCEsockTestBase::ReceiveDataSentNotification(const TDataMonitorEventParams& aParams, TDesC8*& aResponseBuf)
+	{
+	TEsockTestDataMonitoringResponse* response =	FindDataMonitoringResponder(aParams);
+	if(!response)
+		{
+		return KErrNotFound;
+		}
+
+	// Check that its not complete already
+	if(response->iComplete)
+		{
+		return KErrGeneral;
+		}
+
+	RTimer timer;
+	timer.CreateLocal();
+	
+	TRequestStatus timerStatus;
+	timer.After(timerStatus, response->iTimeout * 1000000);
+	
+	User::WaitForRequest(response->iStatus, timerStatus);
+	
+	TInt result;
+	if(response->iStatus.Int() != KErrNone)
+		{
+		result = KErrTimedOut;
+		}
+	else
+		{
+		timer.Cancel();
+		User::WaitForRequest(timerStatus);
+
+	   aResponseBuf = NULL;
+	   if(response->iStatus.Int() == KErrNone) 
+	   	{
+	   	aResponseBuf = &response->iBuffer;
+	   	}
+   	result = response->iStatus.Int();
+   	response->iComplete = ETrue;
+		}
+		
+	timer.Close();
+	
+	return result;
+	}
+
+#if 0
+//
+//CommsServer functions library
+
+TInt CCEsockTestBase::CreateCommsServer(const TDesC& aCommsServerName)
+	{
+    //check if this comms server hasn't been created already
+    if (iCommsServers.Find(aCommsServerName)!=NULL)
+    	return KErrAlreadyExists;
+
+    RConnection* c = new RConnection;
+    if (c==NULL)
+    	return KErrNoMemory;
+
+	TInt error = iConns.Add(c,aConnectionName);
+	if (error!=KErrNone)
+		delete c;
+
+	return error;
+	}
+
+TInt CCEsockTestBase::StartCommsServer(const TRCommsServerParams& aParams, TRequestStatus& aRequestStatus)
+	{
+	RConnManager* c = iCommsServers.Find(aParams.iCommsServerName);
+	if (c==NULL)
+		return KErrNotFound;
+	
+	c->Start(prefs,aRequestStatus);
+		}
+	else if (aParams.iStartWithOldPreferences)
+		{
+		TCommDbConnPref prefs;
+		prefs.SetBearerSet(aParams.iBearer);
+		prefs.SetIapId(aParams.iIAP);
+		c->Start(prefs,aRequestStatus);
+		}
+	else
+		c->Start(aRequestStatus);
+
+	return KErrNone;
+	}
+
+TInt CCEsockTestBase::StartConnection(const TRConnectionParams& aParams)
+	{
+    RConnection* c = iConns.Find(aParams.iConnectionName);
+	if (c==NULL)
+		return KErrNotFound;
+
+	TInt error;
+	if (aParams.iStartWithSnapPreferences)
+		{
+		TCommSnapPref prefs;
+		prefs.SetSnap(aParams.iSNAP);
+		error = c->Start(prefs);
+		}
+	else if (aParams.iStartWithOldPreferences)
+		{
+		TCommDbConnPref prefs;
+		prefs.SetBearerSet(aParams.iBearer);
+		prefs.SetIapId(aParams.iIAP);
+		error = c->Start(prefs);
+		}
+	else
+		error = c->Start();
+
+	return error;
+	}
+
+TInt CCEsockTestBase::StopConnection(const TRConnectionParams& aParams)
+    {
+    RConnection* c = iConns.Find(aParams.iConnectionName);
+	if (c==NULL)
+		return KErrNotFound;
+
+	c->Stop(aParams.iConnStopType);
+	return KErrNone;
+    }
+#endif
+
+
+// SubConnections
+//---------------
+
+RSubConnection* CCEsockTestBase::FindSubConnection(const TDesC& aSubConnectionName)
+    {
+    return iSubConns.Find(aSubConnectionName);
+    }
+
+TInt CCEsockTestBase::CreateSubConnection(const TDesC& aSubConnectionName)
+	{
+    //check if this sub connection hasn't been created already
+    if (iSubConns.Find(aSubConnectionName)!=NULL)
+    	return KErrAlreadyExists;
+
+    RSubConnection* sc = new RSubConnection;
+    if (sc==NULL)
+    	return KErrNoMemory;
+
+	TInt error = iSubConns.Add(sc,aSubConnectionName);
+	if (error!=KErrNone)
+		delete sc;
+
+	return error;
+	}
+
+TInt CCEsockTestBase::OpenSubConnection(const TRSubConnectionParams& aParams)
+	{
+    RSocketServ* ss = iSockServs.Find(aParams.iSockServName);
+    if (ss==NULL)
+		return KErrNotFound;
+
+    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
+	if (sc==NULL)
+		return KErrNotFound;
+
+	RConnection* c = iConns.Find(aParams.iConnectionName);
+	if (c==NULL)
+		return KErrNotFound;
+
+	return sc->Open(*ss, aParams.iSubConnType, *c);
+	}
+
+TInt CCEsockTestBase::CloseSubConnection(const TDesC& aSubConnectionName)
+	{
+    RSubConnection* sc = iSubConns.Find(aSubConnectionName);
+	if (sc==NULL)
+		return KErrNotFound;
+
+	sc->Close();
+	return KErrNone;
+	}
+
+TInt CCEsockTestBase::AddSocketToSubConnection(const TRSubConnectionParams& aParams, TRequestStatus& aStatus)
+    {
+    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
+	if (sc==NULL)
+		return KErrNotFound;
+
+    RSocket* s = iSocks.Find(aParams.iSocketName);
+	if (s==NULL)
+		return KErrNotFound;
+
+	sc->Add(*s,aStatus);
+	return KErrNone;
+	}
+
+TInt CCEsockTestBase::RemoveSocketFromSubConnection(const TRSubConnectionParams& aParams, TRequestStatus& aStatus)
+    {
+    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
+	if (sc==NULL)
+		return KErrNotFound;
+
+    RSocket* s = iSocks.Find(aParams.iSocketName);
+	if (s==NULL)
+		return KErrNotFound;
+
+	sc->Remove(*s,aStatus);
+	return KErrNone;
+    }
+
+TInt CCEsockTestBase::SetSubConnectionParameters(const TRSubConnectionParams& aParams)
+	{
+    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
+	if (sc==NULL)
+		return KErrNotFound;
+
+	RSubConParameterBundle* scp = iSubConnParams.Find(aParams.iSubConnectionParamsName);
+	if (scp==NULL)
+		return KErrNotFound;
+
+	return sc->SetParameters(*scp);
+	}
+
+TInt CCEsockTestBase::GetSubConnectionParameters(const TRSubConnectionParams& aParams)
+	{
+    if (iSubConnParams.Find(aParams.iSubConnectionParamsName)!=NULL)
+    	return KErrAlreadyExists;
+
+    RSubConParameterBundle* scp = new RSubConParameterBundle;
+    if (scp==NULL)
+    	return KErrNoMemory;
+
+	TInt error = iSubConnParams.Add(scp,aParams.iSubConnectionParamsName);
+	if (error!=KErrNone)
+	    {
+		delete scp;
+		return error;
+	    }
+
+    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
+	if (sc==NULL)
+		return KErrNotFound;
+
+	return sc->GetParameters(*scp);
+	}
+
+TInt CCEsockTestBase::CompareIntegerValues(const TCompareIntegersParams& aParams, TInt& aDifference)
+	{
+    TInt* value1;
+    value1 = iIntegerValues.Find(aParams.iValue1);
+    if(value1 == NULL)
+    	{
+		return KErrNotFound;
+		}
+
+    TInt* value2;
+    value2 = iIntegerValues.Find(aParams.iValue2);
+	if (value2 == NULL)
+    	{
+		return KErrNotFound;
+		}
+
+	// Confirm the values
+	aDifference = (*value1 - *value2 + aParams.iDifference);
+	return KErrNone;
+	}
+
+TInt CCEsockTestBase::AwaitRequestStatus(const TDesC& aStatusName)
+	{
+    TRequestStatus* req = iRequestStatuses.Find(aStatusName);
+    ASSERT(req);
+   	User::WaitForRequest(*req);
+   	return req->Int();
+	}
+
+//
+//subconnection parameters
+TInt CCEsockTestBase::CreateRSubConnectionParams(const TDesC& aSubConParamsName)
+	{
+	RSubConParameterBundle* scp = new RSubConParameterBundle;
+    if (scp==NULL)
+    	return KErrNoMemory;
+
+	TInt error = iSubConnParams.Add(scp,aSubConParamsName);
+	if (error!=KErrNone)
+		delete scp;
+
+	return error;
+	}
+// SBLP functions
+
+TInt CCEsockTestBase::CreateTFlowId(const TDesC& aFlowIdName)
+	{
+	TFlowId* fid = new TFlowId;
+	if (fid==NULL)
+    	return KErrNoMemory;
+
+	TInt error = iFlowId.Add(fid,aFlowIdName);
+	if (error!=KErrNone)
+		delete fid;
+
+	return error;
+
+	}
+
+TFlowId* CCEsockTestBase::FindTFlowId(const TDesC& aFlowId)
+	{
+		return iFlowId.Find(aFlowId);
+	}
+
+TInt CCEsockTestBase::CloseRSubConnectionParams(const TDesC& aSubConParamsName)
+	{
+	RSubConParameterBundle* scp = iSubConnParams.Find(aSubConParamsName);
+	if (scp==NULL)
+		return KErrNotFound;
+
+	scp->Close();
+	return KErrNone;
+	}
+
+
+RSubConParameterBundle* CCEsockTestBase::FindRSubConnectionParams(const TDesC& aSubConParamsName)
+	{
+		return iSubConnParams.Find(aSubConParamsName);
+	}
+
+CSubConParameterFamily* CCEsockTestBase::FindRSubConnectionParameterFamily(const TDesC& aSubConParamsName, const TInt aFamilyId)
+    {
+    RSubConParameterBundle* bundle = FindRSubConnectionParams(aSubConParamsName);
+    if (bundle==NULL)
+        return NULL;
+
+    return bundle->FindFamily(aFamilyId);
+    }
+
+//
+//subconnection events
+//(each event notification request is encapsulated in a "EventContainer" that can easily be stored in a map.)
+
+TInt CCEsockTestBase::RegisterForRSubConnectionEvent(const TEventContainerParams& aParams)
+    {
+    TEsockTestEventContainer* ec = iSubConnEvents.Find(aParams.iEventName);
+	if (ec==NULL)
+	    {
+    	ec = new TEsockTestEventContainer;
+        if (ec==NULL)
+    	    return KErrNoMemory;
+
+    	TInt error = iSubConnEvents.Add(ec,aParams.iEventName);
+	    if (error!=KErrNone)
+	        {
+		    delete ec;
+		    return error;
+	        }
+	    }
+
+    __ASSERT_DEBUG(ec->iEventReceived != KRequestPending, User::Panic(KSpecAssert_ESockTestEsckTst, 2));
+    RSubConnection* sc = iSubConns.Find(aParams.iSubConnectionName);
+	if (sc==NULL)
+	    {
+		return KErrNotFound;
+	    }
+
+	//check if we should simply register for all event
+	if (aParams.iAllEvents)
+	    {
+        sc->EventNotification(static_cast<TNotificationEventBuf&>(ec->iEventNotifBuf), EFalse, ec->iEventReceived);
+	    return KErrNone;
+	    }
+
+	//no.. what about only generic ones?
+	if (aParams.iGenericEvents)
+	    {
+        sc->EventNotification(static_cast<TNotificationEventBuf&>(ec->iEventNotifBuf), ETrue, ec->iEventReceived);
+	    return KErrNone;
+	    }
+
+	//no.. reqister for specific events
+    if (aParams.iEventMask == 0)
+        return KErrArgument;
+
+    (ec->iSubconnEventFilter).iEventGroupUid = KSubConnGenericEventsImplUid;
+    (ec->iSubconnEventFilter).iEventMask = aParams.iEventMask;
+    sc->EventNotification(static_cast<TNotificationEventBuf&>(ec->iEventNotifBuf), &(ec->iSubconnEventFilter), 1, ec->iEventReceived);
+    return KErrNone;
+    }
+
+TInt CCEsockTestBase::ReceiveRSubConnectionEvent(TNotificationEventBuf*& aBufferPtr, const TDesC& aSubConEventName)
+    {
+    TEsockTestEventContainer* ec = iSubConnEvents.Find(aSubConEventName);
+	if (ec==NULL)
+		return KErrNotFound;
+
+    User::WaitForRequest(ec->iEventReceived);
+    aBufferPtr = (ec->iEventReceived.Int()==KErrNone)? &static_cast<TNotificationEventBuf&>(ec->iEventNotifBuf) : NULL;
+    __ASSERT_DEBUG(aBufferPtr->GroupId(), User::Panic(KSpecAssert_ESockTestEsckTst, 3));
+    return ec->iEventReceived.Int();
+    }
+
+//
+//mobility notifications
+//(each notification request is encapsulated in a "EventContainer" that can easily be stored in a map.)
+
+TInt CCEsockTestBase::RegisterForMobilityNotification(const TEventContainerParams& aParams)
+    {
+    TEsockTestEventContainer* ec = iConnEvents.Find(aParams.iEventName);
+	if (ec==NULL)
+	    {
+    	ec = new TEsockTestEventContainer;
+        if (ec==NULL)
+    	    return KErrNoMemory;
+
+    	TInt error = iConnEvents.Add(ec,aParams.iEventName);
+	    if (error!=KErrNone)
+	        {
+		    delete ec;
+		    return error;
+	        }
+	    }
+
+    RCommsMobilityApiExt* me = iMobilityExts.Find(aParams.iMobilityExtName);
+	if (me==NULL)
+	    {
+		return KErrNotFound;
+	    }
+
+	//reqister
+    __ASSERT_DEBUG(ec->iEventReceived != KRequestPending, User::Panic(KSpecAssert_ESockTestEsckTst, 4));
+	me->RegisterForMobilityNotification(ec->iEventNotifBuf,ec->iEventReceived);
+
+    return KErrNone;
+    }
+
+TInt CCEsockTestBase::ReceiveMobilityNotification(TDesC8*& aBufferPtr, const TEventContainerParams& aParams)
+    {
+    TEsockTestEventContainer* ec = iConnEvents.Find(aParams.iEventName);
+	if (ec==NULL)
+		return KErrNotFound;
+
+    RCommsMobilityApiExt* me = iMobilityExts.Find(aParams.iMobilityExtName);
+	if (me==NULL)
+		return KErrNotFound;
+
+	if (aParams.iTimeoutMiliSecs!=0)
+		{
+		TRequestStatus timeoutStatus;
+		RTimer timer;
+		timer.CreateLocal();
+		timer.After(timeoutStatus,aParams.iTimeoutMiliSecs*1000);
+    	User::WaitForRequest(ec->iEventReceived,timeoutStatus);
+    	timer.Cancel();
+    	timer.Close();
+    	if (ec->iEventReceived==KRequestPending)
+    		{
+    		me->CancelMobilityNotification();
+    		}
+    	}
+    else
+    	{
+    	User::WaitForRequest(ec->iEventReceived);
+    	
+    	}
+
+    aBufferPtr = (ec->iEventReceived.Int()==KErrNone)? &ec->iEventNotifBuf : NULL;
+    return ec->iEventReceived.Int();
+    }
+
+//
+//cleanup
+
+void CCEsockTestBase::CleanAll()
+	{
+    iSockServs.ResetAndDestroy();
+    iSocks.ResetAndDestroy();
+	iConns.ResetAndDestroy();
+	iSubConns.ResetAndDestroy();
+	iConnectionServs.ResetAndDestroy();
+	iMobilityExts.ResetAndDestroy();
+	iDataMonitoringExts.ResetAndDestroy();
+	iDataMonitoringEvents.ResetAndDestroy();
+	iNotifWatchers.ResetAndDestroy();
+    TInt i = 0;
+    for (i = 0; i < iSubConnParams.Count(); i++)
+        {
+        iSubConnParams[i]->Close();
+        }
+	iSubConnParams.ResetAndDestroy();
+	iSubConnEvents.ResetAndDestroy();
+	iConnEvents.ResetAndDestroy();
+	iFlowId.ResetAndDestroy();
+	iIntegerValues.ResetAndDestroy();
+	iRequestStatuses.ResetAndDestroy();
+	}
+
+//
+//general utils
+
+
+//
+// Simtsy Trigger Event functionality
+
+/**
+ Instructs the simtsy to complete a given request/notification. The supported commands are given in TEtelRequestType.
+ The parameter supplied in aNewValue instructs the simtsy what data from the config.txt to use in the completion of the request.
+ The aNewValue is the index to the entry to be used to complete the request for the current test step section, ie if aNewValue
+ is 0, iTestNumber is 3, and aEtelCommand is ENetworkQoSChange, the entry will complete any NotifyNetworkQoSChange calls
+ with data from the first QosNetworkNotification= entry of section [test3] in the config.txt file
+*/
+
+
+TInt CCEsockTestBase::EtelRequestL(TUint aEventKey, TInt aNewValue)
+	{
+  	// simtsy will listen for any changes to the property, and complete the corresponding request
+	TInt error = RProperty::Set(KUidPSSimTsyCategory, aEventKey, aNewValue);
+
+	return error;
+	}
+
+
+//
+
+
+
+//
+//simtsy functionality
+
+TInt TSimTsy::Start()
+    {
+    //define name of the Phone module to be used for the RTelServer
+    _LIT(KMtsyName, "SIM");
+    TInt res = StartC32();
+    if (res!=KErrNone)
+            return res;
+    TInt error = iServer.Connect();
+    if (error!=KErrNone)
+            return error;
+    error = iServer.LoadPhoneModule(KMtsyName);
+   	if (error!=KErrNone)
+            return error;
+   	error = iPhone.Open(iServer, KPhoneName);
+    if (error!=KErrNone)
+            return error;
+    error = SetTestNumber(0);
+	return error;
+    }
+
+
+void TSimTsy::Stop()
+    {
+    iPhone.Close();
+    iServer.Close();
+    }
+
+
+TInt TSimTsy::SetTestNumber(TInt aTestSectionNumber)
+	{
+   	return RProperty::Set(KUidPSSimTsyCategory, KPSSimTsyTestNumber, aTestSectionNumber);
+	}
+
+//
+