/*

* Copyright (c) 2005-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 contains CTestStep which is the base class for all test steps.

*

*/

/**

 @file TestExecuteStepBase.h

*/

#if (!defined __TESTEXECUTE_STEP_BASE_H__)

#define __TESTEXECUTE_STEP_BASE_H__

#include <e32base.h>

#include <f32file.h>

#include <iniparser.h>

#include <test/testexecutelogger.h>

#include <test/testexecuteclient.h>

#include <test/tefshareddata.h>

#include <test/testshareddata.h>

class CTestStep : public CBase

/**

@publishedPartner

@test

*/

	{

public:

	// Destructor

	IMPORT_C virtual ~CTestStep();

	// Get methods to read values from the ini file

	IMPORT_C TBool GetBoolFromConfig(const TDesC& aSectName,const TDesC& aKeyName,TBool& aResult);

	IMPORT_C TBool GetIntFromConfig(const TDesC& aSectName, const TDesC& aKeyName, TInt& aResult);

	IMPORT_C TBool GetStringFromConfig(const TDesC& aSectName, const TDesC& aKeyName, TPtrC& aResult);

	// Set a user-friendly test step name referred for a test step object from the script file

	IMPORT_C void SetTestStepName(const TDesC& aStepName);

	IMPORT_C TBool GetHexFromConfig(const TDesC& aSectName, const TDesC& aKeyName, TInt& aResult);

	// Set the actual test step error obtained to execution of test step to compare the expected error with the actual

	IMPORT_C void SetTestStepError(const TInt& aErrorCode);

	// Write methods to write values into ini file

	IMPORT_C TBool WriteIntToConfig(const TDesC& aSectName, const TDesC& aKeyName, const TInt& aValue);

	IMPORT_C TBool WriteStringToConfig(const TDesC& aSectName, const TDesC& aKeyName, const TPtrC& aValue);

	IMPORT_C TBool WriteBoolToConfig(const TDesC& aSectName, const TDesC& aKeyName, const TBool& aValue);

	IMPORT_C TBool WriteHexToConfig(const TDesC& aSectName, const TDesC& aKeyName, const TInt& aValue);

	//Updates the data to the shared data name passed either in Copy Mode/Append Mode

	IMPORT_C void WriteSharedDataL(const TDesC& aShareName, TDesC& aSharedDataVal, TModeCopy aModeCopy = ESetText);

	//Reads the data from the specified shared data object

	IMPORT_C void ReadSharedDataL(const TDesC& aShareName, TDes& aSharedDataVal);

	// Initialise the test step during cnstruction

	void InitialiseL(const TDesC& aStepArgs, const TDesC& aServerName, TBool& aSharedDataMode);

	// Initialises logger instance for the test step

	void SetLoggerL();

	// Closes the logger instance for the test step

	void CloseLogger();

	// Returns the section name specified in the script file for the current test step execution

	inline TDes& ConfigSection() {return iSection;};

	// Set the result of test step execution  to one of the TVerdict enum codes

	inline void SetTestStepResult(TVerdict aVerdict) {iTestStepResult = aVerdict;};

	// Returns the test step result at any point during execution of test step

	inline TVerdict TestStepResult() const {return iTestStepResult;};

	// Logger interface used for constructing result strings to be fed for the logger instance

	inline CTestExecuteLogger& Logger() {return *iLogger;};

	// Returns the user-friendly test step name

	inline const TDesC& TestStepName() const {return iTestStepName;};

	// Returns any error code set during the test step execution

	inline const TInt& TestStepError() const {return iTestStepError;};

	// Returns the boolean true of !OOM option is set from the script file, false otherwise

	inline TBool& ShouldRunOOMTest() {return iOOMRequestStatus;};

	// Returns true if test server is loaded using -SharedData mode from the script file

	inline TBool& IsSharedDataMode() {return iSharedDataMode;};

	// Returns the loop index of the current loop if the test runs within a START_REPEAT/EN_REPEAT block

	// Returns -1 if test is not within a loop

	inline TInt GetLoopIndex() {return iLoopIndex;};

	// Returns the setup value set using !Setup TEF parameter within the script file

	// Returns a value 0 if !Setup TEF parameter is not used

	inline TInt GetSetupState() {return iSetupParamValue;};

	// Returns the drive name from which the current script file is executed

	inline TDriveName ScriptDriveName() { return iScriptDriveName;};

	// Returns reference to the iEnableIniAccessLog bool which can be used by tests to switch off ini access logging on the run

	inline TBool& IniAccessLog() { return iEnableIniAccessLog; };

	// Returns the default system drive letter provided by call to RFs::GetSystemDrive()

	inline TDriveName GetSystemDrive() { return iSystemDriveForTest; };

	// Test Step virtuals - Test Implementation methods

	IMPORT_C virtual enum TVerdict	doTestStepL() = 0;

	IMPORT_C virtual enum TVerdict	doTestStepPreambleL();

	IMPORT_C virtual enum TVerdict	doTestStepPostambleL();

	// Setting simulated OOM and testing whether the code under test reached the simulated failure

	IMPORT_C virtual void SetHeapFailNext(TInt aFailureIndex);

	IMPORT_C virtual void ResetHeapFailNext();

	IMPORT_C virtual TBool CheckForHeapFailNext();

	// LEGACY methods

	IMPORT_C void testBooleanTrue(TBool aCondition, const TText8* aFile, TInt aLine);

	IMPORT_C void testBooleanTrue(TBool aCondition, const TText8* aFile, TInt aLine, TBool IgnoreStepResult);

	IMPORT_C void testBooleanTrueL(TBool aCondition, const TText8* aFile, TInt aLine);

	IMPORT_C void testBooleanTrueL(TBool aCondition, const TText8* aFile, TInt aLine, TBool IgnoreStepResult);

	IMPORT_C void testBooleanTrueWithErrorCode(TBool aCondition, TInt aErrorCode, const TText8* aFile, TInt aLine );

	IMPORT_C void testBooleanTrueWithErrorCode(TBool aCondition, TInt aErrorCode, const TText8* aFile, TInt aLine, TBool IgnoreStepResult);

	IMPORT_C void testBooleanTrueWithErrorCodeL(TBool aCondition, TInt aErrorCode,

													const TText8* aFile, TInt aLine );

	IMPORT_C void testBooleanTrueWithErrorCodeL(TBool aCondition, TInt aErrorCode,

													const TText8* aFile, TInt aLine, TBool IgnoreStepResult );

	IMPORT_C void TestCheckPointCompareL(TInt aVal, TInt aExpectedVal, const TDesC& aText, const TText8* aFile, TInt aLine);

	// Retrieve the server name

	IMPORT_C const TDesC& GetServerName() const;

	// Retrieve the test case name/id

	IMPORT_C TBool TestCaseName(TDes& aTestCaseName);

protected:

	IMPORT_C CTestStep();

public:

	IMPORT_C TBool GetIntFromConfig(const TDesC& aSectName, const TDesC& aKeyName, TInt64& aResult);

	IMPORT_C TBool WriteIntToConfig(const TDesC& aSectName, const TDesC& aKeyName, const TInt64& aValue);

private:

	void LoadConfigFileL(const TDesC& aFilePath);

private:

	CTestExecuteLogger*					iLogger;

	TVerdict							iTestStepResult;

	TBuf<KMaxTestExecuteNameLength>		iSection;

	CIniData*							iConfigData;

	TBuf<KMaxTestStepNameLength>	    iTestStepName;		// Name of the test step

	TBuf<KMaxTestExecuteNameLength>		iServerName;		// Name of the test server

	TInt								iTestStepError;		// Expected Test step Error

	HBufC*								iIniFileName;		// Name of the inifile to be use for logging.

	TBool								iOOMRequestStatus;	// Status of OOM request from user

	TBool								iEnableIniAccessLog;// Testexecute.ini entry for logging INI access

	TBool								iSharedDataMode;	// Flag representing -SharedData server mode

	TInt								iSetupParamValue;	// TEFParameter !Setup value set in the script

	TInt								iLoopIndex;			// Loop index of the current loop if test runs within a START_REPEAT

	TBuf<KMaxTestExecuteNameLength>		iTestCaseID;		// Name/ID of the test case in which the current test step executes

	TDriveName							iScriptDriveName;	// Drive name from where the script file is executed

	TDriveName							iSystemDrive;		// Default System Drive name

	TDriveName							iSystemDriveForTest;// System Drive name for Test artifacts

	// Use this buffer when allocating additional memory for the class in future

	// To avoid breaks with other depdenant comps

	TBuf<KMaxTestStepNameLength>		iReserved4Future1;

	TBuf<KMaxTestStepNameLength>		iReserved4Future2;

	TBuf<KMaxTestStepNameLength>		iReserved4Future3;

	TBuf<KMaxTestStepNameLength>		iReserved4Future4;

	};

