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

// 

//

// EPOC includes

#include <e32base.h>

#include <es_sock.h>

#include <ss_std.h>

#include <test/es_dummy.h>

// Test system includes

#include "SocketTestSection5.h"

// Test step 5.1

const TDesC& CSocketTest5_1::GetTestName()

	{

	_LIT(ret,"Test5.1");

	return ret;

	}

enum TVerdict CSocketTest5_1::InternalDoTestStepL( void )

	{

	TVerdict verdict = EPass;

	Logger().WriteFormat(_L("Test Purpose: Memory Leak opening bad socket"));

#if defined(_DEBUG_SOCKET_FUNCTIONS)

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

	// open a bad socket

    Logger().WriteFormat(_L("Attempting to create bad socket type with heap checking"));

	//	ss.__DbgMarkHeap();		// in ESOCKMT leak checking is best done by shutting down the server

	RSocket sock;

    ret = sock.Open(ss, 0, 0, 0);

	//	ss.__DbgMarkEnd(0);

	Logger().WriteFormat(_L("Open returned %S"), &EpocErrorToText(ret));

	TESTL(KErrBadName == ret);

	CleanupStack::Pop(&ss);

	ss.Close();

#else

	Logger().WriteFormat(_L("TestDisabled on release build."));

	verdict = EInconclusive;

#endif

	SetTestStepResult(verdict);

	return verdict;

	}

// Test step 5.2

const TDesC& CSocketTest5_2::GetTestName()

	{

	_LIT(ret,"Test5.2");

	return ret;

	}

enum TVerdict CSocketTest5_2::InternalDoTestStepL( void )

	{

	TVerdict verdict = EPass;

	Logger().WriteFormat(_L("Test Purpose: Memory Leak connecting to server and disconnecting from server"));

#if defined(_DEBUG_SOCKET_FUNCTIONS)

	// connect to esock

	Logger().WriteFormat(_L("Main thread : Attempting to connect to socket server"));

    RSocketServ ss;

	TInt ret = OptimalConnect(ss);

	CleanupClosePushL(ss);

	Logger().WriteFormat(_L("Main Thread : Connect returned %S"), &EpocErrorToText(ret));

	TESTL(KErrNone == ret);

	Logger().WriteFormat(_L("Main thread : Creating semaphore for threads"));

	RSemaphore s;

	s.CreateLocal(0);

	RThread t;

	TSocketThreadArg tArg;

	tArg.iHandle = this;

	tArg.iSem  = &s;

	tArg.iNumSockets = 0;

	// try connect and close in separate thread

	Logger().WriteFormat(_L("Main thread : Creating sub thread to connect"));

	//	ss.__DbgMarkHeap();		// in ESOCKMT leak checking is best done by shutting down the server

	t.Create(_L("socketThread2"), ConnectThread, KDefaultStackSize, KDefaultHeapSize, KDefaultHeapSize, &tArg);

	t.Resume();

	s.Wait();

	t.Close();

	//	ss.__DbgMarkEnd(0);

	Logger().WriteFormat(_L("Main thread : Connect thread completed"));

	CleanupStack::Pop(&ss);

	ss.Close();

#else

	Logger().WriteFormat(_L("TestDisabled on release build."));

	verdict = EInconclusive;

#endif

	SetTestStepResult(verdict);

	return verdict;

	}

// Test step 5.3

const TDesC& CSocketTest5_3::GetTestName()

	{

	_LIT(ret,"Test5.3");

	return ret;

	}

enum TVerdict CSocketTest5_3::InternalDoTestStepL( void )

	{

	TVerdict verdict = EPass;

	Logger().WriteFormat(_L("Test Purpose: Memory Leak killing thread with open resources"));

#if defined(_DEBUG_SOCKET_FUNCTIONS)

	// connect to esock

	Logger().WriteFormat(_L("Main thread : Attempting to connect to socket server"));

    RSocketServ ss;

	TInt ret = OptimalConnect(ss);

	CleanupClosePushL(ss);

	Logger().WriteFormat(_L("Main Thread : Connect returned %S"), &EpocErrorToText(ret));

	TESTL(KErrNone == ret);

	Logger().WriteFormat(_L("Main thread : Creating semaphore for threads"));

	RSemaphore s;

	s.CreateLocal(0);

	// try create in separate thread and kill it

	Logger().WriteFormat(_L("Main Thread : Creating sub thread to create sockets and resolvers"));

	//	ss.__DbgMarkHeap();		// in ESOCKMT leak checking is best done by shutting down the server

	TSocketThreadArg a;

	a.iHandle = this;

	a.iSem = &s;

	a.iNumSockets = 1;

	RThread t2;

	t2.Create(_L("socketThread3"), SocketThread, KDefaultStackSize, KDefaultHeapSize, KDefaultHeapSize, &a);

	t2.Resume();

	s.Wait();

	Logger().WriteFormat(_L("Main Thread : Killing Create sub thread"));

	t2.Kill(KErrNone);

	t2.Close();

	Logger().WriteFormat(_L("Main Thread : Waiting 100ms for thread to clear up"));

	User::After(100000);

	//	ss.__DbgMarkEnd(0);

	Logger().WriteFormat(_L("Main Thread : Create thread completed"));

	CleanupStack::Pop(&ss);

	ss.Close();

#else

	Logger().WriteFormat(_L("TestDisabled on release build."));

	verdict = EInconclusive;

#endif

	SetTestStepResult(verdict);

	return verdict;

	}

