// Copyright (c) 2006-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:

//

// EPOC includes

#include <e32base.h>

#include "TE_SocketServerTestSections.h"

#include<c32root.h>

#include <es_panic.h>

#include <elements/sd_std.h>

#include <comms-infras/sockmes.h>

// Test step 1

const TDesC& CSocketServerTest1::GetTestName()

	{

	_LIT(cRet,"Test1");

	return cRet;

	}

CSocketServerTest1::CSocketServerTest1()

	{

	}

CSocketServerTest1::~CSocketServerTest1()

	{

	}

enum TVerdict CSocketServerTest1::InternalDoTestStepL( void )

	{

	TVerdict verdict = EPass;

	TInt ret;

	Logger().WriteFormat(_L("TE_SocketServer Test1"));

	Logger().WriteFormat(_L("Test Purpose: Attempts to connect directly to optimal SocketServer without first connecting to SocketServer"));

	// connect to esock

	Logger().WriteFormat(_L("Attempting direct optimal connection to socket server - should fail and panic"));

    RSocketServ ss1;

	ret = IllegalOptimalConnect(ss1);

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

	TESTL(ret == KErrPermissionDenied);

	SetTestStepResult(verdict);

	return verdict;

	}

const TDesC& CSocketServerTest2::GetTestName()

	{

	_LIT(cRet,"Test2");

	return cRet;

	}

// Test step 2

CSocketServerTest2::CSocketServerTest2()

    {

    }

CSocketServerTest2::~CSocketServerTest2()

    {

    }

enum TVerdict CSocketServerTest2::InternalDoTestStepL( void )

	{

	TVerdict verdict = EPass;

	TInt ret;

	Logger().WriteFormat(_L("TE_SocketServer Test2"));

	Logger().WriteFormat(_L("Test Purpose: Request optimal SocketServer but connects directly to it twice"));

	// connect to esock

	Logger().WriteFormat(_L("Attempting optimal connection to socket server"));

    RSocketServ ss1;

	ret = OptimalConnect(ss1);

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

	TESTL(ret == KErrNone);

	Logger().WriteFormat(_L("Attempting an illegal direct connection to socket server player"));

	ret = IllegalOptimalConnect(ss1);

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

	TESTL(ret == KErrPermissionDenied);

	SetTestStepResult(verdict);

	return verdict;

	}

// Test step 3

const TDesC& CSocketServerTest3::GetTestName()

	{

	_LIT(cRet,"Test3");

	return cRet;

	}

CSocketServerTest3::CSocketServerTest3()

	{

	}

CSocketServerTest3::~CSocketServerTest3()

	{

	}

enum TVerdict CSocketServerTest3::InternalDoTestStepL( void )

	{

	TVerdict verdict = EPass;

	Logger().WriteFormat(_L("TE_SocketServer Test3"));

	Logger().WriteFormat(_L("Test Purpose: Separate player belonging to optimal SocketServer dies"));

	// connect to esock

	Logger().WriteFormat(_L("Attempting connection to socket server"));

    RSocketServ ss1;

	TInt ret;

	ret = ss1.Connect();

	CleanupClosePushL(ss1);

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

	TESTL(ret == KErrNone);

	RSocket sock1;

	Logger().WriteFormat(_L("Attempting open a socket to protocol 'Dummy Protocol 1'"));

	ret = sock1.Open(ss1,_L("Dummy Protocol 1"));

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

	TESTL(ret == KErrNone);

	Logger().WriteFormat(_L("Attempting to Panic the protocol module"));

	ret = PanicProtocolModule(sock1);

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

	TESTL(ret == KErrServerTerminated || ret == KErrAbort);

	sock1.Close();

	RSocketServ ss2;

	Logger().WriteFormat(_L("Attempting do normal socket server connection"));

	ret = ss2.Connect();

	CleanupClosePushL(ss2);

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

	TESTL(ret == KErrNone);

	RSocketServ ss3;

	Logger().WriteFormat(_L("Attempting do normal optimal socket server connection"));

	ret = OptimalConnect(ss3);

	CleanupClosePushL(ss3);

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

	TESTL(ret == KErrNone);

	RSocket sock2;

	Logger().WriteFormat(_L("Attempting to connect to 'Dummy Protocol 1'"));

	ret = sock2.Open(ss3,_L("Dummy Protocol 1"));

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

	TESTL(ret != KErrNone);

	CleanupStack::PopAndDestroy();

	CleanupStack::PopAndDestroy();

	CleanupStack::PopAndDestroy();

	SetTestStepResult(verdict);

	return verdict;

	}

