// Copyright (c) 2005-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 "ptestcases.h"	

#ifdef SYMBIAN_OLD_EXPORT_LOCATION

#include "es_dummy.h"

#else

#include <test/es_dummy.h>

#endif

#include "es_ptestinternalsocket.h"

#include <es_mbuf.h>

#include <es_sock_internal.h>

#include "agregate.h"

#include "ss_eintsock_msgs.h"

#include <elements/nm_address_internal.h>

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ESockTestptstcs, "ESockTestptstcs.");

#endif

//-------------------------------------------------------------------------------------------------

//	CEIntSockTestBase

//-------------------------------------------------------------------------------------------------	

/**	This is a static method that is called to get a given test running

	@param aTestName The name of the test to be run

	@the name of the provider starting the test

 */

//static const TInt KWaitInterval = 10000; //Wait 10 milliseconds before doing checks;

//static const TInt KMaxNumWait = 100; // Wait KWaitIntercal 100 times; 	

#define BEGIN_TESTLIST

#define ADD_TEST(name) \

	if (aTestName == _L(#name))\

		{\

		return CEIntSock ## name::NewL(aProvd);\

		}

#define END_TESTLIST \

	User::Leave(KErrNotSupported);\

	return NULL;	

CEIntSockTestBase* CEIntSockTestBase::CreateTestL(const TDesC& aTestName, CProxyProvd* aProvd)

	{

	BEGIN_TESTLIST

		ADD_TEST(Test1)

		ADD_TEST(Test2)

		ADD_TEST(Test3)

		ADD_TEST(Test4)

		ADD_TEST(Test5)

		ADD_TEST(Test6)

		ADD_TEST(Test7)

		ADD_TEST(Test8)

		ADD_TEST(Test9)

		ADD_TEST(Test10)

		ADD_TEST(Test11)

		ADD_TEST(Test12)

		ADD_TEST(Test13)

		ADD_TEST(Test14)

		ADD_TEST(Test15)

		ADD_TEST(Test16)

		ADD_TEST(Test17)

		ADD_TEST(Test18)

		ADD_TEST(Test19)

		ADD_TEST(Test20)

		ADD_TEST(Test21)

		ADD_TEST(Test22)

		ADD_TEST(Test23)

		ADD_TEST(Test25A)

		ADD_TEST(Test25B)

		ADD_TEST(Test25C)

		ADD_TEST(Test26)

		ADD_TEST(Test27)

		ADD_TEST(Test28A)

		ADD_TEST(Test28B)

		ADD_TEST(Test29)

		ADD_TEST(Test30)

		ADD_TEST(Test31)

		ADD_TEST(Test32)

		ADD_TEST(Test33)

		ADD_TEST(Test34)

		ADD_TEST(Test35)

	    ADD_TEST(Test36)

	    ADD_TEST(Test37)

	    ADD_TEST(Test38)

	    ADD_TEST(Test39)	    

	    ADD_TEST(Test40)	    	    

	    ADD_TEST(Test41)	    	    	    

	    ADD_TEST(Test42)	    	    	    	    

	    ADD_TEST(Test43)	    	    	   

	    ADD_TEST(Test44)	    	    	    	    	    

	    ADD_TEST(Test45)	    	    	    		

	    ADD_TEST(Test46)	    	    	    			    

	    ADD_TEST(Test47)	    	    	    		

	    ADD_TEST(Test48)	    	    	    			    

	    ADD_TEST(Test49)	    	    	    			    

	    ADD_TEST(Test50)	    	    	    		

	    ADD_TEST(Test51)	    	    	    			    

	    ADD_TEST(Test52)	    	    	    			    

	    ADD_TEST(Test53)	    	    	    		

	    ADD_TEST(Test54)	    	    	    			    

	    ADD_TEST(Test55)	    	    	    			    	    

		ADD_TEST(Test56)	    

		ADD_TEST(Test57)		

		ADD_TEST(Test58)				

		ADD_TEST(Test59)			

		ADD_TEST(Test60)					

		ADD_TEST(Test61)                    

	END_TESTLIST

	}

void CEIntSockTestBase::StartTestL(const TDesC& aTestName, CProxyProvd* aProvd)

	{

	CEIntSockTestBase* test = CreateTestL(aTestName,aProvd);

	CleanupStack::PushL(test);

	test->CEIntSockTestBase::ConstructL();

	CActiveScheduler::Add(test);

	CleanupStack::Pop(test);

	TRequestStatus* stat = &test->iStatus;

	test->SetActive();

	User::RequestComplete(stat,KErrNone);

	}

CEIntSockTestBase::CEIntSockTestBase(CProxyProvd* aProvd) :

	CActive(EPriorityNormal),

	iProvd(aProvd)

	{

	iProvd->SetTestStepNotify(this);

	}

void CEIntSockTestBase::ConstructL()

	{

	SetLoggerL();

	}

CEIntSockTestBase::~CEIntSockTestBase()

	{

	if(iProvd)

		{

		iProvd->SetTestStepNotify(NULL);

		}

	iLogger.Close();

	}

/**	Override this function if you want cleanup to happen before the completion of

	the test case. This function is called before the test is completed 

 */

void CEIntSockTestBase::Cleanup()

	{}

/** Sets the test case as active again and prevents the object from being destroyed

	when the RunL completes.

	Note: The active object is not complete the request again automatically, if this behaviour is

	desired the user must call User::RequestComplete

 */

void CEIntSockTestBase::Reschedule()

	{

	SetActive();

	iReschedule = TRUE;

	}

/** Attaches the iLogger variable to the TestExecute Log Server. This enable this prt to write to

	the testexecute logs as if it were running directly from TestExecute

 */

// 	SetLoggerL() is taken directly from CTestServer::StartLoggerL() in the TEF src TestServerBase.Cpp

void CEIntSockTestBase::SetLoggerL()

	{

    	// Create a cinidata object for parsing the testexecute.ini

	CTestExecuteIniData* parseTestExecuteIni = NULL;

	TBuf<KMaxTestExecuteNameLength> resultFilePath;

	TBuf<KMaxTestExecuteNameLength> xmlFilePath;

	TInt logMode;

	TInt logLevel;

	TRAPD(err,parseTestExecuteIni = CTestExecuteIniData::NewL());

	if (err == KErrNone)

		{

		CleanupStack::PushL(parseTestExecuteIni);

		parseTestExecuteIni->ExtractValuesFromIni();

		parseTestExecuteIni->GetKeyValueFromIni(KTEFHtmlKey, resultFilePath);

		parseTestExecuteIni->GetKeyValueFromIni(KTEFXmlKey, xmlFilePath);

		parseTestExecuteIni->GetKeyValueFromIni(KTEFLogMode, logMode);

		parseTestExecuteIni->GetKeyValueFromIni(KTEFLogSeverityKey, logLevel);

		}

	else

		{

		resultFilePath.Copy(KTestExecuteLogPath);

		xmlFilePath.Copy(KTestExecuteLogPath);

		logMode = TLoggerOptions(ELogHTMLOnly);

		logLevel = RFileFlogger::TLogSeverity(ESevrAll);

		}

	Logger().SetLoggerOptions(logMode);

	// Initialise a handle to the file logger

	User::LeaveIfError(Logger().Connect());

	RFs fS;

	User::LeaveIfError(fS.Connect());

	CleanupClosePushL(fS);

	RFile file;

	TBuf<KMaxTestExecuteNameLength> xmlLogFile(xmlFilePath);

	TBuf<KMaxTestExecuteNameLength> logFile;

	TBuf<KMaxTestExecuteNameLength> logFileNameFile(resultFilePath);

	logFileNameFile.Append(KTestExecuteScheduleTestLogCompatibilityNameFile);

	if(file.Open(fS,logFileNameFile,EFileRead | EFileShareAny) != KErrNone)

		{

		// For the old flogger we have to create an individual file

		_LIT(KTxtLog,"TEIntSock.txt");

		logFile.Copy(KTxtLog);

		logMode = TLoggerOptions(0);

		Logger().SetLoggerOptions(logMode);

		}

	else

		{

		CleanupClosePushL(file);

		TBuf8<KMaxTestExecuteNameLength> logFile8;

		TInt fileSize;

		User::LeaveIfError(file.Size(fileSize));

		User::LeaveIfError(file.Read(logFile8,fileSize));

		logFile.Copy(logFile8);

		xmlLogFile.Append(logFile);

		_LIT(KXmlExtension,".xml");

		xmlLogFile.Append(KXmlExtension);

		_LIT(KHtmExtension,".htm");

		logFile.Append(KHtmExtension);

		CleanupStack::Pop(&file);

		file.Close();

		}

	TBuf<KMaxTestExecuteLogFilePath> logFilePath(resultFilePath);

	logFilePath.Append(logFile);

	CleanupStack::Pop(&fS);

	fS.Close();

	if (logMode == 0 || logMode == 2)

		{

		User::LeaveIfError(Logger().HtmlLogger().CreateLog(logFilePath,	RTestExecuteLogServ::ELogModeAppend));

		}

	if (logMode == 1 || logMode == 2)

		{

		User::LeaveIfError(Logger().XmlLogger().CreateLog(xmlLogFile,RFileFlogger::ELogModeAppend));

		Logger().XmlLogger().SetLogLevel(RFileFlogger::TLogSeverity(logLevel));

		}

	if (parseTestExecuteIni != NULL)

		{

		CleanupStack::PopAndDestroy(parseTestExecuteIni);

		}

	}

/** Called by the active scheduler in order to run the test 

 */

void CEIntSockTestBase::RunL()

	{

	iReschedule = EFalse;

	TVerdict res = RunTestL();

	if (!iReschedule)

		{

		Cleanup();

		FinishTest(res);

		delete this;

		return;

		}

	}

void CEIntSockTestBase::AboutToShutdown()

	{

	// Complete the client before the provider is deleted.

	FinishTest(EPass);

	iProvd = NULL;

	}

void CEIntSockTestBase::FinishTest(TVerdict aResult)

	{

	if(iProvd)

		{

		iProvd->TestComplete(aResult);

		}

	}

void CEIntSockTestBase::DoCancel()

	{

	Cleanup();

	}

//-------------------------------------------------------------------------------------------------

//	CEIntSockTest1

//-------------------------------------------------------------------------------------------------	

CEIntSockTestBase* CEIntSockTest1::NewL(CProxyProvd* aProvd)

	{

	CEIntSockTestBase* ret = new(ELeave) CEIntSockTest1(aProvd);

	return ret;

	}

CEIntSockTest1::CEIntSockTest1(CProxyProvd* aProvd) :

	CEIntSockTestBase(aProvd)

	{}

TVerdict CEIntSockTest1::RunTestL()

	{

	TInt err;

    _LIT(KDescSillyProtocol, "trifle");

    iLogger.WriteFormat(_L("<i>Test 1 - Open and close socket to non-existent protocol</i>"));

	iLogger.WriteFormat(_L("<i>Open socket to protocol - name passed as parameter does not exist</i>"));

	err = iSocket.Open(KDescSillyProtocol);

	if (err != KErrNotFound)

		{

		iLogger.WriteFormat(_L("<i>Open() failed with %d</i>"),err);

		return EFail; 

		}

	iLogger.WriteFormat(_L("<i>Open socket to protocol - address family does not exist</i>"));

	err = iSocket.Open(KDummyAddrFamily, KSockDatagram, 123411); //Some arbitary number

	if (err != KErrBadName)

		{

		iLogger.WriteFormat(_L("<i>Open() failed with %d</i>"),err);

		return EFail;

		}

	return EPass;

	}

void CEIntSockTest1::Cleanup()

	{

	iSocket.Close();

	}

//-------------------------------------------------------------------------------------------------

//	CEIntSockTest2

//-------------------------------------------------------------------------------------------------	

CEIntSockTestBase* CEIntSockTest2::NewL(CProxyProvd* aProvd)

	{

	CEIntSockTestBase* ret = new(ELeave) CEIntSockTest2(aProvd);

	return ret;

	}

CEIntSockTest2::CEIntSockTest2(CProxyProvd* aProvd) :

	CEIntSockTestBase(aProvd)

	{}

TVerdict CEIntSockTest2::RunTestL()

	{

	TInt err;

    iLogger.WriteFormat(_L("<i>Test 2 - Open and close socket</i>"));

	iLogger.WriteFormat(_L("<i>Open socket to protocol by name</i>"));

	err = iSocket.Open(KDummyTwoName);

	if (err != KErrNone)

		{

		iLogger.WriteFormat(_L("<i>Open() failed with %d</i>"),err);

		return EFail;

		}

	iSocket.Close();

	iLogger.WriteFormat(_L("<i>Open socket to protocol supplying address family</i>"));

	err = iSocket.Open(KDummyAddrFamily, KSockDatagram, KDummyOne);

	if (err != KErrNone)

		{

		iLogger.WriteFormat(_L("<i>Open() failed with %d</i>"),err);

		return EFail;

		}

	iSocket.Close();

	// this is a null socket for use with accept, can't specify protocol as no parameters

	iLogger.WriteFormat(_L("<i>Open null socket</i>"));

	err = iSocket.Open();

	if (err != KErrNone)

		{

		iLogger.WriteFormat(_L("<i>Open() failed with %d</i>"),err);

		return EFail;

		}		

	return EPass;

	}

void CEIntSockTest2::Cleanup()

	{

	iSocket.Close();

	}

//-------------------------------------------------------------------------------------------------

//	CEIntSockTest3

//-------------------------------------------------------------------------------------------------	

CEIntSockTestBase* CEIntSockTest3::NewL(CProxyProvd* aProvd)

	{

	CEIntSockTestBase* ret = new(ELeave) CEIntSockTest3(aProvd);

	return ret;

	}

CEIntSockTest3::CEIntSockTest3(CProxyProvd* aProvd) :

	CEIntSockTestBase(aProvd)

	{}

TVerdict CEIntSockTest3::RunTestL()

	{

	TSockAddr localAddr(KProxyAddrFamily);

	TInt err;

	iLogger.WriteFormat(_L("<i>Test 3 - Binding</i>"));

	iLogger.WriteFormat(_L("<i>Opening a socket to PDummy 2</i>"));

	err = iSocket.Open(KDummyTwoName);

	if (err != KErrNone)

		{

		iLogger.WriteFormat(_L("<i>Open() failed with %d</i>"),err);

		return EFail;

		}

	iLogger.WriteFormat(_L("<i>Binding socket to TSockAddr</i>"));

	err = iSocket.Bind(localAddr);

	if (err != KErrNone)

		{

		iLogger.WriteFormat(_L("<i>Bind() failed with %d</i>"),err);

		return EFail;

		}

	iLogger.WriteFormat(_L("<i>Checking LocalName() returns the correct address following the bind</i>"));

	TSockAddr actualAddr;

	iSocket.LocalName(actualAddr);

	if (actualAddr != localAddr)

		{

		iLogger.WriteFormat(_L("<i>Name didn't match the one passed to Bind()</i>"));

		return EFail;

		}

	iLogger.WriteFormat(_L("<i>Closing the socket</i>"));

	iSocket.Close();

	iLogger.WriteFormat(_L("<i>Opening a socket to PDummy 2</i>"));

	err = iSocket.Open(KDummyTwoName);	

	if (err != KErrNone)

		{				

		iLogger.WriteFormat(_L("<i>Open() failed with %d</i>"),err);

		return EFail;

		}

	iLogger.WriteFormat(_L("<i>Setting local port of socket</i>"));

	TUint localPort = 7;

	err = iSocket.SetLocalPort(localPort);

	if (err != KErrNone)

		{				

		iLogger.WriteFormat(_L("<i>SetLocalPort() failed with %d</i>"),err);

		return EFail;

		}

	iLogger.WriteFormat(_L("<i>Checking LocalPort() returns the correct port number following the bind</i>"));

	TUint actualPort;

	actualPort = iSocket.LocalPort();

	if (actualPort != localPort)

		{

		iLogger.WriteFormat(_L("<i>Port didn't match the one passed to SetLocalPort()</i>"));

		return EFail;

		}

	return EPass;

	}

void CEIntSockTest3::Cleanup()

	{

	iSocket.Close();

	}

//-------------------------------------------------------------------------------------------------

//	CEIntSockTest4

//-------------------------------------------------------------------------------------------------	

CEIntSockTestBase* CEIntSockTest4::NewL(CProxyProvd* aProvd)

	{

	CEIntSockTestBase* ret = new(ELeave) CEIntSockTest4(aProvd);

	return ret;

	}

CEIntSockTest4::CEIntSockTest4(CProxyProvd* aProvd) :

	CEIntSockTestBase(aProvd)

	{}

TVerdict CEIntSockTest4::RunTestL()

	{

	TInt err;

	TProtocolDesc info;

	iLogger.WriteFormat(_L("<i>Test 4 - ProtocolInfo </i>"));

	iLogger.WriteFormat(_L("<i>Opening a socket to PDummy 2</i>"));

	err = iSocket.Open(KDummyTwoName);

	if (err != KErrNone)

		{

		iLogger.WriteFormat(_L("<i>Open() failed with %d</i>"),err);

		return EFail;

		}

	iLogger.WriteFormat(_L("<i>Getting info about the protocol</i>"));

	err = iSocket.Info(info);

	if (err != KErrNone)

		{

		iLogger.WriteFormat(_L("<i>Info() failed with %d</i>"),err);

		return EFail;				

		}

	iLogger.WriteFormat(_L("<i>Checking that the address is of type PDummyAddrFamily</i>"));

	if (info.iAddrFamily != KDummyAddrFamily)

		{

		iLogger.WriteFormat(_L("<i>Address family in return unexpectedly was %X</i>"),info.iAddrFamily);

		return EFail;					

		}

	return EPass;

	}

void CEIntSockTest4::Cleanup()

	{

	iSocket.Close();