// 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 "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 file contains test classes and their implementations

// to test production class CRegistrar. Where necessary stubs

// are implemented to help in writing test harness using RTest.

// 

//

#include "RegistryData.h"

#include "EComErrorCodes.h"

#include "EComUidCodes.h"

#include "ImplementationInformation.h"

#include "RegistryData.h"

#include "Registrar.h"

#include "RegistrarObserver.h"

#include "../EcomTestUtils/EcomTestUtils.h"

#include "EComEntryBase.h"

#include "DriveInfo.h"

#include <e32test.h>

#include <f32file.h>

#include <bautils.h>

#include <startup.hrh>

#include "baspi.h"

_LIT (KDataDir, "C:\\private\\10009D8F\\ECom*");

//We need two different entry RSC and the SPI to fully test CRegistrar

//------------------------------NEW TYPE----------------------------------------

const TUid NewDllUid={0x101F847B};

_LIT(KNewResourceFileNameOnly,"EComExample5.rsc");

_LIT(KNewResourceFileNameC, "C:\\resource\\plugins\\EComExample5.rsc");

_LIT(KNewDllFileNameC, "C:\\sys\\bin\\EComExample5.dll");

_LIT(KNewResourceFileNameZ, "z:\\RAMOnly\\EComExample5.rsc");

_LIT(KNewDllFileNameZ,"z:\\RAMOnly\\EComExample5.dll");

//We need IIC type 3 RSC to fully test CRegistrar

//------------------------------IIC TYPE 3----------------------------------------

const TUid Type3DllUid = {0x10009E3E};

_LIT(KType3ResourceFileNameOnly,"EComExample12.rsc");

_LIT(KType3ResourceFileNameC, "C:\\resource\\plugins\\EComExample12.rsc");

_LIT(KType3DllFileNameC, "C:\\sys\\bin\\EComExample12.dll");

_LIT(KType3ResourceFileNameZ, "z:\\RAMOnly\\EComExample12.rsc");

_LIT(KType3DllFileNameZ,"z:\\RAMOnly\\EComExample12.dll");

//We need IIC type 3 RSC with data exceed maximum to fully test CRegistrar

//------------------------------IIC TYPE 3----------------------------------------

_LIT(KType3BadDataResourceFileNameOnly,"EComExampleBadData.rsc");

_LIT(KType3BadDataResourceFileNameC, "C:\\resource\\plugins\\EComExampleBadData.rsc");

_LIT(KType3BadDataDllFileNameC, "C:\\sys\\bin\\EComExampleBadData.dll");

_LIT(KType3BadDataResourceFileNameZ, "z:\\RAMOnly\\EComExampleBadData.rsc");

_LIT(KType3BadDataDllFileNameZ,"z:\\RAMOnly\\EComExampleBadData.dll");

_LIT(KType3BadData1ResourceFileNameOnly,"EComExampleBadData1.rsc");

_LIT(KType3BadData1ResourceFileNameC, "C:\\resource\\plugins\\EComExampleBadData1.rsc");

_LIT(KType3BadData1DllFileNameC, "C:\\sys\\bin\\EComExampleBadData1.dll");

_LIT(KType3BadData1ResourceFileNameZ, "z:\\RAMOnly\\EComExampleBadData1.rsc");

_LIT(KType3BadData1DllFileNameZ,"z:\\RAMOnly\\EComExampleBadData1.dll");

_LIT(KType3BadData2ResourceFileNameOnly,"EComExampleBadData2.rsc");

_LIT(KType3BadData2ResourceFileNameC, "C:\\resource\\plugins\\EComExampleBadData2.rsc");

_LIT(KType3BadData2DllFileNameC, "C:\\sys\\bin\\EComExampleBadData2.dll");

_LIT(KType3BadData2ResourceFileNameZ, "z:\\RAMOnly\\EComExampleBadData2.rsc");

_LIT(KType3BadData2DllFileNameZ,"z:\\RAMOnly\\EComExampleBadData2.dll");

//We need IIC type 2 RSC to fully test CRegistrar

//------------------------------IIC TYPE 2----------------------------------------

_LIT(KType2ResourceFileNameOnly,"EComExample14.rsc");

_LIT(KType2ResourceFileNameC, "C:\\resource\\plugins\\EComExample14.rsc");

_LIT(KType2DllFileNameC, "C:\\sys\\bin\\EComExample14.dll");

_LIT(KType2ResourceFileNameZ, "z:\\RAMOnly\\EComExample14.rsc");

_LIT(KType2DllFileNameZ,"z:\\RAMOnly\\EComExample14.dll");

//------------------------------LEGACY TYPE-------------------------------------

// spi test file

_LIT(KEComSpiTestFilePathAndName, "Z:\\Test\\Data\\EcomTest.spi");

// spi test file for testing IIC Type3

_LIT(KEComSpiTestFileType3PathAndName, "Z:\\Test\\Data\\ecomtesttype3.spi");

const TInt KOneSecond = 1000000;

const TUid interfaceUidExample12 = {0x10009E36};

const TUid extendedInterfaceUid1 = {0x10009E44};

const TUid extendedInterfaceUid2 = {0x10009E45};

