os/ossrv/lowlevellibsandfws/pluginfw/Framework/ExtendedInterfacesTest/t_extendedinterfaces.cpp
1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/lowlevellibsandfws/pluginfw/Framework/ExtendedInterfacesTest/t_extendedinterfaces.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1653 @@
1.4 +// Copyright (c) 2007-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 <f32file.h>
1.21 +#include <bautils.h>
1.22 +#include <ecom/ecom.h>
1.23 +#include <ecom/ecompanics.h>
1.24 +#include "EComUidCodes.h"
1.25 +#include "Interface.h" // interface to Plugins
1.26 +#include "../EcomTestUtils/EcomTestUtils.h"
1.27 +
1.28 +//The tests test all the new APIs added to REComSession created for EC43
1.29 +
1.30 +TUid KCExampleImplUid = {0x10009DC3};
1.31 +
1.32 +const TInt KOneSecond = 1000000;
1.33 +
1.34 +LOCAL_D RTest test(_L("t_extendedinterfaces"));
1.35 +LOCAL_D RFs TheFs;
1.36 +
1.37 +#define __UNUSED_VAR(var) var = var
1.38 +
1.39 +// Used for OOM test
1.40 +#define TEST_OOM_ERR if(err == KErrNoMemory) {User::Leave(err);}
1.41 +
1.42 +
1.43 +static void ResetAndDestroyArray(TAny* aPtr)
1.44 + {
1.45 + (static_cast<RImplInfoPtrArray*>(aPtr))->ResetAndDestroy();
1.46 + }
1.47 +
1.48 +
1.49 +/**
1.50 +Test function for REcomSession::ListImplementationL
1.51 +
1.52 +@param aContainInvalidExtIf The bool value identifying if the extended interfaces list contains
1.53 + invalid extended interface Uid
1.54 +@param aUseDefResolver The bool value identifying if default resolver is used.
1.55 +@param aUseResolveParam The bool value identifying if resolve parameter is used.
1.56 +@param aNumEntriesInExtIFList The number of entries in the extended interfaces list.
1.57 +@param aImplInfoArray A reference to a client owned array which will be filled
1.58 + with interface implementation data.
1.59 +*/
1.60 +LOCAL_C void ListImplementationTestL(TBool aContainInvalidExtIf,
1.61 + TBool aUseDefResolver,
1.62 + TBool aUseResolveParam,
1.63 + TInt aNumEntriesInExtIFList,
1.64 + RImplInfoPtrArray& aImplInfoArray)
1.65 + {
1.66 + const TUid KInterfaceUid = {0x10009DBB};
1.67 + const TUid KExtendedInterfaceUid1 = {0x10009E44};
1.68 + const TUid KExtendedInterfaceUid2 = {0x10009E45};
1.69 + const TUid KExtendedInterfaceUid3 = {0x10009E46};
1.70 + const TUid KInvalidExtendedInterfaceUid2 = {0x10009E49};
1.71 + _LIT8(KExample10ImplementationTest,"Example 10");
1.72 +
1.73 + TUid resolverUid = {0x10009DD0};
1.74 +
1.75 + // Set up extended interfaces
1.76 + RArray<TUid> extendedInterfaces;
1.77 + CleanupClosePushL(extendedInterfaces);
1.78 +
1.79 + if (!aContainInvalidExtIf)
1.80 + {
1.81 + if (aNumEntriesInExtIFList==1)
1.82 + {
1.83 + extendedInterfaces.AppendL(KExtendedInterfaceUid1);
1.84 + }
1.85 + else if (aNumEntriesInExtIFList>1)
1.86 + {
1.87 + extendedInterfaces.AppendL(KExtendedInterfaceUid2);
1.88 + extendedInterfaces.AppendL(KExtendedInterfaceUid3);
1.89 + }
1.90 + }
1.91 + else
1.92 + {
1.93 + extendedInterfaces.AppendL(KExtendedInterfaceUid1);
1.94 + extendedInterfaces.AppendL(KInvalidExtendedInterfaceUid2);
1.95 + }
1.96 +
1.97 + //Set up resolve parameter
1.98 + TEComResolverParams ResolverParams;
1.99 + if (aUseResolveParam)
1.100 + {
1.101 + ResolverParams.SetDataType(KExample10ImplementationTest());
1.102 + ResolverParams.SetGenericMatch(ETrue); // Allow wildcard matching
1.103 + if (aUseDefResolver) //ListImplementationTest2L,ListImplementationTest4L
1.104 + {
1.105 + REComSession::ListImplementationsL(KInterfaceUid,extendedInterfaces,ResolverParams,aImplInfoArray);
1.106 + }
1.107 + else //ListImplementationTest3L
1.108 + {
1.109 + REComSession::ListImplementationsL(KInterfaceUid,extendedInterfaces,ResolverParams,resolverUid,aImplInfoArray);
1.110 + }
1.111 +
1.112 + }
1.113 + else //ListImplementationTest1L, ListImplementationTest5L
1.114 + {
1.115 + REComSession::ListImplementationsL(KInterfaceUid,extendedInterfaces,aImplInfoArray);
1.116 + }
1.117 + CleanupStack::PopAndDestroy(&extendedInterfaces);
1.118 + }
1.119 +
1.120 +
1.121 +/**
1.122 +@SYMTestCaseID SYSLIB-ECOM-CT-3597
1.123 +@SYMTestCaseDesc Tests for CImplementationInformation structure.
1.124 +@SYMTestPriority High
1.125 +@SYMTestActions Call ListImplementationL method to get a list of implementations with extended interfaces.
1.126 + Check that the expected extended interfaces are available in the CImplementationInformation
1.127 + data structure via GetExtendedInterfaceList method.
1.128 +@SYMTestExpectedResults Extended interfaces are available in implementation information structure.
1.129 +@SYMEC EC43
1.130 +*/
1.131 +LOCAL_C void ListImplementationTest5L()
1.132 + {
1.133 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3597 "));
1.134 + // Test Starts...
1.135 + RImplInfoPtrArray ifArray;
1.136 + TBool containInvalidExtIf = EFalse;
1.137 + TBool useDefResolver = ETrue;
1.138 + TBool useResolveParam = EFalse;
1.139 + TInt numEntriesOnExtIFList = 3;
1.140 +
1.141 + ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
1.142 +
1.143 + //Checks the result
1.144 + //0x10009E38 is implemented in EcomExample10.dll
1.145 + TUid KExample10ImplUid = {0x10009E38};
1.146 + TUid KExtendedInterfaceUid1 = {0x10009E44};
1.147 + TUid KExtendedInterfaceUid2 = {0x10009E45};
1.148 + TUid KExtendedInterfaceUid3 = {0x10009E46};
1.149 + const TInt availCount = ifArray.Count();
1.150 + test.Printf(_L("Found %d implementations.\n"),availCount);
1.151 + test(availCount == 1);
1.152 +
1.153 + //tests extended interfaces
1.154 + CImplementationInformation* info = ifArray[0];
1.155 + test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
1.156 + test (KExample10ImplUid==info->ImplementationUid());
1.157 +
1.158 + CleanupStack::PushL(TCleanupItem(ResetAndDestroyArray, &ifArray));
1.159 +
1.160 + // Gets extended interfaces list
1.161 + RArray<TUid> extInf;
1.162 + CleanupClosePushL(extInf);
1.163 + info->GetExtendedInterfaceListL(extInf);
1.164 + test(extInf[0] == KExtendedInterfaceUid1);
1.165 + test(extInf[1] == KExtendedInterfaceUid2);
1.166 + test(extInf[2] == KExtendedInterfaceUid3);
1.167 + CleanupStack::PopAndDestroy(&extInf);
1.168 +
1.169 + // Empty the array of implementations
1.170 + test.Printf(_L("Destroying List..."));
1.171 + CleanupStack::PopAndDestroy(&ifArray);
1.172 + }
1.173 +
1.174 +
1.175 +/**
1.176 +@SYMTestCaseID SYSLIB-ECOM-CT-3594
1.177 +@SYMTestCaseDesc Tests for REComSession::ListImplementationL created with an Interface Uid
1.178 + and invalid extended Interfaces.
1.179 +@SYMTestPriority High
1.180 +@SYMTestActions Call ListImplementationL method supporting interface UID and extended interfaces
1.181 + that are invalid.
1.182 +@SYMTestExpectedResults No implementation is returned.
1.183 +@SYMEC EC43
1.184 +*/
1.185 +LOCAL_C void ListImplementationTest4L()
1.186 + {
1.187 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3594 "));
1.188 + // Test Starts...
1.189 + RImplInfoPtrArray ifArray;
1.190 + TBool containInvalidExtIf = ETrue;
1.191 + TBool useDefResolver = ETrue;
1.192 + TBool useResolveParam = ETrue;
1.193 + TInt numEntriesOnExtIFList = 2;
1.194 +
1.195 + ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
1.196 +
1.197 + //Checks the result
1.198 + const TInt availCount = ifArray.Count();
1.199 + test.Printf(_L("Found %d implementations.\n"),availCount);
1.200 + test(availCount == 0);
1.201 +
1.202 + // Empty the array of implementations
1.203 + test.Printf(_L("Destroying List..."));
1.204 + ifArray.ResetAndDestroy();
1.205 + }
1.206 +
1.207 +/**
1.208 +@SYMTestCaseID SYSLIB-ECOM-CT-3589
1.209 +@SYMTestCaseDesc Tests for REComSession::ListImplementationsL for known Interface UID,
1.210 + resolver match characteristics, resolver UID and extended interfaces.
1.211 +@SYMTestPriority High
1.212 +@SYMTestActions Call ListImplementationL method supporting interface UID, resolver parameters
1.213 + resolver UID and extended interfaces.
1.214 +@SYMTestExpectedResults Expected implementations are returned.
1.215 +@SYMEC EC43
1.216 +*/
1.217 +LOCAL_C void ListImplementationTest3L()
1.218 + {
1.219 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3589 "));
1.220 + // Test Starts...
1.221 + RImplInfoPtrArray ifArray;
1.222 + TBool containInvalidExtIf = EFalse;
1.223 + TBool useDefResolver = EFalse;
1.224 + TBool useResolveParam = ETrue;
1.225 +
1.226 + //Number of entries in extended interfaces is 3.
1.227 + TInt numEntriesOnExtIFList = 3;
1.228 + ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
1.229 +
1.230 + //Checks the result
1.231 + TUid KImplementationUid = {0x10009E38};
1.232 + TInt availCount = ifArray.Count();
1.233 + test.Printf(_L("Found %d implementations.\n"),availCount);
1.234 + test(availCount == 1);
1.235 +
1.236 + //tests implementation uid
1.237 + for (TInt count = 0; count < availCount; ++count)
1.238 + {
1.239 + const CImplementationInformation* info = ifArray[count];
1.240 + test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
1.241 + test(KImplementationUid == info->ImplementationUid());
1.242 + }
1.243 +
1.244 + // Empty the array of implementations
1.245 + test.Printf(_L("Destroying List..."));
1.246 + ifArray.ResetAndDestroy();
1.247 +
1.248 + //Number of entries in extended interfaces is 0.
1.249 + numEntriesOnExtIFList = 0;
1.250 + ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
1.251 +
1.252 + //Checks the result
1.253 + availCount = ifArray.Count();
1.254 + test.Printf(_L("Found %d implementations.\n"),availCount);
1.255 + test(availCount == 1);
1.256 +
1.257 + //tests implementation uid
1.258 + for (TInt count = 0; count < availCount; ++count)
1.259 + {
1.260 + const CImplementationInformation* info = ifArray[count];
1.261 + test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
1.262 + }
1.263 +
1.264 + // Empty the array of implementations
1.265 + test.Printf(_L("Destroying List..."));
1.266 + ifArray.ResetAndDestroy();
1.267 +
1.268 + //Number of entries in extended interfaces is 1.
1.269 + numEntriesOnExtIFList = 1;
1.270 + ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
1.271 +
1.272 + //Checks the result
1.273 + availCount = ifArray.Count();
1.274 + test.Printf(_L("Found %d implementations.\n"),availCount);
1.275 + test(availCount == 1);
1.276 +
1.277 + //tests implementation uid
1.278 + for (TInt count = 0; count < availCount; ++count)
1.279 + {
1.280 + const CImplementationInformation* info = ifArray[count];
1.281 + test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
1.282 + }
1.283 +
1.284 + // Empty the array of implementations
1.285 + test.Printf(_L("Destroying List..."));
1.286 + ifArray.ResetAndDestroy();
1.287 + }
1.288 +
1.289 +
1.290 +/**
1.291 +@SYMTestCaseID SYSLIB-ECOM-CT-3588
1.292 +@SYMTestCaseDesc Tests for REComSession::ListImplementationsL for known Interface UID,
1.293 + resolver match characteristics and extended interfaces.
1.294 +@SYMTestPriority High
1.295 +@SYMTestActions Call ListImplementationL method supporting interface UID, resolver parameters and extended interfaces.
1.296 +@SYMTestExpectedResults Expected implementations are returned.
1.297 +@SYMEC EC43
1.298 +*/
1.299 +LOCAL_C void ListImplementationTest2L()
1.300 + {
1.301 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3588 "));
1.302 + // Test Starts...
1.303 + RImplInfoPtrArray ifArray;
1.304 + TBool containInvalidExtIf = EFalse;
1.305 + TBool useDefResolver = ETrue;
1.306 + TBool useResolveParam = ETrue;
1.307 +
1.308 + //Number of entries in extended interfaces is 3.
1.309 + TInt numEntriesOnExtIFList = 3;
1.310 + ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
1.311 +
1.312 + //Checks the result
1.313 + TUid KImplementationUid = {0x10009E38};
1.314 + TInt availCount = ifArray.Count();
1.315 + test.Printf(_L("Found %d implementations.\n"),availCount);
1.316 + test(availCount == 1);
1.317 +
1.318 + //tests implementation uid
1.319 + for (TInt count = 0; count < availCount; ++count)
1.320 + {
1.321 + const CImplementationInformation* info = ifArray[count];
1.322 + test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
1.323 + test(KImplementationUid==info->ImplementationUid());
1.324 + }
1.325 +
1.326 + // Empty the array of implementations
1.327 + test.Printf(_L("Destroying List..."));
1.328 + ifArray.ResetAndDestroy();
1.329 +
1.330 + //Number of entries in extended interfaces is 0.
1.331 + numEntriesOnExtIFList = 0;
1.332 + ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
1.333 +
1.334 + //Checks the result
1.335 + availCount = ifArray.Count();
1.336 + test.Printf(_L("Found %d implementations.\n"),availCount);
1.337 + test(availCount == 1);
1.338 +
1.339 + //tests implementation uid
1.340 + for (TInt count = 0; count < availCount; ++count)
1.341 + {
1.342 + const CImplementationInformation* info = ifArray[count];
1.343 + test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
1.344 + }
1.345 +
1.346 + // Empty the array of implementations
1.347 + test.Printf(_L("Destroying List..."));
1.348 + ifArray.ResetAndDestroy();
1.349 +
1.350 + //Number of entries in extended interfaces is 1.
1.351 + numEntriesOnExtIFList = 1;
1.352 + ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
1.353 +
1.354 + //Checks the result
1.355 + availCount = ifArray.Count();
1.356 + test.Printf(_L("Found %d implementations.\n"),availCount);
1.357 + test(availCount == 1);
1.358 +
1.359 + //tests implementation uid
1.360 + for (TInt count = 0; count < availCount; ++count)
1.361 + {
1.362 + const CImplementationInformation* info = ifArray[count];
1.363 + test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
1.364 + }
1.365 +
1.366 + // Empty the array of implementations
1.367 + test.Printf(_L("Destroying List..."));
1.368 + ifArray.ResetAndDestroy();
1.369 + }
1.370 +
1.371 +
1.372 +/**
1.373 +@SYMTestCaseID SYSLIB-ECOM-CT-3587
1.374 +@SYMTestCaseDesc Tests for REComSession::ListImplementationsL for known Interface UID and extended interfaces.
1.375 +@SYMTestPriority High
1.376 +@SYMTestActions Call ListImplementationL method supporting interface UID and extended interfaces.
1.377 +@SYMTestExpectedResults Expected implementations are returned.
1.378 +@SYMEC EC43
1.379 +*/
1.380 +LOCAL_C void ListImplementationTest1L()
1.381 + {
1.382 + //
1.383 + // Testing a overloaded method for ListImplementationsL
1.384 + // ------------------------------------------------------------------
1.385 + //
1.386 + // Test Starts...
1.387 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3587 "));
1.388 + RImplInfoPtrArray ifArray;
1.389 +
1.390 + TBool containInvalidExtIf = EFalse;
1.391 + TBool useDefResolver = ETrue;
1.392 + TBool useResolveParam = EFalse;
1.393 +
1.394 + //Number of entries in extended interfaces is 3.
1.395 + TInt numEntriesOnExtIFList = 3;
1.396 + ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
1.397 +
1.398 + //Checks the result
1.399 + //0x10009E38 is implemented in EcomExample10.dll
1.400 + TUid KExample10ImplUid = {0x10009E38};
1.401 + TInt availCount = ifArray.Count();
1.402 + test.Printf(_L("Found %d implementations.\n"),availCount);
1.403 + test(availCount == 1);
1.404 +
1.405 + //tests implementation uid
1.406 + const CImplementationInformation* info = ifArray[0];
1.407 + test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
1.408 + test(KExample10ImplUid == info->ImplementationUid());
1.409 +
1.410 + // Empty the array of implementations
1.411 + test.Printf(_L("Destroying List..."));
1.412 + ifArray.ResetAndDestroy();
1.413 +
1.414 + //Number of entries in extended interfaces is 0.
1.415 + numEntriesOnExtIFList = 0;
1.416 + ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
1.417 +
1.418 + //Checks the result
1.419 + availCount = ifArray.Count();
1.420 + test.Printf(_L("Found %d implementations.\n"),availCount);
1.421 + test(availCount == 3);
1.422 +
1.423 + //tests implementation uid
1.424 + for (TInt count = 0;count < availCount; ++count)
1.425 + {
1.426 + const CImplementationInformation* info = ifArray[count];
1.427 + test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
1.428 + }
1.429 +
1.430 + // Empty the array of implementations
1.431 + test.Printf(_L("Destroying List..."));
1.432 + ifArray.ResetAndDestroy();
1.433 +
1.434 + //Number of entries in extended interfaces is 1.
1.435 + numEntriesOnExtIFList = 1;
1.436 + ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
1.437 +
1.438 + //Checks the result
1.439 + availCount = ifArray.Count();
1.440 + test.Printf(_L("Found %d implementations.\n"),availCount);
1.441 + test(availCount == 2);
1.442 +
1.443 + //tests implementation uid
1.444 + for (TInt count = 0; count < availCount; ++count)
1.445 + {
1.446 + const CImplementationInformation* info = ifArray[count];
1.447 + test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
1.448 + }
1.449 +
1.450 + // Empty the array of implementations
1.451 + test.Printf(_L("Destroying List..."));
1.452 + ifArray.ResetAndDestroy();
1.453 + }
1.454 +
1.455 +
1.456 +/**
1.457 +@SYMTestCaseID SYSLIB-ECOM-CT-3713
1.458 +@SYMTestCaseDesc Tests for REComSession::CreateImplementationL and REComSession::ListImplementationL
1.459 + with a dummy Interface Uid, dummy implementation Uid or dummy resolver Uid.
1.460 +@SYMTestPriority High
1.461 +@SYMTestActions Call CreateImplementationL method with a dummy interface UID
1.462 + Call CreateImplementationL method with a dummy implementation UID
1.463 + Call CreateImplementationL method with a dummy Resolver UID
1.464 + Call ListImplementationL method with a dummy interface UID
1.465 + Call ListImplementationL method with a dummy Resolver UID
1.466 +@SYMTestExpectedResults Leave with KErrAugument and No implementation is created.
1.467 +@SYMDEF DEF111196
1.468 +*/
1.469 +LOCAL_C void DummyUidTestL()
1.470 + {
1.471 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3713 "));
1.472 + TUid instanceKey;
1.473 + TUid dummyUid;
1.474 + dummyUid.iUid = 0;
1.475 + const TUid KInterfaceUid = {0x10009DBB};
1.476 + const TUid KExample10InterfaceUid = {0x10009DBB};
1.477 + _LIT8(KExample10ImplementationTest,"Example 10");
1.478 +
1.479 + CExampleInterface* dllPtr = NULL;
1.480 + // Set up extended interfaces
1.481 + RArray<TUid> extendedInterfaces;
1.482 + CleanupClosePushL(extendedInterfaces);
1.483 +
1.484 + //Set up resolve parameter
1.485 + TEComResolverParams ResolverParams;
1.486 + ResolverParams.SetDataType(KExample10ImplementationTest());
1.487 + ResolverParams.SetGenericMatch(ETrue); // Allow wildcard matching
1.488 +
1.489 + CExampleInterface::TExampleInterfaceInitParams initParams;
1.490 + // Set up some empty initialisation parameters
1.491 + initParams.integer = 0;
1.492 + initParams.descriptor = NULL;
1.493 +
1.494 + // CreateImplementationL with a dummy interface Uid
1.495 + TRAPD(err,dllPtr = REINTERPRET_CAST(CExampleInterface*,
1.496 + REComSession::CreateImplementationL(dummyUid,
1.497 + extendedInterfaces,
1.498 + instanceKey,
1.499 + ResolverParams,
1.500 + &initParams)));
1.501 + test(err == KErrArgument);
1.502 + test(dllPtr == NULL);
1.503 +
1.504 + // CreateImplementationL with a dummy implementation Uid
1.505 + TRAP(err,dllPtr = REINTERPRET_CAST(CExampleInterface*,
1.506 + REComSession::CreateImplementationL(dummyUid,
1.507 + instanceKey)));
1.508 + test(err == KErrArgument);
1.509 + test(dllPtr == NULL);
1.510 +
1.511 + // CreateImplementationL with a dummy resolver Uid
1.512 + TRAP(err, dllPtr = REINTERPRET_CAST(CExampleInterface*,
1.513 + REComSession::CreateImplementationL(KExample10InterfaceUid,
1.514 + extendedInterfaces,
1.515 + instanceKey,
1.516 + ResolverParams,
1.517 + dummyUid,
1.518 + &initParams)));
1.519 + test(err == KErrArgument);
1.520 + test(dllPtr == NULL);
1.521 +
1.522 + RImplInfoPtrArray ifArray;
1.523 +
1.524 + // ListImplementationL with a dummy interface Uid
1.525 + TRAP(err, REComSession::ListImplementationsL(dummyUid,extendedInterfaces,ResolverParams,ifArray));
1.526 + test(err == KErrArgument);
1.527 + test(ifArray.Count() == 0);
1.528 +
1.529 + // ListImplementationL with a dummy resolver Uid
1.530 + TRAP(err, REComSession::ListImplementationsL(KInterfaceUid,extendedInterfaces,ResolverParams,dummyUid,ifArray));
1.531 + test(err == KErrArgument);
1.532 + test(ifArray.Count() == 0);
1.533 +
1.534 + CleanupStack::PopAndDestroy(&extendedInterfaces);
1.535 + }
1.536 +
1.537 +/**
1.538 +@SYMTestCaseID SYSLIB-ECOM-CT-3715
1.539 +@SYMTestCaseDesc Tests for REComSession::CreateImplementationL with ROMOnly resolver
1.540 +@SYMTestPriority High
1.541 +@SYMTestActions Call CreateImplementationL method with ROMOnly resolver
1.542 +@SYMTestExpectedResults Expected implementation is created. Ensure there is no OOM error.
1.543 +@SYMDEF DEF111196
1.544 +*/
1.545 +LOCAL_C void CreateImplementationTest7L()
1.546 + {
1.547 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3715 "));
1.548 + // test start...
1.549 + const TUid KExample10InterfaceUid = {0x10009DBB};
1.550 + const TUid KExtendedInterfaceUid1 = {0x10009E44};
1.551 + const TUid KExtendedInterfaceUid2 = {0x10009E45};
1.552 + const TUid KExtendedInterfaceUid3 = {0x10009E46};
1.553 + const TUid KExample10ImplementationUid = {0x10009E38};
1.554 +
1.555 + _LIT8(KExample10ImplementationTest,"Example 10");
1.556 +
1.557 + // ROMOnly resolver Uid 0x10009D92
1.558 + TUid resolverUid = {0x10009D92};
1.559 +
1.560 + TUid instanceKey;
1.561 +
1.562 + CExampleInterface* dllPtr = NULL;
1.563 + // Set up extended interfaces
1.564 + RArray<TUid> extendedInterfaces;
1.565 + CleanupClosePushL(extendedInterfaces);
1.566 + extendedInterfaces.AppendL(KExtendedInterfaceUid1);
1.567 + extendedInterfaces.AppendL(KExtendedInterfaceUid2);
1.568 + extendedInterfaces.AppendL(KExtendedInterfaceUid3);
1.569 +
1.570 + //Set up resolve parameter
1.571 + TEComResolverParams ResolverParams;
1.572 + ResolverParams.SetDataType(KExample10ImplementationTest());
1.573 + ResolverParams.SetGenericMatch(ETrue); // Allow wildcard matching
1.574 +
1.575 + dllPtr = REINTERPRET_CAST(CExampleInterface*,
1.576 + REComSession::CreateImplementationL(KExample10InterfaceUid,
1.577 + extendedInterfaces,
1.578 + instanceKey,
1.579 + ResolverParams,
1.580 + resolverUid));
1.581 + CleanupStack::PopAndDestroy(&extendedInterfaces);
1.582 +
1.583 + //checks the implementation created
1.584 + test(dllPtr != NULL);
1.585 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
1.586 + test(KExample10ImplementationUid == dllPtr->ImplId());
1.587 +
1.588 + test.Printf(_L("Destroying Plugin..."));
1.589 + REComSession::DestroyedImplementation(instanceKey);
1.590 +
1.591 + delete dllPtr;
1.592 + }
1.593 +
1.594 +
1.595 +/**
1.596 +Test function for REcomSession::CreateImplementationL
1.597 +
1.598 +@param aContainInvalidExtIf The bool value identifying if the extended interfaces list contains
1.599 + invalid extended interface Uid
1.600 +@param aUseDefResolver The bool value identifying if default resolver is used.
1.601 +@param aUseInitParam The bool value identifying if initialise parameter is used.
1.602 +@param aNumEntriesInExtIFList The number of entries in the extended interfaces list.
1.603 +@param aInstanceKey A 32 bit identifer returned by the ECom framework to
1.604 + identify this instance to the framework.
1.605 +@return A pointer to the implementation created.
1.606 +*/
1.607 +LOCAL_C CExampleInterface* CreateImplementationTestL(TBool aContainInvalidExtIf,
1.608 + TBool aUseDefResolver,
1.609 + TBool aUseInitParam,
1.610 + TUid& aInstanceKey)
1.611 + {
1.612 + const TUid KExample10InterfaceUid = {0x10009DBB};
1.613 + const TUid KExtendedInterfaceUid1 = {0x10009E44};
1.614 + const TUid KExtendedInterfaceUid2 = {0x10009E45};
1.615 + const TUid KExtendedInterfaceUid3 = {0x10009E46};
1.616 + const TUid KInvalidExtendedInterfaceUid2 = {0x10009E49};
1.617 + _LIT8(KExample10ImplementationTest,"Example 10");
1.618 +
1.619 + TUid resolverUid = {0x10009DD0};
1.620 +
1.621 + CExampleInterface* dllPtr = NULL;
1.622 + // Set up extended interfaces
1.623 + RArray<TUid> extendedInterfaces;
1.624 + CleanupClosePushL(extendedInterfaces);
1.625 +
1.626 + if (!aContainInvalidExtIf)
1.627 + {
1.628 + extendedInterfaces.AppendL(KExtendedInterfaceUid1);
1.629 + extendedInterfaces.AppendL(KExtendedInterfaceUid2);
1.630 + extendedInterfaces.AppendL(KExtendedInterfaceUid3);
1.631 + }
1.632 + else
1.633 + {
1.634 + extendedInterfaces.AppendL(KExtendedInterfaceUid1);
1.635 + extendedInterfaces.AppendL(KInvalidExtendedInterfaceUid2);
1.636 + }
1.637 +
1.638 + //Set up resolve parameter
1.639 + TEComResolverParams ResolverParams;
1.640 + ResolverParams.SetDataType(KExample10ImplementationTest());
1.641 + ResolverParams.SetGenericMatch(ETrue); // Allow wildcard matching
1.642 +
1.643 + CExampleInterface::TExampleInterfaceInitParams initParams;
1.644 + if (aUseInitParam) //CreateImplementationTest3L,CreateImplementationTest5L
1.645 + {
1.646 + // Set up some empty initialisation parameters
1.647 + initParams.integer = 0;
1.648 + initParams.descriptor = NULL;
1.649 + if (aUseDefResolver) //CreateImplementationTest3L
1.650 + {
1.651 + dllPtr = REINTERPRET_CAST(CExampleInterface*,
1.652 + REComSession::CreateImplementationL(KExample10InterfaceUid,
1.653 + extendedInterfaces,
1.654 + aInstanceKey,
1.655 + ResolverParams,
1.656 + &initParams));
1.657 + }
1.658 + else //CreateImplementationTest5L
1.659 + {
1.660 + dllPtr = REINTERPRET_CAST(CExampleInterface*,
1.661 + REComSession::CreateImplementationL(KExample10InterfaceUid,
1.662 + extendedInterfaces,
1.663 + aInstanceKey,
1.664 + ResolverParams,
1.665 + resolverUid,
1.666 + &initParams));
1.667 + }
1.668 + }
1.669 + else //CreateImplementationTest2L, CreateImplementationTest4L, CreateImplementationTest6
1.670 + {
1.671 + if (aUseDefResolver) //CreateImplementationTest2L, CreateImplementationTest6
1.672 + {
1.673 + dllPtr = REINTERPRET_CAST(CExampleInterface*,
1.674 + REComSession::CreateImplementationL(KExample10InterfaceUid,
1.675 + extendedInterfaces,
1.676 + aInstanceKey,
1.677 + ResolverParams));
1.678 + }
1.679 + else //CreateImplementationTest4L
1.680 + {
1.681 + dllPtr = REINTERPRET_CAST(CExampleInterface*,
1.682 + REComSession::CreateImplementationL(KExample10InterfaceUid,
1.683 + extendedInterfaces,
1.684 + aInstanceKey,
1.685 + ResolverParams,
1.686 + resolverUid));
1.687 + }
1.688 + }
1.689 + CleanupStack::PopAndDestroy(&extendedInterfaces);
1.690 + return dllPtr;
1.691 + }
1.692 +
1.693 +/**
1.694 +@SYMTestCaseID SYSLIB-ECOM-CT-3708
1.695 +@SYMTestCaseDesc Tests for calling DestroyedImplementation() twice.
1.696 +@SYMTestPriority High
1.697 +@SYMTestActions Call CreateImplementationL method to load a plugin.
1.698 + Delete the plugin by calling DestroyedImplementation() twice.
1.699 + Delete pointer. Call DestroyedImplementation().
1.700 + Cal FinalClose(). Call DestroyedImplementation().
1.701 +@SYMTestExpectedResults Second call to DestroyedImplementation() should succeed.
1.702 +@SYMDEF DEF111428
1.703 +*/
1.704 +LOCAL_C void DestroyedImplementationTestL()
1.705 + {
1.706 + // Test Starts...
1.707 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3708 "));
1.708 + TUid instanceKey;
1.709 + TBool containInvalidExtIf = EFalse;
1.710 + TBool useDefResolver = EFalse;
1.711 + TBool useInitParam = ETrue;
1.712 + TUid KExample10ImplementationUid = {0x10009E38};
1.713 +
1.714 + test.Printf(_L("Loading Plugin..."));
1.715 +
1.716 + // Test create implementation by pass in instance key.
1.717 + CExampleInterface* dllPtr = CreateImplementationTestL(containInvalidExtIf,useDefResolver,useInitParam,instanceKey);
1.718 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
1.719 + test(KExample10ImplementationUid == dllPtr->ImplId());
1.720 +
1.721 + // the destructor calls DestroyedImplementation()
1.722 + test.Printf(_L("Calling DestroyedImplementation the 1st time through the plugin destructor..."));
1.723 + delete dllPtr;
1.724 +
1.725 + test.Printf(_L("Calling DestroyedImplementation a 2nd time directly through REComSession..."));
1.726 + REComSession::DestroyedImplementation(instanceKey);
1.727 +
1.728 + test.Printf(_L("Calling DestroyedImplementation a 3rd time directly through REComSession but after FinalClose..."));
1.729 +
1.730 + REComSession::DestroyedImplementation(instanceKey);
1.731 + }
1.732 +
1.733 +/**
1.734 +@SYMTestCaseID SYSLIB-ECOM-CT-3595
1.735 +@SYMTestCaseDesc Tests for REComSession::CreateImplementationL created with an Interface Uid
1.736 + and invalid extended Interfaces.
1.737 +@SYMTestPriority High
1.738 +@SYMTestActions Call CreateImplementationL method supporting interface UID and extended interfaces
1.739 + that are invalid.
1.740 +@SYMTestExpectedResults No implementation is created.
1.741 +@SYMEC EC43
1.742 +*/
1.743 +LOCAL_C void CreateImplementationTest6()
1.744 + {
1.745 + // Test Starts...
1.746 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3595 "));
1.747 + TUid instanceKey;
1.748 + TBool containInvalidExtIf = ETrue;
1.749 + TBool useDefResolver = ETrue;
1.750 + TBool useInitParam = EFalse;
1.751 +
1.752 + test.Printf(_L("Loading Plugin..."));
1.753 + TInt err;
1.754 + TRAP(err,CExampleInterface* dllPtr = CreateImplementationTestL(containInvalidExtIf,useDefResolver,useInitParam,instanceKey));
1.755 +
1.756 + test(KErrNotFound == err);
1.757 +
1.758 + test.Printf(_L("Implementation is not found.\n"));
1.759 + }
1.760 +
1.761 +/**
1.762 +@SYMTestCaseID SYSLIB-ECOM-CT-3593
1.763 +@SYMTestCaseDesc Tests for REComSession::CreateImplementationL created with an resolver Uid
1.764 +@SYMTestPriority High
1.765 +@SYMTestActions Call CreateImplementationL method supporting interface UID, extended interfaces,
1.766 + construction parameters, resolver parameters and resolver UID.
1.767 +@SYMTestExpectedResults Expected implementation is created and no memory leaks.
1.768 +@SYMEC EC43
1.769 +*/
1.770 +LOCAL_C void CreateImplementationTest5L()
1.771 + {
1.772 + // Test Starts...
1.773 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3593 "));
1.774 + TUid instanceKey;
1.775 + TBool containInvalidExtIf = EFalse;
1.776 + TBool useDefResolver = EFalse;
1.777 + TBool useInitParam = ETrue;
1.778 + TUid KExample10ImplementationUid = {0x10009E38};
1.779 +
1.780 + test.Printf(_L("Loading Plugin..."));
1.781 +
1.782 + // Test create implementation by pass in instance key.
1.783 + CExampleInterface* dllPtr = CreateImplementationTestL(containInvalidExtIf,useDefResolver,useInitParam,instanceKey);
1.784 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
1.785 + test(KExample10ImplementationUid == dllPtr->ImplId());
1.786 +
1.787 + test.Printf(_L("Destroying Plugin..."));
1.788 + REComSession::DestroyedImplementation(instanceKey);
1.789 + delete dllPtr;
1.790 +
1.791 + // Test create implementation by pass in offset of the instance key.
1.792 + dllPtr = CExampleInterface::NewL8();
1.793 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
1.794 + test(KExample10ImplementationUid == dllPtr->ImplId());
1.795 +
1.796 + test.Printf(_L("Destroying Plugin..."));
1.797 + delete dllPtr;
1.798 + }
1.799 +
1.800 +/**
1.801 +@SYMTestCaseID SYSLIB-ECOM-CT-3592
1.802 +@SYMTestCaseDesc Tests for REComSession::CreateImplementationL created with an resolver Uid
1.803 +@SYMTestPriority High
1.804 +@SYMTestActions Call CreateImplementationL method supporting interface UID, extended interfaces,
1.805 + resolver parameters and resolver UID.
1.806 +@SYMTestExpectedResults Expected implementation is created and no memory leaks.
1.807 +@SYMEC EC43
1.808 +*/
1.809 +LOCAL_C void CreateImplementationTest4L()
1.810 + {
1.811 + // Test Starts...
1.812 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3592 "));
1.813 + TUid instanceKey;
1.814 + TBool containInvalidExtIf = EFalse;
1.815 + TBool useDefResolver = EFalse;
1.816 + TBool useInitParam = EFalse;
1.817 + TUid KExample10ImplementationUid = {0x10009E38};
1.818 +
1.819 + test.Printf(_L("Loading Plugin..."));
1.820 +
1.821 + // Test create implementation by pass in instance key.
1.822 + CExampleInterface* dllPtr = CreateImplementationTestL(containInvalidExtIf,useDefResolver,useInitParam,instanceKey);
1.823 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
1.824 + test(KExample10ImplementationUid == dllPtr->ImplId());
1.825 +
1.826 + test.Printf(_L("Destroying Plugin..."));
1.827 + REComSession::DestroyedImplementation(instanceKey);
1.828 + delete dllPtr;
1.829 +
1.830 + // Test create implementation by pass in offset of the instance key.
1.831 + dllPtr = CExampleInterface::NewL6();
1.832 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
1.833 + test(KExample10ImplementationUid == dllPtr->ImplId());
1.834 +
1.835 + test.Printf(_L("Destroying Plugin..."));
1.836 + delete dllPtr;
1.837 + }
1.838 +
1.839 +/**
1.840 +@SYMTestCaseID SYSLIB-ECOM-CT-3591
1.841 +@SYMTestCaseDesc Tests for REComSession::CreateImplementationL created with an Interface Uid,
1.842 + ExtendedInterface, construction parameters and resolver parameters
1.843 +@SYMTestPriority High
1.844 +@SYMTestActions Call CreateImplementationL method supporting interface UID,extended interfaces,
1.845 + construction parameters and resolver parameters.
1.846 +@SYMTestExpectedResults Expected implementation is created and no memory leaks.
1.847 +@SYMEC EC43
1.848 +*/
1.849 +LOCAL_C void CreateImplementationTest3L()
1.850 + {
1.851 + // Test Starts...
1.852 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3591 "));
1.853 + TUid instanceKey;
1.854 + TBool containInvalidExtIf = EFalse;
1.855 + TBool useDefResolver = ETrue;
1.856 + TBool useInitParam = ETrue;
1.857 + TUid KExample10ImplementationUid = {0x10009E38};
1.858 +
1.859 + test.Printf(_L("Loading Plugin..."));
1.860 +
1.861 + // Test create implementation by pass in instance key.
1.862 + CExampleInterface* dllPtr = CreateImplementationTestL(containInvalidExtIf,useDefResolver,useInitParam,instanceKey);
1.863 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
1.864 + test(KExample10ImplementationUid == dllPtr->ImplId());
1.865 +
1.866 + test.Printf(_L("Destroying Plugin..."));
1.867 + REComSession::DestroyedImplementation(instanceKey);
1.868 + delete dllPtr;
1.869 +
1.870 + // Test create implementation by pass in offset of the instance key.
1.871 + dllPtr = CExampleInterface::NewL7();
1.872 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
1.873 + test(KExample10ImplementationUid == dllPtr->ImplId());
1.874 +
1.875 + test.Printf(_L("Destroying Plugin..."));
1.876 + delete dllPtr;
1.877 + }
1.878 +
1.879 +
1.880 +/**
1.881 +@SYMTestCaseID SYSLIB-ECOM-CT-3590
1.882 +@SYMTestCaseDesc Tests for REComSession::CreateImplementationL created with an Interface Uid,
1.883 + ExtendedInterface and resolver parameters.
1.884 +@SYMTestPriority High
1.885 +@SYMTestActions Call CreateImplementationL method supporting interface UID,extended interfaces, and resolver parameters.
1.886 +@SYMTestExpectedResults Expected implementation is created and no memory leaks.
1.887 +@SYMEC EC43
1.888 +*/
1.889 +LOCAL_C void CreateImplementationTest2L()
1.890 + {
1.891 + // Test Starts...
1.892 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3590 "));
1.893 + TUid instanceKey;
1.894 + TBool containInvalidExtIf = EFalse;
1.895 + TBool useDefResolver = ETrue;
1.896 + TBool useInitParam = EFalse;
1.897 + TUid KExample10ImplementationUid = {0x10009E38};
1.898 +
1.899 + test.Printf(_L("Loading Plugin..."));
1.900 + // Test create implementation by pass in instance key.
1.901 + CExampleInterface* dllPtr = CreateImplementationTestL(containInvalidExtIf,useDefResolver,useInitParam,instanceKey);
1.902 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
1.903 + test(KExample10ImplementationUid == dllPtr->ImplId());
1.904 +
1.905 + test.Printf(_L("Destroying Plugin..."));
1.906 + REComSession::DestroyedImplementation(instanceKey);
1.907 + delete dllPtr;
1.908 +
1.909 + // Test create implementation by pass in offset of the instance key.
1.910 + dllPtr = CExampleInterface::NewL5();
1.911 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
1.912 + test(KExample10ImplementationUid == dllPtr->ImplId());
1.913 +
1.914 + test.Printf(_L("Destroying Plugin..."));
1.915 + delete dllPtr;
1.916 + }
1.917 +
1.918 +/**
1.919 +@SYMTestCaseID SYSLIB-ECOM-CT-3586
1.920 +@SYMTestCaseDesc Tests for GetExtendedInterfaceL, Manual release
1.921 +@SYMTestPriority High
1.922 +@SYMTestActions Create an implementation. Fetch two extended interfaces (one build in, and one
1.923 + stand alone and requires release). Manually release the stand alone extended
1.924 + interface. Destroy implementation.
1.925 +@SYMTestExpectedResults Ensure that manual release releases the stand alone interface correctly.
1.926 +@SYMEC EC43
1.927 +*/
1.928 +LOCAL_C void GetExtendedInterfaceTest4L()
1.929 + {
1.930 + // Test Starts...
1.931 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3586 "));
1.932 + test.Printf(_L("Loading Plugin..."));
1.933 + const TUid KExample10ImplementationUid = {0x10009E38};
1.934 +
1.935 + CExampleInterface* dllPtr = CExampleInterface::NewL2(KExample10ImplementationUid);
1.936 + CleanupStack::PushL(dllPtr);
1.937 +
1.938 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
1.939 + test(KExample10ImplementationUid == dllPtr->ImplId());
1.940 +
1.941 + // Call extended interface here.
1.942 + const TUid KExample10InterfaceUid1 = {0x10009E44};
1.943 + const TUid KExample10InterfaceUid2 = {0x10009E45};
1.944 +
1.945 + MExampleInterfaceExtended* ext1 = static_cast<MExampleInterfaceExtended*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid1));
1.946 + ext1->DoMethodExtended();
1.947 +
1.948 + MExampleInterfaceExtended2* ext2 = static_cast<MExampleInterfaceExtended2*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid2));
1.949 + ext2->DoMethodExtended2();
1.950 +
1.951 + dllPtr->ManuallyReleaseExtendedInterfaceL(KExample10InterfaceUid2);
1.952 +
1.953 + test.Printf(_L("Destroying Plugin..."));
1.954 + CleanupStack::Pop(dllPtr);
1.955 + delete dllPtr;
1.956 +
1.957 + // Test Ends...
1.958 + }
1.959 +
1.960 +/**
1.961 +@SYMTestCaseID SYSLIB-ECOM-CT-4001
1.962 +@SYMTestCaseDesc Tests GetExtendedInterfaceL with invalid instance keys
1.963 +@SYMTestPriority High
1.964 +@SYMTestActions Retrieve extended interface using unknown instance key
1.965 + Retrieve extended interface using null instance key
1.966 +@SYMTestExpectedResults Ensure that correct leaves occur.
1.967 +@SYMDEF DEF111553
1.968 +*/
1.969 +LOCAL_C void GetExtendedInterfaceTest5L()
1.970 + {
1.971 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-4001 "));
1.972 + // Test Starts...
1.973 + TUid instanceKey;
1.974 + TBool containInvalidExtIf = EFalse;
1.975 + TBool useDefResolver = EFalse;
1.976 + TBool useInitParam = ETrue;
1.977 +
1.978 + // get valid instance key by creating implementation
1.979 + CExampleInterface* dllPtr = CreateImplementationTestL(containInvalidExtIf,useDefResolver,useInitParam,instanceKey);
1.980 +
1.981 + // remove implementation
1.982 + REComSession::DestroyedImplementation(instanceKey);
1.983 + delete dllPtr;
1.984 +
1.985 + // Attempt to fetch extended interface with instance key that is no longer valid but
1.986 + // passes the ASSERT test
1.987 + const TUid KExtendedInterfaceUid = {0x10009E44};
1.988 + TRAPD(err, REComSession::GetExtendedInterfaceL(instanceKey,KExtendedInterfaceUid));
1.989 + test(err = KErrNotFound);
1.990 +
1.991 + // Attempt to fetch extended interface with null instance key
1.992 + TRAP(err, REComSession::GetExtendedInterfaceL(KNullUid,KExtendedInterfaceUid));
1.993 + test(err = KErrArgument);
1.994 +
1.995 + // Test Ends...
1.996 + }
1.997 +
1.998 +/**
1.999 +@SYMTestCaseID SYSLIB-ECOM-CT-3581
1.1000 +@SYMTestCaseDesc Tests for REComSession::ListExtendedInterfaces with a valid Implementation UID.
1.1001 + Tests also for non-existent Implementation UID and PLUGIN1 implementation UID.
1.1002 + Does some create and destruction of implementations before and after calling
1.1003 + ListExtendedInterfaces to mimic typical usage.
1.1004 +@SYMTestPriority High
1.1005 +@SYMTestActions List the extended interfaces. Check expected extended interfaces are returned.
1.1006 + Create an implementation. Ensure that Listing of the extended interface
1.1007 + still works after the create.
1.1008 + Delete the implementation. List extended interfaces again.
1.1009 + List the extended interfaces with a PLUGIN1 implementation UID.
1.1010 +@SYMTestExpectedResults Ensure all ListExtendedInterfaces calls return with expected extended interfaces.
1.1011 +@SYMEC EC43
1.1012 +@SYMDEF DEF111196
1.1013 +*/
1.1014 +LOCAL_C void ListExtendedInterfaceTestL()
1.1015 + {
1.1016 + // Test Starts...
1.1017 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3581 "));
1.1018 + const TUid KExample10ImplementationUid = {0x10009E38};
1.1019 + const TUid KExample10ImplementationUid2 = {0x10009E3A};
1.1020 + const TUid KExample10ImplementationUid3 = {0x10009E3B};
1.1021 +
1.1022 + const TUid KExample10InterfaceUid1 = {0x10009E44};
1.1023 + const TUid KExample10InterfaceUid2 = {0x10009E45};
1.1024 + const TUid KExample10InterfaceUid3 = {0x10009E46};
1.1025 +
1.1026 + const TUid KImpUidPLUGIN1 = {0x10009DC3};
1.1027 +
1.1028 + RArray<TUid> ifInfo;
1.1029 + CleanupClosePushL(ifInfo);
1.1030 +
1.1031 + REComSession::ListExtendedInterfacesL(KExample10ImplementationUid,ifInfo);
1.1032 + test(ifInfo.Count() == 3);
1.1033 +
1.1034 + // Checks that expected interfaces are in list.
1.1035 + test(ifInfo[0] == KExample10InterfaceUid1);
1.1036 + test(ifInfo[1] == KExample10InterfaceUid2);
1.1037 + test(ifInfo[2] == KExample10InterfaceUid3);
1.1038 + ifInfo.Reset();
1.1039 +
1.1040 + // Creates an implementation
1.1041 + // Set up some empty initialisation parameters
1.1042 + test.Printf(_L("Loading Plugin..."));
1.1043 +
1.1044 + CExampleInterface* dllPtr = CExampleInterface::NewL2(KExample10ImplementationUid);
1.1045 + CleanupStack::PushL(dllPtr);
1.1046 +
1.1047 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
1.1048 + test(KExample10ImplementationUid == dllPtr->ImplId());
1.1049 +
1.1050 + // Calls extended interface here.
1.1051 + MExampleInterfaceExtended* ext1 = static_cast<MExampleInterfaceExtended*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid1));
1.1052 + ext1->DoMethodExtended();
1.1053 +
1.1054 + MExampleInterfaceExtended2* ext2 = static_cast<MExampleInterfaceExtended2*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid2));
1.1055 + ext2->DoMethodExtended2();
1.1056 +
1.1057 + // Checks that ListExtendedInterfaces works after a Create Implementation
1.1058 + REComSession::ListExtendedInterfacesL(KExample10ImplementationUid,ifInfo);
1.1059 + test(ifInfo.Count() == 3);
1.1060 +
1.1061 + // Checks that expected interfaces are in list.
1.1062 + test(ifInfo[0] == KExample10InterfaceUid1);
1.1063 + test(ifInfo[1] == KExample10InterfaceUid2);
1.1064 + test(ifInfo[2] == KExample10InterfaceUid3);
1.1065 + ifInfo.Reset();
1.1066 +
1.1067 + test.Printf(_L("Destroying Plugin..."));
1.1068 + CleanupStack::Pop(dllPtr);
1.1069 +
1.1070 + delete dllPtr;
1.1071 +
1.1072 + // Test fetch of extended interfaces for an implementation that has no extended interfaces
1.1073 + REComSession::ListExtendedInterfacesL(KExample10ImplementationUid2,ifInfo);
1.1074 + test(ifInfo.Count() == 0);
1.1075 + ifInfo.Reset();
1.1076 +
1.1077 + // Test fetch of extended interfaces for an implementation that does not exist
1.1078 + TRAPD(err,REComSession::ListExtendedInterfacesL(KNullUid,ifInfo));
1.1079 + TEST_OOM_ERR;
1.1080 + test(err == KErrNotFound);
1.1081 + ifInfo.Reset();
1.1082 +
1.1083 + // Test fetch of extended interfaces for an implementation that has one extended interface
1.1084 + REComSession::ListExtendedInterfacesL(KExample10ImplementationUid3,ifInfo);
1.1085 + test(ifInfo.Count() == 1);
1.1086 + ifInfo.Reset();
1.1087 +
1.1088 + // Test fetch of extended interfaces for an implementation with PLUGIN1 IIC that has no extended interfaces
1.1089 + REComSession::ListExtendedInterfacesL(KImpUidPLUGIN1,ifInfo);
1.1090 + test(ifInfo.Count() == 0);
1.1091 + ifInfo.Reset();
1.1092 +
1.1093 + // Close array, finished with it.
1.1094 + CleanupStack::PopAndDestroy(&ifInfo);
1.1095 + // Test Ends...
1.1096 + }
1.1097 +
1.1098 +/**
1.1099 +@SYMTestCaseID SYSLIB-ECOM-CT-3596
1.1100 +@SYMTestCaseDesc Try to load a PLUGIN3 DLL with a version one resource file. Also try to load a PLUGIN1 DLL
1.1101 + with a version three resource file. Tests UID mismatch specified in the DLL .mmp file and
1.1102 + the resource type in the resource file.
1.1103 +@SYMTestPriority High
1.1104 +@SYMTestActions Create an implementation using the invalid plugin.
1.1105 +@SYMTestExpectedResults The plugin should not have been loaded due to a UID1 mismatch.
1.1106 +@SYMEC EC43
1.1107 +*/
1.1108 +LOCAL_C void CreateImplementationTest1()
1.1109 + {
1.1110 + // Test Starts...
1.1111 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3596 "));
1.1112 + TUid instanceKey;
1.1113 +
1.1114 + // Set up some empty initialisation parameters
1.1115 + CExampleInterface::TExampleInterfaceInitParams initParams;
1.1116 + initParams.integer = 0;
1.1117 + initParams.descriptor = NULL;
1.1118 +
1.1119 + test.Printf(_L("Loading Plugin..."));
1.1120 +
1.1121 + // Interface with NULL get and release function pointers
1.1122 + const TUid KExample12InvalidDllImplementationUid = {0x10009E39};
1.1123 +
1.1124 + TRAPD(err, TAny* dllPtr = REComSession::CreateImplementationL(KExample12InvalidDllImplementationUid,instanceKey,&initParams));
1.1125 +
1.1126 + // The plugin should not have been loaded due to a UID1 mismatch. This is specified as the resource
1.1127 + // type in the resource file and UID1 in the DLL itself.
1.1128 + test(err==KErrNotFound);
1.1129 +
1.1130 + // Load a PLUGIN1 DLL with a version three resource file
1.1131 + const TUid KExample14InvalidDllImplementationUid = {0x10009E48};
1.1132 +
1.1133 + TRAP(err, TAny* dllPtr = REComSession::CreateImplementationL(KExample14InvalidDllImplementationUid,instanceKey,&initParams));
1.1134 +
1.1135 + // The plugin should not have been loaded due to a UID1 mismatch. This is specified as the resource
1.1136 + // type in the resource file and UID1 in the DLL itself.
1.1137 + test(err==KErrNotFound);
1.1138 + // Test Ends...
1.1139 + }
1.1140 +
1.1141 +/**
1.1142 +@SYMTestCaseID SYSLIB-ECOM-CT-3585
1.1143 +@SYMTestCaseDesc Get and release extended interfaces in cases in which both get and release function pointers
1.1144 + do not exist. The tests will be:
1.1145 + 1) Get/release function pointers are NULL
1.1146 + 2) Only get function, no release function
1.1147 + 3) Test with a PLUGIN1 DLL (get/release function pointers should be NULL)
1.1148 +@SYMTestPriority High
1.1149 +@SYMTestActions Create an implementation.
1.1150 + Try getting and releasing interfaces even though no get and release function pointers exist
1.1151 + Test with get extended interface function pointer and no release function pointer
1.1152 +@SYMTestExpectedResults NULL should be returned if get and release function pointers do not exist
1.1153 + Releasing an interface that has no release function pointer should finish with
1.1154 + no errors.
1.1155 +@SYMEC EC43
1.1156 +*/
1.1157 +LOCAL_C void ReleaseExtendedInterfaceTest1L()
1.1158 + {
1.1159 + // Test Starts...
1.1160 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3585 "));
1.1161 + test.Printf(_L("Loading Plugin..."));
1.1162 + // Interface with NULL get and release function pointers
1.1163 + const TUid KExample10ImplementationUid = {0x10009E3A};
1.1164 +
1.1165 + CExampleInterface* dllPtr = CExampleInterface::NewL2(KExample10ImplementationUid);
1.1166 + CleanupStack::PushL(dllPtr);
1.1167 +
1.1168 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
1.1169 + test(KExample10ImplementationUid == dllPtr->ImplId());
1.1170 +
1.1171 + // Call extended interface here.
1.1172 + const TUid KExample10InterfaceUid1 = {0x10009E44};
1.1173 + const TUid KExample10InterfaceUid2 = {0x10009E45};
1.1174 +
1.1175 + // Try getting and releasing interfaces even though no get and release function pointers exist
1.1176 + MExampleInterfaceExtended* ext1 = static_cast<MExampleInterfaceExtended*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid1));
1.1177 + test(ext1 == NULL);
1.1178 +
1.1179 + MExampleInterfaceExtended2* ext2 = static_cast<MExampleInterfaceExtended2*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid2));
1.1180 + test(ext2 == NULL);
1.1181 +
1.1182 + dllPtr->ManuallyReleaseExtendedInterfaceL(KExample10InterfaceUid2);
1.1183 +
1.1184 + test.Printf(_L("Destroying Plugin 1..."));
1.1185 + CleanupStack::Pop(dllPtr);
1.1186 + delete dllPtr;
1.1187 +
1.1188 + // Test with get extended interface function pointer and no release function pointer
1.1189 + const TUid KExample10ImplementationUidNoRelease = {0x10009E3B};
1.1190 +
1.1191 + dllPtr = CExampleInterface::NewL2(KExample10ImplementationUidNoRelease);
1.1192 + CleanupStack::PushL(dllPtr);
1.1193 +
1.1194 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUidNoRelease);
1.1195 + test(KExample10ImplementationUidNoRelease == dllPtr->ImplId());
1.1196 +
1.1197 + // Try releasing interfaces even though no release function pointer exists
1.1198 + MExampleInterfaceExtended* ext = static_cast<MExampleInterfaceExtended*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid1));
1.1199 + ext->DoMethodExtended();
1.1200 +
1.1201 + // This should do nothing
1.1202 + dllPtr->ManuallyReleaseExtendedInterfaceL(KExample10InterfaceUid1);
1.1203 +
1.1204 + test.Printf(_L("Destroying Plugin 2..."));
1.1205 + CleanupStack::Pop(dllPtr);
1.1206 + delete dllPtr;
1.1207 +
1.1208 + // PLUGIN1 test. Try getting and releasing interfaces even though no get and release function pointers exist.
1.1209 + dllPtr = CExampleInterface::NewL2(KCExampleImplUid);
1.1210 + CleanupStack::PushL(dllPtr);
1.1211 +
1.1212 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KCExampleImplUid);
1.1213 + test(KCExampleImplUid == dllPtr->ImplId());
1.1214 +
1.1215 + // Call extended interface here.
1.1216 + // Try getting and releasing interfaces even though no get and release function pointers exist
1.1217 + MExampleInterfaceExtended* ext3 = static_cast<MExampleInterfaceExtended*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid1));
1.1218 + test(ext3 == NULL);
1.1219 +
1.1220 + // Nothing should happen when releasing an extended interface for a PLUGIN1 DLL
1.1221 + dllPtr->ManuallyReleaseExtendedInterfaceL(KExample10InterfaceUid1);
1.1222 +
1.1223 + test.Printf(_L("Destroying Plugin 3..."));
1.1224 + CleanupStack::Pop(dllPtr);
1.1225 + delete dllPtr;
1.1226 + // Test Ends...
1.1227 + }
1.1228 +
1.1229 +/**
1.1230 +@SYMTestCaseID SYSLIB-ECOM-CT-4002
1.1231 +@SYMTestCaseDesc Tests ManuallyReleaseExtendedInterfaceL with invalid instance keys
1.1232 +@SYMTestPriority High
1.1233 +@SYMTestActions Manually release extended interface using unknown instance key
1.1234 + Manually release extended interface using null instance key
1.1235 +@SYMTestExpectedResults Ensure that correct leaves occur.
1.1236 +@SYMDEF DEF111553
1.1237 +*/
1.1238 +LOCAL_C void ReleaseExtendedInterfaceTest2L()
1.1239 + {
1.1240 + // Test Starts...
1.1241 + // get valid instance key by creating implementation
1.1242 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-4002 "));
1.1243 + const TUid KExample10ImplementationUid = {0x10009E3A};
1.1244 + TUid instanceKey;
1.1245 + TAny* impl = REComSession::CreateImplementationL(KExample10ImplementationUid, instanceKey, 0);
1.1246 +
1.1247 + // remove implementation
1.1248 + REComSession::DestroyedImplementation(instanceKey);
1.1249 + delete impl;
1.1250 +
1.1251 + // Attempt to manually release extended interface with instance key that is no longer valid but
1.1252 + // passes the ASSERT test
1.1253 + const TUid KExample10InterfaceUid1 = {0x10009E44};
1.1254 + TRAPD(err, REComSession::ManuallyReleaseExtendedInterfaceL(instanceKey,KExample10InterfaceUid1));
1.1255 + test(err = KErrNotFound);
1.1256 +
1.1257 + // Attempt to manually release extended interface with null instance key
1.1258 + TRAP(err, REComSession::GetExtendedInterfaceL(KNullUid,KExample10InterfaceUid1));
1.1259 + test(err = KErrArgument);
1.1260 + // Test Ends...
1.1261 + }
1.1262 +
1.1263 +/**
1.1264 +@SYMTestCaseID SYSLIB-ECOM-CT-3584
1.1265 +@SYMTestCaseDesc Tests for GetExtendedInterfaceL, fetching an invalid extended interface
1.1266 +@SYMTestPriority High
1.1267 +@SYMTestActions Create an implementation. Fetch two extended interfaces (one build in, and one
1.1268 + stand alone and requires release). Fetch an invalid extended interface. Destroy implementation.
1.1269 +@SYMTestExpectedResults Ensure that the GetExtendedInterfaceL call with the invalid interface returns NULL.
1.1270 +@SYMEC EC43
1.1271 +*/
1.1272 +LOCAL_C void GetExtendedInterfaceTest3L()
1.1273 + {
1.1274 + //
1.1275 + // Testing a overloaded method for CreateImplementationL
1.1276 + // ------------------------------------------------------------------
1.1277 + //
1.1278 + // Test Starts...
1.1279 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3584 "));
1.1280 + test.Printf(_L("Loading Plugin..."));
1.1281 + const TUid KExample10ImplementationUid = {0x10009E38};
1.1282 +
1.1283 + CExampleInterface* dllPtr = CExampleInterface::NewL2(KExample10ImplementationUid);
1.1284 + CleanupStack::PushL(dllPtr);
1.1285 +
1.1286 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
1.1287 + test(KExample10ImplementationUid == dllPtr->ImplId());
1.1288 +
1.1289 + // Call extended interface here.
1.1290 + const TUid KExample10InterfaceUid1 = {0x10009E44};
1.1291 + const TUid KExample10InterfaceUid2 = {0x10009E45};
1.1292 + const TUid KExample10InvalidInterfaceUid = {0x10009E49};
1.1293 +
1.1294 + MExampleInterfaceExtended* ext1 = static_cast<MExampleInterfaceExtended*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid1));
1.1295 + ext1->DoMethodExtended();
1.1296 +
1.1297 + MExampleInterfaceExtended2* ext2 = static_cast<MExampleInterfaceExtended2*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid2));
1.1298 + ext2->DoMethodExtended2();
1.1299 +
1.1300 + // Get an invalid extended interface.
1.1301 + MExampleInterfaceExtended2* ext2invalid = static_cast<MExampleInterfaceExtended2*>(dllPtr->GetExtendedInterfaceL(KExample10InvalidInterfaceUid));
1.1302 + // No interface should be returned if it is not found.
1.1303 + test(ext2invalid == NULL);
1.1304 +
1.1305 + test.Printf(_L("Destroying Plugin..."));
1.1306 + CleanupStack::Pop(dllPtr);
1.1307 + delete dllPtr;
1.1308 +
1.1309 + // Test Ends...
1.1310 + }
1.1311 +
1.1312 +/**
1.1313 +@SYMTestCaseID SYSLIB-ECOM-CT-3583
1.1314 +@SYMTestCaseDesc Tests for GetExtendedInterfaceL, with an invalid instance key.
1.1315 +@SYMTestPriority High
1.1316 +@SYMTestActions Call REComSession::GetExtendedInterfaceL() with an invalid instance key.
1.1317 + GetExtendedInterfacePanic() and ThreadPanicTest() are used for this test case.
1.1318 +@SYMTestExpectedResults Ensure that the GetExtendedInterfaceL panics in debug mode and leaves in release
1.1319 + mode.
1.1320 +@SYMEC EC43
1.1321 +*/
1.1322 +LOCAL_C void GetExtendedInterfaceTest2L()
1.1323 + {
1.1324 + // Test Starts...
1.1325 + TUid instanceKey;
1.1326 + TBool containInvalidExtIf = EFalse;
1.1327 + TBool useDefResolver = EFalse;
1.1328 + TBool useInitParam = ETrue;
1.1329 +
1.1330 + CExampleInterface* dllPtr = CreateImplementationTestL(containInvalidExtIf,useDefResolver,useInitParam,instanceKey);
1.1331 + CleanupStack::PushL(dllPtr);
1.1332 +
1.1333 + const TUid KExtendedInterfaceUid = {0x10009E44};
1.1334 + TUid invalidInstanceKey;
1.1335 + invalidInstanceKey.iUid = instanceKey.iUid + 1;
1.1336 +
1.1337 + // Fetches an extended interface with invalid instance key.
1.1338 + // When passed an invalid instance key, REComSession::GetExtendedInterfaceL() panics
1.1339 + // with KErrArgument in debug mode, but leaves with KErrNotFound in release mode.
1.1340 + MExampleInterfaceExtended* ext1 = static_cast<MExampleInterfaceExtended*>(REComSession::GetExtendedInterfaceL(invalidInstanceKey,KExtendedInterfaceUid));
1.1341 +
1.1342 + REComSession::DestroyedImplementation(instanceKey);
1.1343 + CleanupStack::PopAndDestroy(dllPtr);
1.1344 +
1.1345 + // Test Ends...
1.1346 + }
1.1347 +
1.1348 +/**
1.1349 +A thread function.
1.1350 +Panics in debug mode.
1.1351 +Returns an error code in release mode.
1.1352 +*/
1.1353 +LOCAL_C TInt GetExtendedInterfacePanic(TAny*)
1.1354 + {
1.1355 + __UHEAP_MARK;
1.1356 + CTrapCleanup* threadcleanup = CTrapCleanup::New();
1.1357 +
1.1358 + // In debug mode, GetExtendedInterfaceTest2L panics with reason KErrArgument.
1.1359 + // In release mode, it leaves with KErrNotFound.
1.1360 + TRAPD(err, GetExtendedInterfaceTest2L());
1.1361 +
1.1362 + delete threadcleanup;
1.1363 + __UHEAP_MARKEND;
1.1364 +
1.1365 + return err;
1.1366 + }
1.1367 +
1.1368 +/**
1.1369 +The test code is used for capturing the PANIC that occurs as a result of calling GetExtendedInterfaceL
1.1370 +with an invalid instance key.
1.1371 +*/
1.1372 +LOCAL_C void ThreadPanicTest(const TDesC& aName,TThreadFunction aFunction)
1.1373 + {
1.1374 + test.Next(aName);
1.1375 + TRequestStatus threadStatus;
1.1376 + RThread thread;
1.1377 + TBool jit;
1.1378 + jit=User::JustInTime();
1.1379 + User::SetJustInTime(EFalse);
1.1380 +
1.1381 + TInt err=thread.Create(aName,aFunction,KDefaultStackSize*8,KMinHeapSize,0x100000,0);
1.1382 + test(err==KErrNone);
1.1383 + thread.Logon(threadStatus) ;
1.1384 + thread.Resume();
1.1385 +
1.1386 + User::WaitForRequest(threadStatus);
1.1387 +
1.1388 + // Different verifications for debug and release mode.
1.1389 +#ifdef _DEBUG
1.1390 + test(thread.ExitType()==EExitPanic);
1.1391 + test(thread.ExitReason()==EEComPanic_InvalidImplementationInstanceKey);
1.1392 +#else
1.1393 + test(thread.ExitType()==EExitKill);
1.1394 + test(thread.ExitReason()==KErrNotFound);
1.1395 +#endif
1.1396 +
1.1397 + thread.Close();
1.1398 + User::SetJustInTime(jit);
1.1399 + }
1.1400 +
1.1401 +/**
1.1402 +@SYMTestCaseID SYSLIB-ECOM-CT-3582
1.1403 +@SYMTestCaseDesc Tests for GetExtendedInterfaceL, stand alone and built in extended interfaces with
1.1404 + valid instance keys.
1.1405 +@SYMTestPriority High
1.1406 +@SYMTestActions Create an implementation. Fetch two extended interfaces (one build in, and one
1.1407 + stand alone and requires release). Call extended interfaces. Destroy implementation.
1.1408 + Re-create the same implementation again. Fetch extended interface. Destroy implementation.
1.1409 + Re-create again. Fetch two extended interfaces (both being stand alone and
1.1410 + require release).
1.1411 +@SYMTestExpectedResults Ensure that Extended interfaces can be created, called and cleaned up when
1.1412 + implementation is destroyed.
1.1413 +@SYMEC EC43
1.1414 +*/
1.1415 +LOCAL_C void GetExtendedInterfaceTest1L()
1.1416 + {
1.1417 + // Test Starts...
1.1418 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3582 "));
1.1419 + test.Printf(_L("Loading Plugin..."));
1.1420 + const TUid KExample10ImplementationUid = {0x10009E38};
1.1421 +
1.1422 + CExampleInterface* dllPtr = CExampleInterface::NewL2(KExample10ImplementationUid);
1.1423 + CleanupStack::PushL(dllPtr);
1.1424 +
1.1425 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
1.1426 + test(KExample10ImplementationUid == dllPtr->ImplId());
1.1427 +
1.1428 + // Calls extended interface here.
1.1429 + const TUid KExample10InterfaceUid1 = {0x10009E44};
1.1430 + const TUid KExample10InterfaceUid2 = {0x10009E45};
1.1431 +
1.1432 + // Fetches an extended interface.
1.1433 + MExampleInterfaceExtended* ext1 = static_cast<MExampleInterfaceExtended*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid1));
1.1434 + // Sanity check by calling extended interface.
1.1435 + ext1->DoMethodExtended();
1.1436 +
1.1437 + // Fetches an extended interface. Stand alone interface.
1.1438 + MExampleInterfaceExtended2* ext2 = static_cast<MExampleInterfaceExtended2*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid2));
1.1439 + // Sanity check by calling extended interface.
1.1440 + ext2->DoMethodExtended2();
1.1441 +
1.1442 + // Delete implementation, this will automatically destroy the stand alone interface.
1.1443 + test.Printf(_L("Destroying Plugin..."));
1.1444 + CleanupStack::Pop(dllPtr);
1.1445 + delete dllPtr;
1.1446 +
1.1447 + // Test to ensure that a new interface can be re-created immediately after deletion. This
1.1448 + // also tests that no problems occur when no extended interfaces require releasing yet
1.1449 + // a release function exists in the plug-in implementation.
1.1450 + dllPtr = CExampleInterface::NewL2(KExample10ImplementationUid);
1.1451 + CleanupStack::PushL(dllPtr);
1.1452 +
1.1453 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
1.1454 + test(KExample10ImplementationUid == dllPtr->ImplId());
1.1455 +
1.1456 + // Ensure that the extended interface can also be fetched again
1.1457 + MExampleInterfaceExtended* ext = static_cast<MExampleInterfaceExtended*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid1));
1.1458 + ext->DoMethodExtended();
1.1459 +
1.1460 + test.Printf(_L("Destroying Plugin..."));
1.1461 + CleanupStack::Pop(dllPtr);
1.1462 + delete dllPtr;
1.1463 +
1.1464 + // Re-creates implementation. This time create two extended interfaces that require release
1.1465 + dllPtr = CExampleInterface::NewL2(KExample10ImplementationUid);
1.1466 + CleanupStack::PushL(dllPtr);
1.1467 +
1.1468 + test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
1.1469 + test(KExample10ImplementationUid == dllPtr->ImplId());
1.1470 +
1.1471 + MExampleInterfaceExtended2* extension1 = static_cast<MExampleInterfaceExtended2*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid2));
1.1472 + extension1->DoMethodExtended2();
1.1473 +
1.1474 + const TUid KExample10InterfaceUid3 = {0x10009E46};
1.1475 +
1.1476 + MExampleInterfaceExtended2* extension2 = static_cast<MExampleInterfaceExtended2*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid3));
1.1477 + extension2->DoMethodExtended2();
1.1478 +
1.1479 + // Destroy the implementation. This should automatically delete both extended interfaces above
1.1480 + test.Printf(_L("Destroying Plugin..."));
1.1481 + CleanupStack::Pop(dllPtr);
1.1482 + delete dllPtr;
1.1483 + // Test Ends...
1.1484 + }
1.1485 +
1.1486 +
1.1487 +typedef void (*ClassFuncPtrL) (void);
1.1488 +
1.1489 +/**
1.1490 +Wrapper function to call all test functions
1.1491 +@param testFuncL pointer to test function
1.1492 +@param aTestDesc test function name
1.1493 +*/
1.1494 +LOCAL_C void DoBasicTest(ClassFuncPtrL testFuncL, const TDesC& aTestDesc)
1.1495 + {
1.1496 + test.Next(aTestDesc);
1.1497 +
1.1498 + __UHEAP_MARK;
1.1499 + // find out the number of open handles
1.1500 + TInt pHCountStart;
1.1501 + TInt tHCountStart;
1.1502 + RThread().HandleCount(pHCountStart,tHCountStart);
1.1503 +
1.1504 + TRAPD(err, (*testFuncL)());
1.1505 + test(KErrNone == err);
1.1506 +
1.1507 + // release handles
1.1508 + REComSession::FinalClose();
1.1509 +
1.1510 + // check that no handles have leaked
1.1511 + TInt pHCountEnd;
1.1512 + TInt tHCountEnd;
1.1513 + RThread().HandleCount(pHCountEnd,tHCountEnd);
1.1514 +
1.1515 + test(pHCountStart == pHCountEnd);
1.1516 + test(tHCountStart == tHCountEnd);
1.1517 + test.Printf(_L("Great ! No handle mismatch."));
1.1518 +
1.1519 + __UHEAP_MARKEND;
1.1520 + }
1.1521 +
1.1522 +/**
1.1523 +Wrapper function to call all OOM test functions
1.1524 +@param testFuncL pointer to OOM test function
1.1525 +@param aTestDesc test function name
1.1526 +*/
1.1527 +LOCAL_C void DoOOMTest(ClassFuncPtrL testFuncL, const TDesC& aTestDesc)
1.1528 + {
1.1529 + test.Next(aTestDesc);
1.1530 + TInt err;
1.1531 + TInt failAt = 1;
1.1532 +
1.1533 + do
1.1534 + {
1.1535 + __UHEAP_MARK;
1.1536 + // find out the number of open handles
1.1537 + TInt pHCountStart;
1.1538 + TInt tHCountStart;
1.1539 + RThread().HandleCount(pHCountStart,tHCountStart);
1.1540 +
1.1541 + // Setting Heap failure for OOM test
1.1542 + __UHEAP_SETFAIL(RHeap::EDeterministic, failAt++);
1.1543 +
1.1544 + TRAP(err, (*testFuncL)());
1.1545 +
1.1546 + __UHEAP_SETFAIL(RHeap::ENone, 0);
1.1547 +
1.1548 + // release handles
1.1549 + REComSession::FinalClose();
1.1550 +
1.1551 + // check that no handles have leaked
1.1552 + TInt pHCountEnd;
1.1553 + TInt tHCountEnd;
1.1554 + RThread().HandleCount(pHCountEnd,tHCountEnd);
1.1555 +
1.1556 + test(pHCountStart == pHCountEnd);
1.1557 + test(tHCountStart == tHCountEnd);
1.1558 + test.Printf(_L("Great ! No handle mismatch."));
1.1559 +
1.1560 + __UHEAP_MARKEND;
1.1561 + } while(err == KErrNoMemory);
1.1562 +
1.1563 + test(err == KErrNone);
1.1564 + test.Printf(_L("- server succeeded at heap failure rate of %i\n"), failAt);
1.1565 + }
1.1566 +
1.1567 +
1.1568 +void DoTests()
1.1569 + {
1.1570 + //Basic test...
1.1571 + test.Printf(_L("Basic tests...\n"));
1.1572 +
1.1573 + DoBasicTest(&GetExtendedInterfaceTest1L,_L("GetExtendedInterfaceTest1L"));
1.1574 + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3583 "));
1.1575 + ThreadPanicTest(_L("GetExtendedInterface Panic Testing"),GetExtendedInterfacePanic);
1.1576 + DoBasicTest(&GetExtendedInterfaceTest3L,_L("GetExtendedInterfaceTest3L"));
1.1577 + DoBasicTest(&GetExtendedInterfaceTest4L,_L("GetExtendedInterfaceTest4L"));
1.1578 + DoBasicTest(&GetExtendedInterfaceTest5L,_L("GetExtendedInterfaceTest5L"));
1.1579 + DoBasicTest(&ReleaseExtendedInterfaceTest1L,_L("ReleaseExtendedInterfaceTest1L"));
1.1580 + DoBasicTest(&ReleaseExtendedInterfaceTest2L,_L("ReleaseExtendedInterfaceTest2L"));
1.1581 + DoBasicTest(&ListExtendedInterfaceTestL,_L("ListExtendedInterfaceTestL"));
1.1582 +
1.1583 + DoBasicTest(&CreateImplementationTest1,_L("CreateImplementationTest1"));
1.1584 + DoBasicTest(&CreateImplementationTest2L,_L("CreateImplementationTest2L"));
1.1585 + DoBasicTest(&CreateImplementationTest3L,_L("CreateImplementationTest3L"));
1.1586 + DoBasicTest(&CreateImplementationTest4L,_L("CreateImplementationTest4L"));
1.1587 + DoBasicTest(&CreateImplementationTest5L,_L("CreateImplementationTest5L"));
1.1588 + DoBasicTest(&CreateImplementationTest6,_L("CreateImplementationTest6"));
1.1589 + DoBasicTest(&CreateImplementationTest7L,_L("CreateImplementationTest7L"));
1.1590 + DoBasicTest(&DestroyedImplementationTestL,_L("DestroyedImplementationTestL"));
1.1591 +
1.1592 + DoBasicTest(&ListImplementationTest1L,_L("ListImplementationTest1L"));
1.1593 + DoBasicTest(&ListImplementationTest2L,_L("ListImplementationTest2L"));
1.1594 + DoBasicTest(&ListImplementationTest3L,_L("ListImplementationTest3L"));
1.1595 + DoBasicTest(&ListImplementationTest4L,_L("ListImplementationTest4L"));
1.1596 + DoBasicTest(&ListImplementationTest5L,_L("ListImplementationTest5L"));
1.1597 +
1.1598 + DoBasicTest(&DummyUidTestL,_L("CreateImplementation and ListImplementation Dummy UID test"));
1.1599 +
1.1600 + // OOM test...
1.1601 + test.Printf(_L("OOM tests...\n"));
1.1602 +
1.1603 + DoOOMTest(&GetExtendedInterfaceTest1L,_L("OOM GetExtendedInterfaceTest1L"));
1.1604 + // GetExtendedInterfaceTest2L is a special test case, cannot do OOM testing.
1.1605 + DoOOMTest(&GetExtendedInterfaceTest3L,_L("OOM GetExtendedInterfaceTest3L"));
1.1606 + DoOOMTest(&GetExtendedInterfaceTest4L,_L("OOM GetExtendedInterfaceTest4L"));
1.1607 + DoOOMTest(&GetExtendedInterfaceTest5L,_L("OOM GetExtendedInterfaceTest5L"));
1.1608 + DoOOMTest(&ReleaseExtendedInterfaceTest1L,_L("OOM ReleaseExtendedInterfaceTest1L"));
1.1609 + DoOOMTest(&ReleaseExtendedInterfaceTest2L,_L("OOM ReleaseExtendedInterfaceTest2L"));
1.1610 + DoOOMTest(&ListExtendedInterfaceTestL,_L("OOM ListExtendedInterfaceTestL"));
1.1611 +
1.1612 + // CreateImplementationTest1 is a special test case, cannot do OOM testing.
1.1613 + DoOOMTest(&CreateImplementationTest2L,_L("OOM CreateImplementationTest2L"));
1.1614 + DoOOMTest(&CreateImplementationTest3L,_L("OOM CreateImplementationTest3L"));
1.1615 + DoOOMTest(&CreateImplementationTest4L,_L("OOM CreateImplementationTest4L"));
1.1616 + DoOOMTest(&CreateImplementationTest5L,_L("OOM CreateImplementationTest5L"));
1.1617 + // CreateImplementationTest6 is a special test case, cannot do OOM testing.
1.1618 + DoOOMTest(&CreateImplementationTest7L,_L("OOM CreateImplementationTest7L"));
1.1619 + DoOOMTest(&DestroyedImplementationTestL,_L("OOM DestroyedImplementationTestL"));
1.1620 +
1.1621 + DoOOMTest(&ListImplementationTest1L,_L("OOM ListImplementationTest1L"));
1.1622 + DoOOMTest(&ListImplementationTest2L,_L("OOM ListImplementationTest2L"));
1.1623 + DoOOMTest(&ListImplementationTest3L,_L("OOM ListImplementationTest3L"));
1.1624 + DoOOMTest(&ListImplementationTest4L,_L("OOM ListImplementationTest4L"));
1.1625 + DoOOMTest(&ListImplementationTest5L,_L("OOM ListImplementationTest5L"));
1.1626 + }
1.1627 +
1.1628 +
1.1629 +GLDEF_C TInt E32Main()
1.1630 + {
1.1631 + __UHEAP_MARK;
1.1632 + test.Title();
1.1633 +
1.1634 + test.Start(_L("ExtendedInterfaces tests."));
1.1635 +
1.1636 + // get clean-up stack
1.1637 + CTrapCleanup* cleanup = CTrapCleanup::New();
1.1638 +
1.1639 + //The reason for the folowing delay is:
1.1640 + //ECOM server could be already started. It means that when we copy some
1.1641 + //ECOM plugins from Z: to C: drive - ECOM server should look for and
1.1642 + //find the new ECOM plugins. The ECOM server uses for that CDiscoverer::CIdleScanningTimer
1.1643 + //which is an active object. So the discovering service is asynchronous. We have to
1.1644 + //wait some time until it finishes. Otherwise ListImplementationsL could fail to find
1.1645 + //requested implementations.
1.1646 + User::After(KOneSecond * 5);
1.1647 +
1.1648 + DoTests();
1.1649 +
1.1650 + delete cleanup;
1.1651 +
1.1652 + test.End();
1.1653 + test.Close();
1.1654 + __UHEAP_MARKEND;
1.1655 + return(0);
1.1656 + }