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

	}