const TUid extendedInterfaceUid3 = {0x10009E46};

LOCAL_D RTest test(_L("t_Registrar.exe"));

LOCAL_D RFs					TheFs;

LOCAL_D CTrapCleanup* 		TheTrapCleanup 		= NULL;

LOCAL_D CActiveScheduler*	TheActiveScheduler	= NULL;

// Used for supressing warning in OOM tests

#define __UNUSED_VAR(var) var = var

//It is used by some test methods which are called two times:

//from normal test and from OOM test.

static void LeaveIfErrNoMemory(TInt aError)

	{

	if(aError == KErrNoMemory)

		{

		User::Leave(aError);

		}

	}

/**

TRegistrar_StateAccessor class allows access to private and protected

members of production code class CRegistrar, as its a friend class.

*/

class TRegistrar_StateAccessor

	{

public:

	void DiscoveriesBegin(CRegistrar& aRegistrar);

	void DiscoveriesComplete(CRegistrar& aRegistrar, TBool aSuccessful);

	void DriveRemovedL(CRegistrar& aRegistrar, TDriveUnit aDriveUnit);

	void DriveReinstatedL(CRegistrar& aRegistrar, TDriveUnit aDriveUnit);

	void RegisterDiscoveryL(CRegistrar& aRegistrar,const TDriveName& aDrive, CPluginBase*& aEntry,TBool aDatFileExists);

	void ParseL(CRegistrar& aRegistrar,

				CPluginBase*& aEntry,

				CRegistryData::CDllData& aDll);

	void ParseRegistrationDataL(CRegistrar& aRegistrar,

				CPluginBase*& aEntry,

				TDriveUnit& aDriveUnit,

				TBool aUpdate,

				TInt aRegistryDriveIndex,

				CRegistryData::CDriveData* aDriveData);

	CRegistrar::TRegistrarState State(CRegistrar& aRegistrar);

	};

/**

Parses the resource file associated with an

Interface Implementation Collection for the plugin entry.

@param		aRegistrar The CRegistrar class object under test

@param		aEntry an ecom entry discovered

@param		aDll CRegistrar::CDllData object in which parsed data needs to be stored

@pre 		CRegistrar should be fully constructed.

@post		The resource file is parsed and the data is added to 'aDll'.

 */

void TRegistrar_StateAccessor::ParseL(CRegistrar& aRegistrar,

									  CPluginBase*& aEntry,

									  CRegistryData::CDllData& aDll)

	{

	aRegistrar.ParseL(aEntry,aDll);

	}

/**

Determines if the directory entry for an Interface Implementation

Collection requires registration. Parses and registers the plugin entry

associated with the resource file if entry is not already registered.

@param		aRegistrar The CRegistrar class object under test

@param		aEntry Directory entry for the Interface Impplementation Collection.

@param		aRscFileName Resource file from which to extract the data

@param		aDrive Drive on which registry data has been found on

@param		aUpdate Flag indicating if this is an update, or new entry.

@param		aRegistryDriveIndex Index within the registry data

			for the branch that the registry entry was found within.

@pre 		CRegistrar is fully constructed.

@post		The Interface Implementation Collection entry has been processed appropriately.

*/

void TRegistrar_StateAccessor::ParseRegistrationDataL(CRegistrar& aRegistrar,

														CPluginBase*& aEntry,

														TDriveUnit& aDrive,

														TBool aUpdate,

														TInt aRegistryDriveIndex,

														CRegistryData::CDriveData* aDriveData)

	{

	aRegistrar.ParseRegistrationDataL(aEntry, aDrive,aUpdate, aRegistryDriveIndex, aDriveData);

	}

/**

Overload of the MDiscovererObserver callback method.

The cue that a registry update is about to occur.

@param		aRegistrar The CRegistrar class object under test

@pre 		CRegistrar is fully constructed

@post		The Registry data manager has been informed that its internal

			data is out of date.

*/

void TRegistrar_StateAccessor::DiscoveriesBegin(CRegistrar& aRegistrar)

	{

	aRegistrar.DiscoveriesBegin();

	}

/**

Overload of the MDiscovererObserver callback method.

The cue that a registry update is done.

@param		aRegistrar The CRegistrar class object under test

@param		aSuccessful The registry data has been updated successfully

@pre 		CRegistrar is fully constructed

@post		The current registry data and the internal access indexes have been rebuilt.

*/

void TRegistrar_StateAccessor::DiscoveriesComplete(CRegistrar& aRegistrar,

												   TBool aSuccessful)

	{

	aRegistrar.DiscoveriesComplete(aSuccessful, EPluginProcessingTypeAll);

	}

/**

Overload of the MDiscovererObserver callback method.

Signals registry that the registered Interface Implementation

Collections stored upon the specified drive are no

longer available for use.

@param		aRegistrar The CRegistrar class object under test

@param		aDrive	The drive identifier.

@pre 		CRegistrar is fully constructed.

@post		The registered Interface Implementation Collections

			stored upon the specified drive are no

			longer available for use.

*/

