/*

* Copyright (c) 2008 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 <ss_glob.h>

#include <comms-infras/ss_nodemessages_factory.h>

#include <comms-infras/ss_nodemessages_dataclient.h>

//#include <elements/nm_messages_child.h>

#include "pudpclienttests.h"	

#include "upnp_cf_msgs.h"

#include "upnpflowbase.h"

#include "upnpflowfactory.h"

#include "httpudpflow.h"

//const TUint16 KActivityNull = 0;

//Add Blocks of 64

static const TInt KBlockSize1 = 64;

static const TInt KMinGrowth1 = 30;

static const TInt KThresholdGrowth1 = 30;

static const TInt KInitialAllocation1 = 128;

static const TInt KHeapSize	= 1024 * 1024;	//1MB

using namespace Messages;

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

//	CUdpClientTestBase

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

#define BEGIN_TESTLIST

#define ADD_TEST(name) \

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

		{\

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

		}

#define END_TESTLIST \

	User::Leave(KErrNotSupported);\

	return NULL;	

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

	{

	BEGIN_TESTLIST

		ADD_TEST(TestUPnP)		

		ADD_TEST(TestUPnP1)

		ADD_TEST(TestUPnP2)

		ADD_TEST(TestUPnP3)

		ADD_TEST(TestUPnP4)

		ADD_TEST(TestUPnP5)

		ADD_TEST(TestUPnP6)

		ADD_TEST(TestUPnP7)

		ADD_TEST(TestUPnP8)

		ADD_TEST(TestUPnP9)

		ADD_TEST(TestUPnP10)

		ADD_TEST(TestUPnP11)

		ADD_TEST(TestUPnP12)

	END_TESTLIST

	}

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

	{

	CUdpClientTestBase* test = CreateTestL(aTestName,aProvd);

	CleanupStack::PushL(test);

	test->CUdpClientTestBase::ConstructL();

	CActiveScheduler::Add(test);

	CleanupStack::Pop(test);

	TRequestStatus* stat = &test->iStatus;

	test->SetActive();

	User::RequestComplete(stat,KErrNone);

	}

CUdpClientTestBase::CUdpClientTestBase(CProxyProvd* aProvd) :

	CActive(EPriorityNormal),

	iProvd(aProvd)

	{}

void CUdpClientTestBase::ConstructL()

	{

	//Create the Chunk Manager

	CChunkManager* chkmgr = CChunkManager::NewL ( KHeapSize );

	if ( chkmgr )

		{

		chkmgr->AddPoolL ( KBlockSize1, KInitialAllocation1, KMinGrowth1, KThresholdGrowth1 );

		}

	iChunkManager = chkmgr;

	iAllocator.SetChunkManager(iChunkManager);

	SetLoggerL();

	}

CUdpClientTestBase::~CUdpClientTestBase()

	{

	iLogger.Close();

	delete iChunkManager;

	}

/**	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 CUdpClientTestBase::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 CUdpClientTestBase::Reschedule()

	{

	SetActive();

	iReschedule = TRUE;

	}

void CUdpClientTestBase::CompleteSelf ( TInt aError )

	{

	TRequestStatus* pStat = &iStatus;

    User::RequestComplete ( pStat, aError );

	}	

/** 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 CUdpClientTestBase::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 CUdpClientTestBase::RunL()

	{

	iReschedule = EFalse;

	TVerdict res = RunTestL();

	if (!iReschedule)

		{

		Cleanup();

		FinishTest(res);

		delete this;

		return;

		}

	}

void CUdpClientTestBase::FinishTest(TVerdict aResult)

	{

	iProvd->TestComplete(aResult);

	}

void CUdpClientTestBase::DoCancel()

	{

	Cleanup();

	}

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

/////////////////// CUdpClientTestUPnP /////////////////////////

////// Testcase: Send the test data from the test client/////////

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

CUdpClientTestUPnP* CUdpClientTestUPnP::NewL ( CProxyProvd* aProvd )

	{

	CUdpClientTestUPnP* ret = new ( ELeave ) CUdpClientTestUPnP ( aProvd );

	CleanupStack::PushL ( ret );

	ret->ConstructL ();

	CleanupStack::Pop ( ret );

	return ret;

	}

CUdpClientTestUPnP::CUdpClientTestUPnP ( CProxyProvd* aProvd ) :

	CUdpClientTestBase(aProvd), iTestServer(NULL), iState ( ECreateTestServer )

	{

	}

CUdpClientTestUPnP::~CUdpClientTestUPnP ()

	{

	iTimer.Close ();

	}

void CUdpClientTestUPnP::ConstructL()

	{

	iTimer.CreateLocal ();

	}

TVerdict CUdpClientTestUPnP::RunTestL()

	{//This part of the class creates a dummy server and client

	//The client sends a m-search request to the server

	//and the server responds with a Discovery Responses...this is the point where the test cases come into play

	//every test case send an invalid request to the client using udpflow

	//the client validates these responses

	const TUint16 KActivityNull = 0;

	switch ( iState )

		{

		case ECreateTestServer:

			{

			iLogger.WriteFormat(_L("<i>Creating TestServer..... </i>"));		

			iTestServer = CTestMUdpServer::NewL ( *this );

			iState  = ECreateTestClient;

			iStatus = KRequestPending;			

			Reschedule();

			return EPass;

			}

		case ECreateTestClient:

			{

			iLogger.WriteFormat(_L("<i>TestServer is created..... </i>"));			

			iLogger.WriteFormat(_L("<i>Creating TestClient..... </i>"));

			THttpUdpFlowQuery flowQuery ( Id (), EHttpUdpFlow, iChunkManager);

			const TUid requestedUid = { CUPnPFlowFactory::iUid };	

			TNodeId factoryContainer = SockManGlobals::Get( )->GetPlaneFC( TCFPlayerRole ( TCFPlayerRole::EDataPlane ) );

			RClientInterface::OpenPostMessageClose ( NodeId (), TNodeCtxId ( KActivityNull, factoryContainer ), TCFFactory::TFindOrCreatePeer ( TCFPlayerRole::EDataPlane, requestedUid, &flowQuery ).CRef () );

			iState  = ESendRequestData;

			iStatus = KRequestPending;

			Reschedule();

			return EPass;

			}

		case ESendRequestData:

			{

			iLogger.WriteFormat(_L("<i>Client is Created</i>"));

			iLogger.WriteFormat(_L("<i>Send data..... </i>"));

			RMemChunk st;

			st.CreateL ( KTestCase1, iAllocator );	//KTestCase1 = "testcase1"

			TSsdpInfo searchInfo ( 5, st ); // MX , ST

			TUpnpMessage::TUPnPSearchRequest msg ( searchInfo );

			iClientId.Node ().ReceivedL ( TNodeCtxId ( KActivityNull, Id () ), TNodeCtxId ( KActivityNull, iClientId ), msg );

			iTimer.After ( iStatus, 5000000 ); // 5secs

			iState = ECleanup;

			iStatus = KRequestPending;

			Reschedule ();

			return EPass;

			}

		case ECleanup:		

			{

			delete iTestServer;

			// cleanup udp client flow

			TEChild::TDestroy msg;

			iClientId.Node ().ReceivedL ( TNodeCtxId ( KActivityNull, Id () ), TNodeCtxId ( KActivityNull, iClientId ), msg);

			return EPass;

			}

		case EFailed:	

			{

			delete iTestServer;

			// cleanup udp client flow

			TEChild::TDestroy msg;

			iClientId.Node ().ReceivedL ( TNodeCtxId ( KActivityNull, Id () ), TNodeCtxId ( KActivityNull, iClientId ), msg);

			FinishTest ( EFail );

			delete this;

			return EFail;

			}

		default:

			iLogger.WriteFormat(_L("<i> Failed: TestCase:..... </i>"));

			ASSERT(0);

			return EFail;

		}

	}

void CUdpClientTestUPnP::OnTestServerEventL ( TInt aError )

	{

	CompleteSelf ( aError );

	}

void CUdpClientTestUPnP::ReceivedL ( const TRuntimeCtxId& /*aSender*/, const TNodeId& /*aRecipient*/, TSignatureBase& aMessage )

	{

	if ( aMessage.IsMessage<TCFFactory::TPeerFoundOrCreated> () )

		{

		const TCFFactory::TPeerFoundOrCreated& msg = message_cast < const TCFFactory::TPeerFoundOrCreated > ( aMessage );

		iClientId = msg.iNodeId;

		CompleteSelf ( KErrNone );

		}

	else if ( aMessage.IsMessage<TUpnpMessage::TUPnPSearchResponse > () )

		{

		iTimer.Cancel ();

		iState = EFailed;

		RunTestL ();

		}

	}

