/*

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

* SWIS test step declaration

*

*/

/**

 @file

*/

#ifndef __TSWISSTEP_H__

#define __TSWISSTEP_H__

#include <test/testexecutestepbase.h>

#include <swi/asynclauncher.h>

#include "testutilclientswi.h"

#include "tswisserver.h"

#include "tuiscriptadaptors.h"

#include <swi/sistruststatus.h>

#include <e32base.h>

#ifndef SWI_TEXTSHELL_ROM		

#include <apsidchecker.h>

#else

class CAppSidChecker;

#endif

namespace Swi

	{

	class CInstallPrefs;

	}

/**

 * Base test step class containing handy functions

 * @test

 * @internalComponent

 */

class CSwisTestStep : public CTestStep

	{

protected:

	enum TReadType

		{

		ESimpleType,		//to read "numexist" and "numnonexist" value from INI.

		ECancelType,		//to read "numexistcancel" and "numnonexistcancel" value from INI.

		ERegisteredType		//to read "numregistered" value from INI.

		};

	/**

	 * Get the file names for checking if present or missing.

	 * The test step's INI file must contain entry "numexistcancel=<n>" and one or more entries

	 * "existcancel<i>=<fname>". 

	 * The test step's INI file must contain entry "numnonexistcancel=<n>" and one or more entries 

	 * "nonexistcancel<i>=<fname>".

	 * The test step's INI file must contain entry "numexist=<n>" and one or more entries 

	 * "exist<i>=<fname>".

	 * The test step's INI file must contain entry "numnonexist=<n>" and one or more entries 

	 * "nonexist<i>=<fname>".

	 * 

	 * @param aFileNumExist     this array contains the name of the files which must exist after

	 *						    installation/un-installation/cancellation.

	 * @param aFileNumNonExist	this array contains the name of the files which must not exist after

	 * 							installation/un-installation/cancellation.

	 * @param aDoCancelTest     Used to make decision for reading from the INI file.

	 *                          ETrue  Cancel Testing is enabled, so read entries "numexistcancel" and "numnonexistcancel".

	 *                          EFalse Read entries "numexist" and "numnonexist".

	 */

	void GetFileNamesForCheck(RArray<TPtrC>& aFileNumExist,RArray<TPtrC>& aFileNumNonExist, TReadType aReadType);

	/**

	 * Extract the file names from the INI file. 

	 * @param aEntries     Number of file name entries. 

	 * @param aEntryBase   Base name of the keys specifying names of files to 

	 *                     check; an index (0..n-1) is appended to the base 

	 *                     name to get the actual key name.

	 * @param aFileArray   Contains all the file names to check for missing or present. 

	 */ 

	void ExtractFileName(TInt aEntries, const TDesC& aEntryBase, RArray<TPtrC>& aFileArray);

	/** 

	 * Checks for files that should exist if the installation was successful,

	 * and which shouldn't exist if the installation was cancelled. 

	 * @param aCheckExist  Controls the kind of testing done

	 *                     ETrue  Files must exist

	 *                     EFalse Files must not exist

	 * @param aFileArray   Contains all the file names to check for missing or present depending

	 *					   on the aCheckExist. If ETrue, this contains the names of files that must exist

	 *					   else if EFalse contains the names of files that must not be present.

	 * @param aTestUtil    Contains reference to the testutilserver session.

	 * @param aMsecTimeout Timeout to wait for file to be created, if not already existing

     */

	void CheckIfFilesExist(TBool aCheckExist, const RArray<TPtrC>& aFileArray, RTestUtilSessionSwi& aTestUtil, TInt aMsecTimeout=0);

	/**

	 * Checks whether certain files do or do not exist by checking the registry entry and

	 * sets test step result accordingly.

	 * @param aFileArray   Contains all the file names to check for missing/present.

	 */ 

	void CheckRegistryEntry(RArray<TPtrC>& aFileArray);

	/**

	 * Checks that the correct dialogs have been called during the installation.

	 */

	void CheckDialogsCalled(const Swi::Test::CUIScriptAdaptor& ui);

	/**

	 * Checks whether a fatal OCSP response was encountered during the installation.

	 */

	void CheckFatalOcspResponse(const Swi::Test::CUIScriptAdaptor& ui);

	/**

	 * Checks whether the values of ocsp outcomes in the ini file matches with that of 

	 * the DisplayOcspResultL function.

	 */

    void  CheckExpectedOcspOutcomes(const Swi::Test::CUIScriptAdaptor& ui);	

   /**

	 * Copy files from one place to another.

	 *

	 * @param aNumEntries Name of the key that specifies number of file name 

	 *                    entries

	 * @param aFrom  Base name of the keys specifying names of files to 

	 *                    copy from; an index (0..n-1) is appended to the base 

	 *                    name to get the actual key name

	 * @param aTo    Base name of the keys specifying names of files to 

	 *                    copy to; an index (0..n-1) is appended to the base 

	 *                    name to get the actual key name

	 */

	void CopyFilesL(const TDesC& aNumEntries, const TDesC& aFrom, const TDesC& aTo);

	/**

 	 * Delete files.

 	 *

 	 * @param aNumEntries     Name of the key that specifies number of file name 

 	 *                        entries

 	 * @param aDeleteKeyBase  Base name of the keys specifying names of files

 	 *                        to delete; an index (0..n-1) is appended to the

 	 *                        base name to get the actual key name

 	 */

 	void DeleteFilesL(const TDesC& aNumEntries, const TDesC& aDeleteKeyBase);

	/**

	 * Stores all the values of expected install sizes as indicated in the test

	 * step's INI file.

	 * @param aNumExpectedSizeEntries Name of key that specifies the number of

	 *                                expected install sizes.

	 * @param aExpectedInstallSize    A reference to the array of install sizes.

	 */

	void StoreExpectedInstallSizesL(TInt aNumExpectedSizeEntries, RArray<TTableOfInstallSizes>& aExpectedValue);

	/** Verify the Pub and Sub value of the current installation/uninstallation */

	void CheckPubSubStatus(TDesC& aPubSubStatus);

	/**

	 * Check that the pub and sub status returns to KErrNone after a test.

	 * This check should typically be last, whereas the previous method should

	 * be done ASAP after an install/uninstall since there's a race condition.

	 */

	void CheckPubSubStatusIdle();

   /**

	 * Set or clear read only bit on files.

	 *

	 * @param aNumEntries     Name of the key that specifies number of file name 

	 *                        entries

	 * @param aFileKeyBase    Base name of the keys specifying names of files

	 *                        to set; an index (0..n-1) is appended to the

	 *                        base name to get the actual key name

	 * @param aFileKeyBase    Base name of the keys specifying operation on files

	 *                        ; an index (0..n-1) is appended to the

	 *                        base name to get the actual key name.

	 */

	void SetClearReadOnlyFilesL(const TDesC& aNumEntries,

								const TDesC& aFileKeyBase,

								const TDesC& aSetClearOpBase);

   /**

	 * Check current step result against list of expected result codes.

	 */

	void CheckExpectedResultCodesL();

	/**

	 * Compares hashes for pairs of files read from config section, sets the

	 * test step result to fail if any pair does not match or if there is an

	 * error attempting to get a hash.

	 */

	void CompareFilesL();

	/**

	 * Compares file contents with buffer. Sets test step result to fail if

	 * the contents do not match or there is an error in performing the

	 * operation.

	 */

	void CompareFileWithBufferL(const Swi::Test::CUIScriptAdaptor& ui);

	/**

	 * Get the device supported languages from the config section.

	 */

	void GetDevSupportedLanguagesL(RArray<TInt>& aDeviceLanguages);

	};