void TRegistrar_StateAccessor::DriveRemovedL(CRegistrar& aRegistrar,

											 TDriveUnit aDrive)

	{

	aRegistrar.DriveRemovedL(aDrive);

	}

/**

Overload of the MDiscovererObserver callback method.

Signals registry that the registered Interface

Implementation Collections stored upon the specified drive are again

available for use.

@param		aRegistrar The CRegistrar class object under test

@param		aDrive	The drive identifier.

@pre 		CRegistrar is fully constructed.

@post		The registered Interface Implementation Collections

			stored upon the specified drive are again

			made available for use.

*/

void TRegistrar_StateAccessor::DriveReinstatedL(CRegistrar& aRegistrar,

												   TDriveUnit aDrive)

	{

	aRegistrar.DriveReinstatedL(aDrive);

	}

/**

Overload of the MDiscovererObserver callback method.

Adds the specified Interface Implementation Collection Entry to the registry.

@param		aRegistrar The CRegistrar class object under test

@param		aDirEntry The plugin entry to register.

@pre 		CRegistrar is fully constructed

@post		The plugin entry is registered.

*/

void TRegistrar_StateAccessor::RegisterDiscoveryL(CRegistrar& aRegistrar,

												  const TDriveName& aDrive,

												  CPluginBase*& aEntry,

												  TBool aDatFileExists )

	{

	aRegistrar.RegisterDiscoveryL(aDrive,aEntry,aDatFileExists);

	}

/**

Retrieves the object's current state.

@return 	TCRegistarState the CRegistrar's current state.

@pre		CRegistrar is fully constructed.

@post 		the CRegistrar's current state has been returned.

*/

CRegistrar::TRegistrarState TRegistrar_StateAccessor::State(CRegistrar& aRegistrar)

	{

	return aRegistrar.State();

	}

/**

TRegistryData_StateAccessor class allows access to private and protected

members of production code class CRegistryData, as its a friend class.

*/

class TRegistryData_StateAccessor

	{

public:

	TInt FindImplementation(CRegistryData& aRegistryData,

				const TUid aImplUid,

				const TUid aInterfaceUid,

				CRegistryData::CImplementationData*& aImplData) const;

	};

/**

@return		KErrNone if found otherwise KErrNotFound

@param		aRegistryData The CRegistryData class object

@param		aImplUid The implementation to find.

@param		aInterfaceUid If greater than 0 the interface associated with the

			implementation to find.

@param		aImplData The found implementation data.

@pre 		CRegistrar is fully constructed

*/

TInt TRegistryData_StateAccessor::FindImplementation(CRegistryData& aRegistryData,

												const TUid aImplUid,

												const TUid aInterfaceUid,

												CRegistryData::CImplementationData*& aImplData) const

	{

	return aRegistryData.FindImplementation(aImplUid, aInterfaceUid, aImplData);

	}

/**

The implementation of the abstract Registrar Observer class,

used for recieving notifications of registry changes.

Stub class(for CEComServer) used for the creation of CRegistrar class object.

CEComServer class acts as observer for CRegistrar.

*/

class CTestRegistrarObserver : public MRegistrarObserver // codescanner::missingcclass

	{

public:

	// This function is used by RegistrarObserver (i.e.CEComServer) to notify its

	// clients(REComSession objects) that some change has happened in Registry.

	// Here we have no clients to notify, so no implementaion.

	void Notification( TInt /*aNotification*/ ) {}

	};

/**

Test class for object CRegistrar.

This class provides the parameters and behaviour that

allows this class to behave normally under a test

scenario.

*/

class CRegistrarTest : public CBase

	{

public:

	static CRegistrarTest* NewL(TBool aIsFullDiscovery);

	virtual ~CRegistrarTest();

	const CImplementationInformation * GetImplementationDataL();

	void EnableDisableTestL();

	void ResumeSuspendTestL();

	void DiscoveriesBegin_Register_CompleteTestL();

	void DriveRemovedReinstatedTestL();

	void ParseTestL();

	void ParseType2TestL();

	void ParseType3TestL();

	void ParseType3BadDataTestL();

	void ParseRegistrationDataTestL();

	void ParseRegistrationDataType3TestL();

	void StateTransitionTestL();

	void ParseSpiRegistrationDataTestL();

	void ParseSpiRegistrationDataType3TestL();

	void ParseSpiTestL();

	void ParseSpiType3TestL();

private:

	CRegistrarTest();

	void ConstructL(TBool aIsFullDiscovery);

	void ParseBadDataTestL(const TDesC& aRscFullName, const TDesC& aRscNameOnly);

public:

	/** The instance of the class under test */

	CRegistrar* iRegistrar;

	/** The instance of the State Accessor class */

	TRegistrar_StateAccessor* iStateAccessor;

	/** The registry data instance required to construct a CRegistrar object */

	CRegistryData* iRegistryData;

	/** The instance of the Registry Data State Accessor class */

	TRegistryData_StateAccessor* iRegistryDataStateAccessor;

	/** The instance of the observer of CRegistrar class */

	MRegistrarObserver* iRegistrarObserver;

	/** The destination for the data discovered during a parse */

	CRegistryData::CDllData* iDllData;

	/** Unique Id of the ECOM dll */

	TUid    iDllUid;

	/** Unique Id of an interface implementation */

	TUid	iImplementationUid;

	/** Unique Id of an interface */

	TUid	iInterfaceUid;

	/** The drive on which interface implementations can be found */

	TDriveUnit	iDriveUnit;

	/** Ecom plugin which contains interface implementations. Used in Registration APIs.*/

	TEntry		iDllEntry;

	};

