/*

* Copyright (c) 2005-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:  

* Design Overview:

* The diagram below shows the Script Engine classes and their parent child

* hierarchy. All classes have a CActive base, and apart from CTaskTimer, all classes

* have their own state machine. Apart from CScriptMaster, all classes have a reference

* to a Mixin/Interface completion call of its parent, which it calls when the object

* needs to notify the parent of an event.

* CScriptMaster (derived CActive)

* CScriptControl (derived CActiveBase - Can go recursive)

* CProgramControl (derived CTaskControlBase) CClientControl ( derived CTaskControlBase maps to n x test steps)

* CTaskTimer                                 CTaskTimer (derived CTimer)

*  state transition tables for CScriptMaster, CScriptControl & CClientControl

* CActiveBase:

* Derives CActive.

* Contains code for priming, triggering and completing AO's

* Implements the pure abstract MChildCompletion::ChildCompletion() method

* CTaskControlBase:

* Derives CActiveBase.

* Abstract class. Base for CClientControl and CProgramControl.

* CScriptMaster:

* Derives CActiveBase.

* Master control active object with simple state machine.

* Instantiates the top level CScriptControl object and triggers its state machine.

* CScriptContol:

* Derives CActiveBase.

* Main script interpreter state machine. Creates one or more CClientControl and/or

* CProgramControl objects.

* In CONCURRENT mode, it can create as many instances as there are RUN_TEST_STEP and/or 

* RUN_PROGRAM calls.

* Creates root sessions with the xxxtest servers using the RTestServ::Connect() client call.

* In the case of non-nested scripts, the parent object is CScriptMaster.

* When scripts are nested and it goes recursive, the parent object could be another 

* CScriptControl.

* Implements the MTaskCompletion pure abstract class for callbacks from

* CClientControl or CProgramControl objects

* Calls back into its parent object when the script is complete and all async commands have

* completed.

* CClientControl:

* Derives CTaskControlBase.

* Test Step Controler. Instantiated by CScriptControl when a RUN_TEST_STEP line is interpreted

* Creates and kicks off a CTaskTimer object set to the timeout value for the test step.

* Opens a test step using the RTestSession::Open() client call.

* Executes a test step using the RTestSession::RunTestStep() client call.

* This method issues the client RTestSession::AbortTestStep() call and

* the RunL() state machine handles the completion from the test server.

* Implements the MTaskTimerCompletion pure abstract class for callbacks from the

* CTaskTimer class.

* Calls back into its parent CScriptControl object when a test step completes.

* CProgramControl

* Derives CTaskControlBase

* Kicks off an executable in its own process and handles process completion asynchronously

* CTaskTimer:

* Derives CTimer.

* Calls back into its parent object if the timer expires.

* EPOC include

*

*/

/**

 @file scriptengine.cpp

*/

// User include

#include <test/testexecuteclient.h>

#include "scriptengine.h"

// Fix defect 119337, initialize the integer to zero

GLDEF_D TInt CScriptControl::iNestedNumRunScriptInLoop=0;

// End defect 119337

/**

 * @param aPtrC1 - Instance of TPtrC to compare

 * @param aPtrC2 - Instance of TPtrC to compare

 * Function to implement the comparison algo for RArray::Find to work with

 */

TBool TSelectiveTestingOptions::CompareTPtrC(const TPtrC& aPtrC1, const TPtrC& aPtrC2)

	{

	TInt ret =aPtrC1.CompareF(aPtrC2);

	return (ret==0) ? ETrue : EFalse;

	} 

/**

 * @param aRng1 - Instance of TRange to compare

 * @param aRng2 - Instance of TRange to compare

 * Function to implement the comparison algo for RArray::Find to work with.

 * TRange::iStartTestCase determines the match

 */

TBool TRange::CompareTRangeStartCase(const TRange& aRng1, const TRange& aRng2) 

	{

	TInt ret =aRng2.iStartTestCase.CompareF(aRng1.iStartTestCase);

	return (ret==0) ? ETrue : EFalse;

	}

/**

 * @param aRng1 - Instance of TRange to compare

 * @param aRng2 - Instance of TRange to compare

 * Function to implement the comparison algo for RArray::Find to work with.

 * TRange::iEndTestCase determines the match

 */

TBool TRange::CompareTRangeEnd(const TRange& aRng1, const TRange& aRng2) 

	{

	TInt ret =aRng2.iEndTestCase.CompareF(aRng1.iEndTestCase);

	return (ret==0) ? ETrue : EFalse;  

	}

/**

 * @param aRng1 - Instance of TRange to compare

 * @param aRng2 - Instance of TRange to compare

 * Function to implement the comparison algo for RArray::Sort to work with.

 * TRange::iStartTestCase is used as the sort key

 */

