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

//

//#include<c32root.h>

#include <e32base.h>

#include <es_sock.h>

//#include <ss_std.h>

//#include <e32std.h>

#include <comms-infras/eintsock.h>

#include "TE_EIntSockTestStep.h"

#include "es_ptestinternalsocket.h"

//#include <e32des8.h>

// constructor

CEIntSockTestStep::CEIntSockTestStep()

	{

	}

// destructor

CEIntSockTestStep::~CEIntSockTestStep()

	{

	iESockProxyThread.Close();

	}

enum TVerdict CEIntSockTestStep::doTestStepPreambleL( void )

	{

	return EPass;

	}

enum TVerdict CEIntSockTestStep::doTestStepL()

	{

	TRAPD(trapRet,enum TVerdict stepRet = InternalDoTestStepL();\

		if (stepRet !=EPass)\

			{\

			SetTestStepResult(stepRet);\

			}\

			)

			if (trapRet != KErrNone)

				{

				SetTestStepResult(EFail);

				return EFail;

				}

			return EPass;

	};

//This method ensures that any

enum TVerdict CEIntSockTestStep::doTestStepPostambleL( void )

	{

	return EPass;

	}

enum TVerdict CEIntSockTestStep::InternalDoTestStepL()

	{

	RSocketServ ss1;

	TInt ret;

	ret = ss1.Connect();

	if (ret != KErrNone)

		{

		Logger().WriteFormat(_L("Connect to socket server failed with %S"),&EpocErrorToText(ret));

		}

	CleanupClosePushL(ss1);

	TESTL(ret == KErrNone);

	RSocket sock1;

	ret = sock1.Open(ss1,KProxyAddrFamily,KSockDatagram, KProxy);

	//ret = sock1.Open(ss1,KProxyName);

	if (ret != KErrNone)

		{

		Logger().WriteFormat(_L("Opening socket to the Test Internal Socket Protocol failed with %S"),&EpocErrorToText(ret));

		}

	TESTL(ret == KErrNone);

	Logger().Close();

	TRequestStatus stat;

	TProxyProtocolRequest request;

	request.name.Copy(TestStepName());

	TPckg<TProxyProtocolRequest> requestPckg(request);

	_LIT(PanicStep,"Test21");

	if (TestStepName() == PanicStep)

		{

		doPanicStepTestPreambleL();

		}

	sock1.Ioctl(KProxyProtocolTestRequest,stat,&requestPckg);

	User::WaitForRequest(stat);

	CleanupStack::Pop(&ss1);

	ss1.Close();

	if (TestStepName() == PanicStep)

		{

		doPanicStepTestPostambleL(stat);

		}

	else

		{

		TESTL(stat == KErrNone);

		SetTestStepResult(request.result);

		}

	return TestStepResult();

	}

void CEIntSockTestStep::doPanicStepTestPreambleL()

	{

	// Search for *ESock_Proxy* thread

	TFindThread findThread(_L("*ESock_Proxy*"));

	TFullName threadName;

	TESTL(findThread.Next(threadName) == KErrNone);

	TESTL(iESockProxyThread.Open(findThread) == KErrNone);

	iESockProxyThread.Logon(iESockProxyThreadStatus);

	}

void CEIntSockTestStep::doPanicStepTestPostambleL( TRequestStatus& aStat )

	{

	//ESock is expected to have a panic. The Kernel will therefore return KErrAbort

	TESTL(aStat  == KErrAbort);

	User::WaitForRequest(iESockProxyThreadStatus);

	//Test that ESock_Proxy Paniced

	TESTL(iESockProxyThread.ExitType() == EExitPanic);

	// Test that the Panic Category was "InternalSocket"

	_LIT(KInternalSocketPanic, "InternalSocket");

	TESTL(iESockProxyThread.ExitCategory() == KInternalSocketPanic);

	// Test that the Panic Reason was EInternalSocketNotNullSocket (12)

	TESTL(iESockProxyThread.ExitReason() == ENotNullSocket);

	SetTestStepResult(EPass);	

	}

// extra logging methods

const TPtrC& CEIntSockTestStep::EpocErrorToText(const TInt aErrCode)

