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

// $Header$

// The CTEngine is the class that manages the test infrastructure

// It knows how to process scripts and where to find command knowledge

// The plan is:

// Process console command line or command line supplied script

// read in each line (or command) and process that (if appropriate)

// Include Files  

// 

//

#include <e32std.h>

#include <s32file.h>

#include <f32file.h>

#include <e32hal.h>

#include <fbs.h>

//-----------------------------------------------------------------------------

const TInt KMaxLogEntrySize = 512;

const TInt KMaxUserEntrySize = 128;

//-----------------------------------------------------------------------------

//	result define names

_LIT(KLastResultCode, "$LastResult$");

_LIT(KLastErrorCode, "$LastError$");

//-----------------------------------------------------------------------------

#include "TEngine.h"

//-----------------------------------------------------------------------------

// This is used by the CallCmdFile, CloseCmdFile and CloseCmdFiles member

// functions to alter the command file context. This function defines the

// call argument tags %0%, %1%, ... %k% to those of the present cmd file.

// If there is no command file, then the argument tags (all) are removed.

#if !defined(TEMPLATED_CATALOGUE)

LOCAL_C void SetContextL(CCatalogue *aCatalog, CCmdFile* aCmdFile )

#else

template <class T>

LOCAL_C void SetContextL(CCatalogue<T> *aCatalog, CCmdFile* aCmdFile )

#endif

{

if ( aCmdFile == NULL )

	{

	// No command file = console context: parameter markers are not

	// recognised at all i.e. remove them all.

	TBuf<6> buf;

	TInt i;

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

		{

		buf.Format( _L("%%%d%%"), i );

		aCatalog->Delete(buf);

		}

	}

else

	{

	// Command file context: parameters markers will be mapped to the

	// file name, to the call arguments and to "".

	TBuf<6> buf;

	TPtrC   arg;

	TInt    i;

	TInt		iArgs = aCmdFile->Argc();

	for ( i = 0; ( (i < TFR_MAX_CALL_ARGUMENTS) && (i < iArgs) ); ++i )

		{

		buf.Format(_L("%%%d%%"), i);

		arg.Set(aCmdFile->Argv(i));

		aCatalog->Delete(buf);

		aCatalog->AddL(buf,arg);

		}

	for ( ; i < 10; ++i )

		{

		buf.Format(_L("%%%d%%"), i);

		aCatalog->Delete(buf);

		aCatalog->AddL(buf, _L(""));

		}

	}

}

//-----------------------------------------------------------------------------

//    Overflow handler.

void TTestMachineOverflow::Overflow( TDes16& aDes)

{

_LIT(KErrOverflowMsg, "...");

if( aDes.MaxLength() >= KErrOverflowMsg().Length() + aDes.Length() )

	aDes.Append(KErrOverflowMsg);

}

//-----------------------------------------------------------------------------

//	NewL for Console interface

CTEngine* CTEngine::NewL( CConsoleBase* aConsole )

{

CTEngine* self = NewLC(aConsole);

CleanupStack::Pop(self);

return self; 

}

//-----------------------------------------------------------------------------

//	NewLC for Console Interface

CTEngine* CTEngine::NewLC( CConsoleBase* aConsole )

{

CTEngine* self = new (ELeave) CTEngine(aConsole);

CleanupStack::PushL(self);

self->ConstructL();

return self;

}

//-----------------------------------------------------------------------------

//	Destructor

CTEngine::~CTEngine()

{

Cancel();

	iTimer.Close();

	iFileServer.Close();

	delete iCmdFile;

	delete iLogFile;

	delete iConsoleReader;

	delete iDomain;

	delete iDefines;

	delete iIFPile;

	delete iLogPile;

 	delete iCmdPile;

}

//-----------------------------------------------------------------------------

void CTEngine::ConstructL()

{

iConsoleEnabled = ( iConsole != NULL );    

iCmdPile = CPile<CCmdFile>::NewL();

iLogPile = CPile<CLogFile>::NewL();

iIFPile = CPile<CIFControl>::NewL();

#if !defined(TEMPLATED_CATALOGUE)

iDefines = CCatalogue::NewL();

#else

iDefines = CCatalogue<CLabeledText>::NewL();

#endif

//	domain specific catalogue of items. This provides

//	a mechanism by which we can disassociate the framework

//	from the domain specific commands/data requirements

iDomain = CObjCatalogue::NewL();

iConsoleReader = CConsoleReader::NewL(*iConsole);

TInt r = iTimer.CreateLocal();

if (r!=KErrNone)

	User::Leave(r);

//	Provide access to the fileserver

User::LeaveIfError(iFileServer.Connect());

//	This is normally true (to enable replication of printed

//	output to log (if enabled)

iLogActivity = ETrue;

//	show the unprocessed command lines on screen and log

SetShowCmdLine(ETrue);

}