TInt TRange::CompareTRangeStartOrder(const TRange& aRng1, const TRange& aRng2) 

	{

	return aRng1.iStartTestCase.CompareF( aRng2.iStartTestCase);

	}

/**

 * @param aPtrC1 - Instance of TPtrC to compare

 * @param aPtrC2 - Instance of TPtrC to compare

 * Function to implement the comparison algo for RArray::Sort to work with.

 */

TInt TSelectiveTestingOptions::CompareTPtrCOrder(const TPtrC& aPtrC1, const TPtrC& aPtrC2) 

	{

	return aPtrC1.CompareF(aPtrC2);

	}

/**

 * @param aServ - Instance of the test server handle

 * @param aStepName - Test step name

 * Wrapper around the RTestServ class. Performs counting on test step sessions

 */

TInt RScriptTestSession::Open(RScriptTestServ& aServ, const TBool aIsTestStep, const TDesC& aStepName )

	{

	if(aServ.SharedData() && aServ.SessionCount())

			return KErrInUse;

	TInt ret = KErrNone;

	if( aIsTestStep )

		{

		ret = RTestSession::Open(aServ, aStepName, aServ.SharedData());

		}

	else

		{

		ret = RTestSession::Open(aServ, aServ.SharedData());

		}

	if(ret)

		return ret;

	aServ.AddSession();

	iServ = &aServ;

	return KErrNone;

	}

/**

 * @param aScriptFilePath - The full path and filename of a script command file.

 * @param aLogger - Reference to a logger interface object that contains HTML & XML log client sessions.

 * @param aConsole - Reference to console object for printing script line during test execution

 * @param aSysDrive - Default System drive letter

 * @param aTestSysDrive - Default System drive letter overwritten through testexecute.ini

 * Constructor

 */

CScriptMaster::CScriptMaster(const TDesC& aScriptFilePath, CTestExecuteLogger& aLogger, RConsoleLogger& aConsole, const TDriveName& aSysDrive, const TDriveName& aTestSysDrive, TSelectiveTestingOptions* aSelTestingOptions ) :

	iState(EInit), iScriptFilePath(aScriptFilePath), iLogger(aLogger), iConsoleLogger(aConsole), iDefaultSysDrive(aSysDrive), iTestSysDrive(aTestSysDrive), iSelTestingOptions(aSelTestingOptions)

	{

	}

/**

 * Destructor

 */

CScriptMaster::~CScriptMaster()

	{

	}

/**

 * Pure virtual implementation.

 * The Top level state machine Kick'd() into by MainL()

 * Picks up the completion from a CScriptControl instance then exits the scheduler

 */

void CScriptMaster::RunL()

	{

	switch (iState)

		{

	case EInit	:

		{

		// Create the master CScriptControl instance. 

		CScriptControl* scriptControl = new (ELeave) CScriptControl(*this,iScriptFilePath,Logger(),ConsoleLogger(),iStartLooping,iLoop,iDefaultSysDrive,iTestSysDrive,iSelTestingOptions);

		iState = ERunning;

		// Set our AO up ready for completion

		Prime();

		// Kick the CScriptControl state machine

		scriptControl->Kick();

		}

		break;

	case ERunning	:

		{

		// All child AO's have completed and been deleted so it's safe to exit.

		CActiveScheduler::Stop();

		}

		break;

	default:

		break;

		}

	}

/**

 * @param aCompletion - Callback into the parent object.

 * @param aScriptFilePath - The full path and filename of a script file

 * @param aLogger - Reference to a logger instance

 * @param aConsole - Reference to console object for printing script line during test execution

 * @param aStartLooping - Initiate the looping

 * @param aLoop - Check for nesting of loops

 * @param aSysDrive - Default System drive letter

 * @param aTestSysDrive - System drive letter overwritten from testexecute.ini

 * Constructor

 */

CScriptControl::CScriptControl(MChildCompletion& aCompletion, const TDesC& aScriptFilePath, CTestExecuteLogger& aLogger, RConsoleLogger& aConsole, TBool aStartLooping, TBool aLoop, const TDriveName& aSysDrive, const TDriveName& aTestSysDrive, TSelectiveTestingOptions* aSelTestingOptions):

	iScriptFile(aScriptFilePath),

	iState(EInit),

	iParent(aCompletion),

	iConcurrent(EFalse),

	iCanComplete(ETrue),

	iBreakOnError(EFalse),

	iAsyncTasksOutstanding(0),

	iCurrentScriptLineNumber(0),

	iLogger(aLogger),

	iConsoleLogger(aConsole),

	iScriptLinePrefixSet(EFalse),

	iStartLooping(aStartLooping),

	iLoop(aLoop),

	iSharedDataNum(KTEFZeroValue),

	iIsSharedData(EFalse),

	iSyncControl(NULL),

	iTestCaseID(KTEFTestCaseDefault),

	iDefaultSysDrive(aSysDrive),

	iTestSysDrive(aTestSysDrive),

	iSelTestingOptions(aSelTestingOptions),

	iSelectOne(EFalse),

	iRangeRefCounter(0),

	iTestCaseCounter(0)

	{

	}

