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

#include "CPipeliningTestEngine.h"

#include "CPipeliningTestServer.h"

#include "CPipeliningTestClient.h"

#include "CPipeliningTestParams.h"

#include "CPipeliningTestCase.h"

#include "CPipeliningConfigTest.h"

#include "ctestcaselocalandremotehost.h"

#if !defined(__TESTSCRIPTS_H__)

#include "TestScripts.h"

#endif

enum TPanic

	{

	EFailedToCreateEngine,

	EFailedToReadIniFile

	};

_LIT(KHttpPipeliningTestCompName, 	"pipelining");

_LIT(KHttpPipeliningTestScriptName, "pipelining.ini");

_LIT(KRunTestItemName, 				"RunTest");

//TestCase

_LIT(KTestCaseName,					"TestCaseName");

_LIT(KTestBatchingEnabled,			"Batching");

_LIT(KTestPipeliningEnabled,		"Pipelining");

_LIT(KTestBufferSize,				"BufferSize");

_LIT(KTestConnectionCount,			"ConnectionCount");

_LIT(KTestTransactionCount,			"TotalTransactionCount");

_LIT(KTestTransactionArr,			"TransactionList");

_LIT(KRawRequest,					"RawRequest");

_LIT(KRawResponse,					"RawResponse");

_LIT(KExpectedRequest,				".ExpectedRequests");

_LIT(KExpectedResponse,				".ExpectedResponses");

_LIT(KTestUri,						"Uri");

_LIT(KTestConn,						"Conn");

_LIT(KError,						"Error");

_LIT(KTransType,					"TransType");

_LIT(KHeaderName,					"Header");

_LIT(KHeaderVal,					".Val");

_LIT(KTestReqMethod, 				"Method");

_LIT(KTestHttpPipeliningTestTitle, "HTTP Pipelining Unit Test Harness");

_LIT(KUriLog, "TestCaseParams: Uri[%d] = %S");

_LIT(KRequestLog, "TestCaseParams: RawRequest [%d] = %S");

_LIT(KResponseLog, "TestCaseParams: RawResponse [%d] = %S");

_LIT(KHeaderLog, "TestCaseParams: Header [%d] = %S");

_LIT(KHeaderValLog, "TestCaseParams: Header [%d] : Value [%d] = %S");

