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

// This module contains CParseLine and CSuiteDll classes

// CParseLine contains the functions required to execute

// a line of test script file.

// CSuiteDll objects contains information about test suite

// dlls that have been loaded.

// 

//

// system includes

#include <f32file.h>

// test system includes

#include "TestFramework.h"

#include "script.h"

#include "parseline.h"

#include "Filename.h" 

#include "parseline.inl"

const TInt KTimeIncrement = 100*1000000; // max wait interval in micro-seconds (100s)

const TUint KMaxThreadAttempts = 128;	// max number of times to attempt to create a thread

/**

 *

 * File path literals

 *

 * @xxxx

 *

 */

_LIT(KTxtDLLpath, "c:\\;c:\\system\\libs;d:\\;d:\\system\\libs;e:\\;e:\\system\\libs;z:\\;z:\\system\\libs");

/**

 *

 * Script parameter defaults

 *

 * @xxxx

 *

 */

//const TInt KTestGuardTimerDefault = 1000L;	// EABI warning removal

const TInt KPanicGuardTimerDefault = 1000000L;

const TInt KPanicExitReasonDefault = 0;

/**

 *

 * CParseLine first-phase constructor

 *

 * @xxxx

 *

 */

CParseLine::CParseLine(const TDesC& aMatchString)

	:iTestVerdict(EPass), iMatchString(aMatchString)

	{

	}

/**

 *

 * CParseLine second-phase constructor 

 *

 * @param	"CScript* aScript"

 *			The script to be parsed

 *

 * @param	"CTestUtils* aTestUtils"

 *			The TestUtils object to use

 *

 * @param	"CLog* aLog"

 *			The logger to use

 *

 * @xxxx

 *

 */

void CParseLine::ConstructL(CScript* aScript, CTestUtils* aTestUtils, CLog* aLog, TInt64 aGuardTimer)

	{

	// create a new Array to store the test steps in

	iArrayLoadedSuiteDll = new(ELeave) CArrayPtrFlat<CSuiteDll>(1);

	iScript = aScript;

	iTestUtils = aTestUtils;

	iLog = aLog;

	iGuardTimer = aGuardTimer;

	iSeverity = ESevrAll;

	iBreakOnError = EFalse;

	}

/**

 *

 * CParseLine static constructor 

 *

 * @param	"CScript* aScript"

 *			The script to be parsed

 *

 * @param	"CTestUtils* aTestUtils"

 *			The TestUtils object to use

 *

 * @param	"CLog* aLog"

 *			The logger to use

 *

 * @xxxx

 *

 */

CParseLine* CParseLine::NewL(CScript* aScript, CTestUtils* aTestUtils, CLog* aLog, TInt64 aGuardTimer, const TDesC& aMatchString)

	{

	CParseLine* self = new(ELeave) CParseLine(aMatchString);

	CleanupStack::PushL(self);

	self->ConstructL(aScript, aTestUtils, aLog, aGuardTimer);

	CleanupStack::Pop();

	return self;

	}

/**

 *

 * CParseLine destructor 

 *

 * @xxxx

 *

 */

CParseLine::~CParseLine()

	{

	// unload DLLs and their records

	if (iArrayLoadedSuiteDll)

		{

		// delete all objects in iArrayLoadedSuiteDll

		// the destructors will unload any loaded DLLS

		iArrayLoadedSuiteDll->ResetAndDestroy();

		delete iArrayLoadedSuiteDll;

		}

	}

/**

 *

 * Process a single line from the script file.

 *

 * @param	"const TDesC8& aNarrowline"

 *			The script line

 *

 * @param	"TInt8 aLineNo"

 *			The script line number

 *

 * @xxxx

 *

 */