/**

Standardised safe construction which

leaves nothing on the cleanup stack.

@param		aIsFullDiscovery whether the constructor make full discovery

@post		CRegistrarTest is fully constructed and initialised.

*/

CRegistrarTest* CRegistrarTest::NewL(TBool aIsFullDiscovery)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aIsFullDiscovery);

	CleanupStack::Pop(self);

	return self;

	}

/**

Standardized default c'tor

@post		CRegistrarTest is fully constructed.

*/

CRegistrarTest::CRegistrarTest()

:	CBase(),

	iDriveUnit(EDriveC)

	{

	iDllUid.iUid			= 0x101F847B; // Dlluid for Ecom plugin EComExample5.dll

	iInterfaceUid.iUid		= 0x10009DC0; // Interface uid for interface contained in above plugin

	iImplementationUid.iUid = 0x101f847C; // Implementaion uid for above interface

	TUid uid1 = {0};

	TUid uid2 = {0};

	iDllEntry.iType = TUidType(uid1, uid2, iDllUid);//Setting Dlluid to plugin entry

	}

/**

Destructor.

@post		This object is properly destroyed.

*/

CRegistrarTest::~CRegistrarTest()

	{

	delete iDllData;

	delete iRegistrar;

	delete iRegistryData;

	delete iRegistrarObserver;

	delete iStateAccessor;

	delete iRegistryDataStateAccessor;

	}

/**

Standardized 2nd(Initialization) phase of two phase construction.

@param		aIsFullDiscovery whether the constructor make full discovery

@post		CRegistrarTest is fully constructed.

*/

void CRegistrarTest::ConstructL(TBool aIsFullDiscovery)

	{

	CRegistryData::CDriveData* driveData=NULL;

	iRegistrarObserver = new (ELeave) CTestRegistrarObserver;

	iStateAccessor	   = new (ELeave) TRegistrar_StateAccessor;

	iRegistryDataStateAccessor	   = new (ELeave) TRegistryData_StateAccessor;

	iRegistryData	   = CRegistryData::NewL(TheFs);

	iRegistrar		   = CRegistrar::NewL(*iRegistryData, *iRegistrarObserver, TheFs);

	if(aIsFullDiscovery)

		{

		iRegistrar->ProcessSSAEventL(EStartupStateNonCritical);

		}

	iDllData		   = CRegistryData::CDllData::NewLC(driveData);

	CleanupStack::Pop(iDllData);

	}

/**

Returns information of a particular interface implementation.

@return		Information on the requested implementation

@pre 		This object is fully constructed

*/

const CImplementationInformation * CRegistrarTest::GetImplementationDataL()

	{

	CRegistryData::CImplementationData *implementationData=NULL;

	TUid dummyUid;

	dummyUid.iUid = 0;

	User::LeaveIfError(iRegistryDataStateAccessor->FindImplementation(*iRegistryData, iImplementationUid,

																dummyUid, implementationData));

	return implementationData->iImplInfo;

	}

/**

The test executes by first Disabling the Implementation then by

Enabling it.

@SYMTestCaseID          SYSLIB-ECOM-CT-0727

@SYMTestCaseDesc	    Tests for enabling and disabling the Implementation

@SYMTestPriority 	    High

@SYMTestActions  	    Fetch the Implementation information for testing for iImplementationUid

                        Disable and enable the implementation for the unique UID

@SYMTestExpectedResults The test must not fail.

@SYMREQ                 REQ0000

*/

void CRegistrarTest::EnableDisableTestL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0727 "));

	const CImplementationInformation *implimentationInfo = NULL;

	// Get the Implementation information for testing for iImplementationUid.

	// Implementation for iImplementationUid should be registered to

	// run this test successfully.

	TRAPD(err, implimentationInfo = GetImplementationDataL());

	::LeaveIfErrNoMemory(err);

	test(err == KErrNone);

	test(implimentationInfo != NULL);

	// Disable the implementaion

	err = iRegistrar->Disable(iImplementationUid);

	::LeaveIfErrNoMemory(err);

	test(KErrNone == err);

	test(implimentationInfo->Disabled());//It should be disabled

	// Enable the implementaion

	err = iRegistrar->Enable(iImplementationUid);

	::LeaveIfErrNoMemory(err);

	test(KErrNone == err);

	test(!implimentationInfo->Disabled());//It should be enabled

	}

/**

The test executes by first suspending the discoverer then by resuming it.

@SYMTestCaseID          SYSLIB-ECOM-CT-0728

@SYMTestCaseDesc	    Tests for overloaded MBackupNotifierObserver's Suspend and Resume functions

@SYMTestPriority 	    High

@SYMTestActions  	    The test executes by first calling CRegistrar's suspend and then by resume.

@SYMTestExpectedResults The test must not fail.

@SYMREQ                 REQ0000

*/