/**

Convert a Error code to text.

  @param aError error code to display as text.

  @return Text describing the error.

  */

	{

	//	TPtr errText;

	switch (aErrCode)

		{

		case KErrNone:

			iErrText.Set(_L("KErrNone"));

			break;

		case KErrNotFound:

			iErrText.Set(_L("KErrNotFound"));

			break;

		case KErrGeneral:

			iErrText.Set(_L("KErrGeneral"));

			break;

		case KErrCancel:

			iErrText.Set(_L("KErrCancel"));

			break;

		case KErrNoMemory:

			iErrText.Set(_L("KErrNoMemory"));

			break;

		case KErrNotSupported:

			iErrText.Set(_L("KErrNotSupported"));

			break;

		case KErrArgument:

			iErrText.Set(_L("KErrArgument"));

			break;

		case KErrTotalLossOfPrecision:

			iErrText.Set(_L("KErrTotalLossOfPrecision"));

			break;

		case KErrBadHandle:

			iErrText.Set(_L("KErrBadHandle"));

			break;

		case KErrOverflow:

			iErrText.Set(_L("KErrOverflow"));

			break;

		case KErrUnderflow:

			iErrText.Set(_L("KErrUnderflow"));

			break;

		case KErrAlreadyExists:

			iErrText.Set(_L("KErrAlreadyExists"));

			break;

		case KErrPathNotFound:

			iErrText.Set(_L("KErrPathNotFound"));

			break;

		case KErrDied:

			iErrText.Set(_L("KErrDied"));

			break;

		case KErrInUse:

			iErrText.Set(_L("KErrInUse"));

			break;

		case KErrServerTerminated:

			iErrText.Set(_L("KErrServerTerminated"));

			break;

		case KErrServerBusy:

			iErrText.Set(_L("KErrServerBusy"));

			break;

		case KErrCompletion:

			iErrText.Set(_L("KErrCompletion"));

			break;

		case KErrNotReady:

			iErrText.Set(_L("KErrNotReady"));

			break;

		case KErrUnknown:

			iErrText.Set(_L("KErrUnknown"));

			break;

		case KErrCorrupt:

			iErrText.Set(_L("KErrCorrupt"));

			break;

		case KErrAccessDenied:

			iErrText.Set(_L("KErrAccessDenied"));

			break;

		case KErrLocked:

			iErrText.Set(_L("KErrLocked"));

			break;

		case KErrWrite:

			iErrText.Set(_L("KErrWrite"));

			break;

		case KErrDisMounted:

			iErrText.Set(_L("KErrDisMounted"));

			break;

		case KErrEof:

			iErrText.Set(_L("KErrEof"));

			break;

		case KErrDiskFull:

			iErrText.Set(_L("KErrDiskFull"));

			break;

		case KErrBadDriver:

			iErrText.Set(_L("KErrBadDriver"));

			break;

		case KErrBadName:

			iErrText.Set(_L("KErrBadName"));

			break;

		case KErrCommsLineFail:

			iErrText.Set(_L("KErrCommsLineFail"));

			break;

		case KErrCommsFrame:

			iErrText.Set(_L("KErrCommsFrame"));

			break;

		case KErrCommsOverrun:

			iErrText.Set(_L("KErrCommsOverrun"));

			break;

		case KErrCommsParity:

			iErrText.Set(_L("KErrCommsParity"));

			break;

		case KErrTimedOut:

			iErrText.Set(_L("KErrTimedOut"));

			break;

		case KErrCouldNotConnect:

			iErrText.Set(_L("KErrCouldNotConnect"));

			break;

		case KErrCouldNotDisconnect:

			iErrText.Set(_L("KErrCouldNotDisconnect"));

			break;

		case KErrDisconnected:

			iErrText.Set(_L("KErrDisconnected"));

			break;

		case KErrBadLibraryEntryPoint:

			iErrText.Set(_L("KErrBadLibraryEntryPoint"));

			break;

		case KErrBadDescriptor:

			iErrText.Set(_L("KErrBadDescriptor"));

			break;

		case KErrAbort:

			iErrText.Set(_L("KErrAbort"));

			break;

		case KErrTooBig:

			iErrText.Set(_L("KErrTooBig"));

			break;

		case KRequestPending:

			iErrText.Set(_L("KRequestPending"));

			break;

		default:

			iErrBuff.Format(_L(" %d"),aErrCode);

			iErrText.Set(iErrBuff.Ptr());

			break;

		}

		return iErrText;

	}