// LEGACY

// Autotest macros mapped to CTestStep functions

// Check a boolean is true

#define TESTL(a) testBooleanTrueL((a), (TText8*)__FILE__, __LINE__) 

#define TEST(a)  testBooleanTrue((a), (TText8*)__FILE__, __LINE__) 

// Versions that will always log irrespective of testcase pass

#define TEST1L(a, b) testBooleanTrueL((a), (TText8*)__FILE__, __LINE__, (b) ) 

#define TEST1(a, b)  testBooleanTrue((a), (TText8*)__FILE__, __LINE__, (b) ) 

// Check a boolean is true if not return error code b

#define TESTE(a, b) testBooleanTrueWithErrorCode((a), (b), (TText8*)__FILE__, __LINE__) 

#define TESTEL(a, b) testBooleanTrueWithErrorCodeL((a), (b), (TText8*)__FILE__, __LINE__)  

// Versions that will always log irrespective of testcase pass

#define TESTE1(a, b, c) testBooleanTrueWithErrorCode((a), (b), (TText8*)__FILE__, __LINE__, (c) ) 

#define TESTE1L(a, b, c) testBooleanTrueWithErrorCodeL((a), (b), (TText8*)__FILE__, __LINE__, (c) )  

#define TEST_CHECKL(p1, p2, p3) TestCheckPointCompareL((p1), (p2), (p3), (TText8*)__FILE__, __LINE__)	

// Leave error code

#define TEST_ERROR_CODE 84	

#endif