CPipeliningTestEngine* CPipeliningTestEngine::NewL()

	{

	CPipeliningTestEngine* self = new (ELeave) CPipeliningTestEngine();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CPipeliningTestEngine::~CPipeliningTestEngine()

	{

	delete iTestServer;

	delete iTestUtils;

	}

CPipeliningTestEngine::CPipeliningTestEngine()

	{

	}

void CPipeliningTestEngine::ConstructL()

	{

	iTestUtils = CHTTPTestUtils::NewL(KTestHttpPipeliningTestTitle());

	iTestUtils->InitCommsL();

	iTestServer = CPipeliningTestServer::NewL(*iTestUtils, *this);

	iTestServer->StartServerL();

	}

void CPipeliningTestEngine::StartTestsL(TDesC& secName)

	{	

	TRAPD ( leaveErr,DoTestsL(secName));

	if ( leaveErr != KErrNone )

		{

		_LIT(KTxtLeave, "Engine - Caught a Leave. Leave Error: %d");

		iTestUtils->LogIt(KTxtLeave(), leaveErr);

		_LIT(KTxtFailed, "**** TEST FAILED ****");

		iTestUtils->LogIt(KTxtFailed);

		User::LeaveIfError(leaveErr);

		}

	}

void CPipeliningTestEngine::DoTestsL(TDesC& secName)

	{

	if((secName.Compare(_L("CONFIG_TEST1") ) == 0) || (secName.Compare(_L("CONFIG_TEST2") ) == 0) || (secName.Compare(_L("CONFIG_TEST3") ) == 0) || (secName.Compare(_L("CONFIG_TEST4") ) == 0))

		{

		DoPipeliningConfigTestsL(secName);

		}

	else

		{

		// Open the INI file to initialise the tests we're going to run

		CScriptFile* iniFile = NULL;

		TInt err = KErrNone;

		TRAP(err, iniFile = CScriptFile::NewL(*iTestUtils, KHttpPipeliningTestCompName(), KHttpPipeliningTestScriptName()));

		if (err != KErrNone)

			{

			User::Leave(KErrNoMemory);

			}

		CleanupStack::PushL(iniFile);

		// Create an array of sections from the script / ini file.

		CArrayPtrFlat<CScriptSection>& sections=iniFile->Sections();

		//create the  tests for iteration2 and  append them in the array

		TInt secCount = sections.Count();

		TInt count = secCount;

		CScriptSection* section = NULL;

		for ( TInt iter = 0 ; iter < count ; ++iter)

			{

			//create an array of tests to be sent to the engine

			section = sections[iter];

			// TestCase

			if ( section->SectionName().CompareF(secName) == 0)

				{

				TPtrC itemPtr(iniFile->Section(iter).Item(0).Item());

				TInt itemFieldCount= iniFile->Section(iter).Items().Count();

				TInt runTest = 0;

				runTest = iniFile->ItemValue(iniFile->Section(iter).SectionName(), KRunTestItemName(), 0);

				TPtrC runTestPtr = iniFile->Section(iter).ItemL(KRunTestItemName()).Value();

				TLex  ptrToIntLex(runTestPtr);

				ptrToIntLex.Val(runTest);

				if ( runTest == 1 )

					{

					CPipeliningTestParams* testCaseParams = CPipeliningTestParams::NewL(*iTestUtils);

					CleanupStack::PushL(testCaseParams);

					TBuf<4> intStr;

					//Urichecking strings initialisation

					HBufC* uriCheckingStringBuf = HBufC::NewL(10); 

					CleanupStack::PushL(uriCheckingStringBuf);

					TInt uriCtr = 1;

					(uriCheckingStringBuf->Des()).Copy(KTestUri());					

					intStr.Format(_L( "%d"), uriCtr++);

					(uriCheckingStringBuf->Des()).Append(intStr);

					//RawRequest 

					HBufC* rawRequestCheckingStringBuf = HBufC::NewL(24);

					CleanupStack::PushL(rawRequestCheckingStringBuf);

					TInt rawReqCtr = 1;

					(rawRequestCheckingStringBuf->Des()).Copy(KRawRequest());					

					intStr.Format(_L( "%d"), rawReqCtr++);

					(rawRequestCheckingStringBuf->Des()).Append(intStr);

					//RawResponse

					HBufC* rawResponseCheckingStringBuf = HBufC::NewL(24);

					CleanupStack::PushL(rawResponseCheckingStringBuf);

					TInt rawRespCtr = 1;

					(rawResponseCheckingStringBuf->Des()).Copy(KRawResponse());					

					intStr.Format(_L( "%d"), rawRespCtr++);

					(rawResponseCheckingStringBuf->Des()).Append(intStr);

					//ConnRequest & ConnResponse

					HBufC* connRequestArrStr = HBufC::NewL(32);

					CleanupStack::PushL(connRequestArrStr);

					HBufC* connResponseArrStr = HBufC::NewL(34);

					CleanupStack::PushL(connResponseArrStr);

					TInt connReqCtr = 1;

					TInt connRespCtr = 1;

					(connRequestArrStr->Des()).Copy(KTestConn());

					(connResponseArrStr->Des()).Copy(KTestConn());

					intStr.Format(_L( "%d"), connReqCtr++);

					(connRequestArrStr->Des()).Append(intStr);

					intStr.Format(_L( "%d"), connRespCtr++);

					(connResponseArrStr->Des()).Append(intStr);

					(connRequestArrStr->Des()).Append(KExpectedRequest());

					(connResponseArrStr->Des()).Append(KExpectedResponse());

					//TransType

					HBufC* transTypeStringBuf = HBufC::NewL(22);

					CleanupStack::PushL(transTypeStringBuf);

					TInt transTypeCtr = 2;

					(transTypeStringBuf->Des()).Copy(KTransType());					

					intStr.Format(_L( "%d"), transTypeCtr++);

					(transTypeStringBuf->Des()).Append(intStr);		

					//Header2Process

					HBufC* hdrName = HBufC::NewL(22);

					CleanupStack::PushL(hdrName);

					TInt hdrNameCtr = 1;

					(hdrName->Des()).Copy(KHeaderName());					

					intStr.Format(_L( "%d"), hdrNameCtr++);

					(hdrName->Des()).Append(intStr);	

					//ValueOfHeader	

					HBufC* hdrVal = HBufC::NewL(22);

					CleanupStack::PushL(hdrVal);

					HBufC* hdrValNext = HBufC::NewL(22);

					CleanupStack::PushL(hdrValNext);

					TInt hdrValCtr = 1;

					(hdrVal->Des()).Copy(KHeaderName());

					(hdrValNext->Des()).Copy(KHeaderName());					

					intStr.Format(_L( "%d"), (hdrNameCtr - 1));

					(hdrVal->Des()).Append(intStr);

					intStr.Format(_L( "%d"), (hdrNameCtr));

					(hdrValNext->Des()).Append(intStr);				

					(hdrVal->Des()).Append(KHeaderVal());

					(hdrValNext->Des()).Append(KHeaderVal());

					intStr.Format(_L( "%d"), hdrValCtr++);

					(hdrVal->Des()).Append(intStr);

					(hdrValNext->Des()).Append(intStr);

					for (TInt fctr=0; fctr < itemFieldCount ; ++fctr)

						{

						//Get the field and value				

						TPtrC itemFieldPtr(iniFile->Section(iter).Item(fctr).Item());

						TPtrC itemValuePtr(iniFile->Section(iter).Item(fctr).Value());

						//which member of testcase param to set?

						if (itemFieldPtr.Compare(KRunTestItemName()) == 0)

							{

							//RunTest

							testCaseParams->SetRunTest(itemValuePtr);

							TInt tempInt = 1;

							iTestUtils->LogIt(_L("TestCaseParams: RunTest= %d"), tempInt);

							}

						else if (itemFieldPtr.Compare(KTestPipeliningEnabled()) == 0)

							{

							//Pipelining Enabled

							testCaseParams->EnablePipelining(itemValuePtr);

							iTestUtils->LogIt(_L("TestCaseParams: PipeliningEnabled= %d"),testCaseParams->PipeliningEnabled());	

							}

						else if (itemFieldPtr.Compare(KTestBatchingEnabled()) == 0)			

							{

							//Batching Enabled

							testCaseParams->EnableBatching( itemValuePtr );

							iTestUtils->LogIt(_L("TestCaseParams: BatchingEnabled= %d"),testCaseParams->BatchingEnabled());	

							}

						else if (itemFieldPtr.Compare(KTestBufferSize()) == 0)				

							{

							//Buffer size

							testCaseParams->SetBufferSize(itemValuePtr);

							iTestUtils->LogIt(_L("TestCaseParams: BufferSize= %d"),testCaseParams->BufferSize());

							}

						else if (itemFieldPtr.Compare(KTestTransactionCount()) == 0)				

							{

							//TransactionCount

							testCaseParams->SetTotalTransactionCount(itemValuePtr);

							iTestUtils->LogIt(_L("TestCaseParams: TotalTransactionCount= %d"),testCaseParams->TotalTransactionCount());

							}		

						else if (itemFieldPtr.Compare(KTestConnectionCount()) == 0)			

							{

							//ConnectionCount

							testCaseParams->SetConnectionCount(itemValuePtr);

							iTestUtils->LogIt(_L("TestCaseParams: ConnectionCount= %d"),testCaseParams->ConnectionCount());

							}

						else if (itemFieldPtr.Compare(KError()) == 0)			

							{

							//Error

							testCaseParams->SetErrorL(itemValuePtr);

							iTestUtils->LogIt(_L("TestCaseParams: Error= %d"),testCaseParams->Error());

							}

						else if (itemFieldPtr.Compare(KTestCaseName()) == 0)				

							{

							//TestCaseName

							testCaseParams->SetTestCaseNameL(itemValuePtr);

							TPtrC tcName = testCaseParams->TestCaseName();

							iTestUtils->LogIt(_L("TestCaseParams: TestCaseName= %S"),&tcName);

							}

						else if (itemFieldPtr.Compare(KTestTransactionArr()) == 0)

							{

							//TransArr

							testCaseParams->SetSequenceArrL(itemValuePtr, ETransactionArray);

							iTestUtils->LogIt(_L("TestCaseParams: SequenceArr= %S"), &itemValuePtr);

							}

						else if(itemFieldPtr.Compare(KTestReqMethod()) == 0)

							{

							//Request Method

							testCaseParams->SetReqMethodL(itemValuePtr);

							TPtrC reqMethod = testCaseParams->ReqMethod();

							iTestUtils->LogIt(_L("TestCaseParams: RequestMethod= %S"),&reqMethod );

							}

						else if ((itemFieldPtr.Compare(KTestUri()) == 0) || ((itemFieldPtr.Compare(*uriCheckingStringBuf)) == 0))

							{

							//Uri

							testCaseParams->SetUriL(uriCtr-2, itemValuePtr);

							TPtrC8 uri = (testCaseParams->UriL(uriCtr-2));

							//for logging

							HBufC* uri16 = HBufC::NewL(uri.Length()*2);

							CleanupStack::PushL(uri16);

							(uri16->Des()).Copy(uri);

							TPtrC uriPtr = (uri16->Des());					

							iTestUtils->LogIt(KUriLog(), uriCtr-2 , &uriPtr);

							CleanupStack::PopAndDestroy(uri16);

							//ready for checking next uri

							(uriCheckingStringBuf->Des()).Copy(KTestUri());					

							intStr.Format(_L( "%d"), uriCtr++);

							(uriCheckingStringBuf->Des()).Append(intStr);

							}

						else if (itemFieldPtr.Compare(*rawRequestCheckingStringBuf) == 0)

							{

							//RawRequest

							testCaseParams->SetRawRequestL(rawReqCtr-2, itemValuePtr);

							TPtrC8 request = testCaseParams->RawRequest( rawReqCtr-2 );

							//for logging

							HBufC* req16 = HBufC::NewL(request.Size() * 2);

							CleanupStack::PushL(req16);

							req16->Des().Copy(request);

							TPtrC req16Ptr = req16->Des();

							iTestUtils->LogIt(KRequestLog(),rawReqCtr-2,  &req16Ptr);

							CleanupStack::PopAndDestroy(req16);

							//ready for checking next request

							(rawRequestCheckingStringBuf->Des()).Copy(KRawRequest());					

							intStr.Format(_L( "%d"), rawReqCtr++);

							(rawRequestCheckingStringBuf->Des()).Append(intStr);

							}

						else if (itemFieldPtr.Compare(*rawResponseCheckingStringBuf) == 0)

							{

							//RawRequest

							testCaseParams->SetRawResponseL(rawRespCtr-2, itemValuePtr);

							TPtrC8 response = testCaseParams->RawResponse( rawRespCtr-2 );

							//for logging

							HBufC* res16 = HBufC::NewL(response.Size() * 2);

							CleanupStack::PushL(res16);

							res16->Des().Copy(response);

							TPtrC res16Ptr = res16->Des();

							iTestUtils->LogIt(KResponseLog(),rawRespCtr-2,  &res16Ptr);

							CleanupStack::PopAndDestroy(res16);

							//ready for checking next response

							(rawResponseCheckingStringBuf->Des()).Copy(KRawResponse());					

							intStr.Format(_L( "%d"), rawRespCtr++);

							(rawResponseCheckingStringBuf->Des()).Append(intStr);

							}

						else if (itemFieldPtr.Compare(*connRequestArrStr) == 0)

							{

							//ConnReqArr

							testCaseParams->SetSequenceArrL(itemValuePtr, ERequestArray);

							TPtrC connRequestArrStrPtr = connRequestArrStr->Des();

							iTestUtils->LogIt(_L("TestCaseParams: %S= %S"),&connRequestArrStrPtr, &itemValuePtr);

							//ready for checking next connReqArr

							(connRequestArrStr->Des()).Copy(KTestConn());

							intStr.Format(_L( "%d"), connReqCtr++);

							(connRequestArrStr->Des()).Append(intStr);

							(connRequestArrStr->Des()).Append(KExpectedRequest());

							}

						else if (itemFieldPtr.Compare(*connResponseArrStr) == 0)

							{

							//ConnReqArr

							testCaseParams->SetSequenceArrL(itemValuePtr, EResponseArray);

							TPtrC connResponseArrStrPtr = connResponseArrStr->Des();

							iTestUtils->LogIt(_L("TestCaseParams: %S= %S"),&connResponseArrStrPtr, &itemValuePtr);

							//ready for checking next connReqArr

							(connResponseArrStr->Des()).Copy(KTestConn());

							intStr.Format(_L( "%d"), connRespCtr++);

							(connResponseArrStr->Des()).Append(intStr);

							(connResponseArrStr->Des()).Append(KExpectedResponse());

							}

						else if (itemFieldPtr.Compare(*transTypeStringBuf) == 0)

							{

							//TransType

							TInt returnInt = testCaseParams->SetTransactionTypeL(( transTypeCtr - 1 ), itemValuePtr);

							TPtrC transTypeStringBufPtr = transTypeStringBuf->Des();

							iTestUtils->LogIt(_L("TestCaseParams: %S= %S"), &transTypeStringBufPtr, &itemValuePtr);

							TransInfo transTypeInfo = testCaseParams->TransactionType((transTypeCtr - 1));

							//ready for checking next transType

							(transTypeStringBuf->Des()).Copy(KTransType());					

							intStr.Format(_L( "%d"), transTypeCtr++);

							(transTypeStringBuf->Des()).Append(intStr);

							}

						else if (itemFieldPtr.Compare(*hdrName) == 0)				

							{

							//HeaderName

							testCaseParams->SetHeaderToProcessL(hdrNameCtr-1, itemValuePtr);

							TPtrC8 hdr2Process = testCaseParams->HeaderToProcess(hdrNameCtr-2);

							//for logging

							HBufC *hdr16 = HBufC::NewLC(hdr2Process.Size() * 2);

							hdr16->Des().Copy(hdr2Process);

							TPtrC hdr16Ptr = hdr16->Des();

							iTestUtils->LogIt(KHeaderLog(),hdrNameCtr-1,  &hdr16Ptr);

							CleanupStack::PopAndDestroy(hdr16);

							//Get ready to look for next header

							//ready for checking next response

							(hdrName->Des()).Copy(KHeaderName());					

							intStr.Format(_L( "%d"), hdrNameCtr++);

							(hdrName->Des()).Append(intStr);

							}

						else if ((itemFieldPtr.Compare(*hdrVal) == 0) || (itemFieldPtr.Compare(*hdrValNext) == 0))				

							{

							if ((itemFieldPtr.Compare(*hdrValNext) == 0))

								{

								(hdrValNext->Des()).Copy(KHeaderName());					

								intStr.Format(_L( "%d"), hdrNameCtr - 1);

								(hdrValNext->Des()).Append(intStr);

								(hdrValNext->Des()).Append(KHeaderVal());

								intStr.Format(_L("%d"), 1);

								(hdrValNext->Des()).Append(intStr);	

								hdrValCtr = 2;

								}

							//Header Value Name

							testCaseParams->SetHdrValL(hdrNameCtr-2, hdrValCtr-1, itemValuePtr);

							TPtrC8 hdrValName = testCaseParams->HeaderVal(hdrNameCtr-2, hdrValCtr-1);

							//for logging

							HBufC* hdrVal16 = HBufC::NewL(hdrValName.Size() * 2);

							CleanupStack::PushL(hdrVal16);

							hdrVal16->Des().Copy(hdrValName);

							TPtrC hdrVal16Ptr = hdrVal16->Des();

							iTestUtils->LogIt(KHeaderValLog(),hdrNameCtr-2, hdrValCtr-2,  &hdrVal16Ptr);

							CleanupStack::PopAndDestroy(hdrVal16);

							//Get ready to look for next header

							//ready for checking next response

							(hdrVal->Des()).Copy(KHeaderName());

							intStr.Format(_L( "%d"), hdrNameCtr - 2);	

							(hdrVal->Des()).Append(intStr);						

							(hdrVal->Des()).Append(KHeaderVal());					

							intStr.Format(_L( "%d"), hdrValCtr++);

							(hdrVal->Des()).Append(intStr);			

							}

						}//should have read all available params and values for a single test case

						CleanupStack::PopAndDestroy( hdrValNext );

						CleanupStack::PopAndDestroy( hdrVal );

						CleanupStack::PopAndDestroy( hdrName );

						CleanupStack::PopAndDestroy( transTypeStringBuf );

						CleanupStack::PopAndDestroy( connResponseArrStr );

						CleanupStack::PopAndDestroy( connRequestArrStr );

						CleanupStack::PopAndDestroy( rawResponseCheckingStringBuf );			

						CleanupStack::PopAndDestroy( rawRequestCheckingStringBuf);

						CleanupStack::PopAndDestroy( uriCheckingStringBuf );

						//Valid parameters? Need to fill up Validate & the switch handles

						TRAPD(err, testCaseParams->ValidateL());

						if (err == KErrNone)

							{

							CPipeliningTestCase* testCase1 = CPipeliningTestCase::NewL(*iTestUtils, *testCaseParams);

							CleanupStack::PushL(testCase1);

							RunTestL(secName, *testCase1);

							CleanupStack::PopAndDestroy(testCase1);	

							}

						else

							{

							TPtrC testCaseNamePtr(testCaseParams->TestCaseName()) ;

							switch (err)

								{

								case KErrGeneral :

									iTestUtils->LogIt(_L("TestCaseParams->ValidateL(): %S : Invalid parameters"), &testCaseNamePtr );

									break;							

								default:

									iTestUtils->LogIt(_L("TestCaseParams->ValidateL(): %S : Invalid parameters"), &testCaseNamePtr);

									break;

								}

							}

						testCaseParams->SetErrorL(_L("KErrNone"));

						CleanupStack::Pop( testCaseParams );

						delete testCaseParams;

						}

				break;

				}

			}