void CParseLine::ProcessLineL(const TDesC8& aNarrowline, TInt aLineNo)

	{

	// make a local unicode buffer

	TPtr16 lineBuf(REINTERPRET_CAST(TUint16*,User::AllocLC(KMaxLenScriptLine*2)), 0, KMaxLenScriptLine);

	lineBuf.Fill('\0', KMaxLenScriptLine);

	// convert the narrow script file to Unicode

	// TBC find a better way to do this

	CFileName* testnameU = CFileName::NewLC();

	testnameU->Copy(aNarrowline);

	// find the end of the line

	TInt end = testnameU->Locate('\n');

	// copy the line into lineBuf

	if ((end != KErrNotFound) && (end < KMaxLenScriptLine))

		lineBuf = testnameU->Left(end - 1);

	else

		lineBuf = testnameU->FileName();

	// destroy filename

	CleanupStack::PopAndDestroy(testnameU);

	// the parser relies on spaces between tokens. Commas are

	// allowed but are just replaced with spaces

	TInt findComma = lineBuf.Locate(TChar(','));

	while (findComma != KErrNotFound )

		{

		// found a comma so replace with space

		lineBuf.Replace(findComma, 1, _L(" "));

		findComma = lineBuf.Locate(TChar(','));

		}

	// for debugging display the line with a line no

#ifdef SCRIPT_DEBUG

	INFO_PRINTF3(_L("Line:%d %S "), aLineNo, &lineBuf);

#endif

	// if there has been a failure and the user has selected

	// x then the next commands in the script are skipped until

	// a test complete statement is found

	if (iBreakOnError)

		{

		if (lineBuf.FindF(_L("TEST_COMPLETE")) == 0)

			{

			TestComplete(lineBuf);

			// reset flag now test complete found

			iBreakOnError = EFalse;

			}

		CleanupStack::PopAndDestroy(); // linebuf

		// do not process the rest of the line

		return;

		}

	// check the line for command keywords

	if ((lineBuf.Find(_L("//")) == 0) || (lineBuf.Find(_L("#")) == 0))

		{

		// ignore comments

		}

	else if (lineBuf.FindF(_L("LOAD_SUITE")) == 0)

		{

		LoadSuiteL(lineBuf);

		}

	else if (lineBuf.FindF(_L("RUN_SCRIPT")) == 0)

		{

		RunScriptL(lineBuf);

		}

	else if (lineBuf.FindF(_L("RUN_TEST_STEP")) == 0)

		{

		RunTestStep(lineBuf);

		}

	else if (lineBuf.FindF(_L("RUN_PANIC_STEP")) == 0)

		{

		RunPanicTestStep(lineBuf);

		}

	else if (lineBuf.FindF(_L("RUN_TERMINATION_STEP")) == 0)

		{

		RunTerminationTestStep(lineBuf);

		}

	else if (lineBuf.FindF(_L("RUN_UTILS")) == 0)

		{

		RunUtil(lineBuf);

		}

	else if (lineBuf.FindF(_L("RUN_PROGRAM")) == 0)

		{

		RunProgram(lineBuf);

		}

	else if (lineBuf.FindF(_L("UNLOAD")) == 0)

		{

		Unload();

		}

	else if (lineBuf.FindF(_L("HEAP_MARK")) == 0)

		{

		HeapMark();

		}

	else if (lineBuf.FindF(_L("HEAP_CHECK")) == 0)

		{

		HeapCheck();

		}

	else if (lineBuf.FindF(_L("REQUEST_MARK")) == 0)

		{

		RequestMark();	

		}

	else if (lineBuf.FindF(_L("REQUEST_CHECK")) == 0)

		{

		RequestCheck();

		}

	else if (lineBuf.FindF(_L("HANDLES_MARK")) == 0)

		{

		HandlesMark();

		}

	else if (lineBuf.FindF(_L("HANDLES_CHECK")) == 0)

		{

		HandlesCheck();

		}

	else if (lineBuf.FindF(_L("PRINT")) == 0)

		{

		ScriptPrint(lineBuf);

		}

	else if (lineBuf.FindF(_L("DELAY")) == 0)

		{

		Delay(lineBuf);

		}

	else if (lineBuf.FindF(_L("SEVERITY")) == 0)

		{

		SetSeverity(lineBuf);

		}

	else if (lineBuf.FindF(_L("PAUSE_AT_END")) == 0)

		{

		// if implemented, add iScript->iPauseAtEnd = ETrue;

		WARN_PRINTF1(_L("Warning : PAUSE_AT_END not implemented"));

		}

	else if (lineBuf.FindF(_L("MULTITHREAD")) == 0)

		{

		WARN_PRINTF1(_L("Warning : MULTITHREAD keyword no longer required"));

		}

	else if (lineBuf.FindF(_L("SINGLETHREAD")) == 0)

		{

		ERR_PRINTF1(_L("Error : Single thread operation no longer supported"));

		}

	else if (lineBuf.FindF(_L("PAUSE")) == 0)

		{

		iScript->Pause();

		}

	else if (lineBuf.FindF(_L("BREAK_ON_ERROR")) == 0)

		{

		// if the current test verdict is not PASS

		// give the user the chance to quit

		if ( iTestVerdict != EPass )

			iBreakOnError = iScript->BreakOnError();

		}

	else if (lineBuf.FindF(_L("TEST_COMPLETE")) == 0)

		{

		// use Tlex to decode the cmd line

		TestComplete(lineBuf);

		}

	else if (lineBuf.FindF(_L("LOG_SETTINGS")) == 0)

		{

		// use Tlex to decode the cmd line

		LogSettings(lineBuf);

		}

	else if (lineBuf.Length() == 0)

		{

		// ignore blank lines

		}

	else

		{

		// failed to decode line

		ERR_PRINTF3(_L("Error in script line:%d - \'%S\'"), aLineNo, &lineBuf);

		}

	CleanupStack::PopAndDestroy(); // linebuf

	}