// Test step 5.4

const TDesC& CSocketTest5_4::GetTestName()

	{

	_LIT(ret,"Test5.4");

	return ret;

	}

enum TVerdict CSocketTest5_4::InternalDoTestStepL( void )

	{

	TVerdict verdict = EPass;

	Logger().WriteFormat(_L("Test Purpose: Memory Leak Getting Protocol Info and Opening Socket"));

#if defined(_DEBUG_SOCKET_FUNCTIONS)

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

	// NumProtocols and GetProtocolInfo

	Logger().WriteFormat(_L("Try NumProtocols"));

	//	ss.__DbgMarkHeap();		// in ESOCKMT leak checking is best done by shutting down the server

	TUint numProtocols;

	ret = ss.NumProtocols(numProtocols);

	Logger().WriteFormat(_L("NumProtocols returned %S, number %d"), 

		&EpocErrorToText(ret), numProtocols);

	TESTL(KErrNone == ret);

	//	ss.__DbgMarkEnd(0);

	Logger().WriteFormat(_L("Trying GetProtocolInfo until Dummy Protocol 1 is found"));

	//	ss.__DbgMarkHeap();		// in ESOCKMT leak checking is best done by shutting down the server

	TProtocolDesc protoInfo;

	TUint aIndex;

	TBool aFound = false;

	for (aIndex=1;aIndex<=numProtocols;aIndex++) {

		ret = ss.GetProtocolInfo(aIndex, protoInfo);

		TESTL(KErrNone == ret || KErrCannotFindProtocol == ret);

		if (protoInfo.iName ==_L("Dummy Protocol 1")){

			aFound = true;

			break;

			}

		}

	//	ss.__DbgMarkEnd(0);

	if (!aFound) {

		Logger().WriteFormat(_L("Could not find Dummy Protocol 1"));

		return EFail;

		}

	Logger().WriteFormat(_L("Trying socket Open to load protocol"));

	RSocket sock;

	ret = sock.Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);

	Logger().WriteFormat(_L("Open returned %S"), &EpocErrorToText(ret));

	TESTL(KErrNone == ret);

	sock.Close();

	Logger().WriteFormat(_L("Trying socket Open with Heap checking"));

	//	ss.__DbgMarkHeap();		// in ESOCKMT leak checking is best done by shutting down the server

	RSocket sock1;

	ret = sock1.Open(ss, protoInfo.iAddrFamily, protoInfo.iSockType, protoInfo.iProtocol);

	Logger().WriteFormat(_L("Open returned %S"), &EpocErrorToText(ret));

	TESTL(KErrNone == ret);

	sock1.Close();

	//	ss.__DbgMarkEnd(0);

	CleanupStack::Pop(&ss);

	ss.Close();

#else

	Logger().WriteFormat(_L("TestDisabled on release build."));

	verdict = EInconclusive;

#endif

	SetTestStepResult(verdict);

	return verdict;

	}

// Test step 5.5

const TDesC& CSocketTest5_5::GetTestName()

	{

	_LIT(ret,"Test5.5");

	return ret;

	}

enum TVerdict CSocketTest5_5::InternalDoTestStepL( void )

	{

	TVerdict verdict = EPass;

	Logger().WriteFormat(_L("Test Purpose: Validating leak detection upon shutdown"));

#if defined(_DEBUG_SOCKET_FUNCTIONS)

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

	Logger().WriteFormat(_L("Open a socket on Dummy Protocol 1"));

	RSocket sock;

	ret = sock.Open(ss,_L("Dummy Protocol 1"));

	Logger().WriteFormat(_L("Open returned %S"), &EpocErrorToText(ret));

	TESTL(KErrNone == ret);

	sock.SetOpt(KDummyOptionLeakMemory, 4);

	sock.Close();

	CleanupStack::PopAndDestroy(&ss);

#else

	Logger().WriteFormat(_L("TestDisabled on release build."));

	verdict = EInconclusive;

#endif

	SetTestStepResult(verdict);

	return verdict;

	}