/*

 * Copyright (c) 2004-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: 

 * tpolicy.h

 *

 */

 #ifndef __TPOLICY_H__

 #define __TPOLICY_H__

 #include "t_testaction.h"

 /**

  * This action is used to test whether security policies are correctly enforced.

  * This is done by specifying another test action to run, and the security

  * policy that is under test.  The action is then run in a seprate process.

  * This happens multiple times, to test that it passes when the process has the

  * required security settings and failes when it does not.

  *

  * The action body can contain the the following elements:

  *

  * testexe: The path of the executable to use to run the test

  * excludedcapabilities: Capabilites not to assign to the test executable when performing failure tests

  * policy: The security policy to be tested for

  * preactions: Optional, contains test actions to run to perform setup before the test

  * passaction: The action under test, when expected to pass

  * failaction: The action under test, when expected to fail

  * postactions: Optonal, contains test actions to run to perform cleanup after the test

  *

  * A new script is created containing the preactions if present, the test action

  * and the postactions (if present).  For failure tests, the testaction's expect

  * results is changed to KErrPermissionDenied.

  */

 class CPolicyTest : public CTestAction

 	{

 public:

 	static CPolicyTest* NewL(CConsoleBase& aConsole, Output& aOut,

 		const TTestActionSpec& aTestActionSpec);

 	static CPolicyTest* NewLC(CConsoleBase& aConsole, Output& aOut,

 		const TTestActionSpec& aTestActionSpec);

 	~CPolicyTest();

 private:

 	CPolicyTest(CConsoleBase& aConsole, Output& aOut);

 	void ConstructL(const TTestActionSpec& aTestActionSpec);

 public:

 	virtual void PerformAction(TRequestStatus& aStatus);

 private:

 	// Methods overriden from CTestAction 

 	virtual void DoReportAction();

 	virtual void DoCheckResult(TInt aError);

 	virtual void PerformCancel();

 	virtual void Reset();

 	// Methods for parsing the test spec

 	void BadUsageL(const TDesC& aMessage);

 	void SetTestExeL(const TDesC8& aPath);

 	void SetPolicyL(const TDesC8& aSpec);

 	void SetTestActionL(const TDesC8& aPassAction, const TDesC8& aFailAction);

 	// Methods for running the test

 	void GetNextTest();	

 	void StartProcessL(const TDesC& aExe, const TDesC& aCommandLine, TRequestStatus& aStatus);

 	void CheckProcessTermintationL();

 	void SetupTestL(TRequestStatus& aStatus);

 	void SetTestSecurityInfoL(TInt aSecureId, TInt aVendorId, TUint aCapSet, TRequestStatus& aStatus);

 	void CheckSetCapsResultL();

 	void RunTestL(TRequestStatus& aStatus);

 	void ProcessResultsL(TRequestStatus& aStatus);

 	void WriteScriptFileL(const TDesC& aPath, const TDesC8& aAction);

 private:

 	enum TState

 		{

 		EInit,

 		ESetupTest,

 		ERunTest,

 		EProcessResults,

 		EFinished

 		};

 	enum TTestState

 		{

 		ETestNone,

 		ETestFailSID,

 		ETestFailVID,

 		ETestFailCap,

 		ETestPass,

 		ETestFinished

 		};

 private:

 	RFs iFs;							///< File server handle

 	TInt iProcessSecureId;				///< The secure id of this process

 	TInt iProcessVendorId;				///< The vendor id of this process

 	HBufC* iTestExe;					///< The path of the test harness to run

 	TCapabilitySet iExcludedCaps;		///< Capabilties to exclude from failure tests

 	TUint iSecureId;					///< The secure id of the policy under test, or zero

 	TUint iVendorId;					///< The secure id of the policy under test, or zero

 	RArray<TCapability> iCapabilities;	///< The capabilities of the policy under test

 	HBufC8* iPreActions;				///< Script fragment for setup test actions

 	HBufC8* iPassAction;				///< The action under test

 	HBufC8* iFailAction;				///< The action under test

 	HBufC8* iPostActions;				///< Script fragment for cleanup test actions

 	TState iState;						///< The state we're in

 	TTestState iTestState;				///< The test we're running when iState is ESetCaps or ERunTest

 	TInt iCapIndex;						///< The capability we're testing when iTestState is ECapFailTests

 	RProcess iProcess;					///< Used for running setcap and test harness

 	TInt iFailCount;					///< Running count of tests failed

 	TBuf16<50> iTestExeTmpNewPath;      ///< stores the executable as executable_policytest.exe

 	};

 #endif