/**

 * Installation test step class

 * @test

 * @internalComponent

 */

class CSwisInstallStep : public CSwisTestStep

	{

public:

	CSwisInstallStep(TInstallType aInstallType, TBool aDoCancelTest = EFalse);

	~CSwisInstallStep();

	virtual TVerdict doTestStepPreambleL();

	virtual TVerdict doTestStepPostambleL();

	virtual TVerdict doTestStepL();

private:

	TInt DoInstallL(Swi::CInstallPrefs& aInstallPrefs);

	void GetFilesToHoldOpenL();

private:

	TFileName iSisFileName; // name of the file to install

	TFileName iXmlFileName; // name of the file containing dialog data

	Swi::Test::CUIScriptAdaptor* iUi; // XML script-based UI implementation

	TInstallType iInstallType; // use file handle to install

	RArray<TTableOfInstallSizes> iExpectedValue; // array of expected install sizes

	TBool iDoCancelTest;

	TPtrC iExpectedHash;

	TInt iExpectedDialog;

	TInt  iKErrCode;

	TPtrC Outcomes;// outcomes as received from ini file

	TUid iUid;

	TInt iExpectedUserDrive; // -1 if not checked

	TPtrC iPubSubStatus;

	HBufC* iFileToWatch;

	TBool iExpectFileChange;

	RPointerArray<RFile> iFilesHeldOpen;

	TBool iUseDeviceLanguages;

	RArray<TInt> iDeviceLanguages;

	};

