diff -r 000000000000 -r dfb7c4ff071f datacommsserver/esockserver/test/TE_Socket/SocketTestSection8.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/datacommsserver/esockserver/test/TE_Socket/SocketTestSection8.cpp	Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,558 @@
+// 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:
+// This contains ESock Test cases from section 8
+// 
+//
+
+// EPOC includes
+#include <e32base.h>
+
+#include <es_sock_internal.h>
+
+// Test system includes
+#include "SocketTestSection8.h"
+#include "ES_DUMMY.H"
+
+
+// Test step 8.1
+const TDesC& CSocketTest8_1::GetTestName()
+	{
+	_LIT(ret,"Test8.1");
+	return ret;
+	}
+
+enum TVerdict CSocketTest8_1::InternalDoTestStepL( void )
+	{
+	TVerdict verdict = EPass;
+	
+	Logger().WriteFormat(_L("Test Purpose: Ioctl returns not started on null socket"));
+	
+	// connect to esock
+	Logger().WriteFormat(_L("Attempting to connect to socket server"));
+    RSocketServ ss;
+	TInt ret = OptimalConnect(ss);
+	CleanupClosePushL(ss);
+	Logger().WriteFormat(_L("Connect returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrNone == ret);
+	
+	//PG 14/02/2001
+	//Added test for defect: TOD-4QLDXY - Ioctl on incorrectly opened socket crashes socket server.
+	Logger().WriteFormat(_L("Opening a socket with no protocol"));
+	RSocket socketNoProtoDefined;
+	ret = socketNoProtoDefined.Open(ss);
+	Logger().WriteFormat(_L("Open returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrNone == ret);
+	
+	// see if it's started
+	Logger().WriteFormat(_L("Check Ioctl fails"));
+	TRequestStatus stat;
+	socketNoProtoDefined.Ioctl(KDummyIoctlCheckStarted, stat);
+	User::WaitForRequest(stat);
+	Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));
+	TESTL(KErrNotSupported == stat.Int());
+	socketNoProtoDefined.Close();
+	
+	CleanupStack::Pop(&ss);
+	ss.Close();
+	
+	SetTestStepResult(verdict);
+	return verdict;
+	}
+
+// Test step 8.2
+const TDesC& CSocketTest8_2::GetTestName()
+	{
+	_LIT(ret,"Test8.2");
+	return ret;
+	}
+
+enum TVerdict CSocketTest8_2::InternalDoTestStepL( void )
+	{
+	TVerdict verdict = EPass;
+	
+	Logger().WriteFormat(_L("Test Purpose: Ioctl observes InternalOptionBit"));
+	
+	// connect to esock
+	Logger().WriteFormat(_L("Attempting to connect to socket server"));
+    RSocketServ ss;
+	TInt ret = OptimalConnect(ss);
+	CleanupClosePushL(ss);
+	Logger().WriteFormat(_L("Connect returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrNone == ret);
+	
+	// get a protocol
+	Logger().WriteFormat(_L("Attempting to FindProtocol dummy protocol 1"));
+	TProtocolDesc protoInfo;
+	ret = ss.FindProtocol(_L("Dummy Protocol 1"), protoInfo);
+	Logger().WriteFormat(_L("FindProtocol returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrNone == ret);
+	
+	// check internal options bit
+	RSocket socket;
+	Logger().WriteFormat(_L("Opening a new socket"));
+	ret = socket.Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);
+	Logger().WriteFormat(_L("Open returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrNone == ret);
+	
+	Logger().WriteFormat(_L("Trying Ioctl on internal options bit"));
+	TRequestStatus stat;
+	socket.Ioctl(KInternalIoctlBit, stat);
+	User::WaitForRequest(stat);
+	Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));
+	TESTL(KErrAccessDenied == stat.Int());
+	
+	Logger().WriteFormat(_L("Trying to SetOpt internal options bit"));
+	ret = socket.SetOpt(KSocketInternalOptionBit, KSOLSocket);
+	Logger().WriteFormat(_L("SetOpt returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrAccessDenied == ret);
+	
+	Logger().WriteFormat(_L("Trying to GetOpt internal options bit"));
+	TPckgBuf<TBool> boolean;
+	ret = socket.GetOpt(KSocketInternalOptionBit, KSOLSocket, boolean);
+	Logger().WriteFormat(_L("GetOpt returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrAccessDenied == ret);
+	
+	Logger().WriteFormat(_L("Testing StartL() with Ioctl KDummyIoctlCheckStarted"));
+	socket.Ioctl(KDummyIoctlCheckStarted, stat, NULL, KIoctlDummyLevel);
+	User::WaitForRequest(stat);
+	Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));
+	TESTL(KErrNone == stat.Int());
+	
+	CleanupStack::Pop(&ss);
+	ss.Close();
+	
+	SetTestStepResult(verdict);
+	return verdict;
+	}
+
+// Test step 8.3
+const TDesC& CSocketTest8_3::GetTestName()
+	{
+	_LIT(ret,"Test8.3");
+	return ret;
+	}
+
+enum TVerdict CSocketTest8_3::InternalDoTestStepL( void )
+	{
+	TVerdict verdict = EPass;
+	
+	Logger().WriteFormat(_L("Test Purpose: Ioctl auto bind and check started"));
+	
+	// connect to esock
+	Logger().WriteFormat(_L("Attempting to connect to socket server"));
+    RSocketServ ss;
+	TInt ret = OptimalConnect(ss);
+	CleanupClosePushL(ss);
+	Logger().WriteFormat(_L("Connect returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrNone == ret);
+	
+	// get a protocol
+	Logger().WriteFormat(_L("Attempting to FindProtocol dummy protocol 1"));
+	TProtocolDesc protoInfo;
+	ret = ss.FindProtocol(_L("Dummy Protocol 1"), protoInfo);
+	Logger().WriteFormat(_L("FindProtocol returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrNone == ret);
+	
+	Logger().WriteFormat(_L("Opening a new socket"));
+	RSocket socket;
+	ret = socket.Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);
+	Logger().WriteFormat(_L("Open returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrNone == ret);
+	
+	Logger().WriteFormat(_L("Testing StartL() with Ioctl KDummyIoctlCheckStarted"));
+	TRequestStatus stat;
+	socket.Ioctl(KDummyIoctlCheckStarted, stat, NULL, KIoctlDummyLevel);
+	User::WaitForRequest(stat);
+	Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));
+	TESTL(KErrNone == stat.Int());
+	
+	Logger().WriteFormat(_L("Testing AutoBind()"));
+	TSockAddr addr;
+	Logger().WriteFormat(_L("Trying to Connect socket"));
+	socket.Connect(addr, stat);
+	User::WaitForRequest(stat);
+	Logger().WriteFormat(_L("Connect returned with status %S"), &EpocErrorToText(stat.Int()));
+	TESTL(KErrNone == stat.Int());
+	
+	Logger().WriteFormat(_L("Checking bound status with Ioctl"));
+	socket.Ioctl(KDummyIoctlCheckBound, stat, NULL, KIoctlDummyLevel);
+	User::WaitForRequest(stat);
+	Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));
+	TESTL(KErrNone == stat.Int());
+	
+	CleanupStack::Pop(&ss);
+	ss.Close();
+	
+	SetTestStepResult(verdict);
+	return verdict;
+	}
+
+// Test step 8.4
+const TDesC& CSocketTest8_4::GetTestName()
+	{
+	_LIT(ret,"Test8.4");
+	return ret;
+	}
+
+enum TVerdict CSocketTest8_4::InternalDoTestStepL( void )
+	{
+	TVerdict verdict = EPass;
+	
+	Logger().WriteFormat(_L("Test Purpose: Ioctl Get and Set Options"));
+	
+	// connect to esock
+	Logger().WriteFormat(_L("Attempting to connect to socket server"));
+    RSocketServ ss;
+	TInt ret = OptimalConnect(ss);
+	CleanupClosePushL(ss);
+	Logger().WriteFormat(_L("Connect returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrNone == ret);
+	
+	// try SetLocalPort
+	Logger().WriteFormat(_L("Opening a socket"));
+	RSocket socket;
+	ret = socket.Open(ss, _L("Dummy Protocol 1"));
+	Logger().WriteFormat(_L("Open returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrNone == ret);
+	
+	Logger().WriteFormat(_L("Trying SetLocalPort to 666"));
+	ret = socket.SetLocalPort(666);
+	Logger().WriteFormat(_L("SetLocalPort returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrNone == ret);
+	Logger().WriteFormat(_L("Port now set to %d"), socket.LocalPort());
+	TESTL(666 == socket.LocalPort());
+	
+	// try blocking Get/Set
+	Logger().WriteFormat(_L("Testing blocking mode Get and Set options"));
+	Logger().WriteFormat(_L("Trying to SetOption KSONonBlockingIO"));
+	ret = socket.SetOpt(KSONonBlockingIO, KSOLSocket);
+	Logger().WriteFormat(_L("SetOption returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrNone == ret);
+	
+	Logger().WriteFormat(_L("Trying to GetOption KSONonBlockingIO"));
+	TPckgBuf<TBool> boolean;
+	ret = socket.GetOpt(KSONonBlockingIO, KSOLSocket, boolean);
+	Logger().WriteFormat(_L("GetOption returned %S, value %d"), 
+		&EpocErrorToText(ret), boolean());
+	TESTL(KErrNone == ret);
+	TESTL(TRUE == boolean());
+	
+	Logger().WriteFormat(_L("Trying to GetOption KSOBlockingIO"));
+	ret = socket.GetOpt(KSOBlockingIO, KSOLSocket, boolean);
+	Logger().WriteFormat(_L("GetOption returned %S, value %d"), 
+		&EpocErrorToText(ret), boolean());
+	TESTL(KErrNone == ret);
+	TESTL(FALSE == boolean());
+	
+	Logger().WriteFormat(_L("Trying to SetOption KSOBlockingIO"));
+	ret = socket.SetOpt(KSOBlockingIO, KSOLSocket);
+	Logger().WriteFormat(_L("SetOption returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrNone == ret);
+	
+	Logger().WriteFormat(_L("Trying to GetOption KSONonBlockingIO"));
+	ret = socket.GetOpt(KSONonBlockingIO, KSOLSocket, boolean);
+	Logger().WriteFormat(_L("GetOption returned %S, value %d"), 
+		&EpocErrorToText(ret), boolean());
+	TESTL(KErrNone == ret);
+	TESTL(FALSE == boolean());
+	
+	Logger().WriteFormat(_L("Trying to GetOption KSOBlockingIO"));
+	ret = socket.GetOpt(KSOBlockingIO, KSOLSocket, boolean);
+	Logger().WriteFormat(_L("GetOption returned %S, value %d"), 
+		&EpocErrorToText(ret), boolean());
+	TESTL(KErrNone == ret);
+	TESTL(TRUE == boolean());
+	
+	CleanupStack::Pop(&ss);
+	ss.Close();
+	
+	return verdict;
+	}
+
+// Test step 8.5
+const TDesC& CSocketTest8_5::GetTestName()
+	{
+	_LIT(ret,"Test8.5");
+	return ret;
+	}
+
+enum TVerdict CSocketTest8_5::InternalDoTestStepL( void )
+	{
+	TVerdict verdict = EPass;
+	
+	Logger().WriteFormat(_L("Test Purpose: Ioctl returns not started on null socket"));
+	
+	// connect to esock
+	Logger().WriteFormat(_L("Attempting to connect to socket server"));
+    RSocketServ ss;
+	TInt ret = OptimalConnect(ss);
+    CleanupClosePushL(ss);
+	Logger().WriteFormat(_L("Connect returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrNone == ret);
+	
+	// Added test for defect: DEF043787 	SAP never gets told to cancel an Ioctl if client calls RSocket::CancelAll().
+	_LIT(KSomeProtocol, "Dummy Protocol 1");
+	RSocket socket;
+	ret = socket.Open(ss, KSomeProtocol);
+	CleanupClosePushL(socket);
+	Logger().WriteFormat(_L("Open returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrNone == ret);
+	
+	// Do test IOCTL thats never completes, then cancel it
+	Logger().WriteFormat(_L("Do IOCTL/CancelALL."));
+	TRequestStatus stat;
+	socket.Ioctl(KDummyIoctlIgnore, stat);
+	socket.CancelAll();
+	User::WaitForRequest(stat);
+	Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));
+	TESTL(KErrCancel == stat.Int());
+	
+	// Now query for the result of the previous IOCtl.
+	socket.Ioctl(KDummyIoctlCancelled, stat);
+	User::WaitForRequest(stat);
+	if(stat==KErrNotFound)
+		{
+		Logger().WriteFormat(_L("Ioctl returned with status %S: CancelAll failed to cancel previous IOCTL."), &EpocErrorToText(stat.Int()));
+		}
+	else
+		{
+		Logger().WriteFormat(_L("Ioctl returned with status %S"), &EpocErrorToText(stat.Int()));
+		}
+	TESTL(KErrNone == stat.Int());
+	
+	CleanupStack::PopAndDestroy(2,&ss); // socket, ss
+	SetTestStepResult(verdict);
+	return verdict;
+	}
+	
+const TDesC &CSocketTest8_6::GetTestName()
+	{
+	_LIT(ret,"Test8.6");
+	return ret;
+	}
+	
+enum TVerdict CSocketTest8_6::InternalDoTestStepL( void )
+	{
+	TVerdict verdict = EPass;
+	
+	Logger().WriteFormat(_L("Test Purpose: Retention of socket options from before Accept to after Accept"));
+	
+	// connect to esock
+	Logger().WriteFormat(_L("Attempting to connect to socket server"));
+    RSocketServ ss1;
+	TInt ret = OptimalConnect(ss1);
+	TESTL(KErrNone == ret);
+	CleanupClosePushL(ss1);
+	
+	Logger().WriteFormat(_L("Opening Socket on pdummy3"));
+	RSocket sock1;
+	ret = sock1.Open(ss1,_L("Dummy Protocol 3"));
+	TESTL(KErrNone == ret);
+	
+	Logger().WriteFormat(_L("Binding Sock1"));
+	TSockAddr addr;
+	ret = sock1.Bind(addr);
+	TESTL(KErrNone == ret);
+	
+	Logger().WriteFormat(_L("Listening on Sock1"));
+	ret = sock1.Listen(5);
+	TESTL(KErrNone == ret);
+	
+	Logger().WriteFormat(_L("Opening a null Socket"));
+	RSocket nullSock;
+	nullSock.Open(ss1);
+	TESTL(KErrNone == ret);
+	
+	const TUint KBufferSize = 1024;
+	Logger().WriteFormat(_L("Setting a whole bunch of KSOLSocket options on the parent (sock1) socket"));
+	ret = sock1.SetOpt(KSOSendBuf, KSOLSocket, KBufferSize);
+	TESTL(KErrNone == ret);
+	ret = sock1.SetOpt(KSORecvBuf, KSOLSocket, KBufferSize);
+	TESTL(KErrNone == ret);
+	ret = sock1.SetOpt(KSODebug, KSOLSocket, ETrue);
+	TESTL(KErrNone == ret);
+	ret = sock1.SetOpt(KSONonBlockingIO, KSOLSocket);
+	TESTL(KErrNone == ret);
+	_LIT_SECURITY_POLICY_C2(KProcPolicy, ECapabilityNetworkServices, ECapabilityNetworkControl);
+	ret = nullSock.SetOpt(KSOEnableTransfer, KSOLSocket, KProcPolicy().Package());
+	TESTL(KErrNotReady == ret);
+	
+	Logger().WriteFormat(_L("Now simulating a remote connection to complete the accept"));
+	ret = sock1.SetOpt(KDummyOptionSetConnectComplete, KIoctlDummyLevel);
+	TESTL(KErrNone == ret);
+	Logger().WriteFormat(_L("Now performing accept"));
+	TRequestStatus stat;
+	sock1.Accept(nullSock, stat);
+	User::WaitForRequest(stat);
+	TESTL(KErrNone == stat.Int());
+	
+	Logger().WriteFormat(_L("Now retrieving all the options set on the null socket with getOpts"));
+	TInt retrievedOpt;
+	ret = nullSock.GetOpt(KSOSendBuf, KSOLSocket, retrievedOpt);
+	TESTL(KErrNone == ret);
+	if (retrievedOpt != KBufferSize)
+		{
+		Logger().WriteFormat(_L("Opt KSOSendBuf did not return the correct value"));
+		User::Leave(EFail);
+		}	
+	ret = nullSock.GetOpt(KSORecvBuf, KSOLSocket, retrievedOpt);
+	TESTL(KErrNone == ret);
+	if (retrievedOpt != KBufferSize)
+		{
+		Logger().WriteFormat(_L("Opt KSORecvBuf did not return the correct value"));
+		User::Leave(EFail);
+		}	
+	ret = nullSock.GetOpt(KSODebug, KSOLSocket, retrievedOpt);
+	TESTL(KErrNone == ret);
+	if (!retrievedOpt) 
+		{
+		Logger().WriteFormat(_L("Opt KSODebug did not return the correct value"));
+		User::Leave(EFail);
+		}
+	ret = nullSock.GetOpt(KSONonBlockingIO, KSOLSocket, retrievedOpt);
+	TESTL(KErrNone == ret);
+	if (!retrievedOpt)
+		{
+		Logger().WriteFormat(_L("Opt KSONonBlockingIO did not return the correct value"));
+		User::Leave(EFail);
+		}
+	
+	CleanupStack::Pop(&ss1);
+	ss1.Close();
+	
+	return verdict;
+	}
+
+const TDesC &CSocketTest8_7::GetTestName()
+	{
+	_LIT(ret,"Test8.7");
+	return ret;
+	}
+
+enum TVerdict CSocketTest8_7::InternalDoTestStepL( void )
+	{
+	TVerdict verdict = EPass;
+	
+	Logger().WriteFormat(_L("Test Purpose: getOpt with small client buffer"));
+	
+	// connect to esock
+	Logger().WriteFormat(_L("Attempting to connect to socket server"));
+    RSocketServ ss;
+	TInt ret = OptimalConnect(ss);
+	CleanupClosePushL(ss);
+	Logger().WriteFormat(_L("Connect returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrNone == ret);
+	
+	// try SetLocalPort
+	Logger().WriteFormat(_L("Opening a socket"));
+	RSocket socket;
+	ret = socket.Open(ss, _L("Dummy Protocol 1"));
+	Logger().WriteFormat(_L("Open returned %S"), &EpocErrorToText(ret));
+	TESTL(KErrNone == ret);
+	
+	// try with small buffer - 8 bit descriptor
+	Logger().WriteFormat(_L("Trying to GetOption KSOBlockingIO"));
+	TBuf8<1> smallBuf8;
+	ret = socket.GetOpt(KSOBlockingIO, KSOLSocket, smallBuf8);
+	Logger().WriteFormat(_L("GetOption returned %S"),&EpocErrorToText(ret));
+	TESTL(KErrOverflow == ret);
+		
+	// try with correct size descriptor
+	Logger().WriteFormat(_L("Trying to GetOption KSOBlockingIO"));
+	TPckgBuf<TBool> boolean;
+	ret = socket.GetOpt(KSOBlockingIO, KSOLSocket, boolean);
+	Logger().WriteFormat(_L("GetOption returned %S, value %d"), 
+			&EpocErrorToText(ret), boolean());
+	TESTL(KErrNone == ret);
+	TESTL(TRUE == boolean());
+		
+	CleanupStack::Pop(&ss);
+	ss.Close();
+	
+	return verdict;
+	}
+
+const TDesC &CSocketTest8_8::GetTestName()
+	{
+	_LIT(ret,"Test8.8");
+	return ret;
+	}
+
+enum TVerdict CSocketTest8_8::InternalDoTestStepL( void )
+	{
+	TVerdict verdict = EPass;
+
+	Logger().WriteFormat(_L("Test Purpose: KSOSelectLastError option update"));
+	RSocketServ ss;
+	TInt ret=OptimalConnect(ss);
+	CleanupClosePushL(ss);
+    TESTL(KErrNone == ret);	
+    
+	Logger().WriteFormat(_L("Open by name"));             
+	RSocket sock, sock2;                                                    
+	ret=sock.Open(ss,_L("Dummy Protocol 3")); // dummy 3 is reconnectable                         
+	TESTL(KErrNone == ret);	
+
+	// get last error - check that option value is updated
+  	TInt val;
+   	ret = sock.GetOpt(KSOSelectLastError, KSOLSocket, val);
+   	Logger().WriteFormat(_L("KSOSelectLastError returned with status %S"), &EpocErrorToText(ret));	
+   	TESTL(KErrNone == ret);
+   	// return value should match the updated value
+   	TESTL (val == ret);
+
+	ret=sock2.Open(ss); // null socket to accept onto                         
+	TESTL(KErrNone == ret);	
+	
+	Logger().WriteFormat(_L("Set test option"));             
+	const TInt KExpectedError = -4567; // Something random.
+	ret=sock.SetOpt(KDummyOptionSetErrorNextListen,0,KExpectedError);
+	TESTL(KErrNone == ret);	
+	
+	TSockAddr addr;
+	ret=sock.Bind(addr);
+	TESTL(KErrNone == ret);	
+	
+	Logger().WriteFormat(_L("Listen"));             
+	ret=sock.Listen(0); // No need for a que
+	TESTL(KErrNone == ret);	
+	
+	Logger().WriteFormat(_L("Accept - error"));             
+	TRequestStatus rstat;
+	sock.Accept(sock2, rstat);
+	User::WaitForRequest(rstat);
+	TESTL(rstat.Int() == KExpectedError);	
+	
+	// get last error
+   	ret = sock.GetOpt(KSOSelectLastError, KSOLSocket, val);
+   	Logger().WriteFormat(_L("KSOSelectLastError returned with status %S"), &EpocErrorToText(ret));	
+   	TESTL(KExpectedError == ret);
+   	// return value should match the updated value
+   	TESTL(val == ret);
+	
+	// Clears last error
+   	ret = sock.GetOpt(KSOSelectLastError, KSOLSocket, val);
+   	Logger().WriteFormat(_L("KSOSelectLastError returned with status %S"), &EpocErrorToText(ret));	
+   	TESTL(KErrNone == ret);	
+   	// return value should match the updated value
+   	TESTL(val == ret);
+   	
+	CleanupStack::Pop(&ss);
+	ss.Close();
+	
+	SetTestStepResult(verdict);
+	return verdict;
+	}
+
+