// 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