// Test step 5

const TDesC& CSocketServerTest5::GetTestName()

	{

	_LIT(cRet,"Test5");

	return cRet;

	}

CSocketServerTest5::CSocketServerTest5()

	{

	}

CSocketServerTest5::~CSocketServerTest5()

	{

	}

enum TVerdict CSocketServerTest5::InternalDoTestStepL( void )

	{

	TVerdict verdict = EPass;

	Logger().WriteFormat(_L("TE_SocketServer Test5"));

	Logger().WriteFormat(_L("Test Purpose: Separate player belonging to optimal SocketServer dies, without completing all messages"));

	// connect to esock

	Logger().WriteFormat(_L("Attempting connection to socket server"));

    RSocketServ ss1;

	TInt ret;

	ret = ss1.Connect();

	CleanupClosePushL(ss1);

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

	TESTL(ret == KErrNone);

	Logger().WriteFormat(_L("Attempting optimal connection to socket server"));

    RSocketServ ss2;

	ret = OptimalConnect(ss2);

	CleanupClosePushL(ss2);

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

	TESTL(ret == KErrNone);

	RSocket sock1;

	Logger().WriteFormat(_L("Attempting open a socket to protocol 'Dummy Protocol 1'"));

	ret = sock1.Open(ss1,_L("Dummy Protocol 1"));

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

	TESTL(ret == KErrNone);

	Logger().WriteFormat(_L("Attempting to Hang the protocol module"));

	TRequestStatus stat1;

	NonCompletingIoclt(sock1,stat1);

	RSocket sock2;

	Logger().WriteFormat(_L("Attempting to open a socket to protocol 'Dummy Protocol 1'"));

	ret = sock2.Open(ss2,_L("Dummy Protocol 1"));

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

	TESTL(ret == KErrNone);

	RProperty deathCountProp;

	TRequestStatus deathCountStat;

	ret = deathCountProp.Attach(KUidSystemCategory, KUidC32RootModuleDeathKey.iUid);

	deathCountProp.Subscribe(deathCountStat);

	Logger().WriteFormat(_L("Attempting to Panic the protocol module"));

	ret = PanicProtocolModule(sock2);

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

	TESTL(ret == KErrServerTerminated || ret == KErrAbort);

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

	User::WaitForRequest(stat1);

	TESTL(stat1 == KErrServerTerminated || stat1 == KErrAbort);

	RSocketServ ss3;

	Logger().WriteFormat(_L("Attempting connection to socket server"));

	ret = ss3.Connect();

	CleanupClosePushL(ss3);

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

	User::WaitForRequest(deathCountStat); //Ensure that all the cleanup has happenned	

	Logger().WriteFormat(_L("Checking for  module 'ESock_PDummy1'"));

	CheckForModuleL(_L8("ESock_PDummy1"));

	Logger().WriteFormat(_L("Checking for  module 'ESock_Codealer1'"));

	CheckForModuleL(_L8("ESock_Codealer1"));

	CleanupStack::PopAndDestroy(&ss3);

	CleanupStack::PopAndDestroy(&ss2);

	CleanupStack::PopAndDestroy(&ss1);

	SetTestStepResult(verdict);

	return verdict;

	}

// Test step 7

const TDesC& CSocketServerTest7::GetTestName()

	{

	_LIT(cRet,"Test7");

	return cRet;

	}

CSocketServerTest7::CSocketServerTest7()

	{

	}

CSocketServerTest7::~CSocketServerTest7()

	{

	}

