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

// This module implements the collection of stadard command classes for the

// tester framework.

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

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

// Include Definition Files  

// 

//

#include "CCmdStandard.h"

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

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

//	Comment command.

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

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

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

{

CCmdRemark* self = NewLC(aCommandId, aKeyphrase);

CleanupStack::Pop();

return self; 

}

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

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

{

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

CleanupStack::PushL(self);

self->ConstructL( aCommandId, aKeyphrase );

return self;

}

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

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

{

CCmdBase::ConstructL( aCommandId, aKeyphrase );

}

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

TBool CCmdRemark::Recognize( const TDesC& aCommand  )

{

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

SetStepOver(Family()->StepOver());

// Check if is empty or begins with # character.

TPtrC cmd = TfrLex::Trim(aCommand);

//	look for empty, # or //

return ((cmd.Length() == 0) || (cmd.Match( _L("#*")) == 0) || (cmd.Match(_L("//*")) == 0 ));

}

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

TInt CCmdRemark::ProcessL( const TDesC& aCommand )

{

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

Machine()->CompleteRequest();

if (!Recognize(aCommand))

	return Error(KErrArgument, TFR_KFmtErrBadCmd, &Keyphrase());

// Do nothing.

return KErrNone;

}

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

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

//	Command:	EXIT command.

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

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

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

{

CCmdExit* self = NewLC( aCommandId, aKeyphrase );

CleanupStack::Pop();

return self; 

}

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

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

{

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

CleanupStack::PushL(self);

self->ConstructL(aCommandId, aKeyphrase);

return self;

}

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

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

{

CCmdBase::ConstructL(aCommandId, aKeyphrase);

}

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

TInt CCmdExit::ProcessL(const TDesC &aCommand)

{

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

Machine()->CompleteRequest();

TPtrC param;

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

if (error != KErrNone )

	return Error(error, TFR_KFmtErrBadCmd, &Keyphrase());

TLex parse( param );

if (!parse.Eos() && !parse.Peek().IsSpace())

	return Error( error, TFR_KFmtErrBadCmd, &Keyphrase());

// Print out param if any and stop.

param.Set( TfrLex::Peel(param));

if (param.Length() > 0) 

	Print(param);

Machine()->StopEngine();

return error;

}

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

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

//	Command:	ECHOMODE On/Off command.

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

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

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

{

CCmdEchoMode* self = NewLC( aCommandId, aKeyphrase );

CleanupStack::Pop();

return self; 

}

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

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

{

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

CleanupStack::PushL( self );

self->ConstructL( aCommandId, aKeyphrase );

return self;

}

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

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

{

CCmdBase::ConstructL( aCommandId, aKeyphrase );

}

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

TInt CCmdEchoMode::ProcessL(const TDesC& aCommand)

{

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

Machine()->CompleteRequest();

TPtrC param;

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

if (error != KErrNone)

	return Error(error, TFR_KFmtErrBadCmd, &Keyphrase());

TLex parse( param );

if (!parse.Peek().IsSpace())

	return Error(error, TFR_KFmtErrBadCmd, &Keyphrase());

// Param shall be On or Off?

param.Set(TfrLex::TrimAndPeel(param));

TBool value = (param.CompareF(TFR_KTxtTermOn) == 0);

if ( !value && param.CompareF(TFR_KTxtTermOff) != 0)

	return Error(KErrArgument, TFR_KFmtErrBadCmd, &Keyphrase());

// Set Echo Mode On/Off.

Machine()->SetEchoMode(value);

return error;

}

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

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

//	Command:	CHECKMODE on/off command.

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

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

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

{

CCmdCheckMode* self = NewLC( aCommandId, aKeyphrase );

CleanupStack::Pop();

return self; 

}

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

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

{

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

CleanupStack::PushL( self );

self->ConstructL( aCommandId, aKeyphrase );

return self;

}

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

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

{

CCmdBase::ConstructL( aCommandId, aKeyphrase );

}

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

TInt CCmdCheckMode::ProcessL( const TDesC& aCommand )

{

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

Machine()->CompleteRequest();

TPtrC param;

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

if ( error != KErrNone )

	return Error( error, TFR_KFmtErrBadCmd, &Keyphrase() );

TLex parse( param );

if ( !parse.Peek().IsSpace() )

	return Error( error, TFR_KFmtErrBadCmd, &Keyphrase() );

// Param shall On or Off?

param.Set( TfrLex::TrimAndPeel( param ) );

TBool value = (param.CompareF(TFR_KTxtTermOn) == 0);

if ( !value && param.CompareF(TFR_KTxtTermOff) != 0 )

	return Error( KErrArgument, TFR_KFmtErrBadCmd, &Keyphrase() );

// Set Check Mode (ParseOnly) On/Off.

Family()->SetSwitch(CCmdFamily::EParseOnly, value);

return error;

}

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

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

//	Command:	PRINT command.

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

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

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

{

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

CleanupStack::Pop();

return self; 

}

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

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

{

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

CleanupStack::PushL(self);

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

return self;

}

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

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

{

CCmdBase::ConstructL(aCommandId, aKeyphrase, aHelpPhrase);

//	set the dummy echo mode 

iCurEchoMode = EFalse;

}

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