/**

 *

 * Implements the TEST_COMPLETE script command.

 *

 * @param	"const TDesC& aText"

 *			The script line

 *

 * @xxxx

 *

 */

void CParseLine::TestComplete(const TDesC& aText)

	{

	// use Tlex to decode the cmd line

	TLex lex(aText);

	// start at the begining

	TPtrC token = lex.NextToken();

	// get suite name, if any

	token.Set(lex.NextToken());

	if (token.Length() != 0)

		{

		TBuf<KMaxLenTestSuiteName> currentSuiteName;

		currentSuiteName = token;

		// get step name, if any

		token.Set(lex.NextToken());

		if (token.Length() != 0)

			{	

			iCurrentStepName = token;

			iCurrentSuiteName = currentSuiteName;

			}

		else

			{

			// failed to decode line - require 0 or 2 parameters exactly

			// use last suite/step name, return fail

			ERR_PRINTF2(_L("Error in script line: \'%S\'"), &aText);

			iTestVerdict = EFail;

			}

		}

	if (!iSkip)

		{

		// add the current result to the script

		iScript->AddResult(iTestVerdict);		

		}

	// reset for next test

	iTestVerdict = EPass;

	}

/**

 *

 * Implements the PRINT script command.

 *

 * @param	"const TDesC& aText"

 *			The script line

 *

 * @xxxx

 *

 */

void CParseLine::ScriptPrint(const TDesC& aText)

	{

	// display the text after the PRINT and 1 space = 6

	INFO_PRINTF2(_L("%s "), (aText.Ptr() + 6));

	}

/**

 *

 * Implements the DELAY script command.

 *

 * @param	"const TDesC& aText"

 *			The script line

 *

 * @xxxx

 *

 */

void CParseLine::Delay(const TDesC& aText)

	{

	// if the test has already failed skip the delay

	if (iTestVerdict != EPass)

		{

		WARN_PRINTF1(_L("Skipped delay as test has already failed"));

		return;

		}

	// get the required time for the delay

	// first get the value as a string

	TLex timeOut(aText);

	timeOut.NextToken();

	TPtrC token = timeOut.NextToken();

	// convert the value into a TInt

	TLex lexTime(token);

	TInt64 guardTimerValue;

	if (lexTime.Val(guardTimerValue) != KErrNone  )

		{

		ERR_PRINTF2(_L("Error in guard timer value : could not decode \'%S\' as value"), 

					&token);

		return;

		}

	INFO_PRINTF2(_L("Delay for %ld mS"), guardTimerValue);

	// wait for the required delay

	User::After(I64INT(guardTimerValue) * 1000);

	}

