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