void CRegistrarTest::ResumeSuspendTestL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0728 "));

	TInt err = iRegistrar->Suspend();

	::LeaveIfErrNoMemory(err);

	test(err == KErrNone);

	err = iRegistrar->Resume();

	::LeaveIfErrNoMemory(err);

	test(err == KErrNone);

	}

/**

The test executes by calling DiscoveriesBegin, RegisterDiscoveryL and

DiscoveriesComplete in sequence to register the plugin.

@SYMTestCaseID          SYSLIB-ECOM-CT-0729

@SYMTestCaseDesc	    Tests for registering the DLL interfaces

@SYMTestPriority 	    High

@SYMTestActions  	    Calls up DiscoveriesBegin, RegisterDiscoveryL and

						DiscoveriesComplete in sequence to register the plugin and

						verifies that DLL's have been registered succesfully.

@SYMTestExpectedResults The test must not fail.

@SYMREQ                 REQ0000

*/

void CRegistrarTest::DiscoveriesBegin_Register_CompleteTestL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0729 "));

	// The following three steps need to be executed to successfully

	// register the plugin

	iStateAccessor->DiscoveriesBegin(*iRegistrar);

//-----------------REGISTRATION PART------------------------------------

	CPluginBase* entryBase=NULL;

	TInt err=KErrNone;

	TBool update = EFalse;

	TInt  driveIndex = KErrNotFound;		//Used as return parameter used below

	TBool isDriveRegistered = EFalse;		//Used as return parameter used below

	CRegistryData::CDriveData* driveData = NULL;

	//Testing a RSc based entry using EComExample5.dll and EComExample5.rsc

	TEntry rscBasedEntry;

	rscBasedEntry.iName=KNewResourceFileNameOnly;

	err = TheFs.Modified(KNewResourceFileNameC, rscBasedEntry.iModified);

	test(err==KErrNone);

	TParse rscPath;

	rscPath.Set(KNewResourceFileNameC,NULL,NULL);

	entryBase=CSecurePlugin::NewL(TheFs,rscBasedEntry,rscPath.Drive(), ETrue);

	CleanupStack::PushL(entryBase);

	//Now register this Rsc Entry with the registrar

	TRAP(err, iStateAccessor->RegisterDiscoveryL(*iRegistrar,rscPath.Drive(), entryBase,ETrue));

	::LeaveIfErrNoMemory(err);

	test(err == KErrNone);

	CleanupStack::PopAndDestroy(entryBase);

	entryBase=NULL;

	TRAP(err, driveIndex = iRegistryData->FindDriveL(iDriveUnit, driveData));

	::LeaveIfErrNoMemory(err);

	test(driveIndex != KErrNotFound);

	//Verify weather dll interfaces got registered

	// Check whether Rsc based entry is already registered in CRegistryData

	TRAP(err, isDriveRegistered = iRegistryData->IsRegisteredWithDate(

																		NewDllUid,

																		rscBasedEntry.iModified,

																		update,

																		driveData));

	::LeaveIfErrNoMemory(err);

	test(err == KErrNone);

	test(isDriveRegistered);

	test(!update);// As plugin is just registered, it does not require update.

	//THE REASON WHY THIS FUNCTION IS MOVED TO THE BACK AS IT PREVENT THE TESTING

	//OF THE LEGACY PLUGINS BEING REGISTERED AS DURING THE VALIDATE REGISTRY

	//THE LEGACY ENTRY WILL BE WIPED OUT

	iStateAccessor->DiscoveriesComplete(*iRegistrar, EFalse);

	test(iRegistrar != NULL);

	}

/**

@SYMTestCaseID          SYSLIB-ECOM-CT-0730

@SYMTestCaseDesc	    Tests for CRegistrar::DriveRemovedL,DriveReinstatedL functions

@SYMTestPriority 	    High

@SYMTestActions  	    The test executes by first making the test drive uninstall and

						then testing for Install and Uninstall.

@SYMTestExpectedResults The test must not fail.

@SYMREQ                 REQ0000

*/