/**

 * Uninstallation test step class

 * @test

 * @internalComponent

 */

class CSwisUninstallStep : public CSwisTestStep

	{

public:

	enum TUninstallType { EByUid, EByPackage };

	CSwisUninstallStep(TUninstallType aType, TBool aDoCancelTest = EFalse);

	~CSwisUninstallStep();

	virtual TVerdict doTestStepPreambleL();

	virtual TVerdict doTestStepPostambleL();

	virtual TVerdict doTestStepL();

private:

	TInt DoUninstallL();

private:

	TUid iUid;

	TFileName iXmlFileName; // name of the file containing dialog data

	TPtrC iVendorName;

	TInt iExpectedDialog;

	TInt iKErrCode;

	Swi::Test::CUIScriptAdaptor* iUi; // XML script-based UI implementation

	TPtrC iPackageName;

	TUninstallType iType;

	TBool iDoCancelTest;

	TPtrC iPubSubStatus;

	TBool iIsSafeMode;

	};

/**

 * CTrustStatusStep 

 * @test

 * @internalComponent

 */

class CTrustStatusStep : public CSwisTestStep

	{

public:

	CTrustStatusStep();

	virtual TVerdict doTestStepL();

	TPtrC* GetRevocationName(Swi::TRevocationStatus t);

	TPtrC* GetValidationName(Swi::TValidationStatus t);

	};

/**

 * CPostInstallRevocationCheckStep 

 * @test

 * @internalComponent

 */

class CPostInstallRevocationCheckStep : public CSwisTestStep

	{

public:

	CPostInstallRevocationCheckStep();

	virtual TVerdict doTestStepL();

	};

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

/**

 * CheckSCRField test step class

 * @test

 * @internalComponent

 */

class CCheckScrFieldStep : public CSwisTestStep

	{

public:	

	virtual TVerdict doTestStepL();

	};

class CCheckScrCompPropertyStep : public CSwisTestStep

	{

public:	

	virtual TVerdict doTestStepL();

	};

#endif

_LIT(KSwisInstallStep, "InstallStep");

_LIT(KSwisInstallFHStep, "InstallFHStep"); // install using file handles

_LIT(KSwisInstallMemStep, "InstallMemStep"); // install from memory

_LIT(KSwisInstallCAFStep, "InstallCAFStep"); // install from CAF

_LIT(KSwisInstallOpenFileStep, "InstallOpenFileStep"); // install with already opened file

_LIT(KSwisCheckedInstallStep, "CheckedInstallStep");

// Cancel testing 

_LIT(KSwisInstallCancelStep, "InstallStepCancel");

_LIT(KSwisInstallFHCancelStep, "InstallFHStepCancel"); // install using file handles

_LIT(KSwisInstallMemCancelStep, "InstallMemStepCancel"); // install from memory

_LIT(KSwisInstallCAFCancelStep, "InstallCAFStepCancel"); // install from CAF

_LIT(KSwisUninstallStep, "UninstallStep");

_LIT(KSwisUninstallAugStep, "UninstallAugStep"); // uninstall of augmentation

_LIT(KTrustStatus, "TrustStatus");

_LIT(KPirCheck, "PostInstallRevocationCheck");

_LIT(KSwisUninstallCancelStep, "UninstallStepCancel");

_LIT(KSwisUninstallAugCancelStep, "UninstallAugStepCancel"); // uninstall of augmentation

_LIT(KNumExpectedSizes, "numExpectedSizes"); // This specifies that the test section

											 // has values for installation size(s).

_LIT(KSwisMmcFormatStep, "MmcFormatStep");

_LIT(KSwisMmcMountStep, "MmcMountStep");

_LIT(KSwisMmcUnMountStep, "MmcUnMountStep");

_LIT(KSwisMmcCopyFiles, "MmcCopyFilesStep");

_LIT(KSwisMmcCheckFiles, "MmcCheckFilesStep");

_LIT(KSwisMmcResetTags, "MmcResetTagsStep");

_LIT(KSwisMmcDeleteFiles, "MmcDeleteFilesStep");

_LIT(KSwisMmcGetNumFilesFiles, "MmcGetNumFilesStep");

_LIT(KAskRegistry, "MmcAskRegistry");

_LIT(KSetClearReadOnly, "SetClearReadOnlyStep");

_LIT(KQuerySidViaApparcPlugin, "QuerySidViaApparcPlugin");

_LIT(KSwisListUninstallPkgsStep, "ListUninstallPkgsStep");

_LIT(KSwisRemoveUninstallPkgsStep, "RemoveUninstallPkgsStep");