/**

 * Destructor

 */

CScriptControl::~CScriptControl()

	{

	iTimer.Cancel();

	iTimer.Close();

	// We read the complete script into the heap for parsing so:

	delete iScriptData;

	for (TInt index = 0; index < iSharedDataNum; index++)

		{

		delete iSharedDataArray[index];

		}

	// Instance has an array of pointers to RTestServer objects.

	// Loop through deleting and closing

	TInt i = 0;

	TInt count = iServers.Count();

	for(i=0;i<count;i++)

		{

		iServers[0]->Close();

		delete iServers[0];

		iServers.Remove(0);

		}

	iServers.Close();

	if( iSyncControl )

		{

		delete iSyncControl;

		}

	}

/**

 * @param aError - Integer error value returned by the active object while leaving

 * @return TInt - System-wide error codes

 * Error Handler for active object

 */

TInt CScriptControl::RunError(TInt aError)

	{

	if (aError == KErrNoMemory)

		{

		ERR_PRINTF1(_L("Insufficient memory available to perform further operation.\n\tPlease increase the maximum heap size from the testexecute.mmp and try running the test again. Exiting test script..."));

		}

	else

		{

		ERR_PRINTF2(_L("Test execution failed with error %d. Terminating tests.."), aError);

		}

	iParent.ChildCompletion(KErrNone);

	delete this;

	return KErrNone;

	}

/**

 * Implementation of pure virtual

 * The main script interpreter state machine.

 * Kick'd() into by CScriptMaster or, in the case of nested scripts, another CScriptControl

 * instance.

 * Picks up the completions from CClientControls and/or, in the case of nested scripts,

 * another CScriptControl instance.

 */

