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

// rev:	mjdavey, symbian@mjdss.com, July 2002

// for:	Typhoon (7.0s) & JetStream (8.0)

// Include Module Definitions

// 

//

#include "CCmdBase.h"

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

// format for output of data/time values

//_LIT(KDateFormat,"%D%M%Y%/0%1%/1%2%/2%3%/3 %:0%H%:1%T%:2%S.%C%:3");

_LIT(KDateFormat,"%D%M%Y%/0%1%/1%2%/2%3%/3 %:0%H%:1%T%:2%S");

const TInt K_OUTOFBOUNDS_YEAR = 2499;

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

CCmdBase *CCmdBase::NewL(TInt aCommandId, const TDesC& aKeyphrase)

{

CCmdBase *self = NewLC(aCommandId, aKeyphrase);

CleanupStack::Pop();

return self; 

}

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

CCmdBase *CCmdBase::NewLC(TInt aCommandId, const TDesC& aKeyphrase)

{

CCmdBase *self = new (ELeave) CCmdBase();

CleanupStack::PushL( self );

self->ConstructL(aCommandId, aKeyphrase);

return self;

}

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

CCmdBase *CCmdBase::NewL(TInt aCommandId, const TDesC& aKeyphrase, const TDesC& aHelpPhrase)

{

CCmdBase *self = NewLC(aCommandId, aKeyphrase, aHelpPhrase);

CleanupStack::Pop();

return self; 

}

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

CCmdBase* CCmdBase::NewLC(TInt aCommandId, const TDesC& aKeyphrase, const TDesC& aHelpPhrase)

{

CCmdBase* self = new (ELeave) CCmdBase();

CleanupStack::PushL(self);

self->ConstructL(aCommandId, aKeyphrase, aHelpPhrase);

return self;

}

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

void CCmdBase::ConstructL( TInt aCommandId, const TDesC& aKeyphrase )

{

iFamily = NULL;

iCommandId = aCommandId;

iKeyphrase.Set(aKeyphrase);

iHelpText.Set(NULL, 0);

iFlags = 0x00000000;

SetFlag( EDoLog , ETrue  );

iStepOver = EFalse;

}

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

void CCmdBase::ConstructL( TInt aCommandId, const TDesC& aKeyphrase, const TDesC& aHelpPhrase )

{

iFamily = NULL;

iCommandId = aCommandId;

iKeyphrase.Set(aKeyphrase);

iHelpText.Set(aHelpPhrase);

iFlags = 0x00000000;

SetFlag(EDoLog, ETrue);

iStepOver = EFalse;

}

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

CCmdBase::~CCmdBase()

{

}

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

CCmdBase::CCmdBase()

	: 

	CBase()

{

}

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

TInt CCmdBase::CommandId()

{

return iCommandId;

}

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

const TDesC &CCmdBase::Keyphrase()

{

return iKeyphrase;

}

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

void CCmdBase::SetFamily(CCmdFamily* aCmdFamily)

{

iFamily = aCmdFamily;

}

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

CCmdFamily* CCmdBase::Family( )

{

return iFamily;

}

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

void CCmdBase::SetHelpText( const TDesC& aHelpText )

{

iHelpText.Set(aHelpText);

}

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

const TDesC& CCmdBase::HelpText()

{

return iHelpText;

}

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

void CCmdBase::SetFlag( TInt aFlag, TBool aBoolean )

{

if ( aFlag < 1 || aFlag > 32 ) 

	return;

TUint32 mask = ( 0x00000001<<(aFlag-1) );

iFlags = (aBoolean) ? ( iFlags | mask ) : ( iFlags & (~mask) );

}

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

TBool CCmdBase::Flag( TInt aFlag )

{

if ( aFlag < 1 || aFlag > 32 ) 

	return EFalse;

TUint32 mask = ( 0x00000001<<(aFlag-1) );

return ( (iFlags & mask) != 0x00000000 );

}

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

void CCmdBase::SetStepOver( TBool aBoolean )

{

iStepOver = aBoolean;

}

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

TBool CCmdBase::StepOver( )

{

return iStepOver;

}

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

//

//  CCmdBase::ParamsL

//

//  Get command parameters = the remainder after the Keyword Phrase part in

//    command string. Leaves ((KErrArgument) if can not recogize the command.

//    This function accepts the Keywork Phrase if the non-space characters in

//    it match to those which are found from the beginning of command string.

//    Spaces (white space characters) are fully ignored in here i.e. you can

//    have spaces where you like and how may of then as you like; they simply

//    do not matter. The case does not matter either (folded comparison).

//

//    The next character after the Keyword Phrase must not be alphabetic nor

//    a digit. The end-of-string will do fine.

//

//    Return Values:  TPtrC = params (or Leaves)

//

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

TPtrC CCmdBase::ParamsL( const TDesC& aCommand )

{

// The actual beef is in the TLex version, see below.

TLex command( aCommand );

return ParamsL( command );

}

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

TPtrC CCmdBase::ParamsL( TLex aCommand )

