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

//

// 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 (__CTEXTMODETESTCANCELSINGLETRANS_H__)

#include "T_CancelSingleTrans.h"

#endif

#if !defined (__CTEXTMODETESTPERSISTENTCONN_H__)

#include "T_PersistentConn.h"

#endif

#if !defined (__CTEXTMODETESTCANCELMULTITRANS_H__)

#include "T_CancelMultiTrans.h"

#endif

#if !defined (__CTEXTMODETESTPOSTBODYCHUNKS_H__)

#include "T_PostBodyChunks.h"

#endif

#if !defined (__CTEXTMODETESTMULTITRANS_H__)

#include "T_MultiTrans.h"

#endif

#if !defined (__CTEXTMODETESTMULTITRANSCONCURRENT_H__)

#include "T_MultiTransConcurrent.h"

#endif

#if !defined (__CTEXTMODETESTMULTITRANSMALFORMEDSTATUSLINE_H__)

#include "T_MultiTransMalformedStatusLine.h"

#endif

#if !defined (__CTEXTMODETESTRESPCHUNKSIZE_H__)

#include "T_RespChunkSize.h"

#endif

#if !defined (__CTEXTMODETESTPROXIES_H__)

#include "T_Proxies.h"

#endif

#include "T_Cookies.h"

#include "DEF079378.h"

#include "CINC102380.h"

#include "INC094209.h"

#include "CINC097492.h"

#include "CINC097492_2.h"

#include "CINC097492_3.h"

#include "CINC097492_4.h"

#include "CINC110203.h"

#include "T_UAProf.h"

#include "T_SocketShutdownMode.h"

#include "cinc112633.h"

#include "cinc112633_2.h"

#include "csrvaddrval.h"

#include "CINC082448.h"

#include "cinc105767.h"

#include "CR1130.h"

#include "t_100continuetest.h"

#include "cinc120672.h"

#include "crecvbufsizetest1.h"

#include "crecvbufsizetest2.h"

// Constants used in this file

enum TPanic

	{

	EFailedToCreateEngine,

	EFailedToReadIniFile

	};

// Name of test harness

_LIT(KHttpOnlineTestTitle, "HTTP Online Unit Tests");

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

_LIT(KHttpOnlineTestCompName, 	"online");

_LIT(KHttpOnlineTestScriptName, "UnitTests.ini");

// Labels for resources in the INI file

_LIT(KRunTestItemName, 						"RunTest");

_LIT(KDefaultSection, 						"Defaults");

_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(KTestPostBodyChunks,					"PostBodyChunks");

//

_LIT(KTestMultiTrans,						"MultiTrans");

_LIT(KTestMultiTransConcurrent,				"MultiTransConcurrent");

_LIT(KTestMultiTransMalformedStatusLine,	"MultiTransMalformedStatusLine");

// used to specify the number of transactions to run in parallel

_LIT(KResNumTrans,							"NumTrans"); 

//

_LIT(KTestPersistentConn,					"PersistentConn");

_LIT(KResHostName,							"HostName");

_LIT(KResPath,								"Path");

//

_LIT(KTestProxies,							"Proxies");

_LIT(KResNumSubTests,						"NumSubTests");

_LIT(KResProxyAddr,							"ProxyAddr");

//

_LIT(KResSecureHostName,					"SecureHostName");

//

_LIT(KTestRespChunkSize,					"RespChunkSize");

_LIT(KResMinChunkSize,						"MinChunkSize");

_LIT(KResMaxChunkSize,						"MaxChunkSize");

_LIT(KResChunkSizeStep,						"ChunkSizeStep");

_LIT(KResProxyPort,							"ProxyPort");

//

_LIT(KTestCancelSingleTrans,				"CancelSingleTrans");

_LIT(KResCancelDelay,						"CancelDelay");

//

_LIT(KTestCancelMultiTrans,					"CancelMultiTrans");

_LIT(KTestCookies,							"Cookies");

//

_LIT(KTestUAProf,							"UAProf");

//

_LIT(KTestSocketShutdownMode,				"SocketShutdownMode");

_LIT(KTestSocketShutdownModeImmediate, 		"ImmediateShutdown");

_LIT(KTextSocketShutdownModeInterrupt, 		"Interrupt");

_LIT(KTestAuthentication, 					"Authentication");

_LIT(KTestReconnectAfterConnectionDrop, 	"ReconnectAfterConnectionDrop");

_LIT(KTestINC094209,						"INC094209");

