// 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