{

// TLex for Keyphrase

TLex phrase( iKeyphrase );

// Mark start point

TLexMark mark;

aCommand.Mark( mark );

// First char in phrase

phrase.SkipSpace();

// Check whole phrase...

while ( !phrase.Eos() )

	{

	// Check the next true non-space character in command. The

	// end-of-command is not checked here. We rely on that the

	// Get() returns 0 if that is the case (and the 0 does not

	// match to the true character got from the phrase).

	aCommand.SkipSpace();

	if ( User::Fold(phrase.Get()) != User::Fold(aCommand.Get()) )

		{

		// No match: unget to the start point and "L E A V E".

		aCommand.UnGetToMark( mark );

		User::Leave( KErrArgument  );

		}

	// Next true non-space character in phrase.

	phrase.SkipSpace();

	}

// Apparently the keyword phrase was there: check that the next

// character is not alphabetic nor a decimal digit.

if ( !aCommand.Eos() && aCommand.Peek().IsAlphaDigit() )

	{

	// What a pitty. We were almost there but not quite. Unget

	// to the start point and "L E A V E".

	aCommand.UnGetToMark( mark );

	User::Leave( KErrArgument  );

	}

// Did it: return the remainder, which hopefully is just what

// we aimed at.

return aCommand.Remainder();

}

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

//

//    CCmdBase::Recognize

//

//    Recognize command string. Resets the StepOver flag from the command

//		family. If the family is not defined, then StepOver flag remains as

//    happens to be.

//

//    Return Values:  ETrue/EFalse

//

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

TBool CCmdBase::Recognize(const TDesC&  aCommand)

{

// Obey the command family's step over mode..

if (iFamily != NULL) 

	SetStepOver(iFamily->StepOver());

// The beef is in the ParamsL() function.

TPtrC params;

TRAPD(error, params.Set(ParamsL(aCommand)));

return (error == KErrNone);

}

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

TBool CCmdBase::Recognize(TLex aCommand)

{

// Reset the StepOver flag to what's in command family.

if (iFamily != NULL) 

	SetStepOver(iFamily->StepOver());

// The beef is in the ParamsL() function.

TPtrC params;

TRAPD(error, params.Set(ParamsL(aCommand)));

return (error == KErrNone);

}

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

TInt CCmdBase::ProcessL( const TDesC& aCommand )

{

// Complete the test machine - will then get the next cmd

Machine()->CompleteRequest();

TPtrC params;

TRAPD( error, params.Set( ParamsL( aCommand )) );

return error;

}

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

//	Complete process without doing anything

TInt CCmdBase::ProcessStepOverL()

{

Machine()->CompleteRequest();

return KErrNone;

}

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

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

{

VA_LIST list;

VA_START(list, aFmt);

Machine()->MsgPrintfln( aFmt, list );

}

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

void CCmdBase::Print(const TDesC& aText, const TBool &aNewLine)

{

if (aNewLine)

	Machine()->MsgWriteln(aText);

else

	Machine()->MsgWrite(aText);

}

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

TInt CCmdBase::Error( TInt aError, TRefByValue<const TDesC> aFmt, ... )

{

VA_LIST list;

VA_START(list, aFmt);

Machine()->MsgPrintfln(aFmt, list);

return aError;

}   

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

CTEngine* CCmdBase::Machine()

{

return iFamily->Machine();

}

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

CConsoleBase* CCmdBase::Console()

{

return iFamily->Machine()->Console();

}

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

//	provide general log facility (access standard Machine features)

void CCmdBase::Log(TRefByValue<const TDesC> aFmt, ... )

{

VA_LIST list;

VA_START(list, aFmt);

Machine()->MsgPrintfln(aFmt, list);

//Printf(aFmt, list);

//if (Machine()->Log())

//	Machine()->LogPrintf(aFmt, list);

}

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

//	quick default to known 'invalid' date!

void CCmdBase::WriteDateStamp()

{

TDateTime myTempDate(K_OUTOFBOUNDS_YEAR, EJanuary, 0,0,0,0,0);

WriteDateStamp(myTempDate);

}

//TDateTime myTempDate;

//myTempDate.SetMonth(0);

//myTempDate.SetYear(K_OUTOFBOUNDS_YEAR);

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

//	displays the given date or current date depending on parameter

//buf.Format(_L8 ("%04d/%02d/%02d %02d.%02d:%02d:%06d "),dateTime.Year(),dateTime.Month()+1, dateTime.Day()+1,dateTime.Hour(),dateTime.Minute(),dateTime.Second(),dateTime.MicroSecond());

//buf.AppendFormat(_L8("%S\015\012"),&aText);

void CCmdBase::WriteDateStamp(const TDateTime &aDate)

{

TDateTime date;

TTime now;

TBool iEOL = (aDate.Year() == K_OUTOFBOUNDS_YEAR);

if (iEOL)

	{

	now.HomeTime();

	date = now.DateTime();

	}

else

	date = aDate;

TTime t(date);

TBuf<128> dateTimeString;

TRAPD(err, t.FormatL(dateTimeString, KDateFormat));

if (err == KErrNone)

	{

	if (iEOL)

		Machine()->MsgPrintf(_L("[%S] "), &dateTimeString);

	else

		Log(_L("[%S]\r\n"), &dateTimeString);

	}

} 

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

//	update the completion code and set the $ResultCode$ define in Machine()

void CCmdBase::SetCompletionCode(TInt aCode)

{

iCompletionCode = aCode;

Machine()->SetResultDefine(aCode);

}

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

//  End of File  

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