// 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 CRegistryData. Where necessary stubs

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

 // Test can fail if the Registry Index files are corrupted or missing.

 // To solve that problem we need to run some component test harness, which

 // runs by linking against ECom.lib. like t_listimplementation or t_suicide.

 // 

 //

 #include <ecom/ecom.h>

 #include "EComUidCodes.h"

 #include "RegistrarObserver.h"

 #include "RegistryData.h"

 #include "Registrar.h"

 #include "EComResolverParams.h"

 #include "Discoverer.h"

 #include "DiscovererObserver.h"

 #include "DriveInfo.h"

 #include "DowngradePath.h"

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

 #include "RegistryResolveTransaction.h"

 #include "ParseImplementationData.h"

 #include <ecom/ecompanics.h>

 #include <s32file.h>

 #include <e32test.h>

 #include <f32file.h>

 #include <bautils.h>

 #include <babackup.h>

 #include <hal.h>

 #define UNUSED_VAR(a) a = a

 // Used within tests

 const TUid KCExampleInterfaceUid = {0x10009DC0};

 const TUid KCExampleInterfaceImp = {0x10009DC3};

 const TUid KCDummyUid = {0x00000000};

 const TUid KCInvalidUid = {0x10009999};

 const TInt KOneSecond = 1000000;

 // Used for suppressing warning in OOM tests

 #define __UNUSED_VAR(var) var = var

 // Used for OOM test

 #define TEST_OOM_ERR if(err == KErrNoMemory) User::Leave(err)

 // The implemented structure for the registry data

 typedef CRegistryData::CImplementationData* CImplementationDataPtr;

 typedef RArray<CImplementationDataPtr> RImplDataArray;

 // Test plugins and corresponding .rsc files that be copied to RAM for testing purpose

 _LIT(KEComExDllOnZ,		"Z:\\RAMOnly\\EComExample5.dll");

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

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

 _LIT(KEComRscFileOnZ,	"Z:\\RAMOnly\\EComExample5.rsc");

 _LIT(KEComExampleDllOnC,		"C:\\sys\\bin\\EComExample.dll");

 _LIT(KEComExampleDllOnZSysBin,	"Z:\\sys\\bin\\EComExample.dll");

 _LIT(KEComExample2DllOnC,		"C:\\sys\\bin\\EComExample2.dll");

 _LIT(KEComExample3DllOnC,		"C:\\sys\\bin\\EComExample3.dll");

 _LIT(KEComExampleRscOnC,		"C:\\resource\\plugins\\EComExample.rsc");

 _LIT(KEComExample2RscOnC,		"C:\\resource\\plugins\\EComExample2.rsc");

 _LIT(KEComExample3RscOnC,		"C:\\resource\\plugins\\EComExample3.rsc");

 _LIT(KEComExampleRscOnZ,		"Z:\\RAMOnly\\EComExample.rsc");

 _LIT(KEComExample2RscOnZ,		"Z:\\RAMOnly\\EComExample2.rsc");

 _LIT(KEComExample3RscOnZ,		"Z:\\RAMOnly\\EComExample3.rsc");

 _LIT(KEComExampleDllOnZ,			"Z:\\RAMOnly\\EComExample.dll");

 _LIT(KEComExample2DllOnZ,		"Z:\\RAMOnly\\EComExample2.dll");

 _LIT(KEComExample3DllOnZ,		"Z:\\RAMOnly\\EComExample3.dll");

 // These RSC files/DLLs are used to test an RSC file with a SID that does not

 // match it's corresponding DLL. The implementations should not be listed/created.

 _LIT(KEComInvalidDllOnZ, "z:\\RAMOnly\\InvalidSIDPlugin.dll");

 _LIT(KEComInvalidRscOnZ, "z:\\RAMOnly\\InvalidSIDPlugin.rsc");

 _LIT(KEComInvalidDllOnC, "c:\\sys\\bin\\InvalidSIDPlugin.dll");

 _LIT(KEComInvalidRscOnC, "c:\\resource\\plugins\\InvalidSIDPlugin.rsc");

 // This DLL does not exist, and should fail a security check

 _LIT(KEComMissingDll, "c:\\sys\\bin\\NonExistentDllName.dll");

 // These RSC files/DLLs are used to test an RSC file that points to a missing DLL

 _LIT(KMissingDllRomRscFile, 		"z:\\RAMOnly\\EComRomRslvrExampleOnC.rsc");

 _LIT(KMissingDllRamRscFile, 		"c:\\resource\\plugins\\EComRomRslvrExampleOnC.rsc");

 // When the above RSC file's security check fails, the following implementations should be rolled back to

 // (even though the filenames are EComRomRslvrExampleOnZ they will be copied to and exist on C Drive)

 _LIT(KRollbackForMissingDllRomDllFile, 			"z:\\RAMOnly\\EComRomRslvrExampleOnZ.dll");

 _LIT(KRollbackForMissingDllRamDllFile, 			"c:\\sys\\bin\\EComRomRslvrExampleOnZ.dll");

 _LIT(KRollbackForMissingDllRomRscFile, 			"z:\\RAMOnly\\EComRomRslvrExampleOnZ.rsc");

 _LIT(KRollbackForMissingDllRamRscFile, 			"c:\\resource\\plugins\\EComRomRslvrExampleOnZ.rsc");

 //PLUGIN1 DLL with interfaceID: 0x10009E36

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

 _LIT(KEComExample14DllOnZ,		"Z:\\RAMOnly\\EComExample14.dll");

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

 _LIT(KEComExample14RscOnZ,		"Z:\\RAMOnly\\EComExample14.rsc");

 //PLUGIN3 DLL with interfaceID: 0x10009E36, implementation version 2

 _LIT(KEComExample15DllOnC,		"C:\\sys\\bin\\EComExample15.dll");

 _LIT(KEComExample15DllOnZ,		"Z:\\RAMOnly\\EComExample15.dll");

 _LIT(KEComExample15RscOnC,		"C:\\resource\\plugins\\EComExample15.rsc");

 _LIT(KEComExample15RscOnZ,		"Z:\\RAMOnly\\EComExample15.rsc");

 //PLUGIN3 DLL with interfaceID: 0x10009E36

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

 _LIT(KEComExample12DllOnZ,		"Z:\\RAMOnly\\EComExample12.dll");

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

 _LIT(KEComExample12RscOnZ,		"Z:\\RAMOnly\\EComExample12.rsc");

 _LIT(KEComExample10DllOnC,		"C:\\sys\\bin\\EComExample10.dll");

 //PLUGIN3 Upgraded

 _LIT(KEcomExample12UpgradedOnC, "C:\\resource\\plugins\\EComExample12Upgraded.rsc");

 _LIT(KEcomExample12UpgradedOnZ, "Z:\\RAMOnly\\EComExample12Upgraded.rsc");

 _LIT(KEcomExample12UpgradedResourceNameOnly, "EComExample12Upgraded.rsc");

 //PLUGIN1 Upgraded to PLUGIN3

 _LIT(KEcomExample14UpgradedOnC, "C:\\resource\\plugins\\EComExample14Upgraded.rsc");

 _LIT(KEcomExample14UpgradedOnZ, "Z:\\RAMOnly\\EComExample14Upgraded.rsc");

 _LIT(KEcomExample14UpgradedResourceNameOnly, "EComExample14Upgraded.rsc");

 //PLUGIN3 Downgraded to PLUGIN1

 _LIT(KEcomExample12DowngradedOnC, "C:\\resource\\plugins\\EComExample12Downgraded.rsc");

 _LIT(KEcomExample12DowngradedOnZ, "Z:\\RAMOnly\\EComExample12Downgraded.rsc");

 _LIT(KEcomExample12DowngradedResourceNameOnly, "EComExample12Downgraded.rsc");

 _LIT(KDriveC, "C");

 #ifndef SYMBIAN_DISTINCT_LOCALE_MODEL

     _LIT(KEnglishLocale, "elocl.01");

     _LIT(KEComSpanishLocale, "elocl.04");

 #else

     // refer base/os/kernelhwsrv/kernel/eka/euser/locmapping.cpp

     // Language

     _LIT(KEComEnglishLang,"elocl_lan.001");

     //_LIT(KEComFrenchLang,"elocl_lan.002");

     //_LIT(KEComGermanLang,"elocl_lan.003");

     _LIT(KEComSpanishLang,"elocl_lan.004");

     // Region

     _LIT(KEComEnglishReg,"elocl_reg.826");

     //_LIT(KEComFrenchReg,"elocl_reg.250");

     //_LIT(KEComGermanReg,"elocl_reg.276");

     _LIT(KEComSpanishReg,"elocl_reg.724");

     // Collation

     _LIT(KEComEnglishColl,"elocl_col.001");

     //_LIT(KEComFrenchColl,"elocl_col.002");

     //_LIT(KEComGermanColl,"elocl_col.003");

     _LIT(KEComSpanishColl,"elocl_col.001");

 #endif

 LOCAL_D CTrapCleanup*		TheTrapCleanup=NULL;

 LOCAL_D CActiveScheduler*	TheActiveScheduler=NULL;

 LOCAL_D RFs					TheFs;

 LOCAL_D RTest				TheTest(_L("t_registrydata.exe"));

 //TPtrC defined which will point to KEComSpiFilePathAndName or KEComSpiFilePathAndNameForNand

 //according to the rom build type

 LOCAL_D TPtrC				TheEComSpiFilePathAndNamePtrC;

 TCapabilitySet dummycaps;

 LOCAL_C void CopyPluginsL();

 inline LOCAL_C void DeleteTestPlugin()

 	{

 	TRAPD(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComExDllOnC));

 	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComRscFileOnC));

  	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComExampleDllOnC));

  	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComExample2DllOnC));

  	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComExample3DllOnC));

  	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComExampleRscOnC));

  	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComExample2RscOnC));

  	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComExample3RscOnC));

  	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComInvalidDllOnC));

  	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComInvalidRscOnC));

  	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KMissingDllRamRscFile));

  	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KRollbackForMissingDllRamDllFile));

  	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KRollbackForMissingDllRamRscFile));

  	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComExample12DllOnC));

  	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComExample12RscOnC));

  	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComExample14DllOnC));

  	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComExample14RscOnC));

  	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComExample15DllOnC));

  	TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComExample15RscOnC));

 	}

 //

 //

 //Test macroses and functions

 LOCAL_C void Check(TInt aValue, TInt aLine)

 	{

 	if(!aValue)

 		{

 		::DeleteTestPlugin();

 		TheTest(EFalse, aLine);

 		}

 	}

 LOCAL_C void Check(TInt aValue, TInt aExpected, TInt aLine)

 	{

 	if(aValue != aExpected)

 		{

 		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

 		::DeleteTestPlugin();

 		TheTest(EFalse, aLine);

 		}

 	}

 /**

 Sets up the system-wide locale and language downgrade path.

 */

 LOCAL_C void SetLanguageL(const TLanguage aLang[3])

 	{

 	TLocale locale;

 	locale.SetLanguageDowngrade(0, aLang[0]);

 	locale.SetLanguageDowngrade(1, aLang[1]);

 	locale.SetLanguageDowngrade(2, aLang[2]);

 	User::LeaveIfError(locale.Set());

 	}

 #define TEST(arg) ::Check((arg), __LINE__)

 #define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

 //

 //

 /**

 This class allows us to provide stub behavior to instantiate CRegistrar

 */

 class TRegistrarObserverStub : public MRegistrarObserver

 	{

 public:

 /**

 The overloaded method from the MRegistrarObserver class Used for firing

 notifications to the client sessions that the underlying registry data has changed.

 @post		The CEComServer has notified all its client sessions

 			registered for notifications that the data changed

 */

 	void Notification(TInt aNotificationCode)

 		{

 		RDebug::Print(_L("TRegistrarObserverStub called with notification code %d.\n"), aNotificationCode);

 		};

 	};

 /**

 This friend class allows us to access private and protected members of production

 code class CDiscoverer.

 */

 class TDiscoverer_StateAccessor

 	{

 public:

 	TDiscoverer_StateAccessor() {};

 	void ScanDirectoryL(CDiscoverer& aDiscoverer)

 		{

 		aDiscoverer.ProcessSSAEventL(EStartupStateNonCritical);

 		}

 	void ScanDriveL(CDiscoverer& aDiscoverer, TDriveUnit& aDrive)

 		{

 		TBool isRO = aDiscoverer.iCachedDriveInfo->DriveIsReadOnlyInternalL(aDrive);

 		aDiscoverer.iDirScanner->ScanDriveL(aDrive, isRO);

 		}

 	};

 /**

 This friend class allows us to access private and protected members of production

 code class CRegistrar.

 */

 class TRegistrar_StateAccessor

 	{

 public:

 	TRegistrar_StateAccessor() {};

 	void ScanDirectoryL(CRegistrar& aRegistrar)

 		{

 		TDiscoverer_StateAccessor discovererStateAccessor;

 		discovererStateAccessor.ScanDirectoryL(*(aRegistrar.iDiscoverer));

 		}

 	void ScanDriveL(CRegistrar& aRegistrar, TDriveUnit& aDrive)

 		{

 		TDiscoverer_StateAccessor discovererStateAccessor;

 		discovererStateAccessor.ScanDriveL(*(aRegistrar.iDiscoverer), aDrive);

 		}

 	void ParseL(CRegistrar& aRegistrar, CPluginBase*& aEntry,CRegistryData::CDllData& aDll);

 	};

 void TRegistrar_StateAccessor::ParseL(CRegistrar& aRegistrar, CPluginBase*& aEntry,CRegistryData::CDllData& aDll)

 		{

 		aRegistrar.ParseL(aEntry,aDll);

 		}

 /**

 This friend class allows us to access private and protected members of production

 code class CRegistryData.

 */

 class TRegistryData_StateAccessor

 	{

 public:

 	TBool IsIndexValid(CRegistryData& aRegData);

 	TInt IndexedFind(CRegistryData& aRegData, const TUid& aImplementationUid);

 	TBool IsRegisteredDriveL(CRegistryData& aRegData, TDriveUnit aDriveUnit);

 	TInt RegistrationsCount(CRegistryData& aRegData);

 	TInt ImplementationsCount(CRegistryData& aRegData);

 	void SetRegistryChanged(CRegistryData& aRegData, TBool aChanged, TDriveUnit aDrive);

 	void ClearImplementationIndexList(CRegistryData& aRegData);

 	void ClearRegistrations(CRegistryData& aRegData);

 	void ResetAndDestroy(CRegistryData& aRegData);

 	void ConstructL(CRegistryData& aRegData);

 	TBool FindAnImplementation(CRegistryData& aRegData, TUid& aInterfaceUid, TDriveUnit& aDrive);

 	void GetImplementationInfoL(CRegistryData& aRegData, TUid& aInterfaceUid, RImplDataArray& aImplementationInfo);

 	void AppendDriveDataL(CRegistryData& aRegData, CRegistryData::CDriveData* aDriveData);

 	TInt FindImplementation(CRegistryData& aRegData, const TUid aImplUid, const TUid aInterfaceUid,

 										CRegistryData::CImplementationData*& aImplData) const;

 	static void ResetStaticDriveData();

 	TInt GetDllListL(CRegistryData& aRegistryData, TDriveUnit aDriveUnit, TDll*& aDllList);

 	TBool IsLanguageInitChanged(CRegistryData& aRegistryData);

 	TInt DrivesRemoved(CRegistryData& aRegistryData);

 	};

 /**

 Constructs the registry

 */

 void TRegistryData_StateAccessor::ConstructL(CRegistryData& aRegData)

 	{

 	aRegData.ConstructL();

 	}

 /**

 Resets the registry

 */

 void TRegistryData_StateAccessor::ResetAndDestroy(CRegistryData& aRegData)

 	{

 	aRegData.iRegistrations->ResetAndDestroy();

 	delete aRegData.iRegistrations;

 	}

 /**

 Clears the Implementations

 @param		aRegData RegistryData object under test

 */

 void TRegistryData_StateAccessor::ClearImplementationIndexList(CRegistryData& aRegData)

 	{

 	for(TInt index = 0; index < aRegData.iInterfaceImplIndex.Count(); ++index)

 		{

 		aRegData.iInterfaceImplIndex[index].Reset();

 		}

 	aRegData.iInterfaceImplIndex.Reset();

 	aRegData.iImplIndex.Reset();

 	}

 /**

 Clears the Registrations

 @param		aRegData RegistryData object under test

 */

 void TRegistryData_StateAccessor::ClearRegistrations(CRegistryData& aRegData)

 	{

 	if(aRegData.iRegistrations)

 		{

 		aRegData.iRegistrations->ResetAndDestroy();

 		}

 	}

 /**

 Indicates whether the registry index is currently valid. The

 index will not be valid if discoveries are currently taking place.

 @param		aRegData RegistryData object under test

 @return		ETrue if index is valid EFalse otherwise

 */

 TBool TRegistryData_StateAccessor::IsIndexValid(CRegistryData& aRegData)

 	{

 	return aRegData.IndexValid();

 	}

 /**

 Tries to find the index entry of the passed implementation uid

 @param		aRegData RegistryData object under test

 @param		aImplementationUid the implementation Uid of the implementation to locate

 @return		Index of the implementation, KErrNotFound otherwise

 */

 TInt TRegistryData_StateAccessor::IndexedFind(CRegistryData& aRegData,

 											  const TUid& aImplementationUid)

 	{

 	return aRegData.IndexedFind(aImplementationUid);

 	}

 /**

 Checks if the drive is already registered

 @param		aRegData RegistryData object under test

 @param		aDriveUnit the drive on which plugins are registered

 @return		ETrue if drive is registered, EFalse otherwise

 */

 TBool TRegistryData_StateAccessor::IsRegisteredDriveL(CRegistryData& aRegData,

 													 TDriveUnit aDriveUnit)

 	{

 	TInt driveIndex = KErrNotFound;

 	CRegistryData::CDriveData* aDriveData=NULL;

 	driveIndex = aRegData.FindDriveL(aDriveUnit, aDriveData);

 	// Return True if the driveindex has some valid value i.e. not KErrNotFound

 	return (driveIndex != KErrNotFound);

 	}

 /**

 Obtains count of plugin registrations

 @param		aRegData RegistryData object under test

 @return		Number of registrations

 */

 TInt TRegistryData_StateAccessor::RegistrationsCount(CRegistryData& aRegData)

 	{

 	return aRegData.iRegistrations->Count();

 	}

 /**

 Obtains count of plugin registrations

 @param		aRegData RegistryData object under test

 @return		Number of registrations

 */

 TInt TRegistryData_StateAccessor::ImplementationsCount(CRegistryData& aRegData)

 	{

 	return aRegData.iInterfaceImplIndex.Count();

 	}

 /**

 Sets Registry Changed flag to the given value

 @param		aRegData RegistryData object under test

 @param		aChanged True if the registry is changed

 @param		aDrive the drive under test

 */

 void TRegistryData_StateAccessor::SetRegistryChanged(CRegistryData& aRegData, TBool aChanged, TDriveUnit aDrive)

 	{

 	for(TInt i = 0; i <aRegData.iRegistrations->Count(); i++)

 		{

 		if ((*aRegData.iRegistrations)[i]->iDrive == aDrive)

 			{

 			(*aRegData.iRegistrations)[i]->iRegistryChanged = aChanged;

 			}

 		}

 	}

 /**

 See if an implementation is discovered on the questioned drive

 @param		aRegData RegistryData object under test

 @param		aInterfaceUid Interface UID for the implementation

 @param		aDrive Drive to search the implementation on

 @return 	ETrue if an implementation exists

 */

 TBool TRegistryData_StateAccessor::FindAnImplementation(CRegistryData& aRegData, TUid& aInterfaceUid, TDriveUnit& aDrive)

 	{

 	const TInt driveCount = aRegData.iRegistrations->Count();

 	for(TInt driveIndex = 0; driveIndex < driveCount; ++driveIndex)

 		{

 		CRegistryData::CDriveData* driveData = (*aRegData.iRegistrations)[driveIndex];

 		if(driveData->iDrive == aDrive)

 			{

 			TDll* dllList = (*aRegData.iRegistrations)[driveIndex]->iDllList;

 			const TInt dllCount = dllList->Count();

 			for(TInt dllIndex = 0; dllIndex < dllCount;++dllIndex)

 				{

 				// For each dll structure

 				RInterfaceList* interfaceList = (*dllList)[dllIndex]->iIfList;

 				const TInt ifCount = interfaceList->Count();

 				for(TInt ifIndex = 0; ifIndex < ifCount; ++ifIndex)

 					{

 					CRegistryData::TInterfaceIndex index;

 					// For each interface structure

 					TUid interfaceUid = (*interfaceList)[ifIndex]->iInterfaceUid;

 					if(interfaceUid == aInterfaceUid)

 						{

 						return ETrue;

 						}

 					}

 				}

 			}

 		}

 	return EFalse;

 	}

 /**

 Get implementation info from the index

 @param		aRegData RegistryData object under test

 @param		aInterfaceUid Interface UID for the implementation

 @param  	aImplementationData Reference of array of Implementation Data

 */

 void TRegistryData_StateAccessor::GetImplementationInfoL(CRegistryData& aRegData, TUid& aInterfaceUid, RImplDataArray& aImplementationData)

 	{

 	aRegData.ListImplementationsL(aInterfaceUid, aImplementationData);

 	}

 /**

 Append DriveSata to iRegistrations

 @param		aRegData RegistryData object under test

 @param		aInterfaceUid Interface UID for the implementation

 @return 	Array of Implementations

 */

 void TRegistryData_StateAccessor::AppendDriveDataL(CRegistryData& aRegData, CRegistryData::CDriveData* aDriveData)

 	{

 	aRegData.iRegistrations->AppendL(aDriveData);

 	}

 /**

 @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.

 @return		KErrNone if found otherwise KErrNotFound

 */

 TInt TRegistryData_StateAccessor::FindImplementation(CRegistryData& aRegistryData,

 												const TUid aImplUid,

 												const TUid aInterfaceUid,

 												CRegistryData::CImplementationData*& aImplData) const

 	{

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

 	}

 /**

 @param		aRegistryData The CRegistryData class object

 @param		aDriveUnit A drive unit

 @param		aDllList The dll list returned on a specified drive.

 @return		Index of the specified drive in registryData if found otherwise KErrNotFound

 */

 TInt TRegistryData_StateAccessor::GetDllListL(CRegistryData& aRegistryData, TDriveUnit aDriveUnit, TDll*& aDllList)

 {

 	CRegistryData::CDriveData* drive =NULL;

 	// Get the drive data in the registry.

 	TInt registryDriveIndex = aRegistryData.FindDriveL(aDriveUnit, drive);

 	if(registryDriveIndex != KErrNotFound)

 		{

 		aDllList = (*aRegistryData.iRegistrations)[registryDriveIndex]->iDllList;

 		}

 	return registryDriveIndex;

 }

 /**

 Indicates whether the language downgrade path has been changed during start-up time.

 @param		aRegData RegistryData object under test

 @return		ETrue if index is valid EFalse otherwise

 */

 TBool TRegistryData_StateAccessor::IsLanguageInitChanged(CRegistryData& aRegistryData)

 {

 	return aRegistryData.iLanguageChanged;

 }

 TInt TRegistryData_StateAccessor::DrivesRemoved(CRegistryData& aRegistryData)

 	{

 		return aRegistryData.iRemovedDrives;

 	}

 /** class to hold all the data required to create an instance of

 CRegistryData::CImplementationData.

 NB: the pointers in this struct are all owned by some other objects.

 */

 _LIT8(KDefaultImplDataType, "Data Type");

 _LIT8(KDefaultImplOpaqueData, "");

 struct TImplCreationStruct

 	{

 	TImplCreationStruct(TDriveNumber aDriveNumber,

 						TUid  aInterfaceUid,

 						TUid  aImplUid,

 						const TDesC& aDllPathName,

 						const TDesC& aImplDisplayName,

 						const TDesC8& aImplDataType = KDefaultImplDataType,

 						const TDesC8& aImplOpaqueData = KDefaultImplOpaqueData,

 						TInt  aImplVersion = 1,

 						TBool aRomBased = EFalse,

 						TBool aRomOnly = EFalse);

 	TDriveUnit		iDriveUnit;

 	TUid			iInterfaceUid;

 	TUid			iImplUid;

 	const TDesC&	iDllPathName;

 	const TDesC&	iImplDisplayName;

 	const TDesC8&	iImplDataType;

 	const TDesC8&	iImplOpaqueData;

 	TInt			iDriveIndex;

 	CRegistryData::CDriveData*		iDriveData;

 	CRegistryData::CDllData*		iDllData;

 	CRegistryData::CInterfaceData*	iInterfaceData;

 	CRegistryData::CImplementationData* iImplData;

 	TInt			iImplVersion;

 	TBool			iRomBased;

 	TBool			iRomOnly;

 	};

 // TImplCreationStruct Constructor

 TImplCreationStruct::TImplCreationStruct(TDriveNumber aDriveNumber,

 										TUid  aInterfaceUid,

 										TUid  aImplUid,

 										const TDesC& aDllPathName,

 										const TDesC& aImplDisplayName,

 										const TDesC8& aImplDataType,

 										const TDesC8& aImplOpaqueData,

 										TInt  aImplVersion,

 										TBool aRomBased,

 										TBool aRomOnly)

 	: iDriveUnit(aDriveNumber), iInterfaceUid(aInterfaceUid),

 	iImplUid(aImplUid), iDllPathName(aDllPathName),

 	iImplDisplayName(aImplDisplayName), iImplDataType(aImplDataType),

 	iImplOpaqueData(aImplOpaqueData), iDriveIndex(KErrNotFound),

 	iDriveData(NULL), iDllData(NULL), iInterfaceData(NULL),

 	iImplData(NULL), iImplVersion(aImplVersion), iRomBased(aRomBased),

 	iRomOnly(aRomOnly)

 	{

 	}

 /**

 Test class encloses necessary members that aid to test CRegistryData

 */

 class CRegistryDataTest: public CBase

 	{

 public:

 	static CRegistryDataTest* NewL(TBool aIsFullDiscovery);

 	virtual ~CRegistryDataTest();

 	void AddDllDataPlugIn3TestL();

 	void AddDllDataTestL();

 	void IsRegisteredWithDateUpdateDllDataTestL();

 	void CopyOrgPlugInL();

 	void UpdateDllDataTest1L();

 	void UpdateDllDataTest2L();

 	void UpdateDllDataTest3L();

 	void SetEnabledStateTestL();

 	void FindImplementationTestL();

 	//Test for ListImplementationsL() in CRegistryData

 	void ListImplementationsL();

 	//Test for ListImplementationsL() in CRegistryResolverTransaction

 	void ListImplementationsTestT1L();

 	void ListImplementationsTestT2L();

 	void ListImplementationsTestT3L();

 	void ListImplementationsTestT4L();

 	void ListImplementationsTestT5L();

 	//Test for ListExtendedInterfacesL() in CRegistryData

 	void ListExtendedInterfacesTestL();

 	void DoUndoTemporaryUninstallTestL();

 	void DiscoveriesBeginCompleteTestL();

 	void IndexedFindTestL();

 	void GetImplementationDllInfoForServerTest();

 	void GetImplementationDllInfoForClientTestL();

 	void GetImplementationDllInfoForServerPlugIn3Test();

 	void GetImplementationDllInfoForClientPlugIn3TestL();

 	void VerifySelectNewPluginTypeL();

 	void AllAtOnceDiscoveryStateTransitionTestL();

 	void StagedDiscoveryStateTransitionTestL();

 	void ImplementationDataTestL();

 	void InsertIntoIndexRemoveFromIndexTestL();

 	void RollbackTestL();

 	void ProcessSecurityCheckTestL();

 	void FailedSecurityCheckTestListImplementationsL();

 	void FailedSecurityCheckTestGetImplementationInfoL();

 	void IsAnyDllDiscoveredTestL();

 	void IsAnyDllDiscoveredTestNoSpiL();

 	void IsAnyDllDiscoveredTestWithSpiL();

 	void CheckDuplicatPluginsOnCL();

 	void CheckNoPluginsOnCL();

 	void DuplicateImplUidTestL();

 	void TestDuplicatedImplPrecedenceL(const TImplCreationStruct& highprecedence,

 									const TImplCreationStruct& lowprecedence);

 	static TBool SpiFileExists();

 	void LanguageChangedTestL();

 	void DrivesRemovedTestL();

 private:

 	CRegistryDataTest();

 	void ConstructL(TBool aIsFullDiscovery);

 	void CreateImplL(TImplCreationStruct& aCreationData);

 public:

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

 	CRegistryData*						iRegistryData;

 	/** Registrar observer test class */

 	TRegistrarObserverStub* iRegistrarObserver;

 	/** CRegistrar required for populating the CRegistryData */

 	CRegistrar*							iRegistrar;

 	/** CRegistrar state accessor */

 	TRegistrar_StateAccessor* iRegistrarAccessor;

 	/** A list of returned UIDs from the list methods */

 	RImplInfoArray*						iUidList;

 	/** A list of implementation data from the list methods */

 	RImplDataArray						iImplDataList;

 	/** Friend class pointer used for accessing private members */

 	TRegistryData_StateAccessor*		iStateAccessor;

 	/** The current drive unit identifier */

 	TDriveUnit							iDriveUnit;

 	/** UID for an implementation of an interface */

 	TUid								iImplementationUid;

 	/** UID to identify a particular interface */

 	TUid								iInterfaceUid;

 	/** The directory entry data for a dll */

 	TEntry								iDllEntry;

 	/** Flag to indicate if the registry entry requires an update */

 	TBool								iUpdate;

 	/** The drive index returned by IsRegistered... so we know which drive to update on */

 	TInt								iFoundDriveIndex;

 	};

 /**

 Creates a new CRegistryDataTest object

 @param		aIsFullDriveCDiscovery whether the constructor make full discovery on Drive C

 @return		A pointer to the newly created class.

 */

 CRegistryDataTest* CRegistryDataTest::NewL(TBool aIsFullDriveCDiscovery)

 	{

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

 	CleanupStack::PushL(self);

 	self->ConstructL(aIsFullDriveCDiscovery);

 	CleanupStack::Pop();

 	return self;

 	}

 /**

 Standardized default constructor

 @post		CRegistryDataTest is fully constructed.

 */

 CRegistryDataTest::CRegistryDataTest()

 :	CBase()

 	{

 	iDriveUnit = EDriveC;

 	TUid thirdUid = {0x101F847B};

 	iDllEntry.iType = TUidType(KNullUid, KNullUid, thirdUid);

 	iDllEntry.iName = KEComExDllOnC;

 	iInterfaceUid.iUid		= KCExampleInterfaceUid.iUid;

 	iImplementationUid.iUid	= KCExampleInterfaceImp.iUid;

 	}

 /**

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

 Completes the safe construction of the CRegistryDataTest object

 @param		aIsFullDriveCDiscovery whether the constructor make full discovery on Drive C

 @post		CRegistryDataTest is fully constructed.

 @leave		KErrNoMemory.

 */

 void CRegistryDataTest::ConstructL(TBool aIsFullDriveCDiscovery)

 	{

 	iUidList = new(ELeave) RImplInfoArray;

 	iStateAccessor= new(ELeave) TRegistryData_StateAccessor;

 	iRegistryData = CRegistryData::NewL(TheFs);

 	iRegistrarObserver=new (ELeave) TRegistrarObserverStub;

 	iRegistrarAccessor=new (ELeave) TRegistrar_StateAccessor;

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

 	if (aIsFullDriveCDiscovery)

 		{

 		TDriveUnit driveUnitC = EDriveC;

 		iRegistrarAccessor->ScanDriveL(*iRegistrar,driveUnitC);

 		}

 	}

 /**

 Standard destructor

 */

 CRegistryDataTest::~CRegistryDataTest()

 	{

 	delete iUidList;

 	delete iStateAccessor;

 	delete iRegistrarAccessor;

 	delete iRegistrar;

 	delete iRegistrarObserver;

 	delete iRegistryData;

 	}

 /**

  @return ETrue if the ECom.spi file exists on Z drive, EFalse if it does not

 */

 TBool CRegistryDataTest::SpiFileExists()

 	{

 	TEntry entry;

 	if (TheFs.Entry(TheEComSpiFilePathAndNamePtrC, entry) == KErrNone)

 		{

 		return ETrue;

 		}

 	return EFalse;

 	}

 /**

 @SYMTestCaseID          SYSLIB-ECOM-UT-3712

 @SYMTestCaseDesc	    Tests for AddExtendedInterfaceL when adding duplicate extended interface Uid.

 @SYMTestPriority 	    High

 @SYMTestActions  	    Call CImplementationInformation::AddExtendedInterfaceL() with duplicate extended

 						interface Uid.

 						AddExtendedInterfacePanicL() and ThreadPanicTest() are used for this test case.

 @SYMTestExpectedResults Ensure that the AddExtendedInterfaceL panics in debug mode, but duplicate extended

 						interface is ignored in release mode.

 @SYMDEF                 DEF111196

 */

 LOCAL_C void AddExtendedInterfaceTestL()

 	{

 	// Test Starts...

 	TUid testImplUid;

 	testImplUid.iUid = KCExampleInterfaceUid.iUid;

 	TInt testImplVersion = 2;

 	_LIT(KTestImplName, "Implementation");

 	_LIT8(KTestImplDataType, "Data Type");

 	_LIT8(KTestImplOpaqueData, "Opaque Data");

 	TUid testExtendedInterfaceUid1;

 	TUid testExtendedInterfaceUid2;

 	testExtendedInterfaceUid1.iUid = 0x10009E44;

 	testExtendedInterfaceUid2.iUid = 0x10009E45;

 	TDriveUnit testImplDrive = EDriveC;

 	TBool testImplRomOnly = ETrue;

 	TBool testImplRomBased = EFalse;

 	CRegistryData* registryData = CRegistryData::NewL(TheFs);

 	CleanupStack::PushL(registryData);

 	CRegistryData::CDriveData* driveData = CRegistryData::CDriveData::NewLC(testImplDrive, registryData);

 	CRegistryData::CDllData* dllData = CRegistryData::CDllData::NewLC(driveData);

 	CRegistryData::CInterfaceData* interfaceData = CRegistryData::CInterfaceData::NewLC(dllData);

 	// NewL test

 	HBufC* name = KTestImplName().AllocLC();

 	HBufC8* dataType = KTestImplDataType().AllocLC();

 	HBufC8* opaqueData = KTestImplOpaqueData().AllocLC();

 	RArray<TUid>* extendedInterfaces = new(ELeave) RArray<TUid>;

 	CleanupStack::PushL(TCleanupItem(CloseAndDeleteArray, extendedInterfaces));

 	CRegistryData::CImplementationData* implementationData;

 	implementationData = CRegistryData::CImplementationData::NewL(interfaceData,

 															testImplUid,

 															testImplVersion,

 															name,

 															dataType,

 															opaqueData,

 															testImplDrive,

 															testImplRomOnly,

 															testImplRomBased,

 															extendedInterfaces);

 	CleanupStack::Pop(extendedInterfaces);

 	CleanupStack::Pop(opaqueData);

 	CleanupStack::Pop(dataType);

 	CleanupStack::Pop(name);

 	CleanupStack::PushL(implementationData);

 	TEST(interfaceData == implementationData->iParent);

 	//Add extended interface

 	implementationData->iImplInfo->AddExtendedInterfaceL(testExtendedInterfaceUid1);

 	implementationData->iImplInfo->AddExtendedInterfaceL(testExtendedInterfaceUid2);

 	const RArray<TUid>* extendedInterfacesList = implementationData->iImplInfo->GetExtendedInterfaceList();

 	TEST(extendedInterfacesList->Count() == 2);

 	RDebug::Printf("Number of extended interfaces = %d",extendedInterfacesList->Count());

 	// Add duplicate extended interface, will panic in debug mode, but duplicate extended interface

 	// is ignored in release mode

 	implementationData->iImplInfo->AddExtendedInterfaceL(testExtendedInterfaceUid2);

 #ifdef NDEBUG

 	const RArray<TUid>* extendedInterfacesList1 = implementationData->iImplInfo->GetExtendedInterfaceList();

 	TEST(extendedInterfacesList1->Count() == 2);

 	RDebug::Printf("Number of extended interfaces after adding duplicate extended interface = %d",extendedInterfacesList->Count());

 #endif

 	// Tidy up

 	CleanupStack::PopAndDestroy(5, registryData);

 	// Test Ends...

 	}

 LOCAL_C TInt AddExtendedInterfacePanicL(TAny*)

 	{

 	__UHEAP_MARK;

 	CTrapCleanup* threadcleanup = CTrapCleanup::New();

 	TRAPD(err,AddExtendedInterfaceTestL());

 	TEST(err==KErrNone);

 	delete threadcleanup;

 	__UHEAP_MARKEND;

 	return KErrNone;

 	}

 /**

 The test code is used for capturing the PANIC that occurs as a result of calling AddExtendedInterfaceL

 with duplicate extended interface Uid .

 */

 LOCAL_C void ThreadPanicTest(const TDesC& aName,TThreadFunction aFunction)

 	{

 	TRequestStatus threadStatus;

 	RThread thread;

 	TBool jit;

 	jit=User::JustInTime();

 	User::SetJustInTime(EFalse);

 	// Default stack size was doubled for X86, so reduce this multiplier to prevent panic

 #ifdef __X86GCC__

 	TInt err=thread.Create(aName,aFunction,KDefaultStackSize*4,KMinHeapSize,0x100000,0);

 #else

 	TInt err=thread.Create(aName,aFunction,KDefaultStackSize*8,KMinHeapSize,0x100000,0);

 #endif	

 	TEST(err==KErrNone);

 	thread.Logon(threadStatus)	;

 	thread.Resume();

 	User::WaitForRequest(threadStatus);

 	//Now check why the thread Exit

 	// There is Assert_Debug check for the duplicate extended interface Uid for AddExtendedInterfaceL(),

 	// Therefore, the panic reason would be KErrAlreadyExists for debug mode.

 	// in release mode, the duplicate extended interface is ignored.

 #ifdef _DEBUG

 	RDebug::Printf("Thread status: %d", thread.ExitType());

 	TEST(thread.ExitType()==EExitPanic);

 	TEST(thread.ExitReason()==EEComPanic_CImlpementationInfromation_DuplicateExIf);

 #else

 	RDebug::Printf("Thread status: %d", thread.ExitType());

 	TEST(thread.ExitType()==EExitKill);

 #endif

 	CLOSE_AND_WAIT(thread);

 	User::SetJustInTime(jit);

 	}

 /**

 Plugins to be used in this test

 Interface UID	DLL	UID		Implementation UID	Version		DLL Type	Extended Interfaces

 --------------------------------------------------------------------------------

 0x10009E36		0x10009E3E	0x10009E39				1		PLUGIN3		{0x10009E44, 0x10009E45, 0x10009E46}

 				0x10009E3E	0x10009E3C				1		PLUGIN3		{}

 				0x10009E3E	0x10009E3D				1		PLUGIN3		{0x10009E44}

 0x10009DC0		0x101F847B	0x101F847C				1		PLUGIN1		NULL

 @SYMTestCaseID          SYSLIB-ECOM-UT-3575

 @SYMTestCaseDesc	    Tests for CImplementationInformation::GetExtendedInterfaceList() and

 						CImplementationInformation::GetExtendedInterfaceListL() functions. Makes sure that

 						results from both of the functions are identical.

 @SYMTestPriority 	    High

 @SYMTestActions  	    List the extended interfaces for a valid implementation UID

 						List the extended interfaces for a non-existing implementation UID

 						List the extended interfaces for a valid PLUGIN1 implementation UID

 @SYMTestExpectedResults Expected extended interfaces are returned.

 @SYMEC                  EC43

 @SYMDEF					DEF111196

 */

 void CRegistryDataTest::ListExtendedInterfacesTestL()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3575 "));

 	TUid ImpUid = {0x10009E39};

 	TUid ImpUid1 = {0x10009E3C};

 	TUid ImpUidPLUGIN1 = {0x101F847C};

  	TUid extendedInterfacesUid[] = {0x10009E44,0x10009E45,0x10009E46};

  	TEntry dllinfo;

  	TInt err;

  	TClientRequest clntRq;

  	//Gets the Implementation Information for a valid implementation UID with extended interfaces

  	CImplementationInformation* implementationInfo=NULL;

  	TRAP(err,iRegistryData->GetImplementationDllInfoForClientL(clntRq, ImpUid, KCDummyUid, dllinfo, implementationInfo, ETrue));

  	TEST_OOM_ERR;

  	TEST2(err, KErrNone);

  	TEST(implementationInfo->ImplementationUid() == ImpUid);

  	//Gets the list of extended Interfaces

  	RArray<TUid>* extendedInterfaces = implementationInfo->GetExtendedInterfaceList();

  	//Checks the extended interfaces list

  	TEST(extendedInterfaces != NULL);

 	for (TInt i = 0; i < extendedInterfaces->Count(); i++)

 		{

 		TEST((*extendedInterfaces)[i] == extendedInterfacesUid[i]);

 		}

 	// Uses the GetExtendedInterfaceListL API to get the extended interface.

 	RArray<TUid> extendedInterfacesAPI;

 	CleanupClosePushL(extendedInterfacesAPI);

 	implementationInfo->GetExtendedInterfaceListL(extendedInterfacesAPI);

 	// Makes sure that the list return is the same as the one return from GetExtendedInterfaceList.

 	TEST(extendedInterfacesAPI.Count() == extendedInterfaces->Count());

 	for (TInt i = 0; i < extendedInterfaces->Count(); i++)

 		{

 		TEST((*extendedInterfaces)[i] == extendedInterfacesAPI[i]);

 		}

 	CleanupStack::PopAndDestroy(&extendedInterfacesAPI);

 	//Gets the Implementation Information for a valid implementation UID without extended interfaces

  	TRAP(err,iRegistryData->GetImplementationDllInfoForClientL(clntRq, ImpUid1, KCDummyUid, dllinfo, implementationInfo, ETrue));

  	TEST_OOM_ERR;

  	TEST2(err, KErrNone);

  	TEST(implementationInfo->ImplementationUid() == ImpUid1);

  	//Gets the list of extended Interfaces

 	extendedInterfaces = implementationInfo->GetExtendedInterfaceList();

  	TEST(extendedInterfaces->Count() == 0);

 	// Uses the GetExtendedInterfaceListL API to get the extended interface.

 	RArray<TUid> extendedInterfacesAPI1;

 	CleanupClosePushL(extendedInterfacesAPI1);

 	implementationInfo->GetExtendedInterfaceListL(extendedInterfacesAPI1);

 	// Makes sure that the list return is the same as the one return from GetExtendedInterfaceList.

 	TEST(extendedInterfacesAPI1.Count() == extendedInterfaces->Count());

 	for (TInt i = 0; i < extendedInterfaces->Count(); i++)

 		{

 		TEST((*extendedInterfaces)[i] == extendedInterfacesAPI1[i]);

 		}

 	CleanupStack::PopAndDestroy(&extendedInterfacesAPI1);

 	//Gets the Implementation Information for a non-existing implementation UID

 	TRAP(err,iRegistryData->GetImplementationDllInfoForClientL(clntRq, KCInvalidUid, KCDummyUid, dllinfo, implementationInfo, ETrue));

 	TEST_OOM_ERR;

 	TEST2(err,KErrNone);

 	TEST(implementationInfo == NULL);

 	//Gets the Implementation Information for a valid PLUGIN1 implementation UID without extended interfaces

  	TRAP(err,iRegistryData->GetImplementationDllInfoForClientL(clntRq, ImpUidPLUGIN1, KCDummyUid, dllinfo, implementationInfo, ETrue));

  	TEST_OOM_ERR;

  	TEST2(err, KErrNone);

  	TEST(implementationInfo->ImplementationUid() == ImpUidPLUGIN1);

  	//Gets the list of extended Interfaces

 	extendedInterfaces = implementationInfo->GetExtendedInterfaceList();

  	TEST(extendedInterfaces == NULL);

 	// Uses the GetExtendedInterfaceListL API to get the extended interface.

 	RArray<TUid> extendedInterfacesAPI2;

 	CleanupClosePushL(extendedInterfacesAPI2);

 	implementationInfo->GetExtendedInterfaceListL(extendedInterfacesAPI2);

 	// Makes sure that the list return is the same as the one return from GetExtendedInterfaceList.

 	TEST(extendedInterfacesAPI2.Count() == 0);

 	CleanupStack::PopAndDestroy(&extendedInterfacesAPI2);

 	}

 /**

 The interface Uid 0x10009E36 has 5 implementations on different DLLs(EComExample12.dll,EComExample14.dll and EComExample15.dll).

 0x10009E3D is said to be ROM-Only, it will not be created. 0x10009E39 has higher version in EComExample15.

 Interface UID	DLL	UID		Implementation UID	Version		DLL Type	Extended Interfaces

 --------------------------------------------------------------------------------

 0x10009E36		0x10009E40	0x10009E48				1		PLUGIN1		None

 				0x10009E3E	0x10009E39				1		PLUGIN3		{0x10009E44, 0x10009E45, 0x10009E46}

 				0x10009E3E	0x10009E3C				1		PLUGIN3		{}

 				0x10009E3E	0x10009E3D				1		PLUGIN3		{0x10009E44}

 				0x10009E42	0x10009E39				2		PLUGIN3		{0x10009E44, 0x10009E45, 0x10009E46}

 @SYMTestCaseID          SYSLIB-ECOM-UT-3580

 @SYMTestCaseDesc	    Tests for CRegistryResolveTransaction::ListImplementationsL() function with matches

 						that fall into a PLUGIN1 Dll and PLUGIN3. The extended interface list will not be populated

 @SYMTestPriority 	    High

 @SYMTestActions  	    List the implementations for an interface UID and a set of extended interfaces.

 						Check the VID of every implementation matches the VID of the DLL which the implementation

                         belongs to.

 @SYMTestExpectedResults Expected matches are returned from both PLUGIN1 and PLUGIN3.

 @SYMEC                  EC43

 */

 void CRegistryDataTest::ListImplementationsTestT5L()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3580 "));

 	const TUid KInterfaceUid = {0x10009E36};

 	TEST(iRegistryData->IndexValid());

 	// Set up client request and extended interfaces

 	TClientRequest clientReq;

 	RArray<TUid> extendedInterfaces;

 	CleanupClosePushL(extendedInterfaces);

 	TBool capability= ETrue;

 	CRegistryResolveTransaction* registryResolveTransaction = CRegistryResolveTransaction::NewL(*iRegistryData,extendedInterfaces,clientReq,capability);

 	CleanupStack::PushL(registryResolveTransaction);

 	RImplInfoArray* iUidListPtr = NULL;

 	TRAPD(err, iUidListPtr = &(registryResolveTransaction->ListImplementationsL(KInterfaceUid)));

 	TEST_OOM_ERR;

 	TEST2(err, KErrNone);

 	// Prints UIDs of implementations

 	_LIT(KUIDFormat,"Uid = 0x%08x\n");

 	_LIT(KLists,"There are %d Implementations \n");

 	TheTest.Printf(KLists, iUidListPtr->Count());

 	// Tests for expected number of implementations.

 	TEST(iUidListPtr->Count() == 3);

 	for(TInt index = 0; index < iUidListPtr->Count(); ++index)

 		{

 		// check VID of every implementation

 		TEST(((*(iUidListPtr))[index]->VendorId()).iId == 0x70000001);

 		TUid uid = (*(iUidListPtr))[index]->ImplementationUid();

 		TheTest.Printf(KUIDFormat, uid);

 		}

 	CleanupStack::PopAndDestroy(registryResolveTransaction);

 	CleanupStack::PopAndDestroy(&extendedInterfaces);

 	}

 /**

 The interface Uid 0x10009E36 has 5 implementations on different DLLs(EComExample12.dll,EComExample14.dll and EComExample15.dll).

 0x10009E3D is said to be ROM-Only, it will not be created. 0x10009E39 has higher version in EComExample15.

 Interface UID	DLL	UID		Implementation UID	Version	DLL Type	Extended Interfaces

 -------------------------------------------------------------------------------------------------------

 0x10009E36		0x10009E40	0x10009E48			1		PLUGIN1		None

 				0x10009E3E	0x10009E39			1		PLUGIN3		{0x10009E44, 0x10009E45, 0x10009E46}

 				0x10009E3E	0x10009E3C			1		PLUGIN3		{}

 				0x10009E3E	0x10009E3D			1		PLUGIN3		{0x10009E44}

 				0x10009E42	0x10009E39			2		PLUGIN3		{0x10009E44, 0x10009E45, 0x10009E46}

 @SYMTestCaseID          SYSLIB-ECOM-UT-3579

 @SYMTestCaseDesc	    Tests for CRegistryResolveTransaction::ListImplementationsL() function with matches

 						that fall into a PLUGIN1 Dll and PLUGIN3. The extended interface list will be populated

 @SYMTestPriority 	    High

 @SYMTestActions  	    List the implementations for an interface UID and a set of extended interfaces.

 						Check the VID of every implementation match the VID of the DLL which the implementation

                         belongs to.

 @SYMTestExpectedResults No PLUGIN1 implementations should be returned.

 @SYMEC                  EC43

 */

 void CRegistryDataTest::ListImplementationsTestT4L()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3579 "));

 	const TUid KInterfaceUid = {0x10009E36};

 	const TUid KExtendedInterfaceUid = {0x10009E44};

 	TEST(iRegistryData->IndexValid());

 	//Set up client request and extended interfaces

 	TClientRequest clientReq;

 	RArray<TUid> extendedInterfaces;

 	CleanupClosePushL(extendedInterfaces);

 	extendedInterfaces.AppendL(KExtendedInterfaceUid);

 	TBool capability= ETrue;

 	CRegistryResolveTransaction* registryResolveTransaction = CRegistryResolveTransaction::NewL(*iRegistryData,extendedInterfaces,clientReq,capability);

 	CleanupStack::PushL(registryResolveTransaction);

 	RImplInfoArray* iUidListPtr = NULL;

 	TRAPD(err, iUidListPtr = &(registryResolveTransaction->ListImplementationsL(KInterfaceUid)));

 	TEST_OOM_ERR;

 	TEST2(err, KErrNone);

 	// Prints UIDs of implementations

 	_LIT(KUIDFormat,"Uid = 0x%08x\n");

 	_LIT(KLists,"There are %d Implementations \n");

 	TheTest.Printf(KLists, iUidListPtr->Count());

 	// Tests for expected number of implementations.

 	TEST(iUidListPtr->Count() == 1);

 	for(TInt index = 0; index < iUidListPtr->Count(); ++index)

 		{

 		// check VID of every implementation

 		TEST(((*(iUidListPtr))[index]->VendorId()).iId == 0x70000001);

 		TUid uid = (*(iUidListPtr))[index]->ImplementationUid();

 		TheTest.Printf(KUIDFormat, uid);

 		}

 	CleanupStack::PopAndDestroy(registryResolveTransaction);

 	CleanupStack::PopAndDestroy(&extendedInterfaces);

 	}

 /**

 @SYMTestCaseID          SYSLIB-ECOM-UT-3578

 @SYMTestCaseDesc	    Tests for CRegistryResolveTransaction::ListImplementationsL() function with invalid interface id.

 @SYMTestPriority 	    High

 @SYMTestActions  	    List the implementations for an invalid interface UID and valid extended interfaces.

 @SYMTestExpectedResults No implementation is returned.

 @SYMEC                  EC43

 */

 void CRegistryDataTest::ListImplementationsTestT3L()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3578 "));

 	const TUid KExtendedInterfaceUid = {0x10009E44};

 	TEST(iRegistryData->IndexValid());

 	//Set up client request and extended interfaces

 	TClientRequest clientReq;

 	RArray<TUid> extendedInterfaces;

 	CleanupClosePushL(extendedInterfaces);

 	extendedInterfaces.AppendL(KExtendedInterfaceUid);

 	TBool capability= ETrue;

 	CRegistryResolveTransaction* registryResolveTransaction = CRegistryResolveTransaction::NewL(*iRegistryData,extendedInterfaces,clientReq,capability);

 	CleanupStack::PushL(registryResolveTransaction);

 	TRAPD(err, RImplInfoArray*	iUidListPtr = &(registryResolveTransaction->ListImplementationsL(KCInvalidUid)));

 	TEST_OOM_ERR;

 	TEST2(err, KEComErrNoInterfaceIdentified);

 	TheTest.Printf(_L("No Implementation is found.\n"));

 	CleanupStack::PopAndDestroy(registryResolveTransaction);

 	CleanupStack::PopAndDestroy(&extendedInterfaces);

 	}

 /**

 The interface Uid 0x10009E36 has 5 implementations (EComExample12.dll,EComExample14.dll and EComExample15.dll), but only 1 will

 be picked up as 2 of them do not match the extended interfaces criteria (0x10009E3C and 0x10009E48),

 1 of them is said to be ROM only but it is on RAM(0x10009E3D), and 1 of them has older version(0x10009E39).

 Interface UID	DLL	UID		Implementation UID	Version		Type	Extended Interfaces

 --------------------------------------------------------------------------------------

 0x10009E36		0x10009E3E	0x10009E39			1			PlugIn3	{0x10009E44, 0x10009E45, 0x10009E46}

 				0x10009E3E	0x10009E3C			1			PlugIn3	{}

 				0x10009E3E	0x10009E3D			1			PlugIn3	{0x10009E44}

 				0x10009E40	0x10009E48			1			PLUGIN1	None

 				0x10009E42	0x10009E39			2			PlugIn3	{0x10009E44, 0x10009E45, 0x10009E46}

 @SYMTestCaseID          SYSLIB-ECOM-UT-3577

 @SYMTestCaseDesc	    Tests for CRegistryResolveTransaction::ListImplementationsL() function with matches

 						that fall into a PLUGIN3 Dll.

 @SYMTestPriority 	    High

 @SYMTestActions  	    List the implementations for an existing interface UID and a set of extended interfaces.

                         Test for expected number of implementations. Check the VID of every implementation match

                         the VID of the DLL which the implementation belongs to.

 @SYMTestExpectedResults Expected number of implementations are returned.

 @SYMEC                  EC43

 */

 void CRegistryDataTest::ListImplementationsTestT2L()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3577 "));

 	const TUid KInterfaceUid = {0x10009E36};

 	const TUid KExtendedInterfaceUid = {0x10009E44};

 	TEST(iRegistryData->IndexValid());

 	// Set up client request and extended interfaces

 	TClientRequest clientReq;

 	RArray<TUid> extendedInterfaces;

 	CleanupClosePushL(extendedInterfaces);

 	extendedInterfaces.AppendL(KExtendedInterfaceUid);

 	TBool capability= ETrue;

 	CRegistryResolveTransaction* registryResolveTransaction = CRegistryResolveTransaction::NewL(*iRegistryData,extendedInterfaces,clientReq,capability);

 	CleanupStack::PushL(registryResolveTransaction);

 	RImplInfoArray* iUidListPtr = NULL;

 	TRAPD(err, iUidListPtr = &(registryResolveTransaction->ListImplementationsL(KInterfaceUid)));

 	TEST_OOM_ERR;

 	TEST2(err, KErrNone);

 	// Prints UIDs of implementations

 	_LIT(KUIDFormat,"Uid = 0x%08x\n");

 	_LIT(KLists,"There are %d Implementations \n");

 	TheTest.Printf(KLists, iUidListPtr->Count());

 	// Tests for expected number of implementations.

 	TEST(iUidListPtr->Count() == 1);

 	for(TInt index = 0; index < iUidListPtr->Count(); ++index)

 		{

 		// checks VID of every implementation

 		TEST(((*(iUidListPtr))[index]->VendorId()).iId == 0x70000001);

 		TUid uid = (*(iUidListPtr))[index]->ImplementationUid();

 		TheTest.Printf(KUIDFormat, uid);

 		}

 	CleanupStack::PopAndDestroy(registryResolveTransaction);

 	CleanupStack::PopAndDestroy(&extendedInterfaces);

 	}

 /**

 The interface Uid 0x10009DC0 has 6 implementations on different DLLs but only 4 will

 be picked up as 2 of them are of older version(Impl ID 0x10009DC3 and 0x10009DC4 with version 1)

 Interface UID	DLL	UID		Implementation UID	Version

 -------------------------------------------------------

 0x10009DC0		0x10009DB1	0x10009DC3			1

 				0x10009DB1	0x10009DC4			1

 				0x10009DB3	0x10009DC3			2

 				0x10009DB3	0x10009DC4			2

 				0x101F8477	0x101F8478			1

 				0x101F847B	0x101F847C			1

 @SYMTestCaseID          SYSLIB-ECOM-UT-3576

 @SYMTestCaseDesc	    Tests for CRegistryResolveTransaction::ListImplementationsL() function with matches

 						that fall into a PLUGIN1 Dll.

 @SYMTestPriority 	    High

 @SYMTestActions  	    List the implementations for an existing interface UID and

                         test for expected number of implementations.Check the VID of

                         every implementation match the VID of the DLL which the implementation

                         belongs to.

 @SYMTestExpectedResults Expected number of implementations are returned.

 @SYMEC                  EC43

 */

 void CRegistryDataTest::ListImplementationsTestT1L()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3576 "));

 	TEST(iRegistryData->IndexValid());

 	// Set up client request and extended interfaces

 	TClientRequest clientReq;

 	RArray<TUid> extendedInterfaces;

 	CleanupClosePushL(extendedInterfaces);

 	TBool capability= ETrue;

 	CRegistryResolveTransaction* registryResolveTransaction = CRegistryResolveTransaction::NewL(*iRegistryData,extendedInterfaces,clientReq,capability);

 	CleanupStack::PushL(registryResolveTransaction);

 	RImplInfoArray* iUidListPtr = NULL;

 	TRAPD(err, iUidListPtr = &(registryResolveTransaction->ListImplementationsL(iInterfaceUid)));

 	TEST_OOM_ERR;

 	TEST2(err, KErrNone);

 	// Prints UIDs of implementations

 	_LIT(KUIDFormat,"Uid = 0x%08x\n");

 	_LIT(KLists,"There are %d Implementations \n");

 	TheTest.Printf(KLists, iUidListPtr->Count());

 	// Tests for expected number of implementations.

 	TEST(iUidListPtr->Count() == 4);

 	for(TInt index = 0; index < iUidListPtr->Count(); ++index)

 		{

 		// checks VID of every implementation

 		TEST(((*(iUidListPtr))[index]->VendorId()).iId == 0x70000001);

 		TUid uid = (*(iUidListPtr))[index]->ImplementationUid();

 		TheTest.Printf(KUIDFormat, uid);

 		}

 	CleanupStack::PopAndDestroy(registryResolveTransaction);

 	CleanupStack::PopAndDestroy(&extendedInterfaces);

 	}

 /** In order to create an instance of CImplementationData, the test

 has to create the chain of: drive data, dll data, and interface data.

 Use this method to safe the repetitive work.

 This method will not new the CImplementationData's parents if they

 have been set. Hence can be used to add an implementation to an

 existing interface data.

 */

 void CRegistryDataTest::CreateImplL(TImplCreationStruct& aCreationData)

 	{

 	if (aCreationData.iImplData)

 	  {

 	  // Should not call this method. There is nothing to create.

 	  User::Leave(KErrGeneral);

 	  }

 	if (! aCreationData.iDriveData || (KErrNotFound == aCreationData.iDriveIndex))

 		{

         aCreationData.iDriveIndex = iRegistryData->FindDriveL(

             aCreationData.iDriveUnit, aCreationData.iDriveData);

         if (KErrNotFound == aCreationData.iDriveIndex)

             {

             aCreationData.iDriveData = CRegistryData::CDriveData::NewLC(

                 aCreationData.iDriveUnit, iRegistryData);

             iStateAccessor->AppendDriveDataL(*iRegistryData,

                                              aCreationData.iDriveData);

             CleanupStack::Pop(aCreationData.iDriveData);

             aCreationData.iDriveIndex = iRegistryData->FindDriveL(

             	aCreationData.iDriveUnit,aCreationData.iDriveData);

             }

 		}

 	if (! aCreationData.iDllData)

 		{

 		if (aCreationData.iInterfaceData)

 			{

 			User::Leave(KErrGeneral); // can not have child without parent

 			}

 		TEntry e;

 		e.iName = aCreationData.iDllPathName;

 		TParse fileparse;

 		fileparse.Set(e.iName,NULL,NULL);

 		aCreationData.iDllData = CRegistryData::CDllData::NewLC(

 			fileparse.NameAndExt(),e.iModified,KNullUid,KNullUid, aCreationData.iDriveData);

 		aCreationData.iDllData->iSecurityChecked = ETrue;

 		aCreationData.iDriveData->AddL(aCreationData.iDllData);

 		CleanupStack::Pop(aCreationData.iDllData);

 		}

 	if (!aCreationData.iInterfaceData)

 		{

 		aCreationData.iInterfaceData = CRegistryData::CInterfaceData::NewLC(

 			aCreationData.iInterfaceUid, aCreationData.iDllData);

 		aCreationData.iDllData->AddL(aCreationData.iInterfaceData);

 		CleanupStack::Pop(aCreationData.iInterfaceData);

 		}

 	HBufC* name = aCreationData.iImplDisplayName.AllocLC();

 	HBufC8* dataType = aCreationData.iImplDataType.AllocLC();

 	HBufC8* opaqueData = aCreationData.iImplOpaqueData.AllocLC();

 	aCreationData.iImplData = CRegistryData::CImplementationData::NewL(

 		aCreationData.iInterfaceData,

 		aCreationData.iImplUid,

 		aCreationData.iImplVersion,

 		name,

 		dataType,

 		opaqueData,

 		aCreationData.iDriveUnit,

 		aCreationData.iRomOnly,

 		aCreationData.iRomBased);

 	CleanupStack::Pop(opaqueData);

 	CleanupStack::Pop(dataType);

 	CleanupStack::Pop(name);

 	CleanupStack::PushL(aCreationData.iImplData);

 	aCreationData.iInterfaceData->AddL(aCreationData.iImplData);

 	CleanupStack::Pop(aCreationData.iImplData);

 	}

 /**

 @SYMTestCaseID			SYSLIB-ECOM-CT-0290

 @SYMTestCaseDesc		Unit tests for CRegistryData::CImplementationData

 @SYMTestPriority			High

 @SYMTestActions			Create instances using NewLC and NewL. Check that the parent supplied is

 						correctly set.

 						Externalize instance created by NewL.

 						Internalize data set by previous step. Check implementation data is identical.

 						Check compare uid returns correct values.

 						Check for no crash and memory leaks.

 @SYMTestExpectedResults	The test must not fail.

 @SYMPREQ				PREQ277

 */

 void  CRegistryDataTest::ImplementationDataTestL()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0290 "));

 	// Set up for heap leak checking

 	__UHEAP_MARK;

 	// and leaking thread handles

 	TInt startProcessHandleCount;

 	TInt startThreadHandleCount;

 	TInt endProcessHandleCount;

 	TInt endThreadHandleCount;

 	// Test Starts...

 	RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

 	// Test Data

 	TUid testImplUid;

 	testImplUid.iUid = KCExampleInterfaceUid.iUid;

 	TInt testImplVersion = 2;

 	_LIT(KTestImplName, "Implementation");

 	_LIT8(KTestImplDataType, "Data Type");

 	_LIT8(KTestImplOpaqueData, "Opaque Data");

 	TUid testExtendedInterfaceUid1;

 	TUid testExtendedInterfaceUid2;

 	testExtendedInterfaceUid1.iUid = 0x10009E44;

 	testExtendedInterfaceUid2.iUid = 0x10009E45;

 	TDriveUnit testImplDrive = EDriveC;

 	TBool testImplRomOnly = ETrue;

 	TBool testImplRomBased = EFalse;

 	CRegistryData* registryData = CRegistryData::NewL(TheFs);

 	CleanupStack::PushL(registryData);

 	CRegistryData::CDriveData* driveData = CRegistryData::CDriveData::NewLC(testImplDrive, registryData);

 	CRegistryData::CDllData* dllData = CRegistryData::CDllData::NewLC(driveData);

 	CRegistryData::CInterfaceData* interfaceData = CRegistryData::CInterfaceData::NewLC(dllData);

 	// Start tests...

 	// NewLC test

 	CRegistryData::CImplementationData* implementation1;

 	implementation1 = CRegistryData::CImplementationData::NewLC(interfaceData);

 	TEST(interfaceData == implementation1->iParent);

 	// NewL test

 	HBufC* name = KTestImplName().AllocLC();

 	HBufC8* dataType = KTestImplDataType().AllocLC();

 	HBufC8* opaqueData = KTestImplOpaqueData().AllocLC();

 	RArray<TUid>* extendedInterfaces = new(ELeave) RArray<TUid>;

 	CleanupStack::PushL(TCleanupItem(CloseAndDeleteArray, extendedInterfaces));

 	CRegistryData::CImplementationData* implementation2;

 	implementation2 = CRegistryData::CImplementationData::NewL(interfaceData,

 															testImplUid,

 															testImplVersion,

 															name,

 															dataType,

 															opaqueData,

 															testImplDrive,

 															testImplRomOnly,

 															testImplRomBased,

 															extendedInterfaces);

 	CleanupStack::Pop(extendedInterfaces);

 	CleanupStack::Pop(opaqueData);

 	CleanupStack::Pop(dataType);

 	CleanupStack::Pop(name);

 	CleanupStack::PushL(implementation2);

 	TEST(interfaceData == implementation1->iParent);

 	//Add extended interface

 	implementation2->iImplInfo->AddExtendedInterfaceL(testExtendedInterfaceUid1);

 	implementation2->iImplInfo->AddExtendedInterfaceL(testExtendedInterfaceUid2);

 	// Externalize test

 	_LIT(KFileName,"c:\\ecomimpldata.dat");

 	RFile file;

 	TFileName fileName(KFileName);

 	TEST2(file.Replace(TheFs,fileName,EFileWrite|EFileRead), KErrNone);

 	RFileBuf buf;

 	CleanupClosePushL(buf);

 	buf.Attach(file);

 	RWriteStream stream(&buf);

 	implementation2->ExternalizeL(stream);

 	buf.SynchL();

 	CleanupStack::PopAndDestroy(&buf);

 	// Internalize test

 	TInt err = file.Open(TheFs,fileName,EFileRead);

 	TEST2(err, KErrNone);

 	RFileBuf buf2;

 	CleanupClosePushL(buf2);

 	buf2.Attach(file);

 	RReadStream stream2(&buf2);

 	implementation1->InternalizeL(stream2);

 	TEST(implementation1->iImplInfo->ImplementationUid().Uid == testImplUid.Uid);

 	TEST(implementation1->iImplInfo->Version() == testImplVersion);

 	TEST2(KErrNone, name->Compare(implementation1->iImplInfo->DisplayName()));

 	TEST2(KErrNone, dataType->Compare(implementation1->iImplInfo->DataType()));

 	TEST2(KErrNone, opaqueData->Compare(implementation1->iImplInfo->OpaqueData()));

 	TEST(implementation1->iImplInfo->Drive() == testImplDrive);

 	TEST(implementation1->iImplInfo->RomOnly() == testImplRomOnly);

 	TEST(implementation1->iImplInfo->RomBased() == testImplRomBased);

 	//Get extended interface and check

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

 	TEST((*extendedInterfaceList)[0] == testExtendedInterfaceUid1);

 	TEST((*extendedInterfaceList)[1] == testExtendedInterfaceUid2);

 	CleanupStack::PopAndDestroy(&buf2);

 	// Setup data for Compare Implementation Uid

 	name = KTestImplName().AllocLC();

 	dataType = KTestImplDataType().AllocLC();

 	opaqueData = KTestImplOpaqueData().AllocLC();

 	TUid compareTestImplUid;

 	compareTestImplUid.iUid = 0x10009DC3;

 	CRegistryData::CImplementationData* implementation3;

 	implementation3 = CRegistryData::CImplementationData::NewL(interfaceData,

 															compareTestImplUid,

 															testImplVersion,

 															name,

 															dataType,

 															opaqueData,

 															testImplDrive,

 															testImplRomOnly,

 															testImplRomBased);

 	CleanupStack::Pop(opaqueData);

 	CleanupStack::Pop(dataType);

 	CleanupStack::Pop(name);

 	CleanupStack::PushL(implementation3);

 	TEST(interfaceData == implementation3->iParent);

 	// Compare Implementation Uid test

 	TEST(CRegistryData::CImplementationData::CompareImplUid(*implementation3, *implementation2) > 0);

 	TEST(CRegistryData::CImplementationData::CompareImplUid(*implementation1, *implementation3) < 0);

 	TEST(CRegistryData::CImplementationData::CompareImplUid(*implementation3, *implementation3) == 0);

 	// Tidy up

 	CleanupStack::PopAndDestroy(7, registryData);

 	TheFs.Delete(KFileName);

 // Check for open handles

 	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

 	TEST(startThreadHandleCount == endThreadHandleCount);

 	// Test Ends...

 	__UHEAP_MARKEND;

 	}

 /**

 @SYMTestCaseID			SYSLIB-ECOM-CT-0291

 @SYMTestCaseDesc		Tests for CRegistryData::InsertIntoIndexRemoveFromIndexTestL

 						See CR65BCA3.

 @SYMTestPriority			High

 @SYMTestActions			Create 2 identical implementations, 1 for the Z drive and 1 for the C drive,

 						including parents and add to the registry.

 						Create a 3rd identical implementation, except for the name, for the C drive.

 						Check there are no implementations in the Implementation Index List.

 						Insert the Z implementations into the Implementation Index List and check.

 						Insert the 1st C implementation with security check on and check the upgrade

 						took place.

 						Remove the implementation. Check.

 						Add the Z drive implementation. Check.

 						Insert the 1st C implementation with security check off and check the upgrade

 						took place.

 						Remove the implementation. Check.

 						Add the Z drive implementation. Check.

 						Insert the 2nd C implementation with security check on and check the upgrade

 						did not take place.

 						Insert the 2nd C implementation with security check off and check the upgrade

 						did took place.

 						Remove the implementation. Check.

 						Check for no crash and memory leaks.

 @SYMTestExpectedResults	The test must not fail.

 @SYMPREQ				PREQ277

 */

 void  CRegistryDataTest::InsertIntoIndexRemoveFromIndexTestL()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0291 "));

 	_LIT(KTestImplName, "Implementation");

 	_LIT8(KTestImplDataType, "Data Type");

 	_LIT8(KTestImplOpaqueData, "Opaque Data");

 	// create Z drive data

 	TDriveUnit implDriveZ = EDriveZ;

 	CRegistryData::CDriveData* driveDataZ = CRegistryData::CDriveData::NewLC(implDriveZ,  iRegistryData);

 	iStateAccessor->AppendDriveDataL(*iRegistryData, driveDataZ);

 	CleanupStack::Pop(driveDataZ);

 	// Create Implementation 1 on Z drive

 	_LIT(KEComUpgradeExample1OnZ,		"Z:\\sys\\bin\\EComUpgradeExampleOne.dll");

 	TEntry upgradeExample1OnZ;

 	upgradeExample1OnZ.iName = KEComUpgradeExample1OnZ;

 	TParse fileparse;

 	fileparse.Set(KEComUpgradeExample1OnZ,NULL,NULL);

 	CRegistryData::CDllData* dllDataZ = CRegistryData::CDllData::NewLC(fileparse.NameAndExt(),upgradeExample1OnZ.iModified,KNullUid, KNullUid, driveDataZ);

 	dllDataZ->iSecurityChecked = ETrue;

 	driveDataZ->AddL(dllDataZ);

 	CleanupStack::Pop(dllDataZ);

 	CRegistryData::CInterfaceData* interfaceDataZ = CRegistryData::CInterfaceData::NewLC(iInterfaceUid, dllDataZ);

 	dllDataZ->AddL(interfaceDataZ);

 	CleanupStack::Pop(interfaceDataZ);

 	HBufC* name = KTestImplName().AllocLC();

 	HBufC8* dataType = KTestImplDataType().AllocLC();

 	HBufC8* opaqueData = KTestImplOpaqueData().AllocLC();

 	CRegistryData::CImplementationData* implementation1;

 	implementation1 = CRegistryData::CImplementationData::NewL(interfaceDataZ,

 															iImplementationUid,

 															1,

 															name,

 															dataType,

 															opaqueData,

 															implDriveZ,

 															EFalse,

 															EFalse);

 	CleanupStack::Pop(opaqueData);

 	CleanupStack::Pop(dataType);

 	CleanupStack::Pop(name);

 	CleanupStack::PushL(implementation1);

 	interfaceDataZ->AddL(implementation1);

 	CleanupStack::Pop(implementation1);

 	// create C drive data

 	TDriveUnit implDriveC = EDriveC;

 	CRegistryData::CDriveData* driveDataC = CRegistryData::CDriveData::NewLC(implDriveC,  iRegistryData);

 	iStateAccessor->AppendDriveDataL(*iRegistryData, driveDataC);

 	CleanupStack::Pop(driveDataC);

 	// Create Implementation 1 on C drive

 	_LIT(KEComUpgradeExample1OnC,		"C:\\sys\\bin\\EComUpgradeExampleOne.dll");

 	TEntry upgradeExample1OnC;

 	upgradeExample1OnC.iName = KEComUpgradeExample1OnC;

 	fileparse.Set(KEComUpgradeExample1OnC,NULL,NULL);

 	CRegistryData::CDllData* dllDataC1 = CRegistryData::CDllData::NewLC(fileparse.NameAndExt(),upgradeExample1OnC.iModified,KNullUid, KNullUid, driveDataC);

 	dllDataC1->iSecurityChecked = ETrue;

 	driveDataC->AddL(dllDataC1);

 	CleanupStack::Pop(dllDataC1);

 	CRegistryData::CInterfaceData* interfaceDataC1 = CRegistryData::CInterfaceData::NewLC(iInterfaceUid, dllDataC1);

 	dllDataC1->AddL(interfaceDataC1);

 	CleanupStack::Pop(interfaceDataC1);

 	name = KTestImplName().AllocLC();

 	dataType = KTestImplDataType().AllocLC();

 	opaqueData = KTestImplOpaqueData().AllocLC();

 	CRegistryData::CImplementationData* implementation2;

 	implementation2 = CRegistryData::CImplementationData::NewL(interfaceDataC1,

 															iImplementationUid,

 															2,

 															name,

 															dataType,

 															opaqueData,

 															implDriveC,

 															EFalse,

 															EFalse);

 	CleanupStack::Pop(opaqueData);

 	CleanupStack::Pop(dataType);

 	CleanupStack::Pop(name);

 	CleanupStack::PushL(implementation2);

 	interfaceDataC1->AddL(implementation2);

 	CleanupStack::Pop(implementation2);

 	// Create Implementation 2 on C drive

 	_LIT(KEComUpgradeExample2OnC,		"C:\\sys\\bin\\EComUpgradeExampleTwo.dll");

 	TEntry upgradeExample2OnC;

 	upgradeExample2OnC.iName = KEComUpgradeExample2OnC;

 	fileparse.Set(KEComUpgradeExample2OnC,NULL,NULL);

 	CRegistryData::CDllData* dllDataC2 = CRegistryData::CDllData::NewLC(fileparse.NameAndExt(),upgradeExample2OnC.iModified,KNullUid,KNullUid, driveDataC);

 	dllDataC2->iSecurityChecked = ETrue;

 	driveDataC->AddL(dllDataC2);

 	CleanupStack::Pop(dllDataC2);

 	CRegistryData::CInterfaceData* interfaceDataC2 = CRegistryData::CInterfaceData::NewLC(iInterfaceUid, dllDataC2);

 	dllDataC2->AddL(interfaceDataC2);

 	CleanupStack::Pop(interfaceDataC2);

 	name = KTestImplName().AllocLC();

 	dataType = KTestImplDataType().AllocLC();

 	opaqueData = KTestImplOpaqueData().AllocLC();

 	CRegistryData::CImplementationData* implementation3;

 	implementation3 = CRegistryData::CImplementationData::NewL(interfaceDataC2,

 															iImplementationUid,

 															2,

 															name,

 															dataType,

 															opaqueData,

 															implDriveC,

 															EFalse,

 															EFalse);

 	CleanupStack::Pop(opaqueData);

 	CleanupStack::Pop(dataType);

 	CleanupStack::Pop(name);

 	CleanupStack::PushL(implementation3);

 	interfaceDataC2->AddL(implementation3);

 	CleanupStack::Pop(implementation3);

 //===========================================================================

 	// Check index is empty

 	TEST(iStateAccessor->ImplementationsCount(*iRegistryData) == 0);

 //===========================================================================

 	// Add Implementation from Z drive to index

 	TBool result = iRegistryData->InsertIntoIndexL(implementation1, ETrue);

 	TEST2(result, ETrue);

 	RImplDataArray impls;

 	CleanupClosePushL(impls);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == implDriveZ);

 //===========================================================================

 	// Add Implementation from C drive to index - this should upgrade existing implementation

 	result = iRegistryData->InsertIntoIndexL(implementation2, ETrue);

 	TEST2(result, ETrue);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == implDriveC);

 //===========================================================================

 	// remove existing implementation which causes rollback to Z drive impl

 	iRegistryData->RemoveFromIndexL(dllDataC1);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == implDriveZ);

 //===========================================================================

 	// Add Implementation from C drive to index - this should upgrade existing implementation

 	result = iRegistryData->InsertIntoIndexL(implementation2, EFalse);

 	TEST2(result, ETrue);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == implDriveC);

 //===========================================================================

 	// remove existing implementation which causes rollback to Z drive impl

 	iRegistryData->RemoveFromIndexL(dllDataC1);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == implDriveZ);

 //===========================================================================

 	// Add Implementation with different name from C drive to index

 	// this should NOT upgrade existing implementation

 	result = iRegistryData->InsertIntoIndexL(implementation3, ETrue);

 	TEST2(result, EFalse);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == implDriveZ);

 //===========================================================================

 	// Add Implementation with different name from C drive to index

 	// this should upgrade existing implementation as security check is OFF

 	result = iRegistryData->InsertIntoIndexL(implementation3, EFalse);

 	TEST2(result, ETrue);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == implDriveC);

 //===========================================================================

 	// remove existing implementation which causes rollback to Z drive impl

 	iRegistryData->RemoveFromIndexL(dllDataC2);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == implDriveZ);

 	CleanupStack::PopAndDestroy(&impls);

 	}

 /**

 Test case for Defect ECOM Index must rollback	to original Impl. if upgrade impl. is removed

 @SYMTestCaseID			SYSLIB-ECOM-CT-1373

 @SYMTestCaseDesc		Test case for defect number DEF065559 ECOM Index must rollback

 						to original Impl. if upgrade impl. is removed.

 @SYMTestPriority			High

 @SYMTestActions			Create 3 identical implementations, 1 for the Z drive, 1 for the C drive and

 						1 for the D drive, including parents and add to the registry.

 						Insert the Z implementation and check.

 						Insert the C implementation and check the upgrade took place.

 						Insert the D implementation and check the upgrade took place.

 						Remove the D implementation and check rollback to C occurred.

 						Remove the C implementation and check rollback to Z occurred.

 						Insert the C implementation and check the upgrade took place.

 						Insert the D implementation and check the upgrade took place.

 						Remove the C implementation and check no rollback occurred. i.e D impl available

 						Remove the D implementation and check rollback to Z occurred.

 						Insert the D implementation and check the upgrade took place.

 						Insert the C implementation and check no upgrade took place. i.e D impl available

 						Remove the D implementation and check rollback to C occurred.

 						Remove the C implementation and check rollback to Z occurred.

 						Check for no crash and memory leaks.

 @SYMTestExpectedResults	The test must not fail.

 @SYMDEF				DEF065559

 */

 void  CRegistryDataTest::RollbackTestL()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1373 "));

 	_LIT(KTestImplName, "Implementation");

 	_LIT8(KTestImplDataType, "Data Type");

 	_LIT8(KTestImplOpaqueData, "Opaque Data");

 	// Create Implementation 1 on Z drive

 	_LIT(KEComUpgradeExample1OnZ,		"Z:\\sys\\bin\\EComUpgradeExampleOne.dll");

 	TImplCreationStruct zDllData(EDriveZ,

 								iInterfaceUid,

 								iImplementationUid,

 								KEComUpgradeExample1OnZ,

 								KTestImplName,

 								KTestImplDataType,

 								KTestImplOpaqueData,

 								1,

 								ETrue,  // Z: is ROMBased

 								EFalse);

 	CreateImplL(zDllData);

 	// Create Implementation 1 on C drive

 	_LIT(KEComUpgradeExample1OnC,		"C:\\sys\\bin\\EComUpgradeExampleOne.dll");

 	TImplCreationStruct cDllData(EDriveC,

 								iInterfaceUid,

 								iImplementationUid,

 								KEComUpgradeExample1OnC,

 								KTestImplName,

 								KTestImplDataType,

 								KTestImplOpaqueData,

 								2);

 	CreateImplL(cDllData);

 	// create drive data on third drive.

 	// find a valid drive which is not Z and not C.

 	TEComCachedDriveInfoIterator iter(*iRegistryData->iCachedDriveInfo);

 	iter.Last(); // positioned at Z:

 	iter.Prev(); // the drive before Z:

 	for (; iter.InRange(); iter.Prev())

 		{

 		if (iter.DriveNumber() != EDriveC)

 			{

 			break;

 			}

 		}

 	TEST(iter.InRange() && iter.DriveNumber() != EDriveC);

 	TDriveName drvName = iter.DriveUnit().Name();

 	_LIT(KEComUpgradeExample1On3,		"_:\\sys\\bin\\EComUpgradeExampleOne.dll");

 	TBuf<36> dllName3(KEComUpgradeExample1On3);

 	dllName3[0] = drvName[0];

 	TImplCreationStruct thirdDllData(iter.DriveNumber(),

 									iInterfaceUid,

 									iImplementationUid,

 									dllName3,

 									KTestImplName,

 									KTestImplDataType,

 									KTestImplOpaqueData,

 									3);

 	CreateImplL(thirdDllData);

 //===========================================================================

 	// Check index is empty

 	TEST(iStateAccessor->ImplementationsCount(*iRegistryData) == 0);

 //===========================================================================

 	TDriveUnit implDriveZ = EDriveZ;

 	TDriveUnit implDriveC = EDriveC;

 	// Add Implementation from Z drive to index

 	TBool result = iRegistryData->InsertIntoIndexL(zDllData.iImplData, ETrue);

 	TEST2(result, ETrue);

 	RImplDataArray impls;

 	CleanupClosePushL(impls);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == implDriveZ);

 //===========================================================================

 	// Add Implementation from C drive to index - this should upgrade existing implementation

 	result = iRegistryData->InsertIntoIndexL(cDllData.iImplData, ETrue);

 	TEST2(result, ETrue);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == implDriveC);

 //===========================================================================

 	// Add Implementation from third drive to index - this should upgrade existing implementation

 	result = iRegistryData->InsertIntoIndexL(thirdDllData.iImplData, ETrue);

 	TEST2(result, ETrue);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == iter.DriveUnit());

 //===========================================================================

 	// remove implementation from third drive which causes rollback to C drive impl

 	iRegistryData->RemoveFromIndexL(thirdDllData.iDllData);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == implDriveC);

 //===========================================================================

 	// remove implementation from C which causes rollback to Z drive impl

 	iRegistryData->RemoveFromIndexL(cDllData.iDllData);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == implDriveZ);

 //===========================================================================

 	// Add Implementation from C drive to index - this should upgrade existing implementation

 	result = iRegistryData->InsertIntoIndexL(cDllData.iImplData, ETrue);

 	TEST2(result, ETrue);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == implDriveC);

 //===========================================================================

 	// Add Implementation from third drive to index - this should upgrade existing implementation

 	result = iRegistryData->InsertIntoIndexL(thirdDllData.iImplData, ETrue);

 	TEST2(result, ETrue);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == iter.DriveUnit());

 //===========================================================================

 	// remove implementation from C which should cause no rollback

 	iRegistryData->RemoveFromIndexL(cDllData.iDllData);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == iter.DriveUnit());

 //===========================================================================

 	// remove implementation from third drive which causes rollback to Z drive impl

 	iRegistryData->RemoveFromIndexL(thirdDllData.iDllData);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == implDriveZ);

 //===========================================================================

 	// Add Implementation from third drive to index - this should upgrade existing implementation

 	result = iRegistryData->InsertIntoIndexL(thirdDllData.iImplData, ETrue);

 	TEST2(result, ETrue);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == iter.DriveUnit());

 //===========================================================================

 	// Add Implementation from C drive to index - this should not upgrade existing implementation

 	result = iRegistryData->InsertIntoIndexL(cDllData.iImplData, ETrue);

 	TEST2(result, ETrue);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == iter.DriveUnit());

 //===========================================================================

 	// remove implementation from third drive which causes rollback to C drive impl

 	iRegistryData->RemoveFromIndexL(thirdDllData.iDllData);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == implDriveC);

 //===========================================================================

 	// remove implementation from C which causes rollback to Z drive impl

 	iRegistryData->RemoveFromIndexL(cDllData.iDllData);

 	iStateAccessor->GetImplementationInfoL(*iRegistryData, iInterfaceUid, impls);

 	TEST(impls.Count() == 1);

 	TEST(impls[0]->iImplInfo->Drive() == implDriveZ);

 	CleanupStack::PopAndDestroy(&impls);

 	}

 /**

 @SYMTestCaseID          SYSLIB-ECOM-CT-0737

 @SYMTestCaseDesc	    Tests the creation and deletion of CRegistryData

 @SYMTestPriority 	    High

 @SYMTestActions  	    Create and delete CRegistryData object,checks for open handles

 @SYMTestExpectedResults The test must not fail.

 @SYMREQ                 REQ0000

 */

 LOCAL_C void CreateDeleteTestL()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0737 Create and Delete Test "));

 	// Set up for heap leak checking

 	__UHEAP_MARK;

 	// and leaking thread handles

 	TInt startProcessHandleCount;

 	TInt startThreadHandleCount;

 	TInt endProcessHandleCount;

 	TInt endThreadHandleCount;

 	// Test Starts...

 	RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

 	CRegistryDataTest* theTest = NULL;

 	// Create the object

 	TRAPD(err, theTest = CRegistryDataTest::NewL(EFalse));

 	TEST2(err, KErrNone);

 	// Delete the object

 	delete theTest;

 	// Check for open handles

 	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

 	TEST(startThreadHandleCount == endThreadHandleCount);

 	// Test Ends...

 	__UHEAP_MARKEND;

 	}

 /**

 @SYMTestCaseID          SYSLIB-ECOM-UT-3572

 @SYMTestCaseDesc	    Tests for CRegistryData::UpdateDllDataL() function when an existing registered

 						PLUGIN3 is downgraded with an updated PLUGIN1 resource file.

 @SYMTestPriority 	    High

 @SYMTestActions  	    Update the data for a dll in the registry.

                         Tests for OOM error.

 @SYMTestExpectedResults The data for the dll in the registry is updated.

 @SYMEC                  EC43

 */

 void CRegistryDataTest::UpdateDllDataTest3L()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3572 "));

 	// Checks if drive is registered

 	TEST(iStateAccessor->IsRegisteredDriveL(*iRegistryData, iDriveUnit)!= KErrNotFound);

 	CRegistryData::CDriveData* driveData = NULL;

 	// Fetches index of drive, in iFoundDriveIndex

 	iFoundDriveIndex = iRegistryData->FindDriveL(iDriveUnit,driveData);

 	TEntry dllEntry;

 	TUid example12ThirdUid = {0x10009E3E};

 	dllEntry.iType = TUidType(KNullUid, KNullUid, example12ThirdUid);

 	dllEntry.iName = KEComExample12DllOnC;

 	dllEntry.iModified.HomeTime();

 	TBool registered = EFalse;

 	registered = iRegistryData->IsRegisteredWithDate(

 										 dllEntry[2],

 										 dllEntry.iModified,

 										 iUpdate,

 										 driveData);

 	TEST(registered);

 	// Log message if implementations need update

 	if (!iUpdate)

 		{

 		TheTest.Printf(_L("Specified implementation group is already registered and does not need an update\n"));

 		}

 	//If the implementation needs an update, update it using UpdateDllDataL

 	else

 		{

 		TheTest.Printf(_L("Specified implementation group is not registered with date and needs an update\n"));

 		// Checks Implementation 0x10009E48 registered in the registry is version 1, display name is "Example 12 PlugIn3"

 		// A reference to the implementation entry in the registry

 		const TUid implementationUid = {0x10009E3C};

 		CRegistryData::CImplementationData*	implementationData = NULL;

 		TInt err = iStateAccessor->FindImplementation(*iRegistryData, implementationUid, KCDummyUid, implementationData);

 		TEST2(err,KErrNone);

 		CImplementationInformation* implementationInfo = implementationData->iImplInfo;

 		TEST(implementationInfo->Version() == 1);

 		TEST(implementationInfo->DisplayName().CompareF(_L("Example 12 PlugIn3"))==0);

 		// Dll Data object to be updated

 		CRegistryData::CDllData* updateDllData = NULL;

 		TParse fileparse;

 		fileparse.Set(dllEntry.iName,NULL,NULL);

 		updateDllData = CRegistryData::CDllData::NewLC(fileparse.NameAndExt(),dllEntry.iModified,dllEntry[1], dllEntry[2],driveData);

 		//Copies the downgraded resource file to C:

 		TRAP(err, EComTestUtils::FileManCopyFileL(KEcomExample12DowngradedOnZ, KEcomExample12DowngradedOnC));

 		TEST2(err, KErrNone);

 		//Creats the entry using downgraded resource file

 		TEntry rscBasedEntry;

 		rscBasedEntry.iName = KEcomExample12DowngradedResourceNameOnly;

 		TParse rscPath;

 		rscPath.Set(KEcomExample12DowngradedOnC,NULL,NULL);

 		CPluginBase* entryBase = NULL;

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

 		CleanupStack::PushL(entryBase);

 		// Updates resource ext info

 		HBufC* resourceExt = entryBase->RscFileExt();

 		if(resourceExt)

 			{

 			updateDllData->SetResourceExtL(*resourceExt);

 			}

 		// parses the downgraded resource file

 		TInt error = KErrNone;

 		TRAP(error, iRegistrarAccessor->ParseL(*iRegistrar, entryBase, *updateDllData));

 		if (error == KErrNoMemory)

 			{

 			User::LeaveNoMemory();

 			}

 		CleanupStack::PopAndDestroy(entryBase);

 		TDriveUnit aDrive;

 		// Updates DLL data with a new dll data

 		TRAP(err, iRegistryData->UpdateDllDataL(aDrive, iFoundDriveIndex, updateDllData));

 		TEST_OOM_ERR;

 		TEST2(err, KErrNone);

 		CleanupStack::Pop(updateDllData);

 		// Checks registry data is updated with new data

 		// Implementation 0x10009E48 is downgraded from version 1 to version 0, display name is changed to "Example 12 PlugIn"

 		implementationData = NULL;

 		err = iStateAccessor->FindImplementation(*iRegistryData, implementationUid, KCDummyUid, implementationData);

 		TEST2(err,KErrNone);

 		implementationInfo = implementationData->iImplInfo;

 		TEST(implementationInfo->Version() == 0);

 		TEST(implementationInfo->DisplayName().CompareF(_L("Example 12 PlugIn")) == 0);

 		TheTest.Printf(_L("DLL data is updated \n"));

 		//deletes the downgraded resource file

 		TRAP(err,EComTestUtils::FileManDeleteFileL(KEcomExample12DowngradedOnC));

 		}

 	registered = iRegistryData->IsRegisteredWithDate(

 										 dllEntry[2],

 										 dllEntry.iModified,

 										 iUpdate,

 										 driveData);

 	TEST(registered);

 	TEST(!iUpdate);

 	}

 /**

 @SYMTestCaseID          SYSLIB-ECOM-UT-3571

 @SYMTestCaseDesc	    Tests for CRegistryData::UpdateDllDataL() function when an existing registered

 						PLUGIN1 is upgraded with an updated PLUGIN3 resource file.

 @SYMTestPriority 	    High

 @SYMTestActions  	    Update the data for a dll in the registry.

                         Tests for OOM error.

 @SYMTestExpectedResults The data for the dll in the registry is updated.

 @SYMEC                  EC43

 */

 void CRegistryDataTest::UpdateDllDataTest2L()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3571 "));

 	// Checks if drive is registered

 	TEST(iStateAccessor->IsRegisteredDriveL(*iRegistryData, iDriveUnit)!= KErrNotFound);

 	CRegistryData::CDriveData* driveData = NULL;

 	// Fetches index of drive, in iFoundDriveIndex

 	iFoundDriveIndex = iRegistryData->FindDriveL(iDriveUnit,driveData);

 	TEntry dllEntry;

 	TUid example14ThirdUid = {0x10009E40};

 	dllEntry.iType = TUidType(KNullUid, KNullUid, example14ThirdUid);

 	dllEntry.iName = KEComExample14DllOnC;

 	dllEntry.iModified.HomeTime();

 	TBool registered = EFalse;

 	registered = iRegistryData->IsRegisteredWithDate(

 										 dllEntry[2],

 										 dllEntry.iModified,

 										 iUpdate,

 										 driveData);

 	TEST(registered);

 	// Log message if implementations need update

 	if (!iUpdate)

 		{

 		TheTest.Printf(_L("Specified implementation group is already registered and does not need an update\n"));

 		}

 	//If the implementation needs an update, update it using UpdateDllDataL

 	else

 		{

 		TheTest.Printf(_L("Specified implementation group is not registered with date and needs an update\n"));

 		// Checks Implementation 0x10009E48 registered in the registry is version 1, display name is "Example 14 PlugIn"

 		// A reference to the implementation entry in the registry

 		const TUid implementationUid = {0x10009E48};

 		CRegistryData::CImplementationData*	implementationData = NULL;

 		TInt err = iStateAccessor->FindImplementation(*iRegistryData, implementationUid, KCDummyUid, implementationData);

 		TEST2(err,KErrNone);

 		CImplementationInformation* implementationInfo = implementationData->iImplInfo;

 		TEST(implementationInfo->Version() == 1);

 		TEST(implementationInfo->DisplayName().CompareF(_L("Example 14 PlugIn"))==0);

 		// Dll Data object to be updated

 		CRegistryData::CDllData* updateDllData = NULL;

 		TParse fileparse;

 		fileparse.Set(dllEntry.iName,NULL,NULL);

 		updateDllData = CRegistryData::CDllData::NewLC(fileparse.NameAndExt(),dllEntry.iModified,dllEntry[1], dllEntry[2],driveData);

 		//copies the upgraded resource file to C:

 		TRAP(err, EComTestUtils::FileManCopyFileL(KEcomExample14UpgradedOnZ, KEcomExample14UpgradedOnC));

 		TEST2(err, KErrNone);

 		//Creats the entry using upgraded resource file

 		TEntry rscBasedEntry;

 		rscBasedEntry.iName = KEcomExample14UpgradedResourceNameOnly;

 		TParse rscPath;

 		rscPath.Set(KEcomExample14UpgradedOnC,NULL,NULL);

 		CPluginBase* entryBase = NULL;

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

 		CleanupStack::PushL(entryBase);

 		// Updates resource ext info

 		HBufC* resourceExt = entryBase->RscFileExt();

 		if(resourceExt)

 			{

 			updateDllData->SetResourceExtL(*resourceExt);

 			}

 		// parses the upgraded resource file

 		TInt error = KErrNone;

 		TRAP(error, iRegistrarAccessor->ParseL(*iRegistrar, entryBase, *updateDllData));

 		if (error == KErrNoMemory)

 			{

 			User::LeaveNoMemory();

 			}

 		CleanupStack::PopAndDestroy(entryBase);

 		TDriveUnit aDrive;

 		// Updates DLL data with a new dll data

 		TRAP(err, iRegistryData->UpdateDllDataL(aDrive, iFoundDriveIndex, updateDllData));

 		TEST_OOM_ERR;

 		TEST2(err, KErrNone);

 		CleanupStack::Pop(updateDllData);

 		// Checks registry data is updated with new data

 		// Implementation 0x10009E48 is upgraded from version 1 to version 2, display name is changed to "Example 14 PlugIn3"

 		implementationData = NULL;

 		err = iStateAccessor->FindImplementation(*iRegistryData, implementationUid, KCDummyUid, implementationData);

 		TEST2(err,KErrNone);

 		implementationInfo = implementationData->iImplInfo;

 		TEST(implementationInfo->Version() == 2);

 		TEST(implementationInfo->DisplayName().CompareF(_L("Example 14 PlugIn3"))==0);

 		TheTest.Printf(_L("DLL data is updated \n"));

 		//deletes the upgraded resource file

 		TRAP(err,EComTestUtils::FileManDeleteFileL(KEcomExample14UpgradedOnC));

 		}

 	registered = iRegistryData->IsRegisteredWithDate(

 										 dllEntry[2],

 										 dllEntry.iModified,

 										 iUpdate,

 										 driveData);

 	TEST(registered);

 	TEST(!iUpdate);

 	}

 /**

 @SYMTestCaseID          SYSLIB-ECOM-UT-3570

 @SYMTestCaseDesc	    Tests for CRegistryData::UpdateDllDataL() function when an existing registered

 						PLUGIN3 is upgraded with an updated PLUGIN3 resource file.

 @SYMTestPriority 	    High

 @SYMTestActions  	    Update the data for a dll in the registry.

                         Tests for OOM error.

 @SYMTestExpectedResults The data for the dll in the registry is updated.

 @SYMEC                  EC43

 */

 void CRegistryDataTest::UpdateDllDataTest1L()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3570 "));

 	// Checks if drive is registered

 	TEST2(iStateAccessor->IsRegisteredDriveL(*iRegistryData, iDriveUnit),ETrue);

 	CRegistryData::CDriveData* driveData = NULL;

 	// Fetches index of drive, in iFoundDriveIndex

 	iFoundDriveIndex = iRegistryData->FindDriveL(iDriveUnit,driveData);

 	TEntry dllEntry;

 	TUid example12ThirdUid = {0x10009E3E};

 	dllEntry.iType = TUidType(KNullUid, KNullUid, example12ThirdUid);

 	dllEntry.iName = KEComExample12DllOnC;

 	dllEntry.iModified.HomeTime();

 	TBool registered = EFalse;

 	registered = iRegistryData->IsRegisteredWithDate(

 										 dllEntry[2],

 										 dllEntry.iModified,

 										 iUpdate,

 										 driveData);

 	TEST(registered);

 	// Log message if implementations need update

 	if (!iUpdate)

 		{

 		TheTest.Printf(_L("Specified implementation group is already registered and does not need an update\n"));

 		}

 	//If the implementation needs an update, update it using UpdateDllDataL

 	else

 		{

 		TheTest.Printf(_L("Specified implementation group is not registered with date and needs an update\n"));

 		// Checks Implementation 0x10009E3C registered in the registry is version 1

 		// A reference to the implementation entry in the registry

 		const TUid implementationUid = {0x10009E3C};

 		CRegistryData::CImplementationData*	implementationData = NULL;

 		TInt err = iStateAccessor->FindImplementation(*iRegistryData, implementationUid, KCDummyUid, implementationData);

 		TEST2(err,KErrNone);

 		CImplementationInformation* implementationInfo = implementationData->iImplInfo;

 		TEST(implementationInfo->Version() == 1);

 		// Dll Data object to be updated

 		CRegistryData::CDllData* updateDllData = NULL;

 		TParse fileparse;

 		fileparse.Set(dllEntry.iName,NULL,NULL);

 		updateDllData = CRegistryData::CDllData::NewLC(fileparse.NameAndExt(),dllEntry.iModified,dllEntry[1], dllEntry[2],driveData);

 		//copies the upgraded resource file to C:

 		TRAP(err, EComTestUtils::FileManCopyFileL(KEcomExample12UpgradedOnZ, KEcomExample12UpgradedOnC));

 		TEST_OOM_ERR;

 		TEST2(err, KErrNone);

 		//Creats the entry using upgraded resource file

 		TEntry rscBasedEntry;

 		rscBasedEntry.iName = KEcomExample12UpgradedResourceNameOnly;

 		TParse rscPath;

 		rscPath.Set(KEcomExample12UpgradedOnC,NULL,NULL);

 		CPluginBase* entryBase = NULL;

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

 		CleanupStack::PushL(entryBase);

 		// Updates resource ext info

 		HBufC* resourceExt = entryBase->RscFileExt();

 		if(resourceExt)

 			{

 			updateDllData->SetResourceExtL(*resourceExt);

 			}

 		// parses the upgraded resource file

 		TInt error = KErrNone;

 		TRAP(error, iRegistrarAccessor->ParseL(*iRegistrar, entryBase, *updateDllData));

 		if (error == KErrNoMemory)

 			{

 			User::LeaveNoMemory();

 			}

 		CleanupStack::PopAndDestroy(entryBase);

 		TDriveUnit aDrive;

 		// Updates DLL data with a new dll data

 		TRAP(err, iRegistryData->UpdateDllDataL(aDrive, iFoundDriveIndex, updateDllData));

 		TEST_OOM_ERR;

 		TEST2(err, KErrNone);

 		CleanupStack::Pop(updateDllData);

 		// Checks registry data is updated with new data

 		// Implementation 0x10009E3C is upgraded from version 1 to version 2

 		implementationData = NULL;

 		err = iStateAccessor->FindImplementation(*iRegistryData, implementationUid, KCDummyUid, implementationData);

 		TEST_OOM_ERR;

 		TEST2(err,KErrNone);

 		implementationInfo = implementationData->iImplInfo;

 		TEST(implementationInfo->Version() == 2);

 		TheTest.Printf(_L("DLL data is updated \n"));

 		//cleans the upgraded resource file

 		TRAP(err,EComTestUtils::FileManDeleteFileL(KEcomExample12UpgradedOnC));

 		}

 	registered = iRegistryData->IsRegisteredWithDate(

 										 dllEntry[2],

 										 dllEntry.iModified,

 										 iUpdate,

 										 driveData);

 	TEST(registered);

 	TEST(!iUpdate);

 	}

 /**

 @SYMTestCaseID          SYSLIB-ECOM-UT-3569

 @SYMTestCaseDesc	    Tests for CRegistryData::AddDllDataL() function using Dll type PLUGIN3

 @SYMTestPriority 	    High

 @SYMTestActions  	    Adds data on a specific dll to the registry.

                         Tests for OOM error,checks if drive is registered.

 @SYMTestExpectedResults Dll data is added to the registry.

 @SYMEC                  EC43

 */

 void CRegistryDataTest::AddDllDataPlugIn3TestL()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3569 "));

 	// Checks if drive is registered

 	TEST(iStateAccessor->IsRegisteredDriveL(*iRegistryData, iDriveUnit)!= KErrNotFound);

 	CRegistryData::CDriveData* driveData = NULL;

 	// Fetches index of drive, in iFoundDriveIndex

 	iFoundDriveIndex = iRegistryData->FindDriveL(iDriveUnit,driveData);

 	TEntry dllEntry;

 	TUid example10ThirdUid = {0x10009E37};

 	dllEntry.iType = TUidType(KNullUid, KNullUid, example10ThirdUid);

 	dllEntry.iName = KEComExample10DllOnC;

 	TBool registered = EFalse;

 	TRAPD(err, registered = iRegistryData->IsRegisteredWithDate(

 										 dllEntry[2],

 										 dllEntry.iModified,

 										 iUpdate,

 										 driveData));

 	TEST_OOM_ERR;

 	TEST2(err, KErrNone);

 	TEST(!registered);

 	// Dll Data object to be added

 	CRegistryData::CDllData* addDllData = NULL;

 	TParse fileparse;

 	fileparse.Set(dllEntry.iName,NULL,NULL);

 	addDllData = CRegistryData::CDllData::NewLC(fileparse.NameAndExt(),dllEntry.iModified,dllEntry[1], dllEntry[2],driveData);

 	// Adds DLL data of an existing DLL

 	TRAP(err, iRegistryData->AddDllDataL(iDriveUnit, iFoundDriveIndex, addDllData));

 	TEST_OOM_ERR;

 	CleanupStack::Pop(addDllData);

 	TEST2(err, KErrNone);

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

 	TEST_OOM_ERR;

 	TEST2(err, KErrNone);

 	TRAP(err, registered = iRegistryData->IsRegisteredWithDate(

 										 dllEntry[2],

 										 dllEntry.iModified,

 										 iUpdate,

 										 driveData));

 	TEST_OOM_ERR;

 	TEST2(err, KErrNone);

 	TEST(registered);

 	// Do not delete addDllData as ownership is with the iRegistryData

 	}

 /**

 Adds the dll data on a perticular drive.

 @SYMTestCaseID          SYSLIB-ECOM-CT-0738

 @SYMTestCaseDesc	    Tests for CRegistryData::AddDllDataL() function

 @SYMTestPriority 	    High

 @SYMTestActions  	    Adds data on a specific dll to the registry.

                         Tests for OOM error,checks if drive is registered.

 @SYMTestExpectedResults The test must not fail.

 @SYMREQ                 REQ0000

 */

 void CRegistryDataTest::AddDllDataTestL()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0738 "));

 	// Check if drive is registered

 	TEST(iStateAccessor->IsRegisteredDriveL(*iRegistryData, iDriveUnit)!= KErrNotFound);

 	CRegistryData::CDriveData* driveData = NULL;

 	// Fetch index of drive, in iFoundDriveIndex

 	iFoundDriveIndex = iRegistryData->FindDriveL(iDriveUnit,driveData);

 	iRegistryData->IsRegisteredWithDate(

 										 iDllEntry[2],

 										 iDllEntry.iModified,

 										 iUpdate,

 										 driveData);

 	// Dll Data object to be added

 	CRegistryData::CDllData*			addDllData=NULL;

 	TParse fileparse;

 	fileparse.Set(iDllEntry.iName,NULL,NULL);

 	addDllData = CRegistryData::CDllData::NewLC(fileparse.NameAndExt(),iDllEntry.iModified,iDllEntry[1], iDllEntry[2],driveData);

 	// Add DLL data of an existing DLL

 	TRAPD(err, iRegistryData->AddDllDataL(iDriveUnit, iFoundDriveIndex, addDllData));

 	TEST_OOM_ERR;

 	CleanupStack::Pop(addDllData);

 	TEST2(err, KErrNone);

 	TBool registered = EFalse;

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

 	TEST_OOM_ERR;

 	TEST2(err, KErrNone);

 	TRAP(err, registered = iRegistryData->IsRegisteredWithDate(

 										 iDllEntry[2],

 										 iDllEntry.iModified,

 										 iUpdate,

 										 driveData));

 	TEST_OOM_ERR;

 	TEST2(err, KErrNone);

 	TEST(registered);

 	// Do not delete addDllData as ownership is with the iRegistryData

 	}

 /**

 Determines if the specified implementation is already registered and

 updates the data for the dll in the registry if it needs an update

 @SYMTestCaseID          SYSLIB-ECOM-CT-0739

 @SYMTestCaseDesc	    Tests for CRegistryData::UpdateDllDataL() function

 @SYMTestPriority 	    High

 @SYMTestActions  	    Update the data for a dll in the registry if it needs an update.

                         Tests for OOM error.

 @SYMTestExpectedResults The test must not fail.

 @SYMREQ                 REQ0000

 */

 void CRegistryDataTest::IsRegisteredWithDateUpdateDllDataTestL()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0739 "));

 	TBool result=EFalse;

 	CRegistryData::CDriveData* driveData = NULL;

 	TInt err = KErrNone;

 	// Here we are doing positive testing. We are testing with valid entry.

 	// If that is not registered, register it using UpdateDllDataL

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

 	TEST_OOM_ERR;

 	TEST2(err, KErrNone);

 	TRAP(err, result = iRegistryData->IsRegisteredWithDate(

 					  										 iDllEntry[2],

 															 iDllEntry.iModified,

 															 iUpdate,

 															 driveData));

 	TEST_OOM_ERR;

 	TEST2(err, KErrNone);

 	// Log message if implementations need update

 	if(result)

 		{

 		if(!iUpdate)

 			{

 			TEST(!iUpdate);

 			TheTest.Printf(_L("Specified implementation group is already registered and does not need an update\n"));

 			}

 		else

 			{

 			TheTest.Printf(_L("Specified implementation group is not registered with date and needs an update\n"));

 			// Dll Data object to be updated

 			CRegistryData::CDllData*			updateDllData=NULL;

 			TParse fileparse;

 			fileparse.Set(iDllEntry.iName,NULL,NULL);

 			updateDllData = CRegistryData::CDllData::NewLC(fileparse.NameAndExt(),iDllEntry.iModified,iDllEntry[1],iDllEntry[2],driveData);

 			TDriveUnit aDrive;

 			// Updates DLL data with a new dll data

 			TRAP(err, iRegistryData->UpdateDllDataL(aDrive, iFoundDriveIndex, updateDllData));

 			TEST_OOM_ERR;

 			CleanupStack::Pop(updateDllData);

 			TEST2(err, KErrNone);

 			// Print to that dll data is updated else we won't know we did.

 			TheTest.Printf(_L("DLL data is updated \n"));

 			}

 		}

 	TUid thirdUid = {0x101F8400};

 	iDllEntry.iType = TUidType(KNullUid, KNullUid, thirdUid);

 	// Here we are doing negative testing. We are testing with invalid entry.

 	// The result should be false

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

 	TEST_OOM_ERR;

 	TEST2(err, KErrNone);

 	TRAP(err, result = iRegistryData->IsRegisteredWithDate(

 					  										iDllEntry[2],

 															iDllEntry.iModified,

 															iUpdate,

 															driveData));

 	TEST_OOM_ERR;

 	TEST2(err, KErrNone);

 	TEST(!result);

 	}

 /**

 Tests that an implementation is disabled and enabled by setting the state

 @SYMTestCaseID          SYSLIB-ECOM-CT-0740

 @SYMTestCaseDesc	    Tests for CRegistryData::SetEnabledState() function

 @SYMTestPriority 	    High

 @SYMTestActions  	    Tests for enable or disable the specified interface implementation

 						within the registry.

 @SYMTestExpectedResults The test must not fail.

 @SYMREQ                 REQ0000

 */

 void CRegistryDataTest::SetEnabledStateTestL()

 	{

 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0740 "));

 	// A reference to the implementation entry in the registry

 	CRegistryData::CImplementationData*	implementationData = NULL;

 	// Pass the state and enable or disable the implementaion

 	TInt err;

 	err = iStateAccessor->FindImplementation(*iRegistryData, iImplementationUid, KCDummyUid, implementationData);

 	TEST2(err, KErrNone);