/**

 *

 * Implements the SEVERITY script command.

 *

 * @param	"const TDesC& aText"

 *			The script line

 *

 * @xxxx

 *

 */

void CParseLine::SetSeverity(const TDesC& aText)

	{

	// get the required time for the delay

	// first get the value as a string

	TLex severityOut(aText);

	severityOut.NextToken();

	TPtrC token = severityOut.NextToken();

	// convert the value into a TInt

	TLex lexSeverity(token);

	TInt severityValue = ESevrAll;

	if (lexSeverity.Val(severityValue) != KErrNone)

		{

		ERR_PRINTF2(_L("Error in severity level value : could not decode \'%S\' as value"),

					&token);

		return;

		}

	// check severity value to ensure that only bitmasks in use are set...

	if(!LogSeverity::IsValid(severityValue))

		{

		ERR_PRINTF1(_L("Error in severity value : out of range"));

		return;

		}

	else

		{

		iSeverity = severityValue;

		TInt noOfDlls = iArrayLoadedSuiteDll->Count();

		for ( TInt i = 0; i < noOfDlls; i++)

			{

			CSuiteDll* ptrSuite = iArrayLoadedSuiteDll->At(i);

			CTestSuite* testSuite = ptrSuite->Suite();

			testSuite->SetSeverity(iSeverity);

			}

		}

	INFO_PRINTF2(_L("Severity is set to %d"), severityValue);

	}

/**

 *

 * Implements the RUN_SCRIPT script command.

 *

 * @param	"const TDesC& aText"

 *			The script line

 *

 * @xxxx

 *

 */

void CParseLine::RunScriptL(const TDesC& aText)

	{

	// use Tlex to decode the cmd line

	TLex lex(aText);

	// start at the begining

	TPtrC token=lex.NextToken();

	// step over the keyword

	token.Set(lex.NextToken());

	// format for printing

	INFO_PRINTF2(_L("RUN_SCRIPT %S"), &token);

	// create a new Script object (but use the current parser

	// as it has the dll loaded record)

	CScript* newScript=CScript::NewLC(this, iTestUtils, iLog, iGuardTimer, iMatchString);

	// read in the script file

	CFileName* scriptFileName = CFileName::NewLC();

	*scriptFileName = token;

	if (newScript->OpenScriptFile(scriptFileName))

		{

		// process it

		iTestVerdict = newScript->ExecuteScriptL();

		// don't bother logging verdicts for scripts - not really useful

		// add results from the new script to the owner script

		iScript->AddResult(newScript);

		}

	else

		{

		// failed to find script so verdict incloncusive

		iTestVerdict = EInconclusive;

		}

	CleanupStack::PopAndDestroy(scriptFileName);

	CleanupStack::PopAndDestroy(newScript);

	}

/**

 *

 * Implements the RUN_TEST_STEP script command.

 *

 * @param	"const TDesC& aText"

 *			The script line

 *

 * @xxxx

 *

 */

