diff -r 000000000000 -r e4d67989cc36 lowlevellibsandfws/pluginfw/Framework/LoadManagerTest/t_loadmanager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lowlevellibsandfws/pluginfw/Framework/LoadManagerTest/t_loadmanager.cpp Tue Feb 02 02:01:42 2010 +0200 @@ -0,0 +1,2112 @@ +// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// This file contains test classes and their implementations +// to test production class CLoadManager. Where necessary stubs +// are implemented to help in writing test harness using RTest. +// Plugins available to be used in this test +// Interface UID DLL UID Implementation UID Version DllFile +// 0x10009DC0 0x10009DB1 0x10009DC3 1 Z:\\..\\EComExample.dll +// 0x10009DB1 0x10009DC4 1 Z:\\..\\EComExample.dll +// 0x10009DB3 0x10009DC3 2 Z:\\..\\EComExample2.dll +// 0x10009DB3 0x10009DC4 2 Z:\\..\\EComExample2.dll +// 0x101F8477 0x101F8478 1 Z:\\..\\EComExample3.dll +// 0x101F8479 0x101F847A 1 Z:\\..\\EComExample4.dll +// 0x101F847B 0x101F847C 1 C:\\..\\EComExample5.dll +// 0x10282331 0x10282330 0x10282332 1 Z:\\..\\EComLoadMgrExample1.dll +// 0x10282330 0x10282334 1 Z:\\..\\EComLoadMgrExample1.dll +// 0x10282335 0x10282333 1 Z:\\..\\EComLoadMgrExample2.dll +// +// + +#include +#include +#include +#include +#include "LoadManager.h" +#include +#include "EComUidCodes.h" +#include "RegistryData.h" +#include +#include "../EcomTestUtils/EcomTestUtils.h" +#include "Interface.h" +#include "UnloadPolicy.h" +// --------------------------------------------------------------------------- +// Test and Leave framework + +LOCAL_D RTest TheTest(_L("t_loadmanager.exe")); + +LOCAL_C void Check(TInt aValue, TInt aLine) + { + if(!aValue) + { + //DeleteTestPlugin(); + TheTest(EFalse, aLine); + } + } + +LOCAL_C void Check(TInt aValue, TInt aExpected, TInt aLine) + { + if(aValue != aExpected) + { + RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue); + //DeleteTestPlugin(); + TheTest(EFalse, aLine); + } + } + +#define TEST(arg) ::Check((arg), __LINE__) + +#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__) + +//Leave with info message printed out +LOCAL_C void Leave(TInt aError, TInt aLine) + { + RDebug::Print(_L("*** Leave. Error: %d, Line: %d\r\n"), aError, aLine); + User::Leave(aError); + } + + +//Use LEAVE() macro instead of User::Leave() and LEAVE_IF_ERROR() macro instead of +//User::LeaveIfError(). They will print the line number, where the "leave" was called. + +#define LEAVE(aError) ::Leave(aError, __LINE__) + + +// --------------------------------------------------------------------------- + +LOCAL_D RFs TheFs; + +LOCAL_D CTrapCleanup* TheTrapCleanup = NULL; + +LOCAL_D CActiveScheduler* TheActiveScheduler = NULL; + +//Plugins files used for this test program +_LIT(KResourceFileName5, "C:\\resource\\plugins\\EComExample5.RSC"); +_LIT(KExampleDllFileName5, "C:\\sys\\bin\\EComExample5.dll"); +_LIT(KExampleDllFileName4,"Z:\\sys\\bin\\EComExample4.dll"); +_LIT(KExampleDllFileName3,"Z:\\sys\\bin\\EComExample3.dll"); +_LIT(KExampleDllFileName2,"Z:\\sys\\bin\\EComExample2.dll"); +_LIT(KLoadMgrExample1DllName,"Z:\\sys\\bin\\EComLoadMgrExample1.dll"); +_LIT(KLoadMgrExample2DllName,"Z:\\sys\\bin\\EComLoadMgrExample2.dll"); + +_LIT(KResourceFileName5OnZ, "z:\\RAMOnly\\EComExample5.RSC"); +_LIT(KExampleDllFileName10,"Z:\\sys\\bin\\EComExample10.dll"); +_LIT(KNULLString,""); + +_LIT(KExampleDllFileName12,"C:\\sys\\bin\\EComExample12.dll"); +_LIT(KExampleDllFileName12OnZ, "z:\\RAMOnly\\EComExample12.dll"); +_LIT(KResourceFileName12, "C:\\resource\\plugins\\EComExample12.RSC"); +_LIT(KResourceFileName12OnZ, "z:\\RAMOnly\\EComExample12.RSC"); + +//Contains files that are part of ROM that must be +//Copied to the RAM for test purposes + +_LIT(KExampleDllFileName5OnZ, "z:\\RAMOnly\\EComExample5.dll"); + + +// Used for supressing warning in OOM tests +#define __UNUSED_VAR(var) var = var + +const TInt KOneSecond = 1000000; + +// Utility clean up function +void CleanupEComArray(TAny* aArray); + +//It is used by some test methods which are called two times: +//from normal test and from OOM TheTest. +static void LeaveIfErrNoMemory(TInt aError) + { + if(aError == KErrNoMemory) + { + LEAVE(aError); + } + } + +/** +Test State Accessor class for CLoadManager +This class will be used to access the state +of the policy array within CLoadManager +*/ +class TLoadManager_StateAccessor + { +public: + //Return the number of instance index inside iInstanceInfoList + TInt InstanceIndexCount(CLoadManager& aLoadManager); + //Return the number of unload policy inside iAllUnloadPolicies + TInt UnloadPolicyCount(CLoadManager& aLoadManager); + //Return a pointer to Instance Index item inside the instance index array + CInstanceInfo* InstanceIndex(const TInt& aInt,CLoadManager& aLoadManager); + //Return a pointer to UnloadPolicy item inside the array + CUnloadPolicy* UnloadPolicy(const TInt& aInt,CLoadManager& aLoadManager); + //Return a pointer to garbage UnloadPolicy + CUnloadPolicy* GarbagePolicy(CLoadManager& aLoadManager); + //Return a count to the number of extended objects within an Extended instance. + // Must pass in the index of a valid extended instance + TInt ExtendedInstanceCount(const TInt& aInt,CLoadManager& aLoadManager); + }; + +TInt TLoadManager_StateAccessor::InstanceIndexCount(CLoadManager& aLoadManager) + { + return aLoadManager.iInstanceInfoList.Count(); + } + +TInt TLoadManager_StateAccessor::UnloadPolicyCount(CLoadManager& aLoadManager) + { + return aLoadManager.iAllUnloadPolicies.Count(); + } + +CInstanceInfo* TLoadManager_StateAccessor::InstanceIndex(const TInt& aInt,CLoadManager& aLoadManager) + { + return (aLoadManager.iInstanceInfoList[aInt]); + } + +CUnloadPolicy* TLoadManager_StateAccessor::UnloadPolicy(const TInt& aInt,CLoadManager& aLoadManager) + { + return aLoadManager.iAllUnloadPolicies[aInt]; + } +CUnloadPolicy* TLoadManager_StateAccessor::GarbagePolicy(CLoadManager& aLoadManager) + { + return aLoadManager.iGarbagePolicy; + } + +TInt TLoadManager_StateAccessor::ExtendedInstanceCount(const TInt& aInt,CLoadManager& aLoadManager) + { + CInstanceInfoExtended* instanceExtended = static_cast(aLoadManager.iInstanceInfoList[aInt]); + return instanceExtended->iExtendedObjectInfo.Count(); + } + + +/** +Test class for object CLoadManager. +The class provides the parameters and behaviour that +allows this class to behave normally under a test scenario. +*/ +class CLoadManagerTest : public CBase + { +public: + static CLoadManagerTest* NewL(); + virtual inline ~CLoadManagerTest(); + + void InstantiationMethodTestL(TUid aDllUid, const TDesC& aDllName, const TUid aIICType); + void DestroyThisTestL(TUid aDllUid, const TDesC& aDllName, const TUid aIICType); + + void CreateDestroyTestCase1L(TUid aDllUid1, + TUid aImplUid1, + const TDesC& aDllName1, + TUid aDllUid2, + TUid aImplUid2, + const TDesC& aDllName2, + const TUid aIICType); + void CreateDestroyTestCase2L(TUid aDllUid, + TUid aImplUid1, + const TDesC& aDllName, + TUid aImplUid2, + const TUid aIICType); + void CreateDestroyTestCase3L(); + + void CreateDestroyTestCase4L(TUid aDllUid,TUid aImplUid,const TDesC& aDllName,const TUid aIICType); + + void CreateDestroyTestCase5L(TUid aDllUid1, + TUid aImplUid1, + const TDesC& aDllName1, + TUid aDllUid2, + TUid aImplUid2, + const TDesC& aDllName2, + TUid aImplUid3, + const TUid aIICType); + + void SpecialOOMTestCaseL(); + + void InstantiationMethodTestPlugin1L(); + void InstantiationMethodTestPlugin3L(); + void ImplementationObjectTestL(); + + void GetImplementationUidTestL(); + + void DestroyThisTestPlugin1L(); + void DestroyThisTestPlugin3L(); + + void CreateDestroyTestCase1Plugin1L(); + void CreateDestroyTestCase1Plugin3L(); + + void CreateDestroyTestCase2Plugin1L(); + void CreateDestroyTestCase2Plugin3L(); + + void CreateDestroyTestCase3Plugin3L(); + + void CreateDestroyTestCase4Plugin1L(); + void CreateDestroyTestCase4Plugin3L(); + + void CreateDestroyTestCase5Plugin1L(); + void CreateDestroyTestCase5Plugin3L(); + + // Extended methods + void ExtendedMethodTest1Plugin3L(); + void ExtendedMethodTest2Plugin3L(); + void ManuallyReleaseExtendedInterfaceTestL(); + void CreateDestroyTestCase1PluginAndPlugin3L(); + +private: + CLoadManagerTest(); + void ConstructL(); + +public: + /** The instance of the class under test */ + CLoadManager* iLoadManager; + + /** Unique Id of an interface implementation */ + TUid iImplementationUid; + + /** LoadManager State Accessor */ + TLoadManager_StateAccessor iStateAccessor; + }; + +/** +Standardised safe construction which +leaves nothing on the cleanup stack. + +@post CLoadManagerTest is fully constructed and initialised. +*/ +CLoadManagerTest* CLoadManagerTest::NewL() + { + CLoadManagerTest* self = new(ELeave) CLoadManagerTest; + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +/** +Standardized default constructor + +@post CLoadManagerTest is fully constructed. +*/ +CLoadManagerTest::CLoadManagerTest() + { + // Implementation id for interface 0x10009DC0 + // Implemented in test plugin EComExample4.dll + iImplementationUid.iUid = 0x101F847A; + } + +/** +Destructor. + +@post This object is properly destroyed. +*/ +CLoadManagerTest::~CLoadManagerTest() + { + delete iLoadManager; + } + +/** +Standardized 2nd(Initialization) phase of two phase construction. + +@post CLoadManagerTest is fully constructed. +*/ +void CLoadManagerTest::ConstructL() + { + iLoadManager = CLoadManager::NewL(); + } + +/** +The test executes by getting the Instantiation method for +the given ImplementationId +*/ +void CLoadManagerTest::InstantiationMethodTestL(TUid aDllUid, const TDesC& aDllName, const TUid aIICType) + { + CExampleInterface::TExampleInterfaceInitParams iInitParams; + iInitParams.integer = 5; + TBool initParamsFlag = ETrue; + _LIT(KDummyText,"Dummy params"); + iInitParams.descriptor = &KDummyText; + + TEntry entry; + entry.iName=aDllName; + entry.iModified=TTime(0); + entry.iType=TUidType(KDynamicLibraryUid,aIICType,aDllUid); + + TAny* implementationPtr = 0; + TUid instanceKey; + TRAPD(err, implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid, entry,&iInitParams, initParamsFlag,instanceKey)); + + ::LeaveIfErrNoMemory(err); + TEST2(err,KErrNone); + TEST(implementationPtr != 0); + + //Checking the state of the arrays inside CLoadManager and garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==1); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==1); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL); + + //Checking the instance index and UnloadPolicy info + TEST(iStateAccessor.InstanceIndex(0,*iLoadManager)->ImplementationUid()==iImplementationUid); + TEST(iStateAccessor.UnloadPolicy(0,*iLoadManager)->DllEntryInformation().GetName().CompareF(aDllName)==0); + + delete (CExampleInterface*)implementationPtr; + implementationPtr=0; + iLoadManager->DestroyedThis(instanceKey); + iLoadManager->ClearGarbage(); + } + +/** +Test CLoadManager::ImplementationObjectL with parameters to test old proxy table +*/ +void CLoadManagerTest::InstantiationMethodTestPlugin1L() + { + // This test tests with Ecom plugin EComExample4.dll + // EComExample4.dll should be installed on Z: drive + // The test executes by getting the Instantiation method for the given ImplementationId + // implementationPtr method should get some valid address. + // Manually creating the DLL info that in practice will be returned from the server side + // Set up some init params to be used for testing purpose + TUid dllUid; + dllUid.iUid = 0x101F8479; + iImplementationUid.iUid=0x101F847A; + InstantiationMethodTestL(dllUid,KExampleDllFileName4,KUidInterfaceImplementationCollection); + } + +/** +@SYMTestCaseID SYSLIB-ECOM-UT-3549 +@SYMTestCaseDesc Calls CLoadManager::ImplementationObjectL with parameters to test new proxy table +@SYMTestPriority High +@SYMTestActions Instantiate implementation for the given ImplementationId with construction parameters + and check the CLoadManager data structures. + Destroy the implementation object and again check the CLoadManager data structures. + (ECom plugin EComExample10.dll will be used for the test.) +@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls +@SYMEC EC43 +*/ +void CLoadManagerTest::InstantiationMethodTestPlugin3L() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3549 ")); + TUid dllUid; + dllUid.iUid = 0x10009E37; + iImplementationUid.iUid = 0x10009E38; + InstantiationMethodTestL(dllUid,KExampleDllFileName10,KUidInterfaceImplementationCollection3); + } + + +/** +@SYMTestCaseID SYSLIB-ECOM-UT-3710 +@SYMTestCaseDesc Tests CLoadManager::ImplementationObjectL with some extreme conditions to improve the + condition coverage rate. + 1. implementationUid is NULL. The function will leave with KErrNotFound + 2. dllName is NULL. The function will leave with KErrNotFound + 3. second Uid of the PlugIn is neither IIC or IIC3. The function will leave with KErrNotSupported +@SYMTestPriority High +@SYMTestActions Calls CLoadManager::ImplementationObjectL and check the result. +@SYMTestExpectedResults Expected error is return. +@SYMDEF DEF111196 +*/ +void CLoadManagerTest::ImplementationObjectTestL() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3710 ")); + TUid dummyUid; + dummyUid.iUid = 0; + + TUid dllUid; + dllUid.iUid = 0x10009E37; + + iImplementationUid.iUid = 0x10009E38; + + CExampleInterface::TExampleInterfaceInitParams iInitParams; + iInitParams.integer = 5; + TBool initParamsFlag = ETrue; + _LIT(KDummyText,"Dummy params"); + iInitParams.descriptor = &KDummyText; + + TEntry entry; + entry.iName=KExampleDllFileName10; + entry.iModified=TTime(0); + entry.iType=TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid); + + TUid instanceKey; + + // 1. Calls ImplementationObjectL with implementationUid is NULL. The function will leave with KErrNotFound + TRAPD(err, TAny* implementationPtr = iLoadManager->ImplementationObjectL(dummyUid, entry,&iInitParams, initParamsFlag,instanceKey)); + TEST2(err,KErrNotFound); + + // 2. Calls ImplementationObjectL with dllName is NULL. The function will leave with KErrNotFound + entry.iName = KNULLString; + TRAP(err, TAny* implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid,entry,&iInitParams, initParamsFlag,instanceKey)); + TEST2(err,KErrNotFound); + + // 3. Calls ImplementationObjectL with second Uid of the PlugIn is neither IIC or IIC3 + entry.iName=KExampleDllFileName10; + entry.iModified=TTime(0); + entry.iType=TUidType(KDynamicLibraryUid,dummyUid,dllUid); + TRAP(err, TAny* implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid,entry,&iInitParams, initParamsFlag,instanceKey)); + TEST2(err,KErrNotSupported); + } + + +/** +Test CLoadManager::DestroyThis(). DestroyThis will actually either remove the UnloadPolicy from the list or decrease +referencecount(to UnloadPolicy) by one. +*/ +void CLoadManagerTest::DestroyThisTestL(TUid aDllUid, const TDesC& aDllName, const TUid aIICType) + { + // We must call DestroyedThis only after getting a reference to the Implementation + // so that reference count to this implementaion have value greater than zero. + // ImplementationObjectL is called to increase the reference count of the test implementation, + // so that its reference count goes to 1. + // This test executes by verifing the reference count to this implementation. + CExampleInterface::TExampleInterfaceInitParams iInitParams; + iInitParams.integer = 5; + TBool initParamsFlag = ETrue; + _LIT(KDummyText,"Dummy params"); + iInitParams.descriptor = &KDummyText; + + TEntry entry; + entry.iName=aDllName; + entry.iModified=TTime(0); + entry.iType=TUidType(KDynamicLibraryUid, aIICType, aDllUid); + + TAny* implementationPtr = 0; + TUid instanceKey; + TRAPD(err, implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid, entry, &iInitParams, initParamsFlag,instanceKey)); + + ::LeaveIfErrNoMemory(err); + TEST2(err,KErrNone); + TEST(implementationPtr != 0); + + //Checking the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==1); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==1); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL); + + // The purpose of DestroyedThis is to decrease the reference count of UnloadPolicy or + // remove the Dll from RegistryData if its on grabagelist and reference count reaches 0 + iLoadManager->DestroyedThis(instanceKey); + + //Checking the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==0); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==0); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)!=NULL); + + //delete the instantiation + delete (CExampleInterface*)implementationPtr; + implementationPtr=0; + } + +/** +@SYMTestCaseID SYSLIB-ECOM-UT-3709 +@SYMTestCaseDesc This testcase checks GetImplementationUidL(). +@SYMTestPriority High +@SYMTestActions Instantiate an implementation. + Call GetImplementationUidL() and check impl id. + Call GetImplementationUidL() and check impl id again. + Destroy plugin. + Call GetImplementationUidL() and check for error. +@SYMTestExpectedResults Returns impl uid when valid destructor uid is used otherwise + leaves with the appropriate error. +@SYMDEF DEF111789 +*/ +void CLoadManagerTest::GetImplementationUidTestL() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3709 ")); + // EComExample5.dll (dlluid 0x101F847B) in C:\ with Implementation Uid =0x101F847C + TUid dllUid; + dllUid.iUid = 0x101F847B; + CExampleInterface::TExampleInterfaceInitParams iInitParams; + iInitParams.integer = 5; + TBool initParamsFlag = ETrue; + _LIT(KDummyText,"Dummy params"); + iInitParams.descriptor = &KDummyText; + + TEntry entry; + entry.iName=KExampleDllFileName5; + + entry.iModified=TTime(0); + entry.iType=TUidType(KDynamicLibraryUid, KUidInterfaceImplementationCollection, dllUid); + + iImplementationUid.iUid=0x101F847C; + + TAny* implementationPtr = 0; + TUid instanceKey; + TRAPD(err, implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid, entry, &iInitParams, initParamsFlag, instanceKey)); + + ::LeaveIfErrNoMemory(err); + TEST2(err,KErrNone); + TEST(implementationPtr != 0); + + // Retrieve impl uid corresponding to detructor key id + TUid implId = iLoadManager->GetImplementationUidL(instanceKey); + // Check that the impl uid corresponding to destructor key id is as expected + TEST(implId == iImplementationUid); + + // Do it again to be sure... + implId = iLoadManager->GetImplementationUidL(instanceKey); + // Check that the impl uid corresponding to destructor key id is as expected + TEST(implId == iImplementationUid); + + iLoadManager->DestroyedThis(instanceKey); + + //delete the instantiation + delete (CExampleInterface*)implementationPtr; + implementationPtr=0; + + // Call GetImplementationUidL() again now that the instance has been deleted + // Expecting a Leave... + TRAP(err,implId = iLoadManager->GetImplementationUidL(instanceKey)); + TEST2(err, KErrNotFound); + } + +/** +Test executes by getting the CUnloadPolicy* associated to the testing DLL EComExample5.dll. +*/ +void CLoadManagerTest::DestroyThisTestPlugin1L() + { + // EComExample5.dll (dlluid 0x101F847B) in C:\ with Implementation Uid =0x101F847C + TUid dllUid; + dllUid.iUid = 0x101F847B; + iImplementationUid.iUid=0x101F847C; + DestroyThisTestL(dllUid,KExampleDllFileName5,KUidInterfaceImplementationCollection); + } + +/** +@SYMTestCaseID SYSLIB-ECOM-UT-3550 +@SYMTestCaseDesc Calls CLoadManager::DestroyedThis with parameters to test new proxy table +@SYMTestPriority High +@SYMTestActions Test executes by getting the CUnloadPolicy* associated to the testing DLL EComExample10.dll. + DestroyThis will actually either remove the UnloadPolicy from the list or decrease + referencecount(to UnloadPolicy) by one. +@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls +@SYMEC EC43 +*/ +void CLoadManagerTest::DestroyThisTestPlugin3L() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3550 ")); + // EComExample10.dll + TUid dllUid; + dllUid.iUid = 0x10009E37; + iImplementationUid.iUid = 0x10009E38; + DestroyThisTestL(dllUid,KExampleDllFileName10,KUidInterfaceImplementationCollection3); + } + +/** +Tests for create and destroy load manager +Test case 1:Creates two implementations from two DIFFERENT DLL Z: C: +Test case 2:Creates two implementations from one SAME DLL +Test case 3:Invalid argument testing for Create Implementation + Invalid Entry and Implementation uid argument in ImplementationObjectL +Test case 4:Creates two instance of the same implementation Uid from one single DLL +Test case 5:DEF101930: Incorrect policy object returned in + This testcase checks for the case where 2 implementations + are created each on separate DLL's then an additional + implementation is created from one of the already loaded DLL's. + The impl uid of the newly created impl is lower then the 2 + existing impl uids. The impl uids from the same DLL are such + that 1 is higher then the uid of the other impl and 1 is lower than + the other impl. +*/ + +// Test case 1:Create two implementation from two DIFFERENT DLL Z: C: + +void CLoadManagerTest::CreateDestroyTestCase1L(TUid aDllUid1, + TUid aImplUid1, + const TDesC& aDllName1, + TUid aDllUid2, + TUid aImplUid2, + const TDesC& aDllName2, + const TUid aIICType) + { + //Some interface instantiation parameters + CExampleInterface::TExampleInterfaceInitParams iInitParams; + iInitParams.integer = 5; + TBool initParamsFlag = ETrue; + _LIT(KDummyText,"Dummy params"); + iInitParams.descriptor = &KDummyText; + TAny* impl1 = NULL; + TAny* impl2 = NULL; + + TEntry entry1; + entry1.iName = aDllName1; + entry1.iModified = TTime(0); + entry1.iType = TUidType(KDynamicLibraryUid,aIICType,aDllUid1); + + TEntry entry2; + entry2.iName = aDllName2; + entry2.iModified = TTime(0); + entry2.iType = TUidType(KDynamicLibraryUid,aIICType,aDllUid2); + + TInt err; + //Creates 1st Implementation + TUid instanceKey; + TRAP(err,impl1 = iLoadManager->ImplementationObjectL(aImplUid1,entry1, &iInitParams,initParamsFlag,instanceKey)); + ::LeaveIfErrNoMemory(err); + TEST2(err,KErrNone); + + //Checks the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + + //Creates 2nd Implementation + TUid instanceKey2; + TRAP(err,impl2 = iLoadManager->ImplementationObjectL(aImplUid2,entry2, &iInitParams,initParamsFlag,instanceKey2)); + // If impl2 fails here due to KErrNoMemory we need to clear the previous impl1 + // to avoid memory leak + if (err==KErrNoMemory) + { + iLoadManager->DestroyedThis(instanceKey); + delete (CExampleInterface*)impl1; + impl1 = NULL; + ::LeaveIfErrNoMemory(err); + } + TEST(err == KErrNone); + + //Checks the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 2); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 2); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + + //Now destroy the 2nd Implementation + iLoadManager->DestroyedThis(instanceKey2); + delete (CExampleInterface*)impl2; + impl2 = NULL; + + //Checks the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL); + + //Now destroy the 1st Implementation; + iLoadManager->DestroyedThis(instanceKey); + delete (CExampleInterface*)impl1; + impl1 = NULL; + + //Checks the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL); + + iLoadManager->ClearGarbage(); + + //Checks the final state of the garbage policy + //Tests for the new API ClearGarbage() + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + } + +/** +Plugins used: +- Z:\\..\\EComExample3.dll contains ImplUid=0x101F8478 +- C:\\..\\EComExample5.dll contains ImplUid=0x101F847C + +@SYMTestCaseID SYSLIB-ECOM-CT-0701 +@SYMTestCaseDesc Tests for create and delete of CLoadManager +@SYMTestPriority High +@SYMTestActions Create two implementation from two DIFFERENT DLL Z: C: +@SYMTestExpectedResults Two UnloadPolicy inside the array because of Two DLL loaded + Two Instance indexes because of two Different Implementation Uid's +@SYMREQ REQ0000 +*/ +void CLoadManagerTest::CreateDestroyTestCase1Plugin1L() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-0701 ")); + //Implementation Uid inside Z:\\..\\EComExample3.dll + TUid implUid1={0x101F8478}; + //Implementation Uid inside C:\\..\\EComExample5.dll + TUid implUid2={0x101F847C}; + //EComExample3.dll entry + TUid dllUid1; + dllUid1.iUid = 0x101F8477; + //EComExample5.dll entry + TUid dllUid2; + dllUid2.iUid = 0x101F847B; + + CreateDestroyTestCase1L(dllUid1,implUid1,KExampleDllFileName3,dllUid2,implUid2,KExampleDllFileName5,KUidInterfaceImplementationCollection); + } + +/** +@SYMTestCaseID SYSLIB-ECOM-UT-3551 +@SYMTestCaseDesc Tests for create and delete of implementations using PLUGIN3 from two DIFFERENT DLL's +@SYMTestPriority High +@SYMTestActions Create two implementations from two DIFFERENT DLL's using new Dll type PLUGIN3. + Test executes by getting the CUnloadPolicy* associated to the testing DLL EComExample10.dll. + DestroyThis will actually either remove the UnloadPolicy from the list or decrease + referencecount(to UnloadPolicy) by one. +@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls + Two UnloadPolicy inside the array because of Two DLL loaded + Two Instance indexes because of two Different Implementation Uid's +@SYMEC EC43 +*/ +void CLoadManagerTest::CreateDestroyTestCase1Plugin3L() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3551 ")); + //Implementation Uid inside Z:\\..\\EComExample10.dll + TUid implUid1 = {0x10009E38}; + //Implementation Uid inside C:\\..\\EComExample12.dll + TUid implUid2 = {0x10009E39}; + //EComExample10.dll entry + TUid dllUid1; + dllUid1.iUid = 0x10009E37; + //EComExample12.dll entry + TUid dllUid2; + dllUid2.iUid = 0x10009E3E; + + CreateDestroyTestCase1L(dllUid1,implUid1,KExampleDllFileName10,dllUid2,implUid2,KExampleDllFileName12,KUidInterfaceImplementationCollection3); + } + +/** +@SYMTestCaseID SYSLIB-ECOM-UT-3552 +@SYMTestCaseDesc Tests for create and delete of implementations using PLUGIN1 and PLUGIN3 +@SYMTestPriority High +@SYMTestActions Create two implementations from two DIFFERENT DLL's one of PLUGIN1, the other Dll + of type PLUGIN3. Test executes by getting the CUnloadPolicy* associated to the + testing DLL EComExample10.dll. DestroyThis will actually either remove the + UnloadPolicy from the list or decrease referencecount(to UnloadPolicy) by one. + Plugins used: + - Z:\\..\\EComExample3.dll contains ImplUid=0x101F8478 - PLUGIN type dll + - Z:\\..\\EComExample10.dll contains ImplUid=0x10009E38 - PLUGIN3 type dll +@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls + Two UnloadPolicy inside the array because of Two DLL loaded + Two Instance indexes because of two Different Implementations +@SYMEC EC43 +*/ +void CLoadManagerTest::CreateDestroyTestCase1PluginAndPlugin3L() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3552 ")); + //Implementation Uid inside Z:\\..\\EComExample3.dll + TUid ImplUid1 = {0x101F8478}; + //Implementation Uid inside Z:\\..\\EComExample10.dll + TUid ImplUid2 = {0x10009E38}; + //Some interface instantiation parameters + CExampleInterface::TExampleInterfaceInitParams iInitParams; + iInitParams.integer = 5; + TBool initParamsFlag = ETrue; + _LIT(KDummyText,"Dummy params"); + iInitParams.descriptor = &KDummyText; + TAny* impl1 = NULL; + TAny* impl2 = NULL; + + //EComExample3.dll entry + TUid dllUid1; + dllUid1.iUid = 0x101F8477; + + TEntry entry1; + entry1.iName = KExampleDllFileName3; + entry1.iModified = TTime(0); + entry1.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection,dllUid1); + + //EComExample10.dll entry + TUid dllUid2; + dllUid2.iUid = 0x10009E37; + + TEntry entry2; + entry2.iName = KExampleDllFileName10; + entry2.iModified = TTime(0); + entry2.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid2); + + TInt err; + //Creates Implementation with Uid=0x101F8478 + TUid instanceKey; + TRAP(err,impl1 = iLoadManager->ImplementationObjectL(ImplUid1,entry1, &iInitParams,initParamsFlag,instanceKey)); + ::LeaveIfErrNoMemory(err); + TEST2(err,KErrNone); + + //Checks the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + + //Creates 2nd Implementation with Uid=0x10009E38 + TUid instanceKey2; + TRAP(err,impl2 = iLoadManager->ImplementationObjectL(ImplUid2,entry2, &iInitParams,initParamsFlag,instanceKey2)); + // If impl2 fails here due to KErrNoMemory we need to clear the previous impl1 + // to avoid memory leak + if (err==KErrNoMemory) + { + iLoadManager->DestroyedThis(instanceKey); + delete (CExampleInterface*)impl1; + impl1 = NULL; + ::LeaveIfErrNoMemory(err); + } + TEST(err == KErrNone); + + //Checks the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 2); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 2); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + + //Now destroy the 2nd Implementation + iLoadManager->DestroyedThis(instanceKey2); + delete (CExampleInterface*)impl2; + impl2 = NULL; + + //Checks the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL); + + //Now destroy the 1st Implementation; + iLoadManager->DestroyedThis(instanceKey); + delete (CExampleInterface*)impl1; + impl1 = NULL; + + //Checks the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL); + + iLoadManager->ClearGarbage(); + + //Checks the final state of the garbage policy + //Tests for the new API ClearGarbage() + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + } + + +// Test case 2:Create two implementation from one SAME DLL + +void CLoadManagerTest::CreateDestroyTestCase2L(TUid aDllUid, + TUid aImplUid1, + const TDesC& aDllName, + TUid aImplUid2, + const TUid aIICType) + { + CExampleInterface::TExampleInterfaceInitParams iInitParams; + iInitParams.integer = 5; + TBool initParamsFlag = ETrue; + _LIT(KDummyText,"Dummy params"); + iInitParams.descriptor = &KDummyText; + TAny* impl1 = NULL; + TAny* impl2 = NULL; + + TEntry entry; + entry.iName = aDllName; + entry.iModified = TTime(0); + entry.iType = TUidType(KDynamicLibraryUid,aIICType,aDllUid); + + TInt err; + //Creates Implementation 1 + TUid instanceKey; + TRAP(err,impl1 = iLoadManager->ImplementationObjectL(aImplUid1,entry, &iInitParams,initParamsFlag,instanceKey)); + ::LeaveIfErrNoMemory(err); + TEST(err==KErrNone); + //Checks the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + + TAny* impl4 = NULL; + //Recreates another Implementation 1 + TUid instanceKey2; + TRAP(err,impl4 = iLoadManager->ImplementationObjectL(aImplUid1,entry, &iInitParams,initParamsFlag,instanceKey2)); + if (err == KErrNoMemory) + { + iLoadManager->DestroyedThis(instanceKey); + delete (CExampleInterface*)impl1; + impl1 = NULL; + ::LeaveIfErrNoMemory(err); + } + TEST2(err,KErrNone); + //Checks the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 2); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + + //Creates Implementation 2 + TUid instanceKey3; + TRAP(err,impl2 = iLoadManager->ImplementationObjectL(aImplUid2,entry, &iInitParams,initParamsFlag,instanceKey3)); + // If impl2 fails here due to KErrNoMemory we need to clear the previous impl1 + // to avoid memory leak + if (err == KErrNoMemory) + { + iLoadManager->DestroyedThis(instanceKey); + delete (CExampleInterface*)impl1; + impl1 = NULL; + iLoadManager->DestroyedThis(instanceKey2); + delete (CExampleInterface*)impl4; + impl4 = NULL; + ::LeaveIfErrNoMemory(err); + } + + TEST2(err,KErrNone); + + //Checks the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 3); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + + //Creates another Implementation 2 + TAny* impl3 = NULL; + TUid instanceKey4; + TRAP(err,impl3 = iLoadManager->ImplementationObjectL(aImplUid2,entry, &iInitParams,initParamsFlag,instanceKey4)); + //Checks the state of the arrays inside CLoadManager and the garbage policy + if (err == KErrNoMemory) + { + //cleanup the previously loaded implementation before leaving + iLoadManager->DestroyedThis(instanceKey); + delete (CExampleInterface*)impl1; + impl1 = NULL; + iLoadManager->DestroyedThis(instanceKey2); + delete (CExampleInterface*)impl4; + impl4 = NULL; + iLoadManager->DestroyedThis(instanceKey3); + delete (CExampleInterface*)impl2; + impl2 = NULL; + ::LeaveIfErrNoMemory(err); + } + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 4); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + + //Destroy Implementation 1 + iLoadManager->DestroyedThis(instanceKey); + delete (CExampleInterface*)impl1; + impl1 = NULL; + iLoadManager->DestroyedThis(instanceKey2); + delete (CExampleInterface*)impl4; + impl4 = NULL; + + //Checks the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 2); + //Note here after destroying Impl1, the DLL is still in used, so no garbage policy + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + + //Destroy Implementation 2 + iLoadManager->DestroyedThis(instanceKey3); + delete (CExampleInterface*)impl2; + impl2 = NULL; + + //Destroy 2nd Implementation 2 + iLoadManager->DestroyedThis(instanceKey4); + delete (CExampleInterface*)impl3; + impl3 = NULL; + + //Checks the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL); + + iLoadManager->ClearGarbage(); + + //Checks the final state of the garbage policy + //Tests for the new API ClearGarbage() + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + } + + +/** +Plugins used: +- Z:\\..\\EComExample2.dll contains ImplUid 0x10009DC3 & 0x10009DC4 + +@SYMTestCaseID SYSLIB-ECOM-CT-0702 +@SYMTestCaseDesc Tests for create and delete of CLoadManager +@SYMTestPriority High +@SYMTestActions Create two implementation from the SAME DLL +@SYMTestExpectedResults One UnloadPolicy since both Implementation is based on SAME DLL + Two Instance indexes because of two Different Implementations +@SYMREQ REQ0000 +*/ +void CLoadManagerTest::CreateDestroyTestCase2Plugin1L() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-0702 ")); + TUid implUid1={0x10009DC3}; + TUid implUid2={0x10009DC4}; + + TUid dllUid; + dllUid.iUid = 0x10009DB3; + + CreateDestroyTestCase2L(dllUid,implUid1,KExampleDllFileName2,implUid2,KUidInterfaceImplementationCollection); + + } + +/** +@SYMTestCaseID SYSLIB-ECOM-UT-3553 +@SYMTestCaseDesc Tests for create and delete of implementations using PLUGIN3 from the SAME DLL +@SYMTestPriority High +@SYMTestActions Create two implementation from the SAME DLL using new Dll type PLUGIN3. + Test executes by getting the CUnloadPolicy* associated to the testing DLL EComExample10.dll. + DestroyThis will actually either remove the UnloadPolicy from the list or decrease + referencecount(to UnloadPolicy) by one. +@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls + One UnloadPolicy since both Implementation is based on SAME DLL + Two Instance indexes because of two Different Implementations +@SYMEC EC43 +*/ +void CLoadManagerTest::CreateDestroyTestCase2Plugin3L() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3553 ")); + TUid implUid1 = {0x10009E38}; + TUid implUid2 = {0x10009E3A}; + + TUid dllUid; + dllUid.iUid = 0x10009E37; + + CreateDestroyTestCase2L(dllUid,implUid1,KExampleDllFileName10,implUid2,KUidInterfaceImplementationCollection3); + } + + +//Test case 3:Invalid argument testing for Create Implementation +// - Invalid Entry and Implementation uid argument in ImplementationObjectL + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-0703 +@SYMTestCaseDesc Tests for create CLoadManager +@SYMTestPriority High +@SYMTestActions Passing invalid Entry and Implementation uid argument in ImplementationObjectL +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +void CLoadManagerTest::CreateDestroyTestCase3L() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0703 ")); + TUid invalidUid={0x10007777}; + + //Try supplying invalid implementaion Uid and invalid entry argument + TUid dllUid; + dllUid.iUid = 0; + + TEntry invalidentry; + invalidentry.iName=_L("Z:\\system\\LIBS\\PLUGINS\\EComExample9.dll"); + invalidentry.iModified=TTime(0); + invalidentry.iType=TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection,dllUid); + + TBool initParamsFlag = ETrue; + + TUid instanceKey; + TRAPD(err,iLoadManager->ImplementationObjectL(invalidUid,invalidentry, NULL,initParamsFlag,instanceKey)); + ::LeaveIfErrNoMemory(err); + //It will return KErrNotFound as the DLL is invalid + TEST2(err,KErrNotFound); + + //Checking the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==0); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==0); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL); + } + +/** +@SYMTestCaseID SYSLIB-ECOM-UT-3554 +@SYMTestCaseDesc Invalid argument testing for Create Implementation using new DLL type PLUGIN3 +@SYMTestPriority High +@SYMTestActions Passing invalid Entry and Implementation uid argument in ImplementationObjectL +@SYMTestExpectedResults KErrNotFound will be returned as the DLL is invalid +@SYMEC EC43 +*/ +void CLoadManagerTest::CreateDestroyTestCase3Plugin3L() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3554 ")); + // this implementation(0x10009E48) is implemented in EComExample14Upgraded.dll, not in EComExample10.dll + TUid implementationUid = {0x10009E48}; + + //Try supplying invalid implementaion Uid and invalid entry argument + TUid dllUid; + dllUid.iUid = 0; + + // Invalid entry for EComExample14Upgraded.dll, because it is not under Z:\\system\\LIBS\\PLUGINS + TEntry invalidentry; + invalidentry.iName = _L("Z:\\system\\LIBS\\PLUGINS\\EComExample14Upgraded.dll"); + invalidentry.iModified = TTime(0); + invalidentry.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid); + + TUid dllUid1; + dllUid1.iUid = 0x10009E37; + // Valid entry for EComExample10.dll + TEntry entry; + entry.iName = KExampleDllFileName10; + entry.iModified = TTime(0); + entry.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid1); + TBool initParamsFlag = ETrue; + + // Test for valid implementation Uid with invalid entry. + TUid instanceKey; + TRAPD(err,iLoadManager->ImplementationObjectL(implementationUid,invalidentry, NULL,initParamsFlag,instanceKey)); + ::LeaveIfErrNoMemory(err); + //Returns KErrNotFound as the DLL is invalid + TEST2(err,KErrNotFound); + //Checks the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==0); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==0); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL); + + // Tests for invalid implementation Uid with valid entry. + TRAP(err,iLoadManager->ImplementationObjectL(implementationUid,entry, NULL,initParamsFlag,instanceKey)); + ::LeaveIfErrNoMemory(err); + //Returns KErrNotFound as the implementation Uid is not within the DLL + TEST2(err,KErrNotFound); + + //Checks the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL); + } + +//Test case 4:Create two instance of the same implementation Uid from one single DLL + +void CLoadManagerTest::CreateDestroyTestCase4L(TUid aDllUid, + TUid aImplUid, + const TDesC& aDllName, + const TUid aIICType) + { + TInt err; + TEntry entry; + entry.iName=aDllName; + entry.iModified=TTime(0); + entry.iType=TUidType(KDynamicLibraryUid,aIICType,aDllUid); + + CExampleInterface::TExampleInterfaceInitParams iInitParams; + iInitParams.integer = 5; + TBool initParamsFlag = ETrue; + _LIT(KDummyText,"Dummy params"); + iInitParams.descriptor = &KDummyText; + TAny* impl1=NULL; + TAny* impl2=NULL; + + //Create 1st instance of implementation + TUid instanceKey; + TRAP(err,impl1=iLoadManager->ImplementationObjectL(aImplUid,entry, &iInitParams,initParamsFlag,instanceKey)); + ::LeaveIfErrNoMemory(err); + TEST2(err,KErrNone); + + //Checking the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==1); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==1); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL); + + //Create 2nd instance of the same implementation + TUid instanceKey2; + TRAP(err,impl2=iLoadManager->ImplementationObjectL(aImplUid,entry, &iInitParams,initParamsFlag,instanceKey2)); + // If impl2 fails here due to KErrNoMemory we need to clear the previous impl1 + // to avoid memory leak + if (err==KErrNoMemory) + { + iLoadManager->DestroyedThis(instanceKey); + delete (CExampleInterface*)impl1; + impl1=NULL; + ::LeaveIfErrNoMemory(err); + } + + TEST(err==KErrNone); + + //Checking the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==2); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==1); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL); + + //Destroyed the 2nd instance of implementation + iLoadManager->DestroyedThis(instanceKey2); + delete (CExampleInterface*)impl2; + impl2=NULL; + + //Checking the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==1); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==1); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL); + + //Destroyed the 1st instance of implementation + iLoadManager->DestroyedThis(instanceKey); + delete (CExampleInterface*)impl1; + impl1=NULL; + + //Checking the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==0); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==0); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)!=NULL); + + iLoadManager->ClearGarbage(); + //Checking the final state of the garbage policy + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL); + } + + +/** +Plugins used: +- Z:\\..\\EComExample2.dll contains ImplUid 0x10009DC3 & 0x10009DC4 + +@SYMTestCaseID SYSLIB-ECOM-CT-0704 +@SYMTestCaseDesc Tests for create and delete of CLoadManager +@SYMTestPriority High +@SYMTestActions Create two instance of the same implementation Uid from one single DLL +@SYMTestExpectedResults CLoadManager only maintains a single UnloadPolicy and one policy + mapping index +@SYMREQ REQ0000 +*/ +void CLoadManagerTest::CreateDestroyTestCase4Plugin1L() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0704 ")); + TUid implUid={0x10009DC3}; + + TUid dllUid; + dllUid.iUid = 0x10009DB3; + + CreateDestroyTestCase4L(dllUid,implUid,KExampleDllFileName2,KUidInterfaceImplementationCollection); + } + +/** +@SYMTestCaseID SYSLIB-ECOM-UT-3555 +@SYMTestCaseDesc Create two instance of the same implementation Uid from one single DLL using PLUGIN3 + Plugins used: + - Z:\\..\\EComExample10.dll contains ImplUid 0x10009E38 & 0x10009E3A +@SYMTestPriority High +@SYMTestActions Create two instance of the same implementation Uid from one single DLL +@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls + CLoadManager only maintains a single UnloadPolicy and one instance +@SYMEC EC43 +*/ +void CLoadManagerTest::CreateDestroyTestCase4Plugin3L() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3555 ")); + TUid implUid={0x10009E38}; + + TUid dllUid; + dllUid.iUid = 0x10009E37; + + CreateDestroyTestCase4L(dllUid,implUid,KExampleDllFileName10,KUidInterfaceImplementationCollection3); + } + + +// Test case 5: DEF101930: Incorrect policy object returned in + + +void CLoadManagerTest::CreateDestroyTestCase5L(TUid aDllUid1, + TUid aImplUid1, + const TDesC& aDllName1, + TUid aDllUid2, + TUid aImplUid2, + const TDesC& aDllName2, + TUid aImplUid3, + const TUid aIICType) + { + CExampleInterface::TExampleInterfaceInitParams iInitParams; + iInitParams.integer = 5; + TBool initParamsFlag = ETrue; + _LIT(KDummyText,"Dummy params"); + iInitParams.descriptor = &KDummyText; + TAny* impl1 = NULL; + TAny* impl2 = NULL; + TAny* impl3 = NULL; + + TEntry entryExample1; + entryExample1.iName = aDllName1; + entryExample1.iModified = TTime(0); + entryExample1.iType = TUidType(KDynamicLibraryUid,aIICType,aDllUid1); + + TEntry entryExample2; + entryExample2.iName = aDllName2; + entryExample2.iModified = TTime(0); + entryExample2.iType = TUidType(KDynamicLibraryUid,aIICType,aDllUid2); + + TInt err; + TUid instanceKey2; + + //Create Implementation 2 + TRAP(err,impl2 = iLoadManager->ImplementationObjectL(aImplUid2,entryExample1, &iInitParams,initParamsFlag,instanceKey2)); + ::LeaveIfErrNoMemory(err); + TEST(err == KErrNone); + //Checking the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + + TUid instanceKey3; + //Create Implementation 3 + TRAP(err,impl3 = iLoadManager->ImplementationObjectL(aImplUid3,entryExample2, &iInitParams,initParamsFlag,instanceKey3)); + // If impl3 fails here due to KErrNoMemory we need to clear the previous impl2 + // to avoid memory leak + if (err == KErrNoMemory) + { + iLoadManager->DestroyedThis(instanceKey2); + delete (CExampleInterface*)impl2; + impl2 = NULL; + ::LeaveIfErrNoMemory(err); + } + TEST2(err,KErrNone); + + //Checking the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 2); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 2); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + + //Create Implementation 1 + TUid instanceKey1; + TRAP(err,impl1 = iLoadManager->ImplementationObjectL(aImplUid1,entryExample1, &iInitParams,initParamsFlag,instanceKey1)); + // If impl1 fails here due to KErrNoMemory we need to clear the previous impl2 and impl3 + // to avoid memory leak + if (err == KErrNoMemory) + { + iLoadManager->DestroyedThis(instanceKey2); + delete (CExampleInterface*)impl2; + impl2=NULL; + iLoadManager->DestroyedThis(instanceKey3); + delete (CExampleInterface*)impl3; + impl3=NULL; + ::LeaveIfErrNoMemory(err); + } + TEST2(err,KErrNone); + + //Checking the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 3); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 2); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + + //Destroy Implementation 1 + iLoadManager->DestroyedThis(instanceKey1); + delete (CExampleInterface*)impl1; + impl1 = NULL; + + //Destroy Implementation 2 + iLoadManager->DestroyedThis(instanceKey2); + delete (CExampleInterface*)impl2; + impl2 = NULL; + + //Destroy Implementation 3 + iLoadManager->DestroyedThis(instanceKey3); + delete (CExampleInterface*)impl3; + impl3 = NULL; + + //Checking the state of the arrays inside CLoadManager and the garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL); + + iLoadManager->ClearGarbage(); + + //Checking the final state of the garbage policy + //Test for the new API ClearGarbage() + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + + } + +/** +Plugins used: +- Z:\\..\\EComLoadMgrExample1.dll contains ImplUid 0x10282332 & 0x10282334 +- Z:\\..\\EComLoadMgrExample2.dll contains ImplUid 0x10282333 + +@SYMTestCaseID SYSLIB-ECOM-UT-3372 +@SYMTestCaseDesc This testcase checks for the case where 2 implementations + are created each on separate DLL's then an additional + implementation is created from one of the already loaded DLL's. + The impl uid of the newly created impl is lower then the 2 + existing impl uids. The impl uids from the same DLL are such + that 1 is higher then the uid of the other impl and 1 is lower than + the other impl. +@SYMTestPriority High +@SYMTestActions Load impls 0x10282333 and 0x10282334 first and then load impl + 0x10282332. +@SYMTestExpectedResults Leave with KErrNotFound must not occur. + Policy and unload policy counts must be updated + as described in the test. +@SYMDEF DEF101930 +*/ +void CLoadManagerTest::CreateDestroyTestCase5Plugin1L() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3372 ")); + TUid implUid1={0x10282332}; + TUid implUid2={0x10282334}; + TUid implUid3={0x10282333}; + + TUid dllUidExample1; + dllUidExample1.iUid = 0x10282330; + + TUid dllUidExample2; + dllUidExample2.iUid = 0x10282335; + + CreateDestroyTestCase5L(dllUidExample1, + implUid1, + KLoadMgrExample1DllName, + dllUidExample2, + implUid2, + KLoadMgrExample2DllName, + implUid3, + KUidInterfaceImplementationCollection); + } + +/** +@SYMTestCaseID SYSLIB-ECOM-UT-3556 +@SYMTestCaseDesc DEF101930: Incorrect policy object returned in + This testcase checks for the case where 2 implementations + are created each on separate DLL's then an additional + implementation is created from one of the already loaded DLL's. + The impl uid of the newly created impl is lower then the 2 + existing impl uids. The impl uids from the same DLL are such + that 1 is higher then the uid of the other impl and 1 is lower than + the other impl. DEF101930: Incorrect policy object returned in + + Plugins used: + - Z:\\..\\EComExample10.dll contains ImplUid 0x10009E38 & 0x10009E3A + - Z:\\..\\EComExample12.dll contains ImplUid 0x10009E39 +@SYMTestPriority High +@SYMTestActions Load impls 0x10009E3A and 0x10009E39 first and then load impl 0x10009E38. +@SYMTestExpectedResults Leave with KErrNotFound must not occur. + Policy and unload policy counts must be updated + as described in the test. +@SYMEC EC43 (tested for PLUGIN3 too now, copied from UT-3372) +*/ +void CLoadManagerTest::CreateDestroyTestCase5Plugin3L() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3556 ")); + TUid implUid1={0x10009E38}; + TUid implUid2={0x10009E3A}; + TUid implUid3={0x10009E39}; + + TUid dllUidExample1; + dllUidExample1.iUid = 0x10009E37; + + TUid dllUidExample2; + dllUidExample2.iUid = 0x10009E3E; + + CreateDestroyTestCase5L(dllUidExample1, + implUid1, + KExampleDllFileName10, + dllUidExample2, + implUid2, + KExampleDllFileName12, + implUid3, + KUidInterfaceImplementationCollection3); + } + + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-0705 +@SYMTestCaseDesc Tests for production class CLoadManager +@SYMTestPriority High +@SYMTestActions Check for null condition while creating a new CLoadManagerTest object. +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +LOCAL_C void CreateDeleteTestL() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0705 CreateDeleteTestL ")); + + // + // Tests the Creating and deletion of CLoadManager + // ------------------------------------------------------------------ + // + // Set up for heap leak checking + __UHEAP_MARK; + + TInt startProcessHandleCount = 0; + TInt startThreadHandleCount = 0; + TInt endProcessHandleCount = 0; + TInt endThreadHandleCount = 0; + + RThread rThread; + rThread.HandleCount(startProcessHandleCount, startThreadHandleCount); + + //CREATE DELETE TEST START// + + CLoadManagerTest* loadManagerTest = CLoadManagerTest::NewL(); + + TEST(loadManagerTest != NULL); + + delete loadManagerTest; + + //CREATE DELETE TEST END// + + rThread.HandleCount(endProcessHandleCount, endThreadHandleCount); + TEST(startThreadHandleCount == endThreadHandleCount); + + __UHEAP_MARKEND; + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-0706 +@SYMTestCaseDesc OOM test while creating and deleting CLoadManager +@SYMTestPriority High +@SYMTestActions Create and delete CLoadManager object and test that no handles have leaked +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +LOCAL_C void OOMCreateDeleteTest() + { + // + // Out of memory test + // ------------------------------------------------------------------ + // + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0706 OOMCreateDeleteTest ")); + TInt err; + TInt failAt = 1; + __UNUSED_VAR(failAt); + + CLoadManagerTest* loadManagerTest = NULL; + + do + { + __UHEAP_MARK; + // find out the number of open handles + TInt startProcessHandleCount; + TInt startThreadHandleCount; + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount); + + // Setting Heap failure for OOM test + __UHEAP_SETFAIL(RHeap::EDeterministic, failAt++); + + TRAP(err, loadManagerTest = CLoadManagerTest::NewL()); + + __UHEAP_SETFAIL(RHeap::ENone, 0); + + delete loadManagerTest; + loadManagerTest = NULL; + + // check that no handles have leaked + TInt endProcessHandleCount; + TInt endThreadHandleCount; + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount); + + TEST(startProcessHandleCount == endProcessHandleCount); + TEST(startThreadHandleCount == endThreadHandleCount); + + __UHEAP_MARKEND; + } + while (err == KErrNoMemory); + + TheTest.Printf(_L("- Succeeded at heap failure rate of %i\n"), failAt); + TEST(err == KErrNone); + } + +/** +@SYMTestCaseID SYSLIB-ECOM-UT-3557 +@SYMTestCaseDesc This testcase tests fetching extended interfaces for ImplUid 0x10009E38. + One interface will be the part of the main implementation object, the + second interface will be a separate interface requiring release. Also tests + that the extended interfaces are automatically destroyed. + + Plugins used: + - Z:\\..\\EComExample10.dll contains ImplUid 0x10009E38 with extended interface + 0x10009E44, 0x10009E45 and 0x10009E46 +@SYMTestPriority High +@SYMTestActions This testcase will test one implementation with two extended interfaces. + Create implementation, then fetch extended interface 0x10009E44. Secondly, + fetch 0x10009E45 interface. This will be a separate interface requiring release. + Destroy the interfaces. + Attempt fetch of interface again. Expect Leave with KErrNotFound as implementation + no longer exists. +@SYMTestExpectedResults Extended instance count will be zero for 0x10009E44 extended interface, + 0x10009E45 will have an extended instance count of one. No memory leaks + after implementation, including extended interfaces are automatically + destroyed. +@SYMEC EC43 +@SYMDEF DEF111553 +*/ +void CLoadManagerTest::ExtendedMethodTest1Plugin3L() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3557 ")); + CExampleInterface::TExampleInterfaceInitParams iInitParams; + iInitParams.integer = 5; + TBool initParamsFlag = ETrue; + _LIT(KDummyText,"Dummy params"); + iInitParams.descriptor = &KDummyText; + TUid dllUid; + dllUid.iUid = 0x10009E37; + + TEntry entry; + entry.iName = KExampleDllFileName10; + entry.iModified = TTime(0); + entry.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid); + + iImplementationUid.iUid = 0x10009E38; + + CExampleInterface* implementationPtr = 0; + TUid instanceKey; + TRAPD(err, implementationPtr = reinterpret_cast(iLoadManager->ImplementationObjectL(iImplementationUid, entry,&iInitParams, initParamsFlag,instanceKey))); + + ::LeaveIfErrNoMemory(err); + TEST2(err,KErrNone); + TEST(implementationPtr != 0); + + CleanupStack::PushL(implementationPtr); + + //Checks the state of the arrays inside CLoadManager and garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + + //Checks the instance index and UnloadPolicy info + TEST(iStateAccessor.InstanceIndex(0,*iLoadManager)->ImplementationUid() == iImplementationUid); + TEST(iStateAccessor.UnloadPolicy(0,*iLoadManager)->DllEntryInformation().GetName().CompareF(KExampleDllFileName10) == 0); + + // Call extended interface here. + const TUid KExample10InterfaceUid1 = {0x10009E44}; // Part of main interface + const TUid KExample10InterfaceUid2 = {0x10009E45}; // Separate interface + + MExampleInterfaceExtended* ext1 = static_cast(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid1 )); + // Extended interface part of main interface, so no extended object info is needed to be created. + TEST2(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager),0); + ext1->DoMethodExtended(); + + MExampleInterfaceExtended2* ext2 = static_cast(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid2 )); + // Separate extended interface, so there will be an extended object info created to track + // this extended interface so it can be deleted later when the extended interface is no + // longer needed. + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager)==1); + ext2->DoMethodExtended2(); + + CleanupStack::PopAndDestroy(implementationPtr); + implementationPtr = 0; + iLoadManager->DestroyedThis(instanceKey); + iLoadManager->ClearGarbage(); + //Checks the state of the arrays inside CLoadManager and garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + + // call again now that implementation has been removed. Expecting a Leave + TRAP(err, iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid2 )); + TEST2(err, KErrNotFound); + } + +/** +@SYMTestCaseID SYSLIB-ECOM-UT-3558 +@SYMTestCaseDesc This testcase tests fetching extended interfaces for ImplUid 0x10009E38. + One interface will be the part of the main implementation object, the + second interface will be a separate interface requiring release. Tests + that manual release successful for interface requiring release. Tests + no memory leaks, and no double release of manually released interface. + + Plugins used: + - Z:\\..\\EComExample10.dll contains ImplUid 0x10009E38 with extended interface + 0x10009E44, 0x10009E45 and 0x10009E46 +@SYMTestPriority High +@SYMTestActions This testcase will test one implementation with two extended interfaces. + Create implementation, then fetch extended interface 0x10009E44. Secondly, + fetch 0x10009E45 interface. This will be a separate interface requiring release. + Manually release extended interface. Destroy the interfaces. + Attempt fetch of interface again. Expect Leave with KErrNotFound as implementation + no longer exists. +@SYMTestExpectedResults Extended instance count will be zero for 0x10009E44 extended interface, + 0x10009E45 will have an extended instance count of one. After manual + release, the extended interface count will be zero. No memory leaks after + implementation, including extended interfaces are automatically destroyed. + No double release of extended interface already manually released. +@SYMEC EC43 +@SYMDEF DEF111553 +*/ +void CLoadManagerTest::ExtendedMethodTest2Plugin3L() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3558 ")); + CExampleInterface::TExampleInterfaceInitParams iInitParams; + iInitParams.integer = 5; + TBool initParamsFlag = ETrue; + _LIT(KDummyText,"Dummy params"); + iInitParams.descriptor = &KDummyText; + TUid dllUid; + dllUid.iUid = 0x10009E37; + + TEntry entry; + entry.iName = KExampleDllFileName10; + entry.iModified = TTime(0); + entry.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid); + + iImplementationUid.iUid = 0x10009E38; + + CExampleInterface* implementationPtr = 0; + TUid instanceKey; + TRAPD(err, implementationPtr = reinterpret_cast(iLoadManager->ImplementationObjectL(iImplementationUid, entry,&iInitParams, initParamsFlag,instanceKey))); + + ::LeaveIfErrNoMemory(err); + TEST2(err,KErrNone); + TEST(implementationPtr != 0); + + CleanupStack::PushL(implementationPtr); + + //Checks the state of the arrays inside CLoadManager and garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + + //Checks the instance index and UnloadPolicy info + TEST(iStateAccessor.InstanceIndex(0,*iLoadManager)->ImplementationUid() == iImplementationUid); + TEST(iStateAccessor.UnloadPolicy(0,*iLoadManager)->DllEntryInformation().GetName().CompareF(KExampleDllFileName10) == 0); + + // Call extended interface here. + const TUid KExample10InterfaceUid1 = {0x10009E44}; + const TUid KExample10InterfaceUid2 = {0x10009E45}; // separate interface object + + MExampleInterfaceExtended* ext1 = static_cast(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid1 )); + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 0); // Does not need to be released, so will not be added to extended object array + ext1->DoMethodExtended(); + + MExampleInterfaceExtended2* ext2 = static_cast(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid2 )); + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 1); // Needs to be released + ext2->DoMethodExtended2(); + + iLoadManager->ManuallyReleaseExtendedInterfaceL(instanceKey, KExample10InterfaceUid2); + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 0); + + CleanupStack::PopAndDestroy(implementationPtr); + implementationPtr = 0; + iLoadManager->DestroyedThis(instanceKey); + iLoadManager->ClearGarbage(); + //Checks the state of the arrays inside CLoadManager and garbage policy + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0); + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0); + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL); + + // call again now that implementation has been removed. Expecting a Leave + TRAP(err, iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid2 )); + TEST2(err, KErrNotFound); + } + +/** +@SYMTestCaseID SYSLIB-ECOM-UT-3711 +@SYMTestCaseDesc This testcase tests ManuallyReleaseExtendedInterfaces function for releasing + extended interface which require release and releasing extended interface + which doesn't require release. Also tests for releasing same extended interface twice + + Plugins used: + - Z:\\..\\EComExample10.dll contains ImplUid 0x10009E38 with extended interface + 0x10009E44, 0x10009E45 and 0x10009E46 +@SYMTestPriority High +@SYMTestActions This testcase will do the tests as below: + 1. create implementation 0x10009E38. + 2. Get extended interface 0x10009E44,0x10009E45 and 0x10009E46. + 3. Manually release extended interface 0x10009E44 which does not require release. + 4. Manually release extended interface 0x10009E45 which require manually release. + 5. Again manually release extended interface 0x10009E45 which require manually release. + 6. Manually release extended interface 0x10009E46 which require manually release. + 7. Destroy the interfaces + 8. Attempt fetch manual release again. Expect Leave with KErrNotFound as implementation + no longer exists. +@SYMTestExpectedResults Extended instance count is set correctly. +@SYMDEF DEF111196 +@SYMDEF DEF111553 +*/ +void CLoadManagerTest::ManuallyReleaseExtendedInterfaceTestL() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3711 ")); + CExampleInterface::TExampleInterfaceInitParams iInitParams; + iInitParams.integer = 5; + TBool initParamsFlag = ETrue; + _LIT(KDummyText,"Dummy params"); + iInitParams.descriptor = &KDummyText; + TUid dllUid; + dllUid.iUid = 0x10009E37; + + TEntry entry; + entry.iName = KExampleDllFileName10; + entry.iModified = TTime(0); + entry.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid); + + iImplementationUid.iUid = 0x10009E38; + + CExampleInterface* implementationPtr = 0; + TUid instanceKey; + TRAPD(err, implementationPtr = reinterpret_cast(iLoadManager->ImplementationObjectL(iImplementationUid, entry,&iInitParams, initParamsFlag,instanceKey))); + + ::LeaveIfErrNoMemory(err); + TEST2(err,KErrNone); + TEST(implementationPtr != 0); + + CleanupStack::PushL(implementationPtr); + + const TUid KExample10InterfaceUid1 = {0x10009E44}; + const TUid KExample10InterfaceUid2 = {0x10009E45}; // separate interface object + const TUid KExample10InterfaceUid3 = {0x10009E46}; // separate interface object + + // Gets extended interface 0x10009E44 + MExampleInterfaceExtended* ext1 = static_cast(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid1 )); + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 0); // Does not need to be released, so will not be added to extended object array + + // Gets extended interface 0x10009E45 + MExampleInterfaceExtended2* ext2 = static_cast(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid2 )); + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 1); // Needs to be released + + // Gets extended interface 0x10009E46 + MExampleInterfaceExtended2* ext3 = static_cast(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid3 )); + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 2); // Needs to be released + + // call ManuallyReleaseExtendedInterface for 0x10009E44. + // Nothing would happen because 0x10009E44 is not require release. + iLoadManager->ManuallyReleaseExtendedInterfaceL(instanceKey, KExample10InterfaceUid1); + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 2); + + // call ManuallyReleaseExtendedInterface for 0x10009E45. + // extended instance count would be 1 + iLoadManager->ManuallyReleaseExtendedInterfaceL(instanceKey, KExample10InterfaceUid2); + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 1); + + // call ManuallyReleaseExtendedInterface again, nothing would happen because 0x10009E45 has been released. + iLoadManager->ManuallyReleaseExtendedInterfaceL(instanceKey, KExample10InterfaceUid2); + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 1); + + // call ManuallyReleaseExtendedInterface for 0x10009E46. + // extended instance count would be 0 + iLoadManager->ManuallyReleaseExtendedInterfaceL(instanceKey, KExample10InterfaceUid3); + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 0); + + CleanupStack::PopAndDestroy(implementationPtr); + implementationPtr = 0; + iLoadManager->DestroyedThis(instanceKey); + iLoadManager->ClearGarbage(); + + // call again now that implementation has been removed. Expecting a Leave + TRAP(err, iLoadManager->ManuallyReleaseExtendedInterfaceL(instanceKey, KExample10InterfaceUid3 )); + TEST2(err, KErrNotFound); + } + + + +typedef void (CLoadManagerTest::*ClassFuncPtrL) (void); + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-0707 +@SYMTestCaseDesc Wrapper function to call all test functions +@SYMTestPriority High +@SYMTestActions Calls up CLoadManagerTest's test function. +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +/** +Wrapper function to call all test functions + +@param testFuncL pointer to test function +@param aTestDesc test function name +*/ +LOCAL_C void DoBasicTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc) + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0707 ")); + TheTest.Next(aTestDesc); + + __UHEAP_MARK; + // find out the number of open handles + TInt startProcessHandleCount; + TInt startThreadHandleCount; + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount); + + CLoadManagerTest* loadManagerTest = CLoadManagerTest::NewL(); + CleanupStack::PushL(loadManagerTest); + + (loadManagerTest->*testFuncL)(); + + CleanupStack::PopAndDestroy(loadManagerTest); + + // check that no handles have leaked + TInt endProcessHandleCount; + TInt endThreadHandleCount; + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount); + + TEST(startProcessHandleCount == endProcessHandleCount); + TEST(startThreadHandleCount == endThreadHandleCount); + + __UHEAP_MARKEND; + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-0708 +@SYMTestCaseDesc Function to call all OOM test functions +@SYMTestPriority High +@SYMTestActions Calls up all test functions for OOM test. +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +/** +Wrapper function to call all OOM test functions + +@param testFuncL pointer to OOM test function +@param aTestDesc test function name +*/ +LOCAL_C void DoOOMTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc) + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0708 ")); + TheTest.Next(aTestDesc); + + TInt err, tryCount = 0; + do + { + __UHEAP_MARK; + // find out the number of open handles + TInt startProcessHandleCount; + TInt startThreadHandleCount; + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount); + + CLoadManagerTest* loadManagerTest = CLoadManagerTest::NewL(); + CleanupStack::PushL(loadManagerTest); + + // Setting Heap failure for OOM test + __UHEAP_SETFAIL(RHeap::EDeterministic, ++tryCount); + + TRAP(err, (loadManagerTest->*testFuncL)()); + + __UHEAP_SETFAIL(RHeap::ENone, 0); + + CleanupStack::PopAndDestroy(loadManagerTest); + loadManagerTest = NULL; + + // check that no handles have leaked + TInt endProcessHandleCount; + TInt endThreadHandleCount; + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount); + + TEST(startProcessHandleCount == endProcessHandleCount); + TEST(startThreadHandleCount == endThreadHandleCount); + + __UHEAP_MARKEND; + } while(err == KErrNoMemory); + + TEST(err == KErrNone); + TheTest.Printf(_L("- server succeeded at heap failure rate of %i\n"), tryCount); + } + +void DoTestL() + { + __UHEAP_MARK; + + // Basic tests + CreateDeleteTestL(); + DoBasicTestL(&CLoadManagerTest::InstantiationMethodTestPlugin1L, _L("InstantiationMethodTestPlugin1L")); + DoBasicTestL(&CLoadManagerTest::DestroyThisTestPlugin1L, _L("DestroyThisTestPlugin1L")); + DoBasicTestL(&CLoadManagerTest::GetImplementationUidTestL, _L("GetImplementationUidTestL")); + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase1Plugin1L,_L("Create Destroy Test case 1")); + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase2Plugin1L,_L("Create Destroy Test case 2")); + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase3L,_L("Create Destroy Test case 3")); + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase4Plugin1L,_L("Create Destroy Test case 4")); + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase5Plugin1L,_L("Create Destroy Test case 5")); + + DoBasicTestL(&CLoadManagerTest::InstantiationMethodTestPlugin3L, _L("InstantiationMethodTest3L")); + DoBasicTestL(&CLoadManagerTest::DestroyThisTestPlugin3L, _L("DestroyThisTest3L")); + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase1Plugin3L,_L("Create Destroy Test case 1,Plugin3")); + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase2Plugin3L,_L("Create Destroy Test case 2")); + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase3Plugin3L,_L("Create Destroy Test case 3")); + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase4Plugin3L,_L("Create Destroy Test case 4")); + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase5Plugin3L,_L("Create Destroy Test case 5")); + + //Create an implementation from a PLUGIN dll and one from a PLUGIN3 dll also. + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase1PluginAndPlugin3L,_L("CreateDestroyTestCase1PluginAndPlugin3L")); + + // Get and Release extended interfaces + DoBasicTestL(&CLoadManagerTest::ExtendedMethodTest1Plugin3L,_L("ExtendedMethodTest1Plugin3L")); + DoBasicTestL(&CLoadManagerTest::ExtendedMethodTest2Plugin3L,_L("ExtendedMethodTest2Plugin3L")); + DoBasicTestL(&CLoadManagerTest::ManuallyReleaseExtendedInterfaceTestL,_L("ManuallyReleaseExtendedInterfaceTestL")); + + DoBasicTestL(&CLoadManagerTest::ImplementationObjectTestL,_L("ImplementationObjectTestL")); + + + OOMCreateDeleteTest(); + + DoOOMTestL(&CLoadManagerTest::InstantiationMethodTestPlugin1L, _L("OOM InstantiationMethodTestPlugin1L")); + DoOOMTestL(&CLoadManagerTest::DestroyThisTestPlugin1L, _L("OOM DestroyThisTestPlugin1L")); + DoOOMTestL(&CLoadManagerTest::GetImplementationUidTestL, _L("OOM GetImplementationUidTestL")); + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase1Plugin1L,_L("OOM Create Destroy Test case 1")); + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase2Plugin1L,_L("OOM Create Destroy Test case 2")); + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase3L,_L("OOM Create Destroy Test case 3")); + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase4Plugin1L,_L("OOM Create Destroy Test case 4")); + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase5Plugin1L,_L("OOM Create Destroy Test case 5")); + + DoOOMTestL(&CLoadManagerTest::InstantiationMethodTestPlugin3L, _L("OOM InstantiationMethodTest3L")); + DoOOMTestL(&CLoadManagerTest::DestroyThisTestPlugin3L, _L("OOM DestroyThisTest3L")); + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase1Plugin3L,_L("OOM Create Destroy Test case 1,Plugin3")); + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase2Plugin3L,_L("OOM Create Destroy Test case 2")); + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase3Plugin3L,_L("OOM Create Destroy Test case 3")); + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase4Plugin3L,_L("OOM Create Destroy Test case 4")); + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase5Plugin3L,_L("OOM Create Destroy Test case 5")); + + //Create an implementation from a PLUGIN dll and one from a PLUGIN3 dll also. + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase1PluginAndPlugin3L,_L("OOM CreateDestroyTestCase1PluginAndPlugin3L")); + + // Get and Release extended interfaces + DoOOMTestL(&CLoadManagerTest::ExtendedMethodTest1Plugin3L,_L("OOM ExtendedMethodTest1Plugin3L")); + DoOOMTestL(&CLoadManagerTest::ExtendedMethodTest2Plugin3L,_L("OOM ExtendedMethodTest2Plugin3L")); + DoOOMTestL(&CLoadManagerTest::ManuallyReleaseExtendedInterfaceTestL,_L("OOM ManuallyReleaseExtendedInterfaceTestL")); + + __UHEAP_MARKEND; + } + +//Leave if aError < 0 with info message printed out +LOCAL_C void LeaveIfError(TInt aError, TInt aLine) + { + if(aError < KErrNone) + { + ::Leave(aError, aLine); + } + } + +#define LEAVE_IF_ERROR(aError) ::LeaveIfError(aError, __LINE__) +// +// Copies the Plugins to specific folder for testing purpose +// +LOCAL_C void CopyPlugins() + { + // Connect the file server instance + LEAVE_IF_ERROR(TheFs.Connect()); + + TRAPD(err, EComTestUtils::FileManCopyFileL(KResourceFileName5OnZ, KResourceFileName5)); + TEST(err==KErrNone); + + TRAP(err, EComTestUtils::FileManCopyFileL(KExampleDllFileName5OnZ, KExampleDllFileName5)); + TEST(err==KErrNone); + + TRAP(err, EComTestUtils::FileManCopyFileL(KResourceFileName12OnZ, KResourceFileName12)); + TEST(err==KErrNone); + + TRAP(err, EComTestUtils::FileManCopyFileL(KExampleDllFileName12OnZ, KExampleDllFileName12)); + TEST(err==KErrNone); + } + +// Deleting plugin from the RAM for cleanup purpose +LOCAL_C void DeleteTestPlugin() + { + TRAPD(err, EComTestUtils::FileManDeleteFileL(KResourceFileName5)); + TRAP(err, EComTestUtils::FileManDeleteFileL(KExampleDllFileName5)); + TRAP(err, EComTestUtils::FileManDeleteFileL(KResourceFileName12)); + TRAP(err, EComTestUtils::FileManDeleteFileL(KExampleDllFileName12)); + } + +// +//Initialise the Active Scheduler +// +LOCAL_C void SetupL() + { + // Construct and install the Active Scheduler. The Active Schedular is needed + // by components used by this test as they are ActiveObjects. + TheActiveScheduler = new(ELeave)CActiveScheduler; + CActiveScheduler::Install(TheActiveScheduler); + } + +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + + TheTest.Printf(_L("\n")); + TheTest.Title(); + TheTest.Start( _L("LoadManager Tests.") ); + + TheTrapCleanup = CTrapCleanup::New(); + + TRAPD(err, SetupL()); + TEST(err == KErrNone); + + CopyPlugins(); + // The reason for the folowing delay is: + // ECOM server could be already started. It means that when we copy some + // ECOM plugins from Z: to C: drive - ECOM server should look for and + // find the new ECOM plugins. The ECOM server uses for that an active object, + // which scans plugin directories. So the discovering service is asynchronous. + // We have to wait some time until it finishes. + // Otherwise ListImplementationsL could fail to find requested implementations. + User::After(KOneSecond * 3); + + //Call the main tess + TRAP(err, DoTestL()); + TEST2(err,KErrNone); + + // Cleanup files. If the cleanup fails that is no problem, + // as any subsequent tests will replace them. The only downside + // would be the disk not being tidied + DeleteTestPlugin(); + + TheFs.Close(); + + delete TheActiveScheduler; + delete TheTrapCleanup; + + TheTest.End(); + TheTest.Close(); + + __UHEAP_MARKEND; + return KErrNone; + }