enum TVerdict CSocketServerTest7::InternalDoTestStepL( void )

	{

	TVerdict verdict = EPass;

	Logger().WriteFormat(_L("TE_SocketServer Test7"));

	Logger().WriteFormat(_L("Test Purpose: Optimal SocketServer with separate player dies without the player having completed all messages"));

	// connect to esock

	Logger().WriteFormat(_L("Attempting optimal connection to socket server"));

    RSocketServ ss1;

	TInt ret;

	ret = OptimalConnect(ss1);

	CleanupClosePushL(ss1);

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

	TESTL(ret == KErrNone);

	Logger().WriteFormat(_L("Attemting to open connection to 'Dummy Protocol 1'"));

	RSocket sock1;

	ret = sock1.Open(ss1,_L("Dummy Protocol 1"));

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

	TESTL(ret == KErrNone);

	Logger().WriteFormat(_L("Attemting to panic the dealer module"));

	ret = PanicDealer(ss1);

	sock1.Close();

	if (ret == KErrNotSupported)

		{

		Logger().WriteFormat(_L("Test Only works for debug versions of epoc"));

		verdict = EInconclusive;

		}

	else

		{

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

		TESTL(ret == KErrServerTerminated || ret == KErrAbort);

		Logger().WriteFormat(_L("Attempting connection to socket server"));

		RSocketServ ss2;

		ret = ss2.Connect();

		CleanupClosePushL(ss2);

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

		TESTL(ret == KErrNone);

		Logger().WriteFormat(_L("Checking for  module 'ESock_Codealer2'"));

		CheckForModuleL(_L8("ESock_Codealer2"));

		Logger().WriteFormat(_L("Checking for  module 'ESock_Dealer2'"));

		CheckForModuleL(_L8("ESock_Dealer2"));

		Logger().WriteFormat(_L("Attemting to open connection to 'Dummy Protocol 1'"));

		ret = sock1.Open(ss2,_L("Dummy Protocol 1"));

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

		sock1.Close();

		TESTL(ret == KErrNone);

		ret = sock1.Open(ss2,_L("Dummy Protocol 2"));

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

		sock1.Close();

		TESTL(ret == KErrNotFound);

		CleanupStack::PopAndDestroy(&ss2);

		}

	CleanupStack::PopAndDestroy(&ss1);

	SetTestStepResult(verdict);

	return verdict;

	}

// Test step 9

const TDesC& CSocketServerTest9::GetTestName()

	{

	_LIT(cRet,"Test9");

	return cRet;

	}

CSocketServerTest9::CSocketServerTest9()

	{

	}

CSocketServerTest9::~CSocketServerTest9()

	{

	}

enum TVerdict CSocketServerTest9::InternalDoTestStepL( void )

	{

	TVerdict verdict = EPass;

	int ret;

	Logger().WriteFormat(_L("TE_SocketServer Test9"));

	Logger().WriteFormat(_L("Test Purpose: Optimal SocketServer with separate player dies without the player having completed all messages"));

	// connect to esock

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

    RSocketServ ss1;

	ret =ss1.Connect();

	CleanupClosePushL(ss1);

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

	TESTL(ret == KErrNone);

	Logger().WriteFormat(_L("Attempting to open 'Dummy Protocol 1'"));

	RSocket sock1;

    ret = sock1.Open(ss1,_L("Dummy Protocol 1"));

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

	TESTL(ret == KErrNone);

	Logger().WriteFormat(_L("Attempting optimal connect to socket server"));

    RSocketServ ss2;

	ret = OptimalConnect(ss2);

	CleanupClosePushL(ss2);

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

	TESTL(ret == KErrNone);

	Logger().WriteFormat(_L("Attempting to open 'Dummy Protocol 2'"));

	RSocket sock2;

    ret = sock2.Open(ss2,_L("Dummy Protocol 2"));

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

	TESTL(ret == KErrNone);

	Logger().WriteFormat(_L("Attempting to hang protocol module 2 on socket 2"));

	TRequestStatus stat2;

	NonCompletingIoclt(sock2,stat2);

	RProperty deathCountProp;

	TRequestStatus deathCountStat;

	ret = deathCountProp.Attach(KUidSystemCategory, KUidC32RootModuleDeathKey.iUid);

	deathCountProp.Subscribe(deathCountStat);

	CleanupClosePushL(deathCountProp);

	Logger().WriteFormat(_L("Attempting to panic dealer on socket 3"));

	ret = PanicDealer(ss2);

	if (ret == KErrNotSupported)

		{

		Logger().WriteFormat(_L("Test Only works for debug versions of epoc"));

		deathCountProp.Cancel();

		User::WaitForRequest(deathCountStat); //Ensure that all the cleanup has happenned	

		verdict = EInconclusive;

		}

	else

		{

		Logger().WriteFormat(_L("Ioctl returned %S on socket 3"),&EpocErrorToText(ret));

		TESTL(ret == KErrServerTerminated || ret == KErrAbort);

		User::WaitForRequest(deathCountStat); //Ensure that all the cleanup has happenned	

		User::WaitForRequest(stat2);

		ret = stat2.Int();

		Logger().WriteFormat(_L("Ioctl returned %S on socket 2"),&EpocErrorToText(ret));

		TESTL(ret == KErrServerTerminated || ret == KErrAbort);

		Logger().WriteFormat(_L("Checking for  module 'ESock_Codealer2' and 'ESock_Dealer2'"));

		CheckForModuleL(_L8("ESock_Codealer2"));

		CheckForModuleL(_L8("ESock_Dealer2"));

		Logger().WriteFormat(_L("Attempting to open 'Dummy Protocol 1' on optimal socket server"));

		RSocket sock2_2;

	    ret = sock2_2.Open(ss2,_L("Dummy Protocol 1"));

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

		TESTL(ret != KErrNone);

		Logger().WriteFormat(_L("Attempting to open 'Dummy Protocol 1' on main socket server"));

		RSocket sock1_2;

	    ret = sock1_2.Open(ss1,_L("Dummy Protocol 1"));

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

		TESTL(ret == KErrNone);

		}

	CleanupStack::PopAndDestroy(&deathCountProp);

	CleanupStack::PopAndDestroy(&ss2);

	CleanupStack::PopAndDestroy(&ss1);

	SetTestStepResult(verdict);

	return verdict;

	}

