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

 // 

 //

 // system includes

 #include <f32file.h>

 // test system includes

 #include <testframework.h>

 #include "Filename.h"

 #include "script.h"

 #include "parseline.h"

 #include "config.h"

 #if !defined (__TSU_TESTFRAMEWORK__)

 /**

  *

  * Script files can reference other script files.

  * KMaxDepthRecursion limits the number of references.

  * This is to catch accidental circular references in script files

  * which would otherwise cause the system to continue until all

  * memory had be used making more CScript objects.

  *

  * @xxxx

  *

  */

 const TInt KMaxDepthRecursion = 100; 

 #endif

 /**

  *

  * Global data : count of how deep in script files parser is.

  * This is to check against infinite recursion

  *

  * NB : we must patch this out for Unit Testing, where script.cpp

  * is part of a DLL

  *

  * @xxxx

  *

  */

 // do not define static if Unit Testing

 #if !defined (__TSU_TESTFRAMEWORK__)

 GLDEF_D TInt CScript::iScriptDepth = 0;

 #endif			

 /**

  *

  * Console prompts

  *

  * @xxxx

  *

  */

 //_LIT(KTxtPressAnyKey,"[press any key to continue]\n");	// EABI warning removal

 //_LIT(KTxtBreakOnError,"The test has failed, press X to terminate this test\n [press any other key to continue]\n");	// EABI warning removal

 /**

  *

  * CScript first-phase constructor

  *

  * @xxxx

  *

  */

 CScript::CScript()

 	{

 	}

 /**

  *

  * CScript second-phase constructor for a script processor which

  * does not inherit a parser.

  *

  * @param	"CTestUtils* aTestUtils"

  *			The TestUtils object to use

  *

  * @param	"CLog* aLog"

  *			The logger to use

  *

  * @xxxx

  *

  */

 void CScript::ConstructL(CTestUtils* aTestUtils, CLog* aLog, TInt64 aGuardTimer, const TDesC& aMatchString)

 	{

 	iLog = aLog;

 	iGuardTimer = aGuardTimer;

 	iMatchString = aMatchString.AllocL();

 	iParse = CParseLine::NewL(this, aTestUtils, aLog, aGuardTimer, *iMatchString);

 	iParseOwner = ETrue;

 	iPauseAtEnd = EFalse;

 #if !defined (__TSU_TESTFRAMEWORK__)

 	iScriptDepth++;

 #endif

 	}

 /**

  *

  * CScript static constructor for a script processor which

  * does not inherit a parser.

  *

  * @param	"CTestUtils* aTestUtils"

  *			The TestUtils object to use

  *

  * @param	"CLog* aLog"

  *			The logger to use

  *

  * @xxxx

  *

  */

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

 	{

 	CScript * self = new(ELeave) CScript;

 	CleanupStack::PushL(self);

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

 	CleanupStack::Pop();

 	return self;

 	}

 /**

  *

  * CScript static constructor for a script processor which

  * does not inherit a parser.

  *

  * @param	"CTestUtils* aTestUtils"

  *			The TestUtils object to use

  *

  * @param	"CLog* aLog"

  *			The logger to use

  *

  * @xxxx

  *

  */

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

 	{

 	CScript * self = new(ELeave) CScript;

 	CleanupStack::PushL(self);

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

 	return self;

 	}

 /**

  *

  * CScript second-phase constructor, for a script processor which

  * inherits a parser.

  *

  * @param	"CParseLine* aParse"

  *			The parser to use

  *

  * @param	"CTestUtils*"

  *			Dummy parameter (would be used for constructing a parser);

  *			retained to maintain overload distinction

  *

  * @param	"CLog * aLog"

  *			The logger to use

  *

  * @xxxx

  *

  */

 void CScript::ConstructL(CParseLine* aParse, CTestUtils*, CLog* aLog, TInt64 aGuardTimer, const TDesC& aMatchString)

 	{

 	iLog = aLog;

 	iGuardTimer = aGuardTimer;

 	iMatchString = aMatchString.AllocL(); // should be the same as that for aParse, for moment don't check

 	iParse = aParse;

 	iParseOwner = EFalse;

 	iPauseAtEnd = EFalse;

 #if !defined (__TSU_TESTFRAMEWORK__)

 	iScriptDepth++;

 #endif

 	}

 /**

  *

  * CScript static constructor for a script processor which

  * inherits a parser.

  *

  * @param	"CParseLine* aParse"

  *			The parser to use

  *

  * @param	"CTestUtils* aTestUtils"

  *			The TestUtils object to use

  *

  * @param	"CLog* aLog"

  *			The logger to use

  *

  * @xxxx

  *

  */

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

 	{

 	CScript* self = new(ELeave) CScript;

 	CleanupStack::PushL(self);

 	self->ConstructL(aParse, aTestUtils, aLog, aGuardTimer, aMatchString);

 	CleanupStack::Pop();

 	return self;

 	}

 /**

  *

  * CScript static constructor for a script processor which

  * inherits a parser.

  *

  * @param	"CParseLine* aParse"

  *			The parser to use

  *

  * @param	"CTestUtils* aTestUtils"

  *			The TestUtils object to use

  *

  * @param	"CLog* aLog"

  *			The logger to use

  *

  * @xxxx

  *

  */

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

 	{

 	CScript* self = new(ELeave) CScript;

 	CleanupStack::PushL(self);

 	self->ConstructL(aParse, aTestUtils, aLog, aGuardTimer, aMatchString);

 	return self;

 	}

 /**

  *

  * CScript destructor

  *

  * @xxxx

  *

  */

 CScript::~CScript()

 	{

 	// delete parser if we own it

 	if(iParseOwner)

 		{

 		delete iParse;

 		iParse = NULL;

 		}

 	// delete scriptbuffer

 	delete iScriptBuffer;

 	delete iMatchString;

 #if !defined (__TSU_TESTFRAMEWORK__)

 	iScriptDepth--;

 #endif

 	}

 /**

  *

  * Open and read a script file.

  *

  * @param	"TFileName aScriptFileName"

  *			The script file name

  *

  * @return	"TBool"

  *			true if script file successfully read

  *

  * @xxxx

  *

  */

 #ifdef EXCLUDE_FOR_UNITTEST

 TBool CScript::OpenScriptFile(CFileName* /*aScriptFileName*/)

 	{

 	// empty function to silence OPT:REF warning under WINS UREL build

 	return ETrue;

 	}

 #else

 TBool CScript::OpenScriptFile(CFileName* aScriptFileName)

 	{

 	// get the full pathname default drive name and extension

 	_LIT(KRelated,"\\xx.script"); 

 	TParse parseScriptFileName;

 	TInt returnCode = parseScriptFileName.Set(aScriptFileName->FileName(), &KRelated, NULL);

 	if (returnCode != KErrNone)

 		{

 		ERR_PRINTF2(_L("Could not set script filename: %S"), &parseScriptFileName.FullName());

 		Pause();

 		return EFalse;

 		}

 #if !defined (__TSU_TESTFRAMEWORK__)

 	if (iScriptDepth > KMaxDepthRecursion)

 		{

 		// prevent the parser from recursing forever

 		ERR_PRINTF2(_L("Script parser aborting: depth:%d"), iScriptDepth);

 		return EFalse;	

 		}

 #if !defined(__WINS__)

 	if (iScriptDepth > 3)

 		{

 		// on target, we are likely to KERN-EXEC 3 if nesting more than 4 levels

 		WARN_PRINTF2(_L("Warning : script parser depth = %d"), iScriptDepth);

 		}

 #endif

 #endif

 	// connect to the fileserver

 	returnCode = iTheFs.Connect();

 	if (returnCode != KErrNone)

 		{

 		ERR_PRINTF1(_L("Error trying to connect to the file server") );	

 		return EFalse;

 		}

 	RFile listfile;

 	// have we got a drive letter specified - if not, check all drives

 	if (parseScriptFileName.DrivePresent())

 		{

 		returnCode = listfile.Open(iTheFs, parseScriptFileName.FullName(), EFileRead | EFileShareAny);

 		}

 	else

 		{

 		// checks C, D, E and Z drives - this is ugly, is there a better way of doing this?

 		INFO_PRINTF1(_L("Looking for script file on all drives..."));

 		_LIT(KDriveC, "C:");

 		parseScriptFileName.Set(aScriptFileName->FileName(), &KRelated, &KDriveC);

 		returnCode = listfile.Open(iTheFs, parseScriptFileName.FullName(), EFileRead | EFileShareAny);

 		if (returnCode != KErrNone)

 			{

 			_LIT(KDriveD, "D:");

 			parseScriptFileName.Set(aScriptFileName->FileName(), &KRelated, &KDriveD);

 			returnCode = listfile.Open(iTheFs, parseScriptFileName.FullName(), EFileRead | EFileShareAny);

 			if (returnCode != KErrNone)

 				{

 				_LIT(KDriveE, "E:");

 				parseScriptFileName.Set(aScriptFileName->FileName(), &KRelated, &KDriveE);

 				returnCode = listfile.Open(iTheFs, parseScriptFileName.FullName(), EFileRead | EFileShareAny);

 				if (returnCode != KErrNone)

 					{

 					_LIT(KDriveZ, "Z:");

 					parseScriptFileName.Set(aScriptFileName->FileName(), &KRelated, &KDriveZ);

 					returnCode = listfile.Open(iTheFs, parseScriptFileName.FullName(), EFileRead | EFileShareAny);

 					}

 				}

 			}

 		}

 	// check if open fails 

 	if (returnCode != KErrNone)

 		{

 		parseScriptFileName.Set(aScriptFileName->FileName(), &KRelated, NULL);

 		ERR_PRINTF2(_L("Failed to open script file : %S"), &parseScriptFileName.FullName());

 		listfile.Close();

 		iTheFs.Close();

 		Pause();

 		return EFalse;

 		}

 	// display the file being processed

 	INFO_PRINTF2(_L("Reading script %S"), &parseScriptFileName.FullName());

 	// get the script file size

 	TInt listfilesize;

 	returnCode = listfile.Size(listfilesize);

 	if (returnCode != KErrNone)

 		{

 		ERR_PRINTF2(_L("Failed to read script file: %S size "), &parseScriptFileName.FullName());

 		listfile.Close();

 		iTheFs.Close();

 		return EFalse;

 		}

 	// JW 30-10-02 DEF004555 

 	// Buffer was being orphaned if already allocated, where there was more than one

 	// script file on the command line

 	// Now, we check for this and delete iScriptBuffer if it already exists

 	if(iScriptBuffer)

 		{

 		delete iScriptBuffer;

 		iScriptBuffer = NULL;

 		}

 	// get a buffer to read the file into

 	TRAPD(err, iScriptBuffer = HBufC8::NewL(listfilesize));

 	if (err != KErrNone || iScriptBuffer == NULL)

 		{

 		ERR_PRINTF2(_L("Failed to allocate memory for script file %S "), &parseScriptFileName.FullName());

 		listfile.Close();

 		iTheFs.Close();

 		return EFalse;

 		}

 	// get a pointer to the buffer

 	TPtr8 ptr = iScriptBuffer->Des();

 	// read the file into the buffer

 	returnCode = listfile.Read(ptr);

 	if (returnCode != KErrNone)

 		{

 		ERR_PRINTF2(_L("Failed to read script file %S "), &parseScriptFileName.FullName());

 		listfile.Close();

 		iTheFs.Close();

 		return EFalse;

 		}

 	listfile.Close();

 	iTheFs.Close();

 	return ETrue;

 	}

 #endif // EXCLUDE_FOR_UNITTEST

 /**

  *

  * Parse and execute script file.

  * Assumes script file has been read into iScriptBuffer

  *

  * @return	"TVerdict"

  *			The script verdict (for logging)

  *

  * @xxxx

  *

  */

 TVerdict CScript::ExecuteScriptL()

 	{

 	// use TLex to decode the script

 	TLex8 llex(*iScriptBuffer);

 	// keep a count of the line number

 	TInt8 lineNo = 1;

 	// loop though processing the rest a line at a time

 	while(!llex.Eos())

 		{

 		// skip any spaces

 		while ( llex.Peek() == ' ' )

 			llex.Inc();

 		// mark the start of the line

 		llex.Mark();

 		// move to the next

 		while(!llex.Eos() && llex.Peek() != '\n')

 			llex.Inc();

 		// step over \n

 		if ( llex.Peek() == '\n' )

 			llex.Inc();

 		// get the line 

 		TPtrC8 pline = llex.MarkedToken();

 		if (pline.Length() != 0)

 			{

 			// and then process

 			ProcessLineL(pline, lineNo);

 			}

 		// on to the next line

 		lineNo++;

 		}

 	// script processing complete, now return the script verdict

 	// Note: the script verdicts are just for the log

 	// if no tests failed then return pass for the script

 	// this covers scripts which do not test anything

 	return (iFail == 0 ? EPass : EFail );

 	}

 /**

  *

  * Process a single line from the script file.

  *

  * @param	"const TDesC8& aNarrowline"

  *			The script line

  *

  * @param	"TInt8 lineNo"

  *			The script line number

  *

  * @xxxx

  *

  */

 void CScript::ProcessLineL(const TDesC8& aNarrowline, TInt8 aLineNo)

 	{

 	// call parse to process line

 	iParse->ProcessLineL(aNarrowline, aLineNo);

 	}

 /**

  *

  * Display the accumulated script results.

  *

  * @xxxx

  *

  */

 void CScript::DisplayResults()

 	{

 	INFO_PRINTF1(_L("Test Results Summary ") );

 	INFO_PRINTF1(_L("-------------------- ") );

 	INFO_PRINTF2(_L("Passed            :%d"),  iPass);

 	INFO_PRINTF2(_L("Failed            :%d"),  iFail);

 	INFO_PRINTF2(_L("Inconclusive      :%d"),  iInconclusive);

 	INFO_PRINTF2(_L("Test suite errors :%d"),  iTestSuiteError);

 	INFO_PRINTF2(_L("Aborted           :%d"),  iAbort);

 	INFO_PRINTF2(_L("KnownFailure      :%d"),  iKnownFailure); //A new TVerdict

 	INFO_PRINTF2(_L("Total             :%d"),  iTotal);

 	if(iPauseAtEnd)

 		{

 		// A pause at the end has been requested

 		Pause();

 		}

 	}

 /**

  *

  * Pause testing.

  * NOTE : stubbed pending re-implementation of user input

  *

  * @xxxx

  *

  */

 void CScript::Pause()

 	{

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

 	}

 /**

  *

  * Display error on the console and invite abort.

  * NOTE : stubbed pending re-implementation of user input

  *

  * @xxxx

  *

  */

 TBool CScript::BreakOnError()

 	{

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

 	return EFalse;

 	}

 /**

  *

  * Add a test result to the accumulated totals.

  *

  * @param	"TVerdict aTestVerdict"

  *			The test verdict

  *

  * @xxxx

  *

  */

 void CScript::AddResult(TVerdict aTestVerdict)

 	{

 	// another test complete, so increment total

 	iTotal++;

 	// add in the current result

 	switch (aTestVerdict) 

 		{

 	case EPass:

 		iPass++;

 		break;

 	case EFail:

 		iFail++;

 		break;

 	case EInconclusive:

 		iInconclusive++;

 		break;

 	case ETestSuiteError:

 		iTestSuiteError++;

 		break;

 	case EAbort:

 		iAbort++;

 		break;

 	case EKnownFailure: //A new TVerdict for a known failed test

 		iKnownFailure++;

 		break;

 		}

 	// display the result

 	TPtrC verdictText = CLog::TestResultText(aTestVerdict);

 	TPtrC currentSuiteName = iParse->CurrentSuiteName();

 	TPtrC currentStepName = iParse->CurrentStepName();

 	iLog->LogResult(aTestVerdict, _L("Test Result for %S:%S is %S "), 

 		&currentSuiteName, &currentStepName, &verdictText);

 	}

 /**

  *

  * Add a test result from a subscript to the accumulated totals.

  *

  * @param	"CScript* aSubScript"

  *			The subscript

  *

  * @xxxx

  *

  */

 void CScript::AddResult(CScript* aSubScript)

 	{

 	iPass += aSubScript->iPass;

 	iFail += aSubScript->iFail;

 	iInconclusive += aSubScript->iInconclusive;

 	iTestSuiteError += aSubScript->iTestSuiteError;

 	iAbort += aSubScript->iAbort;

 	iKnownFailure += aSubScript->iKnownFailure;

 	iTotal +=aSubScript->iTotal;

 	}

 /**

  *

  * Traceable logging function for parseline.

  *

  * @param	"const TText8* aFile"

  *			Source code file name

  *

  * @param	"TInt aLine"

  *			Source code line

  *

  * @param	"TInt aSeverity"

  *			Severity level required to log

  *

  * @param	"TRefByValue<const TDesC16> aFmt"

  *			Printf-style format.

  *

  * @param	"..."

  *			Variable print parameters

  *

  * @xxxx

  *

  */

 void CScript::LogExtra(const TText8* aFile, TInt aLine, TInt aSeverity,

 		TRefByValue<const TDesC16> aFmt,...)

 	{

 	VA_LIST aList;

 	VA_START(aList, aFmt);

 	if(aSeverity)

 		{

 		if(iLog)

 			{

 			iLog->LogExtra(aFile, aLine, aSeverity, aFmt, aList);

 			}

 		}

 	VA_END(aList);

 	}