void CScriptControl::RunL()

	{

	switch (iState)

		{

	case EInit		:

		// First state after Kick() from parent

		{

		// Standard log output goes to flogger

		// Result log goes to a propietary file in c:\logs\testexecute

		User::LeaveIfError(iTimer.CreateLocal());

		TRAPD(err,CreateScriptDataFromScriptFileL());

		if(err)

			{

			// If we can't open the script file then log the fact and gracefully exit

			// the state machine.

			TBuf<KMaxTestExecuteCommandLength> buf(iScriptFile);

			_LIT(KScriptFileError,"Failed Script File Open %S");

			ERR_PRINTF2(KScriptFileError,&buf);

			iState = EClosing;

			//condition used for checking failure in testexecute.cpp

			commentedCommandsCount=-1;

			iRunScriptFailCount++;

			Kick();

			break;

			}

		// Script file reading state next

		iState = ERunning;

		// Kick ourselves into the next state

		Kick();

		}

		break;

	case ERunning	:

		// Always in this state whilst we're reading lines from script file data member

		{

		TPtrC scriptLine;

		if(!iStartLooping)

			{

			if(!GetNextScriptLine(scriptLine))

				{

				// End of the script file

				// Check see if there are any async requests outstanding

				// In concurrent mode there are very likely to be

				if(iAsyncTasksOutstanding == 0)

					{

					// No requests outstanding so call into the parent

					iParent.ChildCompletion(KErrNone);

					delete this;

					}

				else

					{

					// Requests outstanding

					// Next time we're completed we'll be in the closing state

					iState = EClosing;

					iCanComplete =ETrue;

					// Prime ourselves for completion

					Prime();

					}

				break;

				}

			}

		//Get the script lines which are to be looped

		else if(!GetLoopScriptLine(scriptLine))

			{

			// End of the script file

			// Check see if there are any async requests outstanding

			// In concurrent mode there are very likely to be

			if(iAsyncTasksOutstanding == 0)

				{

				// No requests outstanding so call into the parent

				iParent.ChildCompletion(KErrNone);

				delete this;

				}

			else

				{

				// Requests outstanding

				// Next time we're completed we'll be in the closing state

				iState = EClosing;

				iCanComplete =ETrue;

				// Prime ourselves for completion

				Prime();

				}

			break;

			}

		iCurrentScriptLine.Set(scriptLine);

		TBool commentedCommand = CheckCommentedCommands();

		if(commentedCommand)

			{

			iCanComplete = EFalse;

			Kick();

			break;

			}

		if (iScriptLinePrefixSet )

			{

			TLex lookahead(iCurrentScriptLine);

			TPtrC firstCommand(lookahead.NextToken());

			if (firstCommand.CompareF(KTEFRemovePrefixCommand) != 0)

				{

				// If we aren't the Remove_Prefix command, prefix the current line...

				iPrefixedCurrentScriptLine = iScriptLinePrefix;

				iPrefixedCurrentScriptLine.Append(scriptLine);

				iCurrentScriptLine.Set(iPrefixedCurrentScriptLine);

				}

			}

		TRAPD(err, MakeAbsoluteFilePathsL(iCurrentScriptLine));

		PrintCurrentScriptLine();

		TLex lex(iCurrentScriptLine);

		TPtrC token(lex.NextToken());

		if (err == KTEFErrInvalidRelPath)

			{

			_LIT(KTEFErrInvalidRelPathText,"Invalid relative path provided in the script file. Skipping the script line from execution..");

			ERR_PRINTF1(KTEFErrInvalidRelPathText);

			if (token.CompareF(KTEFRunTestStepCommand) == 0 ||

				token.CompareF(KTEFRunPanicStepCommand) == 0 ||

				token.CompareF(KTEFRunTestStepResultCommand) == 0 ||

				token.CompareF(KTEFRunPanicStepResultCommand) == 0)

				{

				TExitCategoryName  blankPanicString; //Not a Panic

				LogResult(EIgnore, blankPanicString, iCurrentScriptLineNumber, iCurrentScriptLine);

				}

			iCanComplete = EFalse;

			Kick();

			break;

			}

		if(err == KErrTooBig)

			{

			_LIT(KTEFErrTooBigArguments, "One or more arguments for the command exceeded allowed limit for length. Skipping test..");

			ERR_PRINTF1(KTEFErrTooBigArguments);

			if (token.CompareF(KTEFRunTestStepCommand) == 0 ||

				token.CompareF(KTEFRunPanicStepCommand) == 0 ||

				token.CompareF(KTEFRunTestStepResultCommand) == 0 ||

				token.CompareF(KTEFRunPanicStepResultCommand) == 0)

				{

				TExitCategoryName  blankPanicString; //Not a Panic

				LogResult(EIgnore, blankPanicString, iCurrentScriptLineNumber, iCurrentScriptLine);

				}

			iCanComplete = EFalse;

			Kick();

			break;

			}

		// Main parser

		if(token.CompareF(KTEFLoadSuiteCommand) == 0 || token.CompareF(KTEFLoadServerCommand) == 0)

			{

			TRAPD(err,CreateServerFromScriptLineL());

			// Create a TLogField structure array

			// Size of array equals to number of fields to be displayed for the command

			TExtraLogField logField[2];

			// The first member of the structure stores the field name

			// The second one holds the value for the particular field

			_LIT(KSuiteName, "SUITE_NAME");

			logField[0].iLogFieldName.Copy(KSuiteName);

			logField[0].iLogFieldValue.Copy(lex.NextToken());

			logField[1].iLogFieldName.Copy(KTEFResultString);

			if(err != KErrNone)

				{

				logField[1].iLogFieldValue.Copy(KTEFResultFail);

				if( KErrNotFound == err )

					{

					_LIT(KServerNotFound,"Failed to create server, either the server or one of its dependancies could not be found.");

					ERR_PRINTF1(KServerNotFound);

					}

				else

					{

					_LIT(KServerCreateError,"Failed to Create Server Err = %d");

					ERR_PRINTF2(KServerCreateError,err);

					}

				}

			else

				{

				logField[1].iLogFieldValue.Copy(KTEFResultPass);

				}

			// Call the Logger().LogToXml routine which handles XML logging for individual commands

			// Takes in the command name, number of fields and the struture array

			Logger().LogToXml(((TText8*)__FILE__), __LINE__, RFileFlogger::ESevrMedium, token, 2, logField);

			iCanComplete = EFalse;

			Kick();

			}

		else if(token.CompareF(KTEFStartTestBlock)==0)

			{

			// Parse the START_TEST_BLOCK command line

			TInt index = 0;

			TBool taskCanComplete = ETrue;

			TBool concurrent = iConcurrent;

			// Make sure the server is loaded

			if(!GetServerIndexFromScriptLine(index))

				{

				// Not loaded. Skip the line, but ensure its logged as a failure.

				TExitCategoryName  blankPanicString; //Not a Panic

				LogResult(EIgnore, blankPanicString, iCurrentScriptLineNumber, iCurrentScriptLine);

				iCanComplete = EFalse;

				Kick();

				break;

				}

			TBuf<KMaxTestExecuteCommandLength>	startBlockLine = iCurrentScriptLine;