// Copyright (c) 2001-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 11
// 
//

// EPOC includes
#include <e32base.h>
#include <in_sock.h>

// Test system includes
#include "EsockTestSection11.h"
#include "esockopenserver.h"


// Test step 11.1
const TDesC& CEsockTest11_1::GetTestName()
	{
	// store the name of this test case
	_LIT(ret,"Test11.1");
	return ret;
	}

CEsockTest11_1::~CEsockTest11_1()
	{
	}

enum TVerdict CEsockTest11_1::easyTestStepL()
	{
	// get ip address to connect to
	TInetAddr addr;
	TESTL(GetIpAddressFromConfig(_L("Test_Common"), _L("ipAddress"), addr));
	
	// get port number to connect to
	TInt port;
	TESTL(GetIntFromConfig(_L("Test_11.1"), _L("port"), port));
	
	// set remote address port
	addr.SetPort(port);
	
	// open a TCP socket
	RSocket sock;
	CleanupClosePushL(sock);
	TInt nRet = sock.Open(iEsockSuite->iSocketServer, KAfInet, KSockStream, KProtocolInetTcp);
	TESTEL(KErrNone == nRet, nRet);
	
	// connect to the remote address
	TRequestStatus stat;
	sock.Connect(addr, stat);
	User::WaitForRequest(stat);
	TESTEL(stat==KErrNone, stat.Int());
	
	// get the remote name of the connected socket
	TInetAddr addr1;
	sock.RemoteName(addr1);
	
	// check this matches the address we connected to
	TESTL(addr.CmpAddr(addr1));
	
	CleanupStack::PopAndDestroy(1, &sock);
	return EPass;
	}


// Test step 11.2
const TDesC& CEsockTest11_2::GetTestName()
	{
	// store the name of this test case
	_LIT(ret,"Test11.2");
	
	return ret;
	}

CEsockTest11_2::~CEsockTest11_2()
	{
	}

enum TVerdict CEsockTest11_2::easyTestStepL()
	{
	TInt nRet;
	TProtocolDesc protocolInfo;
	
	// Get protocol information
	
	// open a TCP socket, retrieve the protocol info
	// and check the protocol ID
	RSocket sock1;
	CleanupClosePushL(sock1);
	nRet = sock1.Open(iEsockSuite->iSocketServer, KAfInet, KSockStream, KProtocolInetTcp);
	TESTEL(KErrNone == nRet, nRet);
	TESTL(sock1.Info(protocolInfo)==KErrNone);
	TESTL(protocolInfo.iProtocol==KProtocolInetTcp);
	CleanupStack::PopAndDestroy(1, &sock1);
	
	// open a UDP socket, retrieve the protocol info
	// and check the protocol ID
	RSocket sock2;
	CleanupClosePushL(sock2);
	nRet = sock2.Open(iEsockSuite->iSocketServer, KAfInet, KSockDatagram, KProtocolInetUdp);
	TESTEL(KErrNone == nRet, nRet);
	TESTL(sock2.Info(protocolInfo)==KErrNone);
	TESTL(protocolInfo.iProtocol==KProtocolInetUdp);
	CleanupStack::PopAndDestroy(1, &sock2);
	
	// open an ICMP socket, retrieve the protocol info
	// and check the protocol ID
	RSocket sock3;
	CleanupClosePushL(sock3);
	nRet = sock3.Open(iEsockSuite->iSocketServer, KAfInet, KSockDatagram, KProtocolInetIcmp);
	TESTEL(KErrNone == nRet, nRet);
	TESTL(sock3.Info(protocolInfo)==KErrNone);
	TESTL(protocolInfo.iProtocol==KProtocolInetIcmp);
	CleanupStack::PopAndDestroy(1, &sock3);
	
	// open an IP socket, retrieve the protocol info
	// and check the protocol ID
	RSocket sock4;
	CleanupClosePushL(sock4);
	nRet = sock4.Open(iEsockSuite->iSocketServer, KAfInet, KSockDatagram, KProtocolInetIp);
	TESTEL(KErrNone == nRet, nRet);
	TESTL(sock4.Info(protocolInfo)==KErrNone);
	TESTL(protocolInfo.iProtocol==KProtocolInetIp);
	CleanupStack::PopAndDestroy(1, &sock4);
	
	return EPass;
	}


// Test step 11.3
const TDesC& CEsockTest11_3::GetTestName()
	{
	// store the name of this test case
	_LIT(ret,"Test11.3");
	
	return ret;
	}

CEsockTest11_3::~CEsockTest11_3()
	{
	}

