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