void CRegistrarTest::DriveRemovedReinstatedTestL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0730 "));

	// We are checking with F Drive.

	// The test executes by first removing and then reinstalling

	const TTime modified(0); //Dummy parameter...

	TBool update = EFalse;   //Dummy parameter...

	TBool isDriveRegistered = EFalse;

	TInt  driveIndex = KErrNotFound;

	CRegistryData::CDriveData* driveData = NULL;

	iDriveUnit = EDriveF;

	TInt error = KErrNone;

	TRAP(error, driveIndex = iRegistryData->FindDriveL(iDriveUnit, driveData));

	::LeaveIfErrNoMemory(error);

	TInt err = KErrNone;

	if(driveIndex != KErrNotFound)

	{

	TRAP(err, iRegistryData->IsRegisteredWithDate(

													iDllUid,

													modified,

													update,

													driveData));

	::LeaveIfErrNoMemory(err);

	}

	isDriveRegistered = (driveIndex != KErrNotFound);

	//Remove the drive from registry if registered

	if(isDriveRegistered)

		{

		TRAP(err, iStateAccessor->DriveRemovedL( *iRegistrar, iDriveUnit));

		::LeaveIfErrNoMemory(err);

		test(err == KErrNone);

		//Call CRegistryData::IsRegisteredWithDate again to check its removed now

		driveIndex = KErrNotFound;

		TRAP(err, driveIndex = iRegistryData->FindDriveL(iDriveUnit, driveData));

		//Drive should not be present

		::LeaveIfErrNoMemory(err);

		test(driveIndex == KErrNotFound);

		}

	// Install the drive in registry

	TRAP(err, iStateAccessor->DriveReinstatedL(*iRegistrar, iDriveUnit));

	::LeaveIfErrNoMemory(err);

	test(err == KErrNone);

	//Call CRegistryData::IsRegisteredWithDate to check its Reinstalled now

	driveIndex = KErrNotFound;

	TRAP(err, driveIndex = iRegistryData->FindDriveL(iDriveUnit, driveData));

	::LeaveIfErrNoMemory(err);

	//Drive should be present now

	test(driveIndex != KErrNotFound);

	TRAP(err, iRegistryData->IsRegisteredWithDate(

													iDllUid,

													modified,

													update,

													driveData));

	::LeaveIfErrNoMemory(err);

	test(err == KErrNone);

	//Remove the drive from registry if it was not registered before

	if(!isDriveRegistered)

		{

		TRAP(err, iStateAccessor->DriveRemovedL( *iRegistrar, iDriveUnit));

		::LeaveIfErrNoMemory(err);

		test(err == KErrNone);

		//Call CRegistryData::IsRegisteredWithDate again to check its removed now

		driveIndex = KErrNotFound;

		TRAP(err, driveIndex = iRegistryData->FindDriveL(iDriveUnit, driveData));

		//Drive should not be present

		::LeaveIfErrNoMemory(err);

		test(driveIndex == KErrNotFound);

		}

	}

/**

The test executes by parsing the Interface implementaion information

from the given resource file.

@SYMTestCaseID          SYSLIB-ECOM-CT-0731

@SYMTestCaseDesc	    Tests for verification of Interface implementaion information

@SYMTestPriority 	    High

@SYMTestActions  	    Parse the resource information associated with an

					    Interface Implementation Collection for entry into the registry

					    information.Check for OOM error or parse error.

@SYMTestExpectedResults The test must not fail.

@SYMREQ                 REQ0000

*/

void CRegistrarTest::ParseTestL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0731 "));

	TInt error=KErrNone;

	CPluginBase* entryBase=NULL;

	CRegistryData::CDllData* dllData=NULL;

	CRegistryData::CInterfaceData* ifData =NULL;

	CRegistryData::CDriveData* driveData = NULL;

	//Testing a RSC based entry using EComExample5.dll and EComExample5.rsc

	//(101F847B.RSS)

	TEntry rscBasedEntry;

	rscBasedEntry.iName=KNewResourceFileNameOnly;

	error = TheFs.Modified(KNewResourceFileNameC, rscBasedEntry.iModified);

	test(error==KErrNone);

	TParse rscPath;

	rscPath.Set(KNewResourceFileNameC,NULL,NULL);

	TDriveUnit driveUnit(rscPath.Drive());

	error=iRegistryData->FindDriveL(driveUnit,driveData);

	test(error!=KErrNotFound);

	entryBase=CSecurePlugin::NewL(TheFs,rscBasedEntry,rscPath.Drive(), ETrue);

	CleanupStack::PushL(entryBase);

	dllData=CRegistryData::CDllData::NewLC(*(entryBase->iDllName),entryBase->iDllModifiedTime,entryBase->iDllSecondUid,entryBase->iDllThirdUid,driveData);

	//Now testing the parseL function

	TRAP(error, iStateAccessor->ParseL(*iRegistrar,entryBase,*dllData));

	::LeaveIfErrNoMemory(error);

	test(error == KErrNone);

	//Now checking the content of the DllData

	test(dllData->iIfList->Count()==1);

	ifData=(*(dllData->iIfList))[0];

	test(ifData->iInterfaceUid.iUid==0x10009DC0);

	test(ifData->iImplementations->Count()==1);

	CleanupStack::PopAndDestroy(dllData);

	CleanupStack::PopAndDestroy(entryBase);

	entryBase=NULL;

	dllData=NULL;

	ifData=NULL;

	}

/**

The test executes by parsing the Interface implementation information with type 2 entries

from the given resource file.

@SYMTestCaseID          SYSLIB-ECOM-UT-3563

@SYMTestCaseDesc	    Tests for verification of Interface implementation information with type 2 entries

@SYMTestPriority 	    High

@SYMTestActions  	    Parse the resource information associated with an

					    Interface Implementation Collection type 2 for entry into the registry

					    information.Check for OOM error or parse error.

@SYMTestExpectedResults CRegistrar::ParseL() function parses resource file without error.

						Data is interpreted correctly.

@SYMEC                  EC43

*/

