/*

* Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

*

*/

#include "t_testaction.h"

#include "t_output.h"

#include "t_input.h"

#include "t_testactionspec.h"

#include "tScriptSetup.h"

#include "t_testhandler.h"

EXPORT_C CTestAction::~CTestAction()

	{

	delete iNameInfo;

	}

EXPORT_C void CTestAction::PerformPrerequisite(TRequestStatus& aStatus)

	{

	DoPerformPrerequisite(aStatus);

	}

EXPORT_C void CTestAction::PerformPostrequisite(TRequestStatus& aStatus)

	{

	DoPerformPostrequisite(aStatus);

	}

EXPORT_C void CTestAction::AfterOOMFailure()

	{

	}

TBool CTestAction::Finished()

	{

	return iFinished;

	}

EXPORT_C void CTestAction::ReportAction()

	{

	iOut.writeString(*iNameInfo);

	iOut.writeNewLine();

	DoReportAction();

	}

EXPORT_C void CTestAction::CheckResult(TInt aError)

{

	// DoCheckResult must update iResult 

	//iResult = (iResult && iExpectedResult) || (!iResult && !iExpectedResult);

	DoCheckResult(aError);

	if (iKnownFailure)		//	Expecting an error because of known

		iResult = ETrue;	//	defect current deferred etc

	iOut.writeString(_L("\tStatus : "));

	iOut.writeError(aError);

	iOut.writeString(_L(" ("));

	iOut.writeNum(aError);

	iOut.writeString(_L(")"));

	iOut.writeNewLine();

	iOut.writeString(_L("\tTest outcome : "));

	if (iResult)

		{

		iOut.writeString(_L("PASSED"));

		}

	else

		{

		iOut.writeString(_L("FAILED"));

		}

	iOut.writeNewLine();

	iOut.writeNewLine();

	}

EXPORT_C void CTestAction::PerformCancel()

	{

	}

EXPORT_C void CTestAction::Reset()

	{

	}

EXPORT_C CTestAction::CTestAction(CConsoleBase& aConsole,

								  Output& aOut)

: iFinished(EFalse), iKnownFailure(EFalse), iConsole(aConsole), iOut(aOut)

	{

	}

EXPORT_C void CTestAction::ConstructL(const TTestActionSpec& aTestActionSpec)

{

	iNameInfo = aTestActionSpec.iActionName.AllocL();

	TRAPD(err, iExpectedResult = Input::ParseElementBoolL(

		aTestActionSpec.iActionResult, _L8("<result>")) );

	if(err == KErrArgument)

		{

		//if there is no <result> field or it has invalid text then we assume

		//it's a "normal" test.  ie it must be true to pass.

		iExpectedResult = ETrue; 

		}

	else if(err != KErrNone)

		{

		User::Leave(err);

		}

//	If there's a known defect because of deferred defects etc, the script

//	will flag it.  We record as much here and, when result is returned, check

//	against known failure and adjust result accordingly.  This should only be

//	used for reported defects that have been deferred etc rather than as a 

//	workaround for test failures.  The failure will be reported in a separate

//	part of the log file so it's not overlooked entirely.

	_LIT8(KTrue, "ETrue");

	// _LIT8(KFalse, "EFalse");

	TInt pos = 0; 

	err = KErrNone;

	TPtrC8 knownFailure = Input::ParseElement(aTestActionSpec.iActionBody, KKnownDefectStart, KKnownDefectEnd, pos, err);	

	if (knownFailure.Compare(KTrue)==0)

		iKnownFailure = ETrue;

	else	//	Assume if it's not true it's false or not there which == false

		iKnownFailure = EFalse;

}

EXPORT_C void CTestAction::DoPerformPrerequisite(TRequestStatus& aStatus)

	{

	iActionState = EAction;

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNone);

	}

EXPORT_C void CTestAction::DoPerformPostrequisite(TRequestStatus& aStatus)

	{

	TRequestStatus* status = &aStatus;

	// pass on any error from peform action

	User::RequestComplete(status, aStatus.Int()); 

	iFinished = ETrue;

	}

EXPORT_C void CTestAction::FailTestNow(TRequestStatus& aStatus)

	{

	iActionState=EPostrequisite;

	iResult=EFalse;

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNone);

	}

EXPORT_C CTestAction::TScriptError CTestAction::ScriptError(void)

	{

	return(iScriptError);

	}

EXPORT_C void CTestAction::SetScriptError(const TScriptError &aScriptError, const TDesC& aError)

	{

	iScriptError = aScriptError;

	aScriptErrorDescription.Copy(aError); 

	};

EXPORT_C void CTestAction::ScriptError(TDes& aError)

	{

	aError.Copy(aScriptErrorDescription);

	};

void CTestAction::SetTestHandler(CTestHandler& aTestHandler)

	{

	iTestHandler = &aTestHandler;

	}

EXPORT_C CBase* CTestAction::SharedData() const

	{

	ASSERT(iTestHandler);

	return iTestHandler->SharedData();

	}

EXPORT_C void CTestAction::SetSharedData(CBase* aData)

	{

	ASSERT(iTestHandler);

	iTestHandler->SetSharedData(aData);

	}

EXPORT_C void CTestAction::ResetState()

	{

	}