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

//

// Framework includes

#if !defined(__HTTPTESTUTILS_H__)

#include "httptestutils.h"

#endif

#if !defined(__HTTPTESTCORE_H__)

#include "HttpTestCore.h"

#endif

#if !defined(__TESTSCRIPTS_H__)

#include "TestScripts.h"

#endif

// Individual test class includes

#if !defined(__T_TEXTMODEOFFLINETESTS_H__)

#include "T_TextModeOfflineTests.h"

#endif

#include "t_formencoder.h"

#include "t_hdrcodec.h"

#include "t_core.h"

// @todo rewrite this test properly to work with pipelining changes

//#include "t_respparse.h"

#include "t_filters.h"

//#include "t_httphdr.h"

#include "ctesthttpheadercodec.h"

// @todo rewrite this test properly to work with pipelining changes

//#include "t_textmodeheadersfilter.h"

#include "t_wsptrhndstub.h"

// Constants used in this file

enum TPanic

	{

	EFailedToCreateEngine,

	EFailedToReadIniFile

	};

// Global/constant declarations

_LIT(KHttpOfflineTestTitle, "HTTP Client Offline Unit Test Harness");

// Location of INI file that defines the test cases to be run

_LIT(KHttpOfflineTestCompName, "offline");

_LIT(KHttpOfflineTestScriptName, "UnitTests.ini");

// Labels for resources in the INI file

_LIT(KRunTestItemName, "RunTest");

_LIT(KDefaultSection, "All");

_LIT(KSilenceItemName, "Silent");

_LIT(KLeakTestCount, "LeakTestCount");

_LIT(KFirstLeakIteration, "FirstLeakIteration");

// Test names, used as section headings in the .ini file, and any resource names associated with the test

_LIT(KTestHeaders,				"Headers");

_LIT(KTestFormEncoder,			"FormEncoder");

_LIT(KTestHdrCodec,				"HdrCodec");

_LIT(KTestCore,					"Core");

_LIT(KTestFilter,				"Filter");

//_LIT(KTextModeHeaderFilter,		"TextModeFilter");

//_LIT(KTestRespParsSingleBuff,	"ResponseParser_SingleBuffer");

//_LIT(KTestRespParsSplitStatus,	"ResponseParser_SplitStatus");

//_LIT(KTestRespParsMultiBuff,	"ResponseParser_MultiBuffersSimpleBody");

//_LIT(KTestRespParsMultiBody,	"ResponseParser_MultiPartNormalBody");

//_LIT(KTestRespParsChunkedBody,	"ResponseParser_MultiPartChunkedBody");

//_LIT(KTestRespParsApacheHead,	"ResponseParser_ApacheHeadResponse");

//_LIT(KTestRespParsIisHead,		"ResponseParser_IISHeadResponse");

//_LIT(KTestLineBuffOverrun,		"ResponseParser_LineBuffOverrun");

//_LIT(KTestCycleRespBuffer,		"ResponseParser_CycleRespBuffer");

//_LIT(KMinBuffSizeItemName,		"MinBuffSize");

//_LIT(KBuffSizeIncItemName,		"BuffSizeInc");

//_LIT(KWSPTransportHandlerStub,	"WSPTransportHandlerStub");

const TInt KMaxHeapSize = 0x100000;

const TInt KMaxIntDesLen = 10;				// Des length required for displaying max 32 bit int

_LIT(KTestThreadName,						"TestThread");

_LIT(KRtestFailureLabel, 					"RTEST: FAILED due to a %S %d Panic ");

// A Fake version of chttpmanager

#include <e32std.h>

#include <e32base.h>

#include "CHTTPManager.h"

