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

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

    17 // 

    18 //

    19 

    20 #include "RegistryData.h"

    21 #include "EComErrorCodes.h"

    22 #include "EComUidCodes.h"

    23 #include "ImplementationInformation.h"

    24 #include "RegistryData.h"

    25 #include "Registrar.h"

    26 #include "RegistrarObserver.h"

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

    28 #include "EComEntryBase.h"

    29 #include "DriveInfo.h"

    30 

    31 #include <e32test.h>

    32 #include <f32file.h>

    33 #include <bautils.h>

    34 #include <startup.hrh>

    35 

    36 #include "baspi.h"

    37 

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

    39 

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

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

    42 const TUid NewDllUid={0x101F847B};

    43 _LIT(KNewResourceFileNameOnly,"EComExample5.rsc");

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

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

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

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

    48 

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

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

    51 const TUid Type3DllUid = {0x10009E3E};

    52 _LIT(KType3ResourceFileNameOnly,"EComExample12.rsc");

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

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

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

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

    57 

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

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

    60 _LIT(KType3BadDataResourceFileNameOnly,"EComExampleBadData.rsc");

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

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

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

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

    65 

    66 _LIT(KType3BadData1ResourceFileNameOnly,"EComExampleBadData1.rsc");

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

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

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

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

    71 

    72 _LIT(KType3BadData2ResourceFileNameOnly,"EComExampleBadData2.rsc");

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

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

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

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

    77 

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

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

    80 _LIT(KType2ResourceFileNameOnly,"EComExample14.rsc");

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

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

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

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

    85 

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

    87 

    88 // spi test file

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

    90 // spi test file for testing IIC Type3

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

    92 

    93 const TInt KOneSecond = 1000000;

    94 

    95 const TUid interfaceUidExample12 = {0x10009E36};

    96 const TUid extendedInterfaceUid1 = {0x10009E44};

    97 const TUid extendedInterfaceUid2 = {0x10009E45};

    98 const TUid extendedInterfaceUid3 = {0x10009E46};

    99 

   100 

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

   102 

   103 LOCAL_D RFs					TheFs;

   104 

   105 LOCAL_D CTrapCleanup* 		TheTrapCleanup 		= NULL;

   106 

   107 LOCAL_D CActiveScheduler*	TheActiveScheduler	= NULL;

   108 

   109 // Used for supressing warning in OOM tests

   110 #define __UNUSED_VAR(var) var = var

   111 

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

   113 //from normal test and from OOM test.

   114 static void LeaveIfErrNoMemory(TInt aError)

   115 	{

   116 	if(aError == KErrNoMemory)

   117 		{

   118 		User::Leave(aError);

   119 		}

   120 	}

   121 

   122 /**

   123 TRegistrar_StateAccessor class allows access to private and protected

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

   125 */

   126 class TRegistrar_StateAccessor

   127 	{

   128 public:

   129 	void DiscoveriesBegin(CRegistrar& aRegistrar);

   130 

   131 	void DiscoveriesComplete(CRegistrar& aRegistrar, TBool aSuccessful);

   132 

   133 	void DriveRemovedL(CRegistrar& aRegistrar, TDriveUnit aDriveUnit);

   134 

   135 	void DriveReinstatedL(CRegistrar& aRegistrar, TDriveUnit aDriveUnit);

   136 

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

   138 

   139 	void ParseL(CRegistrar& aRegistrar,

   140 				CPluginBase*& aEntry,

   141 				CRegistryData::CDllData& aDll);

   142 

   143 	void ParseRegistrationDataL(CRegistrar& aRegistrar,

   144 				CPluginBase*& aEntry,

   145 				TDriveUnit& aDriveUnit,

   146 				TBool aUpdate,

   147 				TInt aRegistryDriveIndex,

   148 				CRegistryData::CDriveData* aDriveData);

   149 

   150 	CRegistrar::TRegistrarState State(CRegistrar& aRegistrar);

   151 	};

   152 

   153 /**

   154 Parses the resource file associated with an

   155 Interface Implementation Collection for the plugin entry.

   156 

   157 @param		aRegistrar The CRegistrar class object under test

   158 @param		aEntry an ecom entry discovered

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

   160 @pre 		CRegistrar should be fully constructed.

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

   162  */

   163 void TRegistrar_StateAccessor::ParseL(CRegistrar& aRegistrar,

   164 									  CPluginBase*& aEntry,

   165 									  CRegistryData::CDllData& aDll)

   166 

   167 	{

   168 	aRegistrar.ParseL(aEntry,aDll);

   169 	}

   170 

   171 /**

   172 Determines if the directory entry for an Interface Implementation

   173 Collection requires registration. Parses and registers the plugin entry

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

   175 

   176 @param		aRegistrar The CRegistrar class object under test

   177 @param		aEntry Directory entry for the Interface Impplementation Collection.

   178 @param		aRscFileName Resource file from which to extract the data

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

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

   181 @param		aRegistryDriveIndex Index within the registry data

   182 			for the branch that the registry entry was found within.

   183 @pre 		CRegistrar is fully constructed.

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

   185 */

   186 void TRegistrar_StateAccessor::ParseRegistrationDataL(CRegistrar& aRegistrar,

   187 														CPluginBase*& aEntry,

   188 														TDriveUnit& aDrive,

   189 														TBool aUpdate,

   190 														TInt aRegistryDriveIndex,

   191 														CRegistryData::CDriveData* aDriveData)

   192 	{

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

   194 	}

   195 

   196 /**

   197 Overload of the MDiscovererObserver callback method.

   198 The cue that a registry update is about to occur.

   199 

   200 @param		aRegistrar The CRegistrar class object under test

   201 @pre 		CRegistrar is fully constructed

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

   203 			data is out of date.

   204 */

   205 void TRegistrar_StateAccessor::DiscoveriesBegin(CRegistrar& aRegistrar)

   206 	{

   207 	aRegistrar.DiscoveriesBegin();

   208 	}

   209 

   210 /**

   211 Overload of the MDiscovererObserver callback method.

   212 The cue that a registry update is done.

   213 

   214 @param		aRegistrar The CRegistrar class object under test

   215 @param		aSuccessful The registry data has been updated successfully

   216 @pre 		CRegistrar is fully constructed

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

   218 */

   219 void TRegistrar_StateAccessor::DiscoveriesComplete(CRegistrar& aRegistrar,

   220 												   TBool aSuccessful)

   221 	{

   222 	aRegistrar.DiscoveriesComplete(aSuccessful, EPluginProcessingTypeAll);

   223 	}

   224 

   225 /**

   226 Overload of the MDiscovererObserver callback method.

   227 Signals registry that the registered Interface Implementation

   228 Collections stored upon the specified drive are no

   229 longer available for use.

   230 

   231 @param		aRegistrar The CRegistrar class object under test

   232 @param		aDrive	The drive identifier.

   233 @pre 		CRegistrar is fully constructed.

   234 @post		The registered Interface Implementation Collections

   235 			stored upon the specified drive are no

   236 			longer available for use.

   237 */

   238 void TRegistrar_StateAccessor::DriveRemovedL(CRegistrar& aRegistrar,

   239 											 TDriveUnit aDrive)

   240 	{

   241 	aRegistrar.DriveRemovedL(aDrive);

   242 	}

   243 

   244 /**

   245 Overload of the MDiscovererObserver callback method.

   246 Signals registry that the registered Interface

   247 Implementation Collections stored upon the specified drive are again

   248 available for use.

   249 

   250 @param		aRegistrar The CRegistrar class object under test

   251 @param		aDrive	The drive identifier.

   252 @pre 		CRegistrar is fully constructed.

   253 @post		The registered Interface Implementation Collections

   254 			stored upon the specified drive are again

   255 			made available for use.

   256 */

   257 void TRegistrar_StateAccessor::DriveReinstatedL(CRegistrar& aRegistrar,

   258 												   TDriveUnit aDrive)

   259 	{

   260 	aRegistrar.DriveReinstatedL(aDrive);

   261 	}

   262 

   263 /**

   264 Overload of the MDiscovererObserver callback method.

   265 Adds the specified Interface Implementation Collection Entry to the registry.

   266 

   267 @param		aRegistrar The CRegistrar class object under test

   268 @param		aDirEntry The plugin entry to register.

   269 @pre 		CRegistrar is fully constructed

   270 @post		The plugin entry is registered.

   271 */

   272 void TRegistrar_StateAccessor::RegisterDiscoveryL(CRegistrar& aRegistrar,

   273 												  const TDriveName& aDrive,

   274 												  CPluginBase*& aEntry,

   275 												  TBool aDatFileExists )

   276 	{

   277 	aRegistrar.RegisterDiscoveryL(aDrive,aEntry,aDatFileExists);

   278 	}

   279 

   280 /**

   281 Retrieves the object's current state.

   282 

   283 @return 	TCRegistarState the CRegistrar's current state.

   284 @pre		CRegistrar is fully constructed.

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

   286 */

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

   288 	{

   289 	return aRegistrar.State();

   290 	}

   291 

   292 /**

   293 TRegistryData_StateAccessor class allows access to private and protected

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

   295 */

   296 class TRegistryData_StateAccessor

   297 	{

   298 public:

   299 	TInt FindImplementation(CRegistryData& aRegistryData,

   300 				const TUid aImplUid,

   301 				const TUid aInterfaceUid,

   302 				CRegistryData::CImplementationData*& aImplData) const;

   303 	};

   304 

   305 /**

   306 @return		KErrNone if found otherwise KErrNotFound

   307 @param		aRegistryData The CRegistryData class object

   308 @param		aImplUid The implementation to find.

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

   310 			implementation to find.

   311 @param		aImplData The found implementation data.

   312 @pre 		CRegistrar is fully constructed

   313 */

   314 TInt TRegistryData_StateAccessor::FindImplementation(CRegistryData& aRegistryData,

   315 												const TUid aImplUid,

   316 												const TUid aInterfaceUid,

   317 												CRegistryData::CImplementationData*& aImplData) const

   318 	{

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

   320 	}

   321 

   322 

   323 /**

   324 The implementation of the abstract Registrar Observer class,

   325 used for recieving notifications of registry changes.

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

   327 CEComServer class acts as observer for CRegistrar.

   328 */

   329 class CTestRegistrarObserver : public MRegistrarObserver

   330 	{

   331 public:

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

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

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

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

   336 	};

   337 

   338 /**

   339 Test class for object CRegistrar.

   340 This class provides the parameters and behaviour that

   341 allows this class to behave normally under a test

   342 scenario.

   343 */

   344 class CRegistrarTest : public CBase

   345 	{

   346 public:

   347 

   348 	static CRegistrarTest* NewL(TBool aIsFullDiscovery);

   349 	virtual ~CRegistrarTest();

   350 	const CImplementationInformation * GetImplementationDataL();

   351 

   352 	void EnableDisableTestL();

   353 	void ResumeSuspendTestL();

   354 	void DiscoveriesBegin_Register_CompleteTestL();

   355 	void DriveRemovedReinstatedTestL();

   356 	void ParseTestL();

   357 	void ParseType2TestL();

   358 	void ParseType3TestL();

   359 	void ParseType3BadDataTestL();

   360 	void ParseRegistrationDataTestL();

   361 	void ParseRegistrationDataType3TestL();

   362 	void StateTransitionTestL();

   363 	void ParseSpiRegistrationDataTestL();

   364 	void ParseSpiRegistrationDataType3TestL();

   365 	void ParseSpiTestL();

   366 	void ParseSpiType3TestL();

   367 

   368 private:

   369 	CRegistrarTest();

   370 	void ConstructL(TBool aIsFullDiscovery);

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

   372 public:

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

   374 	CRegistrar* iRegistrar;

   375 

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

   377 	TRegistrar_StateAccessor* iStateAccessor;

   378 

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

   380 	CRegistryData* iRegistryData;

   381 

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

   383 	TRegistryData_StateAccessor* iRegistryDataStateAccessor;

   384 

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

   386 	MRegistrarObserver* iRegistrarObserver;

   387 

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

   389 	CRegistryData::CDllData* iDllData;

   390 

   391 	/** Unique Id of the ECOM dll */

   392 	TUid    iDllUid;

   393 

   394 	/** Unique Id of an interface implementation */

   395 	TUid	iImplementationUid;

   396 

   397 	/** Unique Id of an interface */

   398 	TUid	iInterfaceUid;

   399 

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

   401 	TDriveUnit	iDriveUnit;

   402 

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

   404 	TEntry		iDllEntry;

   405 	};

   406 

   407 /**

   408 Standardised safe construction which

   409 leaves nothing on the cleanup stack.

   410 

   411 @param		aIsFullDiscovery whether the constructor make full discovery

   412 @post		CRegistrarTest is fully constructed and initialised.

   413 */

   414 CRegistrarTest* CRegistrarTest::NewL(TBool aIsFullDiscovery)

   415 	{

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

   417 	CleanupStack::PushL(self);

   418 	self->ConstructL(aIsFullDiscovery);

   419 	CleanupStack::Pop(self);

   420 	return self;

   421 	}

   422 

   423 /**

   424 Standardized default c'tor

   425 

   426 @post		CRegistrarTest is fully constructed.

   427 */

   428 CRegistrarTest::CRegistrarTest()

   429 :	CBase(),

   430 	iDriveUnit(EDriveC)

   431 	{

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

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

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

   435 	TUid uid1 = {0};

   436 	TUid uid2 = {0};

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

   438 	}

   439 

   440 /**

   441 Destructor.

   442 

   443 @post		This object is properly destroyed.

   444 */

   445 CRegistrarTest::~CRegistrarTest()

   446 	{

   447 	delete iDllData;

   448 	delete iRegistrar;

   449 	delete iRegistryData;

   450 	delete iRegistrarObserver;

   451 	delete iStateAccessor;

   452 	delete iRegistryDataStateAccessor;

   453 	}

   454 

   455 /**

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

   457 

   458 @param		aIsFullDiscovery whether the constructor make full discovery

   459 @post		CRegistrarTest is fully constructed.

   460 */

   461 void CRegistrarTest::ConstructL(TBool aIsFullDiscovery)

   462 	{

   463 	CRegistryData::CDriveData* driveData=NULL;

   464 	iRegistrarObserver = new (ELeave) CTestRegistrarObserver;

   465 	iStateAccessor	   = new (ELeave) TRegistrar_StateAccessor;

   466 	iRegistryDataStateAccessor	   = new (ELeave) TRegistryData_StateAccessor;

   467 	iRegistryData	   = CRegistryData::NewL(TheFs);

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

   469 	if(aIsFullDiscovery)

   470 		{

   471 		iRegistrar->ProcessSSAEventL(EStartupStateNonCritical);

   472 		}

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

   474 	CleanupStack::Pop(iDllData);

   475 	}

   476 

   477 

   478 /**

   479 Returns information of a particular interface implementation.

   480 

   481 @return		Information on the requested implementation

   482 @pre 		This object is fully constructed

   483 */

   484 const CImplementationInformation * CRegistrarTest::GetImplementationDataL()

   485 	{

   486 	CRegistryData::CImplementationData *implementationData=NULL;

   487 	TUid dummyUid;

   488 	dummyUid.iUid = 0;

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

   490 																dummyUid, implementationData));

   491 	return implementationData->iImplInfo;

   492 	}

   493 

   494 /**

   495 The test executes by first Disabling the Implementation then by

   496 Enabling it.

   497 

   498 @SYMTestCaseID          SYSLIB-ECOM-CT-0727

   499 @SYMTestCaseDesc	    Tests for enabling and disabling the Implementation

   500 @SYMTestPriority 	    High

   501 @SYMTestActions  	    Fetch the Implementation information for testing for iImplementationUid

   502                         Disable and enable the implementation for the unique UID

   503 @SYMTestExpectedResults The test must not fail.

   504 @SYMREQ                 REQ0000

   505 */

   506 void CRegistrarTest::EnableDisableTestL()

   507 	{

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

   509 	const CImplementationInformation *implimentationInfo = NULL;

   510 

   511 	// Get the Implementation information for testing for iImplementationUid.

   512 	// Implementation for iImplementationUid should be registered to

   513 	// run this test successfully.

   514 	TRAPD(err, implimentationInfo = GetImplementationDataL());

   515 	::LeaveIfErrNoMemory(err);

   516 	test(err == KErrNone);

   517 	test(implimentationInfo != NULL);

   518 

   519 	// Disable the implementaion

   520 	err = iRegistrar->Disable(iImplementationUid);

   521 	::LeaveIfErrNoMemory(err);

   522 	test(KErrNone == err);

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

   524 

   525 

   526 	// Enable the implementaion

   527 	err = iRegistrar->Enable(iImplementationUid);

   528 	::LeaveIfErrNoMemory(err);

   529 	test(KErrNone == err);

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

   531 	}

   532 

   533 /**

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

   535 

   536 @SYMTestCaseID          SYSLIB-ECOM-CT-0728

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

   538 @SYMTestPriority 	    High

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

   540 @SYMTestExpectedResults The test must not fail.

   541 @SYMREQ                 REQ0000

   542 */

   543 void CRegistrarTest::ResumeSuspendTestL()

   544 	{

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

   546 	TInt err = iRegistrar->Suspend();

   547 	::LeaveIfErrNoMemory(err);

   548 	test(err == KErrNone);

   549 

   550 	err = iRegistrar->Resume();

   551 	::LeaveIfErrNoMemory(err);

   552 	test(err == KErrNone);

   553 	}

   554 

   555 /**

   556 The test executes by calling DiscoveriesBegin, RegisterDiscoveryL and

   557 DiscoveriesComplete in sequence to register the plugin.

   558 

   559 @SYMTestCaseID          SYSLIB-ECOM-CT-0729

   560 @SYMTestCaseDesc	    Tests for registering the DLL interfaces

   561 @SYMTestPriority 	    High

   562 @SYMTestActions  	    Calls up DiscoveriesBegin, RegisterDiscoveryL and

   563 						DiscoveriesComplete in sequence to register the plugin and

   564 						verifies that DLL's have been registered succesfully.

   565 @SYMTestExpectedResults The test must not fail.

   566 @SYMREQ                 REQ0000

   567 */

   568 void CRegistrarTest::DiscoveriesBegin_Register_CompleteTestL()

   569 	{

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

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

   572 	// register the plugin

   573 	iStateAccessor->DiscoveriesBegin(*iRegistrar);

   574 

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

   576 	CPluginBase* entryBase=NULL;

   577 	TInt err=KErrNone;

   578 	TBool update = EFalse;

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

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

   581 	CRegistryData::CDriveData* driveData = NULL;

   582 

   583 

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

   585 	TEntry rscBasedEntry;

   586 	rscBasedEntry.iName=KNewResourceFileNameOnly;

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

   588 	test(err==KErrNone);

   589 	TParse rscPath;

   590 	rscPath.Set(KNewResourceFileNameC,NULL,NULL);

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

   592 	CleanupStack::PushL(entryBase);

   593 

   594 	//Now register this Rsc Entry with the registrar

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

   596 	::LeaveIfErrNoMemory(err);

   597 	test(err == KErrNone);

   598 	CleanupStack::PopAndDestroy(entryBase);

   599 	entryBase=NULL;

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

   601 	::LeaveIfErrNoMemory(err);

   602 	test(driveIndex != KErrNotFound);

   603 	//Verify weather dll interfaces got registered

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

   605 

   606 	TRAP(err, isDriveRegistered = iRegistryData->IsRegisteredWithDate(

   607 																		NewDllUid,

   608 																		rscBasedEntry.iModified,

   609 																		update,

   610 																		driveData));

   611 	::LeaveIfErrNoMemory(err);

   612 	test(err == KErrNone);

   613 	test(isDriveRegistered);

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

   615 

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

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

   618 	//THE LEGACY ENTRY WILL BE WIPED OUT

   619 	iStateAccessor->DiscoveriesComplete(*iRegistrar, EFalse);

   620 	test(iRegistrar != NULL);

   621 	}

   622 

   623 /**

   624 @SYMTestCaseID          SYSLIB-ECOM-CT-0730

   625 @SYMTestCaseDesc	    Tests for CRegistrar::DriveRemovedL,DriveReinstatedL functions

   626 @SYMTestPriority 	    High

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

   628 						then testing for Install and Uninstall.

   629 @SYMTestExpectedResults The test must not fail.

   630 @SYMREQ                 REQ0000

   631 */

   632 void CRegistrarTest::DriveRemovedReinstatedTestL()

   633 	{

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

   635 	// We are checking with F Drive.

   636 	// The test executes by first removing and then reinstalling

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

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

   639 	TBool isDriveRegistered = EFalse;

   640 	TInt  driveIndex = KErrNotFound;

   641 	CRegistryData::CDriveData* driveData = NULL;

   642 

   643 	iDriveUnit = EDriveF;

   644 	TInt error = KErrNone;

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

   646 	::LeaveIfErrNoMemory(error);

   647 	TInt err = KErrNone;

   648 	if(driveIndex != KErrNotFound)

   649 	{

   650 	TRAP(err, iRegistryData->IsRegisteredWithDate(

   651 													iDllUid,

   652 													modified,

   653 													update,

   654 

   655 													driveData));

   656 

   657 	::LeaveIfErrNoMemory(err);

   658 	}

   659 

   660 	isDriveRegistered = (driveIndex != KErrNotFound);

   661 

   662 	//Remove the drive from registry if registered

   663 	if(isDriveRegistered)

   664 		{

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

   666 		::LeaveIfErrNoMemory(err);

   667 		test(err == KErrNone);

   668 

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

   670 		driveIndex = KErrNotFound;

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

   672 		//Drive should not be present

   673 		::LeaveIfErrNoMemory(err);

   674 		test(driveIndex == KErrNotFound);

   675 

   676 		}

   677 

   678 

   679 	// Install the drive in registry

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

   681 	::LeaveIfErrNoMemory(err);

   682 	test(err == KErrNone);

   683 

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

   685 	driveIndex = KErrNotFound;

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

   687 	::LeaveIfErrNoMemory(err);

   688 	//Drive should be present now

   689 	test(driveIndex != KErrNotFound);

   690 	TRAP(err, iRegistryData->IsRegisteredWithDate(

   691 													iDllUid,

   692 													modified,

   693 													update,

   694 

   695 													driveData));

   696 	::LeaveIfErrNoMemory(err);

   697 	test(err == KErrNone);

   698 

   699 

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

   701 	if(!isDriveRegistered)

   702 		{

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

   704 		::LeaveIfErrNoMemory(err);

   705 		test(err == KErrNone);

   706 

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

   708 		driveIndex = KErrNotFound;

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

   710 		//Drive should not be present

   711 		::LeaveIfErrNoMemory(err);

   712 		test(driveIndex == KErrNotFound);

   713 		}

   714 	}

   715 

   716 /**

   717 The test executes by parsing the Interface implementaion information

   718 from the given resource file.

   719 

   720 @SYMTestCaseID          SYSLIB-ECOM-CT-0731

   721 @SYMTestCaseDesc	    Tests for verification of Interface implementaion information

   722 @SYMTestPriority 	    High

   723 @SYMTestActions  	    Parse the resource information associated with an

   724 					    Interface Implementation Collection for entry into the registry

   725 					    information.Check for OOM error or parse error.

   726 @SYMTestExpectedResults The test must not fail.

   727 @SYMREQ                 REQ0000

   728 */

   729 void CRegistrarTest::ParseTestL()

   730 	{

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

   732 	TInt error=KErrNone;

   733 	CPluginBase* entryBase=NULL;

   734 	CRegistryData::CDllData* dllData=NULL;

   735 	CRegistryData::CInterfaceData* ifData =NULL;

   736 	CRegistryData::CDriveData* driveData = NULL;

   737 

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

   739 	//(101F847B.RSS)

   740 	TEntry rscBasedEntry;

   741 	rscBasedEntry.iName=KNewResourceFileNameOnly;

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

   743 	test(error==KErrNone);

   744 	TParse rscPath;

   745 	rscPath.Set(KNewResourceFileNameC,NULL,NULL);

   746 	TDriveUnit driveUnit(rscPath.Drive());

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

   748 	test(error!=KErrNotFound);

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

   750 	CleanupStack::PushL(entryBase);

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

   752 

   753 	//Now testing the parseL function

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

   755 	::LeaveIfErrNoMemory(error);

   756 	test(error == KErrNone);

   757 	//Now checking the content of the DllData

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

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

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

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

   762 

   763 	CleanupStack::PopAndDestroy(dllData);

   764 	CleanupStack::PopAndDestroy(entryBase);

   765 	entryBase=NULL;

   766 	dllData=NULL;

   767 	ifData=NULL;

   768 	}

   769 

   770 /**

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

   772 from the given resource file.

   773 

   774 @SYMTestCaseID          SYSLIB-ECOM-UT-3563

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

   776 @SYMTestPriority 	    High

   777 @SYMTestActions  	    Parse the resource information associated with an

   778 					    Interface Implementation Collection type 2 for entry into the registry

   779 					    information.Check for OOM error or parse error.

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

   781 						Data is interpreted correctly.

   782 @SYMEC                  EC43

   783 */

   784 void CRegistrarTest::ParseType2TestL()

   785 	{

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

   787 	TInt error = KErrNone;

   788 	CPluginBase* entryBase = NULL;

   789 	CRegistryData::CDllData* dllData = NULL;

   790 	CRegistryData::CInterfaceData* ifData = NULL;

   791 	CRegistryData::CDriveData* driveData = NULL;

   792 	TUid interfaceUidExample14 = {0x10009E36};

   793 

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

   795 	//(EcomExample14.RSS)

   796 	TEntry rscBasedEntry;

   797 	rscBasedEntry.iName = KType2ResourceFileNameOnly;

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

   799 	test(error == KErrNone);

   800 	TParse rscPath;

   801 	rscPath.Set(KType2ResourceFileNameC,NULL,NULL);

   802 	TDriveUnit driveUnit(rscPath.Drive());

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

   804 	test(error != KErrNotFound);

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

   806 	CleanupStack::PushL(entryBase);

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

   808 

   809 	//tests the parseL function

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

   811 	::LeaveIfErrNoMemory(error);

   812 	test(error == KErrNone);

   813 	//checks the content of the DllData

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

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

   816 	test(ifData->iInterfaceUid == interfaceUidExample14);

   817 	CleanupStack::PopAndDestroy(dllData);

   818 	CleanupStack::PopAndDestroy(entryBase);

   819 	}

   820 

   821 /**

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

   823 from the given resource file.

   824 

   825 @SYMTestCaseID          SYSLIB-ECOM-UT-3564

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

   827 @SYMTestPriority 	    High

   828 @SYMTestActions  	    Parse the resource information associated with an

   829 					    Interface Implementation Collection type 3 for entry into the registry

   830 					    information.Check for OOM error or parse error.

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

   832 						Data is interpreted correctly.

   833 @SYMEC                  EC43

   834 */

   835 void CRegistrarTest::ParseType3TestL()

   836 	{

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

   838 	TInt error = KErrNone;

   839 	CPluginBase* entryBase = NULL;

   840 	CRegistryData::CDllData* dllData = NULL;

   841 	CRegistryData::CInterfaceData* ifData = NULL;

   842 	CRegistryData::CDriveData* driveData = NULL;

   843 	CRegistryData::CImplementationData* implData = NULL;

   844 	CImplementationInformation* implInfo = NULL;

   845 

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

   847 	//(EcomExample12.RSS)

   848 	TEntry rscBasedEntry;

   849 	rscBasedEntry.iName = KType3ResourceFileNameOnly;

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

   851 	test(error == KErrNone);

   852 	TParse rscPath;

   853 	rscPath.Set(KType3ResourceFileNameC,NULL,NULL);

   854 	TDriveUnit driveUnit(rscPath.Drive());

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

   856 	test(error != KErrNotFound);

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

   858 	CleanupStack::PushL(entryBase);

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

   860 

   861 	// Tests the parseL function

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

   863 	::LeaveIfErrNoMemory(error);

   864 	test(error == KErrNone);

   865 	// Checks the content of the DllData

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

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

   868 	test(ifData->iInterfaceUid == interfaceUidExample12);

   869 	//Currently there are 3 implementations for this interface.

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

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

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

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

   874 	implInfo = implData->iImplInfo;

   875 

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

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

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

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

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

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

   882 	CleanupStack::PopAndDestroy(dllData);

   883 	CleanupStack::PopAndDestroy(entryBase);

   884 	}

   885 

   886 

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

   888 and data in the resource file exceed maximum

   889 */

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

   891 	{

   892 	TInt error = KErrNone;

   893 	CPluginBase* entryBase = NULL;

   894 	CRegistryData::CDllData* dllData = NULL;

   895 	CRegistryData::CDriveData* driveData = NULL;

   896 

   897 	TEntry rscBasedEntry;

   898 	rscBasedEntry.iName = aRscNameOnly;

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

   900 	test(error == KErrNone);

   901 	TParse rscPath;

   902 	rscPath.Set(aRscFullName,NULL,NULL);

   903 	TDriveUnit driveUnit(rscPath.Drive());

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

   905 	test(error != KErrNotFound);

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

   907 	CleanupStack::PushL(entryBase);

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

   909 

   910 	//Tests the parseL function

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

   912 	test(error == KErrNotSupported);

   913 

   914 	CleanupStack::PopAndDestroy(dllData);

   915 	CleanupStack::PopAndDestroy(entryBase);

   916 	}

   917 

   918 

   919 /**

   920 @SYMTestCaseID          SYSLIB-ECOM-UT-3565

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

   922 						and data in the resource file exceed maximum.

   923 @SYMTestPriority 	    High

   924 @SYMTestActions  	    Parse the resource information associated with an

   925 					    Interface Implementation Collection type 3 for entry into the registry

   926 					    information.

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

   928 @SYMEC                  EC43

   929 @SYMDEF                 DEF111196

   930 */

   931 void CRegistrarTest::ParseType3BadDataTestL()

   932 	{

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

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

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

   936 	ParseBadDataTestL(KType3BadDataResourceFileNameC,KType3BadDataResourceFileNameOnly);

   937 

   938 	// Tests for number of interfaces exceeds maximum

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

   940 	ParseBadDataTestL(KType3BadData1ResourceFileNameC,KType3BadData1ResourceFileNameOnly);

   941 

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

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

   944 	ParseBadDataTestL(KType3BadData2ResourceFileNameC,KType3BadData2ResourceFileNameOnly);

   945 	}

   946 

   947 /**

   948 @SYMTestCaseID		SYSLIB-ECOM-CT-0089

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

   950 @SYMTestPriority 	High

   951 @SYMTestActions  	Ensure ecomtest.spi can be parsed successfully

   952 					and no leave occurs.

   953 @SYMTestExpectedResults The test must not fail.

   954 @SYMREQ REQ3655

   955 */

   956 void CRegistrarTest::ParseSpiTestL()

   957 	{

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

   959 	TEntry spiEntry;

   960 	TParse spiPath;

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

   962 		return;

   963 

   964 	spiPath.Set(KEComSpiTestFilePathAndName,NULL,NULL);

   965 	RResourceArchive resourceArchive;

   966 	resourceArchive.OpenL(TheFs, KEComSpiTestFilePathAndName);

   967 	CleanupClosePushL(resourceArchive);

   968 

   969 	// Checks SPI file type

   970 	TUid type = resourceArchive.Type();

   971 	test(type == KEcomSpiFileTypeUid);

   972 

   973 	// there is only 1 resource file

   974 	CPluginBase* entryBase=NULL;

   975 	CRegistryData::CDllData* dllData=NULL;

   976 	CRegistryData::CDriveData* driveData = NULL;

   977 

   978 	TDriveUnit driveUnit(spiPath.Drive());

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

   980 	test(error!=KErrNotFound);

   981 

   982 	while(!resourceArchive.End())

   983 		{

   984 		entryBase=CSpiPlugin::NewL(resourceArchive);

   985 		CleanupStack::PushL(entryBase);

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

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

   988 

   989 		::LeaveIfErrNoMemory(err);

   990 		test(err == KErrNone);

   991 		CleanupStack::Pop(dllData);

   992 		CleanupStack::PopAndDestroy(entryBase);

   993 		entryBase=NULL;

   994 		}

   995 

   996 	CleanupStack::PopAndDestroy(&resourceArchive);

   997 

   998 	// Currently only one interface definition in the resource file

   999 	const TInt ifCount = dllData->iIfList->Count();

  1000 	test(ifCount == 1);

  1001 

  1002 	// Currently only one implemention for the above interface in the resource file

  1003 	CRegistryData::CInterfaceData* ifData = (*(dllData->iIfList))[0];

  1004 	const TInt impCount = ifData->iImplementations->Count();

  1005 	test(impCount == 1);

  1006 	// Interface UID verification

  1007 	test(ifData->iInterfaceUid == iInterfaceUid);

  1008 

  1009 	delete dllData;

  1010 	}

  1011 

  1012 /**

  1013 @SYMTestCaseID		SYSLIB-ECOM-UT-3566

  1014 @SYMTestCaseDesc 	Check that the ParseL for spi data with IIC Type 3 entry works correctly.

  1015 @SYMTestPriority 	High

  1016 @SYMTestActions  	Ensure ecomtesttype3.spi can be parsed successfully

  1017 					and no leave occurs.

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

  1019 						Data is interpreted correctly.

  1020 @SYMEC                  EC43

  1021 */

  1022 void CRegistrarTest::ParseSpiType3TestL()

  1023 	{

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

  1025 	TEntry spiEntry;

  1026 	TParse spiPath;

  1027 	//"Z:\\Test\\Data\\ecomtesttype3.spi" is used for testing. The only resource file included

  1028 	//in the spi file is EComExample12.RSC

  1029 	if (TheFs.Entry(KEComSpiTestFileType3PathAndName, spiEntry) != KErrNone)

  1030 		return;

  1031 

  1032 	spiPath.Set(KEComSpiTestFileType3PathAndName,NULL,NULL);

  1033 	RResourceArchive resourceArchive;

  1034 	resourceArchive.OpenL(TheFs, KEComSpiTestFileType3PathAndName);

  1035 	CleanupClosePushL(resourceArchive);

  1036 

  1037 	// Checks SPI file type

  1038 	TUid type = resourceArchive.Type();

  1039 	test(type == KEcomSpiFileTypeUid);

  1040 

  1041 	CRegistryData::CDriveData* driveData = NULL;

  1042 

  1043 	TDriveUnit driveUnit(spiPath.Drive());

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

  1045 	test(error!=KErrNotFound);

  1046 	// there is only 1 resource file in the spi file

  1047 	while(!resourceArchive.End())

  1048 		{

  1049 		CPluginBase* entryBase = NULL;

  1050 		entryBase=CSpiPlugin::NewL(resourceArchive);

  1051 		CleanupStack::PushL(entryBase);

  1052 		CRegistryData::CDllData* dllData = NULL;

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

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

  1055 		::LeaveIfErrNoMemory(err);

  1056 		test(err == KErrNone);

  1057 		// Currently only one interface definition in the resource file

  1058 		// Checks the content of the DllData

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

  1060 		CRegistryData::CInterfaceData* ifData = NULL;

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

  1062 		//There are 3 implementations for the above interface in the spi file.

  1063 		//Since ecomtesttype3.spi is under Z: drive which is ROM based,

  1064 		//the implementation (UID=0x10009E3D) will be created during Parsing.

  1065 		//So, the total implementations is 3.

  1066 		test(ifData->iImplementations->Count() == 3);

  1067 		// Interface UID verification

  1068 		test(ifData->iInterfaceUid == interfaceUidExample12);

  1069 		// Fetches the list of extended interfaces for the second implementation

  1070 		//Currently we have no extended Interface for the second implementation

  1071 		CRegistryData::CImplementationData* implData = NULL;

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

  1073 		CImplementationInformation* implInfo = NULL;

  1074 		implInfo = implData->iImplInfo;

  1075 

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

  1077 		test(extendedInterfaceList->Count() == 0);

  1078 		CleanupStack::PopAndDestroy(dllData);

  1079 		CleanupStack::PopAndDestroy(entryBase);

  1080 		}

  1081 	CleanupStack::PopAndDestroy(&resourceArchive);

  1082 	}

  1083 

  1084 /**

  1085 The test executes by registering the Interface implementaion information

  1086 for an plugin entry.

  1087 

  1088 @SYMTestCaseID          SYSLIB-ECOM-CT-0732

  1089 @SYMTestCaseDesc	    Tests for CRegistrar::ParseRegistrationDataL() function

  1090 @SYMTestPriority 	    High

  1091 @SYMTestActions  	    Checks for directory entry for an Interface Implementation

  1092 						Collection entry requires registration.Parses the associated resource file information where necessary

  1093 						Checks for OOM or parsing error.

  1094 @SYMTestExpectedResults The test must not fail.

  1095 @SYMREQ                 REQ0000

  1096 */

  1097 void CRegistrarTest::ParseRegistrationDataTestL()

  1098 	{

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

  1100 	TInt error=KErrNone;

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

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

  1103 	TInt  driveIndex		= KErrNotFound;

  1104 	CRegistryData::CImplementationData *implementationData = NULL;

  1105 	CPluginBase* entryBase=NULL;

  1106 	TUid implementationUid;

  1107 	CRegistryData::CDriveData* driveData = NULL;

  1108 

  1109 	// Calling  RegistryData->IsRegisteredWithDate to get the drive index,

  1110 	// that will be used in the ParseRegistrationDataL call

  1111 	// The drive should have been installed before registering any plugin

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

  1113 	::LeaveIfErrNoMemory(error);

  1114 	test(driveIndex != KErrNotFound);

  1115 	TRAP(error, iRegistryData->IsRegisteredWithDate(

  1116 																		NewDllUid,

  1117 																		modified,

  1118 																		update,

  1119 

  1120 																		driveData));

  1121 	::LeaveIfErrNoMemory(error);

  1122 	test(error == KErrNone);

  1123 

  1124 	//Creating the entry

  1125 	TEntry rscBasedEntry;

  1126 	rscBasedEntry.iName=KNewResourceFileNameOnly;

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

  1128 	test(error==KErrNone);

  1129 	TParse rscPath;

  1130 	rscPath.Set(KNewResourceFileNameC,NULL,NULL);

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

  1132 	CleanupStack::PushL(entryBase);

  1133 

  1134 	//Trying to parse the registration data