// Test step 16

const TDesC& CSocketServerTest16::GetTestName()

	{

	_LIT(cRet,"Test16");

	return cRet;

	}

CSocketServerTest16::CSocketServerTest16()

	{

	}

CSocketServerTest16::~CSocketServerTest16()

	{

	}

enum TVerdict CSocketServerTest16::InternalDoTestStepL( void )

	{

	TVerdict verdict = EPass;

	TInt ret;

	Logger().WriteFormat(_L("TE_SocketServer Test16"));

	Logger().WriteFormat(_L("Test Purpose: A large number of IOCTLs cause the separate player channel to be full as player is temporarily unresponsive"));

	Logger().WriteFormat(_L("Attempting to connect session 1"));

    RSocketServ ss1;

	ret = ss1.Connect();

	CleanupClosePushL(ss1);

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

	TESTL(ret == KErrNone);

	Logger().WriteFormat(_L("Making Multiple opens"));

	RSocket sock[KLargeNumSockets];

	OpenMultipleSocketsL(ss1,sock,sizeof(sock)/sizeof(RSocket));

	int i;

	Logger().WriteFormat(_L("Making Slow Ioctl calls"));

	TRequestStatus stat[KLargeNumSockets];

	for (i = 0;i < KLargeNumSockets; i++)

		{

		SlowIoctlReturn(sock[i],stat[i],FALSE);

		Logger().WriteFormat(_L("Ioclt call %d returned %S"),i,&EpocErrorToText(ret));

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

		}

	//Now close	

	for (i = 0;i < KLargeNumSockets; i++)

		{

		sock[i].Close();

		User::WaitForRequest(stat[i]);

		ret = stat[i].Int();

		Logger().WriteFormat(_L("Ioclt TRequestStatus %d returned %S"),i,&EpocErrorToText(ret));

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

		}

    CleanupStack::PopAndDestroy(&ss1);

	SetTestStepResult(verdict);

	return verdict;

	}

// Test step Test

const TDesC& CSocketServerTest17::GetTestName()

	{

	_LIT(cRet,"Test17");

	return cRet;

	}

CSocketServerTest17::CSocketServerTest17()

	{

	}

CSocketServerTest17::~CSocketServerTest17()

	{

	}

enum TVerdict CSocketServerTest17::InternalDoTestStepL( void )

	{

	TVerdict verdict = EPass;

	int ret;

	// connect to esock

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

    RSocketServ ss1;

	ret =ss1.Connect();

	CleanupClosePushL(ss1);