_LIT(KTestCINC102380,						"INC102380");

_LIT(KTestINC097492,						"INC097492");

_LIT(KTestCINC105767,						"INC105767");

_LIT(KTestCR1130,							"CR1130");

_LIT(KTestINC112633,						"INC112633");

_LIT(KTestINC110203,						"INC110203");

_LIT(KTest100Continue,						"100-ContinueTest");

_LIT(KTestCINC120672_1,						"INC120672_1");

_LIT(KTestCINC120672_2,						"INC120672_2");

_LIT(KSettingsIniCompName,					"settings");

_LIT(KSettingsIniName,						"settings.ini");

_LIT(KRecvBufSizeTest1,						"RecvBufSizeTest1");

_LIT(KRecvBufSizeTest2,						"RecvBufSizeTest2");

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 ");

_LIT(KPanicOnLeave,							"Leave DoTestL()");// Panic if DeTestL() does a Leave().

/**

	This function is called the E32Main function to configure and start the

	execution of the tests.

	@leave	Leaves with a standard error, Failed to create engine, Failed to

			read ini file

*/

void DoTestsL()

	{

	// The following two lines create a semaphore which removes the security dialog

	// displayed when an untrusted certificate is received from a SSL server

	RSemaphore semaphore;

	semaphore.CreateGlobal(_L("T_AUTOSSL"), 0);

	TBool runTestDefault = EFalse;

	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

	// 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(KHttpOnlineTestTitle(), EFalse));

	if (err != KErrNone)

		{

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

		}

	CleanupStack::PushL(engine);

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

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

	CScriptFile* iniFile = NULL;

	TRAP(err, iniFile = CScriptFile::NewL(engine->Utils(), KHttpOnlineTestCompName, KHttpOnlineTestScriptName()));

	if (err != KErrNone)

		{

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

		}

	CleanupStack::PushL(iniFile);

	// Open the settings.ini file which has the server IP/Name that would

	// be used by the tests.

	CScriptFile* iniSettingsFile = NULL;

	TRAP(err, iniSettingsFile = CScriptFile::NewL(engine->Utils(), KSettingsIniCompName, KSettingsIniName()));

	if (err != KErrNone)

		{

		User::Panic(KHttpOnlineTestCompName(),EFailedToReadIniFile);

		}

	CleanupStack::PushL(iniSettingsFile);

	// 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> onlineTests;

	CleanupClosePushL(onlineTests);

	// 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 i=0;i<count;i++)

		{

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

		section = sections[i];

		_LIT(KZero, "0");

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

			{

			if (iniFile->Section(i).ItemL(KSilenceItemName).Value().CompareF(KZero) == 0)

				{

   				engine->SetSilent(EFalse);

				}

 			else

				{

				engine->SetSilent(ETrue);

				}

 			if (iniFile->Section(i).ItemL(KRunTestItemName).Value().CompareF(KZero) != 0)

				{

				runTestDefault = ETrue;

				}

			}

		// Single POST test; body data provided in timed chunks

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

			{

			TBool runTest = runTestDefault;			

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

 			if (itemPtr.CompareF(KRunTestItemName)==0)

				{

 				runTest = !(iniFile->Section(i).Item(0).Value().CompareF(KZero) == 0);

				}

 			if (runTest)

				{

				CTextModeTestPostBodyChunks* postChunksTest = CTextModeTestPostBodyChunks::NewL(iniSettingsFile);

				CleanupStack::PushL(postChunksTest);

				onlineTests.Append(postChunksTest);

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

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

				postChunksTest->SetLeakTests(numLeakTests, firstLeakIter);

				CleanupStack::Pop(postChunksTest);

				}

			}

		// Parallel transactions test  

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

			{

			TBool runTest = runTestDefault;			

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

 			if (itemPtr.CompareF(KRunTestItemName)==0)

				{

 				runTest = !(iniFile->Section(i).Item(0).Value().CompareF(KZero) == 0);

				}

 			if (runTest)

				{

				CTextModeTestMultiTrans* multiTransTest;

				TInt numTrans = iniFile->ItemValue(KTestMultiTrans(), KResNumTrans(), 8); // 8 transactions is default

				// Retrieve the host name from script / ini file.

				_LIT(KDefaultHostName, "WapTestIP");

				const TDesC& hostName = iniFile->ItemValue(KTestMultiTrans(), KResHostName(), KDefaultHostName());

				HBufC16* newUrl16 = TSrvAddrVal::ReplaceHostNameL(hostName, iniSettingsFile);

				CleanupStack::PushL(newUrl16);

				TPtr newUrlPtr16 = newUrl16->Des();

				TInt num;

				for (num = 1; num <= numTrans; num++)

					{

					multiTransTest = CTextModeTestMultiTrans::NewL(newUrlPtr16, num);

					CleanupStack::PushL(multiTransTest);

					onlineTests.Append(multiTransTest);

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

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

					multiTransTest->SetLeakTests(numLeakTests, firstLeakIter);

					}

				CleanupStack::Pop(num-1);

				CleanupStack::PopAndDestroy(newUrl16);

				}

			}

 		// Parallel transactions test  

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

 			{

 			TBool runTest = runTestDefault;			

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

 			if (itemPtr.CompareF(KRunTestItemName)==0)

				{

  				runTest = !(iniFile->Section(i).Item(0).Value().CompareF(KZero) == 0);

				}

  			if (runTest)

 				{

 				CTextModeTestMultiTransConcurrent* multiTransTest;

 				TInt numTrans = iniFile->ItemValue(KTestMultiTrans(), KResNumTrans(), 8); // 8 transactions is default

				_LIT(KDefaultHostName, "WapTestIP");

				const TDesC& hostName = iniFile->ItemValue(KTestMultiTransConcurrent(), KResHostName(), KDefaultHostName());

				HBufC16* newUrl16 = TSrvAddrVal::ReplaceHostNameL(hostName, iniSettingsFile);

				CleanupStack::PushL(newUrl16);

				TPtr newUrlPtr16 = newUrl16->Des();

				multiTransTest = CTextModeTestMultiTransConcurrent::NewL(newUrlPtr16, numTrans);

				CleanupStack::PopAndDestroy(newUrl16);

 				CleanupStack::PushL(multiTransTest);

 				onlineTests.Append(multiTransTest);

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

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

 				multiTransTest->SetLeakTests(numLeakTests, firstLeakIter);

				CleanupStack::Pop(multiTransTest);

 				}

 			}

 		// Parallel transactions test  

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

 			{

 			TBool runTest = runTestDefault;			

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

  			if (itemPtr.CompareF(KRunTestItemName)==0)

  				{

  				runTest = !(iniFile->Section(i).Item(0).Value().CompareF(KZero) == 0);

  				}

  			if (runTest)

 				{

 				CTextModeTestMultiTransMalformedStatusLine* multiTransTest;

 				TInt numTrans = iniFile->ItemValue(KTestMultiTransMalformedStatusLine(), KResNumTrans(), 1);

 				// The host here is a special test server that will always 

				// serve malform status lines

				_LIT(KDefaultHostName, "http://JigsawTestIP:9002");

				const TDesC& hostName = iniFile->ItemValue(KTestMultiTransMalformedStatusLine(), KResHostName(), KDefaultHostName());

				HBufC16* newUrl16 = TSrvAddrVal::ReplaceHostNameL(hostName, iniSettingsFile);

				CleanupStack::PushL(newUrl16);

				TPtr newUrlPtr16 = newUrl16->Des();

				TInt num;

 				for (num = 1; num <= numTrans; num++)

 					{

					multiTransTest = CTextModeTestMultiTransMalformedStatusLine::NewL(newUrlPtr16, num);

					CleanupStack::PushL(multiTransTest);

 					onlineTests.Append(multiTransTest);

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

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

 					multiTransTest->SetLeakTests(numLeakTests, firstLeakIter);

 					}

				CleanupStack::Pop(num-1);

				CleanupStack::PopAndDestroy(newUrl16);

 				}

 			}

		// Do the persistent connection test five times, each with one 

		// additional transaction

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

			{

			TBool runTest = runTestDefault;			

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

 			if (itemPtr.CompareF(KRunTestItemName)==0)

				{

 				runTest = !(iniFile->Section(i).Item(0).Value().CompareF(KZero) == 0);

				}

 			if (runTest)

				{

				CTextModeTestPersistentConn* persistConnTest;

				TInt numTrans = iniFile->ItemValue(KTestPersistentConn(), KResNumTrans(), 5); // 5 transactions is default

				_LIT(KDefaultHostName, "WapTestIP");

				_LIT(KDefaultPath, "/perl/dumpform.pl");

				const TDesC& hostName = iniFile->ItemValue(KTestPersistentConn(), KResHostName(), KDefaultHostName());

				const TDesC& path = iniFile->ItemValue(KTestPersistentConn(), KResPath(), KDefaultPath());

				HBufC16* newUrl16 = TSrvAddrVal::ReplaceHostNameL(hostName, iniSettingsFile);

				CleanupStack::PushL(newUrl16);

				TPtr newUrlPtr16 = newUrl16->Des();

				TInt num;

				for (num = 1; num <= numTrans; num++)

					{

					persistConnTest = CTextModeTestPersistentConn::NewL(newUrlPtr16, path, num);

					CleanupStack::PushL(persistConnTest);

					onlineTests.Append(persistConnTest);

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

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

					persistConnTest->SetLeakTests(numLeakTests, firstLeakIter);

					}

				CleanupStack::Pop(num-1);

				CleanupStack::PopAndDestroy(newUrl16);

				}

			}

		// Proxies test

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

			{

			TBool runTest = runTestDefault;			

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

 			if (itemPtr.CompareF(KRunTestItemName)==0)

				{

 				runTest = !(iniFile->Section(i).Item(0).Value().CompareF(KZero) == 0);

				}

 			if (runTest)

				{

				CTextModeTestProxies* proxiesTest;

				TInt numSubTests = iniFile->ItemValue(KTestProxies(), KResNumSubTests(), 10); // 10 sub-tests is default

				_LIT(KDefaultProxy, "WapTestIP:9003");

				_LIT(KDefaultHostName, "WapTestIP");

				const TDesC& proxy = iniFile->ItemValue(KTestProxies(), KResProxyAddr(), KDefaultProxy());

				const TDesC& host = iniFile->ItemValue(KTestProxies(), KResHostName(), KDefaultHostName());

				HBufC16* newUrl16 = TSrvAddrVal::ReplaceHostNameL(host, iniSettingsFile);

				CleanupStack::PushL(newUrl16);

				TPtr16 newUrlPtr16 = newUrl16->Des();

				HBufC16* proxy16 = TSrvAddrVal::ReplaceHostNameL(proxy, iniSettingsFile);

				CleanupStack::PushL(proxy16);

				TPtr16 proxyPtr16 = proxy16->Des();

				TBuf8<32> proxy8;

				proxy8.Copy(proxyPtr16);

				TBuf8<32> host8;

				host8.Copy(newUrlPtr16);

				TInt num;

				for (num = 1; num <= numSubTests; num++)

					{

					proxiesTest = CTextModeTestProxies::NewL(num, proxy8, host8);

					CleanupStack::PushL(proxiesTest);

					onlineTests.Append(proxiesTest);

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

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

					proxiesTest->SetLeakTests(numLeakTests, firstLeakIter);

					}

				CleanupStack::Pop(num-1);

				CleanupStack::PopAndDestroy(2, newUrl16); // and proxy16

				}

			}

		// Do the response chunk size test 32 times (to cover all possible 

		// chunk boundaries in the header) 

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

			{

			TBool runTest = runTestDefault;			

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

 			if (itemPtr.CompareF(KRunTestItemName)==0)

				{

 				runTest = !(iniFile->Section(i).Item(0).Value().CompareF(KZero) == 0);

				}

 			if (runTest)

				{

				CTextModeTestRespChunkSize* respChunkSizeTest;

				TInt min = iniFile->ItemValue(KTestRespChunkSize(), KResMinChunkSize(), 8); // minimum size of 8 bytes

				TInt max = iniFile->ItemValue(KTestRespChunkSize(), KResMaxChunkSize(), 256); // maximum size of 256 bytes

				// stepping up by 8 bytes each time

				TInt step = iniFile->ItemValue(KTestRespChunkSize(), KResChunkSizeStep(), 8);

				// port number the dummy proxy will listen on

				TInt port = iniFile->ItemValue(KTestRespChunkSize(), KResProxyPort(), 8000); 

				TInt num;

				TInt count=0;

				for (num = min; num <= max; num+=step)

					{

					++count;

					respChunkSizeTest = CTextModeTestRespChunkSize::NewL(port, num, iniSettingsFile);

					CleanupStack::PushL(respChunkSizeTest);

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

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

					respChunkSizeTest->SetLeakTests(numLeakTests, firstLeakIter);

					onlineTests.Append(respChunkSizeTest);

					}

				CleanupStack::Pop(count);

				}

			}

		// Do the single trans cancellation test fifty times at increasing

		// intervals