Symaptic: os/ossrv/lowlevellibsandfws/pluginfw/Framework/LoadManagerTest/t

sl@0	1	// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0	2	// All rights reserved.
sl@0	3	// This component and the accompanying materials are made available
sl@0	4	// under the terms of "Eclipse Public License v1.0"
sl@0	5	// which accompanies this distribution, and is available
sl@0	6	// at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0	7	//
sl@0	8	// Initial Contributors:
sl@0	9	// Nokia Corporation - initial contribution.
sl@0	10	//
sl@0	11	// Contributors:
sl@0	12	//
sl@0	13	// Description:
sl@0	14	// This file contains test classes and their implementations
sl@0	15	// to test production class CLoadManager. Where necessary stubs
sl@0	16	// are implemented to help in writing test harness using RTest.
sl@0	17	// Plugins available to be used in this test
sl@0	18	// Interface UID DLL UID Implementation UID Version DllFile
sl@0	19	// 0x10009DC0 0x10009DB1 0x10009DC3 1 Z:\\..\\EComExample.dll
sl@0	20	// 0x10009DB1 0x10009DC4 1 Z:\\..\\EComExample.dll
sl@0	21	// 0x10009DB3 0x10009DC3 2 Z:\\..\\EComExample2.dll
sl@0	22	// 0x10009DB3 0x10009DC4 2 Z:\\..\\EComExample2.dll
sl@0	23	// 0x101F8477 0x101F8478 1 Z:\\..\\EComExample3.dll
sl@0	24	// 0x101F8479 0x101F847A 1 Z:\\..\\EComExample4.dll
sl@0	25	// 0x101F847B 0x101F847C 1 C:\\..\\EComExample5.dll
sl@0	26	// 0x10282331 0x10282330 0x10282332 1 Z:\\..\\EComLoadMgrExample1.dll
sl@0	27	// 0x10282330 0x10282334 1 Z:\\..\\EComLoadMgrExample1.dll
sl@0	28	// 0x10282335 0x10282333 1 Z:\\..\\EComLoadMgrExample2.dll
sl@0	29	//
sl@0	30	//
sl@0	31
sl@0	32	#include <e32test.h>
sl@0	33	#include <f32file.h>
sl@0	34	#include <bautils.h>
sl@0	35	#include <e32uid.h>
sl@0	36	#include "LoadManager.h"
sl@0	37	#include <ecom/ecomerrorcodes.h>
sl@0	38	#include "EComUidCodes.h"
sl@0	39	#include "RegistryData.h"
sl@0	40	#include <ecom/implementationinformation.h>
sl@0	41	#include "../EcomTestUtils/EcomTestUtils.h"
sl@0	42	#include "Interface.h"
sl@0	43	#include "UnloadPolicy.h"
sl@0	44	// ---------------------------------------------------------------------------
sl@0	45	// Test and Leave framework
sl@0	46
sl@0	47	LOCAL_D RTest TheTest(_L("t_loadmanager.exe"));
sl@0	48
sl@0	49	LOCAL_C void Check(TInt aValue, TInt aLine)
sl@0	50	{
sl@0	51	if(!aValue)
sl@0	52	{
sl@0	53	//DeleteTestPlugin();
sl@0	54	TheTest(EFalse, aLine);
sl@0	55	}
sl@0	56	}
sl@0	57
sl@0	58	LOCAL_C void Check(TInt aValue, TInt aExpected, TInt aLine)
sl@0	59	{
sl@0	60	if(aValue != aExpected)
sl@0	61	{
sl@0	62	RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
sl@0	63	//DeleteTestPlugin();
sl@0	64	TheTest(EFalse, aLine);
sl@0	65	}
sl@0	66	}
sl@0	67
sl@0	68	#define TEST(arg) ::Check((arg), __LINE__)
sl@0	69
sl@0	70	#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
sl@0	71
sl@0	72	//Leave with info message printed out
sl@0	73	LOCAL_C void Leave(TInt aError, TInt aLine)
sl@0	74	{
sl@0	75	RDebug::Print(_L("*** Leave. Error: %d, Line: %d\r\n"), aError, aLine);
sl@0	76	User::Leave(aError);
sl@0	77	}
sl@0	78
sl@0	79
sl@0	80	//Use LEAVE() macro instead of User::Leave() and LEAVE_IF_ERROR() macro instead of
sl@0	81	//User::LeaveIfError(). They will print the line number, where the "leave" was called.
sl@0	82
sl@0	83	#define LEAVE(aError) ::Leave(aError, __LINE__)
sl@0	84
sl@0	85
sl@0	86	// ---------------------------------------------------------------------------
sl@0	87
sl@0	88	LOCAL_D RFs TheFs;
sl@0	89
sl@0	90	LOCAL_D CTrapCleanup* TheTrapCleanup = NULL;
sl@0	91
sl@0	92	LOCAL_D CActiveScheduler* TheActiveScheduler = NULL;
sl@0	93
sl@0	94	//Plugins files used for this test program
sl@0	95	_LIT(KResourceFileName5, "C:\\resource\\plugins\\EComExample5.RSC");
sl@0	96	_LIT(KExampleDllFileName5, "C:\\sys\\bin\\EComExample5.dll");
sl@0	97	_LIT(KExampleDllFileName4,"Z:\\sys\\bin\\EComExample4.dll");
sl@0	98	_LIT(KExampleDllFileName3,"Z:\\sys\\bin\\EComExample3.dll");
sl@0	99	_LIT(KExampleDllFileName2,"Z:\\sys\\bin\\EComExample2.dll");
sl@0	100	_LIT(KLoadMgrExample1DllName,"Z:\\sys\\bin\\EComLoadMgrExample1.dll");
sl@0	101	_LIT(KLoadMgrExample2DllName,"Z:\\sys\\bin\\EComLoadMgrExample2.dll");
sl@0	102
sl@0	103	_LIT(KResourceFileName5OnZ, "z:\\RAMOnly\\EComExample5.RSC");
sl@0	104	_LIT(KExampleDllFileName10,"Z:\\sys\\bin\\EComExample10.dll");
sl@0	105	_LIT(KNULLString,"");
sl@0	106
sl@0	107	_LIT(KExampleDllFileName12,"C:\\sys\\bin\\EComExample12.dll");
sl@0	108	_LIT(KExampleDllFileName12OnZ, "z:\\RAMOnly\\EComExample12.dll");
sl@0	109	_LIT(KResourceFileName12, "C:\\resource\\plugins\\EComExample12.RSC");
sl@0	110	_LIT(KResourceFileName12OnZ, "z:\\RAMOnly\\EComExample12.RSC");
sl@0	111
sl@0	112	//Contains files that are part of ROM that must be
sl@0	113	//Copied to the RAM for test purposes
sl@0	114
sl@0	115	_LIT(KExampleDllFileName5OnZ, "z:\\RAMOnly\\EComExample5.dll");
sl@0	116
sl@0	117
sl@0	118	// Used for supressing warning in OOM tests
sl@0	119	#define __UNUSED_VAR(var) var = var
sl@0	120
sl@0	121	const TInt KOneSecond = 1000000;
sl@0	122
sl@0	123	// Utility clean up function
sl@0	124	void CleanupEComArray(TAny* aArray);
sl@0	125
sl@0	126	//It is used by some test methods which are called two times:
sl@0	127	//from normal test and from OOM TheTest.
sl@0	128	static void LeaveIfErrNoMemory(TInt aError)
sl@0	129	{
sl@0	130	if(aError == KErrNoMemory)
sl@0	131	{
sl@0	132	LEAVE(aError);
sl@0	133	}
sl@0	134	}
sl@0	135
sl@0	136	/**
sl@0	137	Test State Accessor class for CLoadManager
sl@0	138	This class will be used to access the state
sl@0	139	of the policy array within CLoadManager
sl@0	140	*/
sl@0	141	class TLoadManager_StateAccessor
sl@0	142	{
sl@0	143	public:
sl@0	144	//Return the number of instance index inside iInstanceInfoList
sl@0	145	TInt InstanceIndexCount(CLoadManager& aLoadManager);
sl@0	146	//Return the number of unload policy inside iAllUnloadPolicies
sl@0	147	TInt UnloadPolicyCount(CLoadManager& aLoadManager);
sl@0	148	//Return a pointer to Instance Index item inside the instance index array
sl@0	149	CInstanceInfo* InstanceIndex(const TInt& aInt,CLoadManager& aLoadManager);
sl@0	150	//Return a pointer to UnloadPolicy item inside the array
sl@0	151	CUnloadPolicy* UnloadPolicy(const TInt& aInt,CLoadManager& aLoadManager);
sl@0	152	//Return a pointer to garbage UnloadPolicy
sl@0	153	CUnloadPolicy* GarbagePolicy(CLoadManager& aLoadManager);
sl@0	154	//Return a count to the number of extended objects within an Extended instance.
sl@0	155	// Must pass in the index of a valid extended instance
sl@0	156	TInt ExtendedInstanceCount(const TInt& aInt,CLoadManager& aLoadManager);
sl@0	157	};
sl@0	158
sl@0	159	TInt TLoadManager_StateAccessor::InstanceIndexCount(CLoadManager& aLoadManager)
sl@0	160	{
sl@0	161	return aLoadManager.iInstanceInfoList.Count();
sl@0	162	}
sl@0	163
sl@0	164	TInt TLoadManager_StateAccessor::UnloadPolicyCount(CLoadManager& aLoadManager)
sl@0	165	{
sl@0	166	return aLoadManager.iAllUnloadPolicies.Count();
sl@0	167	}
sl@0	168
sl@0	169	CInstanceInfo* TLoadManager_StateAccessor::InstanceIndex(const TInt& aInt,CLoadManager& aLoadManager)
sl@0	170	{
sl@0	171	return (aLoadManager.iInstanceInfoList[aInt]);
sl@0	172	}
sl@0	173
sl@0	174	CUnloadPolicy* TLoadManager_StateAccessor::UnloadPolicy(const TInt& aInt,CLoadManager& aLoadManager)
sl@0	175	{
sl@0	176	return aLoadManager.iAllUnloadPolicies[aInt];
sl@0	177	}
sl@0	178	CUnloadPolicy* TLoadManager_StateAccessor::GarbagePolicy(CLoadManager& aLoadManager)
sl@0	179	{
sl@0	180	return aLoadManager.iGarbagePolicy;
sl@0	181	}
sl@0	182
sl@0	183	TInt TLoadManager_StateAccessor::ExtendedInstanceCount(const TInt& aInt,CLoadManager& aLoadManager)
sl@0	184	{
sl@0	185	CInstanceInfoExtended* instanceExtended = static_cast<CInstanceInfoExtended*>(aLoadManager.iInstanceInfoList[aInt]);
sl@0	186	return instanceExtended->iExtendedObjectInfo.Count();
sl@0	187	}
sl@0	188
sl@0	189
sl@0	190	/**
sl@0	191	Test class for object CLoadManager.
sl@0	192	The class provides the parameters and behaviour that
sl@0	193	allows this class to behave normally under a test scenario.
sl@0	194	*/
sl@0	195	class CLoadManagerTest : public CBase
sl@0	196	{
sl@0	197	public:
sl@0	198	static CLoadManagerTest* NewL();
sl@0	199	virtual inline ~CLoadManagerTest();
sl@0	200
sl@0	201	void InstantiationMethodTestL(TUid aDllUid, const TDesC& aDllName, const TUid aIICType);
sl@0	202	void DestroyThisTestL(TUid aDllUid, const TDesC& aDllName, const TUid aIICType);
sl@0	203
sl@0	204	void CreateDestroyTestCase1L(TUid aDllUid1,
sl@0	205	TUid aImplUid1,
sl@0	206	const TDesC& aDllName1,
sl@0	207	TUid aDllUid2,
sl@0	208	TUid aImplUid2,
sl@0	209	const TDesC& aDllName2,
sl@0	210	const TUid aIICType);
sl@0	211	void CreateDestroyTestCase2L(TUid aDllUid,
sl@0	212	TUid aImplUid1,
sl@0	213	const TDesC& aDllName,
sl@0	214	TUid aImplUid2,
sl@0	215	const TUid aIICType);
sl@0	216	void CreateDestroyTestCase3L();
sl@0	217
sl@0	218	void CreateDestroyTestCase4L(TUid aDllUid,TUid aImplUid,const TDesC& aDllName,const TUid aIICType);
sl@0	219
sl@0	220	void CreateDestroyTestCase5L(TUid aDllUid1,
sl@0	221	TUid aImplUid1,
sl@0	222	const TDesC& aDllName1,
sl@0	223	TUid aDllUid2,
sl@0	224	TUid aImplUid2,
sl@0	225	const TDesC& aDllName2,
sl@0	226	TUid aImplUid3,
sl@0	227	const TUid aIICType);
sl@0	228
sl@0	229	void SpecialOOMTestCaseL();
sl@0	230
sl@0	231	void InstantiationMethodTestPlugin1L();
sl@0	232	void InstantiationMethodTestPlugin3L();
sl@0	233	void ImplementationObjectTestL();
sl@0	234
sl@0	235	void GetImplementationUidTestL();
sl@0	236
sl@0	237	void DestroyThisTestPlugin1L();
sl@0	238	void DestroyThisTestPlugin3L();
sl@0	239
sl@0	240	void CreateDestroyTestCase1Plugin1L();
sl@0	241	void CreateDestroyTestCase1Plugin3L();
sl@0	242
sl@0	243	void CreateDestroyTestCase2Plugin1L();
sl@0	244	void CreateDestroyTestCase2Plugin3L();
sl@0	245
sl@0	246	void CreateDestroyTestCase3Plugin3L();
sl@0	247
sl@0	248	void CreateDestroyTestCase4Plugin1L();
sl@0	249	void CreateDestroyTestCase4Plugin3L();
sl@0	250
sl@0	251	void CreateDestroyTestCase5Plugin1L();
sl@0	252	void CreateDestroyTestCase5Plugin3L();
sl@0	253
sl@0	254	// Extended methods
sl@0	255	void ExtendedMethodTest1Plugin3L();
sl@0	256	void ExtendedMethodTest2Plugin3L();
sl@0	257	void ManuallyReleaseExtendedInterfaceTestL();
sl@0	258	void CreateDestroyTestCase1PluginAndPlugin3L();
sl@0	259
sl@0	260	private:
sl@0	261	CLoadManagerTest();
sl@0	262	void ConstructL();
sl@0	263
sl@0	264	public:
sl@0	265	/** The instance of the class under test */
sl@0	266	CLoadManager* iLoadManager;
sl@0	267
sl@0	268	/** Unique Id of an interface implementation */
sl@0	269	TUid iImplementationUid;
sl@0	270
sl@0	271	/** LoadManager State Accessor */
sl@0	272	TLoadManager_StateAccessor iStateAccessor;
sl@0	273	};
sl@0	274
sl@0	275	/**
sl@0	276	Standardised safe construction which
sl@0	277	leaves nothing on the cleanup stack.
sl@0	278
sl@0	279	@post CLoadManagerTest is fully constructed and initialised.
sl@0	280	*/
sl@0	281	CLoadManagerTest* CLoadManagerTest::NewL()
sl@0	282	{
sl@0	283	CLoadManagerTest* self = new(ELeave) CLoadManagerTest;
sl@0	284	CleanupStack::PushL(self);
sl@0	285	self->ConstructL();
sl@0	286	CleanupStack::Pop(self);
sl@0	287	return self;
sl@0	288	}
sl@0	289
sl@0	290	/**
sl@0	291	Standardized default constructor
sl@0	292
sl@0	293	@post CLoadManagerTest is fully constructed.
sl@0	294	*/
sl@0	295	CLoadManagerTest::CLoadManagerTest()
sl@0	296	{
sl@0	297	// Implementation id for interface 0x10009DC0
sl@0	298	// Implemented in test plugin EComExample4.dll
sl@0	299	iImplementationUid.iUid = 0x101F847A;
sl@0	300	}
sl@0	301
sl@0	302	/**
sl@0	303	Destructor.
sl@0	304
sl@0	305	@post This object is properly destroyed.
sl@0	306	*/
sl@0	307	CLoadManagerTest::~CLoadManagerTest()
sl@0	308	{
sl@0	309	delete iLoadManager;
sl@0	310	}
sl@0	311
sl@0	312	/**
sl@0	313	Standardized 2nd(Initialization) phase of two phase construction.
sl@0	314
sl@0	315	@post CLoadManagerTest is fully constructed.
sl@0	316	*/
sl@0	317	void CLoadManagerTest::ConstructL()
sl@0	318	{
sl@0	319	iLoadManager = CLoadManager::NewL();
sl@0	320	}
sl@0	321
sl@0	322	/**
sl@0	323	The test executes by getting the Instantiation method for
sl@0	324	the given ImplementationId
sl@0	325	*/
sl@0	326	void CLoadManagerTest::InstantiationMethodTestL(TUid aDllUid, const TDesC& aDllName, const TUid aIICType)
sl@0	327	{
sl@0	328	CExampleInterface::TExampleInterfaceInitParams iInitParams;
sl@0	329	iInitParams.integer = 5;
sl@0	330	TBool initParamsFlag = ETrue;
sl@0	331	_LIT(KDummyText,"Dummy params");
sl@0	332	iInitParams.descriptor = &KDummyText;
sl@0	333
sl@0	334	TEntry entry;
sl@0	335	entry.iName=aDllName;
sl@0	336	entry.iModified=TTime(0);
sl@0	337	entry.iType=TUidType(KDynamicLibraryUid,aIICType,aDllUid);
sl@0	338
sl@0	339	TAny* implementationPtr = 0;
sl@0	340	TUid instanceKey;
sl@0	341	TRAPD(err, implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid, entry,&iInitParams, initParamsFlag,instanceKey));
sl@0	342
sl@0	343	::LeaveIfErrNoMemory(err);
sl@0	344	TEST2(err,KErrNone);
sl@0	345	TEST(implementationPtr != 0);
sl@0	346
sl@0	347	//Checking the state of the arrays inside CLoadManager and garbage policy
sl@0	348	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==1);
sl@0	349	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==1);
sl@0	350	TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL);
sl@0	351
sl@0	352	//Checking the instance index and UnloadPolicy info
sl@0	353	TEST(iStateAccessor.InstanceIndex(0,*iLoadManager)->ImplementationUid()==iImplementationUid);
sl@0	354	TEST(iStateAccessor.UnloadPolicy(0,*iLoadManager)->DllEntryInformation().GetName().CompareF(aDllName)==0);
sl@0	355
sl@0	356	delete (CExampleInterface*)implementationPtr;
sl@0	357	implementationPtr=0;
sl@0	358	iLoadManager->DestroyedThis(instanceKey);
sl@0	359	iLoadManager->ClearGarbage();
sl@0	360	}
sl@0	361
sl@0	362	/**
sl@0	363	Test CLoadManager::ImplementationObjectL with parameters to test old proxy table
sl@0	364	*/
sl@0	365	void CLoadManagerTest::InstantiationMethodTestPlugin1L()
sl@0	366	{
sl@0	367	// This test tests with Ecom plugin EComExample4.dll
sl@0	368	// EComExample4.dll should be installed on Z: drive
sl@0	369	// The test executes by getting the Instantiation method for the given ImplementationId
sl@0	370	// implementationPtr method should get some valid address.
sl@0	371	// Manually creating the DLL info that in practice will be returned from the server side
sl@0	372	// Set up some init params to be used for testing purpose
sl@0	373	TUid dllUid;
sl@0	374	dllUid.iUid = 0x101F8479;
sl@0	375	iImplementationUid.iUid=0x101F847A;
sl@0	376	InstantiationMethodTestL(dllUid,KExampleDllFileName4,KUidInterfaceImplementationCollection);
sl@0	377	}
sl@0	378
sl@0	379	/**
sl@0	380	@SYMTestCaseID SYSLIB-ECOM-UT-3549
sl@0	381	@SYMTestCaseDesc Calls CLoadManager::ImplementationObjectL with parameters to test new proxy table
sl@0	382	@SYMTestPriority High
sl@0	383	@SYMTestActions Instantiate implementation for the given ImplementationId with construction parameters
sl@0	384	and check the CLoadManager data structures.
sl@0	385	Destroy the implementation object and again check the CLoadManager data structures.
sl@0	386	(ECom plugin EComExample10.dll will be used for the test.)
sl@0	387	@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls
sl@0	388	@SYMEC EC43
sl@0	389	*/
sl@0	390	void CLoadManagerTest::InstantiationMethodTestPlugin3L()
sl@0	391	{
sl@0	392	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3549 "));
sl@0	393	TUid dllUid;
sl@0	394	dllUid.iUid = 0x10009E37;
sl@0	395	iImplementationUid.iUid = 0x10009E38;
sl@0	396	InstantiationMethodTestL(dllUid,KExampleDllFileName10,KUidInterfaceImplementationCollection3);
sl@0	397	}
sl@0	398
sl@0	399
sl@0	400	/**
sl@0	401	@SYMTestCaseID SYSLIB-ECOM-UT-3710
sl@0	402	@SYMTestCaseDesc Tests CLoadManager::ImplementationObjectL with some extreme conditions to improve the
sl@0	403	condition coverage rate.
sl@0	404	1. implementationUid is NULL. The function will leave with KErrNotFound
sl@0	405	2. dllName is NULL. The function will leave with KErrNotFound
sl@0	406	3. second Uid of the PlugIn is neither IIC or IIC3. The function will leave with KErrNotSupported
sl@0	407	@SYMTestPriority High
sl@0	408	@SYMTestActions Calls CLoadManager::ImplementationObjectL and check the result.
sl@0	409	@SYMTestExpectedResults Expected error is return.
sl@0	410	@SYMDEF DEF111196
sl@0	411	*/
sl@0	412	void CLoadManagerTest::ImplementationObjectTestL()
sl@0	413	{
sl@0	414	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3710 "));
sl@0	415	TUid dummyUid;
sl@0	416	dummyUid.iUid = 0;
sl@0	417
sl@0	418	TUid dllUid;
sl@0	419	dllUid.iUid = 0x10009E37;
sl@0	420
sl@0	421	iImplementationUid.iUid = 0x10009E38;
sl@0	422
sl@0	423	CExampleInterface::TExampleInterfaceInitParams iInitParams;
sl@0	424	iInitParams.integer = 5;
sl@0	425	TBool initParamsFlag = ETrue;
sl@0	426	_LIT(KDummyText,"Dummy params");
sl@0	427	iInitParams.descriptor = &KDummyText;
sl@0	428
sl@0	429	TEntry entry;
sl@0	430	entry.iName=KExampleDllFileName10;
sl@0	431	entry.iModified=TTime(0);
sl@0	432	entry.iType=TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid);
sl@0	433
sl@0	434	TUid instanceKey;
sl@0	435
sl@0	436	// 1. Calls ImplementationObjectL with implementationUid is NULL. The function will leave with KErrNotFound
sl@0	437	TRAPD(err, TAny* implementationPtr = iLoadManager->ImplementationObjectL(dummyUid, entry,&iInitParams, initParamsFlag,instanceKey));
sl@0	438	TEST2(err,KErrNotFound);
sl@0	439
sl@0	440	// 2. Calls ImplementationObjectL with dllName is NULL. The function will leave with KErrNotFound
sl@0	441	entry.iName = KNULLString;
sl@0	442	TRAP(err, TAny* implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid,entry,&iInitParams, initParamsFlag,instanceKey));
sl@0	443	TEST2(err,KErrNotFound);
sl@0	444
sl@0	445	// 3. Calls ImplementationObjectL with second Uid of the PlugIn is neither IIC or IIC3
sl@0	446	entry.iName=KExampleDllFileName10;
sl@0	447	entry.iModified=TTime(0);
sl@0	448	entry.iType=TUidType(KDynamicLibraryUid,dummyUid,dllUid);
sl@0	449	TRAP(err, TAny* implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid,entry,&iInitParams, initParamsFlag,instanceKey));
sl@0	450	TEST2(err,KErrNotSupported);
sl@0	451	}
sl@0	452
sl@0	453
sl@0	454	/**
sl@0	455	Test CLoadManager::DestroyThis(). DestroyThis will actually either remove the UnloadPolicy from the list or decrease
sl@0	456	referencecount(to UnloadPolicy) by one.
sl@0	457	*/
sl@0	458	void CLoadManagerTest::DestroyThisTestL(TUid aDllUid, const TDesC& aDllName, const TUid aIICType)
sl@0	459	{
sl@0	460	// We must call DestroyedThis only after getting a reference to the Implementation
sl@0	461	// so that reference count to this implementaion have value greater than zero.
sl@0	462	// ImplementationObjectL is called to increase the reference count of the test implementation,
sl@0	463	// so that its reference count goes to 1.
sl@0	464	// This test executes by verifing the reference count to this implementation.
sl@0	465	CExampleInterface::TExampleInterfaceInitParams iInitParams;
sl@0	466	iInitParams.integer = 5;
sl@0	467	TBool initParamsFlag = ETrue;
sl@0	468	_LIT(KDummyText,"Dummy params");
sl@0	469	iInitParams.descriptor = &KDummyText;
sl@0	470
sl@0	471	TEntry entry;
sl@0	472	entry.iName=aDllName;
sl@0	473	entry.iModified=TTime(0);
sl@0	474	entry.iType=TUidType(KDynamicLibraryUid, aIICType, aDllUid);
sl@0	475
sl@0	476	TAny* implementationPtr = 0;
sl@0	477	TUid instanceKey;
sl@0	478	TRAPD(err, implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid, entry, &iInitParams, initParamsFlag,instanceKey));
sl@0	479
sl@0	480	::LeaveIfErrNoMemory(err);
sl@0	481	TEST2(err,KErrNone);
sl@0	482	TEST(implementationPtr != 0);
sl@0	483
sl@0	484	//Checking the state of the arrays inside CLoadManager and the garbage policy
sl@0	485	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==1);
sl@0	486	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==1);
sl@0	487	TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL);
sl@0	488
sl@0	489	// The purpose of DestroyedThis is to decrease the reference count of UnloadPolicy or
sl@0	490	// remove the Dll from RegistryData if its on grabagelist and reference count reaches 0
sl@0	491	iLoadManager->DestroyedThis(instanceKey);
sl@0	492
sl@0	493	//Checking the state of the arrays inside CLoadManager and the garbage policy
sl@0	494	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==0);
sl@0	495	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==0);
sl@0	496	TEST(iStateAccessor.GarbagePolicy(*iLoadManager)!=NULL);
sl@0	497
sl@0	498	//delete the instantiation
sl@0	499	delete (CExampleInterface*)implementationPtr;
sl@0	500	implementationPtr=0;
sl@0	501	}
sl@0	502
sl@0	503	/**
sl@0	504	@SYMTestCaseID SYSLIB-ECOM-UT-3709
sl@0	505	@SYMTestCaseDesc This testcase checks GetImplementationUidL().
sl@0	506	@SYMTestPriority High
sl@0	507	@SYMTestActions Instantiate an implementation.
sl@0	508	Call GetImplementationUidL() and check impl id.
sl@0	509	Call GetImplementationUidL() and check impl id again.
sl@0	510	Destroy plugin.
sl@0	511	Call GetImplementationUidL() and check for error.
sl@0	512	@SYMTestExpectedResults Returns impl uid when valid destructor uid is used otherwise
sl@0	513	leaves with the appropriate error.
sl@0	514	@SYMDEF DEF111789
sl@0	515	*/
sl@0	516	void CLoadManagerTest::GetImplementationUidTestL()
sl@0	517	{
sl@0	518	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3709 "));
sl@0	519	// EComExample5.dll (dlluid 0x101F847B) in C:\ with Implementation Uid =0x101F847C
sl@0	520	TUid dllUid;
sl@0	521	dllUid.iUid = 0x101F847B;
sl@0	522	CExampleInterface::TExampleInterfaceInitParams iInitParams;
sl@0	523	iInitParams.integer = 5;
sl@0	524	TBool initParamsFlag = ETrue;
sl@0	525	_LIT(KDummyText,"Dummy params");
sl@0	526	iInitParams.descriptor = &KDummyText;
sl@0	527
sl@0	528	TEntry entry;
sl@0	529	entry.iName=KExampleDllFileName5;
sl@0	530
sl@0	531	entry.iModified=TTime(0);
sl@0	532	entry.iType=TUidType(KDynamicLibraryUid, KUidInterfaceImplementationCollection, dllUid);
sl@0	533
sl@0	534	iImplementationUid.iUid=0x101F847C;
sl@0	535
sl@0	536	TAny* implementationPtr = 0;
sl@0	537	TUid instanceKey;
sl@0	538	TRAPD(err, implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid, entry, &iInitParams, initParamsFlag, instanceKey));
sl@0	539
sl@0	540	::LeaveIfErrNoMemory(err);
sl@0	541	TEST2(err,KErrNone);
sl@0	542	TEST(implementationPtr != 0);
sl@0	543
sl@0	544	// Retrieve impl uid corresponding to detructor key id
sl@0	545	TUid implId = iLoadManager->GetImplementationUidL(instanceKey);
sl@0	546	// Check that the impl uid corresponding to destructor key id is as expected
sl@0	547	TEST(implId == iImplementationUid);
sl@0	548
sl@0	549	// Do it again to be sure...
sl@0	550	implId = iLoadManager->GetImplementationUidL(instanceKey);
sl@0	551	// Check that the impl uid corresponding to destructor key id is as expected
sl@0	552	TEST(implId == iImplementationUid);
sl@0	553
sl@0	554	iLoadManager->DestroyedThis(instanceKey);
sl@0	555
sl@0	556	//delete the instantiation
sl@0	557	delete (CExampleInterface*)implementationPtr;
sl@0	558	implementationPtr=0;
sl@0	559
sl@0	560	// Call GetImplementationUidL() again now that the instance has been deleted
sl@0	561	// Expecting a Leave...
sl@0	562	TRAP(err,implId = iLoadManager->GetImplementationUidL(instanceKey));
sl@0	563	TEST2(err, KErrNotFound);
sl@0	564	}
sl@0	565
sl@0	566	/**
sl@0	567	Test executes by getting the CUnloadPolicy* associated to the testing DLL EComExample5.dll.
sl@0	568	*/
sl@0	569	void CLoadManagerTest::DestroyThisTestPlugin1L()
sl@0	570	{
sl@0	571	// EComExample5.dll (dlluid 0x101F847B) in C:\ with Implementation Uid =0x101F847C
sl@0	572	TUid dllUid;
sl@0	573	dllUid.iUid = 0x101F847B;
sl@0	574	iImplementationUid.iUid=0x101F847C;
sl@0	575	DestroyThisTestL(dllUid,KExampleDllFileName5,KUidInterfaceImplementationCollection);
sl@0	576	}
sl@0	577
sl@0	578	/**
sl@0	579	@SYMTestCaseID SYSLIB-ECOM-UT-3550
sl@0	580	@SYMTestCaseDesc Calls CLoadManager::DestroyedThis with parameters to test new proxy table
sl@0	581	@SYMTestPriority High
sl@0	582	@SYMTestActions Test executes by getting the CUnloadPolicy* associated to the testing DLL EComExample10.dll.
sl@0	583	DestroyThis will actually either remove the UnloadPolicy from the list or decrease
sl@0	584	referencecount(to UnloadPolicy) by one.
sl@0	585	@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls
sl@0	586	@SYMEC EC43
sl@0	587	*/
sl@0	588	void CLoadManagerTest::DestroyThisTestPlugin3L()
sl@0	589	{
sl@0	590	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3550 "));
sl@0	591	// EComExample10.dll
sl@0	592	TUid dllUid;
sl@0	593	dllUid.iUid = 0x10009E37;
sl@0	594	iImplementationUid.iUid = 0x10009E38;
sl@0	595	DestroyThisTestL(dllUid,KExampleDllFileName10,KUidInterfaceImplementationCollection3);
sl@0	596	}
sl@0	597
sl@0	598	/**
sl@0	599	Tests for create and destroy load manager
sl@0	600	Test case 1:Creates two implementations from two DIFFERENT DLL Z: C:
sl@0	601	Test case 2:Creates two implementations from one SAME DLL
sl@0	602	Test case 3:Invalid argument testing for Create Implementation
sl@0	603	Invalid Entry and Implementation uid argument in ImplementationObjectL
sl@0	604	Test case 4:Creates two instance of the same implementation Uid from one single DLL
sl@0	605	Test case 5:DEF101930: Incorrect policy object returned in
sl@0	606	This testcase checks for the case where 2 implementations
sl@0	607	are created each on separate DLL's then an additional
sl@0	608	implementation is created from one of the already loaded DLL's.
sl@0	609	The impl uid of the newly created impl is lower then the 2
sl@0	610	existing impl uids. The impl uids from the same DLL are such
sl@0	611	that 1 is higher then the uid of the other impl and 1 is lower than
sl@0	612	the other impl.
sl@0	613	*/
sl@0	614
sl@0	615	// Test case 1:Create two implementation from two DIFFERENT DLL Z: C:
sl@0	616
sl@0	617	void CLoadManagerTest::CreateDestroyTestCase1L(TUid aDllUid1,
sl@0	618	TUid aImplUid1,
sl@0	619	const TDesC& aDllName1,
sl@0	620	TUid aDllUid2,
sl@0	621	TUid aImplUid2,
sl@0	622	const TDesC& aDllName2,
sl@0	623	const TUid aIICType)
sl@0	624	{
sl@0	625	//Some interface instantiation parameters
sl@0	626	CExampleInterface::TExampleInterfaceInitParams iInitParams;
sl@0	627	iInitParams.integer = 5;
sl@0	628	TBool initParamsFlag = ETrue;
sl@0	629	_LIT(KDummyText,"Dummy params");
sl@0	630	iInitParams.descriptor = &KDummyText;
sl@0	631	TAny* impl1 = NULL;
sl@0	632	TAny* impl2 = NULL;
sl@0	633
sl@0	634	TEntry entry1;
sl@0	635	entry1.iName = aDllName1;
sl@0	636	entry1.iModified = TTime(0);
sl@0	637	entry1.iType = TUidType(KDynamicLibraryUid,aIICType,aDllUid1);
sl@0	638
sl@0	639	TEntry entry2;
sl@0	640	entry2.iName = aDllName2;
sl@0	641	entry2.iModified = TTime(0);
sl@0	642	entry2.iType = TUidType(KDynamicLibraryUid,aIICType,aDllUid2);
sl@0	643
sl@0	644	TInt err;
sl@0	645	//Creates 1st Implementation
sl@0	646	TUid instanceKey;
sl@0	647	TRAP(err,impl1 = iLoadManager->ImplementationObjectL(aImplUid1,entry1, &iInitParams,initParamsFlag,instanceKey));
sl@0	648	::LeaveIfErrNoMemory(err);
sl@0	649	TEST2(err,KErrNone);
sl@0	650
sl@0	651	//Checks the state of the arrays inside CLoadManager and the garbage policy
sl@0	652	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1);
sl@0	653	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
sl@0	654	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	655
sl@0	656	//Creates 2nd Implementation
sl@0	657	TUid instanceKey2;
sl@0	658	TRAP(err,impl2 = iLoadManager->ImplementationObjectL(aImplUid2,entry2, &iInitParams,initParamsFlag,instanceKey2));
sl@0	659	// If impl2 fails here due to KErrNoMemory we need to clear the previous impl1
sl@0	660	// to avoid memory leak
sl@0	661	if (err==KErrNoMemory)
sl@0	662	{
sl@0	663	iLoadManager->DestroyedThis(instanceKey);
sl@0	664	delete (CExampleInterface*)impl1;
sl@0	665	impl1 = NULL;
sl@0	666	::LeaveIfErrNoMemory(err);
sl@0	667	}
sl@0	668	TEST(err == KErrNone);
sl@0	669
sl@0	670	//Checks the state of the arrays inside CLoadManager and the garbage policy
sl@0	671	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 2);
sl@0	672	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 2);
sl@0	673	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	674
sl@0	675	//Now destroy the 2nd Implementation
sl@0	676	iLoadManager->DestroyedThis(instanceKey2);
sl@0	677	delete (CExampleInterface*)impl2;
sl@0	678	impl2 = NULL;
sl@0	679
sl@0	680	//Checks the state of the arrays inside CLoadManager and the garbage policy
sl@0	681	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1);
sl@0	682	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
sl@0	683	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL);
sl@0	684
sl@0	685	//Now destroy the 1st Implementation;
sl@0	686	iLoadManager->DestroyedThis(instanceKey);
sl@0	687	delete (CExampleInterface*)impl1;
sl@0	688	impl1 = NULL;
sl@0	689
sl@0	690	//Checks the state of the arrays inside CLoadManager and the garbage policy
sl@0	691	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0);
sl@0	692	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0);
sl@0	693	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL);
sl@0	694
sl@0	695	iLoadManager->ClearGarbage();
sl@0	696
sl@0	697	//Checks the final state of the garbage policy
sl@0	698	//Tests for the new API ClearGarbage()
sl@0	699	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	700	}
sl@0	701
sl@0	702	/**
sl@0	703	Plugins used:
sl@0	704	- Z:\\..\\EComExample3.dll contains ImplUid=0x101F8478
sl@0	705	- C:\\..\\EComExample5.dll contains ImplUid=0x101F847C
sl@0	706
sl@0	707	@SYMTestCaseID SYSLIB-ECOM-CT-0701
sl@0	708	@SYMTestCaseDesc Tests for create and delete of CLoadManager
sl@0	709	@SYMTestPriority High
sl@0	710	@SYMTestActions Create two implementation from two DIFFERENT DLL Z: C:
sl@0	711	@SYMTestExpectedResults Two UnloadPolicy inside the array because of Two DLL loaded
sl@0	712	Two Instance indexes because of two Different Implementation Uid's
sl@0	713	@SYMREQ REQ0000
sl@0	714	*/
sl@0	715	void CLoadManagerTest::CreateDestroyTestCase1Plugin1L()
sl@0	716	{
sl@0	717	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-0701 "));
sl@0	718	//Implementation Uid inside Z:\\..\\EComExample3.dll
sl@0	719	TUid implUid1={0x101F8478};
sl@0	720	//Implementation Uid inside C:\\..\\EComExample5.dll
sl@0	721	TUid implUid2={0x101F847C};
sl@0	722	//EComExample3.dll entry
sl@0	723	TUid dllUid1;
sl@0	724	dllUid1.iUid = 0x101F8477;
sl@0	725	//EComExample5.dll entry
sl@0	726	TUid dllUid2;
sl@0	727	dllUid2.iUid = 0x101F847B;
sl@0	728
sl@0	729	CreateDestroyTestCase1L(dllUid1,implUid1,KExampleDllFileName3,dllUid2,implUid2,KExampleDllFileName5,KUidInterfaceImplementationCollection);
sl@0	730	}
sl@0	731
sl@0	732	/**
sl@0	733	@SYMTestCaseID SYSLIB-ECOM-UT-3551
sl@0	734	@SYMTestCaseDesc Tests for create and delete of implementations using PLUGIN3 from two DIFFERENT DLL's
sl@0	735	@SYMTestPriority High
sl@0	736	@SYMTestActions Create two implementations from two DIFFERENT DLL's using new Dll type PLUGIN3.
sl@0	737	Test executes by getting the CUnloadPolicy* associated to the testing DLL EComExample10.dll.
sl@0	738	DestroyThis will actually either remove the UnloadPolicy from the list or decrease
sl@0	739	referencecount(to UnloadPolicy) by one.
sl@0	740	@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls
sl@0	741	Two UnloadPolicy inside the array because of Two DLL loaded
sl@0	742	Two Instance indexes because of two Different Implementation Uid's
sl@0	743	@SYMEC EC43
sl@0	744	*/
sl@0	745	void CLoadManagerTest::CreateDestroyTestCase1Plugin3L()
sl@0	746	{
sl@0	747	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3551 "));
sl@0	748	//Implementation Uid inside Z:\\..\\EComExample10.dll
sl@0	749	TUid implUid1 = {0x10009E38};
sl@0	750	//Implementation Uid inside C:\\..\\EComExample12.dll
sl@0	751	TUid implUid2 = {0x10009E39};
sl@0	752	//EComExample10.dll entry
sl@0	753	TUid dllUid1;
sl@0	754	dllUid1.iUid = 0x10009E37;
sl@0	755	//EComExample12.dll entry
sl@0	756	TUid dllUid2;
sl@0	757	dllUid2.iUid = 0x10009E3E;
sl@0	758
sl@0	759	CreateDestroyTestCase1L(dllUid1,implUid1,KExampleDllFileName10,dllUid2,implUid2,KExampleDllFileName12,KUidInterfaceImplementationCollection3);
sl@0	760	}
sl@0	761
sl@0	762	/**
sl@0	763	@SYMTestCaseID SYSLIB-ECOM-UT-3552
sl@0	764	@SYMTestCaseDesc Tests for create and delete of implementations using PLUGIN1 and PLUGIN3
sl@0	765	@SYMTestPriority High
sl@0	766	@SYMTestActions Create two implementations from two DIFFERENT DLL's one of PLUGIN1, the other Dll
sl@0	767	of type PLUGIN3. Test executes by getting the CUnloadPolicy* associated to the
sl@0	768	testing DLL EComExample10.dll. DestroyThis will actually either remove the
sl@0	769	UnloadPolicy from the list or decrease referencecount(to UnloadPolicy) by one.
sl@0	770	Plugins used:
sl@0	771	- Z:\\..\\EComExample3.dll contains ImplUid=0x101F8478 - PLUGIN type dll
sl@0	772	- Z:\\..\\EComExample10.dll contains ImplUid=0x10009E38 - PLUGIN3 type dll
sl@0	773	@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls
sl@0	774	Two UnloadPolicy inside the array because of Two DLL loaded
sl@0	775	Two Instance indexes because of two Different Implementations
sl@0	776	@SYMEC EC43
sl@0	777	*/
sl@0	778	void CLoadManagerTest::CreateDestroyTestCase1PluginAndPlugin3L()
sl@0	779	{
sl@0	780	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3552 "));
sl@0	781	//Implementation Uid inside Z:\\..\\EComExample3.dll
sl@0	782	TUid ImplUid1 = {0x101F8478};
sl@0	783	//Implementation Uid inside Z:\\..\\EComExample10.dll
sl@0	784	TUid ImplUid2 = {0x10009E38};
sl@0	785	//Some interface instantiation parameters
sl@0	786	CExampleInterface::TExampleInterfaceInitParams iInitParams;
sl@0	787	iInitParams.integer = 5;
sl@0	788	TBool initParamsFlag = ETrue;
sl@0	789	_LIT(KDummyText,"Dummy params");
sl@0	790	iInitParams.descriptor = &KDummyText;
sl@0	791	TAny* impl1 = NULL;
sl@0	792	TAny* impl2 = NULL;
sl@0	793
sl@0	794	//EComExample3.dll entry
sl@0	795	TUid dllUid1;
sl@0	796	dllUid1.iUid = 0x101F8477;
sl@0	797
sl@0	798	TEntry entry1;
sl@0	799	entry1.iName = KExampleDllFileName3;
sl@0	800	entry1.iModified = TTime(0);
sl@0	801	entry1.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection,dllUid1);
sl@0	802
sl@0	803	//EComExample10.dll entry
sl@0	804	TUid dllUid2;
sl@0	805	dllUid2.iUid = 0x10009E37;
sl@0	806
sl@0	807	TEntry entry2;
sl@0	808	entry2.iName = KExampleDllFileName10;
sl@0	809	entry2.iModified = TTime(0);
sl@0	810	entry2.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid2);
sl@0	811
sl@0	812	TInt err;
sl@0	813	//Creates Implementation with Uid=0x101F8478
sl@0	814	TUid instanceKey;
sl@0	815	TRAP(err,impl1 = iLoadManager->ImplementationObjectL(ImplUid1,entry1, &iInitParams,initParamsFlag,instanceKey));
sl@0	816	::LeaveIfErrNoMemory(err);
sl@0	817	TEST2(err,KErrNone);
sl@0	818
sl@0	819	//Checks the state of the arrays inside CLoadManager and the garbage policy
sl@0	820	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1);
sl@0	821	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
sl@0	822	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	823
sl@0	824	//Creates 2nd Implementation with Uid=0x10009E38
sl@0	825	TUid instanceKey2;
sl@0	826	TRAP(err,impl2 = iLoadManager->ImplementationObjectL(ImplUid2,entry2, &iInitParams,initParamsFlag,instanceKey2));
sl@0	827	// If impl2 fails here due to KErrNoMemory we need to clear the previous impl1
sl@0	828	// to avoid memory leak
sl@0	829	if (err==KErrNoMemory)
sl@0	830	{
sl@0	831	iLoadManager->DestroyedThis(instanceKey);
sl@0	832	delete (CExampleInterface*)impl1;
sl@0	833	impl1 = NULL;
sl@0	834	::LeaveIfErrNoMemory(err);
sl@0	835	}
sl@0	836	TEST(err == KErrNone);
sl@0	837
sl@0	838	//Checks the state of the arrays inside CLoadManager and the garbage policy
sl@0	839	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 2);
sl@0	840	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 2);
sl@0	841	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	842
sl@0	843	//Now destroy the 2nd Implementation
sl@0	844	iLoadManager->DestroyedThis(instanceKey2);
sl@0	845	delete (CExampleInterface*)impl2;
sl@0	846	impl2 = NULL;
sl@0	847
sl@0	848	//Checks the state of the arrays inside CLoadManager and the garbage policy
sl@0	849	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1);
sl@0	850	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
sl@0	851	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL);
sl@0	852
sl@0	853	//Now destroy the 1st Implementation;
sl@0	854	iLoadManager->DestroyedThis(instanceKey);
sl@0	855	delete (CExampleInterface*)impl1;
sl@0	856	impl1 = NULL;
sl@0	857
sl@0	858	//Checks the state of the arrays inside CLoadManager and the garbage policy
sl@0	859	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0);
sl@0	860	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0);
sl@0	861	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL);
sl@0	862
sl@0	863	iLoadManager->ClearGarbage();
sl@0	864
sl@0	865	//Checks the final state of the garbage policy
sl@0	866	//Tests for the new API ClearGarbage()
sl@0	867	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	868	}
sl@0	869
sl@0	870
sl@0	871	// Test case 2:Create two implementation from one SAME DLL
sl@0	872
sl@0	873	void CLoadManagerTest::CreateDestroyTestCase2L(TUid aDllUid,
sl@0	874	TUid aImplUid1,
sl@0	875	const TDesC& aDllName,
sl@0	876	TUid aImplUid2,
sl@0	877	const TUid aIICType)
sl@0	878	{
sl@0	879	CExampleInterface::TExampleInterfaceInitParams iInitParams;
sl@0	880	iInitParams.integer = 5;
sl@0	881	TBool initParamsFlag = ETrue;
sl@0	882	_LIT(KDummyText,"Dummy params");
sl@0	883	iInitParams.descriptor = &KDummyText;
sl@0	884	TAny* impl1 = NULL;
sl@0	885	TAny* impl2 = NULL;
sl@0	886
sl@0	887	TEntry entry;
sl@0	888	entry.iName = aDllName;
sl@0	889	entry.iModified = TTime(0);
sl@0	890	entry.iType = TUidType(KDynamicLibraryUid,aIICType,aDllUid);
sl@0	891
sl@0	892	TInt err;
sl@0	893	//Creates Implementation 1
sl@0	894	TUid instanceKey;
sl@0	895	TRAP(err,impl1 = iLoadManager->ImplementationObjectL(aImplUid1,entry, &iInitParams,initParamsFlag,instanceKey));
sl@0	896	::LeaveIfErrNoMemory(err);
sl@0	897	TEST(err==KErrNone);
sl@0	898	//Checks the state of the arrays inside CLoadManager and the garbage policy
sl@0	899	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1);
sl@0	900	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
sl@0	901	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	902
sl@0	903	TAny* impl4 = NULL;
sl@0	904	//Recreates another Implementation 1
sl@0	905	TUid instanceKey2;
sl@0	906	TRAP(err,impl4 = iLoadManager->ImplementationObjectL(aImplUid1,entry, &iInitParams,initParamsFlag,instanceKey2));
sl@0	907	if (err == KErrNoMemory)
sl@0	908	{
sl@0	909	iLoadManager->DestroyedThis(instanceKey);
sl@0	910	delete (CExampleInterface*)impl1;
sl@0	911	impl1 = NULL;
sl@0	912	::LeaveIfErrNoMemory(err);
sl@0	913	}
sl@0	914	TEST2(err,KErrNone);
sl@0	915	//Checks the state of the arrays inside CLoadManager and the garbage policy
sl@0	916	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 2);
sl@0	917	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
sl@0	918	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	919
sl@0	920	//Creates Implementation 2
sl@0	921	TUid instanceKey3;
sl@0	922	TRAP(err,impl2 = iLoadManager->ImplementationObjectL(aImplUid2,entry, &iInitParams,initParamsFlag,instanceKey3));
sl@0	923	// If impl2 fails here due to KErrNoMemory we need to clear the previous impl1
sl@0	924	// to avoid memory leak
sl@0	925	if (err == KErrNoMemory)
sl@0	926	{
sl@0	927	iLoadManager->DestroyedThis(instanceKey);
sl@0	928	delete (CExampleInterface*)impl1;
sl@0	929	impl1 = NULL;
sl@0	930	iLoadManager->DestroyedThis(instanceKey2);
sl@0	931	delete (CExampleInterface*)impl4;
sl@0	932	impl4 = NULL;
sl@0	933	::LeaveIfErrNoMemory(err);
sl@0	934	}
sl@0	935
sl@0	936	TEST2(err,KErrNone);
sl@0	937
sl@0	938	//Checks the state of the arrays inside CLoadManager and the garbage policy
sl@0	939	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 3);
sl@0	940	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
sl@0	941	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	942
sl@0	943	//Creates another Implementation 2
sl@0	944	TAny* impl3 = NULL;
sl@0	945	TUid instanceKey4;
sl@0	946	TRAP(err,impl3 = iLoadManager->ImplementationObjectL(aImplUid2,entry, &iInitParams,initParamsFlag,instanceKey4));
sl@0	947	//Checks the state of the arrays inside CLoadManager and the garbage policy
sl@0	948	if (err == KErrNoMemory)
sl@0	949	{
sl@0	950	//cleanup the previously loaded implementation before leaving
sl@0	951	iLoadManager->DestroyedThis(instanceKey);
sl@0	952	delete (CExampleInterface*)impl1;
sl@0	953	impl1 = NULL;
sl@0	954	iLoadManager->DestroyedThis(instanceKey2);
sl@0	955	delete (CExampleInterface*)impl4;
sl@0	956	impl4 = NULL;
sl@0	957	iLoadManager->DestroyedThis(instanceKey3);
sl@0	958	delete (CExampleInterface*)impl2;
sl@0	959	impl2 = NULL;
sl@0	960	::LeaveIfErrNoMemory(err);
sl@0	961	}
sl@0	962	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 4);
sl@0	963	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
sl@0	964	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	965
sl@0	966	//Destroy Implementation 1
sl@0	967	iLoadManager->DestroyedThis(instanceKey);
sl@0	968	delete (CExampleInterface*)impl1;
sl@0	969	impl1 = NULL;
sl@0	970	iLoadManager->DestroyedThis(instanceKey2);
sl@0	971	delete (CExampleInterface*)impl4;
sl@0	972	impl4 = NULL;
sl@0	973
sl@0	974	//Checks the state of the arrays inside CLoadManager and the garbage policy
sl@0	975	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 2);
sl@0	976	//Note here after destroying Impl1, the DLL is still in used, so no garbage policy
sl@0	977	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
sl@0	978	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	979
sl@0	980	//Destroy Implementation 2
sl@0	981	iLoadManager->DestroyedThis(instanceKey3);
sl@0	982	delete (CExampleInterface*)impl2;
sl@0	983	impl2 = NULL;
sl@0	984
sl@0	985	//Destroy 2nd Implementation 2
sl@0	986	iLoadManager->DestroyedThis(instanceKey4);
sl@0	987	delete (CExampleInterface*)impl3;
sl@0	988	impl3 = NULL;
sl@0	989
sl@0	990	//Checks the state of the arrays inside CLoadManager and the garbage policy
sl@0	991	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0);
sl@0	992	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0);
sl@0	993	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL);
sl@0	994
sl@0	995	iLoadManager->ClearGarbage();
sl@0	996
sl@0	997	//Checks the final state of the garbage policy
sl@0	998	//Tests for the new API ClearGarbage()
sl@0	999	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	1000	}
sl@0	1001
sl@0	1002
sl@0	1003	/**
sl@0	1004	Plugins used:
sl@0	1005	- Z:\\..\\EComExample2.dll contains ImplUid 0x10009DC3 & 0x10009DC4
sl@0	1006
sl@0	1007	@SYMTestCaseID SYSLIB-ECOM-CT-0702
sl@0	1008	@SYMTestCaseDesc Tests for create and delete of CLoadManager
sl@0	1009	@SYMTestPriority High
sl@0	1010	@SYMTestActions Create two implementation from the SAME DLL
sl@0	1011	@SYMTestExpectedResults One UnloadPolicy since both Implementation is based on SAME DLL
sl@0	1012	Two Instance indexes because of two Different Implementations
sl@0	1013	@SYMREQ REQ0000
sl@0	1014	*/
sl@0	1015	void CLoadManagerTest::CreateDestroyTestCase2Plugin1L()
sl@0	1016	{
sl@0	1017	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-0702 "));
sl@0	1018	TUid implUid1={0x10009DC3};
sl@0	1019	TUid implUid2={0x10009DC4};
sl@0	1020
sl@0	1021	TUid dllUid;
sl@0	1022	dllUid.iUid = 0x10009DB3;
sl@0	1023
sl@0	1024	CreateDestroyTestCase2L(dllUid,implUid1,KExampleDllFileName2,implUid2,KUidInterfaceImplementationCollection);
sl@0	1025
sl@0	1026	}
sl@0	1027
sl@0	1028	/**
sl@0	1029	@SYMTestCaseID SYSLIB-ECOM-UT-3553
sl@0	1030	@SYMTestCaseDesc Tests for create and delete of implementations using PLUGIN3 from the SAME DLL
sl@0	1031	@SYMTestPriority High
sl@0	1032	@SYMTestActions Create two implementation from the SAME DLL using new Dll type PLUGIN3.
sl@0	1033	Test executes by getting the CUnloadPolicy* associated to the testing DLL EComExample10.dll.
sl@0	1034	DestroyThis will actually either remove the UnloadPolicy from the list or decrease
sl@0	1035	referencecount(to UnloadPolicy) by one.
sl@0	1036	@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls
sl@0	1037	One UnloadPolicy since both Implementation is based on SAME DLL
sl@0	1038	Two Instance indexes because of two Different Implementations
sl@0	1039	@SYMEC EC43
sl@0	1040	*/
sl@0	1041	void CLoadManagerTest::CreateDestroyTestCase2Plugin3L()
sl@0	1042	{
sl@0	1043	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3553 "));
sl@0	1044	TUid implUid1 = {0x10009E38};
sl@0	1045	TUid implUid2 = {0x10009E3A};
sl@0	1046
sl@0	1047	TUid dllUid;
sl@0	1048	dllUid.iUid = 0x10009E37;
sl@0	1049
sl@0	1050	CreateDestroyTestCase2L(dllUid,implUid1,KExampleDllFileName10,implUid2,KUidInterfaceImplementationCollection3);
sl@0	1051	}
sl@0	1052
sl@0	1053
sl@0	1054	//Test case 3:Invalid argument testing for Create Implementation
sl@0	1055	// - Invalid Entry and Implementation uid argument in ImplementationObjectL
sl@0	1056
sl@0	1057	/**
sl@0	1058	@SYMTestCaseID SYSLIB-ECOM-CT-0703
sl@0	1059	@SYMTestCaseDesc Tests for create CLoadManager
sl@0	1060	@SYMTestPriority High
sl@0	1061	@SYMTestActions Passing invalid Entry and Implementation uid argument in ImplementationObjectL
sl@0	1062	@SYMTestExpectedResults The test must not fail.
sl@0	1063	@SYMREQ REQ0000
sl@0	1064	*/
sl@0	1065	void CLoadManagerTest::CreateDestroyTestCase3L()
sl@0	1066	{
sl@0	1067	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0703 "));
sl@0	1068	TUid invalidUid={0x10007777};
sl@0	1069
sl@0	1070	//Try supplying invalid implementaion Uid and invalid entry argument
sl@0	1071	TUid dllUid;
sl@0	1072	dllUid.iUid = 0;
sl@0	1073
sl@0	1074	TEntry invalidentry;
sl@0	1075	invalidentry.iName=_L("Z:\\system\\LIBS\\PLUGINS\\EComExample9.dll");
sl@0	1076	invalidentry.iModified=TTime(0);
sl@0	1077	invalidentry.iType=TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection,dllUid);
sl@0	1078
sl@0	1079	TBool initParamsFlag = ETrue;
sl@0	1080
sl@0	1081	TUid instanceKey;
sl@0	1082	TRAPD(err,iLoadManager->ImplementationObjectL(invalidUid,invalidentry, NULL,initParamsFlag,instanceKey));
sl@0	1083	::LeaveIfErrNoMemory(err);
sl@0	1084	//It will return KErrNotFound as the DLL is invalid
sl@0	1085	TEST2(err,KErrNotFound);
sl@0	1086
sl@0	1087	//Checking the state of the arrays inside CLoadManager and the garbage policy
sl@0	1088	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==0);
sl@0	1089	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==0);
sl@0	1090	TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL);
sl@0	1091	}
sl@0	1092
sl@0	1093	/**
sl@0	1094	@SYMTestCaseID SYSLIB-ECOM-UT-3554
sl@0	1095	@SYMTestCaseDesc Invalid argument testing for Create Implementation using new DLL type PLUGIN3
sl@0	1096	@SYMTestPriority High
sl@0	1097	@SYMTestActions Passing invalid Entry and Implementation uid argument in ImplementationObjectL
sl@0	1098	@SYMTestExpectedResults KErrNotFound will be returned as the DLL is invalid
sl@0	1099	@SYMEC EC43
sl@0	1100	*/
sl@0	1101	void CLoadManagerTest::CreateDestroyTestCase3Plugin3L()
sl@0	1102	{
sl@0	1103	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3554 "));
sl@0	1104	// this implementation(0x10009E48) is implemented in EComExample14Upgraded.dll, not in EComExample10.dll
sl@0	1105	TUid implementationUid = {0x10009E48};
sl@0	1106
sl@0	1107	//Try supplying invalid implementaion Uid and invalid entry argument
sl@0	1108	TUid dllUid;
sl@0	1109	dllUid.iUid = 0;
sl@0	1110
sl@0	1111	// Invalid entry for EComExample14Upgraded.dll, because it is not under Z:\\system\\LIBS\\PLUGINS
sl@0	1112	TEntry invalidentry;
sl@0	1113	invalidentry.iName = _L("Z:\\system\\LIBS\\PLUGINS\\EComExample14Upgraded.dll");
sl@0	1114	invalidentry.iModified = TTime(0);
sl@0	1115	invalidentry.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid);
sl@0	1116
sl@0	1117	TUid dllUid1;
sl@0	1118	dllUid1.iUid = 0x10009E37;
sl@0	1119	// Valid entry for EComExample10.dll
sl@0	1120	TEntry entry;
sl@0	1121	entry.iName = KExampleDllFileName10;
sl@0	1122	entry.iModified = TTime(0);
sl@0	1123	entry.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid1);
sl@0	1124	TBool initParamsFlag = ETrue;
sl@0	1125
sl@0	1126	// Test for valid implementation Uid with invalid entry.
sl@0	1127	TUid instanceKey;
sl@0	1128	TRAPD(err,iLoadManager->ImplementationObjectL(implementationUid,invalidentry, NULL,initParamsFlag,instanceKey));
sl@0	1129	::LeaveIfErrNoMemory(err);
sl@0	1130	//Returns KErrNotFound as the DLL is invalid
sl@0	1131	TEST2(err,KErrNotFound);
sl@0	1132	//Checks the state of the arrays inside CLoadManager and the garbage policy
sl@0	1133	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==0);
sl@0	1134	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==0);
sl@0	1135	TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL);
sl@0	1136
sl@0	1137	// Tests for invalid implementation Uid with valid entry.
sl@0	1138	TRAP(err,iLoadManager->ImplementationObjectL(implementationUid,entry, NULL,initParamsFlag,instanceKey));
sl@0	1139	::LeaveIfErrNoMemory(err);
sl@0	1140	//Returns KErrNotFound as the implementation Uid is not within the DLL
sl@0	1141	TEST2(err,KErrNotFound);
sl@0	1142
sl@0	1143	//Checks the state of the arrays inside CLoadManager and the garbage policy
sl@0	1144	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0);
sl@0	1145	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0);
sl@0	1146	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL);
sl@0	1147	}
sl@0	1148
sl@0	1149	//Test case 4:Create two instance of the same implementation Uid from one single DLL
sl@0	1150
sl@0	1151	void CLoadManagerTest::CreateDestroyTestCase4L(TUid aDllUid,
sl@0	1152	TUid aImplUid,
sl@0	1153	const TDesC& aDllName,
sl@0	1154	const TUid aIICType)
sl@0	1155	{
sl@0	1156	TInt err;
sl@0	1157	TEntry entry;
sl@0	1158	entry.iName=aDllName;
sl@0	1159	entry.iModified=TTime(0);
sl@0	1160	entry.iType=TUidType(KDynamicLibraryUid,aIICType,aDllUid);
sl@0	1161
sl@0	1162	CExampleInterface::TExampleInterfaceInitParams iInitParams;
sl@0	1163	iInitParams.integer = 5;
sl@0	1164	TBool initParamsFlag = ETrue;
sl@0	1165	_LIT(KDummyText,"Dummy params");
sl@0	1166	iInitParams.descriptor = &KDummyText;
sl@0	1167	TAny* impl1=NULL;
sl@0	1168	TAny* impl2=NULL;
sl@0	1169
sl@0	1170	//Create 1st instance of implementation
sl@0	1171	TUid instanceKey;
sl@0	1172	TRAP(err,impl1=iLoadManager->ImplementationObjectL(aImplUid,entry, &iInitParams,initParamsFlag,instanceKey));
sl@0	1173	::LeaveIfErrNoMemory(err);
sl@0	1174	TEST2(err,KErrNone);
sl@0	1175
sl@0	1176	//Checking the state of the arrays inside CLoadManager and the garbage policy
sl@0	1177	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==1);
sl@0	1178	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==1);
sl@0	1179	TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL);
sl@0	1180
sl@0	1181	//Create 2nd instance of the same implementation
sl@0	1182	TUid instanceKey2;
sl@0	1183	TRAP(err,impl2=iLoadManager->ImplementationObjectL(aImplUid,entry, &iInitParams,initParamsFlag,instanceKey2));
sl@0	1184	// If impl2 fails here due to KErrNoMemory we need to clear the previous impl1
sl@0	1185	// to avoid memory leak
sl@0	1186	if (err==KErrNoMemory)
sl@0	1187	{
sl@0	1188	iLoadManager->DestroyedThis(instanceKey);
sl@0	1189	delete (CExampleInterface*)impl1;
sl@0	1190	impl1=NULL;
sl@0	1191	::LeaveIfErrNoMemory(err);
sl@0	1192	}
sl@0	1193
sl@0	1194	TEST(err==KErrNone);
sl@0	1195
sl@0	1196	//Checking the state of the arrays inside CLoadManager and the garbage policy
sl@0	1197	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==2);
sl@0	1198	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==1);
sl@0	1199	TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL);
sl@0	1200
sl@0	1201	//Destroyed the 2nd instance of implementation
sl@0	1202	iLoadManager->DestroyedThis(instanceKey2);
sl@0	1203	delete (CExampleInterface*)impl2;
sl@0	1204	impl2=NULL;
sl@0	1205
sl@0	1206	//Checking the state of the arrays inside CLoadManager and the garbage policy
sl@0	1207	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==1);
sl@0	1208	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==1);
sl@0	1209	TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL);
sl@0	1210
sl@0	1211	//Destroyed the 1st instance of implementation
sl@0	1212	iLoadManager->DestroyedThis(instanceKey);
sl@0	1213	delete (CExampleInterface*)impl1;
sl@0	1214	impl1=NULL;
sl@0	1215
sl@0	1216	//Checking the state of the arrays inside CLoadManager and the garbage policy
sl@0	1217	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==0);
sl@0	1218	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==0);
sl@0	1219	TEST(iStateAccessor.GarbagePolicy(*iLoadManager)!=NULL);
sl@0	1220
sl@0	1221	iLoadManager->ClearGarbage();
sl@0	1222	//Checking the final state of the garbage policy
sl@0	1223	TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL);
sl@0	1224	}
sl@0	1225
sl@0	1226
sl@0	1227	/**
sl@0	1228	Plugins used:
sl@0	1229	- Z:\\..\\EComExample2.dll contains ImplUid 0x10009DC3 & 0x10009DC4
sl@0	1230
sl@0	1231	@SYMTestCaseID SYSLIB-ECOM-CT-0704
sl@0	1232	@SYMTestCaseDesc Tests for create and delete of CLoadManager
sl@0	1233	@SYMTestPriority High
sl@0	1234	@SYMTestActions Create two instance of the same implementation Uid from one single DLL
sl@0	1235	@SYMTestExpectedResults CLoadManager only maintains a single UnloadPolicy and one policy
sl@0	1236	mapping index
sl@0	1237	@SYMREQ REQ0000
sl@0	1238	*/
sl@0	1239	void CLoadManagerTest::CreateDestroyTestCase4Plugin1L()
sl@0	1240	{
sl@0	1241	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0704 "));
sl@0	1242	TUid implUid={0x10009DC3};
sl@0	1243
sl@0	1244	TUid dllUid;
sl@0	1245	dllUid.iUid = 0x10009DB3;
sl@0	1246
sl@0	1247	CreateDestroyTestCase4L(dllUid,implUid,KExampleDllFileName2,KUidInterfaceImplementationCollection);
sl@0	1248	}
sl@0	1249
sl@0	1250	/**
sl@0	1251	@SYMTestCaseID SYSLIB-ECOM-UT-3555
sl@0	1252	@SYMTestCaseDesc Create two instance of the same implementation Uid from one single DLL using PLUGIN3
sl@0	1253	Plugins used:
sl@0	1254	- Z:\\..\\EComExample10.dll contains ImplUid 0x10009E38 & 0x10009E3A
sl@0	1255	@SYMTestPriority High
sl@0	1256	@SYMTestActions Create two instance of the same implementation Uid from one single DLL
sl@0	1257	@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls
sl@0	1258	CLoadManager only maintains a single UnloadPolicy and one instance
sl@0	1259	@SYMEC EC43
sl@0	1260	*/
sl@0	1261	void CLoadManagerTest::CreateDestroyTestCase4Plugin3L()
sl@0	1262	{
sl@0	1263	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3555 "));
sl@0	1264	TUid implUid={0x10009E38};
sl@0	1265
sl@0	1266	TUid dllUid;
sl@0	1267	dllUid.iUid = 0x10009E37;
sl@0	1268
sl@0	1269	CreateDestroyTestCase4L(dllUid,implUid,KExampleDllFileName10,KUidInterfaceImplementationCollection3);
sl@0	1270	}
sl@0	1271
sl@0	1272
sl@0	1273	// Test case 5: DEF101930: Incorrect policy object returned in
sl@0	1274
sl@0	1275
sl@0	1276	void CLoadManagerTest::CreateDestroyTestCase5L(TUid aDllUid1,
sl@0	1277	TUid aImplUid1,
sl@0	1278	const TDesC& aDllName1,
sl@0	1279	TUid aDllUid2,
sl@0	1280	TUid aImplUid2,
sl@0	1281	const TDesC& aDllName2,
sl@0	1282	TUid aImplUid3,
sl@0	1283	const TUid aIICType)
sl@0	1284	{
sl@0	1285	CExampleInterface::TExampleInterfaceInitParams iInitParams;
sl@0	1286	iInitParams.integer = 5;
sl@0	1287	TBool initParamsFlag = ETrue;
sl@0	1288	_LIT(KDummyText,"Dummy params");
sl@0	1289	iInitParams.descriptor = &KDummyText;
sl@0	1290	TAny* impl1 = NULL;
sl@0	1291	TAny* impl2 = NULL;
sl@0	1292	TAny* impl3 = NULL;
sl@0	1293
sl@0	1294	TEntry entryExample1;
sl@0	1295	entryExample1.iName = aDllName1;
sl@0	1296	entryExample1.iModified = TTime(0);
sl@0	1297	entryExample1.iType = TUidType(KDynamicLibraryUid,aIICType,aDllUid1);
sl@0	1298
sl@0	1299	TEntry entryExample2;
sl@0	1300	entryExample2.iName = aDllName2;
sl@0	1301	entryExample2.iModified = TTime(0);
sl@0	1302	entryExample2.iType = TUidType(KDynamicLibraryUid,aIICType,aDllUid2);
sl@0	1303
sl@0	1304	TInt err;
sl@0	1305	TUid instanceKey2;
sl@0	1306
sl@0	1307	//Create Implementation 2
sl@0	1308	TRAP(err,impl2 = iLoadManager->ImplementationObjectL(aImplUid2,entryExample1, &iInitParams,initParamsFlag,instanceKey2));
sl@0	1309	::LeaveIfErrNoMemory(err);
sl@0	1310	TEST(err == KErrNone);
sl@0	1311	//Checking the state of the arrays inside CLoadManager and the garbage policy
sl@0	1312	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1);
sl@0	1313	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
sl@0	1314	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	1315
sl@0	1316	TUid instanceKey3;
sl@0	1317	//Create Implementation 3
sl@0	1318	TRAP(err,impl3 = iLoadManager->ImplementationObjectL(aImplUid3,entryExample2, &iInitParams,initParamsFlag,instanceKey3));
sl@0	1319	// If impl3 fails here due to KErrNoMemory we need to clear the previous impl2
sl@0	1320	// to avoid memory leak
sl@0	1321	if (err == KErrNoMemory)
sl@0	1322	{
sl@0	1323	iLoadManager->DestroyedThis(instanceKey2);
sl@0	1324	delete (CExampleInterface*)impl2;
sl@0	1325	impl2 = NULL;
sl@0	1326	::LeaveIfErrNoMemory(err);
sl@0	1327	}
sl@0	1328	TEST2(err,KErrNone);
sl@0	1329
sl@0	1330	//Checking the state of the arrays inside CLoadManager and the garbage policy
sl@0	1331	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 2);
sl@0	1332	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 2);
sl@0	1333	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	1334
sl@0	1335	//Create Implementation 1
sl@0	1336	TUid instanceKey1;
sl@0	1337	TRAP(err,impl1 = iLoadManager->ImplementationObjectL(aImplUid1,entryExample1, &iInitParams,initParamsFlag,instanceKey1));
sl@0	1338	// If impl1 fails here due to KErrNoMemory we need to clear the previous impl2 and impl3
sl@0	1339	// to avoid memory leak
sl@0	1340	if (err == KErrNoMemory)
sl@0	1341	{
sl@0	1342	iLoadManager->DestroyedThis(instanceKey2);
sl@0	1343	delete (CExampleInterface*)impl2;
sl@0	1344	impl2=NULL;
sl@0	1345	iLoadManager->DestroyedThis(instanceKey3);
sl@0	1346	delete (CExampleInterface*)impl3;
sl@0	1347	impl3=NULL;
sl@0	1348	::LeaveIfErrNoMemory(err);
sl@0	1349	}
sl@0	1350	TEST2(err,KErrNone);
sl@0	1351
sl@0	1352	//Checking the state of the arrays inside CLoadManager and the garbage policy
sl@0	1353	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 3);
sl@0	1354	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 2);
sl@0	1355	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	1356
sl@0	1357	//Destroy Implementation 1
sl@0	1358	iLoadManager->DestroyedThis(instanceKey1);
sl@0	1359	delete (CExampleInterface*)impl1;
sl@0	1360	impl1 = NULL;
sl@0	1361
sl@0	1362	//Destroy Implementation 2
sl@0	1363	iLoadManager->DestroyedThis(instanceKey2);
sl@0	1364	delete (CExampleInterface*)impl2;
sl@0	1365	impl2 = NULL;
sl@0	1366
sl@0	1367	//Destroy Implementation 3
sl@0	1368	iLoadManager->DestroyedThis(instanceKey3);
sl@0	1369	delete (CExampleInterface*)impl3;
sl@0	1370	impl3 = NULL;
sl@0	1371
sl@0	1372	//Checking the state of the arrays inside CLoadManager and the garbage policy
sl@0	1373	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0);
sl@0	1374	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0);
sl@0	1375	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL);
sl@0	1376
sl@0	1377	iLoadManager->ClearGarbage();
sl@0	1378
sl@0	1379	//Checking the final state of the garbage policy
sl@0	1380	//Test for the new API ClearGarbage()
sl@0	1381	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	1382
sl@0	1383	}
sl@0	1384
sl@0	1385	/**
sl@0	1386	Plugins used:
sl@0	1387	- Z:\\..\\EComLoadMgrExample1.dll contains ImplUid 0x10282332 & 0x10282334
sl@0	1388	- Z:\\..\\EComLoadMgrExample2.dll contains ImplUid 0x10282333
sl@0	1389
sl@0	1390	@SYMTestCaseID SYSLIB-ECOM-UT-3372
sl@0	1391	@SYMTestCaseDesc This testcase checks for the case where 2 implementations
sl@0	1392	are created each on separate DLL's then an additional
sl@0	1393	implementation is created from one of the already loaded DLL's.
sl@0	1394	The impl uid of the newly created impl is lower then the 2
sl@0	1395	existing impl uids. The impl uids from the same DLL are such
sl@0	1396	that 1 is higher then the uid of the other impl and 1 is lower than
sl@0	1397	the other impl.
sl@0	1398	@SYMTestPriority High
sl@0	1399	@SYMTestActions Load impls 0x10282333 and 0x10282334 first and then load impl
sl@0	1400	0x10282332.
sl@0	1401	@SYMTestExpectedResults Leave with KErrNotFound must not occur.
sl@0	1402	Policy and unload policy counts must be updated
sl@0	1403	as described in the test.
sl@0	1404	@SYMDEF DEF101930
sl@0	1405	*/
sl@0	1406	void CLoadManagerTest::CreateDestroyTestCase5Plugin1L()
sl@0	1407	{
sl@0	1408	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3372 "));
sl@0	1409	TUid implUid1={0x10282332};
sl@0	1410	TUid implUid2={0x10282334};
sl@0	1411	TUid implUid3={0x10282333};
sl@0	1412
sl@0	1413	TUid dllUidExample1;
sl@0	1414	dllUidExample1.iUid = 0x10282330;
sl@0	1415
sl@0	1416	TUid dllUidExample2;
sl@0	1417	dllUidExample2.iUid = 0x10282335;
sl@0	1418
sl@0	1419	CreateDestroyTestCase5L(dllUidExample1,
sl@0	1420	implUid1,
sl@0	1421	KLoadMgrExample1DllName,
sl@0	1422	dllUidExample2,
sl@0	1423	implUid2,
sl@0	1424	KLoadMgrExample2DllName,
sl@0	1425	implUid3,
sl@0	1426	KUidInterfaceImplementationCollection);
sl@0	1427	}
sl@0	1428
sl@0	1429	/**
sl@0	1430	@SYMTestCaseID SYSLIB-ECOM-UT-3556
sl@0	1431	@SYMTestCaseDesc DEF101930: Incorrect policy object returned in
sl@0	1432	This testcase checks for the case where 2 implementations
sl@0	1433	are created each on separate DLL's then an additional
sl@0	1434	implementation is created from one of the already loaded DLL's.
sl@0	1435	The impl uid of the newly created impl is lower then the 2
sl@0	1436	existing impl uids. The impl uids from the same DLL are such
sl@0	1437	that 1 is higher then the uid of the other impl and 1 is lower than
sl@0	1438	the other impl. DEF101930: Incorrect policy object returned in
sl@0	1439
sl@0	1440	Plugins used:
sl@0	1441	- Z:\\..\\EComExample10.dll contains ImplUid 0x10009E38 & 0x10009E3A
sl@0	1442	- Z:\\..\\EComExample12.dll contains ImplUid 0x10009E39
sl@0	1443	@SYMTestPriority High
sl@0	1444	@SYMTestActions Load impls 0x10009E3A and 0x10009E39 first and then load impl 0x10009E38.
sl@0	1445	@SYMTestExpectedResults Leave with KErrNotFound must not occur.
sl@0	1446	Policy and unload policy counts must be updated
sl@0	1447	as described in the test.
sl@0	1448	@SYMEC EC43 (tested for PLUGIN3 too now, copied from UT-3372)
sl@0	1449	*/
sl@0	1450	void CLoadManagerTest::CreateDestroyTestCase5Plugin3L()
sl@0	1451	{
sl@0	1452	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3556 "));
sl@0	1453	TUid implUid1={0x10009E38};
sl@0	1454	TUid implUid2={0x10009E3A};
sl@0	1455	TUid implUid3={0x10009E39};
sl@0	1456
sl@0	1457	TUid dllUidExample1;
sl@0	1458	dllUidExample1.iUid = 0x10009E37;
sl@0	1459
sl@0	1460	TUid dllUidExample2;
sl@0	1461	dllUidExample2.iUid = 0x10009E3E;
sl@0	1462
sl@0	1463	CreateDestroyTestCase5L(dllUidExample1,
sl@0	1464	implUid1,
sl@0	1465	KExampleDllFileName10,
sl@0	1466	dllUidExample2,
sl@0	1467	implUid2,
sl@0	1468	KExampleDllFileName12,
sl@0	1469	implUid3,
sl@0	1470	KUidInterfaceImplementationCollection3);
sl@0	1471	}
sl@0	1472
sl@0	1473
sl@0	1474	/**
sl@0	1475	@SYMTestCaseID SYSLIB-ECOM-CT-0705
sl@0	1476	@SYMTestCaseDesc Tests for production class CLoadManager
sl@0	1477	@SYMTestPriority High
sl@0	1478	@SYMTestActions Check for null condition while creating a new CLoadManagerTest object.
sl@0	1479	@SYMTestExpectedResults The test must not fail.
sl@0	1480	@SYMREQ REQ0000
sl@0	1481	*/
sl@0	1482	LOCAL_C void CreateDeleteTestL()
sl@0	1483	{
sl@0	1484	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0705 CreateDeleteTestL "));
sl@0	1485
sl@0	1486	//
sl@0	1487	// Tests the Creating and deletion of CLoadManager
sl@0	1488	// ------------------------------------------------------------------
sl@0	1489	//
sl@0	1490	// Set up for heap leak checking
sl@0	1491	__UHEAP_MARK;
sl@0	1492
sl@0	1493	TInt startProcessHandleCount = 0;
sl@0	1494	TInt startThreadHandleCount = 0;
sl@0	1495	TInt endProcessHandleCount = 0;
sl@0	1496	TInt endThreadHandleCount = 0;
sl@0	1497
sl@0	1498	RThread rThread;
sl@0	1499	rThread.HandleCount(startProcessHandleCount, startThreadHandleCount);
sl@0	1500
sl@0	1501	//CREATE DELETE TEST START//
sl@0	1502
sl@0	1503	CLoadManagerTest* loadManagerTest = CLoadManagerTest::NewL();
sl@0	1504
sl@0	1505	TEST(loadManagerTest != NULL);
sl@0	1506
sl@0	1507	delete loadManagerTest;
sl@0	1508
sl@0	1509	//CREATE DELETE TEST END//
sl@0	1510
sl@0	1511	rThread.HandleCount(endProcessHandleCount, endThreadHandleCount);
sl@0	1512	TEST(startThreadHandleCount == endThreadHandleCount);
sl@0	1513
sl@0	1514	__UHEAP_MARKEND;
sl@0	1515	}
sl@0	1516
sl@0	1517	/**
sl@0	1518	@SYMTestCaseID SYSLIB-ECOM-CT-0706
sl@0	1519	@SYMTestCaseDesc OOM test while creating and deleting CLoadManager
sl@0	1520	@SYMTestPriority High
sl@0	1521	@SYMTestActions Create and delete CLoadManager object and test that no handles have leaked
sl@0	1522	@SYMTestExpectedResults The test must not fail.
sl@0	1523	@SYMREQ REQ0000
sl@0	1524	*/
sl@0	1525	LOCAL_C void OOMCreateDeleteTest()
sl@0	1526	{
sl@0	1527	//
sl@0	1528	// Out of memory test
sl@0	1529	// ------------------------------------------------------------------
sl@0	1530	//
sl@0	1531	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0706 OOMCreateDeleteTest "));
sl@0	1532	TInt err;
sl@0	1533	TInt failAt = 1;
sl@0	1534	__UNUSED_VAR(failAt);
sl@0	1535
sl@0	1536	CLoadManagerTest* loadManagerTest = NULL;
sl@0	1537
sl@0	1538	do
sl@0	1539	{
sl@0	1540	__UHEAP_MARK;
sl@0	1541	// find out the number of open handles
sl@0	1542	TInt startProcessHandleCount;
sl@0	1543	TInt startThreadHandleCount;
sl@0	1544	RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
sl@0	1545
sl@0	1546	// Setting Heap failure for OOM test
sl@0	1547	__UHEAP_SETFAIL(RHeap::EDeterministic, failAt++);
sl@0	1548
sl@0	1549	TRAP(err, loadManagerTest = CLoadManagerTest::NewL());
sl@0	1550
sl@0	1551	__UHEAP_SETFAIL(RHeap::ENone, 0);
sl@0	1552
sl@0	1553	delete loadManagerTest;
sl@0	1554	loadManagerTest = NULL;
sl@0	1555
sl@0	1556	// check that no handles have leaked
sl@0	1557	TInt endProcessHandleCount;
sl@0	1558	TInt endThreadHandleCount;
sl@0	1559	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
sl@0	1560
sl@0	1561	TEST(startProcessHandleCount == endProcessHandleCount);
sl@0	1562	TEST(startThreadHandleCount == endThreadHandleCount);
sl@0	1563
sl@0	1564	__UHEAP_MARKEND;
sl@0	1565	}
sl@0	1566	while (err == KErrNoMemory);
sl@0	1567
sl@0	1568	TheTest.Printf(_L("- Succeeded at heap failure rate of %i\n"), failAt);
sl@0	1569	TEST(err == KErrNone);
sl@0	1570	}
sl@0	1571
sl@0	1572	/**
sl@0	1573	@SYMTestCaseID SYSLIB-ECOM-UT-3557
sl@0	1574	@SYMTestCaseDesc This testcase tests fetching extended interfaces for ImplUid 0x10009E38.
sl@0	1575	One interface will be the part of the main implementation object, the
sl@0	1576	second interface will be a separate interface requiring release. Also tests
sl@0	1577	that the extended interfaces are automatically destroyed.
sl@0	1578
sl@0	1579	Plugins used:
sl@0	1580	- Z:\\..\\EComExample10.dll contains ImplUid 0x10009E38 with extended interface
sl@0	1581	0x10009E44, 0x10009E45 and 0x10009E46
sl@0	1582	@SYMTestPriority High
sl@0	1583	@SYMTestActions This testcase will test one implementation with two extended interfaces.
sl@0	1584	Create implementation, then fetch extended interface 0x10009E44. Secondly,
sl@0	1585	fetch 0x10009E45 interface. This will be a separate interface requiring release.
sl@0	1586	Destroy the interfaces.
sl@0	1587	Attempt fetch of interface again. Expect Leave with KErrNotFound as implementation
sl@0	1588	no longer exists.
sl@0	1589	@SYMTestExpectedResults Extended instance count will be zero for 0x10009E44 extended interface,
sl@0	1590	0x10009E45 will have an extended instance count of one. No memory leaks
sl@0	1591	after implementation, including extended interfaces are automatically
sl@0	1592	destroyed.
sl@0	1593	@SYMEC EC43
sl@0	1594	@SYMDEF DEF111553
sl@0	1595	*/
sl@0	1596	void CLoadManagerTest::ExtendedMethodTest1Plugin3L()
sl@0	1597	{
sl@0	1598	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3557 "));
sl@0	1599	CExampleInterface::TExampleInterfaceInitParams iInitParams;
sl@0	1600	iInitParams.integer = 5;
sl@0	1601	TBool initParamsFlag = ETrue;
sl@0	1602	_LIT(KDummyText,"Dummy params");
sl@0	1603	iInitParams.descriptor = &KDummyText;
sl@0	1604	TUid dllUid;
sl@0	1605	dllUid.iUid = 0x10009E37;
sl@0	1606
sl@0	1607	TEntry entry;
sl@0	1608	entry.iName = KExampleDllFileName10;
sl@0	1609	entry.iModified = TTime(0);
sl@0	1610	entry.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid);
sl@0	1611
sl@0	1612	iImplementationUid.iUid = 0x10009E38;
sl@0	1613
sl@0	1614	CExampleInterface* implementationPtr = 0;
sl@0	1615	TUid instanceKey;
sl@0	1616	TRAPD(err, implementationPtr = reinterpret_cast<CExampleInterface*>(iLoadManager->ImplementationObjectL(iImplementationUid, entry,&iInitParams, initParamsFlag,instanceKey)));
sl@0	1617
sl@0	1618	::LeaveIfErrNoMemory(err);
sl@0	1619	TEST2(err,KErrNone);
sl@0	1620	TEST(implementationPtr != 0);
sl@0	1621
sl@0	1622	CleanupStack::PushL(implementationPtr);
sl@0	1623
sl@0	1624	//Checks the state of the arrays inside CLoadManager and garbage policy
sl@0	1625	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1);
sl@0	1626	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
sl@0	1627	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	1628
sl@0	1629	//Checks the instance index and UnloadPolicy info
sl@0	1630	TEST(iStateAccessor.InstanceIndex(0,*iLoadManager)->ImplementationUid() == iImplementationUid);
sl@0	1631	TEST(iStateAccessor.UnloadPolicy(0,*iLoadManager)->DllEntryInformation().GetName().CompareF(KExampleDllFileName10) == 0);
sl@0	1632
sl@0	1633	// Call extended interface here.
sl@0	1634	const TUid KExample10InterfaceUid1 = {0x10009E44}; // Part of main interface
sl@0	1635	const TUid KExample10InterfaceUid2 = {0x10009E45}; // Separate interface
sl@0	1636
sl@0	1637	MExampleInterfaceExtended* ext1 = static_cast<MExampleInterfaceExtended*>(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid1 ));
sl@0	1638	// Extended interface part of main interface, so no extended object info is needed to be created.
sl@0	1639	TEST2(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager),0);
sl@0	1640	ext1->DoMethodExtended();
sl@0	1641
sl@0	1642	MExampleInterfaceExtended2* ext2 = static_cast<MExampleInterfaceExtended2*>(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid2 ));
sl@0	1643	// Separate extended interface, so there will be an extended object info created to track
sl@0	1644	// this extended interface so it can be deleted later when the extended interface is no
sl@0	1645	// longer needed.
sl@0	1646	TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager)==1);
sl@0	1647	ext2->DoMethodExtended2();
sl@0	1648
sl@0	1649	CleanupStack::PopAndDestroy(implementationPtr);
sl@0	1650	implementationPtr = 0;
sl@0	1651	iLoadManager->DestroyedThis(instanceKey);
sl@0	1652	iLoadManager->ClearGarbage();
sl@0	1653	//Checks the state of the arrays inside CLoadManager and garbage policy
sl@0	1654	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0);
sl@0	1655	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0);
sl@0	1656	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	1657
sl@0	1658	// call again now that implementation has been removed. Expecting a Leave
sl@0	1659	TRAP(err, iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid2 ));
sl@0	1660	TEST2(err, KErrNotFound);
sl@0	1661	}
sl@0	1662
sl@0	1663	/**
sl@0	1664	@SYMTestCaseID SYSLIB-ECOM-UT-3558
sl@0	1665	@SYMTestCaseDesc This testcase tests fetching extended interfaces for ImplUid 0x10009E38.
sl@0	1666	One interface will be the part of the main implementation object, the
sl@0	1667	second interface will be a separate interface requiring release. Tests
sl@0	1668	that manual release successful for interface requiring release. Tests
sl@0	1669	no memory leaks, and no double release of manually released interface.
sl@0	1670
sl@0	1671	Plugins used:
sl@0	1672	- Z:\\..\\EComExample10.dll contains ImplUid 0x10009E38 with extended interface
sl@0	1673	0x10009E44, 0x10009E45 and 0x10009E46
sl@0	1674	@SYMTestPriority High
sl@0	1675	@SYMTestActions This testcase will test one implementation with two extended interfaces.
sl@0	1676	Create implementation, then fetch extended interface 0x10009E44. Secondly,
sl@0	1677	fetch 0x10009E45 interface. This will be a separate interface requiring release.
sl@0	1678	Manually release extended interface. Destroy the interfaces.
sl@0	1679	Attempt fetch of interface again. Expect Leave with KErrNotFound as implementation
sl@0	1680	no longer exists.
sl@0	1681	@SYMTestExpectedResults Extended instance count will be zero for 0x10009E44 extended interface,
sl@0	1682	0x10009E45 will have an extended instance count of one. After manual
sl@0	1683	release, the extended interface count will be zero. No memory leaks after
sl@0	1684	implementation, including extended interfaces are automatically destroyed.
sl@0	1685	No double release of extended interface already manually released.
sl@0	1686	@SYMEC EC43
sl@0	1687	@SYMDEF DEF111553
sl@0	1688	*/
sl@0	1689	void CLoadManagerTest::ExtendedMethodTest2Plugin3L()
sl@0	1690	{
sl@0	1691	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3558 "));
sl@0	1692	CExampleInterface::TExampleInterfaceInitParams iInitParams;
sl@0	1693	iInitParams.integer = 5;
sl@0	1694	TBool initParamsFlag = ETrue;
sl@0	1695	_LIT(KDummyText,"Dummy params");
sl@0	1696	iInitParams.descriptor = &KDummyText;
sl@0	1697	TUid dllUid;
sl@0	1698	dllUid.iUid = 0x10009E37;
sl@0	1699
sl@0	1700	TEntry entry;
sl@0	1701	entry.iName = KExampleDllFileName10;
sl@0	1702	entry.iModified = TTime(0);
sl@0	1703	entry.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid);
sl@0	1704
sl@0	1705	iImplementationUid.iUid = 0x10009E38;
sl@0	1706
sl@0	1707	CExampleInterface* implementationPtr = 0;
sl@0	1708	TUid instanceKey;
sl@0	1709	TRAPD(err, implementationPtr = reinterpret_cast<CExampleInterface*>(iLoadManager->ImplementationObjectL(iImplementationUid, entry,&iInitParams, initParamsFlag,instanceKey)));
sl@0	1710
sl@0	1711	::LeaveIfErrNoMemory(err);
sl@0	1712	TEST2(err,KErrNone);
sl@0	1713	TEST(implementationPtr != 0);
sl@0	1714
sl@0	1715	CleanupStack::PushL(implementationPtr);
sl@0	1716
sl@0	1717	//Checks the state of the arrays inside CLoadManager and garbage policy
sl@0	1718	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1);
sl@0	1719	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
sl@0	1720	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	1721
sl@0	1722	//Checks the instance index and UnloadPolicy info
sl@0	1723	TEST(iStateAccessor.InstanceIndex(0,*iLoadManager)->ImplementationUid() == iImplementationUid);
sl@0	1724	TEST(iStateAccessor.UnloadPolicy(0,*iLoadManager)->DllEntryInformation().GetName().CompareF(KExampleDllFileName10) == 0);
sl@0	1725
sl@0	1726	// Call extended interface here.
sl@0	1727	const TUid KExample10InterfaceUid1 = {0x10009E44};
sl@0	1728	const TUid KExample10InterfaceUid2 = {0x10009E45}; // separate interface object
sl@0	1729
sl@0	1730	MExampleInterfaceExtended* ext1 = static_cast<MExampleInterfaceExtended*>(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid1 ));
sl@0	1731	TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 0); // Does not need to be released, so will not be added to extended object array
sl@0	1732	ext1->DoMethodExtended();
sl@0	1733
sl@0	1734	MExampleInterfaceExtended2* ext2 = static_cast<MExampleInterfaceExtended2*>(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid2 ));
sl@0	1735	TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 1); // Needs to be released
sl@0	1736	ext2->DoMethodExtended2();
sl@0	1737
sl@0	1738	iLoadManager->ManuallyReleaseExtendedInterfaceL(instanceKey, KExample10InterfaceUid2);
sl@0	1739	TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 0);
sl@0	1740
sl@0	1741	CleanupStack::PopAndDestroy(implementationPtr);
sl@0	1742	implementationPtr = 0;
sl@0	1743	iLoadManager->DestroyedThis(instanceKey);
sl@0	1744	iLoadManager->ClearGarbage();
sl@0	1745	//Checks the state of the arrays inside CLoadManager and garbage policy
sl@0	1746	TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0);
sl@0	1747	TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0);
sl@0	1748	TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
sl@0	1749
sl@0	1750	// call again now that implementation has been removed. Expecting a Leave
sl@0	1751	TRAP(err, iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid2 ));
sl@0	1752	TEST2(err, KErrNotFound);
sl@0	1753	}
sl@0	1754
sl@0	1755	/**
sl@0	1756	@SYMTestCaseID SYSLIB-ECOM-UT-3711
sl@0	1757	@SYMTestCaseDesc This testcase tests ManuallyReleaseExtendedInterfaces function for releasing
sl@0	1758	extended interface which require release and releasing extended interface
sl@0	1759	which doesn't require release. Also tests for releasing same extended interface twice
sl@0	1760
sl@0	1761	Plugins used:
sl@0	1762	- Z:\\..\\EComExample10.dll contains ImplUid 0x10009E38 with extended interface
sl@0	1763	0x10009E44, 0x10009E45 and 0x10009E46
sl@0	1764	@SYMTestPriority High
sl@0	1765	@SYMTestActions This testcase will do the tests as below:
sl@0	1766	1. create implementation 0x10009E38.
sl@0	1767	2. Get extended interface 0x10009E44,0x10009E45 and 0x10009E46.
sl@0	1768	3. Manually release extended interface 0x10009E44 which does not require release.
sl@0	1769	4. Manually release extended interface 0x10009E45 which require manually release.
sl@0	1770	5. Again manually release extended interface 0x10009E45 which require manually release.
sl@0	1771	6. Manually release extended interface 0x10009E46 which require manually release.
sl@0	1772	7. Destroy the interfaces
sl@0	1773	8. Attempt fetch manual release again. Expect Leave with KErrNotFound as implementation
sl@0	1774	no longer exists.
sl@0	1775	@SYMTestExpectedResults Extended instance count is set correctly.
sl@0	1776	@SYMDEF DEF111196
sl@0	1777	@SYMDEF DEF111553
sl@0	1778	*/
sl@0	1779	void CLoadManagerTest::ManuallyReleaseExtendedInterfaceTestL()
sl@0	1780	{
sl@0	1781	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3711 "));
sl@0	1782	CExampleInterface::TExampleInterfaceInitParams iInitParams;
sl@0	1783	iInitParams.integer = 5;
sl@0	1784	TBool initParamsFlag = ETrue;
sl@0	1785	_LIT(KDummyText,"Dummy params");
sl@0	1786	iInitParams.descriptor = &KDummyText;
sl@0	1787	TUid dllUid;
sl@0	1788	dllUid.iUid = 0x10009E37;
sl@0	1789
sl@0	1790	TEntry entry;
sl@0	1791	entry.iName = KExampleDllFileName10;
sl@0	1792	entry.iModified = TTime(0);
sl@0	1793	entry.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid);
sl@0	1794
sl@0	1795	iImplementationUid.iUid = 0x10009E38;
sl@0	1796
sl@0	1797	CExampleInterface* implementationPtr = 0;
sl@0	1798	TUid instanceKey;
sl@0	1799	TRAPD(err, implementationPtr = reinterpret_cast<CExampleInterface*>(iLoadManager->ImplementationObjectL(iImplementationUid, entry,&iInitParams, initParamsFlag,instanceKey)));
sl@0	1800
sl@0	1801	::LeaveIfErrNoMemory(err);
sl@0	1802	TEST2(err,KErrNone);
sl@0	1803	TEST(implementationPtr != 0);
sl@0	1804
sl@0	1805	CleanupStack::PushL(implementationPtr);
sl@0	1806
sl@0	1807	const TUid KExample10InterfaceUid1 = {0x10009E44};
sl@0	1808	const TUid KExample10InterfaceUid2 = {0x10009E45}; // separate interface object
sl@0	1809	const TUid KExample10InterfaceUid3 = {0x10009E46}; // separate interface object
sl@0	1810
sl@0	1811	// Gets extended interface 0x10009E44
sl@0	1812	MExampleInterfaceExtended* ext1 = static_cast<MExampleInterfaceExtended*>(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid1 ));
sl@0	1813	TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 0); // Does not need to be released, so will not be added to extended object array
sl@0	1814
sl@0	1815	// Gets extended interface 0x10009E45
sl@0	1816	MExampleInterfaceExtended2* ext2 = static_cast<MExampleInterfaceExtended2*>(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid2 ));
sl@0	1817	TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 1); // Needs to be released
sl@0	1818
sl@0	1819	// Gets extended interface 0x10009E46
sl@0	1820	MExampleInterfaceExtended2* ext3 = static_cast<MExampleInterfaceExtended2*>(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid3 ));
sl@0	1821	TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 2); // Needs to be released
sl@0	1822
sl@0	1823	// call ManuallyReleaseExtendedInterface for 0x10009E44.
sl@0	1824	// Nothing would happen because 0x10009E44 is not require release.
sl@0	1825	iLoadManager->ManuallyReleaseExtendedInterfaceL(instanceKey, KExample10InterfaceUid1);
sl@0	1826	TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 2);
sl@0	1827
sl@0	1828	// call ManuallyReleaseExtendedInterface for 0x10009E45.
sl@0	1829	// extended instance count would be 1
sl@0	1830	iLoadManager->ManuallyReleaseExtendedInterfaceL(instanceKey, KExample10InterfaceUid2);
sl@0	1831	TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 1);
sl@0	1832
sl@0	1833	// call ManuallyReleaseExtendedInterface again, nothing would happen because 0x10009E45 has been released.
sl@0	1834	iLoadManager->ManuallyReleaseExtendedInterfaceL(instanceKey, KExample10InterfaceUid2);
sl@0	1835	TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 1);
sl@0	1836
sl@0	1837	// call ManuallyReleaseExtendedInterface for 0x10009E46.
sl@0	1838	// extended instance count would be 0
sl@0	1839	iLoadManager->ManuallyReleaseExtendedInterfaceL(instanceKey, KExample10InterfaceUid3);
sl@0	1840	TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 0);
sl@0	1841
sl@0	1842	CleanupStack::PopAndDestroy(implementationPtr);
sl@0	1843	implementationPtr = 0;
sl@0	1844	iLoadManager->DestroyedThis(instanceKey);
sl@0	1845	iLoadManager->ClearGarbage();
sl@0	1846
sl@0	1847	// call again now that implementation has been removed. Expecting a Leave
sl@0	1848	TRAP(err, iLoadManager->ManuallyReleaseExtendedInterfaceL(instanceKey, KExample10InterfaceUid3 ));
sl@0	1849	TEST2(err, KErrNotFound);
sl@0	1850	}
sl@0	1851
sl@0	1852
sl@0	1853
sl@0	1854	typedef void (CLoadManagerTest::*ClassFuncPtrL) (void);
sl@0	1855
sl@0	1856	/**
sl@0	1857	@SYMTestCaseID SYSLIB-ECOM-CT-0707
sl@0	1858	@SYMTestCaseDesc Wrapper function to call all test functions
sl@0	1859	@SYMTestPriority High
sl@0	1860	@SYMTestActions Calls up CLoadManagerTest's test function.
sl@0	1861	@SYMTestExpectedResults The test must not fail.
sl@0	1862	@SYMREQ REQ0000
sl@0	1863	*/
sl@0	1864	/**
sl@0	1865	Wrapper function to call all test functions
sl@0	1866
sl@0	1867	@param testFuncL pointer to test function
sl@0	1868	@param aTestDesc test function name
sl@0	1869	*/
sl@0	1870	LOCAL_C void DoBasicTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc)
sl@0	1871	{
sl@0	1872	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0707 "));
sl@0	1873	TheTest.Next(aTestDesc);
sl@0	1874
sl@0	1875	__UHEAP_MARK;
sl@0	1876	// find out the number of open handles
sl@0	1877	TInt startProcessHandleCount;
sl@0	1878	TInt startThreadHandleCount;
sl@0	1879	RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
sl@0	1880
sl@0	1881	CLoadManagerTest* loadManagerTest = CLoadManagerTest::NewL();
sl@0	1882	CleanupStack::PushL(loadManagerTest);
sl@0	1883
sl@0	1884	(loadManagerTest->*testFuncL)();
sl@0	1885
sl@0	1886	CleanupStack::PopAndDestroy(loadManagerTest);
sl@0	1887
sl@0	1888	// check that no handles have leaked
sl@0	1889	TInt endProcessHandleCount;
sl@0	1890	TInt endThreadHandleCount;
sl@0	1891	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
sl@0	1892
sl@0	1893	TEST(startProcessHandleCount == endProcessHandleCount);
sl@0	1894	TEST(startThreadHandleCount == endThreadHandleCount);
sl@0	1895
sl@0	1896	__UHEAP_MARKEND;
sl@0	1897	}
sl@0	1898
sl@0	1899	/**
sl@0	1900	@SYMTestCaseID SYSLIB-ECOM-CT-0708
sl@0	1901	@SYMTestCaseDesc Function to call all OOM test functions
sl@0	1902	@SYMTestPriority High
sl@0	1903	@SYMTestActions Calls up all test functions for OOM test.
sl@0	1904	@SYMTestExpectedResults The test must not fail.
sl@0	1905	@SYMREQ REQ0000
sl@0	1906	*/
sl@0	1907	/**
sl@0	1908	Wrapper function to call all OOM test functions
sl@0	1909
sl@0	1910	@param testFuncL pointer to OOM test function
sl@0	1911	@param aTestDesc test function name
sl@0	1912	*/
sl@0	1913	LOCAL_C void DoOOMTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc)
sl@0	1914	{
sl@0	1915	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0708 "));
sl@0	1916	TheTest.Next(aTestDesc);
sl@0	1917
sl@0	1918	TInt err, tryCount = 0;
sl@0	1919	do
sl@0	1920	{
sl@0	1921	__UHEAP_MARK;
sl@0	1922	// find out the number of open handles
sl@0	1923	TInt startProcessHandleCount;
sl@0	1924	TInt startThreadHandleCount;
sl@0	1925	RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
sl@0	1926
sl@0	1927	CLoadManagerTest* loadManagerTest = CLoadManagerTest::NewL();
sl@0	1928	CleanupStack::PushL(loadManagerTest);
sl@0	1929
sl@0	1930	// Setting Heap failure for OOM test
sl@0	1931	__UHEAP_SETFAIL(RHeap::EDeterministic, ++tryCount);
sl@0	1932
sl@0	1933	TRAP(err, (loadManagerTest->*testFuncL)());
sl@0	1934
sl@0	1935	__UHEAP_SETFAIL(RHeap::ENone, 0);
sl@0	1936
sl@0	1937	CleanupStack::PopAndDestroy(loadManagerTest);
sl@0	1938	loadManagerTest = NULL;
sl@0	1939
sl@0	1940	// check that no handles have leaked
sl@0	1941	TInt endProcessHandleCount;
sl@0	1942	TInt endThreadHandleCount;
sl@0	1943	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
sl@0	1944
sl@0	1945	TEST(startProcessHandleCount == endProcessHandleCount);
sl@0	1946	TEST(startThreadHandleCount == endThreadHandleCount);
sl@0	1947
sl@0	1948	__UHEAP_MARKEND;
sl@0	1949	} while(err == KErrNoMemory);
sl@0	1950
sl@0	1951	TEST(err == KErrNone);
sl@0	1952	TheTest.Printf(_L("- server succeeded at heap failure rate of %i\n"), tryCount);
sl@0	1953	}
sl@0	1954
sl@0	1955	void DoTestL()
sl@0	1956	{
sl@0	1957	__UHEAP_MARK;
sl@0	1958
sl@0	1959	// Basic tests
sl@0	1960	CreateDeleteTestL();
sl@0	1961	DoBasicTestL(&CLoadManagerTest::InstantiationMethodTestPlugin1L, _L("InstantiationMethodTestPlugin1L"));
sl@0	1962	DoBasicTestL(&CLoadManagerTest::DestroyThisTestPlugin1L, _L("DestroyThisTestPlugin1L"));
sl@0	1963	DoBasicTestL(&CLoadManagerTest::GetImplementationUidTestL, _L("GetImplementationUidTestL"));
sl@0	1964	DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase1Plugin1L,_L("Create Destroy Test case 1"));
sl@0	1965	DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase2Plugin1L,_L("Create Destroy Test case 2"));
sl@0	1966	DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase3L,_L("Create Destroy Test case 3"));
sl@0	1967	DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase4Plugin1L,_L("Create Destroy Test case 4"));
sl@0	1968	DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase5Plugin1L,_L("Create Destroy Test case 5"));
sl@0	1969
sl@0	1970	DoBasicTestL(&CLoadManagerTest::InstantiationMethodTestPlugin3L, _L("InstantiationMethodTest3L"));
sl@0	1971	DoBasicTestL(&CLoadManagerTest::DestroyThisTestPlugin3L, _L("DestroyThisTest3L"));
sl@0	1972	DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase1Plugin3L,_L("Create Destroy Test case 1,Plugin3"));
sl@0	1973	DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase2Plugin3L,_L("Create Destroy Test case 2"));
sl@0	1974	DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase3Plugin3L,_L("Create Destroy Test case 3"));
sl@0	1975	DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase4Plugin3L,_L("Create Destroy Test case 4"));
sl@0	1976	DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase5Plugin3L,_L("Create Destroy Test case 5"));
sl@0	1977
sl@0	1978	//Create an implementation from a PLUGIN dll and one from a PLUGIN3 dll also.
sl@0	1979	DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase1PluginAndPlugin3L,_L("CreateDestroyTestCase1PluginAndPlugin3L"));
sl@0	1980
sl@0	1981	// Get and Release extended interfaces
sl@0	1982	DoBasicTestL(&CLoadManagerTest::ExtendedMethodTest1Plugin3L,_L("ExtendedMethodTest1Plugin3L"));
sl@0	1983	DoBasicTestL(&CLoadManagerTest::ExtendedMethodTest2Plugin3L,_L("ExtendedMethodTest2Plugin3L"));
sl@0	1984	DoBasicTestL(&CLoadManagerTest::ManuallyReleaseExtendedInterfaceTestL,_L("ManuallyReleaseExtendedInterfaceTestL"));
sl@0	1985
sl@0	1986	DoBasicTestL(&CLoadManagerTest::ImplementationObjectTestL,_L("ImplementationObjectTestL"));
sl@0	1987
sl@0	1988
sl@0	1989	OOMCreateDeleteTest();
sl@0	1990
sl@0	1991	DoOOMTestL(&CLoadManagerTest::InstantiationMethodTestPlugin1L, _L("OOM InstantiationMethodTestPlugin1L"));
sl@0	1992	DoOOMTestL(&CLoadManagerTest::DestroyThisTestPlugin1L, _L("OOM DestroyThisTestPlugin1L"));
sl@0	1993	DoOOMTestL(&CLoadManagerTest::GetImplementationUidTestL, _L("OOM GetImplementationUidTestL"));
sl@0	1994	DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase1Plugin1L,_L("OOM Create Destroy Test case 1"));
sl@0	1995	DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase2Plugin1L,_L("OOM Create Destroy Test case 2"));
sl@0	1996	DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase3L,_L("OOM Create Destroy Test case 3"));
sl@0	1997	DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase4Plugin1L,_L("OOM Create Destroy Test case 4"));
sl@0	1998	DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase5Plugin1L,_L("OOM Create Destroy Test case 5"));
sl@0	1999
sl@0	2000	DoOOMTestL(&CLoadManagerTest::InstantiationMethodTestPlugin3L, _L("OOM InstantiationMethodTest3L"));
sl@0	2001	DoOOMTestL(&CLoadManagerTest::DestroyThisTestPlugin3L, _L("OOM DestroyThisTest3L"));
sl@0	2002	DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase1Plugin3L,_L("OOM Create Destroy Test case 1,Plugin3"));
sl@0	2003	DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase2Plugin3L,_L("OOM Create Destroy Test case 2"));
sl@0	2004	DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase3Plugin3L,_L("OOM Create Destroy Test case 3"));
sl@0	2005	DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase4Plugin3L,_L("OOM Create Destroy Test case 4"));
sl@0	2006	DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase5Plugin3L,_L("OOM Create Destroy Test case 5"));
sl@0	2007
sl@0	2008	//Create an implementation from a PLUGIN dll and one from a PLUGIN3 dll also.
sl@0	2009	DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase1PluginAndPlugin3L,_L("OOM CreateDestroyTestCase1PluginAndPlugin3L"));
sl@0	2010
sl@0	2011	// Get and Release extended interfaces
sl@0	2012	DoOOMTestL(&CLoadManagerTest::ExtendedMethodTest1Plugin3L,_L("OOM ExtendedMethodTest1Plugin3L"));
sl@0	2013	DoOOMTestL(&CLoadManagerTest::ExtendedMethodTest2Plugin3L,_L("OOM ExtendedMethodTest2Plugin3L"));
sl@0	2014	DoOOMTestL(&CLoadManagerTest::ManuallyReleaseExtendedInterfaceTestL,_L("OOM ManuallyReleaseExtendedInterfaceTestL"));
sl@0	2015
sl@0	2016	__UHEAP_MARKEND;
sl@0	2017	}
sl@0	2018
sl@0	2019	//Leave if aError < 0 with info message printed out
sl@0	2020	LOCAL_C void LeaveIfError(TInt aError, TInt aLine)
sl@0	2021	{
sl@0	2022	if(aError < KErrNone)
sl@0	2023	{
sl@0	2024	::Leave(aError, aLine);
sl@0	2025	}
sl@0	2026	}
sl@0	2027
sl@0	2028	#define LEAVE_IF_ERROR(aError) ::LeaveIfError(aError, __LINE__)
sl@0	2029	//
sl@0	2030	// Copies the Plugins to specific folder for testing purpose
sl@0	2031	//
sl@0	2032	LOCAL_C void CopyPlugins()
sl@0	2033	{
sl@0	2034	// Connect the file server instance
sl@0	2035	LEAVE_IF_ERROR(TheFs.Connect());
sl@0	2036
sl@0	2037	TRAPD(err, EComTestUtils::FileManCopyFileL(KResourceFileName5OnZ, KResourceFileName5));
sl@0	2038	TEST(err==KErrNone);
sl@0	2039
sl@0	2040	TRAP(err, EComTestUtils::FileManCopyFileL(KExampleDllFileName5OnZ, KExampleDllFileName5));
sl@0	2041	TEST(err==KErrNone);
sl@0	2042
sl@0	2043	TRAP(err, EComTestUtils::FileManCopyFileL(KResourceFileName12OnZ, KResourceFileName12));
sl@0	2044	TEST(err==KErrNone);
sl@0	2045
sl@0	2046	TRAP(err, EComTestUtils::FileManCopyFileL(KExampleDllFileName12OnZ, KExampleDllFileName12));
sl@0	2047	TEST(err==KErrNone);
sl@0	2048	}
sl@0	2049
sl@0	2050	// Deleting plugin from the RAM for cleanup purpose
sl@0	2051	LOCAL_C void DeleteTestPlugin()
sl@0	2052	{
sl@0	2053	TRAPD(err, EComTestUtils::FileManDeleteFileL(KResourceFileName5));
sl@0	2054	TRAP(err, EComTestUtils::FileManDeleteFileL(KExampleDllFileName5));
sl@0	2055	TRAP(err, EComTestUtils::FileManDeleteFileL(KResourceFileName12));
sl@0	2056	TRAP(err, EComTestUtils::FileManDeleteFileL(KExampleDllFileName12));
sl@0	2057	}
sl@0	2058
sl@0	2059	//
sl@0	2060	//Initialise the Active Scheduler
sl@0	2061	//
sl@0	2062	LOCAL_C void SetupL()
sl@0	2063	{
sl@0	2064	// Construct and install the Active Scheduler. The Active Schedular is needed
sl@0	2065	// by components used by this test as they are ActiveObjects.
sl@0	2066	TheActiveScheduler = new(ELeave)CActiveScheduler;
sl@0	2067	CActiveScheduler::Install(TheActiveScheduler);
sl@0	2068	}
sl@0	2069
sl@0	2070	GLDEF_C TInt E32Main()
sl@0	2071	{
sl@0	2072	__UHEAP_MARK;
sl@0	2073
sl@0	2074	TheTest.Printf(_L("\n"));
sl@0	2075	TheTest.Title();
sl@0	2076	TheTest.Start( _L("LoadManager Tests.") );
sl@0	2077
sl@0	2078	TheTrapCleanup = CTrapCleanup::New();
sl@0	2079
sl@0	2080	TRAPD(err, SetupL());
sl@0	2081	TEST(err == KErrNone);
sl@0	2082
sl@0	2083	CopyPlugins();
sl@0	2084	// The reason for the folowing delay is:
sl@0	2085	// ECOM server could be already started. It means that when we copy some
sl@0	2086	// ECOM plugins from Z: to C: drive - ECOM server should look for and
sl@0	2087	// find the new ECOM plugins. The ECOM server uses for that an active object,
sl@0	2088	// which scans plugin directories. So the discovering service is asynchronous.
sl@0	2089	// We have to wait some time until it finishes.
sl@0	2090	// Otherwise ListImplementationsL could fail to find requested implementations.
sl@0	2091	User::After(KOneSecond * 3);
sl@0	2092
sl@0	2093	//Call the main tess
sl@0	2094	TRAP(err, DoTestL());
sl@0	2095	TEST2(err,KErrNone);
sl@0	2096
sl@0	2097	// Cleanup files. If the cleanup fails that is no problem,
sl@0	2098	// as any subsequent tests will replace them. The only downside
sl@0	2099	// would be the disk not being tidied
sl@0	2100	DeleteTestPlugin();
sl@0	2101
sl@0	2102	TheFs.Close();
sl@0	2103
sl@0	2104	delete TheActiveScheduler;
sl@0	2105	delete TheTrapCleanup;
sl@0	2106
sl@0	2107	TheTest.End();
sl@0	2108	TheTest.Close();
sl@0	2109
sl@0	2110	__UHEAP_MARKEND;
sl@0	2111	return KErrNone;
sl@0	2112	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--