--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/cryptomgmtlibs/securitytestfw/test/testhandler2/t_testsetup.cpp	Wed Jul 08 11:25:26 2009 +0100
@@ -0,0 +1,474 @@
+/*
+* Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "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 "t_testsetup.h"
+#include "t_testactionspec.h"
+#include "t_input.h"
+#include "t_certstoreactionmemfail.h"
+#include "tcancel.h"
+#include "t_message.h"
+#include "tScriptSetup.h"
+#include "Thardcodedsetup.h"
+#include "t_testhandler.h"
+#include "t_output.h"
+#include "tTestSpec.h"
+#include "ttesthandlersettings.h"
+#include "testexecuteinterface.h"
+#include "t_logger.h"
+#include "t_testrunner.h"
+#include "t_dummyconsole.h"
+
+EXPORT_C HBufC* CTestSetup::GetArgument(TInt nPos)
+	{
+	// Get command line
+	HBufC *argv = HBufC::NewLC(User::CommandLineLength());
+	TPtr cmd(argv->Des());
+	User::CommandLine(cmd);
+
+	TLex arguments(cmd);
+	TPtrC token;
+	token.Set(KNullDesC);
+	
+	// finds nth parameter that doesnt have a - 
+	while(nPos >= 0 && !arguments.Eos())
+		{
+		token.Set(arguments.NextToken());
+		if(token.Length() > 0 && token[0] != '-')
+			nPos--;
+		}
+
+	HBufC* result = token.AllocL();
+
+	CleanupStack::PopAndDestroy(argv);
+
+	return result;
+	}
+
+void CTestSetup::InitFileserverSessionLC(RFs& aFs)
+	{
+	User::LeaveIfError(aFs.Connect());
+	CleanupClosePushL(aFs);
+	
+	// enable tests to pass file handles between processes
+	aFs.ShareProtected();
+	
+	// Create the private directory, to fix failures in tests that write to
+	// relative paths that were broken when the default path was changed to the
+	// private path in build 03429
+	TFileName privatePath;
+	User::LeaveIfError(aFs.PrivatePath(privatePath));
+	TInt err = aFs.MkDir(privatePath);
+	if (err != KErrNone && err != KErrAlreadyExists)
+		{
+		User::Leave(err);
+		}
+	}
+
+EXPORT_C void CTestSetup::CreateAndRunTestsL(TScriptTests theTestTypes[], 
+		const TDesC& aScript, const TDesC& aLogFile, TBool aUseCommandLine, 
+		CConsoleBase* aConsole, TBool* aResult)
+{
+    LOG(_L("-- Test handler starting")); 
+ 	
+	RFs fs;
+
+	InitFileserverSessionLC(fs);
+	
+	CScriptSetup* testSetup = CScriptSetup::NewLC(aConsole);
+	CTestHandlerSettings* commandLineArgs = CTestHandlerSettings::NewLC();
+ 	CTestSpec* testSpec = CTestSpec::NewL();
+	CleanupStack::PushL(testSpec);
+
+	TTestSummary summary;
+	if(testSetup->InitialiseL(fs, aScript, aLogFile, aUseCommandLine))
+		{
+		
+		// Store the state of the heap and RFs resource count before the tests
+		
+		TInt initAllocCount = User::CountAllocCells();
+		TInt initRFsCount = fs.ResourceCount();
+		
+		// Store the initial count of process and thread handles
+		TInt initThreadHandleCount;
+		TInt initProcessHandleCount;
+		RThread().HandleCount(initProcessHandleCount, initThreadHandleCount);
+		
+
+		testSetup->LogFile().write(_L("State of the system before the tests:\n"));
+		testSetup->LogFile().write(_L("\tRFs resource count: %d\n"), initRFsCount);
+		testSetup->LogFile().write(_L("\tProcess handle count: %d\n"), initProcessHandleCount);
+		testSetup->LogFile().write(_L("\tThread handle count: %d\n"), initThreadHandleCount);
+			
+		TRAPD(error, testSetup->SetupTestsL(fs, *testSpec, theTestTypes, *commandLineArgs))
+			
+		if(error==KErrNone)
+			{
+			CTestHandler* handler = CTestHandler::NewLC(fs, *testSpec, *commandLineArgs, 
+														&testSetup->Console(),
+														&testSetup->LogFile());
+			handler->RunTestsL();
+			summary = handler->Summary();
+			testSpec->FreeAllTests();
+			CleanupStack::PopAndDestroy(handler);
+			
+			// Do heap, RFs resource, process and thread handle balance checks	
+			
+			TInt finalRFsCount = fs.ResourceCount();
+			
+			testSetup->LogFile().write(_L("State of the system after the tests:\n"));
+			testSetup->LogFile().write(_L("\tRFs resource count: %d\n"), finalRFsCount);
+
+			if (initRFsCount == finalRFsCount)
+				{
+				testSetup->LogFile().write(_L("\nRFs resource count ok: %d final\n\n"),
+										   finalRFsCount);
+				}
+			else
+				{
+				testSetup->LogFile().write(_L("\nRFs resource count inbalance: %d final\n\n"),
+										   finalRFsCount);
+				++summary.iTestsFailed;
+				}
+	
+
+			TInt finalAllocCount = User::CountAllocCells();
+			if (initAllocCount == finalAllocCount)
+				{
+				testSetup->LogFile().write(_L("\nHeap alloc count ok: %d final vs %d initial\n\n"),
+										   finalAllocCount, initAllocCount);
+				}
+			else
+				{
+				testSetup->LogFile().write(_L("\nHeap alloc count inbalance: %d final vs %d initial\n\n"),
+										   finalAllocCount, initAllocCount);
+				++summary.iTestsFailed;
+				}
+
+			TInt finalThreadHandleCount;
+			TInt finalProcessHandleCount;
+			RThread().HandleCount(finalProcessHandleCount, finalThreadHandleCount);
+
+			if (initProcessHandleCount == finalProcessHandleCount)
+				{
+				testSetup->LogFile().write(_L("\nProcess handle count ok: %d final vs %d initial\n\n"),
+										   finalProcessHandleCount, initProcessHandleCount);
+				}
+			else
+				{
+				testSetup->LogFile().write(_L("\nProcess handle count imbalance: %d final vs %d initial\n\n"),
+										   finalProcessHandleCount, initProcessHandleCount);
+				++summary.iTestsFailed;
+				}
+
+			if (initThreadHandleCount == finalThreadHandleCount)
+				{
+				testSetup->LogFile().write(_L("\nThread handle count ok: %d final vs %d initial\n\n"),
+										   finalThreadHandleCount, initThreadHandleCount);
+				}
+			else
+				{
+				testSetup->LogFile().write(_L("\nThread handle count imbalance: %d final vs %d initial\n\n"),
+										   finalThreadHandleCount, initThreadHandleCount);
+				++summary.iTestsFailed;
+				}
+			++summary.iTestsRun;
+			}
+		
+		// Set the result if required by caller
+		if (aResult)
+			{
+			*aResult = summary.AllTestsPassed();
+			}
+
+		summary.PrintL(testSetup->LogFile());
+	
+		// pauses runtime if command line requests it i.e. -w
+		if(commandLineArgs->iWaitForKeyPressAtEnd)
+			{
+			testSetup->Console().Printf(_L("\nPress a key to quit"));
+			testSetup->Console().Getch();
+			}
+
+		}
+
+	CleanupStack::PopAndDestroy(4, &fs); // fs, testsetup, commandLineArgs and testspec
+	// this MUST be the last thing to do incase objects being destructed on cleanup
+	// have debug info
+	//if (bTestSuccess)
+	//	RDebug::RawPrint(_L("RTEST: SUCCESS : testhandler\n"));
+}
+
+EXPORT_C void CTestSetup::CreateAndRunTestsL(THardcodedTests theTestTypes[], const TDesC& aDefaultLog)
+{
+    LOG(_L("-- Test handler starting")); 
+ 
+	RFs fs;
+
+	InitFileserverSessionLC(fs);
+	
+	InitFileserverSessionLC(fs);
+	
+	CHardcodedSetup* testSetup = CHardcodedSetup::NewLC();
+	CTestHandlerSettings* commandLineArgs = CTestHandlerSettings::NewLC();
+ 	CTestSpec* testSpec = CTestSpec::NewL();
+	CleanupStack::PushL(testSpec);
+
+	TTestSummary summary;
+	if(testSetup->InitialiseL(fs, aDefaultLog))
+		{
+		
+		// Store the state of the heap and RFs resource count before the tests
+		
+		TInt initAllocCount = User::CountAllocCells();
+		TInt initRFsCount = fs.ResourceCount();
+				
+		TRAPD(error, testSetup->SetupTestsL(fs, *testSpec, theTestTypes, *commandLineArgs));
+			
+		if(error==KErrNone)
+			{
+			CTestHandler* handler = CTestHandler::NewLC(fs, *testSpec, *commandLineArgs, 
+														&testSetup->Console(),
+														&testSetup->LogFile());
+			handler->RunTestsL();
+			summary = handler->Summary();
+			testSpec->FreeAllTests();
+			CleanupStack::PopAndDestroy(handler);
+
+			// Do heap and RFs resource balance checks
+			
+			TInt finalRFsCount = fs.ResourceCount();
+			
+			testSetup->LogFile().write(_L("State of the system after the tests:\n"));
+			testSetup->LogFile().write(_L("\tRFs resource count: %d\n"), finalRFsCount);
+
+			if (initRFsCount == finalRFsCount)
+				{
+				testSetup->LogFile().write(_L("\nRFs resource count ok: %d final\n\n"),
+										   finalRFsCount);
+				}
+			else
+				{
+				testSetup->LogFile().write(_L("\nRFs resource count inbalance: %d final\n\n"),
+										   finalRFsCount);
+				++summary.iTestsFailed;
+				}
+
+			TInt finalAllocCount = User::CountAllocCells();
+			if (initAllocCount == finalAllocCount)
+				{
+				testSetup->LogFile().write(_L("\nHeap alloc count ok: %d final vs %d initial\n\n"),
+										   finalAllocCount, initAllocCount);
+				}
+			else
+				{
+				testSetup->LogFile().write(_L("\nHeap alloc count inbalance: %d final vs %d initial\n\n"),
+										   finalAllocCount, initAllocCount);
+				++summary.iTestsFailed;
+				}
+			++summary.iTestsRun;
+			}
+
+		summary.PrintL(testSetup->LogFile());
+
+		// pauses runtime if command line requests it i.e. -w
+		if(commandLineArgs->iWaitForKeyPressAtEnd)
+			{
+			testSetup->Console().Printf(_L("\nPress a key to quit"));
+			testSetup->Console().Getch();
+			}
+		}
+
+	CleanupStack::PopAndDestroy(4, &fs); // fs, testsetup, commandLineArgs and testspec
+	
+	//if (bTestSuccess)
+	//	RDebug::RawPrint(_L("RTEST: SUCCESS : testhandler\n"));
+}
+
+//Check all flags is provided for understanability - Each grouping function called calls the next function
+// if it has succeeded
+TBool CTestSetup::CheckAllFlags(const CTestHandlerSettings& aCommandLineSettings, TInt& aScriptGroupings)
+	{
+	return CheckExhaustiveandSmoke(aCommandLineSettings,aScriptGroupings);
+	}
+
+TBool CTestSetup::CheckExhaustiveandSmoke(const CTestHandlerSettings& aCommandLineSettings, TInt& aScriptGroupings)
+	{
+	
+	if (aCommandLineSettings.iExhaust || (aScriptGroupings & SMOKE))
+		{
+		//Do other flags
+		return CheckSkipped(aCommandLineSettings, aScriptGroupings);
+		}
+	else
+
+		return EFalse;
+	}
+
+
+TBool CTestSetup::CheckSkipped(const CTestHandlerSettings& aCommandLineSettings,
+							   TInt& aScriptGroupings)
+	{
+	if (aCommandLineSettings.iSkip || !(aScriptGroupings & SKIP))
+		{
+		//Do other flags
+		return CheckInteractive(aCommandLineSettings, aScriptGroupings);
+		}
+	else
+		return EFalse;
+	}
+
+TBool CTestSetup::CheckInteractive(const CTestHandlerSettings& aCommandLineSettings,
+								   TInt& aScriptGroupings)
+	{
+	if (aCommandLineSettings.iInt || !(aScriptGroupings & INTER))
+		{
+		//Do other flags
+		return CheckOOMandCancel(aCommandLineSettings, aScriptGroupings);
+		}
+	else
+		return EFalse;
+	}
+
+TBool CTestSetup::CheckOOMandCancel(const CTestHandlerSettings& aCommandLineSettings, 
+									TInt& aScriptGroupings)
+	{
+
+	if ((aScriptGroupings & (EXOOM | INOOM)) == (EXOOM | INOOM))
+		User::Panic(_L("Test is both Included and Excluded from OOM"), 1);
+
+	if ((aScriptGroupings & (EXCANCEL | INCANCEL)) == (EXCANCEL | INCANCEL))
+		User::Panic(_L("Test is both Included and Excluded from Cancel"), 1);
+
+	if ((aScriptGroupings & (INOOM | INCANCEL)) == (INOOM | INCANCEL))
+		User::Panic(_L("Test is in both OOM and Cancel groups"), 1);
+
+	// Check to see whether -o set
+	if (aCommandLineSettings.iOOM)
+		{
+		//Is the test in OOM group?
+		if (aScriptGroupings & INOOM)
+			return ETrue;
+		else
+		//Is the test excluded from OOM?
+		if (aScriptGroupings & EXOOM)
+			return EFalse;
+		}
+	else
+	if (aScriptGroupings & INOOM)
+			return EFalse;
+
+	// Check to see whether -c set
+	if (aCommandLineSettings.iCancel)
+		{
+		//Is the test in CANCEL group?
+		if (aScriptGroupings & INCANCEL)
+			return ETrue;
+		else
+		//Is the test excluded from CANCEL?
+		if (aScriptGroupings & EXCANCEL)
+			return EFalse;
+		}
+	else
+	if (aScriptGroupings & INCANCEL)
+			return EFalse;
+
+
+	return ETrue;
+	}
+
+
+CTestSetup::~CTestSetup()
+	{
+	delete iLogFile;
+	delete iTestConsole;
+	if (iConsoleOwned)
+		{
+		// Note that the heap count when this is deleted must be the same as
+		// when the console was allocated, otherwise a panic will occur.  This
+		// is due to the techview implementation of the console doing a heap
+		// mark in its destructor.
+		delete iConsole;
+		}
+	}
+
+CTestSetup::CTestSetup(CConsoleBase* aConsole) 
+	: iConsole(aConsole), iConsoleOwned(aConsole == NULL)
+	{
+	}
+
+void CTestSetup::ConstructL()
+	{
+	if (iConsoleOwned)
+		{
+		iConsole = Console::NewL(_L("Test code"), TSize(KDefaultConsWidth, KDefaultConsHeight));
+		}
+
+	// Currently the console passed to the test actions discards all output -
+	// this is an attempt to make hardware tests run faster.  All information
+	// should be written to the log file anyway, and I'd like to remove use of a
+	// console as well as the log file.  -- jc
+	iTestConsole = new (ELeave) CDummyConsole();
+	}
+
+void CTestSetup::OpenLogFileL(RFs &aFs, TInt nPos, const TDesC &aLogFile, TBool aUseCommandline)
+	{
+	HBufC* logFileName = NULL;
+
+	if (aUseCommandline)
+		{
+		logFileName = GetArgument(nPos);
+		CleanupStack::PushL(logFileName);
+		
+		// check if logfile was specified on command line
+		if(logFileName->Length()==0)
+			{
+			// empty so remove it
+			CleanupStack::PopAndDestroy(logFileName);
+			logFileName = NULL;
+			}
+		}
+	
+	if(logFileName == NULL)
+		{
+		if(aLogFile.Length()==0)
+			{
+			PRINTANDLOG(_L("No log file specified on command line and no default given"));
+			User::Leave(KErrArgument);
+			}
+		else
+			{
+			// there is a default copy that
+			logFileName = aLogFile.AllocL();
+			CleanupStack::PushL(logFileName);
+			}
+		}
+
+	PRINTANDLOG1(_L("Log file: %S"), logFileName);
+	
+	RFile logFile;
+
+	// attempts to create directories incase they dont exist
+	aFs.MkDirAll(*logFileName); // ignore errors
+ 
+	// write over any existing log
+	User::LeaveIfError(logFile.Replace(aFs, *logFileName, EFileWrite));
+
+	// output goes only to the log file
+	iLogFile = new(ELeave) FileOutput(logFile);
+	CleanupStack::PopAndDestroy(logFileName);
+	};