enum TVerdict CEsockTest11_3::easyTestStepL()
	{
	TInetAddr addrLocal, addrRemote;
	TRequestStatus wstat, wstat2, wstat3, rstat;
	TInt sockIndex1, sockIndex2, sockIndex3;
	
	const TInt KBufSize = 4024;
	// Constructs an empty 8 bit modifiable buffer descriptor. It contains no data.
	typedef TBuf8<KBufSize> TBuffer;
	
	// get local ip address
	TESTL(GetIpAddressFromConfig(_L("Test_11.3"), _L("ipAddressLocal"), addrLocal));
	
	// get ip address to connect to (usually loopback)
	TESTL(GetIpAddressFromConfig(_L("Test_11.3"), _L("ipAddressRemote"), addrRemote));
	
	// open socket and listen for connect requests
	TESTL(KErrNone == OpenListeningSocketL(addrLocal, sockIndex1));
	
	// open active socket and make connect request
	TESTL(KErrNone == OpenActiveSocketL(addrRemote, sockIndex2));
	
	// accept connect request
	TESTL(KErrNone == AcceptConnectionL(sockIndex3, sockIndex1));
	
	TBuffer* wtemp=new (ELeave) TBuffer;
	CleanupStack::PushL(wtemp);
	TBuffer& wbuf=*wtemp;
	
	TBuffer* rtemp=new (ELeave) TBuffer;
	CleanupStack::PushL(rtemp);
	TBuffer& rbuf=*rtemp;
	
	wbuf.SetMax();
	StripeDes(wbuf, 0, wbuf.Length(), '@', 'Z');
	
	iEsockSuite->GetSocketHandle(sockIndex2).Send(wbuf, 0, wstat);
	iEsockSuite->GetSocketHandle(sockIndex2).Send(wbuf, 0, wstat2);
	iEsockSuite->GetSocketHandle(sockIndex2).Send(wbuf, 0, wstat3);
	iEsockSuite->GetSocketHandle(sockIndex2).CancelAll();
	User::WaitForRequest(wstat);
	User::WaitForRequest(wstat2);
	User::WaitForRequest(wstat3);
	TESTEL(wstat==KErrNone || wstat==KErrCancel, wstat.Int());
	TESTEL(wstat2==KErrNone || wstat2==KErrCancel, wstat2.Int());
	TESTEL(wstat3==KErrNone || wstat3==KErrCancel, wstat3.Int());
	
	Logger().WriteFormat(_L("stat1 %d stat2 %d stat3 %d"),wstat.Int(), wstat2.Int(), wstat3.Int());
	
	iEsockSuite->GetSocketHandle(sockIndex3).Recv(rbuf, 0, rstat);
	iEsockSuite->GetSocketHandle(sockIndex3).CancelAll();
	User::WaitForRequest(rstat);
	TESTEL(rstat==KErrNone || rstat==KErrCancel, rstat.Int());
	
	iEsockSuite->GetSocketHandle(sockIndex2).Shutdown(RSocket::ENormal, wstat);
	iEsockSuite->GetSocketHandle(sockIndex3).Shutdown(RSocket::ENormal, rstat);
	iEsockSuite->GetSocketHandle(sockIndex2).CancelAll();
	iEsockSuite->GetSocketHandle(sockIndex3).CancelAll();
	User::WaitForRequest(wstat);
	User::WaitForRequest(rstat);
	TESTEL(wstat == KErrNone, wstat.Int());
	TESTEL(rstat == KErrNone, rstat.Int());

	CleanupStack::PopAndDestroy(2, wtemp);
	
	// shutdown the client socket - do not wait for completion
	CloseSockets(2);
	return EPass;
	}


// Test step 11.4
const TDesC& CEsockTest11_4::GetTestName()
	{
	// store the name of this test case
	_LIT(ret,"Test11.4");
	
	return ret;
	}

CEsockTest11_4::~CEsockTest11_4()
	{
	}

enum TVerdict CEsockTest11_4::easyTestStepL()
	{
	//
	// Out Of Memory Test on open() RSocket //
	//

	TVerdict verdict = EPass;
	
	Logger().WriteFormat(_L("TE_ESock: test 11.4"));
	Logger().WriteFormat(_L("RSocket Open"));

#if defined (_DEBUG_SOCKET_FUNCTIONS)

	RSocketServ socketHelper;
	CleanupClosePushL(socketHelper);
	TInt ret = socketHelper.Connect();
	TESTEL(KErrNone == ret, ret);

	// Create a socket on the helper to get the DND up & running
	RSocket sockHelper;
	CleanupClosePushL(sockHelper);
	ret = sockHelper.Open(socketHelper, KAfInet, KSockStream, KProtocolInetTcp);
	TESTEL(KErrNone == ret, ret);
	// Short wait for DND settle down
    User::After(5000000);
	socketHelper.__DbgMarkHeap();

	RSocketServ socketServer;
	CleanupClosePushL(socketServer);
	ret = socketServer.Connect();
	TESTEL(KErrNone == ret, ret);
	
	// See if we can crash the server:
	RSocket sock;
	CleanupClosePushL(sock);
	TInt failure = 0;

	verdict = EInconclusive;
	TInt prevResult = KErrNoMemory;
	TInt prevOccurs = 0;
	while (EInconclusive == verdict)
		{
		socketServer.__DbgFailNext(failure++);
		ret = sock.Open(socketServer, KAfInet, KSockStream, KProtocolInetTcp);
		
		if ((prevResult != ret) || (++prevOccurs >= 1000))
			{
			Logger().WriteFormat(_L("%d loop(s), open socket returned %d"), prevOccurs, prevResult);
			if (KErrNone == ret)
				{
				verdict = EPass;
				}
			else if (KErrServerTerminated == ret)
				{
				verdict = EFail;
				}
			else if (prevResult != ret)
				{
				prevResult = ret;
				prevOccurs = 1;
				}
			else
				{
				prevOccurs = 0;
				}
			}
		};
	
	socketServer.__DbgFailNext(-1);
	// wait for protocol families to unload - it's via an async callback and dependent upon the IP stack, which
	// may also be killing off DND. So a big delay is needed. If it proves unreliable in future then the really
	// strong approach would be shutting down ESOCK - it'll panic if it has allocations outstanding
    User::After(5000000);
	socketHelper.__DbgMarkEnd(0);
	CleanupStack::PopAndDestroy(4, &socketHelper);

#else
	Logger().WriteFormat(_L("Test disabled on release build."));
#endif
	
	return verdict;
	}