void CRegistrarTest::ParseType2TestL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3563 "));

	TInt error = KErrNone;

	CPluginBase* entryBase = NULL;

	CRegistryData::CDllData* dllData = NULL;

	CRegistryData::CInterfaceData* ifData = NULL;

	CRegistryData::CDriveData* driveData = NULL;

	TUid interfaceUidExample14 = {0x10009E36};

	//Tests an RSC based entry using EComExample14.dll and EComExample14.rsc

	//(EcomExample14.RSS)

	TEntry rscBasedEntry;

	rscBasedEntry.iName = KType2ResourceFileNameOnly;

	error = TheFs.Modified(KType2ResourceFileNameC, rscBasedEntry.iModified);

	test(error == KErrNone);

	TParse rscPath;

	rscPath.Set(KType2ResourceFileNameC,NULL,NULL);

	TDriveUnit driveUnit(rscPath.Drive());

	error = iRegistryData->FindDriveL(driveUnit,driveData);

	test(error != KErrNotFound);

	entryBase = CSecurePlugin::NewL(TheFs,rscBasedEntry,rscPath.Drive(), ETrue);

	CleanupStack::PushL(entryBase);

	dllData = CRegistryData::CDllData::NewLC(*(entryBase->iDllName),entryBase->iDllModifiedTime,entryBase->iDllSecondUid,entryBase->iDllThirdUid,driveData);

	//tests the parseL function

	TRAP(error, iStateAccessor->ParseL(*iRegistrar,entryBase,*dllData));

	::LeaveIfErrNoMemory(error);

	test(error == KErrNone);

	//checks the content of the DllData

	test(dllData->iIfList->Count() == 1);

	ifData = (*(dllData->iIfList))[0];

	test(ifData->iInterfaceUid == interfaceUidExample14);

	CleanupStack::PopAndDestroy(dllData);

	CleanupStack::PopAndDestroy(entryBase);

	}

/**

The test executes by parsing the Interface implementation information with type 3 entries

from the given resource file.

@SYMTestCaseID          SYSLIB-ECOM-UT-3564

@SYMTestCaseDesc	    Tests for verification of Interface implementation information with type 3 entries

@SYMTestPriority 	    High

@SYMTestActions  	    Parse the resource information associated with an

					    Interface Implementation Collection type 3 for entry into the registry

					    information.Check for OOM error or parse error.

@SYMTestExpectedResults CRegistrar::ParseL() function parses resource file without error.

						Data is interpreted correctly.

@SYMEC                  EC43

*/

void CRegistrarTest::ParseType3TestL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3564 "));

	TInt error = KErrNone;

	CPluginBase* entryBase = NULL;

	CRegistryData::CDllData* dllData = NULL;

	CRegistryData::CInterfaceData* ifData = NULL;

	CRegistryData::CDriveData* driveData = NULL;

	CRegistryData::CImplementationData* implData = NULL;

	CImplementationInformation* implInfo = NULL;

	//Tests an RSC based entry using EComExample12.dll and EComExample12.rsc

	//(EcomExample12.RSS)

	TEntry rscBasedEntry;

	rscBasedEntry.iName = KType3ResourceFileNameOnly;

	error = TheFs.Modified(KType3ResourceFileNameC, rscBasedEntry.iModified);

	test(error == KErrNone);

	TParse rscPath;

	rscPath.Set(KType3ResourceFileNameC,NULL,NULL);

	TDriveUnit driveUnit(rscPath.Drive());

	error = iRegistryData->FindDriveL(driveUnit,driveData);

	test(error != KErrNotFound);

	entryBase = CSecurePlugin::NewL(TheFs,rscBasedEntry,rscPath.Drive(), ETrue);

	CleanupStack::PushL(entryBase);

	dllData = CRegistryData::CDllData::NewLC(*(entryBase->iDllName),entryBase->iDllModifiedTime,entryBase->iDllSecondUid,entryBase->iDllThirdUid,driveData);

	// Tests the parseL function

	TRAP(error, iStateAccessor->ParseL(*iRegistrar,entryBase,*dllData));

	::LeaveIfErrNoMemory(error);

	test(error == KErrNone);

	// Checks the content of the DllData

	test(dllData->iIfList->Count() == 1);

	ifData = (*(dllData->iIfList))[0];

	test(ifData->iInterfaceUid == interfaceUidExample12);

	//Currently there are 3 implementations for this interface.

	//But the implementation(UID=0x10009E3D) is ROM-only but is actually in RAM will not be created.

	//So, actually number of implementations created for this interface is 2.

	test(ifData->iImplementations->Count() == 2);

	implData = (*(ifData->iImplementations))[0];

	implInfo = implData->iImplInfo;

	// Fetches the list of extended interfaces for the first implementation

	RArray<TUid>* extendedInterfaceList = implInfo->GetExtendedInterfaceList();

	test(extendedInterfaceList->Count()==3);

	test((*extendedInterfaceList)[0] == extendedInterfaceUid1);

	test((*extendedInterfaceList)[1] == extendedInterfaceUid2);

	test((*extendedInterfaceList)[2] == extendedInterfaceUid3);

	CleanupStack::PopAndDestroy(dllData);

	CleanupStack::PopAndDestroy(entryBase);

	}