//-----------------------------------------------------------------------------

CTEngine::CTEngine(CConsoleBase* aConsole)

	: 

	CActive(EPriorityStandard), 

	iStopped(ETrue), 

	iEchoMode(ETrue),

	iConsole(aConsole)

{

iConsoleEnabled = ( iConsole != NULL );    

iCmdPath.Zero();

iLogPath.Zero();

iCmdline.Zero();

iCommand.Zero();

iPrompt.Copy(THA_CommandPrompt);

CActiveScheduler::Add(this);

}

//-----------------------------------------------------------------------------

void CTEngine::SetCmdFamily(CCmdFamily* aCmdFamily)

{

iCmdFamily = aCmdFamily;

if (aCmdFamily != NULL) 

	aCmdFamily->SetMachine( this );

}

//-----------------------------------------------------------------------------

TBool CTEngine::ConsoleEnabled( )

{

return ( iConsoleEnabled );

}

//-----------------------------------------------------------------------------

void CTEngine::DisableConsole()

{

iConsoleEnabled = EFalse;

}

//-----------------------------------------------------------------------------

void CTEngine::EnableConsole()

{

iConsoleEnabled = (iConsole != NULL);

}

//-----------------------------------------------------------------------------

CConsoleBase* CTEngine::Console() const

{

return (iConsole);

}

//-----------------------------------------------------------------------------

void CTEngine::Write(const TDesC& aText)

{    

if (ConsoleEnabled()) 

	iConsole->Write(aText);

}

//-----------------------------------------------------------------------------

void CTEngine::Writeln( const TDesC& aText )

{

if (ConsoleEnabled())

	{

	iConsole->Write(aText);

	iConsole->Write(TFR_KTxtNewLine);

	}

}

//-----------------------------------------------------------------------------

void CTEngine::Writeln()

{    

if (ConsoleEnabled()) 

	iConsole->Write(TFR_KTxtNewLine);

}

//-----------------------------------------------------------------------------

void CTEngine::Printf( TRefByValue<const TDesC> aFmt, ... )

{    

VA_LIST list;

VA_START( list, aFmt );

Printf( aFmt, list ); 

}

//-----------------------------------------------------------------------------

void CTEngine::Printf( TRefByValue<const TDesC> aFmt, VA_LIST& aList )

{

if ( ConsoleEnabled() )

	{

	iPrintBuf.Zero();

	TRAPD(error,iPrintBuf.AppendFormatList( aFmt, aList, &iOverflow));

	if ( error == KErrNone )

		{

		iConsole->Write( iPrintBuf );

		}

	else

		{

		iConsole->Write( TFR_KTxtErrPrintOflo );

		iConsole->Write( TFR_KTxtNewLine );

		}

	}

}

//-----------------------------------------------------------------------------

void CTEngine::Printfln( TRefByValue<const TDesC> aFmt, ... )

{    

VA_LIST list;

VA_START( list, aFmt );

Printfln( aFmt, list );

}

//-----------------------------------------------------------------------------

void CTEngine::Printfln( TRefByValue<const TDesC> aFmt, VA_LIST& aList )

{

if ( ConsoleEnabled( ) )

	{

	iPrintBuf.Zero();

	TInt error = KErrNone;

	TRAP(error,iPrintBuf.AppendFormatList( aFmt, aList, &iOverflow));

	if ( error != KErrNone ) 

		return;

	TRAP(error,iPrintBuf.AppendFormat( _L("%S"), &iOverflow, &TFR_KTxtNewLine ));

	if (error == KErrNone )

		{

		iConsole->Write( iPrintBuf );

		}

	else

		{

		iConsole->Write( TFR_KTxtErrPrintOflo );

		iConsole->Write( TFR_KTxtNewLine );

		}

	}

}

//-----------------------------------------------------------------------------

void CTEngine::Pause(const TDesC& aPrompt)

{

if (ConsoleEnabled())

	{

	iCmdline.Zero();

	iConsole->Write(aPrompt);

	if (!IsActive())

		SetActive();

	iConsoleReader->ReadChar(iCmdline, iStatus);

	}

else

	CompleteRequest();

}

