--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/applayerprotocols/httptransportfw/Test/T_HttpOffline/t_httpoffline.cpp	Tue Feb 02 01:09:52 2010 +0200
@@ -0,0 +1,431 @@
+// 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;
+	}