void CParseLine::RunTestStep(const TDesC& aText)

	{

	// use TLex to decode the cmd line

	TLex lex(aText);

	// step over keyword

	lex.NextToken();

	// get guard timer

	TPtrC timeout;

	timeout.Set(lex.NextToken());

	// get the other parameters

	TPtrC suite, step, config, name, paramSet;

	suite.Set(lex.NextToken());

	step.Set(lex.NextToken());

	config.Set(lex.NextToken());

	name.Set(lex.NextToken());

	if (name.Length()==0)

		{

		// name is optional, if not given use step 

		name.Set(step);

		}

	paramSet.Set(lex.NextToken()); 

	if (paramSet.Length()==0)

		{

		// paramSet is optional, if not given use name 

		paramSet.Set(name);

		}

	// save the name of the current test suite / step

	iCurrentSuiteName = suite;

	iCurrentStepName = name;

	TVerdict currentTestVerdict;

	INFO_PRINTF2(_L("<a name=\"%S\"</a>"),&name);

	if (iMatchString.Length()>0 && name.Match(iMatchString)<0)

		{

		// we have a match string but no match - so skip

		INFO_PRINTF2(_L("TEST_STEP:%S skipped"), &name);

		iSkip = ETrue;

		return;

		}

	iSkip = EFalse;

	// convert the guard timer value to a TInt64

	TLex lexTimeOut(timeout);

	TInt64 guardTimerValue;

	if (lexTimeOut.Val(guardTimerValue) != KErrNone)

		{

		ERR_PRINTF2(_L("Error in guard timer value: %S"),

					&timeout);

		currentTestVerdict = EInconclusive;

		}

	else

		{

		// override guard timer if necessary

		if((guardTimerValue == KNoGuardTimer) && (iGuardTimer != KNoGuardTimer))

			{

			INFO_PRINTF3(_L("Warning : Guard timer value overridden from %ld to %ld"),

							guardTimerValue, iGuardTimer);

			guardTimerValue = iGuardTimer;

			}

		// log the start of a test step

		INFO_PRINTF7(_L("RUN_TEST_STEP:%S (step:%S suite:%S timeout:%ldmS config:%S(%S))"),

					&name, &step, &suite, guardTimerValue, &config, &paramSet);

		// NOTE. Now running multithreaded all the time.

		currentTestVerdict = DoTestNewThread(suite, step, guardTimerValue, config, paramSet);

		}

	TPtrC verdictText = CLog::TestResultText(currentTestVerdict);

	INFO_PRINTF3(_L("TEST_STEP:%S returned:%S "), 

				&name, &verdictText);

	// this result is only significant if everything else has passed

	if (iTestVerdict == EPass)

		iTestVerdict = currentTestVerdict;

	}

/**

 *

 * Implements the RUN_PANIC_STEP script command.

 *

 * @param	"const TDesC& aText"

 *			The script line

 *

 * @xxxx

 *

 */

void CParseLine::RunPanicTestStep(const TDesC& aText)

	{

	// NOTE. RUN_PANIC_STEP now incorporates the panic reason and category

	// use Tlex to decode the cmd line

	TLex lex(aText);

	// start at the begining

	TPtrC timeout=lex.NextToken();

	// step over the keyword

	timeout.Set(lex.NextToken());

	// get the other parameters

	TPtrC suite, step;

	TPtrC category, reason;

	TPtrC config, name, paramSet;

	suite.Set(lex.NextToken());

	step.Set(lex.NextToken());

	category.Set(lex.NextToken());

	reason.Set(lex.NextToken());

	config.Set(lex.NextToken());

	name.Set(lex.NextToken());

	if (name.Length()==0)

		{

		// name is optional, if not given use step 

		name.Set(step);

		}

	paramSet.Set(lex.NextToken()); 

	if (paramSet.Length()==0)

		{

		// paramSet is optional, if not given use name 

		paramSet.Set(name);

		}

	if (iMatchString.Length()>0 && name.Match(iMatchString)<0)

		{

		// we have a match string but no match - so skip

		INFO_PRINTF2(_L("TEST_STEP:%S skipped"), &name);

		iSkip = ETrue;

		return;

		}

	iSkip = EFalse;

	// save the name of the current test suite / step

	iCurrentSuiteName = suite;

	iCurrentStepName = name;

	// convert the guard timer value to a TInt

	TLex lexTimeOut(timeout);

	TInt64 guardTimerValue;

	if (lexTimeOut.Val(guardTimerValue) != KErrNone)

		{

		ERR_PRINTF3(_L("Error in guard timer value:%S using default %dmS"), 

					&timeout, KPanicGuardTimerDefault);

		guardTimerValue = KPanicGuardTimerDefault;

		}

	// convert the exitReason value to a TInt

	TLex lexReason(reason);

	TInt exitReason;

	if (lexReason.Val(exitReason) != KErrNone)

		{

		ERR_PRINTF3(_L("Error in exitReason value:%S using default %d"), 

					&reason, KPanicExitReasonDefault);

		exitReason = KPanicExitReasonDefault;

		}

	// override guard timer if necessary

	if((guardTimerValue == KNoGuardTimer) && (iGuardTimer != KNoGuardTimer))

		{

		INFO_PRINTF3(_L("Warning : Guard timer value overridden from %ld to %ld"),

						guardTimerValue, iGuardTimer);

		guardTimerValue = iGuardTimer;

		}

	// log the start of a test step

	INFO_PRINTF9(_L("RUN_PANIC_STEP:%S (step:%S suite:%S timeout:%ldmS category:%S reason:%d config:%S(%S))"),

				&name, &step, &suite, guardTimerValue, &category, exitReason, &config, &paramSet);

	// run the test step

	TVerdict currentTestVerdict;

	// now running multithreaded all the time

	currentTestVerdict = DoPanicTest(suite, step, guardTimerValue,

									 category, exitReason, config, paramSet);

	TPtrC verdictText = CLog::TestResultText(currentTestVerdict);

	INFO_PRINTF3(_L("TEST_STEP:%S returned:%S "), 

				&name, &verdictText);

	// this result is only significant if every thing else has passed

	if (iTestVerdict == EPass)

		iTestVerdict = currentTestVerdict;

	}