_LIT(KSwisGetPackageDetails, "GetPackageDetails");

_LIT(KSwisGetPublishedUidArrayStep, "GetPublishedUidArrayStep");

_LIT(KSwisRemoveWithLastDependent, "RemoveWithLastDependent");

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

_LIT(KCheckSCRFieldStep, "CheckSCRFieldStep");

_LIT(KCheckSCRCompPropertyStep, "CheckSCRCompPropertyStep");

#endif

/**

 * Listing and Removing Uninslled Pkgs test step class

 * @test

 * @internalComponent

 */

class CSwisUninstallPkgsStep : public CSwisTestStep

	{

public:

	enum TUnInstallAppType { EListPkgs, ERemovePkgs, EPkgDetails};

	CSwisUninstallPkgsStep(TUnInstallAppType aInstallType);

	~CSwisUninstallPkgsStep();

	virtual TVerdict doTestStepPreambleL();

	virtual TVerdict doTestStepPostambleL();

	virtual TVerdict doTestStepL();

private:

	TUnInstallAppType iUnInstallAppType; // use file handle to install

	TUid iUid;

	TInt iDrive;

	TChar iDriveChar;

	};

/**

 * MMC emulation test step class

 * @test

 * @internalComponent

 */

class CSwisMmcStep : public CSwisTestStep

	{

public:

	enum TMmcOperation { 

		/**

		 * EFormat - Format the specified drive

		 *

		 * If the drive is NOT mounted the format will fail with error -18 KErrNotReady

		 *

		 * nb. Formating a drive looks like an MMC insertion to the SWI

		 * daemon (it does NOT look like a remove followed by an insert).

		 */

		EFormat,

		/**

		 * EMount - Mount the specified drive

		 *

		 * Mounting an already mounted drive fails with error -21 KErrAccessDenied

		 * 

		 * Mounting an unmounted drive looks exactly like a MMC card

		 * insertion to the SWI daemon.

		 *

		 * [The SWI daemon detects MMC insertion by registering with the

		 * FS server using NotifyChange(ENotifyEntry,,) for a non-existent

		 * file on the drive being watched. It then checks if it can read

		 * the Volume info to decide if media has been inserted or

		 * removed.]

		 */

		EMount,

		/**

		 * EUnMount - UnMount the specified drive

		 *

		 * Un-mounting an already un-mounted drive fails with error -18 KErrNotReady

		 *

		 * Unmounting an mounted drive looks exactly like a MMC card

		 * removal to the SWI daemon.

		 *

		 * Will fail if there are any open file descriptors on the drive.

		 */

		EUnMount,

		/**

		 * ECopyFiles - Copy some files to the MMC

		 */

		ECopyFiles,

		/**

		 * ECheckFiles - Check set of files specified by

		 * numexist/existX and numnonexist/nonexistX are present/absent as specified.

		 */

		ECheckFiles,

		/**

		 * EResetTags - Delete the tags directory for a new test

		 */

		EResetTags,

		/**

 		 * EDeleteFiles - Delete some files which may be in private directories

 		 */

		EDeleteFiles,

		/**

 		 * EGetNumFiles - Get the number of files in a given directory

 		 */

		EGetNumFiles,

		EAskReg,

		ESetClearReadOnly,

		/**

		 * Query if the specified SID is installed

		 */

		EQuerySidViaApparcPlugin

	};

	CSwisMmcStep(TMmcOperation aOperation);

	~CSwisMmcStep();

	virtual TVerdict doTestStepPreambleL();

	virtual TVerdict doTestStepPostambleL();

	virtual TVerdict doTestStepL();

private:

	TMmcOperation iOperation;

	TInt iDrive;

	TInt iBootMode;

	TChar iDriveChar;

#ifndef SWI_TEXTSHELL_ROM

	CAppSidChecker *iSwiSidChecker;

#endif

	};

/**

 * Check Published Uid test step class

 * @test

 * @internalComponent

 */

const TInt KTestMaxUidCount=20; //One more than the maximum number of Uids that the array, publishing the Uids, holds

class CSwisCheckPublishUidStep : public CSwisTestStep

    {

public:

    CSwisCheckPublishUidStep();

    virtual TVerdict doTestStepPreambleL();

    virtual TVerdict doTestStepPostambleL();

    virtual TVerdict doTestStepL();

private:

	void GenerateIndexedAttributeNameL(TDes& aInitialAttributeName, TInt aIndex);

private:

TUid iExpectedUidList[KTestMaxUidCount];    //An array whose first element holds the number of uids in the subsequent indices of the array, followed by the the list of uids that are being published.

TBool iJustDefineProperty;

	};