void DoTestsL()

	{	

	CTestScheduler* as = new(ELeave) CTestScheduler;

	CleanupStack::PushL(as);

	if (!as)

		User::Panic(_L("Failed to create active scheduler"),KErrNoMemory);

	CActiveScheduler::Install(as); // Install active scheduler

	// Create the test engine

	CHttpTestEngine* engine=NULL;

	TRAPD(err,engine = CHttpTestEngine::NewL(KHttpOfflineTestTitle(), EFalse));

	if (err != KErrNone)

		User::Panic(_L("T_HTTPOFFLIN"),EFailedToCreateEngine);

	CleanupStack::PushL(engine);

	engine->Utils().LogIt(_L("@SYMTestCaseID IWS-APPPROTOCOLS-HTTP-FRAMEWORK-T_HTTPOFFLINE-0001 "));

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

	CScriptFile* iniFile = NULL;

	TRAP(err, iniFile = CScriptFile::NewL(engine->Utils(), KHttpOfflineTestCompName, KHttpOfflineTestScriptName()));

	if (err != KErrNone)

		{

		engine->Utils().Test().Printf(_L("\n\nExpected to find INI file %S in C:\\HttpTest\\%S\n"),

										&KHttpOfflineTestScriptName(), &KHttpOfflineTestCompName());

		engine->PressAnyKey();

		User::Panic(_L("T_HTTPOFFLIN"),EFailedToReadIniFile);

		}

	CleanupStack::PushL(iniFile);

	// Read the default silent setting for the tests

	engine->Utils().SetSilent(iniFile->ItemValue(KDefaultSection, KSilenceItemName, EFalse));

	// Create the tests we're going to run.  Ownership is transferred to the test engine

	RPointerArray<CHttpTestBase> offlineTests;

	CleanupClosePushL(offlineTests);

	// Header fields, parts and parameters tests

	if (iniFile->ItemValue(KTestHeaders(), KRunTestItemName(), ETrue))

		{

		CTestHttpHeaderCodec* httpHdrTest = CTestHttpHeaderCodec::NewLC();

		offlineTests.Append(httpHdrTest);

		TInt numLeakTests = iniFile->ItemValue(KTestHeaders(), KLeakTestCount(), 0);

		TInt firstLeakIter = iniFile->ItemValue(KTestHeaders(), KFirstLeakIteration(), 0);

		httpHdrTest->SetLeakTests(numLeakTests, firstLeakIter);

		}

	// Form encoder tests

	if (iniFile->ItemValue(KTestFormEncoder(), KRunTestItemName(), ETrue))

		{

		CFormEncoderTest* formEncTest = new(ELeave)CFormEncoderTest;

		CleanupStack::PushL(formEncTest);

		offlineTests.Append(formEncTest);

		TInt numLeakTests = iniFile->ItemValue(KTestFormEncoder(), KLeakTestCount(), 0);

		TInt firstLeakIter = iniFile->ItemValue(KTestHeaders(), KFirstLeakIteration(), 0);

		formEncTest->SetLeakTests(numLeakTests, firstLeakIter);

		}

	// Header codec tests

	if (iniFile->ItemValue(KTestHdrCodec(), KRunTestItemName(), ETrue))

		{

		CHttpHdrCodecTest* hdrCodecTest = CHttpHdrCodecTest::NewLC();

		offlineTests.Append(hdrCodecTest);

		TInt numLeakTests = iniFile->ItemValue(KTestHdrCodec(), KLeakTestCount(), 0);

		TInt firstLeakIter = iniFile->ItemValue(KTestHdrCodec(), KFirstLeakIteration(), 0);

		hdrCodecTest->SetLeakTests(numLeakTests, firstLeakIter);

		}

	// Core tests

	if (iniFile->ItemValue(KTestCore(), KRunTestItemName(), ETrue))

		{

		CHTTPCoreTest* coreTest = CHTTPCoreTest::NewLC();

		offlineTests.Append(coreTest);

		TInt numLeakTests = iniFile->ItemValue(KTestCore(), KLeakTestCount(), 0);

		TInt firstLeakIter = iniFile->ItemValue(KTestCore(), KFirstLeakIteration(), 0);

		coreTest->SetLeakTests(numLeakTests, firstLeakIter);

		}

	// Filter mechanism tests

	if (iniFile->ItemValue(KTestFilter(), KRunTestItemName(), ETrue))

		{

		CHTTPFilterTest* filterTest = CHTTPFilterTest::NewL();

		CleanupStack::PushL(filterTest);

		offlineTests.Append(filterTest);

		TInt numLeakTests = iniFile->ItemValue(KTestFilter(), KLeakTestCount(), 0);

		TInt firstLeakIter = iniFile->ItemValue(KTestFilter(), KFirstLeakIteration(), 0);

		filterTest->SetLeakTests(numLeakTests, firstLeakIter);

		}

/* @todo rewrite this test properly to work with pipelining changes

	// Textmode headers filter test

	if (iniFile->ItemValue(KTextModeHeaderFilter(), KRunTestItemName(), ETrue))

		{

		CTextModeHeadersFilterTest* textmodeheadersfiltertest = CTextModeHeadersFilterTest::NewLC();

		offlineTests.Append(textmodeheadersfiltertest);

		TInt numLeakTests = iniFile->ItemValue(KTextModeHeaderFilter(), KLeakTestCount(), 0);

		TInt firstLeakIter = iniFile->ItemValue(KTextModeHeaderFilter(), KFirstLeakIteration(), 0);

		textmodeheadersfiltertest->SetLeakTests(numLeakTests, firstLeakIter);

		}

*/

/* @todo rewrite this test properly to work with pipelining changes

	// Response Parser tests

	if (iniFile->ItemValue(KTestRespParsSingleBuff(), KRunTestItemName(), ETrue))

		{

		CRespParsTestSingleBuff* respParserTest = CRespParsTestSingleBuff::NewLC();

		offlineTests.Append(respParserTest);

		TInt numLeakTests = iniFile->ItemValue(KTestRespParsSingleBuff(), KLeakTestCount(), 0);

		TInt firstLeakIter = iniFile->ItemValue(KTestRespParsSingleBuff(), KFirstLeakIteration(), 0);

		respParserTest->SetLeakTests(numLeakTests, firstLeakIter);

		}

	if (iniFile->ItemValue(KTestRespParsSplitStatus(), KRunTestItemName(), ETrue))

		{

		CRespParsTestSplitStatusLine* respParserTest = CRespParsTestSplitStatusLine::NewLC();

		offlineTests.Append(respParserTest);

		TInt numLeakTests = iniFile->ItemValue(KTestRespParsSplitStatus(), KLeakTestCount(), 0);

		TInt firstLeakIter = iniFile->ItemValue(KTestRespParsSplitStatus(), KFirstLeakIteration(), 0);

		respParserTest->SetLeakTests(numLeakTests, firstLeakIter);

		}

	if (iniFile->ItemValue(KTestRespParsMultiBuff(), KRunTestItemName(), ETrue))

		{

		CRespParsTestMultipleBuffers* respParserTest = CRespParsTestMultipleBuffers::NewLC();

		offlineTests.Append(respParserTest);

		TInt numLeakTests = iniFile->ItemValue(KTestRespParsMultiBuff(), KLeakTestCount(), 0);

		TInt firstLeakIter = iniFile->ItemValue(KTestRespParsMultiBuff(), KFirstLeakIteration(), 0);

		respParserTest->SetLeakTests(numLeakTests, firstLeakIter);

		}

	if (iniFile->ItemValue(KTestRespParsMultiBody(), KRunTestItemName(), ETrue))

		{

		CRespParsTestMultiBodyNormal* respParserTest = CRespParsTestMultiBodyNormal::NewLC();

		offlineTests.Append(respParserTest);

		TInt numLeakTests = iniFile->ItemValue(KTestRespParsMultiBody(), KLeakTestCount(), 0);

		TInt firstLeakIter = iniFile->ItemValue(KTestRespParsMultiBody(), KFirstLeakIteration(), 0);

		respParserTest->SetLeakTests(numLeakTests, firstLeakIter);

		}

	if (iniFile->ItemValue(KTestRespParsChunkedBody(), KRunTestItemName(), ETrue))

		{

		CRespParsTestChunkedResponse* respParserTest = CRespParsTestChunkedResponse::NewLC();

		offlineTests.Append(respParserTest);

		TInt numLeakTests = iniFile->ItemValue(KTestRespParsChunkedBody(), KLeakTestCount(), 0);

		TInt firstLeakIter = iniFile->ItemValue(KTestRespParsChunkedBody(), KFirstLeakIteration(), 0);

		respParserTest->SetLeakTests(numLeakTests, firstLeakIter);

		}

	if (iniFile->ItemValue(KTestRespParsApacheHead(), KRunTestItemName(), ETrue))

		{

		CRespParsTestApacheHeadResponse* respParserTest = CRespParsTestApacheHeadResponse::NewLC();

		offlineTests.Append(respParserTest);

		TInt numLeakTests = iniFile->ItemValue(KTestRespParsApacheHead(), KLeakTestCount(), 0);

		TInt firstLeakIter = iniFile->ItemValue(KTestRespParsApacheHead(), KFirstLeakIteration(), 0);

		respParserTest->SetLeakTests(numLeakTests, firstLeakIter);

		}

	if (iniFile->ItemValue(KTestRespParsIisHead(), KRunTestItemName(), ETrue))

		{

		CRespParsTestIISHeadResponse* respParserTest = CRespParsTestIISHeadResponse::NewLC();

		offlineTests.Append(respParserTest);

		TInt numLeakTests = iniFile->ItemValue(KTestRespParsIisHead(), KLeakTestCount(), 0);

		TInt firstLeakIter = iniFile->ItemValue(KTestRespParsIisHead(), KFirstLeakIteration(), 0);

		respParserTest->SetLeakTests(numLeakTests, firstLeakIter);

		}

	if (iniFile->ItemValue(KTestLineBuffOverrun(), KRunTestItemName(), ETrue))

		{

		CRespParsTestLineBuffOverrun* respParserTest = CRespParsTestLineBuffOverrun::NewLC();

		offlineTests.Append(respParserTest);

		TInt numLeakTests = iniFile->ItemValue(KTestLineBuffOverrun(), KLeakTestCount(), 0);

		TInt firstLeakIter = iniFile->ItemValue(KTestLineBuffOverrun(), KFirstLeakIteration(), 0);

		respParserTest->SetLeakTests(numLeakTests, firstLeakIter);

		}

	if (iniFile->ItemValue(KTestCycleRespBuffer(), KRunTestItemName(), ETrue))

		{

		TInt minBuffSize = iniFile->ItemValue(KTestCycleRespBuffer(), KMinBuffSizeItemName(), 1);

		TInt buffSizeInc = iniFile->ItemValue(KTestCycleRespBuffer(), KBuffSizeIncItemName(), 1);

		CRespParsTestCyclingRespBuffer* respParserTest = CRespParsTestCyclingRespBuffer::NewLC(minBuffSize, buffSizeInc);

		offlineTests.Append(respParserTest);

		TInt numLeakTests = iniFile->ItemValue(KTestCycleRespBuffer(), KLeakTestCount(), 0);

		TInt firstLeakIter = iniFile->ItemValue(KTestCycleRespBuffer(), KFirstLeakIteration(), 0);

		respParserTest->SetLeakTests(numLeakTests, firstLeakIter);

		}

*/		

/*	if (iniFile->ItemValue(KWSPTransportHandlerStub(), KRunTestItemName(), ETrue))

		{

		CWspTrHndStubTest* wspStubTest = CWspTrHndStubTest::NewLC();

		offlineTests.Append(wspStubTest);

		TInt numLeakTests = iniFile->ItemValue(KTestCycleRespBuffer(), KLeakTestCount(), 0);

		TInt firstLeakIter = iniFile->ItemValue(KTestCycleRespBuffer(), KFirstLeakIteration(), 0);

		wspStubTest->SetLeakTests(numLeakTests, firstLeakIter);

		}

*/

	// Set the test set based on the ini file settings

	engine->ConfigureTestSet(offlineTests);

	// Pop the tests which are now owned by the test engine

	TInt numTestsToPop = offlineTests.Count();

	CleanupStack::Pop(numTestsToPop);

	CleanupStack::Pop(); // offlineTests, the array itself

	// All the action happens within the main event loop

	CActiveScheduler::Start();

	engine->Utils().LogIt(_L("\nEnd of tests"));

	TInt pass, fail;

	engine->TestSummary(pass, fail);

	engine->Utils().LogIt(_L("\nTest Summary: %d passed, %d failed.\n"), pass, fail);

	engine->PressAnyKey();

	// Clean up

	CleanupStack::PopAndDestroy(3); // inifile, engine, as

	}