//-----------------------------------------------------------------------------

void CTEngine::Hold(TTimeIntervalMicroSeconds32 aInterval)

{

iTimer.After(iStatus, aInterval);

SetActive();

}

//-----------------------------------------------------------------------------

TInt CTEngine::SetCmdPath( const TDesC& aPath )

{

if (aPath.Length() == 0)

	{

	Printf(_L("Path is set to: %S\r\n"), &iCmdPath);

	return KErrNone;

	}

if (iParse.SetNoWild( aPath, NULL, NULL ) != KErrNone)

	return KErrArgument;

if (!iParse.PathPresent() || iParse.NameOrExtPresent())

	return KErrArgument;

//	set it

iCmdPath.Copy(aPath);

//	echo it

Printf(_L("Path is set to: %S\r\n"), &iCmdPath);

return KErrNone;

}

//-----------------------------------------------------------------------------

TPtrC CTEngine::CmdPath() const

{

TPtrC path(iCmdPath);

return path;

}

//-----------------------------------------------------------------------------

TPtrC CTEngine::FileName() const

{

TPtrC fileName(iFileName);

return fileName;

}

//-----------------------------------------------------------------------------

//	parameterless version

TInt CTEngine::CallCmdFile(const TDesC& aFile)

{

return CallCmdFile(aFile, _L(""));

}

//-----------------------------------------------------------------------------

TInt CTEngine::CallCmdFile(const TDesC &aFile, const TDesC &aArgs)

{

// Make CCmdFile object.

CCmdFile *file = NULL;

TRAPD(error, file = CCmdFile::NewL());

if ( error != KErrNone ) 

	return error;

error = file->Open(iCmdPath, aFile);

if ( error != KErrNone )

	{

	delete file;

	//	print file x not found echo it

	Printf(_L("Error: file [%S] not found\r\n"), &aFile);

	Printf(_L("       Check file path <%S>\r\n"), &iCmdPath);

	return error;

	}

// Save file name and arguments.

TRAP(error, file->AddArgsL(aFile));

if (error == KErrNone) 

	TRAP(error, file->AddArgsL(aArgs));

if ( error != KErrNone )

	{

	delete file;

	return error;

	}

// Check that not too many call arguments.

if ( file->Argc() > (TFR_MAX_CALL_ARGUMENTS + 1))

	{

	delete file;

	return error = KErrArgument;

	}

// Push present command file to cmdfile pile.

TRAP(error, iCmdPile->PushL( iCmdFile ));

if ( error != KErrNone )

	{

	delete file;

	return error;

	}

// Switch context to the called command file.

iCmdFile = file;

file = NULL;

TRAP(error, SetContextL(iDefines, iCmdFile));

return error;

}

//-----------------------------------------------------------------------------

CCmdFile* CTEngine::CmdFile()

{

return iCmdFile;

}

//-----------------------------------------------------------------------------

TInt CTEngine::CloseCmdFile()

{

// Get rid of the present command file (NULL iCmdFile is Ok).

delete iCmdFile;

iCmdFile = NULL;

// Pop the previous one from the pile (returns NULL if none).

iCmdFile = iCmdPile->Pop();

// Switch context to that file (NULL iCmdFile does no harm).

TRAPD(error,SetContextL(iDefines,iCmdFile));

return error;

}

//-----------------------------------------------------------------------------

void CTEngine::CloseCmdFiles()

{

// Pop and delete all previous command files from the file pile.

iCmdPile->Empty();

// Get rid of the present file as well (NULL iCmdFile is Ok).

delete iCmdFile;

iCmdFile = NULL;

// Switch context to "no command file" (since iCmdFile = NULL).

TRAP_IGNORE(SetContextL(iDefines,iCmdFile)); // doesn't LEAVE, see yourself

}

//-----------------------------------------------------------------------------

TInt CTEngine::SetLogPath( const TDesC& aPath )

{

if (aPath.Length() == 0)

	{

	iLogPath.Zero();

	return KErrNone;

	}

if (iParse.SetNoWild( aPath, NULL, NULL ) != KErrNone)

	return KErrArgument;

if (!iParse.PathPresent() || iParse.NameOrExtPresent())

	return KErrArgument;

TInt error;

RFs fs;

if (error = fs.Connect(), error == KErrNone)

	{

	error = fs.MkDirAll( iParse.DriveAndPath());

	if (error == KErrAlreadyExists) 

		error = KErrNone;

	fs.Close();