1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/lowlevellibsandfws/pluginfw/Framework/SimpleTests/t_ecomdefect.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,672 @@
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 +//
1.18 +
1.19 +#include <e32test.h>
1.20 +#include <e32panic.h>
1.21 +#include <f32file.h>
1.22 +#include <bautils.h>
1.23 +#include "LoadManager.h"
1.24 +#include <ecom/ecom.h>
1.25 +#include "EComUidCodes.h"
1.26 +#include "Interface.h" // interface to Plugins
1.27 +//Test utils for copying the resolver to C
1.28 +#include "../EcomTestUtils/EcomTestUtils.h"
1.29 +
1.30 +LOCAL_D RTest TEST(_L("Ecom Defect Test"));
1.31 +
1.32 +_LIT(KEComExDllOnZ, "Z:\\RAMOnly\\T_PlatSecResolverC.dll");
1.33 +
1.34 +_LIT(KEComExDllOnC, "C:\\sys\\bin\\T_PlatSecResolverC.dll");
1.35 +_LIT(KEComRscFileOnC, "C:\\resource\\plugins\\T_PlatSecResolverC.rsc");
1.36 +_LIT(KEComRscFileOnZ, "Z:\\RAMOnly\\T_PlatSecResolverC.rsc");
1.37 +
1.38 +#define UNUSED_VAR(a) a = a
1.39 +inline LOCAL_C void DeleteTestPlugin()
1.40 + {
1.41 + TRAPD(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComExDllOnC));
1.42 + TRAP(ignoreErr, EComTestUtils::FileManDeleteFileL(KEComRscFileOnC));
1.43 + }
1.44 +
1.45 +class REcomDefectTest
1.46 + {
1.47 +public:
1.48 + static void DEF049285_TestCaseL();
1.49 + static void DEF049979_TestCaseL();
1.50 + static void INC057514_TestCaseL();
1.51 + static void DEF065025_TestCase();
1.52 + };
1.53 +
1.54 +/**
1.55 +Test case for Defect DEF048053 LoadManager Leaks Memory even when FinalClose is called.
1.56 +
1.57 +@SYMTestCaseID SYSLIB-ECOM-CT-0770
1.58 +@SYMTestCaseDesc Test case for defect number DEF048053 LoadManager Leaks Memory even when FinalClose is called
1.59 +@SYMTestPriority High
1.60 +@SYMTestActions Create two simple implementation with different UID and check for memory leak when FinalClose is called.
1.61 + Create two complex implementations in Two different DLL check for memory leak when FinalClose is called.
1.62 + Create two simple implementation with same UID and check for memory leak when FinalClose is called.
1.63 + Create two complex implementations in different DLL check for memory leak when FinalClose is called.
1.64 + Test for invalid implementationUid to ensure no leak and proper cleanup
1.65 +@SYMTestExpectedResults The test must not fail.
1.66 +@SYMREQ REQ0000
1.67 +*/
1.68 +void REcomDefectTest::DEF049285_TestCaseL()
1.69 + {
1.70 + TEST.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0770 "));
1.71 + _LIT(KDummyText,"Dummy params");
1.72 +
1.73 + TInt err=KErrNone;
1.74 + TInt failAt = 1;
1.75 + //TO clear warnings in urel armv5 as failAt++ is only used in __UHEAP_SETFAIL in udeb
1.76 + failAt+=0;
1.77 + //Dummy instantiation parameters
1.78 + CExampleInterface::TExampleInterfaceInitParams iInitParams;
1.79 + iInitParams.integer = 5;
1.80 + iInitParams.descriptor = &KDummyText;
1.81 +
1.82 + /**
1.83 + -------------Part 1: Two Simple Implementations in Two different DLL----------------
1.84 + Plugins used: T_PlatSecEcom1.dll with implUid1=0x102026AA
1.85 + T_PlatSecEcom2.dll with implUid2=0x102026AC
1.86 + */
1.87 + TEST.Next(_L("DEF048053 Part 1\n"));
1.88 + __UHEAP_MARK;
1.89 + TUid implUid1={0x102026AA};
1.90 + TUid implUid2={0x102026AC};
1.91 + TUid returnedUid1;
1.92 + TUid returnedUid2;
1.93 +
1.94 + //Create the first implementation
1.95 + TAny* imp1=REComSession::CreateImplementationL(implUid1,returnedUid1);
1.96 + CInstanceInfoSimple* instanceInfo = reinterpret_cast <CInstanceInfoSimple*> (returnedUid1.iUid);
1.97 + TEST(implUid1==instanceInfo->ImplementationUid(), __LINE__);
1.98 + //Now start the OOM test when creating the second implementation
1.99 + __UHEAP_MARK;
1.100 + do
1.101 + {
1.102 + // Setting Heap failure for OOM test
1.103 + __UHEAP_SETFAIL(RHeap::EDeterministic, failAt++);
1.104 + TAny* imp2=NULL;
1.105 + //Create the second implementation
1.106 + TRAP(err,imp2=REComSession::CreateImplementationL(implUid2,returnedUid2));
1.107 + if (err==KErrNone)
1.108 + {
1.109 + instanceInfo = reinterpret_cast <CInstanceInfoSimple*> (returnedUid2.iUid);
1.110 + TEST(implUid2==instanceInfo->ImplementationUid(), __LINE__);
1.111 + REComSession::DestroyedImplementation(returnedUid2);
1.112 + delete imp2;
1.113 + imp2=NULL;
1.114 + }
1.115 + __UHEAP_SETFAIL(RHeap::ENone, 0);
1.116 + }
1.117 + while (err == KErrNoMemory);
1.118 + //CALL FinalClose() HERE, do not want to leak memory
1.119 + REComSession::FinalClose();
1.120 + __UHEAP_MARKEND;
1.121 +
1.122 + REComSession::DestroyedImplementation(returnedUid1);
1.123 + delete imp1;
1.124 + imp1=NULL;
1.125 + //call FinalClose() here, do not want to leak memory
1.126 + REComSession::FinalClose();
1.127 + __UHEAP_MARKEND;
1.128 +
1.129 +
1.130 + /**
1.131 + ---------------Part 2: Two Complex Implementations in Two different DLL-----------------------
1.132 + Plugins used: EComExample2.dll with implUid1=0x10009DC4
1.133 + EComExample3.dll with implUid2=0x101F8478
1.134 + */
1.135 + TEST.Next(_L("DEF048053 Part 2\n"));
1.136 + __UHEAP_MARK;
1.137 + implUid1=TUid::Uid(0x10009DC4);
1.138 + implUid2=TUid::Uid(0x101F8478);
1.139 + failAt=1;
1.140 + //Set up initialisation parameters
1.141 + //This initialisation parameters are required for testing the
1.142 + //failure point in a more complex plugin where it is possible
1.143 + //to fail in the ConstructL stage of the plugin NewL
1.144 + //Create the first plugin
1.145 + CExampleInterface* impl1 = REINTERPRET_CAST(CExampleInterface*,
1.146 + REComSession::CreateImplementationL(implUid1,
1.147 + returnedUid1,
1.148 + &iInitParams
1.149 + ));
1.150 + //Now start the OOM test when creating the second implementation
1.151 + do
1.152 + {
1.153 + __UHEAP_MARK;
1.154 + // Setting Heap failure for OOM test
1.155 + __UHEAP_SETFAIL(RHeap::EDeterministic, failAt++);
1.156 + CExampleInterface* impl2=NULL;
1.157 + //Create the second implementation
1.158 + TRAP(err,impl2 = REINTERPRET_CAST(CExampleInterface*,
1.159 + REComSession::CreateImplementationL(implUid2,
1.160 + returnedUid2,
1.161 + &iInitParams
1.162 + )));
1.163 + if (err==KErrNone)
1.164 + {
1.165 + instanceInfo = reinterpret_cast <CInstanceInfoSimple*> (returnedUid2.iUid);
1.166 + TEST(implUid2==instanceInfo->ImplementationUid(), __LINE__);
1.167 + REComSession::DestroyedImplementation(returnedUid2);
1.168 + delete impl2;
1.169 + impl2=NULL;
1.170 + }
1.171 + //CALL FinalClose() HERE!, do not want to leak memory
1.172 + REComSession::FinalClose();
1.173 + __UHEAP_MARKEND;
1.174 + __UHEAP_SETFAIL(RHeap::ENone, 0);
1.175 + }
1.176 + while (err == KErrNoMemory);
1.177 +
1.178 + REComSession::DestroyedImplementation(returnedUid1);
1.179 + delete impl1;
1.180 + impl1=NULL;
1.181 + //call FinalClose() here, do not want to leak memory
1.182 + REComSession::FinalClose();
1.183 + __UHEAP_MARKEND;
1.184 +
1.185 + /*
1.186 + -----------Part 3, Two Simple Implementations in the Same DLL-------
1.187 + Plugins used: EComExample2.dll with implUid1=0x10009DC3
1.188 + with implUid2=0x10009DC4
1.189 + */
1.190 + TEST.Next(_L("DEF048053 Part 3\n"));
1.191 + __UHEAP_MARK;
1.192 + implUid1=TUid::Uid(0x10009DC3);
1.193 + implUid2=TUid::Uid(0x10009DC4);
1.194 + failAt=1;
1.195 + //Set up initialisation parameters
1.196 + //This initialisation parameters are required for testing the
1.197 + //failure point in a more complex plugin where it is possible
1.198 + //to fail in the ConstructL stage of the plugin NewL
1.199 + //Create the first plugin
1.200 + impl1 = REINTERPRET_CAST(CExampleInterface*,
1.201 + REComSession::CreateImplementationL(implUid1,
1.202 + returnedUid1,
1.203 + &iInitParams
1.204 + ));
1.205 + //Now start the OOM test when creating the second implementation
1.206 + do
1.207 + {
1.208 + __UHEAP_MARK;
1.209 + // Setting Heap failure for OOM test
1.210 + __UHEAP_SETFAIL(RHeap::EDeterministic, failAt++);
1.211 + CExampleInterface* impl2=NULL;
1.212 + //Create the second implementation
1.213 + TRAP(err,impl2 = REINTERPRET_CAST(CExampleInterface*,
1.214 + REComSession::CreateImplementationL(implUid2,
1.215 + returnedUid2,
1.216 + &iInitParams
1.217 + )));
1.218 + if (err==KErrNone)
1.219 + {
1.220 + instanceInfo = reinterpret_cast <CInstanceInfoSimple*> (returnedUid2.iUid);
1.221 + TEST(implUid2==instanceInfo->ImplementationUid(), __LINE__);
1.222 + REComSession::DestroyedImplementation(returnedUid2);
1.223 + delete impl2;
1.224 + impl2=NULL;
1.225 + }
1.226 + //CALL FinalClose() HERE!, do not want to leak memory
1.227 + REComSession::FinalClose();
1.228 + __UHEAP_MARKEND;
1.229 + __UHEAP_SETFAIL(RHeap::ENone, 0);
1.230 + }
1.231 + while (err == KErrNoMemory);
1.232 +
1.233 + REComSession::DestroyedImplementation(returnedUid1);
1.234 + delete impl1;
1.235 + impl1=NULL;
1.236 + //call FinalClose() here, do not want to leak memory
1.237 + REComSession::FinalClose();
1.238 + __UHEAP_MARKEND;
1.239 +
1.240 +
1.241 + /*
1.242 + ------------Part 4. Two complex implementations in different DLL--------
1.243 + Plugins used: EComExample2.dll with implUid1=0x10009DC4
1.244 + EcomRomRslvrExampleOnZ.dll with implUid2=0x10009DC7
1.245 + //Special case
1.246 + //Implementation with uid 10009DC7 is registered as the implementation in
1.247 + //plugin EComRomRslvrExampleOnZ.DLL however there is no mapping in the
1.248 + //implementaton proxy table that matches this implementation to its NewL
1.249 + //with KErrNotFound(-1)
1.250 + */
1.251 + TEST.Next(_L("DEF048053 Part 4\n"));
1.252 + __UHEAP_MARK;
1.253 + implUid1=TUid::Uid(0x10009DC4);
1.254 + implUid2=TUid::Uid(0x10009DC7);
1.255 + failAt=1;
1.256 + //Set up initialisation parameters
1.257 + //This initialisation parameters are required for testing the
1.258 + //failure point in a more complex plugin where it is possible
1.259 + //to fail in the ConstructL stage of the plugin NewL
1.260 + //Create the first plugin
1.261 + impl1 = REINTERPRET_CAST(CExampleInterface*,
1.262 + REComSession::CreateImplementationL(implUid1,
1.263 + returnedUid1
1.264 + ));
1.265 + //Now start the OOM test when creating the second implementation
1.266 + do
1.267 + {
1.268 + __UHEAP_MARK;
1.269 + // Setting Heap failure for OOM test
1.270 + __UHEAP_SETFAIL(RHeap::EDeterministic, failAt++);
1.271 + CExampleInterface* impl2=NULL;
1.272 + //Create the second implementation
1.273 + TRAP(err,impl2 = REINTERPRET_CAST(CExampleInterface*,
1.274 + REComSession::CreateImplementationL(implUid2,
1.275 + returnedUid2,
1.276 + &iInitParams
1.277 + )));
1.278 + if (err==KErrNone)
1.279 + {
1.280 + instanceInfo = reinterpret_cast <CInstanceInfoSimple*> (returnedUid2.iUid);
1.281 + TEST(implUid2==instanceInfo->ImplementationUid(), __LINE__);
1.282 + REComSession::DestroyedImplementation(returnedUid2);
1.283 + delete impl2;
1.284 + impl2=NULL;
1.285 + }
1.286 + //CALL FinalClose() HERE!, do not want to leak memory
1.287 + REComSession::FinalClose();
1.288 + __UHEAP_MARKEND;
1.289 + __UHEAP_SETFAIL(RHeap::ENone, 0);
1.290 + }
1.291 + while (err == KErrNoMemory);
1.292 +
1.293 + REComSession::DestroyedImplementation(returnedUid1);
1.294 + delete impl1;
1.295 + impl1=NULL;
1.296 + //call FinalClose() here, do not want to leak memory
1.297 + REComSession::FinalClose();
1.298 + __UHEAP_MARKEND;
1.299 +
1.300 + /*
1.301 + ------------Part 5. Invalid argument testing in CreateImplementation
1.302 + Test for invalid implementationUid to ensure no leak and proper cleanup
1.303 + */
1.304 + __UHEAP_MARK;
1.305 +
1.306 + TUid invalidImplUid={0x1111111};
1.307 + TUid returnedUid;
1.308 + TAny* invalidimpl=NULL;
1.309 + TRAP(err,invalidimpl=REComSession::CreateImplementationL(invalidImplUid,returnedUid));
1.310 + TEST(err==KErrNotFound, __LINE__);
1.311 + TEST(invalidimpl==NULL, __LINE__);
1.312 + TEST(returnedUid==KNullUid, __LINE__);
1.313 + REComSession::FinalClose();
1.314 +
1.315 + __UHEAP_MARKEND;
1.316 +
1.317 + }
1.318 +
1.319 +/**
1.320 +Test case for Defect ECom Server only loads Resolvers from Z: Drive
1.321 +
1.322 +@SYMTestCaseID SYSLIB-ECOM-CT-0769
1.323 +@SYMTestCaseDesc Test case for defect number DEF049979 LoadManager Leaks Memory even when FinalClose is called
1.324 +@SYMTestPriority High
1.325 +@SYMTestActions List all the implemetations once using a UID which reside on C: drive and another on Z: drive
1.326 +@SYMTestExpectedResults The test must not fail.
1.327 +@SYMREQ REQ0000
1.328 +*/
1.329 +void REcomDefectTest::DEF049979_TestCaseL()
1.330 + {
1.331 + RImplInfoPtrArray ifArray;
1.332 + TEST.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0769 DEF049979_TestCaseL\n "));
1.333 +
1.334 + _LIT8(KImplementationTest,"text/wml");
1.335 + // Set up the interface find for the default resolver.
1.336 + TEComResolverParams ResolverParams;
1.337 + ResolverParams.SetDataType(KImplementationTest());
1.338 + ResolverParams.SetGenericMatch(ETrue); // Allow wildcard matching
1.339 + TUid ifUid = {0x10009DC0};
1.340 +
1.341 + /*
1.342 + -----Test case 1 ListImplementation using a C resolver----------
1.343 + */
1.344 + __UHEAP_MARK;
1.345 +
1.346 + //A resolver uid that only resides in C T_PlatSecResolverC.dll
1.347 + TUid resolverUidC={0x10244444};
1.348 +
1.349 +
1.350 + REComSession::ListImplementationsL(
1.351 + ifUid,
1.352 + ResolverParams,
1.353 + resolverUidC,
1.354 + ifArray);
1.355 +
1.356 + // There should be 6 implementations found but only 2 returned.
1.357 + // These 2, are the only two that match the datatype supplied.
1.358 + // These 2, are also 2 of a posible 4, i.e. version 2.
1.359 + // The version 1 implementations are not part of the reported 6
1.360 + // they are superseeded.
1.361 + // So the 2 that match are implementation uids 0x10009DC3 & 0x10009DC4
1.362 + TInt availCount = ifArray.Count();
1.363 + TEST(availCount == 2, __LINE__);
1.364 +
1.365 + ifArray.ResetAndDestroy();
1.366 +
1.367 + /*
1.368 + -----Test case 2 List Implementation using a Z resolver---------
1.369 + */
1.370 + //A resolver uid that resides in Z T_PlatSecResolverZ.dll
1.371 + TUid resolverUidZ={0x10999999};
1.372 +
1.373 + REComSession::ListImplementationsL(
1.374 + ifUid,
1.375 + ResolverParams,
1.376 + resolverUidZ,
1.377 + ifArray);
1.378 +
1.379 + // There should be 6 implementations found but only 2 returned.
1.380 + // These 2, are the only two that match the datatype supplied.
1.381 + // These 2, are also 2 of a posible 4, i.e. version 2.
1.382 + // The version 1 implementations are not part of the reported 6
1.383 + // they are superseeded.
1.384 + // So the 2 that match are implementation uids 0x10009DC3 & 0x10009DC4
1.385 + availCount = ifArray.Count();
1.386 + TEST(availCount == 2, __LINE__);
1.387 +
1.388 + ifArray.ResetAndDestroy();
1.389 +
1.390 + REComSession::FinalClose();
1.391 + __UHEAP_MARKEND;
1.392 +
1.393 + }
1.394 +
1.395 +
1.396 +// This class is used for INC057514_TestCaseL.
1.397 +// Checks the reference count when constructing and destructing REComSessions.
1.398 +//
1.399 +class CStuff : public CBase
1.400 + {
1.401 +public:
1.402 + static CStuff* NewL() {
1.403 + CStuff* self = new (ELeave) CStuff;
1.404 + CleanupStack::PushL (self);
1.405 + self->ConstructL();
1.406 + CleanupStack::Pop (self);
1.407 + return self;
1.408 + }
1.409 + void ConstructL ();
1.410 + ~CStuff();
1.411 +
1.412 + REComSession iEcomSession;
1.413 +
1.414 +private:
1.415 + CStuff() {/*do nothing*/};
1.416 + };
1.417 +
1.418 +void CStuff::ConstructL ()
1.419 + {
1.420 + iEcomSession = REComSession::OpenL();
1.421 + }
1.422 +
1.423 +CStuff::~CStuff()
1.424 + {
1.425 + iEcomSession.Close();
1.426 + }
1.427 +
1.428 +/**
1.429 +Test case for Defect ECOM can't (reference) count
1.430 +
1.431 +@SYMTestCaseID SYSLIB-ECOM-CT-01364
1.432 +@SYMTestCaseDesc Test case for defect number INC057514 ECOM can't (reference) count
1.433 +@SYMTestPriority High
1.434 +@SYMTestActions Create 2 implementations
1.435 + Open session with REComSession
1.436 + Close session with REComSession
1.437 + When out of scope destructor for REComSession is called.
1.438 +@SYMTestExpectedResults The test must not fail.
1.439 +@SYMDEF INC057514
1.440 +*/
1.441 +void REcomDefectTest::INC057514_TestCaseL()
1.442 + {
1.443 + TEST.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1364 INC057514_TestCaseL "));
1.444 +
1.445 + // Set up for heap leak checking
1.446 + __UHEAP_MARK;
1.447 +
1.448 + //Check Thread handles leak
1.449 + TInt startProcessHandleCount = 0;
1.450 + TInt startThreadHandleCount = 0;
1.451 + TInt endProcessHandleCount = 0;
1.452 + TInt endThreadHandleCount = 0;
1.453 +
1.454 + RThread rThread;
1.455 + rThread.HandleCount(startProcessHandleCount, startThreadHandleCount);
1.456 +
1.457 + // START TEST //
1.458 +
1.459 +
1.460 + __UHEAP_MARK;
1.461 +
1.462 + CStuff* stuff1 = CStuff::NewL();
1.463 + CleanupStack::PushL(stuff1);
1.464 +
1.465 + TUid implUid1={0x102026AA};
1.466 + TUid returnedUid1;
1.467 + TUid returnedUid2;
1.468 +
1.469 + //Create the first implementation
1.470 + TAny* imp1=stuff1->iEcomSession.CreateImplementationL(implUid1,returnedUid1);
1.471 + CInstanceInfoSimple* instanceInfo = reinterpret_cast <CInstanceInfoSimple*> (returnedUid1.iUid);
1.472 + CleanupStack::PushL(imp1);
1.473 + TEST(implUid1==instanceInfo->ImplementationUid(), __LINE__);
1.474 +
1.475 + CStuff* stuff2 = CStuff::NewL();
1.476 + CleanupStack::PushL(stuff2);
1.477 +
1.478 + //Create the first implementation
1.479 + TAny* imp2=stuff2->iEcomSession.CreateImplementationL(implUid1,returnedUid2);
1.480 + instanceInfo = reinterpret_cast <CInstanceInfoSimple*> (returnedUid2.iUid);
1.481 + CleanupStack::PushL(imp2);
1.482 + TEST(implUid1==instanceInfo->ImplementationUid(), __LINE__);
1.483 +
1.484 + {
1.485 + REComSession session = stuff1->iEcomSession.OpenL();
1.486 + session.Close();
1.487 + // When we go out of scope we cause the destructor
1.488 + // to be called for REComSession.
1.489 + }
1.490 +
1.491 + REComSession::DestroyedImplementation(returnedUid1);
1.492 +
1.493 + CleanupStack::PopAndDestroy(imp2);
1.494 + CleanupStack::PopAndDestroy(stuff2);
1.495 +
1.496 + REComSession::FinalClose();
1.497 +
1.498 + REComSession::DestroyedImplementation(returnedUid2);
1.499 +
1.500 + CleanupStack::PopAndDestroy(imp1);
1.501 + CleanupStack::PopAndDestroy(stuff1);
1.502 +
1.503 + REComSession::FinalClose();
1.504 +
1.505 +
1.506 + __UHEAP_MARKEND;
1.507 +
1.508 +
1.509 +
1.510 + // END TEST //
1.511 +
1.512 + // Check for open handles
1.513 + rThread.HandleCount(endProcessHandleCount, endThreadHandleCount);
1.514 + TEST(startThreadHandleCount == endThreadHandleCount, __LINE__);
1.515 +
1.516 + //Test ends
1.517 + __UHEAP_MARKEND;
1.518 + }
1.519 +
1.520 +static RSemaphore TheLoadEcomServerSemaphore;
1.521 +
1.522 +static TInt LoadEcomServer(void*)
1.523 + {
1.524 + RThread currThread;
1.525 + const TName& threadName = currThread.Name();
1.526 + RDebug::Print(_L("Thread %S running\n"), &threadName);
1.527 +
1.528 + //Wait until get a notification from the creating thread that the ECOM server can be loaded.
1.529 + TheLoadEcomServerSemaphore.Wait();
1.530 +
1.531 + CTrapCleanup* cleanup = CTrapCleanup::New();
1.532 + TEST(cleanup != NULL);
1.533 +
1.534 + //Create ECOM session. This call will try to load the ECOM server.
1.535 + REComSession ecomSession;
1.536 + TRAPD(err, ecomSession.OpenL());
1.537 + TEST(err==KErrNone);
1.538 +
1.539 + //Wait some time. During that time the ECOM server will try to process the ECOM registry.
1.540 + User::After(3000000);
1.541 + ecomSession.Close();
1.542 +
1.543 + delete cleanup;
1.544 + RDebug::Print(_L("Thread %S exits\n"), &threadName);
1.545 + return KErrNone;
1.546 + }
1.547 +
1.548 +/**
1.549 +Test case for Defect Multi-threaded client start-up of ECOM server can causeKErrInUse errors
1.550 +
1.551 +@SYMTestCaseID SYSLIB-ECOM-CT-01365
1.552 +@SYMTestCaseDesc Test case for defect number DEF065025 Multi-threaded client
1.553 + start-up of ECOM server can causeKErrInUse errors
1.554 +@SYMTestPriority High
1.555 +@SYMTestActions Create 16 threads and block.
1.556 + Unblock each thread causing them all to run simultaneously.
1.557 + Each thread opens a session to ECOM Server.
1.558 + Close each session to ECOM Server.
1.559 + Close each thread.
1.560 +@SYMTestExpectedResults The test must not fail.
1.561 +@SYMDEF DEF065025
1.562 +*/
1.563 +void REcomDefectTest::DEF065025_TestCase()
1.564 + {
1.565 + TEST.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1365 "));
1.566 + TInt err=KErrNone;
1.567 + _LIT(KEComServerProcessName,"ecomserver");
1.568 + TRAP(err, EComTestUtils::KillProcessL(KEComServerProcessName));
1.569 + UNUSED_VAR(err);
1.570 +
1.571 + const TInt KThreadCnt = 16;
1.572 + err = TheLoadEcomServerSemaphore.CreateLocal(0);
1.573 + TEST(err==KErrNone);
1.574 +
1.575 + RThread loadEcomThread[KThreadCnt];
1.576 + TRequestStatus threadStatus[KThreadCnt];
1.577 + TInt i;
1.578 +
1.579 + //Create KThreadCnt threads. They will be blocked on TheLoadEcomServerSemaphore after
1.580 + //their creation.
1.581 + for(i=0;i<KThreadCnt;++i)
1.582 + {
1.583 + TBuf<32> threadName;
1.584 + threadName.Format(_L("Th-%02d"), i + 1);
1.585 + TInt err = loadEcomThread[i].Create(threadName, (TThreadFunction)LoadEcomServer,
1.586 + KDefaultStackSize, KMinHeapSize, 0x00100000, NULL);
1.587 + TEST(err==KErrNone);
1.588 + loadEcomThread[i].Logon(threadStatus[i]);
1.589 + loadEcomThread[i].Resume();
1.590 + }
1.591 + User::After(3000000);
1.592 +
1.593 + //Unblock the threads. The threads will run simultaneously and will try to load multiple
1.594 + //instances of the ECOM server, which will try to open and process Registry files at the
1.595 + //same time.
1.596 + TheLoadEcomServerSemaphore.Signal(KThreadCnt);
1.597 +
1.598 + //Wait until all threads die.
1.599 + for(i=0;i<KThreadCnt;++i)
1.600 + {
1.601 + User::WaitForRequest(threadStatus[i]);
1.602 + }
1.603 +
1.604 + //Close all threads.
1.605 + for(i=0;i<KThreadCnt;++i)
1.606 + {
1.607 + loadEcomThread[i].Close();
1.608 + }
1.609 +
1.610 + TheLoadEcomServerSemaphore.Close();
1.611 + //Put a break point there and kill the test
1.612 + //Check EPOCWIND.OUT file.
1.613 + }
1.614 +/**
1.615 +Copies the Resolver Plugins to C:\ drive
1.616 +*/
1.617 +LOCAL_C void CopyPluginsL()
1.618 + {
1.619 + // Copy the dlls and .rsc files on to RAM
1.620 + TRAPD(err, EComTestUtils::FileManCopyFileL(KEComExDllOnZ, KEComExDllOnC));
1.621 + TEST(err==KErrNone, __LINE__);
1.622 + TRAP(err, EComTestUtils::FileManCopyFileL(KEComRscFileOnZ, KEComRscFileOnC));
1.623 + TEST(err==KErrNone, __LINE__);
1.624 + // Wait, so that ECom server looks for plugins copied from Z: to C drive
1.625 + // ECOM server could be already started. It means that when we copy some
1.626 + // ECOM plugins from Z: to C: drive - ECOM server should look for and
1.627 + // find the new ECOM plugins. The ECOM server uses for that CDiscoverer::CIdleScanningTimer
1.628 + // which is an active object. So the discovering service is asynchronous. We have to
1.629 + // wait some time until it finishes. Otherwise ListImplementationsL could fail to find
1.630 + // requested implementations.
1.631 + User::After(5000000);
1.632 + }
1.633 +
1.634 +
1.635 +LOCAL_C void RunTestL()
1.636 + {
1.637 + __UHEAP_MARK;
1.638 +
1.639 + CopyPluginsL();
1.640 +
1.641 + REcomDefectTest::DEF049285_TestCaseL();
1.642 +
1.643 + REcomDefectTest::DEF049979_TestCaseL();
1.644 +
1.645 + REcomDefectTest::INC057514_TestCaseL();
1.646 +
1.647 + REcomDefectTest::DEF065025_TestCase();
1.648 + DeleteTestPlugin();
1.649 +
1.650 + __UHEAP_MARKEND;
1.651 + }
1.652 +
1.653 +GLDEF_C TInt E32Main()
1.654 + {
1.655 + __UHEAP_MARK;
1.656 +
1.657 + TEST.Title();
1.658 + TEST.Start(_L("Ecom Defect tests."));
1.659 +
1.660 + CTrapCleanup* cleanup = CTrapCleanup::New();
1.661 + CActiveScheduler* scheduler = new(ELeave)CActiveScheduler;
1.662 + CActiveScheduler::Install(scheduler);
1.663 +
1.664 + TRAPD(err,RunTestL());
1.665 + TEST(err==KErrNone, __LINE__);
1.666 +
1.667 + delete scheduler;
1.668 + delete cleanup;
1.669 +
1.670 + TEST.End();
1.671 + TEST.Close();
1.672 +
1.673 + __UHEAP_MARKEND;
1.674 + return(0);
1.675 + }