diff -r 000000000000 -r dfb7c4ff071f datacommsserver/esockserver/test/TE_Socket/TestStepSocket.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/datacommsserver/esockserver/test/TE_Socket/TestStepSocket.cpp	Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,513 @@
+// 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:
+// Contains definition of CTestStepSocket which is the base class 
+// for all the Socket Test Step classes (p.s. very dummy class) 
+// 
+//
+
+// EPOC includes
+#include <e32base.h>
+#include <es_sock.h>
+#include <test/es_dummy.h>
+
+// Test system includes
+#include "TestStepSocket.h"
+
+
+// static consts
+const TUint CTestStepSocket::KNumTestSockets = 10;
+const TInt CTestStepSocket::KNumExhaustiveSockets = 100;
+const TInt CTestStepSocket::KNumStretchOpens = 16;
+
+_LIT(KProtocolName, "Dummy Protocol 1");          // Name of test protocol to use in these tests
+_LIT8(KSendStringTest, "Bad descriptor"); // Sample testdata to send in these tests
+
+const TInt segmentlengthtest = 1;
+const TInt txlengthtest = 42; // Length of KSEndStringTest Its useful to be const
+
+// constructor
+CTestStepSocket::CTestStepSocket() : iErrText()
+	{
+	}
+
+// destructor
+CTestStepSocket::~CTestStepSocket()
+	{
+	}
+
+
+enum TVerdict CTestStepSocket::doTestStepL()
+	{
+	
+	TRAPD(trapRet,
+		Logger().ShareAuto();
+	enum TVerdict stepRet = InternalDoTestStepL();
+	if (stepRet !=EPass)
+		{
+		SetTestStepResult(stepRet);
+		}
+		)
+		
+		if (trapRet != KErrNone)
+			{
+			SetTestStepResult(EFail);
+			return EFail;
+			}
+		return EPass;
+	};
+
+
+// extra logging methods
+const TPtrC& CTestStepSocket::EpocErrorToText(const TInt aErrCode)
+/**
+Convert a Error code to text.
+
+  @param aError error code to display as text.
+  @return Text describing the error.
+  */
+	{
+	//	TPtr errText;
+	switch (aErrCode)
+		{
+		case KErrNone:
+			iErrText.Set(_L("KErrNone"));
+			break;
+		case KErrNotFound:
+			iErrText.Set(_L("KErrNotFound"));
+			break;
+		case KErrGeneral:
+			iErrText.Set(_L("KErrGeneral"));
+			break;
+		case KErrCancel:
+			iErrText.Set(_L("KErrCancel"));
+			break;
+		case KErrNoMemory:
+			iErrText.Set(_L("KErrNoMemory"));
+			break;
+		case KErrNotSupported:
+			iErrText.Set(_L("KErrNotSupported"));
+			break;
+		case KErrArgument:
+			iErrText.Set(_L("KErrArgument"));
+			break;
+		case KErrTotalLossOfPrecision:
+			iErrText.Set(_L("KErrTotalLossOfPrecision"));
+			break;
+		case KErrBadHandle:
+			iErrText.Set(_L("KErrBadHandle"));
+			break;
+		case KErrOverflow:
+			iErrText.Set(_L("KErrOverflow"));
+			break;
+		case KErrUnderflow:
+			iErrText.Set(_L("KErrUnderflow"));
+			break;
+		case KErrAlreadyExists:
+			iErrText.Set(_L("KErrAlreadyExists"));
+			break;
+		case KErrPathNotFound:
+			iErrText.Set(_L("KErrPathNotFound"));
+			break;
+		case KErrDied:
+			iErrText.Set(_L("KErrDied"));
+			break;
+		case KErrInUse:
+			iErrText.Set(_L("KErrInUse"));
+			break;
+		case KErrServerTerminated:
+			iErrText.Set(_L("KErrServerTerminated"));
+			break;
+		case KErrServerBusy:
+			iErrText.Set(_L("KErrServerBusy"));
+			break;
+		case KErrCompletion:
+			iErrText.Set(_L("KErrCompletion"));
+			break;
+		case KErrNotReady:
+			iErrText.Set(_L("KErrNotReady"));
+			break;
+		case KErrUnknown:
+			iErrText.Set(_L("KErrUnknown"));
+			break;
+		case KErrCorrupt:
+			iErrText.Set(_L("KErrCorrupt"));
+			break;
+		case KErrAccessDenied:
+			iErrText.Set(_L("KErrAccessDenied"));
+			break;
+		case KErrLocked:
+			iErrText.Set(_L("KErrLocked"));
+			break;
+		case KErrWrite:
+			iErrText.Set(_L("KErrWrite"));
+			break;
+		case KErrDisMounted:
+			iErrText.Set(_L("KErrDisMounted"));
+			break;
+		case KErrEof:
+			iErrText.Set(_L("KErrEof"));
+			break;
+		case KErrDiskFull:
+			iErrText.Set(_L("KErrDiskFull"));
+			break;
+		case KErrBadDriver:
+			iErrText.Set(_L("KErrBadDriver"));
+			break;
+		case KErrBadName:
+			iErrText.Set(_L("KErrBadName"));
+			break;
+		case KErrCommsLineFail:
+			iErrText.Set(_L("KErrCommsLineFail"));
+			break;
+		case KErrCommsFrame:
+			iErrText.Set(_L("KErrCommsFrame"));
+			break;
+		case KErrCommsOverrun:
+			iErrText.Set(_L("KErrCommsOverrun"));
+			break;
+		case KErrCommsParity:
+			iErrText.Set(_L("KErrCommsParity"));
+			break;
+		case KErrTimedOut:
+			iErrText.Set(_L("KErrTimedOut"));
+			break;
+		case KErrCouldNotConnect:
+			iErrText.Set(_L("KErrCouldNotConnect"));
+			break;
+		case KErrCouldNotDisconnect:
+			iErrText.Set(_L("KErrCouldNotDisconnect"));
+			break;
+		case KErrDisconnected:
+			iErrText.Set(_L("KErrDisconnected"));
+			break;
+		case KErrBadLibraryEntryPoint:
+			iErrText.Set(_L("KErrBadLibraryEntryPoint"));
+			break;
+		case KErrBadDescriptor:
+			iErrText.Set(_L("KErrBadDescriptor"));
+			break;
+		case KErrAbort:
+			iErrText.Set(_L("KErrAbort"));
+			break;
+		case KErrTooBig:
+			iErrText.Set(_L("KErrTooBig"));
+			break;
+		case KErrCannotFindProtocol:
+			iErrText.Set(_L("KErrCannotFindProtocol"));
+			break;
+		case KErrPermissionDenied:
+			iErrText.Set(_L("KErrPermissionDenied"));
+			break;	
+		default:
+			iErrBuf.Format(_L(" %d"),aErrCode);
+			iErrText.Set(iErrBuf.Ptr());
+			break;
+		}
+		return iErrText;
+	}	
+	
+// static threads
+
+void CTestStepSocket::DoCreateSubsessionsL(CTestStepSocket *aTestStep, TInt aNumSubsess)
+	{
+	aTestStep->Logger().WriteFormat(_L("SocketThread : eSock client test sub thread - creating sockets and resolvers"));
+	
+	aTestStep->Logger().WriteFormat(_L("Attempting to connect to socket server"));
+	RSocketServ ss;
+	TInt ret = ss.Connect();
+	if (KErrNone != ret)
+		{
+		aTestStep->Logger().WriteFormat(_L("SocketThread : Connect returned %d"), ret);
+		User::Leave(ret);
+		}
+	
+	TProtocolDesc protoInfo;
+	ret = ss.FindProtocol(_L("Dummy Protocol 1"), protoInfo);
+	if (KErrNone != ret)
+		{
+		aTestStep->Logger().WriteFormat(_L("SocketThread : FindProtocol returned %d"), ret);
+		User::Leave(ret);
+		}
+	
+	aTestStep->Logger().WriteFormat(_L("SocketThread : Making %d sockets, host resolvers, service resolvers, net databases"), aNumSubsess);
+	
+	RSocket* sock = new(ELeave) RSocket[aNumSubsess];
+	RHostResolver* hostR = new(ELeave) RHostResolver[aNumSubsess];
+	RServiceResolver* servR = new(ELeave) RServiceResolver[aNumSubsess];
+	RNetDatabase* netDb = new(ELeave) RNetDatabase[aNumSubsess];
+	
+	for (TInt i=0;i<aNumSubsess;i++)
+		{
+		ret = sock[i].Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);
+		if (KErrNone != ret)
+			{
+			aTestStep->Logger().WriteFormat(_L("SocketThread : Socket Open returned %d"), ret);
+			User::Leave(ret);
+			}
+		ret = hostR[i].Open(ss, protoInfo.iAddrFamily, protoInfo.iProtocol);
+		if (KErrNone != ret)
+			{
+			aTestStep->Logger().WriteFormat(_L("SocketThread : Host Resolver Open returned %d"), ret);
+			User::Leave(ret);
+			}
+		ret = servR[i].Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);
+		if (KErrNone != ret)
+			{
+			aTestStep->Logger().WriteFormat(_L("SocketThread : Service Resolver Open returned %d"), ret);
+			User::Leave(ret);
+			}
+		
+		ret = netDb[i].Open(ss, protoInfo.iAddrFamily, protoInfo.iProtocol);
+		if (KErrNone != ret)
+			{
+			aTestStep->Logger().WriteFormat(_L("SocketThread : Net Database Open returned %d"), ret);
+			User::Leave(ret);
+			}
+		}
+	}
+
+TInt CTestStepSocket::SocketThread(TAny * anArg)
+	{
+	
+	TSocketThreadArg* tArg = static_cast<TSocketThreadArg*>(anArg); 
+	CTestStepSocket *h = tArg->iHandle;
+	
+	TInt trapRet;
+	CTrapCleanup *cleanup = CTrapCleanup::New(); //Creates and then installs the cleanup stack
+	if (cleanup)
+		{
+		TRAP(trapRet, DoCreateSubsessionsL(h, tArg->iNumSockets));
+		}
+	else
+		{
+		trapRet = KErrNoMemory;
+		}
+
+	delete cleanup;
+	RSemaphore *s = tArg->iSem;
+	s->Signal();
+	User::WaitForAnyRequest();
+
+	return trapRet;
+	}
+
+	
+	
+TInt CTestStepSocket::ConnectThread(TAny * anArg)
+	{
+	TSocketThreadArg* tArg = static_cast<TSocketThreadArg*>(anArg); 
+	CTestStepSocket *h = tArg->iHandle;
+	
+	CTrapCleanup *cleanup = CTrapCleanup::New();
+	if (!cleanup)
+		{
+		tArg->iSem->Signal();
+		return KErrNoMemory;
+		}
+	
+	TInt trapRet;
+	TRAP(trapRet,
+		h->Logger().WriteFormat(_L("ConnectThread : eSock client test sub thread - connect and disconnect"));
+	
+	h->Logger().WriteFormat(_L("Attempting to connect to socket server"));
+	RSocketServ ss;
+	TInt ret = ss.Connect();
+	if (KErrNone != ret)
+		{
+		h->Logger().WriteFormat(_L("ConnectThread : Connect returned %d"), ret);
+		delete cleanup;
+		tArg->iSem->Signal();
+		return ret;
+		}
+	ss.Close();
+	
+	)
+		
+		delete cleanup;
+	
+	tArg->iSem->Signal();
+	
+	return trapRet;
+	}
+
+
+TInt CTestStepSocket::BadHandleThread(TAny* anArg)
+	{
+	TSocketThreadArg* tArg = static_cast<TSocketThreadArg*>(anArg); 
+	CTestStepSocket *h = tArg->iHandle;
+	
+	CTrapCleanup *cleanup = CTrapCleanup::New();
+	if (!cleanup)
+		{
+		return KErrNoMemory;
+		}
+	
+	TInt trapRet;
+	TRAP(trapRet,
+		h->Logger().WriteFormat(_L("BadHandleThread : eSock client test sub thread - use bad handle"));
+	RSocketServ ss;
+	TInt ret = ss.Connect();
+	if (KErrNone != ret)
+		{
+		h->Logger().WriteFormat(_L("SocketThread : Connect returned %d"), ret);
+		delete cleanup;
+		return ret;
+		}
+	
+	// Give socket a bad handle
+	RSocket socket;
+	*(RSessionBase*)(&socket)=ss;
+	*(((TInt*)&socket)+(sizeof(RSessionBase)/sizeof(TInt))) = 4;
+	
+	// attempt to use it - should panic
+	TSockAddr addr;
+	socket.LocalName(addr);
+	
+	)
+		// Shouldn't get there (panic before ;-)
+		delete cleanup; //really a waste of time because will not get here. Just here for neatness
+	
+	return trapRet;
+	}
+
+TInt CTestStepSocket::ReadTwiceThread(TAny* anArg)
+	{
+	TSocketThreadArg* tArg = static_cast<TSocketThreadArg*>(anArg); 
+	CTestStepSocket *h = tArg->iHandle;
+	
+	CTrapCleanup *cleanup = CTrapCleanup::New();
+	if (!cleanup)
+		{
+		return KErrNoMemory;
+		}
+	
+	TInt trapRet;
+	
+	TRAP(trapRet,
+		
+		h->Logger().WriteFormat(_L("ReadTwiceThread : eSock client test sub thread - read twice"));
+	
+	h->Logger().WriteFormat(_L("Attempting to connect to socket server"));
+	RSocketServ ss;
+	TInt ret = ss.Connect();
+	if (KErrNone != ret)
+		{
+		h->Logger().WriteFormat(_L("ReadTwiceThread : Connect returned %d"), ret);
+		delete cleanup;
+		return ret;
+		}
+	
+	RSocket socket;
+	h->Logger().WriteFormat(_L("ReadTwiceThread : Opening socket on dummy protocol 1"));
+	ret = socket.Open(ss, _L("Dummy Protocol 1"));
+	h->Logger().WriteFormat(_L("ReadTwiceThread : Open returned %d"), ret);
+	if (KErrNone != ret)
+		{
+		delete cleanup;
+		return ret;
+		}
+	
+	h->Logger().WriteFormat(_L("ReadTwiceThread : Attempting Reads - should panic"));
+	TRequestStatus stat(KRequestPending);
+	TBuf8<100> buf;
+	socket.Read(buf, stat);
+	socket.Read(buf, stat);
+	
+	//Make sure ESock has time to PANIC us before we exit.
+	// We expect ESock will PANIC us immediately upon receiving the
+	// IPC message for the second read.
+	User::After(5000000); 
+	
+	)
+		// Shouldn't get there (panic before ;-)
+		delete cleanup;
+	return trapRet;
+	}
+
+TInt CTestStepSocket::BadDescriptorThread(TAny* anArg)
+	{
+	TSocketThreadArg* tArg = static_cast<TSocketThreadArg*>(anArg); 
+	CTestStepSocket *h = tArg->iHandle;
+	RSocketServ server;
+	CTrapCleanup *cleanup = CTrapCleanup::New();
+	if (!cleanup)
+		{
+		return KErrNoMemory;
+		}
+	
+	TInt trapRet;
+	TRAP(trapRet,
+		
+		h->Logger().WriteFormat(_L("Connecting to Socket server"));
+	TInt ret = server.Connect();
+	
+	RSocket socket;
+	h->Logger().WriteFormat(_L("Openning socket"));
+	ret = socket.Open(server,KProtocolName);
+	
+	TRequestStatus status;
+	TSockAddr addr;
+	h->Logger().WriteFormat(_L("Connecting to socket"));
+	socket.Connect(addr,status);
+	User::WaitForRequest(status);
+	
+	h->Logger().WriteFormat(_L("Attempt is made to pass a negative descriptor."));
+	h->Logger().WriteFormat(_L("Esock panics when a Negative Descriptor is passed"));
+	
+	TBuf8<txlengthtest> logstr;
+	logstr.Copy(KSendStringTest);
+	TInt* plength=(TInt*)&logstr;
+	*plength=-42;
+	
+	// Send
+	TSockXfrLength length;
+	socket.Send(logstr, 0, status, length);
+	User::WaitForRequest(status);
+	
+	// Receive setup
+	TSockXfrLength rxlength;
+	TBuf8<segmentlengthtest> rxbuf;
+	
+	//Receive 0 octets
+	socket.Recv(rxbuf, 0, status, rxlength);
+	User::WaitForRequest(status);
+	
+	)
+		
+		delete cleanup;
+	
+	return trapRet;
+	
+	}
+
+TInt CTestStepSocket::OptimalConnect(RSocketServ& aSrv)
+	{
+    TSessionPref pref;
+    pref.iAddrFamily = KDummyAddrFamily;
+    pref.iProtocol = KDummyThree;
+	return aSrv.Connect(pref);
+	}
+
+TBool CSocketTestStep_OOMCapable::CheckForHeapFailNext()
+	{
+	if(iOOMSess.Handle() != KNullHandle)
+		{
+		// If ESOCK heaps are still in FailNext mode then we try to flag the termination
+		// of the loop to TEF by setting the local heap to fail. Because this might get
+		// "eaten" inside TEF before it checks we walk a failure point here too
+		return iOOMSess.__DbgCheckFailNext();
+		}
+	return ETrue;
+	}
+