1 // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // This file contains test classes and their implementations

    15 // to test production class CRegistryData. Where necessary stubs

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

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

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

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

    20 // 

    21 //

    22 

    23 #include <ecom/ecom.h>

    24 #include "EComUidCodes.h"

    25 #include "RegistrarObserver.h"

    26 #include "RegistryData.h"

    27 #include "Registrar.h"

    28 #include "EComResolverParams.h"

    29 #include "Discoverer.h"

    30 #include "DiscovererObserver.h"

    31 #include "DriveInfo.h"

    32 #include "DowngradePath.h"

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

    34 #include "RegistryResolveTransaction.h"

    35 #include "ParseImplementationData.h"

    36 

    37 #include <ecom/ecompanics.h>

    38 #include <s32file.h>

    39 #include <e32test.h>

    40 #include <f32file.h>

    41 #include <bautils.h>

    42 #include <babackup.h>

    43 #include <hal.h>

    44 

    45 #define UNUSED_VAR(a) a = a

    46 

    47 // Used within tests

    48 const TUid KCExampleInterfaceUid = {0x10009DC0};

    49 const TUid KCExampleInterfaceImp = {0x10009DC3};

    50 const TUid KCDummyUid = {0x00000000};

    51 const TUid KCInvalidUid = {0x10009999};

    52 

    53 const TInt KOneSecond = 1000000;

    54 

    55 // Used for suppressing warning in OOM tests

    56 #define __UNUSED_VAR(var) var = var

    57 

    58 // Used for OOM test

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

    60 

    61 // The implemented structure for the registry data

    62 typedef CRegistryData::CImplementationData* CImplementationDataPtr;

    63 typedef RArray<CImplementationDataPtr> RImplDataArray;

    64 

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

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

    67 

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

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

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

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

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

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

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

    75 

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

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

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

    79 

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

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

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

    83 

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

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

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

    87 

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

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

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

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

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

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

    94 

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

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

    97 

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

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

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

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

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

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

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

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

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

   107 

   108 //PLUGIN1 DLL with interfaceID: 0x10009E36

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

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

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

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

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

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

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

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

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

   118 //PLUGIN3 DLL with interfaceID: 0x10009E36

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

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

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

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

   123 

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

   125 //PLUGIN3 Upgraded

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

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

   128 _LIT(KEcomExample12UpgradedResourceNameOnly, "EComExample12Upgraded.rsc");

   129 //PLUGIN1 Upgraded to PLUGIN3

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

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

   132 _LIT(KEcomExample14UpgradedResourceNameOnly, "EComExample14Upgraded.rsc");

   133 //PLUGIN3 Downgraded to PLUGIN1

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

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

   136 _LIT(KEcomExample12DowngradedResourceNameOnly, "EComExample12Downgraded.rsc");

   137 

   138 _LIT(KDriveC, "C");

   139 

   140 #ifndef SYMBIAN_DISTINCT_LOCALE_MODEL

   141     _LIT(KEnglishLocale, "elocl.01");

   142     _LIT(KEComSpanishLocale, "elocl.04");

   143 #else

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

   145     // Language

   146     _LIT(KEComEnglishLang,"elocl_lan.001");

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

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

   149     _LIT(KEComSpanishLang,"elocl_lan.004");

   150     // Region

   151     _LIT(KEComEnglishReg,"elocl_reg.826");

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

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

   154     _LIT(KEComSpanishReg,"elocl_reg.724");

   155     // Collation

   156     _LIT(KEComEnglishColl,"elocl_col.001");

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

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

   159     _LIT(KEComSpanishColl,"elocl_col.001");

   160 #endif

   161 

   162 LOCAL_D CTrapCleanup*		TheTrapCleanup=NULL;

   163 

   164 LOCAL_D CActiveScheduler*	TheActiveScheduler=NULL;

   165 

   166 LOCAL_D RFs					TheFs;

   167 

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

   169 

   170 //TPtrC defined which will point to KEComSpiFilePathAndName or KEComSpiFilePathAndNameForNand

   171 //according to the rom build type

   172 LOCAL_D TPtrC				TheEComSpiFilePathAndNamePtrC;

   173 

   174 TCapabilitySet dummycaps;

   175 

   176 LOCAL_C void CopyPluginsL();

   177 

   178 inline LOCAL_C void DeleteTestPlugin()

   179 	{

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   199 	}

   200 

   201 //

   202 //

   203 //Test macroses and functions

   204 LOCAL_C void Check(TInt aValue, TInt aLine)

   205 	{

   206 	if(!aValue)

   207 		{

   208 		::DeleteTestPlugin();

   209 		TheTest(EFalse, aLine);

   210 		}

   211 	}

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

   213 	{

   214 	if(aValue != aExpected)

   215 		{

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

   217 		::DeleteTestPlugin();

   218 		TheTest(EFalse, aLine);

   219 		}

   220 	}

   221 /**

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

   223 */

   224 LOCAL_C void SetLanguageL(const TLanguage aLang[3])

   225 	{

   226 	TLocale locale;

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

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

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

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

   231 	}

   232 

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

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

   235 //

   236 //

   237 

   238 /**

   239 This class allows us to provide stub behavior to instantiate CRegistrar

   240 */

   241 class TRegistrarObserverStub : public MRegistrarObserver

   242 	{

   243 public:

   244 /**

   245 The overloaded method from the MRegistrarObserver class Used for firing

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

   247 @post		The CEComServer has notified all its client sessions

   248 			registered for notifications that the data changed

   249 */

   250 	void Notification(TInt aNotificationCode)

   251 		{

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

   253 		};

   254 	};

   255 

   256 /**

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

   258 code class CDiscoverer.

   259 */

   260 class TDiscoverer_StateAccessor

   261 	{

   262 public:

   263 	TDiscoverer_StateAccessor() {};

   264 	void ScanDirectoryL(CDiscoverer& aDiscoverer)

   265 		{

   266 		aDiscoverer.ProcessSSAEventL(EStartupStateNonCritical);

   267 		}

   268 	void ScanDriveL(CDiscoverer& aDiscoverer, TDriveUnit& aDrive)

   269 		{

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

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

   272 		}

   273 	};

   274 

   275 /**

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

   277 code class CRegistrar.

   278 */

   279 class TRegistrar_StateAccessor

   280 	{

   281 public:

   282 	TRegistrar_StateAccessor() {};

   283 	void ScanDirectoryL(CRegistrar& aRegistrar)

   284 		{

   285 		TDiscoverer_StateAccessor discovererStateAccessor;

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

   287 		}

   288 	void ScanDriveL(CRegistrar& aRegistrar, TDriveUnit& aDrive)

   289 		{

   290 		TDiscoverer_StateAccessor discovererStateAccessor;

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

   292 		}

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

   294 	};

   295 

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

   297 		{

   298 		aRegistrar.ParseL(aEntry,aDll);

   299 		}

   300 

   301 

   302 /**

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

   304 code class CRegistryData.

   305 */

   306 class TRegistryData_StateAccessor

   307 	{

   308 public:

   309 	TBool IsIndexValid(CRegistryData& aRegData);

   310 

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

   312 

   313 	TBool IsRegisteredDriveL(CRegistryData& aRegData, TDriveUnit aDriveUnit);

   314 

   315 	TInt RegistrationsCount(CRegistryData& aRegData);

   316 

   317 	TInt ImplementationsCount(CRegistryData& aRegData);

   318 

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

   320 

   321 	void ClearImplementationIndexList(CRegistryData& aRegData);

   322 

   323 	void ClearRegistrations(CRegistryData& aRegData);

   324 

   325 	void ResetAndDestroy(CRegistryData& aRegData);

   326 

   327 	void ConstructL(CRegistryData& aRegData);

   328 

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

   330 

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

   332 

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

   334 

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

   336 										CRegistryData::CImplementationData*& aImplData) const;

   337 	static void ResetStaticDriveData();

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

   339 	TBool IsLanguageInitChanged(CRegistryData& aRegistryData);

   340 	TInt DrivesRemoved(CRegistryData& aRegistryData);

   341 	};

   342 

   343 /**

   344 Constructs the registry

   345 

   346 */

   347 void TRegistryData_StateAccessor::ConstructL(CRegistryData& aRegData)

   348 	{

   349 	aRegData.ConstructL();

   350 	}

   351 

   352 /**

   353 Resets the registry

   354 

   355 */

   356 void TRegistryData_StateAccessor::ResetAndDestroy(CRegistryData& aRegData)

   357 	{

   358 	aRegData.iRegistrations->ResetAndDestroy();

   359 	delete aRegData.iRegistrations;

   360 	}

   361 

   362 /**

   363 Clears the Implementations

   364 @param		aRegData RegistryData object under test

   365 */

   366 void TRegistryData_StateAccessor::ClearImplementationIndexList(CRegistryData& aRegData)

   367 	{

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

   369 		{

   370 		aRegData.iInterfaceImplIndex[index].Reset();

   371 		}

   372 	aRegData.iInterfaceImplIndex.Reset();

   373 	aRegData.iImplIndex.Reset();

   374 	}

   375 

   376 

   377 /**

   378 Clears the Registrations

   379 @param		aRegData RegistryData object under test

   380 */

   381 void TRegistryData_StateAccessor::ClearRegistrations(CRegistryData& aRegData)

   382 	{

   383 	if(aRegData.iRegistrations)

   384 		{

   385 		aRegData.iRegistrations->ResetAndDestroy();

   386 		}

   387 	}

   388 

   389 /**

   390 Indicates whether the registry index is currently valid. The

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

   392 @param		aRegData RegistryData object under test

   393 @return		ETrue if index is valid EFalse otherwise

   394 */

   395 TBool TRegistryData_StateAccessor::IsIndexValid(CRegistryData& aRegData)

   396 	{

   397 	return aRegData.IndexValid();

   398 	}

   399 

   400 /**

   401 Tries to find the index entry of the passed implementation uid

   402 @param		aRegData RegistryData object under test

   403 @param		aImplementationUid the implementation Uid of the implementation to locate

   404 @return		Index of the implementation, KErrNotFound otherwise

   405 */

   406 TInt TRegistryData_StateAccessor::IndexedFind(CRegistryData& aRegData,

   407 											  const TUid& aImplementationUid)

   408 	{

   409 	return aRegData.IndexedFind(aImplementationUid);

   410 	}

   411 

   412 /**

   413 Checks if the drive is already registered

   414 @param		aRegData RegistryData object under test

   415 @param		aDriveUnit the drive on which plugins are registered

   416 @return		ETrue if drive is registered, EFalse otherwise

   417 */

   418 TBool TRegistryData_StateAccessor::IsRegisteredDriveL(CRegistryData& aRegData,

   419 													 TDriveUnit aDriveUnit)

   420 	{

   421 	TInt driveIndex = KErrNotFound;

   422 	CRegistryData::CDriveData* aDriveData=NULL;

   423 	driveIndex = aRegData.FindDriveL(aDriveUnit, aDriveData);

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

   425 	return (driveIndex != KErrNotFound);

   426 	}

   427 

   428 /**

   429 Obtains count of plugin registrations

   430 @param		aRegData RegistryData object under test

   431 @return		Number of registrations

   432 */

   433 TInt TRegistryData_StateAccessor::RegistrationsCount(CRegistryData& aRegData)

   434 	{

   435 	return aRegData.iRegistrations->Count();

   436 	}

   437 

   438 /**

   439 Obtains count of plugin registrations

   440 @param		aRegData RegistryData object under test

   441 @return		Number of registrations

   442 */

   443 TInt TRegistryData_StateAccessor::ImplementationsCount(CRegistryData& aRegData)

   444 	{

   445 	return aRegData.iInterfaceImplIndex.Count();

   446 	}

   447 

   448 /**

   449 Sets Registry Changed flag to the given value

   450 @param		aRegData RegistryData object under test

   451 @param		aChanged True if the registry is changed

   452 @param		aDrive the drive under test

   453 */

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

   455 	{

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

   457 		{

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

   459 			{

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

   461 			}

   462 		}

   463 	}

   464 

   465 /**

   466 See if an implementation is discovered on the questioned drive

   467 @param		aRegData RegistryData object under test

   468 @param		aInterfaceUid Interface UID for the implementation

   469 @param		aDrive Drive to search the implementation on

   470 @return 	ETrue if an implementation exists

   471 */

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

   473 	{

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

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

   476 		{

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

   478 		if(driveData->iDrive == aDrive)

   479 			{

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

   481 			const TInt dllCount = dllList->Count();

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

   483 				{

   484 				// For each dll structure

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

   486 				const TInt ifCount = interfaceList->Count();

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

   488 					{

   489 					CRegistryData::TInterfaceIndex index;

   490 

   491 					// For each interface structure

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

   493 					if(interfaceUid == aInterfaceUid)

   494 						{

   495 						return ETrue;

   496 						}

   497 					}

   498 				}

   499 			}

   500 		}

   501 

   502 	return EFalse;

   503 	}

   504 

   505 /**

   506 Get implementation info from the index

   507 @param		aRegData RegistryData object under test

   508 @param		aInterfaceUid Interface UID for the implementation

   509 @param  	aImplementationData Reference of array of Implementation Data

   510 */

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

   512 	{

   513 	aRegData.ListImplementationsL(aInterfaceUid, aImplementationData);

   514 	}

   515 

   516 /**

   517 Append DriveSata to iRegistrations

   518 @param		aRegData RegistryData object under test

   519 @param		aInterfaceUid Interface UID for the implementation

   520 @return 	Array of Implementations

   521 */

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

   523 	{

   524 	aRegData.iRegistrations->AppendL(aDriveData);

   525 	}

   526 

   527 /**

   528 @param		aRegistryData The CRegistryData class object

   529 @param		aImplUid The implementation to find.

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

   531 			implementation to find.

   532 @param		aImplData The found implementation data.

   533 @return		KErrNone if found otherwise KErrNotFound

   534 */

   535 TInt TRegistryData_StateAccessor::FindImplementation(CRegistryData& aRegistryData,

   536 												const TUid aImplUid,

   537 												const TUid aInterfaceUid,

   538 												CRegistryData::CImplementationData*& aImplData) const

   539 	{

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

   541 	}

   542 

   543 /**

   544 @param		aRegistryData The CRegistryData class object

   545 @param		aDriveUnit A drive unit

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

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

   548 */

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

   550 {

   551 	CRegistryData::CDriveData* drive =NULL;

   552 

   553 	// Get the drive data in the registry.

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

   555 	if(registryDriveIndex != KErrNotFound)

   556 		{

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

   558 		}

   559 	return registryDriveIndex;

   560 }

   561 

   562 /**

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

   564 @param		aRegData RegistryData object under test

   565 @return		ETrue if index is valid EFalse otherwise

   566 */

   567 TBool TRegistryData_StateAccessor::IsLanguageInitChanged(CRegistryData& aRegistryData)

   568 {

   569 	return aRegistryData.iLanguageChanged;

   570 }

   571 

   572 TInt TRegistryData_StateAccessor::DrivesRemoved(CRegistryData& aRegistryData)

   573 	{

   574 		return aRegistryData.iRemovedDrives;

   575 	}

   576 

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

   578 CRegistryData::CImplementationData.

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

   580 */

   581 _LIT8(KDefaultImplDataType, "Data Type");

   582 _LIT8(KDefaultImplOpaqueData, "");

   583 

   584 struct TImplCreationStruct

   585 	{

   586 	TImplCreationStruct(TDriveNumber aDriveNumber,

   587 						TUid  aInterfaceUid,

   588 						TUid  aImplUid,

   589 						const TDesC& aDllPathName,

   590 						const TDesC& aImplDisplayName,

   591 						const TDesC8& aImplDataType = KDefaultImplDataType,

   592 						const TDesC8& aImplOpaqueData = KDefaultImplOpaqueData,

   593 						TInt  aImplVersion = 1,

   594 						TBool aRomBased = EFalse,

   595 						TBool aRomOnly = EFalse);

   596 

   597 	TDriveUnit		iDriveUnit;

   598 	TUid			iInterfaceUid;

   599 	TUid			iImplUid;

   600 	const TDesC&	iDllPathName;

   601 	const TDesC&	iImplDisplayName;

   602 	const TDesC8&	iImplDataType;

   603 	const TDesC8&	iImplOpaqueData;

   604 	TInt			iDriveIndex;

   605 	CRegistryData::CDriveData*		iDriveData;

   606 	CRegistryData::CDllData*		iDllData;

   607 	CRegistryData::CInterfaceData*	iInterfaceData;

   608 	CRegistryData::CImplementationData* iImplData;

   609 	TInt			iImplVersion;

   610 	TBool			iRomBased;

   611 	TBool			iRomOnly;

   612 	};

   613 

   614 // TImplCreationStruct Constructor

   615 TImplCreationStruct::TImplCreationStruct(TDriveNumber aDriveNumber,

   616 										TUid  aInterfaceUid,

   617 										TUid  aImplUid,

   618 										const TDesC& aDllPathName,

   619 										const TDesC& aImplDisplayName,

   620 										const TDesC8& aImplDataType,

   621 										const TDesC8& aImplOpaqueData,

   622 										TInt  aImplVersion,

   623 										TBool aRomBased,

   624 										TBool aRomOnly)

   625 	: iDriveUnit(aDriveNumber), iInterfaceUid(aInterfaceUid),

   626 	iImplUid(aImplUid), iDllPathName(aDllPathName),

   627 	iImplDisplayName(aImplDisplayName), iImplDataType(aImplDataType),

   628 	iImplOpaqueData(aImplOpaqueData), iDriveIndex(KErrNotFound),

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

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

   631 	iRomOnly(aRomOnly)

   632 	{

   633 	}

   634 

   635 /**

   636 Test class encloses necessary members that aid to test CRegistryData

   637 */

   638 class CRegistryDataTest: public CBase

   639 	{

   640 public:

   641 	static CRegistryDataTest* NewL(TBool aIsFullDiscovery);

   642 

   643 	virtual ~CRegistryDataTest();

   644 

   645 	void AddDllDataPlugIn3TestL();

   646 	void AddDllDataTestL();

   647 

   648 	void IsRegisteredWithDateUpdateDllDataTestL();

   649 	void CopyOrgPlugInL();

   650 	void UpdateDllDataTest1L();

   651 	void UpdateDllDataTest2L();

   652 	void UpdateDllDataTest3L();

   653 

   654 	void SetEnabledStateTestL();

   655 

   656 	void FindImplementationTestL();

   657 	//Test for ListImplementationsL() in CRegistryData

   658 	void ListImplementationsL();

   659 	//Test for ListImplementationsL() in CRegistryResolverTransaction

   660 	void ListImplementationsTestT1L();

   661 	void ListImplementationsTestT2L();

   662 	void ListImplementationsTestT3L();

   663 	void ListImplementationsTestT4L();

   664 	void ListImplementationsTestT5L();

   665 

   666 	//Test for ListExtendedInterfacesL() in CRegistryData

   667 	void ListExtendedInterfacesTestL();

   668 

   669 	void DoUndoTemporaryUninstallTestL();

   670 

   671 	void DiscoveriesBeginCompleteTestL();

   672 

   673 	void IndexedFindTestL();

   674 

   675 	void GetImplementationDllInfoForServerTest();

   676 

   677 	void GetImplementationDllInfoForClientTestL();

   678 

   679 	void GetImplementationDllInfoForServerPlugIn3Test();

   680 

   681 	void GetImplementationDllInfoForClientPlugIn3TestL();

   682 

   683 	void VerifySelectNewPluginTypeL();

   684 

   685 	void AllAtOnceDiscoveryStateTransitionTestL();

   686 

   687 	void StagedDiscoveryStateTransitionTestL();

   688 

   689 	void ImplementationDataTestL();

   690 

   691 	void InsertIntoIndexRemoveFromIndexTestL();

   692 

   693 	void RollbackTestL();

   694 

   695 	void ProcessSecurityCheckTestL();

   696 

   697 	void FailedSecurityCheckTestListImplementationsL();

   698 

   699 	void FailedSecurityCheckTestGetImplementationInfoL();

   700 

   701 	void IsAnyDllDiscoveredTestL();

   702 	void IsAnyDllDiscoveredTestNoSpiL();

   703 	void IsAnyDllDiscoveredTestWithSpiL();

   704 

   705 	void CheckDuplicatPluginsOnCL();

   706 

   707 	void CheckNoPluginsOnCL();

   708 

   709 	void DuplicateImplUidTestL();

   710 	void TestDuplicatedImplPrecedenceL(const TImplCreationStruct& highprecedence,

   711 									const TImplCreationStruct& lowprecedence);

   712 

   713 	static TBool SpiFileExists();

   714 

   715 	void LanguageChangedTestL();

   716 

   717 	void DrivesRemovedTestL();

   718 private:

   719 	CRegistryDataTest();

   720 

   721 	void ConstructL(TBool aIsFullDiscovery);

   722 

   723 	void CreateImplL(TImplCreationStruct& aCreationData);

   724 public:

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

   726 	CRegistryData*						iRegistryData;

   727 

   728 	/** Registrar observer test class */

   729 	TRegistrarObserverStub* iRegistrarObserver;

   730 

   731 	/** CRegistrar required for populating the CRegistryData */

   732 	CRegistrar*							iRegistrar;

   733 	/** CRegistrar state accessor */

   734 	TRegistrar_StateAccessor* iRegistrarAccessor;

   735 

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

   737 	RImplInfoArray*						iUidList;

   738 

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

   740 	RImplDataArray						iImplDataList;

   741 

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

   743 	TRegistryData_StateAccessor*		iStateAccessor;

   744 

   745 	/** The current drive unit identifier */

   746 	TDriveUnit							iDriveUnit;

   747 

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

   749 	TUid								iImplementationUid;

   750 

   751 	/** UID to identify a particular interface */

   752 	TUid								iInterfaceUid;

   753 

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

   755 	TEntry								iDllEntry;

   756 

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

   758 	TBool								iUpdate;

   759 

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

   761 	TInt								iFoundDriveIndex;

   762 

   763 	};

   764 

   765 /**

   766 Creates a new CRegistryDataTest object

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

   768 @return		A pointer to the newly created class.

   769 */

   770 CRegistryDataTest* CRegistryDataTest::NewL(TBool aIsFullDriveCDiscovery)

   771 	{

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

   773 	CleanupStack::PushL(self);

   774 	self->ConstructL(aIsFullDriveCDiscovery);

   775 	CleanupStack::Pop();

   776 	return self;

   777 	}

   778 

   779 /**

   780 Standardized default constructor

   781 @post		CRegistryDataTest is fully constructed.

   782 */

   783 CRegistryDataTest::CRegistryDataTest()

   784 :	CBase()

   785 	{

   786 	iDriveUnit = EDriveC;

   787 

   788 	TUid thirdUid = {0x101F847B};

   789 

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

   791 	iDllEntry.iName = KEComExDllOnC;

   792 

   793 	iInterfaceUid.iUid		= KCExampleInterfaceUid.iUid;

   794 	iImplementationUid.iUid	= KCExampleInterfaceImp.iUid;

   795 	}

   796 

   797 /**

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

   799 Completes the safe construction of the CRegistryDataTest object

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

   801 @post		CRegistryDataTest is fully constructed.

   802 @leave		KErrNoMemory.

   803 */

   804 void CRegistryDataTest::ConstructL(TBool aIsFullDriveCDiscovery)

   805 	{

   806 	iUidList = new(ELeave) RImplInfoArray;

   807 	iStateAccessor= new(ELeave) TRegistryData_StateAccessor;

   808 	iRegistryData = CRegistryData::NewL(TheFs);

   809 	iRegistrarObserver=new (ELeave) TRegistrarObserverStub;

   810 	iRegistrarAccessor=new (ELeave) TRegistrar_StateAccessor;

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

   812 	if (aIsFullDriveCDiscovery)

   813 		{

   814 		TDriveUnit driveUnitC = EDriveC;

   815 		iRegistrarAccessor->ScanDriveL(*iRegistrar,driveUnitC);

   816 		}

   817 	}

   818 

   819 /**

   820 Standard destructor

   821 */

   822 CRegistryDataTest::~CRegistryDataTest()

   823 	{

   824 	delete iUidList;

   825 	delete iStateAccessor;

   826 	delete iRegistrarAccessor;

   827 	delete iRegistrar;

   828 	delete iRegistrarObserver;

   829 	delete iRegistryData;

   830 	}

   831 

   832 /**

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

   834 */

   835 TBool CRegistryDataTest::SpiFileExists()

   836 	{

   837 	TEntry entry;

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

   839 		{

   840 		return ETrue;

   841 		}

   842 	return EFalse;

   843 	}

   844 

   845 /**

   846 @SYMTestCaseID          SYSLIB-ECOM-UT-3712

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

   848 @SYMTestPriority 	    High

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

   850 						interface Uid.

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

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

   853 						interface is ignored in release mode.

   854 @SYMDEF                 DEF111196

   855 */

   856 LOCAL_C void AddExtendedInterfaceTestL()

   857 	{

   858 	

   859 	// Test Starts...

   860 	TUid testImplUid;

   861 	testImplUid.iUid = KCExampleInterfaceUid.iUid;

   862 	TInt testImplVersion = 2;

   863 	_LIT(KTestImplName, "Implementation");

   864 	_LIT8(KTestImplDataType, "Data Type");

   865 	_LIT8(KTestImplOpaqueData, "Opaque Data");

   866 	TUid testExtendedInterfaceUid1;

   867 	TUid testExtendedInterfaceUid2;

   868 	testExtendedInterfaceUid1.iUid = 0x10009E44;

   869 	testExtendedInterfaceUid2.iUid = 0x10009E45;

   870 

   871 	TDriveUnit testImplDrive = EDriveC;

   872 	TBool testImplRomOnly = ETrue;

   873 	TBool testImplRomBased = EFalse;

   874 

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

   876 	CleanupStack::PushL(registryData);

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

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

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

   880 

   881 	// NewL test

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

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

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

   885 

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

   887 

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

   889 

   890 	CRegistryData::CImplementationData* implementationData;

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

   892 															testImplUid,

   893 															testImplVersion,

   894 															name,

   895 															dataType,

   896 															opaqueData,

   897 															testImplDrive,

   898 															testImplRomOnly,

   899 															testImplRomBased,

   900 															extendedInterfaces);

   901 

   902 	CleanupStack::Pop(extendedInterfaces);

   903 	CleanupStack::Pop(opaqueData);

   904 	CleanupStack::Pop(dataType);

   905 	CleanupStack::Pop(name);

   906 

   907 	CleanupStack::PushL(implementationData);

   908 	TEST(interfaceData == implementationData->iParent);

   909 

   910 	//Add extended interface

   911 	implementationData->iImplInfo->AddExtendedInterfaceL(testExtendedInterfaceUid1);

   912 	implementationData->iImplInfo->AddExtendedInterfaceL(testExtendedInterfaceUid2);

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

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

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

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

   917 	// is ignored in release mode

   918 	implementationData->iImplInfo->AddExtendedInterfaceL(testExtendedInterfaceUid2);

   919 

   920 #ifdef NDEBUG

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

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

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

   924 #endif

   925 	// Tidy up

   926 	CleanupStack::PopAndDestroy(5, registryData);

   927 

   928 	// Test Ends...

   929 	}

   930 

   931 LOCAL_C TInt AddExtendedInterfacePanicL(TAny*)

   932 	{

   933 	__UHEAP_MARK;

   934 	CTrapCleanup* threadcleanup = CTrapCleanup::New();

   935 	TRAPD(err,AddExtendedInterfaceTestL());

   936 	TEST(err==KErrNone);

   937 	delete threadcleanup;

   938 	__UHEAP_MARKEND;

   939 	return KErrNone;

   940 	}

   941 

   942 /**

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

   944 with duplicate extended interface Uid .

   945 */

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

   947 	{

   948 	TRequestStatus threadStatus;

   949 	RThread thread;

   950 	TBool jit;

   951 	jit=User::JustInTime();

   952 	User::SetJustInTime(EFalse);

   953 

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

   955 #ifdef __X86GCC__

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

   957 #else

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

   959 #endif	

   960 	TEST(err==KErrNone);

   961 	thread.Logon(threadStatus)	;

   962 	thread.Resume();

   963 

   964 	User::WaitForRequest(threadStatus);

   965 

   966 	//Now check why the thread Exit

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

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

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

   970 #ifdef _DEBUG

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

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

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

   974 #else

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

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

   977 #endif

   978 	CLOSE_AND_WAIT(thread);

   979 	User::SetJustInTime(jit);

   980 	}

   981 

   982 

   983 /**

   984 Plugins to be used in this test

   985 Interface UID	DLL	UID		Implementation UID	Version		DLL Type	Extended Interfaces

   986 --------------------------------------------------------------------------------

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

   988 				0x10009E3E	0x10009E3C				1		PLUGIN3		{}

   989 				0x10009E3E	0x10009E3D				1		PLUGIN3		{0x10009E44}

   990 0x10009DC0		0x101F847B	0x101F847C				1		PLUGIN1		NULL

   991 

   992 @SYMTestCaseID          SYSLIB-ECOM-UT-3575

   993 @SYMTestCaseDesc	    Tests for CImplementationInformation::GetExtendedInterfaceList() and

   994 						CImplementationInformation::GetExtendedInterfaceListL() functions. Makes sure that

   995 						results from both of the functions are identical.

   996 @SYMTestPriority 	    High

   997 @SYMTestActions  	    List the extended interfaces for a valid implementation UID

   998 						List the extended interfaces for a non-existing implementation UID

   999 						List the extended interfaces for a valid PLUGIN1 implementation UID

  1000 @SYMTestExpectedResults Expected extended interfaces are returned.

  1001 @SYMEC                  EC43

  1002 @SYMDEF					DEF111196

  1003 */

  1004 void CRegistryDataTest::ListExtendedInterfacesTestL()

  1005 	{

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

  1007 	TUid ImpUid = {0x10009E39};

  1008 	TUid ImpUid1 = {0x10009E3C};

  1009 	TUid ImpUidPLUGIN1 = {0x101F847C};

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

  1011  	TEntry dllinfo;

  1012  	TInt err;

  1013  	TClientRequest clntRq;

  1014 

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

  1016  	CImplementationInformation* implementationInfo=NULL;

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

  1018  	TEST_OOM_ERR;

  1019  	TEST2(err, KErrNone);

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

  1021 

  1022  	//Gets the list of extended Interfaces

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

  1024 

  1025  	//Checks the extended interfaces list

  1026  	TEST(extendedInterfaces != NULL);

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

  1028 		{

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

  1030 		}

  1031 

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

  1033 	RArray<TUid> extendedInterfacesAPI;

  1034 	CleanupClosePushL(extendedInterfacesAPI);

  1035 	implementationInfo->GetExtendedInterfaceListL(extendedInterfacesAPI);

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

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

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

  1039 		{

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

  1041 		}

  1042 	CleanupStack::PopAndDestroy(&extendedInterfacesAPI);

  1043 

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

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

  1046  	TEST_OOM_ERR;

  1047  	TEST2(err, KErrNone);

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

  1049 

  1050  	//Gets the list of extended Interfaces

  1051 	extendedInterfaces = implementationInfo->GetExtendedInterfaceList();

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

  1053 

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

  1055 	RArray<TUid> extendedInterfacesAPI1;

  1056 	CleanupClosePushL(extendedInterfacesAPI1);

  1057 	implementationInfo->GetExtendedInterfaceListL(extendedInterfacesAPI1);

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

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

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

  1061 		{

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

  1063 		}

  1064 	CleanupStack::PopAndDestroy(&extendedInterfacesAPI1);

  1065 

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

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

  1068 	TEST_OOM_ERR;

  1069 	TEST2(err,KErrNone);

  1070 	TEST(implementationInfo == NULL);

  1071 

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

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

  1074  	TEST_OOM_ERR;

  1075  	TEST2(err, KErrNone);

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

  1077 

  1078  	//Gets the list of extended Interfaces

  1079 	extendedInterfaces = implementationInfo->GetExtendedInterfaceList();

  1080  	TEST(extendedInterfaces == NULL);

  1081 

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

  1083 	RArray<TUid> extendedInterfacesAPI2;

  1084 	CleanupClosePushL(extendedInterfacesAPI2);

  1085 	implementationInfo->GetExtendedInterfaceListL(extendedInterfacesAPI2);

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

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

  1088 	CleanupStack::PopAndDestroy(&extendedInterfacesAPI2);

  1089 	}

  1090 

  1091 

  1092 /**

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

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

  1095 Interface UID	DLL	UID		Implementation UID	Version		DLL Type	Extended Interfaces

  1096 --------------------------------------------------------------------------------

  1097 0x10009E36		0x10009E40	0x10009E48				1		PLUGIN1		None

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

  1099 				0x10009E3E	0x10009E3C				1		PLUGIN3		{}

  1100 				0x10009E3E	0x10009E3D				1		PLUGIN3		{0x10009E44}

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

  1102 

  1103 @SYMTestCaseID          SYSLIB-ECOM-UT-3580

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

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

  1106 @SYMTestPriority 	    High

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

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

  1109                         belongs to.

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

  1111 @SYMEC                  EC43

  1112 */

  1113 void CRegistryDataTest::ListImplementationsTestT5L()

  1114 	{

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

  1116 	const TUid KInterfaceUid = {0x10009E36};

  1117 

  1118 	TEST(iRegistryData->IndexValid());

  1119 	// Set up client request and extended interfaces

  1120 	TClientRequest clientReq;

  1121 	RArray<TUid> extendedInterfaces;

  1122 	CleanupClosePushL(extendedInterfaces);

  1123 	TBool capability= ETrue;

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

  1125 	CleanupStack::PushL(registryResolveTransaction);

  1126 	RImplInfoArray* iUidListPtr = NULL;

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

  1128 

  1129 	TEST_OOM_ERR;

  1130 	TEST2(err, KErrNone);

  1131 

  1132 	// Prints UIDs of implementations

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

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

  1135