//	look for PRINT* but note that Match is casesensitive and hence use temp TBuf value to check

//	and note that the command string might be quite long (and we're only interested in the 

//	first left bit!!

TBool CCmdPrint::Recognize(const TDesC& aCommand)

{

TBuf<16> iCmd = aCommand.Left(5);

iCmd.UpperCase();

TInt iResult = iCmd.Match(THA_TxtCmdPrint);

if (iResult == KErrNotFound)	//	NF(-1) otherwise >=0 here means position of string in host

	return EFalse;

return ETrue;			//	accept it for now!

}

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

TInt CCmdPrint::ProcessL(const TDesC& aCommand)

{

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

Machine()->CompleteRequest();

TPtrC param;

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

if (error != KErrNone)

	return Error(error, TFR_KFmtErrBadCmd, &Keyphrase());

TLex parse(param);

if ( !parse.Eos() && !parse.Peek().IsSpace() )

	return Error(error, TFR_KFmtErrBadCmd, &Keyphrase());

// ParseOnly => not executed.

if (Family()->Switch(CCmdFamily::EParseOnly))

	return error;

iCurEchoMode = Machine()->EchoMode();

Machine()->SetEchoMode(EFalse);

// Print out the param text.

param.Set(TfrLex::TrimAndPeel(param));

//Print(param, EFalse);

Print(param, ETrue);

//Print(param.Mid(6), EFalse);

//	reset the echo mode to that of before this command!

Machine()->SetEchoMode(iCurEchoMode);

return error;

}

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

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

//	Command:	PAUSE command.

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

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

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

{

CCmdPause* self = NewLC( aCommandId, aKeyphrase );

CleanupStack::Pop();

return self; 

}

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

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

{

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

CleanupStack::PushL(self);

self->ConstructL(aCommandId, aKeyphrase);

return self;

}

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

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

{

CCmdBase::ConstructL(aCommandId, aKeyphrase);

}

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

TInt CCmdPause::ProcessL(const TDesC& aCommand)

{

TPtrC param;

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

if (error != KErrNone)

	{

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

	Machine()->CompleteRequest();

	return Error(error, TFR_KFmtErrBadCmd, &Keyphrase());

	}

TLex parse( param );

if (!parse.Eos() && !parse.Peek().IsSpace())

	{

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

	Machine()->CompleteRequest();

	return Error(error, TFR_KFmtErrBadCmd, &Keyphrase());

	}

// ParseOnly => not executed.

if (Family()->Switch(CCmdFamily::EParseOnly))

	{

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

	Machine()->CompleteRequest();

	return error;

	}

// Ask any key, prompt is either param or a default.

param.Set( TfrLex::TrimAndPeel(param));

if (param.Length() == 0) 

	param.Set(TFR_KTxtMsgPressAnyKey);

Machine()->Pause(param);

return error;

}

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

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

//	Command:	HOLD command.

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

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

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

{

CCmdHold* self = NewLC( aCommandId, aKeyphrase );

CleanupStack::Pop();

return self; 

}

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

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

{

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

CleanupStack::PushL( self );

self->ConstructL( aCommandId, aKeyphrase );

return self;

}

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

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

{

CCmdBase::ConstructL ( aCommandId, aKeyphrase );

}

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

TInt CCmdHold::ProcessL( const TDesC& aCommand )

{

TPtrC param;

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

if ( error != KErrNone )

	{

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

	Machine()->CompleteRequest();

	return Error(error, TFR_KFmtErrBadCmd, &Keyphrase() );

	}

TLex parse( param );

if ( !parse.Eos() && !parse.Peek().IsSpace() )

	{

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

	Machine()->CompleteRequest();

	return Error( error, TFR_KFmtErrBadCmd, &Keyphrase() );

	}

// Param must be integer. If no param then default is 1 second.

param.Set( TfrLex::TrimAndPeel(param) );

parse = param;

TInt n;

if ( parse.Eos() )

	n = 1;

else if (parse.Val(n) != KErrNone || !parse.Eos())

	{

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

	Machine()->CompleteRequest();

	return Error(error, TFR_KFmtErrBadCmd, &Keyphrase());

	}

// ParseOnly => not executed!

if (Family()->Switch(CCmdFamily::EParseOnly) )

	{

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

	Machine()->CompleteRequest();

	return error;

	}

// Hold processing for n seconds.

TTimeIntervalMicroSeconds32 microseconds;

microseconds = 1000000 * n;

Machine()->Hold(microseconds);

return error;

}

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

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

//	Command:	SETPROMPT command.

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

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

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

{

CCmdSetPrompt* self = NewLC( aCommandId, aKeyphrase );

CleanupStack::Pop();

return self; 

}

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

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

{

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

CleanupStack::PushL( self );

self->ConstructL( aCommandId, aKeyphrase );

return self;

}

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

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

{

CCmdBase::ConstructL ( aCommandId, aKeyphrase );

}

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

TInt CCmdSetPrompt::ProcessL( const TDesC& aCommand )

{

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

Machine()->CompleteRequest();

TPtrC param;

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

if ( error != KErrNone )

	return Error( error, TFR_KFmtErrBadCmd, &Keyphrase() );

TLex parse( param );