CUdpClientTestUPnP1* CUdpClientTestUPnP1::NewL ( CProxyProvd* aProvd )

	{

	CUdpClientTestUPnP1* ret = new ( ELeave ) CUdpClientTestUPnP1 ( aProvd );

	CleanupStack::PushL ( ret );

	ret->ConstructL ();

	CleanupStack::Pop ( ret );

	return ret;

	}

CUdpClientTestUPnP1::CUdpClientTestUPnP1 ( CProxyProvd* aProvd ) :

	CUdpClientTestBase(aProvd), iTestServer(NULL), iState ( ECreateTestServer )

	{

	}

CUdpClientTestUPnP1::~CUdpClientTestUPnP1 ()

	{

	iTimer.Close ();

	}

void CUdpClientTestUPnP1::ConstructL()

	{

	iTimer.CreateLocal ();

	}

TVerdict CUdpClientTestUPnP1::RunTestL()

	{

	const TUint16 KActivityNull = 0;

	switch ( iState )

		{

		case ECreateTestServer:

			{

			iLogger.WriteFormat(_L("<i>Creating TestServer..... </i>"));

			iTestServer = CTestMUdpServer::NewL ( *this );

			iState  = ECreateTestClient;

			iStatus = KRequestPending;			

			Reschedule();

			return EPass;

			}

		case ECreateTestClient:

			{

			iLogger.WriteFormat(_L("<i>TestServer is created..... </i>"));			

			iLogger.WriteFormat(_L("<i>Creating TestClient..... </i>"));

			THttpUdpFlowQuery flowQuery ( Id (), EHttpUdpFlow, iChunkManager);

			const TUid requestedUid = { CUPnPFlowFactory::iUid };	

			TNodeId factoryContainer = SockManGlobals::Get( )->GetPlaneFC( TCFPlayerRole ( TCFPlayerRole::EDataPlane ) );

			RClientInterface::OpenPostMessageClose ( NodeId (), TNodeCtxId ( KActivityNull, factoryContainer ), TCFFactory::TFindOrCreatePeer ( TCFPlayerRole::EDataPlane, requestedUid, &flowQuery ).CRef () );

			iState  = ESendRequestData;

			iStatus = KRequestPending;

			Reschedule();

			return EPass;

			}

		case ESendRequestData:

			{

			iLogger.WriteFormat(_L("<i>Client is Created</i>"));

			iLogger.WriteFormat(_L("<i>Send data..... </i>"));

			RMemChunk st;

			st.CreateL ( KTestCase2, iAllocator );	//KTestCase2 = "testcase2"

			TSsdpInfo searchInfo ( 5, st ); // MX , ST

			TUpnpMessage::TUPnPSearchRequest msg ( searchInfo );

			iClientId.Node ().ReceivedL ( TNodeCtxId ( KActivityNull, Id () ), TNodeCtxId ( KActivityNull, iClientId ), msg );

			iTimer.After ( iStatus, 5000000 ); // 5secs

			iState = ECleanup;

			iStatus = KRequestPending;

			Reschedule ();

			return EPass;

			}

		case ECleanup:		

			{

			delete iTestServer;

			// cleanup udp client flow

			TEChild::TDestroy msg;

			iClientId.Node ().ReceivedL ( TNodeCtxId ( KActivityNull, Id () ), TNodeCtxId ( KActivityNull, iClientId ), msg);

			return EPass;

			}

		case EFailed:	

			{

			delete iTestServer;

			// cleanup udp client flow

			TEChild::TDestroy msg;

			iClientId.Node ().ReceivedL ( TNodeCtxId ( KActivityNull, Id () ), TNodeCtxId ( KActivityNull, iClientId ), msg);

			FinishTest ( EFail );

			delete this;

			return EFail;

			}

		default:

			iLogger.WriteFormat(_L("<i> Failed: TestCase:..... </i>"));

			ASSERT(0);

			return EFail;

		}

	}

void CUdpClientTestUPnP1::OnTestServerEventL ( TInt aError )

	{

	CompleteSelf ( aError );

	}

void CUdpClientTestUPnP1::ReceivedL ( const TRuntimeCtxId& /*aSender*/, const TNodeId& /*aRecipient*/, TSignatureBase& aMessage )

	{

	if ( aMessage.IsMessage<TCFFactory::TPeerFoundOrCreated> () )

		{

		const TCFFactory::TPeerFoundOrCreated& msg = message_cast < const TCFFactory::TPeerFoundOrCreated > ( aMessage );

		iClientId = msg.iNodeId;

		CompleteSelf ( KErrNone );

		}

	else if ( aMessage.IsMessage<TUpnpMessage::TUPnPSearchResponse > () )

		{

		iTimer.Cancel ();

		iState = EFailed;

		RunTestL ();

		}

	}	

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

CUdpClientTestUPnP2* CUdpClientTestUPnP2::NewL ( CProxyProvd* aProvd )

	{

	CUdpClientTestUPnP2* ret = new ( ELeave ) CUdpClientTestUPnP2 ( aProvd );

	CleanupStack::PushL ( ret );