TInt TestEntryPoint(TAny* /*aParam*/)

    {

__UHEAP_MARK;

	// Install exception handler

	CTrapCleanup* theCleanup = CTrapCleanup::New(); 	

	TRAP_IGNORE(DoTestsL());

	delete theCleanup;

__UHEAP_MARKEND;

	User::Heap().Check();

    return(KErrNone);

	}

void LogOnPanicL(RThread& aTestThread)	

	{

	CActiveScheduler* as = new(ELeave) CActiveScheduler;

	CleanupStack::PushL(as);

	if (!as)

		{

		User::Panic(_L("Failed to create active scheduler"),KErrNoMemory);

		}

	CActiveScheduler::Install(as); // Install active scheduler

	// Initialise Comms, required in a minimal console environment

	CHTTPTestUtils::InitCommsL();

	// Force a connection to be held open keep NT RAS connected...

	CHTTPTestUtils::HoldOpenConnectionL();

	// Create the test engine

	CHttpTestEngine* engine=NULL;

	TRAPD(err,engine = CHttpTestEngine::NewL(KHttpOfflineTestTitle(), EFalse));

	if (err != KErrNone)

		{

		User::Panic(_L("T_OFFLINE"),err);

		}

	CleanupStack::PushL(engine);

	// Create log message

	TExitCategoryName panicName = aTestThread.ExitCategory();

	TInt panicNumber = aTestThread.ExitReason();

	HBufC* logMessage = HBufC::NewLC(KRtestFailureLabel().Length() + 

								   panicName.Length() +	

								   KMaxIntDesLen);

	TPtr logMessagePtr = logMessage->Des();

	logMessagePtr.Format(KRtestFailureLabel, &panicName, panicNumber);

	engine->Utils().LogIt(logMessagePtr);

	// Panic here so that nothing else is written to the log file

	User::Panic(panicName, panicNumber);

	// The code below provided for completenes, but should never be reached

	// Release the held open connection

	CHTTPTestUtils::ReleaseConnectionL();	

	CleanupStack::PopAndDestroy(3, as); //as, engine, logMessage

	}

// main loop

//

GLDEF_C TInt E32Main()

    {  

	__UHEAP_MARK;  

	CTrapCleanup* theCleanup = CTrapCleanup::New(); // Install exception handler  

	// Create a new thread for running tests in

	RThread testThread;

	TInt err = testThread.Create(KTestThreadName, TestEntryPoint, KDefaultStackSize,  

							 KMinHeapSize, KMaxHeapSize, NULL);

	if(err == KErrNone)

		{

		testThread.Resume();	

		}

	else

		{

		return err;

		}

	// Kick off test thread and wait for it to exit

	TRequestStatus tStat;

	testThread.Logon(tStat);

	User::WaitForRequest(tStat);

	// Log if paniced

	if(testThread.ExitType() == EExitPanic)

		{

		TRAP_IGNORE(LogOnPanicL(testThread));	

		}

	testThread.Close();

	delete theCleanup;		

	__UHEAP_MARKEND;		

	return KErrNone;

	}