/** Wrapper function for testing ParseL function with type 3 entries

and data in the resource file exceed maximum

*/

void CRegistrarTest::ParseBadDataTestL(const TDesC& aRscFullName, const TDesC& aRscNameOnly)

	{

	TInt error = KErrNone;

	CPluginBase* entryBase = NULL;

	CRegistryData::CDllData* dllData = NULL;

	CRegistryData::CDriveData* driveData = NULL;

	TEntry rscBasedEntry;

	rscBasedEntry.iName = aRscNameOnly;

	error = TheFs.Modified(aRscFullName, rscBasedEntry.iModified);

	test(error == KErrNone);

	TParse rscPath;

	rscPath.Set(aRscFullName,NULL,NULL);

	TDriveUnit driveUnit(rscPath.Drive());

	error = iRegistryData->FindDriveL(driveUnit,driveData);

	test(error != KErrNotFound);

	entryBase = CSecurePlugin::NewL(TheFs,rscBasedEntry,rscPath.Drive(), ETrue);

	CleanupStack::PushL(entryBase);

	dllData = CRegistryData::CDllData::NewLC(*(entryBase->iDllName),entryBase->iDllModifiedTime,entryBase->iDllSecondUid,entryBase->iDllThirdUid,driveData);

	//Tests the parseL function

	TRAP(error, iStateAccessor->ParseL(*iRegistrar,entryBase,*dllData));

	test(error == KErrNotSupported);

	CleanupStack::PopAndDestroy(dllData);

	CleanupStack::PopAndDestroy(entryBase);

	}

/**

@SYMTestCaseID          SYSLIB-ECOM-UT-3565

@SYMTestCaseDesc	    Tests for verification of Interface implementation information with type 3 entries

						and data in the resource file exceed maximum.

@SYMTestPriority 	    High

@SYMTestActions  	    Parse the resource information associated with an

					    Interface Implementation Collection type 3 for entry into the registry

					    information.

@SYMTestExpectedResults CRegistrar::ParseL() function parses resource file with KErrNotSupported leave occurs.

@SYMEC                  EC43

@SYMDEF                 DEF111196

*/

void CRegistrarTest::ParseType3BadDataTestL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3565 "));

	// Tests for number of strings of default data exceeds maximum

	// Uses EComExampleBadData.dll and EComExampleBadData.rsc (EcomExampleBadData.RSS)

	ParseBadDataTestL(KType3BadDataResourceFileNameC,KType3BadDataResourceFileNameOnly);

	// Tests for number of interfaces exceeds maximum

	// Uses EComExampleBadData1.dll and EComExampleBadData1.rsc (EcomExampleBadData1.RSS)

	ParseBadDataTestL(KType3BadData1ResourceFileNameC,KType3BadData1ResourceFileNameOnly);

	// Tests for number of implementation in one interfaces exceeds maximum

	// Uses EComExampleBadData2.dll and EComExampleBadData2.rsc (EcomExampleBadData2.RSS)

	ParseBadDataTestL(KType3BadData2ResourceFileNameC,KType3BadData2ResourceFileNameOnly);

	}

/**

@SYMTestCaseID		SYSLIB-ECOM-CT-0089

@SYMTestCaseDesc 	Check that the ParseL for spi data works correctly.

@SYMTestPriority 	High

@SYMTestActions  	Ensure ecomtest.spi can be parsed successfully

					and no leave occurs.

@SYMTestExpectedResults The test must not fail.

@SYMREQ REQ3655

*/

void CRegistrarTest::ParseSpiTestL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0089 "));

	TEntry spiEntry;

	TParse spiPath;

	if (TheFs.Entry(KEComSpiTestFilePathAndName, spiEntry) != KErrNone)

		return;

	spiPath.Set(KEComSpiTestFilePathAndName,NULL,NULL);

	RResourceArchive resourceArchive;

	resourceArchive.OpenL(TheFs, KEComSpiTestFilePathAndName);

	CleanupClosePushL(resourceArchive);

	// Checks SPI file type

	TUid type = resourceArchive.Type();

	test(type == KEcomSpiFileTypeUid);

	// there is only 1 resource file

	CPluginBase* entryBase=NULL;

	CRegistryData::CDllData* dllData=NULL;

	CRegistryData::CDriveData* driveData = NULL;

	TDriveUnit driveUnit(spiPath.Drive());

	TInt error=iRegistryData->FindDriveL(driveUnit,driveData);

	test(error!=KErrNotFound);

	while(!resourceArchive.End())

		{

		entryBase=CSpiPlugin::NewL(resourceArchive);

		CleanupStack::PushL(entryBase);

		dllData=CRegistryData::CDllData::NewLC(*(entryBase->iDllName),entryBase->iDllModifiedTime,entryBase->iDllSecondUid,entryBase->iDllThirdUid,driveData);

		TRAPD(err,iStateAccessor->ParseL(*iRegistrar,entryBase,*dllData));

		::LeaveIfErrNoMemory(err);

		test(err == KErrNone);

		CleanupStack::Pop(dllData);

		CleanupStack::PopAndDestroy(entryBase);

		entryBase=NULL;

		}