1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/lowlevellibsandfws/pluginfw/Framework/LoadManagerTest/t_loadmanager.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,2112 @@
1.4 +// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +// This file contains test classes and their implementations
1.18 +// to test production class CLoadManager. Where necessary stubs
1.19 +// are implemented to help in writing test harness using RTest.
1.20 +// Plugins available to be used in this test
1.21 +// Interface UID DLL UID Implementation UID Version DllFile
1.22 +// 0x10009DC0 0x10009DB1 0x10009DC3 1 Z:\\..\\EComExample.dll
1.23 +// 0x10009DB1 0x10009DC4 1 Z:\\..\\EComExample.dll
1.24 +// 0x10009DB3 0x10009DC3 2 Z:\\..\\EComExample2.dll
1.25 +// 0x10009DB3 0x10009DC4 2 Z:\\..\\EComExample2.dll
1.26 +// 0x101F8477 0x101F8478 1 Z:\\..\\EComExample3.dll
1.27 +// 0x101F8479 0x101F847A 1 Z:\\..\\EComExample4.dll
1.28 +// 0x101F847B 0x101F847C 1 C:\\..\\EComExample5.dll
1.29 +// 0x10282331 0x10282330 0x10282332 1 Z:\\..\\EComLoadMgrExample1.dll
1.30 +// 0x10282330 0x10282334 1 Z:\\..\\EComLoadMgrExample1.dll
1.31 +// 0x10282335 0x10282333 1 Z:\\..\\EComLoadMgrExample2.dll
1.32 +//
1.33 +//
1.34 +
1.35 +#include <e32test.h>
1.36 +#include <f32file.h>
1.37 +#include <bautils.h>
1.38 +#include <e32uid.h>
1.39 +#include "LoadManager.h"
1.40 +#include <ecom/ecomerrorcodes.h>
1.41 +#include "EComUidCodes.h"
1.42 +#include "RegistryData.h"
1.43 +#include <ecom/implementationinformation.h>
1.44 +#include "../EcomTestUtils/EcomTestUtils.h"
1.45 +#include "Interface.h"
1.46 +#include "UnloadPolicy.h"
1.47 +// ---------------------------------------------------------------------------
1.48 +// Test and Leave framework
1.49 +
1.50 +LOCAL_D RTest TheTest(_L("t_loadmanager.exe"));
1.51 +
1.52 +LOCAL_C void Check(TInt aValue, TInt aLine)
1.53 + {
1.54 + if(!aValue)
1.55 + {
1.56 + //DeleteTestPlugin();
1.57 + TheTest(EFalse, aLine);
1.58 + }
1.59 + }
1.60 +
1.61 +LOCAL_C void Check(TInt aValue, TInt aExpected, TInt aLine)
1.62 + {
1.63 + if(aValue != aExpected)
1.64 + {
1.65 + RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
1.66 + //DeleteTestPlugin();
1.67 + TheTest(EFalse, aLine);
1.68 + }
1.69 + }
1.70 +
1.71 +#define TEST(arg) ::Check((arg), __LINE__)
1.72 +
1.73 +#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
1.74 +
1.75 +//Leave with info message printed out
1.76 +LOCAL_C void Leave(TInt aError, TInt aLine)
1.77 + {
1.78 + RDebug::Print(_L("*** Leave. Error: %d, Line: %d\r\n"), aError, aLine);
1.79 + User::Leave(aError);
1.80 + }
1.81 +
1.82 +
1.83 +//Use LEAVE() macro instead of User::Leave() and LEAVE_IF_ERROR() macro instead of
1.84 +//User::LeaveIfError(). They will print the line number, where the "leave" was called.
1.85 +
1.86 +#define LEAVE(aError) ::Leave(aError, __LINE__)
1.87 +
1.88 +
1.89 +// ---------------------------------------------------------------------------
1.90 +
1.91 +LOCAL_D RFs TheFs;
1.92 +
1.93 +LOCAL_D CTrapCleanup* TheTrapCleanup = NULL;
1.94 +
1.95 +LOCAL_D CActiveScheduler* TheActiveScheduler = NULL;
1.96 +
1.97 +//Plugins files used for this test program
1.98 +_LIT(KResourceFileName5, "C:\\resource\\plugins\\EComExample5.RSC");
1.99 +_LIT(KExampleDllFileName5, "C:\\sys\\bin\\EComExample5.dll");
1.100 +_LIT(KExampleDllFileName4,"Z:\\sys\\bin\\EComExample4.dll");
1.101 +_LIT(KExampleDllFileName3,"Z:\\sys\\bin\\EComExample3.dll");
1.102 +_LIT(KExampleDllFileName2,"Z:\\sys\\bin\\EComExample2.dll");
1.103 +_LIT(KLoadMgrExample1DllName,"Z:\\sys\\bin\\EComLoadMgrExample1.dll");
1.104 +_LIT(KLoadMgrExample2DllName,"Z:\\sys\\bin\\EComLoadMgrExample2.dll");
1.105 +
1.106 +_LIT(KResourceFileName5OnZ, "z:\\RAMOnly\\EComExample5.RSC");
1.107 +_LIT(KExampleDllFileName10,"Z:\\sys\\bin\\EComExample10.dll");
1.108 +_LIT(KNULLString,"");
1.109 +
1.110 +_LIT(KExampleDllFileName12,"C:\\sys\\bin\\EComExample12.dll");
1.111 +_LIT(KExampleDllFileName12OnZ, "z:\\RAMOnly\\EComExample12.dll");
1.112 +_LIT(KResourceFileName12, "C:\\resource\\plugins\\EComExample12.RSC");
1.113 +_LIT(KResourceFileName12OnZ, "z:\\RAMOnly\\EComExample12.RSC");
1.114 +
1.115 +//Contains files that are part of ROM that must be
1.116 +//Copied to the RAM for test purposes
1.117 +
1.118 +_LIT(KExampleDllFileName5OnZ, "z:\\RAMOnly\\EComExample5.dll");
1.119 +
1.120 +
1.121 +// Used for supressing warning in OOM tests
1.122 +#define __UNUSED_VAR(var) var = var
1.123 +
1.124 +const TInt KOneSecond = 1000000;
1.125 +
1.126 +// Utility clean up function
1.127 +void CleanupEComArray(TAny* aArray);
1.128 +
1.129 +//It is used by some test methods which are called two times:
1.130 +//from normal test and from OOM TheTest.
1.131 +static void LeaveIfErrNoMemory(TInt aError)
1.132 + {
1.133 + if(aError == KErrNoMemory)
1.134 + {
1.135 + LEAVE(aError);
1.136 + }
1.137 + }
1.138 +
1.139 +/**
1.140 +Test State Accessor class for CLoadManager
1.141 +This class will be used to access the state
1.142 +of the policy array within CLoadManager
1.143 +*/
1.144 +class TLoadManager_StateAccessor
1.145 + {
1.146 +public:
1.147 + //Return the number of instance index inside iInstanceInfoList
1.148 + TInt InstanceIndexCount(CLoadManager& aLoadManager);
1.149 + //Return the number of unload policy inside iAllUnloadPolicies
1.150 + TInt UnloadPolicyCount(CLoadManager& aLoadManager);
1.151 + //Return a pointer to Instance Index item inside the instance index array
1.152 + CInstanceInfo* InstanceIndex(const TInt& aInt,CLoadManager& aLoadManager);
1.153 + //Return a pointer to UnloadPolicy item inside the array
1.154 + CUnloadPolicy* UnloadPolicy(const TInt& aInt,CLoadManager& aLoadManager);
1.155 + //Return a pointer to garbage UnloadPolicy
1.156 + CUnloadPolicy* GarbagePolicy(CLoadManager& aLoadManager);
1.157 + //Return a count to the number of extended objects within an Extended instance.
1.158 + // Must pass in the index of a valid extended instance
1.159 + TInt ExtendedInstanceCount(const TInt& aInt,CLoadManager& aLoadManager);
1.160 + };
1.161 +
1.162 +TInt TLoadManager_StateAccessor::InstanceIndexCount(CLoadManager& aLoadManager)
1.163 + {
1.164 + return aLoadManager.iInstanceInfoList.Count();
1.165 + }
1.166 +
1.167 +TInt TLoadManager_StateAccessor::UnloadPolicyCount(CLoadManager& aLoadManager)
1.168 + {
1.169 + return aLoadManager.iAllUnloadPolicies.Count();
1.170 + }
1.171 +
1.172 +CInstanceInfo* TLoadManager_StateAccessor::InstanceIndex(const TInt& aInt,CLoadManager& aLoadManager)
1.173 + {
1.174 + return (aLoadManager.iInstanceInfoList[aInt]);
1.175 + }
1.176 +
1.177 +CUnloadPolicy* TLoadManager_StateAccessor::UnloadPolicy(const TInt& aInt,CLoadManager& aLoadManager)
1.178 + {
1.179 + return aLoadManager.iAllUnloadPolicies[aInt];
1.180 + }
1.181 +CUnloadPolicy* TLoadManager_StateAccessor::GarbagePolicy(CLoadManager& aLoadManager)
1.182 + {
1.183 + return aLoadManager.iGarbagePolicy;
1.184 + }
1.185 +
1.186 +TInt TLoadManager_StateAccessor::ExtendedInstanceCount(const TInt& aInt,CLoadManager& aLoadManager)
1.187 + {
1.188 + CInstanceInfoExtended* instanceExtended = static_cast<CInstanceInfoExtended*>(aLoadManager.iInstanceInfoList[aInt]);
1.189 + return instanceExtended->iExtendedObjectInfo.Count();
1.190 + }
1.191 +
1.192 +
1.193 +/**
1.194 +Test class for object CLoadManager.
1.195 +The class provides the parameters and behaviour that
1.196 +allows this class to behave normally under a test scenario.
1.197 +*/
1.198 +class CLoadManagerTest : public CBase
1.199 + {
1.200 +public:
1.201 + static CLoadManagerTest* NewL();
1.202 + virtual inline ~CLoadManagerTest();
1.203 +
1.204 + void InstantiationMethodTestL(TUid aDllUid, const TDesC& aDllName, const TUid aIICType);
1.205 + void DestroyThisTestL(TUid aDllUid, const TDesC& aDllName, const TUid aIICType);
1.206 +
1.207 + void CreateDestroyTestCase1L(TUid aDllUid1,
1.208 + TUid aImplUid1,
1.209 + const TDesC& aDllName1,
1.210 + TUid aDllUid2,
1.211 + TUid aImplUid2,
1.212 + const TDesC& aDllName2,
1.213 + const TUid aIICType);
1.214 + void CreateDestroyTestCase2L(TUid aDllUid,
1.215 + TUid aImplUid1,
1.216 + const TDesC& aDllName,
1.217 + TUid aImplUid2,
1.218 + const TUid aIICType);
1.219 + void CreateDestroyTestCase3L();
1.220 +
1.221 + void CreateDestroyTestCase4L(TUid aDllUid,TUid aImplUid,const TDesC& aDllName,const TUid aIICType);
1.222 +
1.223 + void CreateDestroyTestCase5L(TUid aDllUid1,
1.224 + TUid aImplUid1,
1.225 + const TDesC& aDllName1,
1.226 + TUid aDllUid2,
1.227 + TUid aImplUid2,
1.228 + const TDesC& aDllName2,
1.229 + TUid aImplUid3,
1.230 + const TUid aIICType);
1.231 +
1.232 + void SpecialOOMTestCaseL();
1.233 +
1.234 + void InstantiationMethodTestPlugin1L();
1.235 + void InstantiationMethodTestPlugin3L();
1.236 + void ImplementationObjectTestL();
1.237 +
1.238 + void GetImplementationUidTestL();
1.239 +
1.240 + void DestroyThisTestPlugin1L();
1.241 + void DestroyThisTestPlugin3L();
1.242 +
1.243 + void CreateDestroyTestCase1Plugin1L();
1.244 + void CreateDestroyTestCase1Plugin3L();
1.245 +
1.246 + void CreateDestroyTestCase2Plugin1L();
1.247 + void CreateDestroyTestCase2Plugin3L();
1.248 +
1.249 + void CreateDestroyTestCase3Plugin3L();
1.250 +
1.251 + void CreateDestroyTestCase4Plugin1L();
1.252 + void CreateDestroyTestCase4Plugin3L();
1.253 +
1.254 + void CreateDestroyTestCase5Plugin1L();
1.255 + void CreateDestroyTestCase5Plugin3L();
1.256 +
1.257 + // Extended methods
1.258 + void ExtendedMethodTest1Plugin3L();
1.259 + void ExtendedMethodTest2Plugin3L();
1.260 + void ManuallyReleaseExtendedInterfaceTestL();
1.261 + void CreateDestroyTestCase1PluginAndPlugin3L();
1.262 +
1.263 +private:
1.264 + CLoadManagerTest();
1.265 + void ConstructL();
1.266 +
1.267 +public:
1.268 + /** The instance of the class under test */
1.269 + CLoadManager* iLoadManager;
1.270 +
1.271 + /** Unique Id of an interface implementation */
1.272 + TUid iImplementationUid;
1.273 +
1.274 + /** LoadManager State Accessor */
1.275 + TLoadManager_StateAccessor iStateAccessor;
1.276 + };
1.277 +
1.278 +/**
1.279 +Standardised safe construction which
1.280 +leaves nothing on the cleanup stack.
1.281 +
1.282 +@post CLoadManagerTest is fully constructed and initialised.
1.283 +*/
1.284 +CLoadManagerTest* CLoadManagerTest::NewL()
1.285 + {
1.286 + CLoadManagerTest* self = new(ELeave) CLoadManagerTest;
1.287 + CleanupStack::PushL(self);
1.288 + self->ConstructL();
1.289 + CleanupStack::Pop(self);
1.290 + return self;
1.291 + }
1.292 +
1.293 +/**
1.294 +Standardized default constructor
1.295 +
1.296 +@post CLoadManagerTest is fully constructed.
1.297 +*/
1.298 +CLoadManagerTest::CLoadManagerTest()
1.299 + {
1.300 + // Implementation id for interface 0x10009DC0
1.301 + // Implemented in test plugin EComExample4.dll
1.302 + iImplementationUid.iUid = 0x101F847A;
1.303 + }
1.304 +
1.305 +/**
1.306 +Destructor.
1.307 +
1.308 +@post This object is properly destroyed.
1.309 +*/
1.310 +CLoadManagerTest::~CLoadManagerTest()
1.311 + {
1.312 + delete iLoadManager;
1.313 + }
1.314 +
1.315 +/**
1.316 +Standardized 2nd(Initialization) phase of two phase construction.
1.317 +
1.318 +@post CLoadManagerTest is fully constructed.
1.319 +*/
1.320 +void CLoadManagerTest::ConstructL()
1.321 + {
1.322 + iLoadManager = CLoadManager::NewL();
1.323 + }
1.324 +
1.325 +/**
1.326 +The test executes by getting the Instantiation method for
1.327 +the given ImplementationId
1.328 +*/
1.329 +void CLoadManagerTest::InstantiationMethodTestL(TUid aDllUid, const TDesC& aDllName, const TUid aIICType)
1.330 + {
1.331 + CExampleInterface::TExampleInterfaceInitParams iInitParams;
1.332 + iInitParams.integer = 5;
1.333 + TBool initParamsFlag = ETrue;
1.334 + _LIT(KDummyText,"Dummy params");
1.335 + iInitParams.descriptor = &KDummyText;
1.336 +
1.337 + TEntry entry;
1.338 + entry.iName=aDllName;
1.339 + entry.iModified=TTime(0);
1.340 + entry.iType=TUidType(KDynamicLibraryUid,aIICType,aDllUid);
1.341 +
1.342 + TAny* implementationPtr = 0;
1.343 + TUid instanceKey;
1.344 + TRAPD(err, implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid, entry,&iInitParams, initParamsFlag,instanceKey));
1.345 +
1.346 + ::LeaveIfErrNoMemory(err);
1.347 + TEST2(err,KErrNone);
1.348 + TEST(implementationPtr != 0);
1.349 +
1.350 + //Checking the state of the arrays inside CLoadManager and garbage policy
1.351 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==1);
1.352 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==1);
1.353 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL);
1.354 +
1.355 + //Checking the instance index and UnloadPolicy info
1.356 + TEST(iStateAccessor.InstanceIndex(0,*iLoadManager)->ImplementationUid()==iImplementationUid);
1.357 + TEST(iStateAccessor.UnloadPolicy(0,*iLoadManager)->DllEntryInformation().GetName().CompareF(aDllName)==0);
1.358 +
1.359 + delete (CExampleInterface*)implementationPtr;
1.360 + implementationPtr=0;
1.361 + iLoadManager->DestroyedThis(instanceKey);
1.362 + iLoadManager->ClearGarbage();
1.363 + }
1.364 +
1.365 +/**
1.366 +Test CLoadManager::ImplementationObjectL with parameters to test old proxy table
1.367 +*/
1.368 +void CLoadManagerTest::InstantiationMethodTestPlugin1L()
1.369 + {
1.370 + // This test tests with Ecom plugin EComExample4.dll
1.371 + // EComExample4.dll should be installed on Z: drive
1.372 + // The test executes by getting the Instantiation method for the given ImplementationId
1.373 + // implementationPtr method should get some valid address.
1.374 + // Manually creating the DLL info that in practice will be returned from the server side
1.375 + // Set up some init params to be used for testing purpose
1.376 + TUid dllUid;
1.377 + dllUid.iUid = 0x101F8479;
1.378 + iImplementationUid.iUid=0x101F847A;
1.379 + InstantiationMethodTestL(dllUid,KExampleDllFileName4,KUidInterfaceImplementationCollection);
1.380 + }
1.381 +
1.382 +/**
1.383 +@SYMTestCaseID SYSLIB-ECOM-UT-3549
1.384 +@SYMTestCaseDesc Calls CLoadManager::ImplementationObjectL with parameters to test new proxy table
1.385 +@SYMTestPriority High
1.386 +@SYMTestActions Instantiate implementation for the given ImplementationId with construction parameters
1.387 + and check the CLoadManager data structures.
1.388 + Destroy the implementation object and again check the CLoadManager data structures.
1.389 + (ECom plugin EComExample10.dll will be used for the test.)
1.390 +@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls
1.391 +@SYMEC EC43
1.392 +*/
1.393 +void CLoadManagerTest::InstantiationMethodTestPlugin3L()
1.394 + {
1.395 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3549 "));
1.396 + TUid dllUid;
1.397 + dllUid.iUid = 0x10009E37;
1.398 + iImplementationUid.iUid = 0x10009E38;
1.399 + InstantiationMethodTestL(dllUid,KExampleDllFileName10,KUidInterfaceImplementationCollection3);
1.400 + }
1.401 +
1.402 +
1.403 +/**
1.404 +@SYMTestCaseID SYSLIB-ECOM-UT-3710
1.405 +@SYMTestCaseDesc Tests CLoadManager::ImplementationObjectL with some extreme conditions to improve the
1.406 + condition coverage rate.
1.407 + 1. implementationUid is NULL. The function will leave with KErrNotFound
1.408 + 2. dllName is NULL. The function will leave with KErrNotFound
1.409 + 3. second Uid of the PlugIn is neither IIC or IIC3. The function will leave with KErrNotSupported
1.410 +@SYMTestPriority High
1.411 +@SYMTestActions Calls CLoadManager::ImplementationObjectL and check the result.
1.412 +@SYMTestExpectedResults Expected error is return.
1.413 +@SYMDEF DEF111196
1.414 +*/
1.415 +void CLoadManagerTest::ImplementationObjectTestL()
1.416 + {
1.417 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3710 "));
1.418 + TUid dummyUid;
1.419 + dummyUid.iUid = 0;
1.420 +
1.421 + TUid dllUid;
1.422 + dllUid.iUid = 0x10009E37;
1.423 +
1.424 + iImplementationUid.iUid = 0x10009E38;
1.425 +
1.426 + CExampleInterface::TExampleInterfaceInitParams iInitParams;
1.427 + iInitParams.integer = 5;
1.428 + TBool initParamsFlag = ETrue;
1.429 + _LIT(KDummyText,"Dummy params");
1.430 + iInitParams.descriptor = &KDummyText;
1.431 +
1.432 + TEntry entry;
1.433 + entry.iName=KExampleDllFileName10;
1.434 + entry.iModified=TTime(0);
1.435 + entry.iType=TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid);
1.436 +
1.437 + TUid instanceKey;
1.438 +
1.439 + // 1. Calls ImplementationObjectL with implementationUid is NULL. The function will leave with KErrNotFound
1.440 + TRAPD(err, TAny* implementationPtr = iLoadManager->ImplementationObjectL(dummyUid, entry,&iInitParams, initParamsFlag,instanceKey));
1.441 + TEST2(err,KErrNotFound);
1.442 +
1.443 + // 2. Calls ImplementationObjectL with dllName is NULL. The function will leave with KErrNotFound
1.444 + entry.iName = KNULLString;
1.445 + TRAP(err, TAny* implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid,entry,&iInitParams, initParamsFlag,instanceKey));
1.446 + TEST2(err,KErrNotFound);
1.447 +
1.448 + // 3. Calls ImplementationObjectL with second Uid of the PlugIn is neither IIC or IIC3
1.449 + entry.iName=KExampleDllFileName10;
1.450 + entry.iModified=TTime(0);
1.451 + entry.iType=TUidType(KDynamicLibraryUid,dummyUid,dllUid);
1.452 + TRAP(err, TAny* implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid,entry,&iInitParams, initParamsFlag,instanceKey));
1.453 + TEST2(err,KErrNotSupported);
1.454 + }
1.455 +
1.456 +
1.457 +/**
1.458 +Test CLoadManager::DestroyThis(). DestroyThis will actually either remove the UnloadPolicy from the list or decrease
1.459 +referencecount(to UnloadPolicy) by one.
1.460 +*/
1.461 +void CLoadManagerTest::DestroyThisTestL(TUid aDllUid, const TDesC& aDllName, const TUid aIICType)
1.462 + {
1.463 + // We must call DestroyedThis only after getting a reference to the Implementation
1.464 + // so that reference count to this implementaion have value greater than zero.
1.465 + // ImplementationObjectL is called to increase the reference count of the test implementation,
1.466 + // so that its reference count goes to 1.
1.467 + // This test executes by verifing the reference count to this implementation.
1.468 + CExampleInterface::TExampleInterfaceInitParams iInitParams;
1.469 + iInitParams.integer = 5;
1.470 + TBool initParamsFlag = ETrue;
1.471 + _LIT(KDummyText,"Dummy params");
1.472 + iInitParams.descriptor = &KDummyText;
1.473 +
1.474 + TEntry entry;
1.475 + entry.iName=aDllName;
1.476 + entry.iModified=TTime(0);
1.477 + entry.iType=TUidType(KDynamicLibraryUid, aIICType, aDllUid);
1.478 +
1.479 + TAny* implementationPtr = 0;
1.480 + TUid instanceKey;
1.481 + TRAPD(err, implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid, entry, &iInitParams, initParamsFlag,instanceKey));
1.482 +
1.483 + ::LeaveIfErrNoMemory(err);
1.484 + TEST2(err,KErrNone);
1.485 + TEST(implementationPtr != 0);
1.486 +
1.487 + //Checking the state of the arrays inside CLoadManager and the garbage policy
1.488 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==1);
1.489 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==1);
1.490 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL);
1.491 +
1.492 + // The purpose of DestroyedThis is to decrease the reference count of UnloadPolicy or
1.493 + // remove the Dll from RegistryData if its on grabagelist and reference count reaches 0
1.494 + iLoadManager->DestroyedThis(instanceKey);
1.495 +
1.496 + //Checking the state of the arrays inside CLoadManager and the garbage policy
1.497 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==0);
1.498 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==0);
1.499 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)!=NULL);
1.500 +
1.501 + //delete the instantiation
1.502 + delete (CExampleInterface*)implementationPtr;
1.503 + implementationPtr=0;
1.504 + }
1.505 +
1.506 +/**
1.507 +@SYMTestCaseID SYSLIB-ECOM-UT-3709
1.508 +@SYMTestCaseDesc This testcase checks GetImplementationUidL().
1.509 +@SYMTestPriority High
1.510 +@SYMTestActions Instantiate an implementation.
1.511 + Call GetImplementationUidL() and check impl id.
1.512 + Call GetImplementationUidL() and check impl id again.
1.513 + Destroy plugin.
1.514 + Call GetImplementationUidL() and check for error.
1.515 +@SYMTestExpectedResults Returns impl uid when valid destructor uid is used otherwise
1.516 + leaves with the appropriate error.
1.517 +@SYMDEF DEF111789
1.518 +*/
1.519 +void CLoadManagerTest::GetImplementationUidTestL()
1.520 + {
1.521 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3709 "));
1.522 + // EComExample5.dll (dlluid 0x101F847B) in C:\ with Implementation Uid =0x101F847C
1.523 + TUid dllUid;
1.524 + dllUid.iUid = 0x101F847B;
1.525 + CExampleInterface::TExampleInterfaceInitParams iInitParams;
1.526 + iInitParams.integer = 5;
1.527 + TBool initParamsFlag = ETrue;
1.528 + _LIT(KDummyText,"Dummy params");
1.529 + iInitParams.descriptor = &KDummyText;
1.530 +
1.531 + TEntry entry;
1.532 + entry.iName=KExampleDllFileName5;
1.533 +
1.534 + entry.iModified=TTime(0);
1.535 + entry.iType=TUidType(KDynamicLibraryUid, KUidInterfaceImplementationCollection, dllUid);
1.536 +
1.537 + iImplementationUid.iUid=0x101F847C;
1.538 +
1.539 + TAny* implementationPtr = 0;
1.540 + TUid instanceKey;
1.541 + TRAPD(err, implementationPtr = iLoadManager->ImplementationObjectL(iImplementationUid, entry, &iInitParams, initParamsFlag, instanceKey));
1.542 +
1.543 + ::LeaveIfErrNoMemory(err);
1.544 + TEST2(err,KErrNone);
1.545 + TEST(implementationPtr != 0);
1.546 +
1.547 + // Retrieve impl uid corresponding to detructor key id
1.548 + TUid implId = iLoadManager->GetImplementationUidL(instanceKey);
1.549 + // Check that the impl uid corresponding to destructor key id is as expected
1.550 + TEST(implId == iImplementationUid);
1.551 +
1.552 + // Do it again to be sure...
1.553 + implId = iLoadManager->GetImplementationUidL(instanceKey);
1.554 + // Check that the impl uid corresponding to destructor key id is as expected
1.555 + TEST(implId == iImplementationUid);
1.556 +
1.557 + iLoadManager->DestroyedThis(instanceKey);
1.558 +
1.559 + //delete the instantiation
1.560 + delete (CExampleInterface*)implementationPtr;
1.561 + implementationPtr=0;
1.562 +
1.563 + // Call GetImplementationUidL() again now that the instance has been deleted
1.564 + // Expecting a Leave...
1.565 + TRAP(err,implId = iLoadManager->GetImplementationUidL(instanceKey));
1.566 + TEST2(err, KErrNotFound);
1.567 + }
1.568 +
1.569 +/**
1.570 +Test executes by getting the CUnloadPolicy* associated to the testing DLL EComExample5.dll.
1.571 +*/
1.572 +void CLoadManagerTest::DestroyThisTestPlugin1L()
1.573 + {
1.574 + // EComExample5.dll (dlluid 0x101F847B) in C:\ with Implementation Uid =0x101F847C
1.575 + TUid dllUid;
1.576 + dllUid.iUid = 0x101F847B;
1.577 + iImplementationUid.iUid=0x101F847C;
1.578 + DestroyThisTestL(dllUid,KExampleDllFileName5,KUidInterfaceImplementationCollection);
1.579 + }
1.580 +
1.581 +/**
1.582 +@SYMTestCaseID SYSLIB-ECOM-UT-3550
1.583 +@SYMTestCaseDesc Calls CLoadManager::DestroyedThis with parameters to test new proxy table
1.584 +@SYMTestPriority High
1.585 +@SYMTestActions Test executes by getting the CUnloadPolicy* associated to the testing DLL EComExample10.dll.
1.586 + DestroyThis will actually either remove the UnloadPolicy from the list or decrease
1.587 + referencecount(to UnloadPolicy) by one.
1.588 +@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls
1.589 +@SYMEC EC43
1.590 +*/
1.591 +void CLoadManagerTest::DestroyThisTestPlugin3L()
1.592 + {
1.593 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3550 "));
1.594 + // EComExample10.dll
1.595 + TUid dllUid;
1.596 + dllUid.iUid = 0x10009E37;
1.597 + iImplementationUid.iUid = 0x10009E38;
1.598 + DestroyThisTestL(dllUid,KExampleDllFileName10,KUidInterfaceImplementationCollection3);
1.599 + }
1.600 +
1.601 +/**
1.602 +Tests for create and destroy load manager
1.603 +Test case 1:Creates two implementations from two DIFFERENT DLL Z: C:
1.604 +Test case 2:Creates two implementations from one SAME DLL
1.605 +Test case 3:Invalid argument testing for Create Implementation
1.606 + Invalid Entry and Implementation uid argument in ImplementationObjectL
1.607 +Test case 4:Creates two instance of the same implementation Uid from one single DLL
1.608 +Test case 5:DEF101930: Incorrect policy object returned in
1.609 + This testcase checks for the case where 2 implementations
1.610 + are created each on separate DLL's then an additional
1.611 + implementation is created from one of the already loaded DLL's.
1.612 + The impl uid of the newly created impl is lower then the 2
1.613 + existing impl uids. The impl uids from the same DLL are such
1.614 + that 1 is higher then the uid of the other impl and 1 is lower than
1.615 + the other impl.
1.616 +*/
1.617 +
1.618 +// Test case 1:Create two implementation from two DIFFERENT DLL Z: C:
1.619 +
1.620 +void CLoadManagerTest::CreateDestroyTestCase1L(TUid aDllUid1,
1.621 + TUid aImplUid1,
1.622 + const TDesC& aDllName1,
1.623 + TUid aDllUid2,
1.624 + TUid aImplUid2,
1.625 + const TDesC& aDllName2,
1.626 + const TUid aIICType)
1.627 + {
1.628 + //Some interface instantiation parameters
1.629 + CExampleInterface::TExampleInterfaceInitParams iInitParams;
1.630 + iInitParams.integer = 5;
1.631 + TBool initParamsFlag = ETrue;
1.632 + _LIT(KDummyText,"Dummy params");
1.633 + iInitParams.descriptor = &KDummyText;
1.634 + TAny* impl1 = NULL;
1.635 + TAny* impl2 = NULL;
1.636 +
1.637 + TEntry entry1;
1.638 + entry1.iName = aDllName1;
1.639 + entry1.iModified = TTime(0);
1.640 + entry1.iType = TUidType(KDynamicLibraryUid,aIICType,aDllUid1);
1.641 +
1.642 + TEntry entry2;
1.643 + entry2.iName = aDllName2;
1.644 + entry2.iModified = TTime(0);
1.645 + entry2.iType = TUidType(KDynamicLibraryUid,aIICType,aDllUid2);
1.646 +
1.647 + TInt err;
1.648 + //Creates 1st Implementation
1.649 + TUid instanceKey;
1.650 + TRAP(err,impl1 = iLoadManager->ImplementationObjectL(aImplUid1,entry1, &iInitParams,initParamsFlag,instanceKey));
1.651 + ::LeaveIfErrNoMemory(err);
1.652 + TEST2(err,KErrNone);
1.653 +
1.654 + //Checks the state of the arrays inside CLoadManager and the garbage policy
1.655 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1);
1.656 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
1.657 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.658 +
1.659 + //Creates 2nd Implementation
1.660 + TUid instanceKey2;
1.661 + TRAP(err,impl2 = iLoadManager->ImplementationObjectL(aImplUid2,entry2, &iInitParams,initParamsFlag,instanceKey2));
1.662 + // If impl2 fails here due to KErrNoMemory we need to clear the previous impl1
1.663 + // to avoid memory leak
1.664 + if (err==KErrNoMemory)
1.665 + {
1.666 + iLoadManager->DestroyedThis(instanceKey);
1.667 + delete (CExampleInterface*)impl1;
1.668 + impl1 = NULL;
1.669 + ::LeaveIfErrNoMemory(err);
1.670 + }
1.671 + TEST(err == KErrNone);
1.672 +
1.673 + //Checks the state of the arrays inside CLoadManager and the garbage policy
1.674 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 2);
1.675 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 2);
1.676 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.677 +
1.678 + //Now destroy the 2nd Implementation
1.679 + iLoadManager->DestroyedThis(instanceKey2);
1.680 + delete (CExampleInterface*)impl2;
1.681 + impl2 = NULL;
1.682 +
1.683 + //Checks the state of the arrays inside CLoadManager and the garbage policy
1.684 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1);
1.685 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
1.686 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL);
1.687 +
1.688 + //Now destroy the 1st Implementation;
1.689 + iLoadManager->DestroyedThis(instanceKey);
1.690 + delete (CExampleInterface*)impl1;
1.691 + impl1 = NULL;
1.692 +
1.693 + //Checks the state of the arrays inside CLoadManager and the garbage policy
1.694 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0);
1.695 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0);
1.696 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL);
1.697 +
1.698 + iLoadManager->ClearGarbage();
1.699 +
1.700 + //Checks the final state of the garbage policy
1.701 + //Tests for the new API ClearGarbage()
1.702 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.703 + }
1.704 +
1.705 +/**
1.706 +Plugins used:
1.707 +- Z:\\..\\EComExample3.dll contains ImplUid=0x101F8478
1.708 +- C:\\..\\EComExample5.dll contains ImplUid=0x101F847C
1.709 +
1.710 +@SYMTestCaseID SYSLIB-ECOM-CT-0701
1.711 +@SYMTestCaseDesc Tests for create and delete of CLoadManager
1.712 +@SYMTestPriority High
1.713 +@SYMTestActions Create two implementation from two DIFFERENT DLL Z: C:
1.714 +@SYMTestExpectedResults Two UnloadPolicy inside the array because of Two DLL loaded
1.715 + Two Instance indexes because of two Different Implementation Uid's
1.716 +@SYMREQ REQ0000
1.717 +*/
1.718 +void CLoadManagerTest::CreateDestroyTestCase1Plugin1L()
1.719 + {
1.720 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-0701 "));
1.721 + //Implementation Uid inside Z:\\..\\EComExample3.dll
1.722 + TUid implUid1={0x101F8478};
1.723 + //Implementation Uid inside C:\\..\\EComExample5.dll
1.724 + TUid implUid2={0x101F847C};
1.725 + //EComExample3.dll entry
1.726 + TUid dllUid1;
1.727 + dllUid1.iUid = 0x101F8477;
1.728 + //EComExample5.dll entry
1.729 + TUid dllUid2;
1.730 + dllUid2.iUid = 0x101F847B;
1.731 +
1.732 + CreateDestroyTestCase1L(dllUid1,implUid1,KExampleDllFileName3,dllUid2,implUid2,KExampleDllFileName5,KUidInterfaceImplementationCollection);
1.733 + }
1.734 +
1.735 +/**
1.736 +@SYMTestCaseID SYSLIB-ECOM-UT-3551
1.737 +@SYMTestCaseDesc Tests for create and delete of implementations using PLUGIN3 from two DIFFERENT DLL's
1.738 +@SYMTestPriority High
1.739 +@SYMTestActions Create two implementations from two DIFFERENT DLL's using new Dll type PLUGIN3.
1.740 + Test executes by getting the CUnloadPolicy* associated to the testing DLL EComExample10.dll.
1.741 + DestroyThis will actually either remove the UnloadPolicy from the list or decrease
1.742 + referencecount(to UnloadPolicy) by one.
1.743 +@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls
1.744 + Two UnloadPolicy inside the array because of Two DLL loaded
1.745 + Two Instance indexes because of two Different Implementation Uid's
1.746 +@SYMEC EC43
1.747 +*/
1.748 +void CLoadManagerTest::CreateDestroyTestCase1Plugin3L()
1.749 + {
1.750 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3551 "));
1.751 + //Implementation Uid inside Z:\\..\\EComExample10.dll
1.752 + TUid implUid1 = {0x10009E38};
1.753 + //Implementation Uid inside C:\\..\\EComExample12.dll
1.754 + TUid implUid2 = {0x10009E39};
1.755 + //EComExample10.dll entry
1.756 + TUid dllUid1;
1.757 + dllUid1.iUid = 0x10009E37;
1.758 + //EComExample12.dll entry
1.759 + TUid dllUid2;
1.760 + dllUid2.iUid = 0x10009E3E;
1.761 +
1.762 + CreateDestroyTestCase1L(dllUid1,implUid1,KExampleDllFileName10,dllUid2,implUid2,KExampleDllFileName12,KUidInterfaceImplementationCollection3);
1.763 + }
1.764 +
1.765 +/**
1.766 +@SYMTestCaseID SYSLIB-ECOM-UT-3552
1.767 +@SYMTestCaseDesc Tests for create and delete of implementations using PLUGIN1 and PLUGIN3
1.768 +@SYMTestPriority High
1.769 +@SYMTestActions Create two implementations from two DIFFERENT DLL's one of PLUGIN1, the other Dll
1.770 + of type PLUGIN3. Test executes by getting the CUnloadPolicy* associated to the
1.771 + testing DLL EComExample10.dll. DestroyThis will actually either remove the
1.772 + UnloadPolicy from the list or decrease referencecount(to UnloadPolicy) by one.
1.773 + Plugins used:
1.774 + - Z:\\..\\EComExample3.dll contains ImplUid=0x101F8478 - PLUGIN type dll
1.775 + - Z:\\..\\EComExample10.dll contains ImplUid=0x10009E38 - PLUGIN3 type dll
1.776 +@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls
1.777 + Two UnloadPolicy inside the array because of Two DLL loaded
1.778 + Two Instance indexes because of two Different Implementations
1.779 +@SYMEC EC43
1.780 +*/
1.781 +void CLoadManagerTest::CreateDestroyTestCase1PluginAndPlugin3L()
1.782 + {
1.783 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3552 "));
1.784 + //Implementation Uid inside Z:\\..\\EComExample3.dll
1.785 + TUid ImplUid1 = {0x101F8478};
1.786 + //Implementation Uid inside Z:\\..\\EComExample10.dll
1.787 + TUid ImplUid2 = {0x10009E38};
1.788 + //Some interface instantiation parameters
1.789 + CExampleInterface::TExampleInterfaceInitParams iInitParams;
1.790 + iInitParams.integer = 5;
1.791 + TBool initParamsFlag = ETrue;
1.792 + _LIT(KDummyText,"Dummy params");
1.793 + iInitParams.descriptor = &KDummyText;
1.794 + TAny* impl1 = NULL;
1.795 + TAny* impl2 = NULL;
1.796 +
1.797 + //EComExample3.dll entry
1.798 + TUid dllUid1;
1.799 + dllUid1.iUid = 0x101F8477;
1.800 +
1.801 + TEntry entry1;
1.802 + entry1.iName = KExampleDllFileName3;
1.803 + entry1.iModified = TTime(0);
1.804 + entry1.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection,dllUid1);
1.805 +
1.806 + //EComExample10.dll entry
1.807 + TUid dllUid2;
1.808 + dllUid2.iUid = 0x10009E37;
1.809 +
1.810 + TEntry entry2;
1.811 + entry2.iName = KExampleDllFileName10;
1.812 + entry2.iModified = TTime(0);
1.813 + entry2.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid2);
1.814 +
1.815 + TInt err;
1.816 + //Creates Implementation with Uid=0x101F8478
1.817 + TUid instanceKey;
1.818 + TRAP(err,impl1 = iLoadManager->ImplementationObjectL(ImplUid1,entry1, &iInitParams,initParamsFlag,instanceKey));
1.819 + ::LeaveIfErrNoMemory(err);
1.820 + TEST2(err,KErrNone);
1.821 +
1.822 + //Checks the state of the arrays inside CLoadManager and the garbage policy
1.823 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1);
1.824 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
1.825 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.826 +
1.827 + //Creates 2nd Implementation with Uid=0x10009E38
1.828 + TUid instanceKey2;
1.829 + TRAP(err,impl2 = iLoadManager->ImplementationObjectL(ImplUid2,entry2, &iInitParams,initParamsFlag,instanceKey2));
1.830 + // If impl2 fails here due to KErrNoMemory we need to clear the previous impl1
1.831 + // to avoid memory leak
1.832 + if (err==KErrNoMemory)
1.833 + {
1.834 + iLoadManager->DestroyedThis(instanceKey);
1.835 + delete (CExampleInterface*)impl1;
1.836 + impl1 = NULL;
1.837 + ::LeaveIfErrNoMemory(err);
1.838 + }
1.839 + TEST(err == KErrNone);
1.840 +
1.841 + //Checks the state of the arrays inside CLoadManager and the garbage policy
1.842 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 2);
1.843 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 2);
1.844 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.845 +
1.846 + //Now destroy the 2nd Implementation
1.847 + iLoadManager->DestroyedThis(instanceKey2);
1.848 + delete (CExampleInterface*)impl2;
1.849 + impl2 = NULL;
1.850 +
1.851 + //Checks the state of the arrays inside CLoadManager and the garbage policy
1.852 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1);
1.853 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
1.854 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL);
1.855 +
1.856 + //Now destroy the 1st Implementation;
1.857 + iLoadManager->DestroyedThis(instanceKey);
1.858 + delete (CExampleInterface*)impl1;
1.859 + impl1 = NULL;
1.860 +
1.861 + //Checks the state of the arrays inside CLoadManager and the garbage policy
1.862 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0);
1.863 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0);
1.864 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL);
1.865 +
1.866 + iLoadManager->ClearGarbage();
1.867 +
1.868 + //Checks the final state of the garbage policy
1.869 + //Tests for the new API ClearGarbage()
1.870 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.871 + }
1.872 +
1.873 +
1.874 +// Test case 2:Create two implementation from one SAME DLL
1.875 +
1.876 +void CLoadManagerTest::CreateDestroyTestCase2L(TUid aDllUid,
1.877 + TUid aImplUid1,
1.878 + const TDesC& aDllName,
1.879 + TUid aImplUid2,
1.880 + const TUid aIICType)
1.881 + {
1.882 + CExampleInterface::TExampleInterfaceInitParams iInitParams;
1.883 + iInitParams.integer = 5;
1.884 + TBool initParamsFlag = ETrue;
1.885 + _LIT(KDummyText,"Dummy params");
1.886 + iInitParams.descriptor = &KDummyText;
1.887 + TAny* impl1 = NULL;
1.888 + TAny* impl2 = NULL;
1.889 +
1.890 + TEntry entry;
1.891 + entry.iName = aDllName;
1.892 + entry.iModified = TTime(0);
1.893 + entry.iType = TUidType(KDynamicLibraryUid,aIICType,aDllUid);
1.894 +
1.895 + TInt err;
1.896 + //Creates Implementation 1
1.897 + TUid instanceKey;
1.898 + TRAP(err,impl1 = iLoadManager->ImplementationObjectL(aImplUid1,entry, &iInitParams,initParamsFlag,instanceKey));
1.899 + ::LeaveIfErrNoMemory(err);
1.900 + TEST(err==KErrNone);
1.901 + //Checks the state of the arrays inside CLoadManager and the garbage policy
1.902 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1);
1.903 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
1.904 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.905 +
1.906 + TAny* impl4 = NULL;
1.907 + //Recreates another Implementation 1
1.908 + TUid instanceKey2;
1.909 + TRAP(err,impl4 = iLoadManager->ImplementationObjectL(aImplUid1,entry, &iInitParams,initParamsFlag,instanceKey2));
1.910 + if (err == KErrNoMemory)
1.911 + {
1.912 + iLoadManager->DestroyedThis(instanceKey);
1.913 + delete (CExampleInterface*)impl1;
1.914 + impl1 = NULL;
1.915 + ::LeaveIfErrNoMemory(err);
1.916 + }
1.917 + TEST2(err,KErrNone);
1.918 + //Checks the state of the arrays inside CLoadManager and the garbage policy
1.919 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 2);
1.920 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
1.921 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.922 +
1.923 + //Creates Implementation 2
1.924 + TUid instanceKey3;
1.925 + TRAP(err,impl2 = iLoadManager->ImplementationObjectL(aImplUid2,entry, &iInitParams,initParamsFlag,instanceKey3));
1.926 + // If impl2 fails here due to KErrNoMemory we need to clear the previous impl1
1.927 + // to avoid memory leak
1.928 + if (err == KErrNoMemory)
1.929 + {
1.930 + iLoadManager->DestroyedThis(instanceKey);
1.931 + delete (CExampleInterface*)impl1;
1.932 + impl1 = NULL;
1.933 + iLoadManager->DestroyedThis(instanceKey2);
1.934 + delete (CExampleInterface*)impl4;
1.935 + impl4 = NULL;
1.936 + ::LeaveIfErrNoMemory(err);
1.937 + }
1.938 +
1.939 + TEST2(err,KErrNone);
1.940 +
1.941 + //Checks the state of the arrays inside CLoadManager and the garbage policy
1.942 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 3);
1.943 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
1.944 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.945 +
1.946 + //Creates another Implementation 2
1.947 + TAny* impl3 = NULL;
1.948 + TUid instanceKey4;
1.949 + TRAP(err,impl3 = iLoadManager->ImplementationObjectL(aImplUid2,entry, &iInitParams,initParamsFlag,instanceKey4));
1.950 + //Checks the state of the arrays inside CLoadManager and the garbage policy
1.951 + if (err == KErrNoMemory)
1.952 + {
1.953 + //cleanup the previously loaded implementation before leaving
1.954 + iLoadManager->DestroyedThis(instanceKey);
1.955 + delete (CExampleInterface*)impl1;
1.956 + impl1 = NULL;
1.957 + iLoadManager->DestroyedThis(instanceKey2);
1.958 + delete (CExampleInterface*)impl4;
1.959 + impl4 = NULL;
1.960 + iLoadManager->DestroyedThis(instanceKey3);
1.961 + delete (CExampleInterface*)impl2;
1.962 + impl2 = NULL;
1.963 + ::LeaveIfErrNoMemory(err);
1.964 + }
1.965 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 4);
1.966 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
1.967 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.968 +
1.969 + //Destroy Implementation 1
1.970 + iLoadManager->DestroyedThis(instanceKey);
1.971 + delete (CExampleInterface*)impl1;
1.972 + impl1 = NULL;
1.973 + iLoadManager->DestroyedThis(instanceKey2);
1.974 + delete (CExampleInterface*)impl4;
1.975 + impl4 = NULL;
1.976 +
1.977 + //Checks the state of the arrays inside CLoadManager and the garbage policy
1.978 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 2);
1.979 + //Note here after destroying Impl1, the DLL is still in used, so no garbage policy
1.980 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
1.981 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.982 +
1.983 + //Destroy Implementation 2
1.984 + iLoadManager->DestroyedThis(instanceKey3);
1.985 + delete (CExampleInterface*)impl2;
1.986 + impl2 = NULL;
1.987 +
1.988 + //Destroy 2nd Implementation 2
1.989 + iLoadManager->DestroyedThis(instanceKey4);
1.990 + delete (CExampleInterface*)impl3;
1.991 + impl3 = NULL;
1.992 +
1.993 + //Checks the state of the arrays inside CLoadManager and the garbage policy
1.994 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0);
1.995 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0);
1.996 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL);
1.997 +
1.998 + iLoadManager->ClearGarbage();
1.999 +
1.1000 + //Checks the final state of the garbage policy
1.1001 + //Tests for the new API ClearGarbage()
1.1002 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.1003 + }
1.1004 +
1.1005 +
1.1006 +/**
1.1007 +Plugins used:
1.1008 +- Z:\\..\\EComExample2.dll contains ImplUid 0x10009DC3 & 0x10009DC4
1.1009 +
1.1010 +@SYMTestCaseID SYSLIB-ECOM-CT-0702
1.1011 +@SYMTestCaseDesc Tests for create and delete of CLoadManager
1.1012 +@SYMTestPriority High
1.1013 +@SYMTestActions Create two implementation from the SAME DLL
1.1014 +@SYMTestExpectedResults One UnloadPolicy since both Implementation is based on SAME DLL
1.1015 + Two Instance indexes because of two Different Implementations
1.1016 +@SYMREQ REQ0000
1.1017 +*/
1.1018 +void CLoadManagerTest::CreateDestroyTestCase2Plugin1L()
1.1019 + {
1.1020 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-0702 "));
1.1021 + TUid implUid1={0x10009DC3};
1.1022 + TUid implUid2={0x10009DC4};
1.1023 +
1.1024 + TUid dllUid;
1.1025 + dllUid.iUid = 0x10009DB3;
1.1026 +
1.1027 + CreateDestroyTestCase2L(dllUid,implUid1,KExampleDllFileName2,implUid2,KUidInterfaceImplementationCollection);
1.1028 +
1.1029 + }
1.1030 +
1.1031 +/**
1.1032 +@SYMTestCaseID SYSLIB-ECOM-UT-3553
1.1033 +@SYMTestCaseDesc Tests for create and delete of implementations using PLUGIN3 from the SAME DLL
1.1034 +@SYMTestPriority High
1.1035 +@SYMTestActions Create two implementation from the SAME DLL using new Dll type PLUGIN3.
1.1036 + Test executes by getting the CUnloadPolicy* associated to the testing DLL EComExample10.dll.
1.1037 + DestroyThis will actually either remove the UnloadPolicy from the list or decrease
1.1038 + referencecount(to UnloadPolicy) by one.
1.1039 +@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls
1.1040 + One UnloadPolicy since both Implementation is based on SAME DLL
1.1041 + Two Instance indexes because of two Different Implementations
1.1042 +@SYMEC EC43
1.1043 +*/
1.1044 +void CLoadManagerTest::CreateDestroyTestCase2Plugin3L()
1.1045 + {
1.1046 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3553 "));
1.1047 + TUid implUid1 = {0x10009E38};
1.1048 + TUid implUid2 = {0x10009E3A};
1.1049 +
1.1050 + TUid dllUid;
1.1051 + dllUid.iUid = 0x10009E37;
1.1052 +
1.1053 + CreateDestroyTestCase2L(dllUid,implUid1,KExampleDllFileName10,implUid2,KUidInterfaceImplementationCollection3);
1.1054 + }
1.1055 +
1.1056 +
1.1057 +//Test case 3:Invalid argument testing for Create Implementation
1.1058 +// - Invalid Entry and Implementation uid argument in ImplementationObjectL
1.1059 +
1.1060 +/**
1.1061 +@SYMTestCaseID SYSLIB-ECOM-CT-0703
1.1062 +@SYMTestCaseDesc Tests for create CLoadManager
1.1063 +@SYMTestPriority High
1.1064 +@SYMTestActions Passing invalid Entry and Implementation uid argument in ImplementationObjectL
1.1065 +@SYMTestExpectedResults The test must not fail.
1.1066 +@SYMREQ REQ0000
1.1067 +*/
1.1068 +void CLoadManagerTest::CreateDestroyTestCase3L()
1.1069 + {
1.1070 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0703 "));
1.1071 + TUid invalidUid={0x10007777};
1.1072 +
1.1073 + //Try supplying invalid implementaion Uid and invalid entry argument
1.1074 + TUid dllUid;
1.1075 + dllUid.iUid = 0;
1.1076 +
1.1077 + TEntry invalidentry;
1.1078 + invalidentry.iName=_L("Z:\\system\\LIBS\\PLUGINS\\EComExample9.dll");
1.1079 + invalidentry.iModified=TTime(0);
1.1080 + invalidentry.iType=TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection,dllUid);
1.1081 +
1.1082 + TBool initParamsFlag = ETrue;
1.1083 +
1.1084 + TUid instanceKey;
1.1085 + TRAPD(err,iLoadManager->ImplementationObjectL(invalidUid,invalidentry, NULL,initParamsFlag,instanceKey));
1.1086 + ::LeaveIfErrNoMemory(err);
1.1087 + //It will return KErrNotFound as the DLL is invalid
1.1088 + TEST2(err,KErrNotFound);
1.1089 +
1.1090 + //Checking the state of the arrays inside CLoadManager and the garbage policy
1.1091 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==0);
1.1092 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==0);
1.1093 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL);
1.1094 + }
1.1095 +
1.1096 +/**
1.1097 +@SYMTestCaseID SYSLIB-ECOM-UT-3554
1.1098 +@SYMTestCaseDesc Invalid argument testing for Create Implementation using new DLL type PLUGIN3
1.1099 +@SYMTestPriority High
1.1100 +@SYMTestActions Passing invalid Entry and Implementation uid argument in ImplementationObjectL
1.1101 +@SYMTestExpectedResults KErrNotFound will be returned as the DLL is invalid
1.1102 +@SYMEC EC43
1.1103 +*/
1.1104 +void CLoadManagerTest::CreateDestroyTestCase3Plugin3L()
1.1105 + {
1.1106 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3554 "));
1.1107 + // this implementation(0x10009E48) is implemented in EComExample14Upgraded.dll, not in EComExample10.dll
1.1108 + TUid implementationUid = {0x10009E48};
1.1109 +
1.1110 + //Try supplying invalid implementaion Uid and invalid entry argument
1.1111 + TUid dllUid;
1.1112 + dllUid.iUid = 0;
1.1113 +
1.1114 + // Invalid entry for EComExample14Upgraded.dll, because it is not under Z:\\system\\LIBS\\PLUGINS
1.1115 + TEntry invalidentry;
1.1116 + invalidentry.iName = _L("Z:\\system\\LIBS\\PLUGINS\\EComExample14Upgraded.dll");
1.1117 + invalidentry.iModified = TTime(0);
1.1118 + invalidentry.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid);
1.1119 +
1.1120 + TUid dllUid1;
1.1121 + dllUid1.iUid = 0x10009E37;
1.1122 + // Valid entry for EComExample10.dll
1.1123 + TEntry entry;
1.1124 + entry.iName = KExampleDllFileName10;
1.1125 + entry.iModified = TTime(0);
1.1126 + entry.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid1);
1.1127 + TBool initParamsFlag = ETrue;
1.1128 +
1.1129 + // Test for valid implementation Uid with invalid entry.
1.1130 + TUid instanceKey;
1.1131 + TRAPD(err,iLoadManager->ImplementationObjectL(implementationUid,invalidentry, NULL,initParamsFlag,instanceKey));
1.1132 + ::LeaveIfErrNoMemory(err);
1.1133 + //Returns KErrNotFound as the DLL is invalid
1.1134 + TEST2(err,KErrNotFound);
1.1135 + //Checks the state of the arrays inside CLoadManager and the garbage policy
1.1136 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==0);
1.1137 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==0);
1.1138 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL);
1.1139 +
1.1140 + // Tests for invalid implementation Uid with valid entry.
1.1141 + TRAP(err,iLoadManager->ImplementationObjectL(implementationUid,entry, NULL,initParamsFlag,instanceKey));
1.1142 + ::LeaveIfErrNoMemory(err);
1.1143 + //Returns KErrNotFound as the implementation Uid is not within the DLL
1.1144 + TEST2(err,KErrNotFound);
1.1145 +
1.1146 + //Checks the state of the arrays inside CLoadManager and the garbage policy
1.1147 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0);
1.1148 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0);
1.1149 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL);
1.1150 + }
1.1151 +
1.1152 +//Test case 4:Create two instance of the same implementation Uid from one single DLL
1.1153 +
1.1154 +void CLoadManagerTest::CreateDestroyTestCase4L(TUid aDllUid,
1.1155 + TUid aImplUid,
1.1156 + const TDesC& aDllName,
1.1157 + const TUid aIICType)
1.1158 + {
1.1159 + TInt err;
1.1160 + TEntry entry;
1.1161 + entry.iName=aDllName;
1.1162 + entry.iModified=TTime(0);
1.1163 + entry.iType=TUidType(KDynamicLibraryUid,aIICType,aDllUid);
1.1164 +
1.1165 + CExampleInterface::TExampleInterfaceInitParams iInitParams;
1.1166 + iInitParams.integer = 5;
1.1167 + TBool initParamsFlag = ETrue;
1.1168 + _LIT(KDummyText,"Dummy params");
1.1169 + iInitParams.descriptor = &KDummyText;
1.1170 + TAny* impl1=NULL;
1.1171 + TAny* impl2=NULL;
1.1172 +
1.1173 + //Create 1st instance of implementation
1.1174 + TUid instanceKey;
1.1175 + TRAP(err,impl1=iLoadManager->ImplementationObjectL(aImplUid,entry, &iInitParams,initParamsFlag,instanceKey));
1.1176 + ::LeaveIfErrNoMemory(err);
1.1177 + TEST2(err,KErrNone);
1.1178 +
1.1179 + //Checking the state of the arrays inside CLoadManager and the garbage policy
1.1180 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==1);
1.1181 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==1);
1.1182 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL);
1.1183 +
1.1184 + //Create 2nd instance of the same implementation
1.1185 + TUid instanceKey2;
1.1186 + TRAP(err,impl2=iLoadManager->ImplementationObjectL(aImplUid,entry, &iInitParams,initParamsFlag,instanceKey2));
1.1187 + // If impl2 fails here due to KErrNoMemory we need to clear the previous impl1
1.1188 + // to avoid memory leak
1.1189 + if (err==KErrNoMemory)
1.1190 + {
1.1191 + iLoadManager->DestroyedThis(instanceKey);
1.1192 + delete (CExampleInterface*)impl1;
1.1193 + impl1=NULL;
1.1194 + ::LeaveIfErrNoMemory(err);
1.1195 + }
1.1196 +
1.1197 + TEST(err==KErrNone);
1.1198 +
1.1199 + //Checking the state of the arrays inside CLoadManager and the garbage policy
1.1200 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==2);
1.1201 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==1);
1.1202 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL);
1.1203 +
1.1204 + //Destroyed the 2nd instance of implementation
1.1205 + iLoadManager->DestroyedThis(instanceKey2);
1.1206 + delete (CExampleInterface*)impl2;
1.1207 + impl2=NULL;
1.1208 +
1.1209 + //Checking the state of the arrays inside CLoadManager and the garbage policy
1.1210 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==1);
1.1211 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==1);
1.1212 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL);
1.1213 +
1.1214 + //Destroyed the 1st instance of implementation
1.1215 + iLoadManager->DestroyedThis(instanceKey);
1.1216 + delete (CExampleInterface*)impl1;
1.1217 + impl1=NULL;
1.1218 +
1.1219 + //Checking the state of the arrays inside CLoadManager and the garbage policy
1.1220 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager)==0);
1.1221 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager)==0);
1.1222 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)!=NULL);
1.1223 +
1.1224 + iLoadManager->ClearGarbage();
1.1225 + //Checking the final state of the garbage policy
1.1226 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager)==NULL);
1.1227 + }
1.1228 +
1.1229 +
1.1230 +/**
1.1231 +Plugins used:
1.1232 +- Z:\\..\\EComExample2.dll contains ImplUid 0x10009DC3 & 0x10009DC4
1.1233 +
1.1234 +@SYMTestCaseID SYSLIB-ECOM-CT-0704
1.1235 +@SYMTestCaseDesc Tests for create and delete of CLoadManager
1.1236 +@SYMTestPriority High
1.1237 +@SYMTestActions Create two instance of the same implementation Uid from one single DLL
1.1238 +@SYMTestExpectedResults CLoadManager only maintains a single UnloadPolicy and one policy
1.1239 + mapping index
1.1240 +@SYMREQ REQ0000
1.1241 +*/
1.1242 +void CLoadManagerTest::CreateDestroyTestCase4Plugin1L()
1.1243 + {
1.1244 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0704 "));
1.1245 + TUid implUid={0x10009DC3};
1.1246 +
1.1247 + TUid dllUid;
1.1248 + dllUid.iUid = 0x10009DB3;
1.1249 +
1.1250 + CreateDestroyTestCase4L(dllUid,implUid,KExampleDllFileName2,KUidInterfaceImplementationCollection);
1.1251 + }
1.1252 +
1.1253 +/**
1.1254 +@SYMTestCaseID SYSLIB-ECOM-UT-3555
1.1255 +@SYMTestCaseDesc Create two instance of the same implementation Uid from one single DLL using PLUGIN3
1.1256 + Plugins used:
1.1257 + - Z:\\..\\EComExample10.dll contains ImplUid 0x10009E38 & 0x10009E3A
1.1258 +@SYMTestPriority High
1.1259 +@SYMTestActions Create two instance of the same implementation Uid from one single DLL
1.1260 +@SYMTestExpectedResults Ensure the CLoadManager data structures are as expected after the ImplementationObjectL calls
1.1261 + CLoadManager only maintains a single UnloadPolicy and one instance
1.1262 +@SYMEC EC43
1.1263 +*/
1.1264 +void CLoadManagerTest::CreateDestroyTestCase4Plugin3L()
1.1265 + {
1.1266 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3555 "));
1.1267 + TUid implUid={0x10009E38};
1.1268 +
1.1269 + TUid dllUid;
1.1270 + dllUid.iUid = 0x10009E37;
1.1271 +
1.1272 + CreateDestroyTestCase4L(dllUid,implUid,KExampleDllFileName10,KUidInterfaceImplementationCollection3);
1.1273 + }
1.1274 +
1.1275 +
1.1276 +// Test case 5: DEF101930: Incorrect policy object returned in
1.1277 +
1.1278 +
1.1279 +void CLoadManagerTest::CreateDestroyTestCase5L(TUid aDllUid1,
1.1280 + TUid aImplUid1,
1.1281 + const TDesC& aDllName1,
1.1282 + TUid aDllUid2,
1.1283 + TUid aImplUid2,
1.1284 + const TDesC& aDllName2,
1.1285 + TUid aImplUid3,
1.1286 + const TUid aIICType)
1.1287 + {
1.1288 + CExampleInterface::TExampleInterfaceInitParams iInitParams;
1.1289 + iInitParams.integer = 5;
1.1290 + TBool initParamsFlag = ETrue;
1.1291 + _LIT(KDummyText,"Dummy params");
1.1292 + iInitParams.descriptor = &KDummyText;
1.1293 + TAny* impl1 = NULL;
1.1294 + TAny* impl2 = NULL;
1.1295 + TAny* impl3 = NULL;
1.1296 +
1.1297 + TEntry entryExample1;
1.1298 + entryExample1.iName = aDllName1;
1.1299 + entryExample1.iModified = TTime(0);
1.1300 + entryExample1.iType = TUidType(KDynamicLibraryUid,aIICType,aDllUid1);
1.1301 +
1.1302 + TEntry entryExample2;
1.1303 + entryExample2.iName = aDllName2;
1.1304 + entryExample2.iModified = TTime(0);
1.1305 + entryExample2.iType = TUidType(KDynamicLibraryUid,aIICType,aDllUid2);
1.1306 +
1.1307 + TInt err;
1.1308 + TUid instanceKey2;
1.1309 +
1.1310 + //Create Implementation 2
1.1311 + TRAP(err,impl2 = iLoadManager->ImplementationObjectL(aImplUid2,entryExample1, &iInitParams,initParamsFlag,instanceKey2));
1.1312 + ::LeaveIfErrNoMemory(err);
1.1313 + TEST(err == KErrNone);
1.1314 + //Checking the state of the arrays inside CLoadManager and the garbage policy
1.1315 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1);
1.1316 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
1.1317 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.1318 +
1.1319 + TUid instanceKey3;
1.1320 + //Create Implementation 3
1.1321 + TRAP(err,impl3 = iLoadManager->ImplementationObjectL(aImplUid3,entryExample2, &iInitParams,initParamsFlag,instanceKey3));
1.1322 + // If impl3 fails here due to KErrNoMemory we need to clear the previous impl2
1.1323 + // to avoid memory leak
1.1324 + if (err == KErrNoMemory)
1.1325 + {
1.1326 + iLoadManager->DestroyedThis(instanceKey2);
1.1327 + delete (CExampleInterface*)impl2;
1.1328 + impl2 = NULL;
1.1329 + ::LeaveIfErrNoMemory(err);
1.1330 + }
1.1331 + TEST2(err,KErrNone);
1.1332 +
1.1333 + //Checking the state of the arrays inside CLoadManager and the garbage policy
1.1334 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 2);
1.1335 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 2);
1.1336 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.1337 +
1.1338 + //Create Implementation 1
1.1339 + TUid instanceKey1;
1.1340 + TRAP(err,impl1 = iLoadManager->ImplementationObjectL(aImplUid1,entryExample1, &iInitParams,initParamsFlag,instanceKey1));
1.1341 + // If impl1 fails here due to KErrNoMemory we need to clear the previous impl2 and impl3
1.1342 + // to avoid memory leak
1.1343 + if (err == KErrNoMemory)
1.1344 + {
1.1345 + iLoadManager->DestroyedThis(instanceKey2);
1.1346 + delete (CExampleInterface*)impl2;
1.1347 + impl2=NULL;
1.1348 + iLoadManager->DestroyedThis(instanceKey3);
1.1349 + delete (CExampleInterface*)impl3;
1.1350 + impl3=NULL;
1.1351 + ::LeaveIfErrNoMemory(err);
1.1352 + }
1.1353 + TEST2(err,KErrNone);
1.1354 +
1.1355 + //Checking the state of the arrays inside CLoadManager and the garbage policy
1.1356 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 3);
1.1357 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 2);
1.1358 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.1359 +
1.1360 + //Destroy Implementation 1
1.1361 + iLoadManager->DestroyedThis(instanceKey1);
1.1362 + delete (CExampleInterface*)impl1;
1.1363 + impl1 = NULL;
1.1364 +
1.1365 + //Destroy Implementation 2
1.1366 + iLoadManager->DestroyedThis(instanceKey2);
1.1367 + delete (CExampleInterface*)impl2;
1.1368 + impl2 = NULL;
1.1369 +
1.1370 + //Destroy Implementation 3
1.1371 + iLoadManager->DestroyedThis(instanceKey3);
1.1372 + delete (CExampleInterface*)impl3;
1.1373 + impl3 = NULL;
1.1374 +
1.1375 + //Checking the state of the arrays inside CLoadManager and the garbage policy
1.1376 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0);
1.1377 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0);
1.1378 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) != NULL);
1.1379 +
1.1380 + iLoadManager->ClearGarbage();
1.1381 +
1.1382 + //Checking the final state of the garbage policy
1.1383 + //Test for the new API ClearGarbage()
1.1384 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.1385 +
1.1386 + }
1.1387 +
1.1388 +/**
1.1389 +Plugins used:
1.1390 +- Z:\\..\\EComLoadMgrExample1.dll contains ImplUid 0x10282332 & 0x10282334
1.1391 +- Z:\\..\\EComLoadMgrExample2.dll contains ImplUid 0x10282333
1.1392 +
1.1393 +@SYMTestCaseID SYSLIB-ECOM-UT-3372
1.1394 +@SYMTestCaseDesc This testcase checks for the case where 2 implementations
1.1395 + are created each on separate DLL's then an additional
1.1396 + implementation is created from one of the already loaded DLL's.
1.1397 + The impl uid of the newly created impl is lower then the 2
1.1398 + existing impl uids. The impl uids from the same DLL are such
1.1399 + that 1 is higher then the uid of the other impl and 1 is lower than
1.1400 + the other impl.
1.1401 +@SYMTestPriority High
1.1402 +@SYMTestActions Load impls 0x10282333 and 0x10282334 first and then load impl
1.1403 + 0x10282332.
1.1404 +@SYMTestExpectedResults Leave with KErrNotFound must not occur.
1.1405 + Policy and unload policy counts must be updated
1.1406 + as described in the test.
1.1407 +@SYMDEF DEF101930
1.1408 +*/
1.1409 +void CLoadManagerTest::CreateDestroyTestCase5Plugin1L()
1.1410 + {
1.1411 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3372 "));
1.1412 + TUid implUid1={0x10282332};
1.1413 + TUid implUid2={0x10282334};
1.1414 + TUid implUid3={0x10282333};
1.1415 +
1.1416 + TUid dllUidExample1;
1.1417 + dllUidExample1.iUid = 0x10282330;
1.1418 +
1.1419 + TUid dllUidExample2;
1.1420 + dllUidExample2.iUid = 0x10282335;
1.1421 +
1.1422 + CreateDestroyTestCase5L(dllUidExample1,
1.1423 + implUid1,
1.1424 + KLoadMgrExample1DllName,
1.1425 + dllUidExample2,
1.1426 + implUid2,
1.1427 + KLoadMgrExample2DllName,
1.1428 + implUid3,
1.1429 + KUidInterfaceImplementationCollection);
1.1430 + }
1.1431 +
1.1432 +/**
1.1433 +@SYMTestCaseID SYSLIB-ECOM-UT-3556
1.1434 +@SYMTestCaseDesc DEF101930: Incorrect policy object returned in
1.1435 + This testcase checks for the case where 2 implementations
1.1436 + are created each on separate DLL's then an additional
1.1437 + implementation is created from one of the already loaded DLL's.
1.1438 + The impl uid of the newly created impl is lower then the 2
1.1439 + existing impl uids. The impl uids from the same DLL are such
1.1440 + that 1 is higher then the uid of the other impl and 1 is lower than
1.1441 + the other impl. DEF101930: Incorrect policy object returned in
1.1442 +
1.1443 + Plugins used:
1.1444 + - Z:\\..\\EComExample10.dll contains ImplUid 0x10009E38 & 0x10009E3A
1.1445 + - Z:\\..\\EComExample12.dll contains ImplUid 0x10009E39
1.1446 +@SYMTestPriority High
1.1447 +@SYMTestActions Load impls 0x10009E3A and 0x10009E39 first and then load impl 0x10009E38.
1.1448 +@SYMTestExpectedResults Leave with KErrNotFound must not occur.
1.1449 + Policy and unload policy counts must be updated
1.1450 + as described in the test.
1.1451 +@SYMEC EC43 (tested for PLUGIN3 too now, copied from UT-3372)
1.1452 +*/
1.1453 +void CLoadManagerTest::CreateDestroyTestCase5Plugin3L()
1.1454 + {
1.1455 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3556 "));
1.1456 + TUid implUid1={0x10009E38};
1.1457 + TUid implUid2={0x10009E3A};
1.1458 + TUid implUid3={0x10009E39};
1.1459 +
1.1460 + TUid dllUidExample1;
1.1461 + dllUidExample1.iUid = 0x10009E37;
1.1462 +
1.1463 + TUid dllUidExample2;
1.1464 + dllUidExample2.iUid = 0x10009E3E;
1.1465 +
1.1466 + CreateDestroyTestCase5L(dllUidExample1,
1.1467 + implUid1,
1.1468 + KExampleDllFileName10,
1.1469 + dllUidExample2,
1.1470 + implUid2,
1.1471 + KExampleDllFileName12,
1.1472 + implUid3,
1.1473 + KUidInterfaceImplementationCollection3);
1.1474 + }
1.1475 +
1.1476 +
1.1477 +/**
1.1478 +@SYMTestCaseID SYSLIB-ECOM-CT-0705
1.1479 +@SYMTestCaseDesc Tests for production class CLoadManager
1.1480 +@SYMTestPriority High
1.1481 +@SYMTestActions Check for null condition while creating a new CLoadManagerTest object.
1.1482 +@SYMTestExpectedResults The test must not fail.
1.1483 +@SYMREQ REQ0000
1.1484 +*/
1.1485 +LOCAL_C void CreateDeleteTestL()
1.1486 + {
1.1487 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0705 CreateDeleteTestL "));
1.1488 +
1.1489 + //
1.1490 + // Tests the Creating and deletion of CLoadManager
1.1491 + // ------------------------------------------------------------------
1.1492 + //
1.1493 + // Set up for heap leak checking
1.1494 + __UHEAP_MARK;
1.1495 +
1.1496 + TInt startProcessHandleCount = 0;
1.1497 + TInt startThreadHandleCount = 0;
1.1498 + TInt endProcessHandleCount = 0;
1.1499 + TInt endThreadHandleCount = 0;
1.1500 +
1.1501 + RThread rThread;
1.1502 + rThread.HandleCount(startProcessHandleCount, startThreadHandleCount);
1.1503 +
1.1504 + //CREATE DELETE TEST START//
1.1505 +
1.1506 + CLoadManagerTest* loadManagerTest = CLoadManagerTest::NewL();
1.1507 +
1.1508 + TEST(loadManagerTest != NULL);
1.1509 +
1.1510 + delete loadManagerTest;
1.1511 +
1.1512 + //CREATE DELETE TEST END//
1.1513 +
1.1514 + rThread.HandleCount(endProcessHandleCount, endThreadHandleCount);
1.1515 + TEST(startThreadHandleCount == endThreadHandleCount);
1.1516 +
1.1517 + __UHEAP_MARKEND;
1.1518 + }
1.1519 +
1.1520 +/**
1.1521 +@SYMTestCaseID SYSLIB-ECOM-CT-0706
1.1522 +@SYMTestCaseDesc OOM test while creating and deleting CLoadManager
1.1523 +@SYMTestPriority High
1.1524 +@SYMTestActions Create and delete CLoadManager object and test that no handles have leaked
1.1525 +@SYMTestExpectedResults The test must not fail.
1.1526 +@SYMREQ REQ0000
1.1527 +*/
1.1528 +LOCAL_C void OOMCreateDeleteTest()
1.1529 + {
1.1530 + //
1.1531 + // Out of memory test
1.1532 + // ------------------------------------------------------------------
1.1533 + //
1.1534 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0706 OOMCreateDeleteTest "));
1.1535 + TInt err;
1.1536 + TInt failAt = 1;
1.1537 + __UNUSED_VAR(failAt);
1.1538 +
1.1539 + CLoadManagerTest* loadManagerTest = NULL;
1.1540 +
1.1541 + do
1.1542 + {
1.1543 + __UHEAP_MARK;
1.1544 + // find out the number of open handles
1.1545 + TInt startProcessHandleCount;
1.1546 + TInt startThreadHandleCount;
1.1547 + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
1.1548 +
1.1549 + // Setting Heap failure for OOM test
1.1550 + __UHEAP_SETFAIL(RHeap::EDeterministic, failAt++);
1.1551 +
1.1552 + TRAP(err, loadManagerTest = CLoadManagerTest::NewL());
1.1553 +
1.1554 + __UHEAP_SETFAIL(RHeap::ENone, 0);
1.1555 +
1.1556 + delete loadManagerTest;
1.1557 + loadManagerTest = NULL;
1.1558 +
1.1559 + // check that no handles have leaked
1.1560 + TInt endProcessHandleCount;
1.1561 + TInt endThreadHandleCount;
1.1562 + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
1.1563 +
1.1564 + TEST(startProcessHandleCount == endProcessHandleCount);
1.1565 + TEST(startThreadHandleCount == endThreadHandleCount);
1.1566 +
1.1567 + __UHEAP_MARKEND;
1.1568 + }
1.1569 + while (err == KErrNoMemory);
1.1570 +
1.1571 + TheTest.Printf(_L("- Succeeded at heap failure rate of %i\n"), failAt);
1.1572 + TEST(err == KErrNone);
1.1573 + }
1.1574 +
1.1575 +/**
1.1576 +@SYMTestCaseID SYSLIB-ECOM-UT-3557
1.1577 +@SYMTestCaseDesc This testcase tests fetching extended interfaces for ImplUid 0x10009E38.
1.1578 + One interface will be the part of the main implementation object, the
1.1579 + second interface will be a separate interface requiring release. Also tests
1.1580 + that the extended interfaces are automatically destroyed.
1.1581 +
1.1582 + Plugins used:
1.1583 + - Z:\\..\\EComExample10.dll contains ImplUid 0x10009E38 with extended interface
1.1584 + 0x10009E44, 0x10009E45 and 0x10009E46
1.1585 +@SYMTestPriority High
1.1586 +@SYMTestActions This testcase will test one implementation with two extended interfaces.
1.1587 + Create implementation, then fetch extended interface 0x10009E44. Secondly,
1.1588 + fetch 0x10009E45 interface. This will be a separate interface requiring release.
1.1589 + Destroy the interfaces.
1.1590 + Attempt fetch of interface again. Expect Leave with KErrNotFound as implementation
1.1591 + no longer exists.
1.1592 +@SYMTestExpectedResults Extended instance count will be zero for 0x10009E44 extended interface,
1.1593 + 0x10009E45 will have an extended instance count of one. No memory leaks
1.1594 + after implementation, including extended interfaces are automatically
1.1595 + destroyed.
1.1596 +@SYMEC EC43
1.1597 +@SYMDEF DEF111553
1.1598 +*/
1.1599 +void CLoadManagerTest::ExtendedMethodTest1Plugin3L()
1.1600 + {
1.1601 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3557 "));
1.1602 + CExampleInterface::TExampleInterfaceInitParams iInitParams;
1.1603 + iInitParams.integer = 5;
1.1604 + TBool initParamsFlag = ETrue;
1.1605 + _LIT(KDummyText,"Dummy params");
1.1606 + iInitParams.descriptor = &KDummyText;
1.1607 + TUid dllUid;
1.1608 + dllUid.iUid = 0x10009E37;
1.1609 +
1.1610 + TEntry entry;
1.1611 + entry.iName = KExampleDllFileName10;
1.1612 + entry.iModified = TTime(0);
1.1613 + entry.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid);
1.1614 +
1.1615 + iImplementationUid.iUid = 0x10009E38;
1.1616 +
1.1617 + CExampleInterface* implementationPtr = 0;
1.1618 + TUid instanceKey;
1.1619 + TRAPD(err, implementationPtr = reinterpret_cast<CExampleInterface*>(iLoadManager->ImplementationObjectL(iImplementationUid, entry,&iInitParams, initParamsFlag,instanceKey)));
1.1620 +
1.1621 + ::LeaveIfErrNoMemory(err);
1.1622 + TEST2(err,KErrNone);
1.1623 + TEST(implementationPtr != 0);
1.1624 +
1.1625 + CleanupStack::PushL(implementationPtr);
1.1626 +
1.1627 + //Checks the state of the arrays inside CLoadManager and garbage policy
1.1628 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1);
1.1629 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
1.1630 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.1631 +
1.1632 + //Checks the instance index and UnloadPolicy info
1.1633 + TEST(iStateAccessor.InstanceIndex(0,*iLoadManager)->ImplementationUid() == iImplementationUid);
1.1634 + TEST(iStateAccessor.UnloadPolicy(0,*iLoadManager)->DllEntryInformation().GetName().CompareF(KExampleDllFileName10) == 0);
1.1635 +
1.1636 + // Call extended interface here.
1.1637 + const TUid KExample10InterfaceUid1 = {0x10009E44}; // Part of main interface
1.1638 + const TUid KExample10InterfaceUid2 = {0x10009E45}; // Separate interface
1.1639 +
1.1640 + MExampleInterfaceExtended* ext1 = static_cast<MExampleInterfaceExtended*>(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid1 ));
1.1641 + // Extended interface part of main interface, so no extended object info is needed to be created.
1.1642 + TEST2(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager),0);
1.1643 + ext1->DoMethodExtended();
1.1644 +
1.1645 + MExampleInterfaceExtended2* ext2 = static_cast<MExampleInterfaceExtended2*>(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid2 ));
1.1646 + // Separate extended interface, so there will be an extended object info created to track
1.1647 + // this extended interface so it can be deleted later when the extended interface is no
1.1648 + // longer needed.
1.1649 + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager)==1);
1.1650 + ext2->DoMethodExtended2();
1.1651 +
1.1652 + CleanupStack::PopAndDestroy(implementationPtr);
1.1653 + implementationPtr = 0;
1.1654 + iLoadManager->DestroyedThis(instanceKey);
1.1655 + iLoadManager->ClearGarbage();
1.1656 + //Checks the state of the arrays inside CLoadManager and garbage policy
1.1657 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0);
1.1658 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0);
1.1659 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.1660 +
1.1661 + // call again now that implementation has been removed. Expecting a Leave
1.1662 + TRAP(err, iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid2 ));
1.1663 + TEST2(err, KErrNotFound);
1.1664 + }
1.1665 +
1.1666 +/**
1.1667 +@SYMTestCaseID SYSLIB-ECOM-UT-3558
1.1668 +@SYMTestCaseDesc This testcase tests fetching extended interfaces for ImplUid 0x10009E38.
1.1669 + One interface will be the part of the main implementation object, the
1.1670 + second interface will be a separate interface requiring release. Tests
1.1671 + that manual release successful for interface requiring release. Tests
1.1672 + no memory leaks, and no double release of manually released interface.
1.1673 +
1.1674 + Plugins used:
1.1675 + - Z:\\..\\EComExample10.dll contains ImplUid 0x10009E38 with extended interface
1.1676 + 0x10009E44, 0x10009E45 and 0x10009E46
1.1677 +@SYMTestPriority High
1.1678 +@SYMTestActions This testcase will test one implementation with two extended interfaces.
1.1679 + Create implementation, then fetch extended interface 0x10009E44. Secondly,
1.1680 + fetch 0x10009E45 interface. This will be a separate interface requiring release.
1.1681 + Manually release extended interface. Destroy the interfaces.
1.1682 + Attempt fetch of interface again. Expect Leave with KErrNotFound as implementation
1.1683 + no longer exists.
1.1684 +@SYMTestExpectedResults Extended instance count will be zero for 0x10009E44 extended interface,
1.1685 + 0x10009E45 will have an extended instance count of one. After manual
1.1686 + release, the extended interface count will be zero. No memory leaks after
1.1687 + implementation, including extended interfaces are automatically destroyed.
1.1688 + No double release of extended interface already manually released.
1.1689 +@SYMEC EC43
1.1690 +@SYMDEF DEF111553
1.1691 +*/
1.1692 +void CLoadManagerTest::ExtendedMethodTest2Plugin3L()
1.1693 + {
1.1694 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3558 "));
1.1695 + CExampleInterface::TExampleInterfaceInitParams iInitParams;
1.1696 + iInitParams.integer = 5;
1.1697 + TBool initParamsFlag = ETrue;
1.1698 + _LIT(KDummyText,"Dummy params");
1.1699 + iInitParams.descriptor = &KDummyText;
1.1700 + TUid dllUid;
1.1701 + dllUid.iUid = 0x10009E37;
1.1702 +
1.1703 + TEntry entry;
1.1704 + entry.iName = KExampleDllFileName10;
1.1705 + entry.iModified = TTime(0);
1.1706 + entry.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid);
1.1707 +
1.1708 + iImplementationUid.iUid = 0x10009E38;
1.1709 +
1.1710 + CExampleInterface* implementationPtr = 0;
1.1711 + TUid instanceKey;
1.1712 + TRAPD(err, implementationPtr = reinterpret_cast<CExampleInterface*>(iLoadManager->ImplementationObjectL(iImplementationUid, entry,&iInitParams, initParamsFlag,instanceKey)));
1.1713 +
1.1714 + ::LeaveIfErrNoMemory(err);
1.1715 + TEST2(err,KErrNone);
1.1716 + TEST(implementationPtr != 0);
1.1717 +
1.1718 + CleanupStack::PushL(implementationPtr);
1.1719 +
1.1720 + //Checks the state of the arrays inside CLoadManager and garbage policy
1.1721 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 1);
1.1722 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 1);
1.1723 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.1724 +
1.1725 + //Checks the instance index and UnloadPolicy info
1.1726 + TEST(iStateAccessor.InstanceIndex(0,*iLoadManager)->ImplementationUid() == iImplementationUid);
1.1727 + TEST(iStateAccessor.UnloadPolicy(0,*iLoadManager)->DllEntryInformation().GetName().CompareF(KExampleDllFileName10) == 0);
1.1728 +
1.1729 + // Call extended interface here.
1.1730 + const TUid KExample10InterfaceUid1 = {0x10009E44};
1.1731 + const TUid KExample10InterfaceUid2 = {0x10009E45}; // separate interface object
1.1732 +
1.1733 + MExampleInterfaceExtended* ext1 = static_cast<MExampleInterfaceExtended*>(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid1 ));
1.1734 + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 0); // Does not need to be released, so will not be added to extended object array
1.1735 + ext1->DoMethodExtended();
1.1736 +
1.1737 + MExampleInterfaceExtended2* ext2 = static_cast<MExampleInterfaceExtended2*>(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid2 ));
1.1738 + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 1); // Needs to be released
1.1739 + ext2->DoMethodExtended2();
1.1740 +
1.1741 + iLoadManager->ManuallyReleaseExtendedInterfaceL(instanceKey, KExample10InterfaceUid2);
1.1742 + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 0);
1.1743 +
1.1744 + CleanupStack::PopAndDestroy(implementationPtr);
1.1745 + implementationPtr = 0;
1.1746 + iLoadManager->DestroyedThis(instanceKey);
1.1747 + iLoadManager->ClearGarbage();
1.1748 + //Checks the state of the arrays inside CLoadManager and garbage policy
1.1749 + TEST(iStateAccessor.InstanceIndexCount(*iLoadManager) == 0);
1.1750 + TEST(iStateAccessor.UnloadPolicyCount(*iLoadManager) == 0);
1.1751 + TEST(iStateAccessor.GarbagePolicy(*iLoadManager) == NULL);
1.1752 +
1.1753 + // call again now that implementation has been removed. Expecting a Leave
1.1754 + TRAP(err, iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid2 ));
1.1755 + TEST2(err, KErrNotFound);
1.1756 + }
1.1757 +
1.1758 +/**
1.1759 +@SYMTestCaseID SYSLIB-ECOM-UT-3711
1.1760 +@SYMTestCaseDesc This testcase tests ManuallyReleaseExtendedInterfaces function for releasing
1.1761 + extended interface which require release and releasing extended interface
1.1762 + which doesn't require release. Also tests for releasing same extended interface twice
1.1763 +
1.1764 + Plugins used:
1.1765 + - Z:\\..\\EComExample10.dll contains ImplUid 0x10009E38 with extended interface
1.1766 + 0x10009E44, 0x10009E45 and 0x10009E46
1.1767 +@SYMTestPriority High
1.1768 +@SYMTestActions This testcase will do the tests as below:
1.1769 + 1. create implementation 0x10009E38.
1.1770 + 2. Get extended interface 0x10009E44,0x10009E45 and 0x10009E46.
1.1771 + 3. Manually release extended interface 0x10009E44 which does not require release.
1.1772 + 4. Manually release extended interface 0x10009E45 which require manually release.
1.1773 + 5. Again manually release extended interface 0x10009E45 which require manually release.
1.1774 + 6. Manually release extended interface 0x10009E46 which require manually release.
1.1775 + 7. Destroy the interfaces
1.1776 + 8. Attempt fetch manual release again. Expect Leave with KErrNotFound as implementation
1.1777 + no longer exists.
1.1778 +@SYMTestExpectedResults Extended instance count is set correctly.
1.1779 +@SYMDEF DEF111196
1.1780 +@SYMDEF DEF111553
1.1781 +*/
1.1782 +void CLoadManagerTest::ManuallyReleaseExtendedInterfaceTestL()
1.1783 + {
1.1784 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3711 "));
1.1785 + CExampleInterface::TExampleInterfaceInitParams iInitParams;
1.1786 + iInitParams.integer = 5;
1.1787 + TBool initParamsFlag = ETrue;
1.1788 + _LIT(KDummyText,"Dummy params");
1.1789 + iInitParams.descriptor = &KDummyText;
1.1790 + TUid dllUid;
1.1791 + dllUid.iUid = 0x10009E37;
1.1792 +
1.1793 + TEntry entry;
1.1794 + entry.iName = KExampleDllFileName10;
1.1795 + entry.iModified = TTime(0);
1.1796 + entry.iType = TUidType(KDynamicLibraryUid,KUidInterfaceImplementationCollection3,dllUid);
1.1797 +
1.1798 + iImplementationUid.iUid = 0x10009E38;
1.1799 +
1.1800 + CExampleInterface* implementationPtr = 0;
1.1801 + TUid instanceKey;
1.1802 + TRAPD(err, implementationPtr = reinterpret_cast<CExampleInterface*>(iLoadManager->ImplementationObjectL(iImplementationUid, entry,&iInitParams, initParamsFlag,instanceKey)));
1.1803 +
1.1804 + ::LeaveIfErrNoMemory(err);
1.1805 + TEST2(err,KErrNone);
1.1806 + TEST(implementationPtr != 0);
1.1807 +
1.1808 + CleanupStack::PushL(implementationPtr);
1.1809 +
1.1810 + const TUid KExample10InterfaceUid1 = {0x10009E44};
1.1811 + const TUid KExample10InterfaceUid2 = {0x10009E45}; // separate interface object
1.1812 + const TUid KExample10InterfaceUid3 = {0x10009E46}; // separate interface object
1.1813 +
1.1814 + // Gets extended interface 0x10009E44
1.1815 + MExampleInterfaceExtended* ext1 = static_cast<MExampleInterfaceExtended*>(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid1 ));
1.1816 + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 0); // Does not need to be released, so will not be added to extended object array
1.1817 +
1.1818 + // Gets extended interface 0x10009E45
1.1819 + MExampleInterfaceExtended2* ext2 = static_cast<MExampleInterfaceExtended2*>(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid2 ));
1.1820 + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 1); // Needs to be released
1.1821 +
1.1822 + // Gets extended interface 0x10009E46
1.1823 + MExampleInterfaceExtended2* ext3 = static_cast<MExampleInterfaceExtended2*>(iLoadManager->GetExtendedInterfaceL(instanceKey, KExample10InterfaceUid3 ));
1.1824 + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 2); // Needs to be released
1.1825 +
1.1826 + // call ManuallyReleaseExtendedInterface for 0x10009E44.
1.1827 + // Nothing would happen because 0x10009E44 is not require release.
1.1828 + iLoadManager->ManuallyReleaseExtendedInterfaceL(instanceKey, KExample10InterfaceUid1);
1.1829 + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 2);
1.1830 +
1.1831 + // call ManuallyReleaseExtendedInterface for 0x10009E45.
1.1832 + // extended instance count would be 1
1.1833 + iLoadManager->ManuallyReleaseExtendedInterfaceL(instanceKey, KExample10InterfaceUid2);
1.1834 + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 1);
1.1835 +
1.1836 + // call ManuallyReleaseExtendedInterface again, nothing would happen because 0x10009E45 has been released.
1.1837 + iLoadManager->ManuallyReleaseExtendedInterfaceL(instanceKey, KExample10InterfaceUid2);
1.1838 + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 1);
1.1839 +
1.1840 + // call ManuallyReleaseExtendedInterface for 0x10009E46.
1.1841 + // extended instance count would be 0
1.1842 + iLoadManager->ManuallyReleaseExtendedInterfaceL(instanceKey, KExample10InterfaceUid3);
1.1843 + TEST(iStateAccessor.ExtendedInstanceCount(0,*iLoadManager) == 0);
1.1844 +
1.1845 + CleanupStack::PopAndDestroy(implementationPtr);
1.1846 + implementationPtr = 0;
1.1847 + iLoadManager->DestroyedThis(instanceKey);
1.1848 + iLoadManager->ClearGarbage();
1.1849 +
1.1850 + // call again now that implementation has been removed. Expecting a Leave
1.1851 + TRAP(err, iLoadManager->ManuallyReleaseExtendedInterfaceL(instanceKey, KExample10InterfaceUid3 ));
1.1852 + TEST2(err, KErrNotFound);
1.1853 + }
1.1854 +
1.1855 +
1.1856 +
1.1857 +typedef void (CLoadManagerTest::*ClassFuncPtrL) (void);
1.1858 +
1.1859 +/**
1.1860 +@SYMTestCaseID SYSLIB-ECOM-CT-0707
1.1861 +@SYMTestCaseDesc Wrapper function to call all test functions
1.1862 +@SYMTestPriority High
1.1863 +@SYMTestActions Calls up CLoadManagerTest's test function.
1.1864 +@SYMTestExpectedResults The test must not fail.
1.1865 +@SYMREQ REQ0000
1.1866 +*/
1.1867 +/**
1.1868 +Wrapper function to call all test functions
1.1869 +
1.1870 +@param testFuncL pointer to test function
1.1871 +@param aTestDesc test function name
1.1872 +*/
1.1873 +LOCAL_C void DoBasicTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc)
1.1874 + {
1.1875 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0707 "));
1.1876 + TheTest.Next(aTestDesc);
1.1877 +
1.1878 + __UHEAP_MARK;
1.1879 + // find out the number of open handles
1.1880 + TInt startProcessHandleCount;
1.1881 + TInt startThreadHandleCount;
1.1882 + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
1.1883 +
1.1884 + CLoadManagerTest* loadManagerTest = CLoadManagerTest::NewL();
1.1885 + CleanupStack::PushL(loadManagerTest);
1.1886 +
1.1887 + (loadManagerTest->*testFuncL)();
1.1888 +
1.1889 + CleanupStack::PopAndDestroy(loadManagerTest);
1.1890 +
1.1891 + // check that no handles have leaked
1.1892 + TInt endProcessHandleCount;
1.1893 + TInt endThreadHandleCount;
1.1894 + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
1.1895 +
1.1896 + TEST(startProcessHandleCount == endProcessHandleCount);
1.1897 + TEST(startThreadHandleCount == endThreadHandleCount);
1.1898 +
1.1899 + __UHEAP_MARKEND;
1.1900 + }
1.1901 +
1.1902 +/**
1.1903 +@SYMTestCaseID SYSLIB-ECOM-CT-0708
1.1904 +@SYMTestCaseDesc Function to call all OOM test functions
1.1905 +@SYMTestPriority High
1.1906 +@SYMTestActions Calls up all test functions for OOM test.
1.1907 +@SYMTestExpectedResults The test must not fail.
1.1908 +@SYMREQ REQ0000
1.1909 +*/
1.1910 +/**
1.1911 +Wrapper function to call all OOM test functions
1.1912 +
1.1913 +@param testFuncL pointer to OOM test function
1.1914 +@param aTestDesc test function name
1.1915 +*/
1.1916 +LOCAL_C void DoOOMTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc)
1.1917 + {
1.1918 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0708 "));
1.1919 + TheTest.Next(aTestDesc);
1.1920 +
1.1921 + TInt err, tryCount = 0;
1.1922 + do
1.1923 + {
1.1924 + __UHEAP_MARK;
1.1925 + // find out the number of open handles
1.1926 + TInt startProcessHandleCount;
1.1927 + TInt startThreadHandleCount;
1.1928 + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
1.1929 +
1.1930 + CLoadManagerTest* loadManagerTest = CLoadManagerTest::NewL();
1.1931 + CleanupStack::PushL(loadManagerTest);
1.1932 +
1.1933 + // Setting Heap failure for OOM test
1.1934 + __UHEAP_SETFAIL(RHeap::EDeterministic, ++tryCount);
1.1935 +
1.1936 + TRAP(err, (loadManagerTest->*testFuncL)());
1.1937 +
1.1938 + __UHEAP_SETFAIL(RHeap::ENone, 0);
1.1939 +
1.1940 + CleanupStack::PopAndDestroy(loadManagerTest);
1.1941 + loadManagerTest = NULL;
1.1942 +
1.1943 + // check that no handles have leaked
1.1944 + TInt endProcessHandleCount;
1.1945 + TInt endThreadHandleCount;
1.1946 + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
1.1947 +
1.1948 + TEST(startProcessHandleCount == endProcessHandleCount);
1.1949 + TEST(startThreadHandleCount == endThreadHandleCount);
1.1950 +
1.1951 + __UHEAP_MARKEND;
1.1952 + } while(err == KErrNoMemory);
1.1953 +
1.1954 + TEST(err == KErrNone);
1.1955 + TheTest.Printf(_L("- server succeeded at heap failure rate of %i\n"), tryCount);
1.1956 + }
1.1957 +
1.1958 +void DoTestL()
1.1959 + {
1.1960 + __UHEAP_MARK;
1.1961 +
1.1962 + // Basic tests
1.1963 + CreateDeleteTestL();
1.1964 + DoBasicTestL(&CLoadManagerTest::InstantiationMethodTestPlugin1L, _L("InstantiationMethodTestPlugin1L"));
1.1965 + DoBasicTestL(&CLoadManagerTest::DestroyThisTestPlugin1L, _L("DestroyThisTestPlugin1L"));
1.1966 + DoBasicTestL(&CLoadManagerTest::GetImplementationUidTestL, _L("GetImplementationUidTestL"));
1.1967 + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase1Plugin1L,_L("Create Destroy Test case 1"));
1.1968 + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase2Plugin1L,_L("Create Destroy Test case 2"));
1.1969 + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase3L,_L("Create Destroy Test case 3"));
1.1970 + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase4Plugin1L,_L("Create Destroy Test case 4"));
1.1971 + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase5Plugin1L,_L("Create Destroy Test case 5"));
1.1972 +
1.1973 + DoBasicTestL(&CLoadManagerTest::InstantiationMethodTestPlugin3L, _L("InstantiationMethodTest3L"));
1.1974 + DoBasicTestL(&CLoadManagerTest::DestroyThisTestPlugin3L, _L("DestroyThisTest3L"));
1.1975 + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase1Plugin3L,_L("Create Destroy Test case 1,Plugin3"));
1.1976 + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase2Plugin3L,_L("Create Destroy Test case 2"));
1.1977 + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase3Plugin3L,_L("Create Destroy Test case 3"));
1.1978 + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase4Plugin3L,_L("Create Destroy Test case 4"));
1.1979 + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase5Plugin3L,_L("Create Destroy Test case 5"));
1.1980 +
1.1981 + //Create an implementation from a PLUGIN dll and one from a PLUGIN3 dll also.
1.1982 + DoBasicTestL(&CLoadManagerTest::CreateDestroyTestCase1PluginAndPlugin3L,_L("CreateDestroyTestCase1PluginAndPlugin3L"));
1.1983 +
1.1984 + // Get and Release extended interfaces
1.1985 + DoBasicTestL(&CLoadManagerTest::ExtendedMethodTest1Plugin3L,_L("ExtendedMethodTest1Plugin3L"));
1.1986 + DoBasicTestL(&CLoadManagerTest::ExtendedMethodTest2Plugin3L,_L("ExtendedMethodTest2Plugin3L"));
1.1987 + DoBasicTestL(&CLoadManagerTest::ManuallyReleaseExtendedInterfaceTestL,_L("ManuallyReleaseExtendedInterfaceTestL"));
1.1988 +
1.1989 + DoBasicTestL(&CLoadManagerTest::ImplementationObjectTestL,_L("ImplementationObjectTestL"));
1.1990 +
1.1991 +
1.1992 + OOMCreateDeleteTest();
1.1993 +
1.1994 + DoOOMTestL(&CLoadManagerTest::InstantiationMethodTestPlugin1L, _L("OOM InstantiationMethodTestPlugin1L"));
1.1995 + DoOOMTestL(&CLoadManagerTest::DestroyThisTestPlugin1L, _L("OOM DestroyThisTestPlugin1L"));
1.1996 + DoOOMTestL(&CLoadManagerTest::GetImplementationUidTestL, _L("OOM GetImplementationUidTestL"));
1.1997 + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase1Plugin1L,_L("OOM Create Destroy Test case 1"));
1.1998 + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase2Plugin1L,_L("OOM Create Destroy Test case 2"));
1.1999 + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase3L,_L("OOM Create Destroy Test case 3"));
1.2000 + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase4Plugin1L,_L("OOM Create Destroy Test case 4"));
1.2001 + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase5Plugin1L,_L("OOM Create Destroy Test case 5"));
1.2002 +
1.2003 + DoOOMTestL(&CLoadManagerTest::InstantiationMethodTestPlugin3L, _L("OOM InstantiationMethodTest3L"));
1.2004 + DoOOMTestL(&CLoadManagerTest::DestroyThisTestPlugin3L, _L("OOM DestroyThisTest3L"));
1.2005 + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase1Plugin3L,_L("OOM Create Destroy Test case 1,Plugin3"));
1.2006 + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase2Plugin3L,_L("OOM Create Destroy Test case 2"));
1.2007 + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase3Plugin3L,_L("OOM Create Destroy Test case 3"));
1.2008 + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase4Plugin3L,_L("OOM Create Destroy Test case 4"));
1.2009 + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase5Plugin3L,_L("OOM Create Destroy Test case 5"));
1.2010 +
1.2011 + //Create an implementation from a PLUGIN dll and one from a PLUGIN3 dll also.
1.2012 + DoOOMTestL(&CLoadManagerTest::CreateDestroyTestCase1PluginAndPlugin3L,_L("OOM CreateDestroyTestCase1PluginAndPlugin3L"));
1.2013 +
1.2014 + // Get and Release extended interfaces
1.2015 + DoOOMTestL(&CLoadManagerTest::ExtendedMethodTest1Plugin3L,_L("OOM ExtendedMethodTest1Plugin3L"));
1.2016 + DoOOMTestL(&CLoadManagerTest::ExtendedMethodTest2Plugin3L,_L("OOM ExtendedMethodTest2Plugin3L"));
1.2017 + DoOOMTestL(&CLoadManagerTest::ManuallyReleaseExtendedInterfaceTestL,_L("OOM ManuallyReleaseExtendedInterfaceTestL"));
1.2018 +
1.2019 + __UHEAP_MARKEND;
1.2020 + }
1.2021 +
1.2022 +//Leave if aError < 0 with info message printed out
1.2023 +LOCAL_C void LeaveIfError(TInt aError, TInt aLine)
1.2024 + {
1.2025 + if(aError < KErrNone)
1.2026 + {
1.2027 + ::Leave(aError, aLine);
1.2028 + }
1.2029 + }
1.2030 +
1.2031 +#define LEAVE_IF_ERROR(aError) ::LeaveIfError(aError, __LINE__)
1.2032 +//
1.2033 +// Copies the Plugins to specific folder for testing purpose
1.2034 +//
1.2035 +LOCAL_C void CopyPlugins()
1.2036 + {
1.2037 + // Connect the file server instance
1.2038 + LEAVE_IF_ERROR(TheFs.Connect());
1.2039 +
1.2040 + TRAPD(err, EComTestUtils::FileManCopyFileL(KResourceFileName5OnZ, KResourceFileName5));
1.2041 + TEST(err==KErrNone);
1.2042 +
1.2043 + TRAP(err, EComTestUtils::FileManCopyFileL(KExampleDllFileName5OnZ, KExampleDllFileName5));
1.2044 + TEST(err==KErrNone);
1.2045 +
1.2046 + TRAP(err, EComTestUtils::FileManCopyFileL(KResourceFileName12OnZ, KResourceFileName12));
1.2047 + TEST(err==KErrNone);
1.2048 +
1.2049 + TRAP(err, EComTestUtils::FileManCopyFileL(KExampleDllFileName12OnZ, KExampleDllFileName12));
1.2050 + TEST(err==KErrNone);
1.2051 + }
1.2052 +
1.2053 +// Deleting plugin from the RAM for cleanup purpose
1.2054 +LOCAL_C void DeleteTestPlugin()
1.2055 + {
1.2056 + TRAPD(err, EComTestUtils::FileManDeleteFileL(KResourceFileName5));
1.2057 + TRAP(err, EComTestUtils::FileManDeleteFileL(KExampleDllFileName5));
1.2058 + TRAP(err, EComTestUtils::FileManDeleteFileL(KResourceFileName12));
1.2059 + TRAP(err, EComTestUtils::FileManDeleteFileL(KExampleDllFileName12));
1.2060 + }
1.2061 +
1.2062 +//
1.2063 +//Initialise the Active Scheduler
1.2064 +//
1.2065 +LOCAL_C void SetupL()
1.2066 + {
1.2067 + // Construct and install the Active Scheduler. The Active Schedular is needed
1.2068 + // by components used by this test as they are ActiveObjects.
1.2069 + TheActiveScheduler = new(ELeave)CActiveScheduler;
1.2070 + CActiveScheduler::Install(TheActiveScheduler);
1.2071 + }
1.2072 +
1.2073 +GLDEF_C TInt E32Main()
1.2074 + {
1.2075 + __UHEAP_MARK;
1.2076 +
1.2077 + TheTest.Printf(_L("\n"));
1.2078 + TheTest.Title();
1.2079 + TheTest.Start( _L("LoadManager Tests.") );
1.2080 +
1.2081 + TheTrapCleanup = CTrapCleanup::New();
1.2082 +
1.2083 + TRAPD(err, SetupL());
1.2084 + TEST(err == KErrNone);
1.2085 +
1.2086 + CopyPlugins();
1.2087 + // The reason for the folowing delay is:
1.2088 + // ECOM server could be already started. It means that when we copy some
1.2089 + // ECOM plugins from Z: to C: drive - ECOM server should look for and
1.2090 + // find the new ECOM plugins. The ECOM server uses for that an active object,
1.2091 + // which scans plugin directories. So the discovering service is asynchronous.
1.2092 + // We have to wait some time until it finishes.
1.2093 + // Otherwise ListImplementationsL could fail to find requested implementations.
1.2094 + User::After(KOneSecond * 3);
1.2095 +
1.2096 + //Call the main tess
1.2097 + TRAP(err, DoTestL());
1.2098 + TEST2(err,KErrNone);
1.2099 +
1.2100 + // Cleanup files. If the cleanup fails that is no problem,
1.2101 + // as any subsequent tests will replace them. The only downside
1.2102 + // would be the disk not being tidied
1.2103 + DeleteTestPlugin();
1.2104 +
1.2105 + TheFs.Close();
1.2106 +
1.2107 + delete TheActiveScheduler;
1.2108 + delete TheTrapCleanup;
1.2109 +
1.2110 + TheTest.End();
1.2111 + TheTest.Close();
1.2112 +
1.2113 + __UHEAP_MARKEND;
1.2114 + return KErrNone;
1.2115 + }