/**

 *

 * Implements the RUN_TERMINATION_STEP script command.

 *

 * @param	"const TDesC& aText"

 *			The script line

 *

 * @xxxx

 *

 */

void CParseLine::RunTerminationTestStep(const TDesC& aText)

	{

	// use Tlex to decode the cmd line

	TLex lex(aText);

	// start at the begining

	TPtrC timeout=lex.NextToken();

	// step over the keyword

	timeout.Set(lex.NextToken());

	// get the other parameters

	TPtrC suite, step;

	TPtrC reason;

	TPtrC config;

	suite.Set(lex.NextToken());

	step.Set(lex.NextToken());

	reason.Set(lex.NextToken());

	config.Set(lex.NextToken());

	// save the name of the current test suite / step

	iCurrentSuiteName = suite;

	iCurrentStepName = step;

	// convert the guard timer value to a TInt

	TLex lexTimeOut(timeout);

	TInt64 guardTimerValue;

	if (lexTimeOut.Val(guardTimerValue) != KErrNone)

		{

		ERR_PRINTF3(_L("Error in guard timer value:%S using default %dmS"), 

					&timeout, KPanicGuardTimerDefault);

		guardTimerValue = KPanicGuardTimerDefault;

		}

	// convert the exitReason value to a TInt

	TLex lexReason(reason);

	TInt exitReason;

	if (lexReason.Val(exitReason) != KErrNone)

		{

		ERR_PRINTF3(_L("Error in exitReason value:%S using default %d"), 

					&reason, KPanicExitReasonDefault);

		exitReason = KPanicExitReasonDefault;

		}

	// override guard timer if necessary

	if((guardTimerValue == KNoGuardTimer) && (iGuardTimer != KNoGuardTimer))

	{

		INFO_PRINTF3(_L("Warning : Guard timer value overridden from %ld to %ld"),

						guardTimerValue, iGuardTimer);

		guardTimerValue = iGuardTimer;

	}

	// log the start of a test step

	INFO_PRINTF6(_L("RUN_TERMINATION_STEP:%S suite:%S timeout:%ldmS reason:%d config:%S"),

				&step, &suite, guardTimerValue, exitReason, &config);

	// run the test step

	TVerdict currentTestVerdict;

	// now running multithreaded all the time

	currentTestVerdict = DoTerminationTest(suite, step, guardTimerValue,

									 exitReason, config);

	TPtrC verdictText = CLog::TestResultText(currentTestVerdict);

	INFO_PRINTF3(_L("TEST_STEP:%S returned:%S "), 

				&step, &verdictText);

	// this result is only significant if every thing else has passed

	if (iTestVerdict == EPass)

		iTestVerdict = currentTestVerdict;

	}

/**

 *

 * Implements the RUN_UTILS script command.

 *

 * @param	"const TDesC& aText"

 *			The script line

 *

 * @xxxx

 *

 */

void CParseLine::RunUtil(const TDesC& aText)

	{

	// Call the utils

	iTestUtils->RunUtils(aText);

	}

/**

 *

 * Implements the REBOOT script command.

 *

 * @param	"const TDesC& aText"

 *			The script line

 *

 * @xxxx

 *

 */

void CParseLine::Reboot()

	{

	WARN_PRINTF1(_L("Warning : REBOOT command not implemented"));

	}

/**

 *

 * Static function to call DoTestStep which is run

 * in a separate thread

 *

 * @param	"TAny* aPtr"

 *			The test step data

 *

 * @return "TInt"

 *			EPOC error code

 *

 * @xxxx

 *

 */

TInt CParseLine::ThreadFunctionL(TAny* aPtr)

	{

	TInt result = KErrNone;

	// get clean-up stack

  	CTrapCleanup* trapCleanup = CTrapCleanup::New();

	TRAPD(err, result = ThreadTrapFunctionL(aPtr));

	delete trapCleanup;

	return((err != KErrNone) ? err : result);

	}

/**

 *

 * Main function to call DoTestStep, called from within

 * a trap

 *

 * @param	"TAny* aPtr"

 *			The test step data

 *

 * @return "TInt"

 *			EPOC error code

 *

 * @xxxx

 *

 */

TInt CParseLine::ThreadTrapFunctionL(TAny* aPtr)

	{

	// get the data for the test

	CStepData* data = REINTERPRET_CAST(CStepData*, aPtr);

	CSuiteDll* suiteDll = data->SuiteDll();

	CTestSuite* testSuite = suiteDll->Suite();

	// setup local logger

	CLog* logClient	= CLog::NewLC();

	logClient->OpenLogFileL();

	testSuite->SetLogSystem(logClient);

	// do the test step 

	TVerdict result =  testSuite->DoTestStep(data->Step(), data->Config(), data->ParamSet());

	// NB it is the CALLING program's responsibility to save/restore the logger.

	// If the thread terminates prematurely, the logger is in an undefined state.

	CleanupStack::PopAndDestroy(logClient);

	testSuite->SetLogSystem(NULL);

	// return the test result

	return result;

	}

/**

 *

 * Do a test step in a new thread.

 *

 * @param	"const TDesC& aSuite"

 *			The test suite

 *

 * @param	"const TDesC& aStep"

 *			The test step

 *

 * @param	"TInt aGuardTimerValue"

 *			The guard timer value

 *

 * @param	"const TDesC& aConfig"

 *			The config data

 *

 * @return  "TVerdict"

 *			The test result

 *

 * @xxxx

 *

 */

TVerdict CParseLine::DoTestNewThread(const TDesC& aSuite, const TDesC& aStep, 

							TInt64 aGuardTimerValue, const TDesC& aConfig, const TDesC& aParamSet)

	{

	//	get the number of suites loaded

	TInt noOfDlls = iArrayLoadedSuiteDll->Count();

	// search the list of loaded test suite DLLs for the required one

	for (TInt i = 0; i < noOfDlls; i++)

		{

		CSuiteDll* ptrSuite = iArrayLoadedSuiteDll->At(i);

		TPtrC name = ptrSuite->Name();

		if (name.FindF(aSuite)!= KErrNotFound)

			{

			// reset step status

			CTestSuite* testSuite = ptrSuite->Suite();

			testSuite->SetStepStatus(EStepStatusNone);

			// store old log status, for restore at thread exit

			// NB we must do this here, as if thread times out, the log

			// is in an undefined state

			CLog* oldLogger = testSuite->LogSystem();

			CStepData* data = NULL;

			TRAPD(err, data = CStepData::NewL(aStep, aConfig, aParamSet, ptrSuite));

			if (err != KErrNone)

				{

				ERR_PRINTF2(_L("CStepData::NewL() left with error %d : unable to create test data!"), err);

				return EFail;

				}

			// get step's own stack and heap sizes

			TInt theHeapSize = KMaxTestThreadHeapSize;

			TInt theStackSize = KTestStackSize;

			GetHeapAndStackSize(data, &theHeapSize, &theStackSize);

			TInt res = KErrAlreadyExists;

			RThread newThread;

			TPtrC threadBaseName(_L("DoTestThread"));

			TBuf<32> threadName;

			// create a unique named test thread

			// this will leave if creation is not successful