--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/lowlevellibsandfws/pluginfw/Framework/ExtendedInterfacesTest/t_extendedinterfaces.cpp Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,1653 @@
+// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include <e32test.h>
+#include <f32file.h>
+#include <bautils.h>
+#include <ecom/ecom.h>
+#include <ecom/ecompanics.h>
+#include "EComUidCodes.h"
+#include "Interface.h" // interface to Plugins
+#include "../EcomTestUtils/EcomTestUtils.h"
+
+//The tests test all the new APIs added to REComSession created for EC43
+
+TUid KCExampleImplUid = {0x10009DC3};
+
+const TInt KOneSecond = 1000000;
+
+LOCAL_D RTest test(_L("t_extendedinterfaces"));
+LOCAL_D RFs TheFs;
+
+#define __UNUSED_VAR(var) var = var
+
+// Used for OOM test
+#define TEST_OOM_ERR if(err == KErrNoMemory) {User::Leave(err);}
+
+
+static void ResetAndDestroyArray(TAny* aPtr)
+ {
+ (static_cast<RImplInfoPtrArray*>(aPtr))->ResetAndDestroy();
+ }
+
+
+/**
+Test function for REcomSession::ListImplementationL
+
+@param aContainInvalidExtIf The bool value identifying if the extended interfaces list contains
+ invalid extended interface Uid
+@param aUseDefResolver The bool value identifying if default resolver is used.
+@param aUseResolveParam The bool value identifying if resolve parameter is used.
+@param aNumEntriesInExtIFList The number of entries in the extended interfaces list.
+@param aImplInfoArray A reference to a client owned array which will be filled
+ with interface implementation data.
+*/
+LOCAL_C void ListImplementationTestL(TBool aContainInvalidExtIf,
+ TBool aUseDefResolver,
+ TBool aUseResolveParam,
+ TInt aNumEntriesInExtIFList,
+ RImplInfoPtrArray& aImplInfoArray)
+ {
+ const TUid KInterfaceUid = {0x10009DBB};
+ const TUid KExtendedInterfaceUid1 = {0x10009E44};
+ const TUid KExtendedInterfaceUid2 = {0x10009E45};
+ const TUid KExtendedInterfaceUid3 = {0x10009E46};
+ const TUid KInvalidExtendedInterfaceUid2 = {0x10009E49};
+ _LIT8(KExample10ImplementationTest,"Example 10");
+
+ TUid resolverUid = {0x10009DD0};
+
+ // Set up extended interfaces
+ RArray<TUid> extendedInterfaces;
+ CleanupClosePushL(extendedInterfaces);
+
+ if (!aContainInvalidExtIf)
+ {
+ if (aNumEntriesInExtIFList==1)
+ {
+ extendedInterfaces.AppendL(KExtendedInterfaceUid1);
+ }
+ else if (aNumEntriesInExtIFList>1)
+ {
+ extendedInterfaces.AppendL(KExtendedInterfaceUid2);
+ extendedInterfaces.AppendL(KExtendedInterfaceUid3);
+ }
+ }
+ else
+ {
+ extendedInterfaces.AppendL(KExtendedInterfaceUid1);
+ extendedInterfaces.AppendL(KInvalidExtendedInterfaceUid2);
+ }
+
+ //Set up resolve parameter
+ TEComResolverParams ResolverParams;
+ if (aUseResolveParam)
+ {
+ ResolverParams.SetDataType(KExample10ImplementationTest());
+ ResolverParams.SetGenericMatch(ETrue); // Allow wildcard matching
+ if (aUseDefResolver) //ListImplementationTest2L,ListImplementationTest4L
+ {
+ REComSession::ListImplementationsL(KInterfaceUid,extendedInterfaces,ResolverParams,aImplInfoArray);
+ }
+ else //ListImplementationTest3L
+ {
+ REComSession::ListImplementationsL(KInterfaceUid,extendedInterfaces,ResolverParams,resolverUid,aImplInfoArray);
+ }
+
+ }
+ else //ListImplementationTest1L, ListImplementationTest5L
+ {
+ REComSession::ListImplementationsL(KInterfaceUid,extendedInterfaces,aImplInfoArray);
+ }
+ CleanupStack::PopAndDestroy(&extendedInterfaces);
+ }
+
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3597
+@SYMTestCaseDesc Tests for CImplementationInformation structure.
+@SYMTestPriority High
+@SYMTestActions Call ListImplementationL method to get a list of implementations with extended interfaces.
+ Check that the expected extended interfaces are available in the CImplementationInformation
+ data structure via GetExtendedInterfaceList method.
+@SYMTestExpectedResults Extended interfaces are available in implementation information structure.
+@SYMEC EC43
+*/
+LOCAL_C void ListImplementationTest5L()
+ {
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3597 "));
+ // Test Starts...
+ RImplInfoPtrArray ifArray;
+ TBool containInvalidExtIf = EFalse;
+ TBool useDefResolver = ETrue;
+ TBool useResolveParam = EFalse;
+ TInt numEntriesOnExtIFList = 3;
+
+ ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
+
+ //Checks the result
+ //0x10009E38 is implemented in EcomExample10.dll
+ TUid KExample10ImplUid = {0x10009E38};
+ TUid KExtendedInterfaceUid1 = {0x10009E44};
+ TUid KExtendedInterfaceUid2 = {0x10009E45};
+ TUid KExtendedInterfaceUid3 = {0x10009E46};
+ const TInt availCount = ifArray.Count();
+ test.Printf(_L("Found %d implementations.\n"),availCount);
+ test(availCount == 1);
+
+ //tests extended interfaces
+ CImplementationInformation* info = ifArray[0];
+ test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
+ test (KExample10ImplUid==info->ImplementationUid());
+
+ CleanupStack::PushL(TCleanupItem(ResetAndDestroyArray, &ifArray));
+
+ // Gets extended interfaces list
+ RArray<TUid> extInf;
+ CleanupClosePushL(extInf);
+ info->GetExtendedInterfaceListL(extInf);
+ test(extInf[0] == KExtendedInterfaceUid1);
+ test(extInf[1] == KExtendedInterfaceUid2);
+ test(extInf[2] == KExtendedInterfaceUid3);
+ CleanupStack::PopAndDestroy(&extInf);
+
+ // Empty the array of implementations
+ test.Printf(_L("Destroying List..."));
+ CleanupStack::PopAndDestroy(&ifArray);
+ }
+
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3594
+@SYMTestCaseDesc Tests for REComSession::ListImplementationL created with an Interface Uid
+ and invalid extended Interfaces.
+@SYMTestPriority High
+@SYMTestActions Call ListImplementationL method supporting interface UID and extended interfaces
+ that are invalid.
+@SYMTestExpectedResults No implementation is returned.
+@SYMEC EC43
+*/
+LOCAL_C void ListImplementationTest4L()
+ {
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3594 "));
+ // Test Starts...
+ RImplInfoPtrArray ifArray;
+ TBool containInvalidExtIf = ETrue;
+ TBool useDefResolver = ETrue;
+ TBool useResolveParam = ETrue;
+ TInt numEntriesOnExtIFList = 2;
+
+ ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
+
+ //Checks the result
+ const TInt availCount = ifArray.Count();
+ test.Printf(_L("Found %d implementations.\n"),availCount);
+ test(availCount == 0);
+
+ // Empty the array of implementations
+ test.Printf(_L("Destroying List..."));
+ ifArray.ResetAndDestroy();
+ }
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3589
+@SYMTestCaseDesc Tests for REComSession::ListImplementationsL for known Interface UID,
+ resolver match characteristics, resolver UID and extended interfaces.
+@SYMTestPriority High
+@SYMTestActions Call ListImplementationL method supporting interface UID, resolver parameters
+ resolver UID and extended interfaces.
+@SYMTestExpectedResults Expected implementations are returned.
+@SYMEC EC43
+*/
+LOCAL_C void ListImplementationTest3L()
+ {
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3589 "));
+ // Test Starts...
+ RImplInfoPtrArray ifArray;
+ TBool containInvalidExtIf = EFalse;
+ TBool useDefResolver = EFalse;
+ TBool useResolveParam = ETrue;
+
+ //Number of entries in extended interfaces is 3.
+ TInt numEntriesOnExtIFList = 3;
+ ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
+
+ //Checks the result
+ TUid KImplementationUid = {0x10009E38};
+ TInt availCount = ifArray.Count();
+ test.Printf(_L("Found %d implementations.\n"),availCount);
+ test(availCount == 1);
+
+ //tests implementation uid
+ for (TInt count = 0; count < availCount; ++count)
+ {
+ const CImplementationInformation* info = ifArray[count];
+ test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
+ test(KImplementationUid == info->ImplementationUid());
+ }
+
+ // Empty the array of implementations
+ test.Printf(_L("Destroying List..."));
+ ifArray.ResetAndDestroy();
+
+ //Number of entries in extended interfaces is 0.
+ numEntriesOnExtIFList = 0;
+ ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
+
+ //Checks the result
+ availCount = ifArray.Count();
+ test.Printf(_L("Found %d implementations.\n"),availCount);
+ test(availCount == 1);
+
+ //tests implementation uid
+ for (TInt count = 0; count < availCount; ++count)
+ {
+ const CImplementationInformation* info = ifArray[count];
+ test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
+ }
+
+ // Empty the array of implementations
+ test.Printf(_L("Destroying List..."));
+ ifArray.ResetAndDestroy();
+
+ //Number of entries in extended interfaces is 1.
+ numEntriesOnExtIFList = 1;
+ ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
+
+ //Checks the result
+ availCount = ifArray.Count();
+ test.Printf(_L("Found %d implementations.\n"),availCount);
+ test(availCount == 1);
+
+ //tests implementation uid
+ for (TInt count = 0; count < availCount; ++count)
+ {
+ const CImplementationInformation* info = ifArray[count];
+ test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
+ }
+
+ // Empty the array of implementations
+ test.Printf(_L("Destroying List..."));
+ ifArray.ResetAndDestroy();
+ }
+
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3588
+@SYMTestCaseDesc Tests for REComSession::ListImplementationsL for known Interface UID,
+ resolver match characteristics and extended interfaces.
+@SYMTestPriority High
+@SYMTestActions Call ListImplementationL method supporting interface UID, resolver parameters and extended interfaces.
+@SYMTestExpectedResults Expected implementations are returned.
+@SYMEC EC43
+*/
+LOCAL_C void ListImplementationTest2L()
+ {
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3588 "));
+ // Test Starts...
+ RImplInfoPtrArray ifArray;
+ TBool containInvalidExtIf = EFalse;
+ TBool useDefResolver = ETrue;
+ TBool useResolveParam = ETrue;
+
+ //Number of entries in extended interfaces is 3.
+ TInt numEntriesOnExtIFList = 3;
+ ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
+
+ //Checks the result
+ TUid KImplementationUid = {0x10009E38};
+ TInt availCount = ifArray.Count();
+ test.Printf(_L("Found %d implementations.\n"),availCount);
+ test(availCount == 1);
+
+ //tests implementation uid
+ for (TInt count = 0; count < availCount; ++count)
+ {
+ const CImplementationInformation* info = ifArray[count];
+ test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
+ test(KImplementationUid==info->ImplementationUid());
+ }
+
+ // Empty the array of implementations
+ test.Printf(_L("Destroying List..."));
+ ifArray.ResetAndDestroy();
+
+ //Number of entries in extended interfaces is 0.
+ numEntriesOnExtIFList = 0;
+ ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
+
+ //Checks the result
+ availCount = ifArray.Count();
+ test.Printf(_L("Found %d implementations.\n"),availCount);
+ test(availCount == 1);
+
+ //tests implementation uid
+ for (TInt count = 0; count < availCount; ++count)
+ {
+ const CImplementationInformation* info = ifArray[count];
+ test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
+ }
+
+ // Empty the array of implementations
+ test.Printf(_L("Destroying List..."));
+ ifArray.ResetAndDestroy();
+
+ //Number of entries in extended interfaces is 1.
+ numEntriesOnExtIFList = 1;
+ ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
+
+ //Checks the result
+ availCount = ifArray.Count();
+ test.Printf(_L("Found %d implementations.\n"),availCount);
+ test(availCount == 1);
+
+ //tests implementation uid
+ for (TInt count = 0; count < availCount; ++count)
+ {
+ const CImplementationInformation* info = ifArray[count];
+ test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
+ }
+
+ // Empty the array of implementations
+ test.Printf(_L("Destroying List..."));
+ ifArray.ResetAndDestroy();
+ }
+
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3587
+@SYMTestCaseDesc Tests for REComSession::ListImplementationsL for known Interface UID and extended interfaces.
+@SYMTestPriority High
+@SYMTestActions Call ListImplementationL method supporting interface UID and extended interfaces.
+@SYMTestExpectedResults Expected implementations are returned.
+@SYMEC EC43
+*/
+LOCAL_C void ListImplementationTest1L()
+ {
+ //
+ // Testing a overloaded method for ListImplementationsL
+ // ------------------------------------------------------------------
+ //
+ // Test Starts...
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3587 "));
+ RImplInfoPtrArray ifArray;
+
+ TBool containInvalidExtIf = EFalse;
+ TBool useDefResolver = ETrue;
+ TBool useResolveParam = EFalse;
+
+ //Number of entries in extended interfaces is 3.
+ TInt numEntriesOnExtIFList = 3;
+ ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
+
+ //Checks the result
+ //0x10009E38 is implemented in EcomExample10.dll
+ TUid KExample10ImplUid = {0x10009E38};
+ TInt availCount = ifArray.Count();
+ test.Printf(_L("Found %d implementations.\n"),availCount);
+ test(availCount == 1);
+
+ //tests implementation uid
+ const CImplementationInformation* info = ifArray[0];
+ test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
+ test(KExample10ImplUid == info->ImplementationUid());
+
+ // Empty the array of implementations
+ test.Printf(_L("Destroying List..."));
+ ifArray.ResetAndDestroy();
+
+ //Number of entries in extended interfaces is 0.
+ numEntriesOnExtIFList = 0;
+ ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
+
+ //Checks the result
+ availCount = ifArray.Count();
+ test.Printf(_L("Found %d implementations.\n"),availCount);
+ test(availCount == 3);
+
+ //tests implementation uid
+ for (TInt count = 0;count < availCount; ++count)
+ {
+ const CImplementationInformation* info = ifArray[count];
+ test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
+ }
+
+ // Empty the array of implementations
+ test.Printf(_L("Destroying List..."));
+ ifArray.ResetAndDestroy();
+
+ //Number of entries in extended interfaces is 1.
+ numEntriesOnExtIFList = 1;
+ ListImplementationTestL(containInvalidExtIf,useDefResolver,useResolveParam,numEntriesOnExtIFList,ifArray);
+
+ //Checks the result
+ availCount = ifArray.Count();
+ test.Printf(_L("Found %d implementations.\n"),availCount);
+ test(availCount == 2);
+
+ //tests implementation uid
+ for (TInt count = 0; count < availCount; ++count)
+ {
+ const CImplementationInformation* info = ifArray[count];
+ test.Printf(_L("Implementation Uid-%x. %s\n"),info->ImplementationUid(),((info->DisplayName()).Ptr()));
+ }
+
+ // Empty the array of implementations
+ test.Printf(_L("Destroying List..."));
+ ifArray.ResetAndDestroy();
+ }
+
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3713
+@SYMTestCaseDesc Tests for REComSession::CreateImplementationL and REComSession::ListImplementationL
+ with a dummy Interface Uid, dummy implementation Uid or dummy resolver Uid.
+@SYMTestPriority High
+@SYMTestActions Call CreateImplementationL method with a dummy interface UID
+ Call CreateImplementationL method with a dummy implementation UID
+ Call CreateImplementationL method with a dummy Resolver UID
+ Call ListImplementationL method with a dummy interface UID
+ Call ListImplementationL method with a dummy Resolver UID
+@SYMTestExpectedResults Leave with KErrAugument and No implementation is created.
+@SYMDEF DEF111196
+*/
+LOCAL_C void DummyUidTestL()
+ {
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3713 "));
+ TUid instanceKey;
+ TUid dummyUid;
+ dummyUid.iUid = 0;
+ const TUid KInterfaceUid = {0x10009DBB};
+ const TUid KExample10InterfaceUid = {0x10009DBB};
+ _LIT8(KExample10ImplementationTest,"Example 10");
+
+ CExampleInterface* dllPtr = NULL;
+ // Set up extended interfaces
+ RArray<TUid> extendedInterfaces;
+ CleanupClosePushL(extendedInterfaces);
+
+ //Set up resolve parameter
+ TEComResolverParams ResolverParams;
+ ResolverParams.SetDataType(KExample10ImplementationTest());
+ ResolverParams.SetGenericMatch(ETrue); // Allow wildcard matching
+
+ CExampleInterface::TExampleInterfaceInitParams initParams;
+ // Set up some empty initialisation parameters
+ initParams.integer = 0;
+ initParams.descriptor = NULL;
+
+ // CreateImplementationL with a dummy interface Uid
+ TRAPD(err,dllPtr = REINTERPRET_CAST(CExampleInterface*,
+ REComSession::CreateImplementationL(dummyUid,
+ extendedInterfaces,
+ instanceKey,
+ ResolverParams,
+ &initParams)));
+ test(err == KErrArgument);
+ test(dllPtr == NULL);
+
+ // CreateImplementationL with a dummy implementation Uid
+ TRAP(err,dllPtr = REINTERPRET_CAST(CExampleInterface*,
+ REComSession::CreateImplementationL(dummyUid,
+ instanceKey)));
+ test(err == KErrArgument);
+ test(dllPtr == NULL);
+
+ // CreateImplementationL with a dummy resolver Uid
+ TRAP(err, dllPtr = REINTERPRET_CAST(CExampleInterface*,
+ REComSession::CreateImplementationL(KExample10InterfaceUid,
+ extendedInterfaces,
+ instanceKey,
+ ResolverParams,
+ dummyUid,
+ &initParams)));
+ test(err == KErrArgument);
+ test(dllPtr == NULL);
+
+ RImplInfoPtrArray ifArray;
+
+ // ListImplementationL with a dummy interface Uid
+ TRAP(err, REComSession::ListImplementationsL(dummyUid,extendedInterfaces,ResolverParams,ifArray));
+ test(err == KErrArgument);
+ test(ifArray.Count() == 0);
+
+ // ListImplementationL with a dummy resolver Uid
+ TRAP(err, REComSession::ListImplementationsL(KInterfaceUid,extendedInterfaces,ResolverParams,dummyUid,ifArray));
+ test(err == KErrArgument);
+ test(ifArray.Count() == 0);
+
+ CleanupStack::PopAndDestroy(&extendedInterfaces);
+ }
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3715
+@SYMTestCaseDesc Tests for REComSession::CreateImplementationL with ROMOnly resolver
+@SYMTestPriority High
+@SYMTestActions Call CreateImplementationL method with ROMOnly resolver
+@SYMTestExpectedResults Expected implementation is created. Ensure there is no OOM error.
+@SYMDEF DEF111196
+*/
+LOCAL_C void CreateImplementationTest7L()
+ {
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3715 "));
+ // test start...
+ const TUid KExample10InterfaceUid = {0x10009DBB};
+ const TUid KExtendedInterfaceUid1 = {0x10009E44};
+ const TUid KExtendedInterfaceUid2 = {0x10009E45};
+ const TUid KExtendedInterfaceUid3 = {0x10009E46};
+ const TUid KExample10ImplementationUid = {0x10009E38};
+
+ _LIT8(KExample10ImplementationTest,"Example 10");
+
+ // ROMOnly resolver Uid 0x10009D92
+ TUid resolverUid = {0x10009D92};
+
+ TUid instanceKey;
+
+ CExampleInterface* dllPtr = NULL;
+ // Set up extended interfaces
+ RArray<TUid> extendedInterfaces;
+ CleanupClosePushL(extendedInterfaces);
+ extendedInterfaces.AppendL(KExtendedInterfaceUid1);
+ extendedInterfaces.AppendL(KExtendedInterfaceUid2);
+ extendedInterfaces.AppendL(KExtendedInterfaceUid3);
+
+ //Set up resolve parameter
+ TEComResolverParams ResolverParams;
+ ResolverParams.SetDataType(KExample10ImplementationTest());
+ ResolverParams.SetGenericMatch(ETrue); // Allow wildcard matching
+
+ dllPtr = REINTERPRET_CAST(CExampleInterface*,
+ REComSession::CreateImplementationL(KExample10InterfaceUid,
+ extendedInterfaces,
+ instanceKey,
+ ResolverParams,
+ resolverUid));
+ CleanupStack::PopAndDestroy(&extendedInterfaces);
+
+ //checks the implementation created
+ test(dllPtr != NULL);
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
+ test(KExample10ImplementationUid == dllPtr->ImplId());
+
+ test.Printf(_L("Destroying Plugin..."));
+ REComSession::DestroyedImplementation(instanceKey);
+
+ delete dllPtr;
+ }
+
+
+/**
+Test function for REcomSession::CreateImplementationL
+
+@param aContainInvalidExtIf The bool value identifying if the extended interfaces list contains
+ invalid extended interface Uid
+@param aUseDefResolver The bool value identifying if default resolver is used.
+@param aUseInitParam The bool value identifying if initialise parameter is used.
+@param aNumEntriesInExtIFList The number of entries in the extended interfaces list.
+@param aInstanceKey A 32 bit identifer returned by the ECom framework to
+ identify this instance to the framework.
+@return A pointer to the implementation created.
+*/
+LOCAL_C CExampleInterface* CreateImplementationTestL(TBool aContainInvalidExtIf,
+ TBool aUseDefResolver,
+ TBool aUseInitParam,
+ TUid& aInstanceKey)
+ {
+ const TUid KExample10InterfaceUid = {0x10009DBB};
+ const TUid KExtendedInterfaceUid1 = {0x10009E44};
+ const TUid KExtendedInterfaceUid2 = {0x10009E45};
+ const TUid KExtendedInterfaceUid3 = {0x10009E46};
+ const TUid KInvalidExtendedInterfaceUid2 = {0x10009E49};
+ _LIT8(KExample10ImplementationTest,"Example 10");
+
+ TUid resolverUid = {0x10009DD0};
+
+ CExampleInterface* dllPtr = NULL;
+ // Set up extended interfaces
+ RArray<TUid> extendedInterfaces;
+ CleanupClosePushL(extendedInterfaces);
+
+ if (!aContainInvalidExtIf)
+ {
+ extendedInterfaces.AppendL(KExtendedInterfaceUid1);
+ extendedInterfaces.AppendL(KExtendedInterfaceUid2);
+ extendedInterfaces.AppendL(KExtendedInterfaceUid3);
+ }
+ else
+ {
+ extendedInterfaces.AppendL(KExtendedInterfaceUid1);
+ extendedInterfaces.AppendL(KInvalidExtendedInterfaceUid2);
+ }
+
+ //Set up resolve parameter
+ TEComResolverParams ResolverParams;
+ ResolverParams.SetDataType(KExample10ImplementationTest());
+ ResolverParams.SetGenericMatch(ETrue); // Allow wildcard matching
+
+ CExampleInterface::TExampleInterfaceInitParams initParams;
+ if (aUseInitParam) //CreateImplementationTest3L,CreateImplementationTest5L
+ {
+ // Set up some empty initialisation parameters
+ initParams.integer = 0;
+ initParams.descriptor = NULL;
+ if (aUseDefResolver) //CreateImplementationTest3L
+ {
+ dllPtr = REINTERPRET_CAST(CExampleInterface*,
+ REComSession::CreateImplementationL(KExample10InterfaceUid,
+ extendedInterfaces,
+ aInstanceKey,
+ ResolverParams,
+ &initParams));
+ }
+ else //CreateImplementationTest5L
+ {
+ dllPtr = REINTERPRET_CAST(CExampleInterface*,
+ REComSession::CreateImplementationL(KExample10InterfaceUid,
+ extendedInterfaces,
+ aInstanceKey,
+ ResolverParams,
+ resolverUid,
+ &initParams));
+ }
+ }
+ else //CreateImplementationTest2L, CreateImplementationTest4L, CreateImplementationTest6
+ {
+ if (aUseDefResolver) //CreateImplementationTest2L, CreateImplementationTest6
+ {
+ dllPtr = REINTERPRET_CAST(CExampleInterface*,
+ REComSession::CreateImplementationL(KExample10InterfaceUid,
+ extendedInterfaces,
+ aInstanceKey,
+ ResolverParams));
+ }
+ else //CreateImplementationTest4L
+ {
+ dllPtr = REINTERPRET_CAST(CExampleInterface*,
+ REComSession::CreateImplementationL(KExample10InterfaceUid,
+ extendedInterfaces,
+ aInstanceKey,
+ ResolverParams,
+ resolverUid));
+ }
+ }
+ CleanupStack::PopAndDestroy(&extendedInterfaces);
+ return dllPtr;
+ }
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3708
+@SYMTestCaseDesc Tests for calling DestroyedImplementation() twice.
+@SYMTestPriority High
+@SYMTestActions Call CreateImplementationL method to load a plugin.
+ Delete the plugin by calling DestroyedImplementation() twice.
+ Delete pointer. Call DestroyedImplementation().
+ Cal FinalClose(). Call DestroyedImplementation().
+@SYMTestExpectedResults Second call to DestroyedImplementation() should succeed.
+@SYMDEF DEF111428
+*/
+LOCAL_C void DestroyedImplementationTestL()
+ {
+ // Test Starts...
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3708 "));
+ TUid instanceKey;
+ TBool containInvalidExtIf = EFalse;
+ TBool useDefResolver = EFalse;
+ TBool useInitParam = ETrue;
+ TUid KExample10ImplementationUid = {0x10009E38};
+
+ test.Printf(_L("Loading Plugin..."));
+
+ // Test create implementation by pass in instance key.
+ CExampleInterface* dllPtr = CreateImplementationTestL(containInvalidExtIf,useDefResolver,useInitParam,instanceKey);
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
+ test(KExample10ImplementationUid == dllPtr->ImplId());
+
+ // the destructor calls DestroyedImplementation()
+ test.Printf(_L("Calling DestroyedImplementation the 1st time through the plugin destructor..."));
+ delete dllPtr;
+
+ test.Printf(_L("Calling DestroyedImplementation a 2nd time directly through REComSession..."));
+ REComSession::DestroyedImplementation(instanceKey);
+
+ test.Printf(_L("Calling DestroyedImplementation a 3rd time directly through REComSession but after FinalClose..."));
+
+ REComSession::DestroyedImplementation(instanceKey);
+ }
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3595
+@SYMTestCaseDesc Tests for REComSession::CreateImplementationL created with an Interface Uid
+ and invalid extended Interfaces.
+@SYMTestPriority High
+@SYMTestActions Call CreateImplementationL method supporting interface UID and extended interfaces
+ that are invalid.
+@SYMTestExpectedResults No implementation is created.
+@SYMEC EC43
+*/
+LOCAL_C void CreateImplementationTest6()
+ {
+ // Test Starts...
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3595 "));
+ TUid instanceKey;
+ TBool containInvalidExtIf = ETrue;
+ TBool useDefResolver = ETrue;
+ TBool useInitParam = EFalse;
+
+ test.Printf(_L("Loading Plugin..."));
+ TInt err;
+ TRAP(err,CExampleInterface* dllPtr = CreateImplementationTestL(containInvalidExtIf,useDefResolver,useInitParam,instanceKey));
+
+ test(KErrNotFound == err);
+
+ test.Printf(_L("Implementation is not found.\n"));
+ }
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3593
+@SYMTestCaseDesc Tests for REComSession::CreateImplementationL created with an resolver Uid
+@SYMTestPriority High
+@SYMTestActions Call CreateImplementationL method supporting interface UID, extended interfaces,
+ construction parameters, resolver parameters and resolver UID.
+@SYMTestExpectedResults Expected implementation is created and no memory leaks.
+@SYMEC EC43
+*/
+LOCAL_C void CreateImplementationTest5L()
+ {
+ // Test Starts...
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3593 "));
+ TUid instanceKey;
+ TBool containInvalidExtIf = EFalse;
+ TBool useDefResolver = EFalse;
+ TBool useInitParam = ETrue;
+ TUid KExample10ImplementationUid = {0x10009E38};
+
+ test.Printf(_L("Loading Plugin..."));
+
+ // Test create implementation by pass in instance key.
+ CExampleInterface* dllPtr = CreateImplementationTestL(containInvalidExtIf,useDefResolver,useInitParam,instanceKey);
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
+ test(KExample10ImplementationUid == dllPtr->ImplId());
+
+ test.Printf(_L("Destroying Plugin..."));
+ REComSession::DestroyedImplementation(instanceKey);
+ delete dllPtr;
+
+ // Test create implementation by pass in offset of the instance key.
+ dllPtr = CExampleInterface::NewL8();
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
+ test(KExample10ImplementationUid == dllPtr->ImplId());
+
+ test.Printf(_L("Destroying Plugin..."));
+ delete dllPtr;
+ }
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3592
+@SYMTestCaseDesc Tests for REComSession::CreateImplementationL created with an resolver Uid
+@SYMTestPriority High
+@SYMTestActions Call CreateImplementationL method supporting interface UID, extended interfaces,
+ resolver parameters and resolver UID.
+@SYMTestExpectedResults Expected implementation is created and no memory leaks.
+@SYMEC EC43
+*/
+LOCAL_C void CreateImplementationTest4L()
+ {
+ // Test Starts...
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3592 "));
+ TUid instanceKey;
+ TBool containInvalidExtIf = EFalse;
+ TBool useDefResolver = EFalse;
+ TBool useInitParam = EFalse;
+ TUid KExample10ImplementationUid = {0x10009E38};
+
+ test.Printf(_L("Loading Plugin..."));
+
+ // Test create implementation by pass in instance key.
+ CExampleInterface* dllPtr = CreateImplementationTestL(containInvalidExtIf,useDefResolver,useInitParam,instanceKey);
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
+ test(KExample10ImplementationUid == dllPtr->ImplId());
+
+ test.Printf(_L("Destroying Plugin..."));
+ REComSession::DestroyedImplementation(instanceKey);
+ delete dllPtr;
+
+ // Test create implementation by pass in offset of the instance key.
+ dllPtr = CExampleInterface::NewL6();
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
+ test(KExample10ImplementationUid == dllPtr->ImplId());
+
+ test.Printf(_L("Destroying Plugin..."));
+ delete dllPtr;
+ }
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3591
+@SYMTestCaseDesc Tests for REComSession::CreateImplementationL created with an Interface Uid,
+ ExtendedInterface, construction parameters and resolver parameters
+@SYMTestPriority High
+@SYMTestActions Call CreateImplementationL method supporting interface UID,extended interfaces,
+ construction parameters and resolver parameters.
+@SYMTestExpectedResults Expected implementation is created and no memory leaks.
+@SYMEC EC43
+*/
+LOCAL_C void CreateImplementationTest3L()
+ {
+ // Test Starts...
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3591 "));
+ TUid instanceKey;
+ TBool containInvalidExtIf = EFalse;
+ TBool useDefResolver = ETrue;
+ TBool useInitParam = ETrue;
+ TUid KExample10ImplementationUid = {0x10009E38};
+
+ test.Printf(_L("Loading Plugin..."));
+
+ // Test create implementation by pass in instance key.
+ CExampleInterface* dllPtr = CreateImplementationTestL(containInvalidExtIf,useDefResolver,useInitParam,instanceKey);
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
+ test(KExample10ImplementationUid == dllPtr->ImplId());
+
+ test.Printf(_L("Destroying Plugin..."));
+ REComSession::DestroyedImplementation(instanceKey);
+ delete dllPtr;
+
+ // Test create implementation by pass in offset of the instance key.
+ dllPtr = CExampleInterface::NewL7();
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
+ test(KExample10ImplementationUid == dllPtr->ImplId());
+
+ test.Printf(_L("Destroying Plugin..."));
+ delete dllPtr;
+ }
+
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3590
+@SYMTestCaseDesc Tests for REComSession::CreateImplementationL created with an Interface Uid,
+ ExtendedInterface and resolver parameters.
+@SYMTestPriority High
+@SYMTestActions Call CreateImplementationL method supporting interface UID,extended interfaces, and resolver parameters.
+@SYMTestExpectedResults Expected implementation is created and no memory leaks.
+@SYMEC EC43
+*/
+LOCAL_C void CreateImplementationTest2L()
+ {
+ // Test Starts...
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3590 "));
+ TUid instanceKey;
+ TBool containInvalidExtIf = EFalse;
+ TBool useDefResolver = ETrue;
+ TBool useInitParam = EFalse;
+ TUid KExample10ImplementationUid = {0x10009E38};
+
+ test.Printf(_L("Loading Plugin..."));
+ // Test create implementation by pass in instance key.
+ CExampleInterface* dllPtr = CreateImplementationTestL(containInvalidExtIf,useDefResolver,useInitParam,instanceKey);
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
+ test(KExample10ImplementationUid == dllPtr->ImplId());
+
+ test.Printf(_L("Destroying Plugin..."));
+ REComSession::DestroyedImplementation(instanceKey);
+ delete dllPtr;
+
+ // Test create implementation by pass in offset of the instance key.
+ dllPtr = CExampleInterface::NewL5();
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
+ test(KExample10ImplementationUid == dllPtr->ImplId());
+
+ test.Printf(_L("Destroying Plugin..."));
+ delete dllPtr;
+ }
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3586
+@SYMTestCaseDesc Tests for GetExtendedInterfaceL, Manual release
+@SYMTestPriority High
+@SYMTestActions Create an implementation. Fetch two extended interfaces (one build in, and one
+ stand alone and requires release). Manually release the stand alone extended
+ interface. Destroy implementation.
+@SYMTestExpectedResults Ensure that manual release releases the stand alone interface correctly.
+@SYMEC EC43
+*/
+LOCAL_C void GetExtendedInterfaceTest4L()
+ {
+ // Test Starts...
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3586 "));
+ test.Printf(_L("Loading Plugin..."));
+ const TUid KExample10ImplementationUid = {0x10009E38};
+
+ CExampleInterface* dllPtr = CExampleInterface::NewL2(KExample10ImplementationUid);
+ CleanupStack::PushL(dllPtr);
+
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
+ test(KExample10ImplementationUid == dllPtr->ImplId());
+
+ // Call extended interface here.
+ const TUid KExample10InterfaceUid1 = {0x10009E44};
+ const TUid KExample10InterfaceUid2 = {0x10009E45};
+
+ MExampleInterfaceExtended* ext1 = static_cast<MExampleInterfaceExtended*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid1));
+ ext1->DoMethodExtended();
+
+ MExampleInterfaceExtended2* ext2 = static_cast<MExampleInterfaceExtended2*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid2));
+ ext2->DoMethodExtended2();
+
+ dllPtr->ManuallyReleaseExtendedInterfaceL(KExample10InterfaceUid2);
+
+ test.Printf(_L("Destroying Plugin..."));
+ CleanupStack::Pop(dllPtr);
+ delete dllPtr;
+
+ // Test Ends...
+ }
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-4001
+@SYMTestCaseDesc Tests GetExtendedInterfaceL with invalid instance keys
+@SYMTestPriority High
+@SYMTestActions Retrieve extended interface using unknown instance key
+ Retrieve extended interface using null instance key
+@SYMTestExpectedResults Ensure that correct leaves occur.
+@SYMDEF DEF111553
+*/
+LOCAL_C void GetExtendedInterfaceTest5L()
+ {
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-4001 "));
+ // Test Starts...
+ TUid instanceKey;
+ TBool containInvalidExtIf = EFalse;
+ TBool useDefResolver = EFalse;
+ TBool useInitParam = ETrue;
+
+ // get valid instance key by creating implementation
+ CExampleInterface* dllPtr = CreateImplementationTestL(containInvalidExtIf,useDefResolver,useInitParam,instanceKey);
+
+ // remove implementation
+ REComSession::DestroyedImplementation(instanceKey);
+ delete dllPtr;
+
+ // Attempt to fetch extended interface with instance key that is no longer valid but
+ // passes the ASSERT test
+ const TUid KExtendedInterfaceUid = {0x10009E44};
+ TRAPD(err, REComSession::GetExtendedInterfaceL(instanceKey,KExtendedInterfaceUid));
+ test(err = KErrNotFound);
+
+ // Attempt to fetch extended interface with null instance key
+ TRAP(err, REComSession::GetExtendedInterfaceL(KNullUid,KExtendedInterfaceUid));
+ test(err = KErrArgument);
+
+ // Test Ends...
+ }
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3581
+@SYMTestCaseDesc Tests for REComSession::ListExtendedInterfaces with a valid Implementation UID.
+ Tests also for non-existent Implementation UID and PLUGIN1 implementation UID.
+ Does some create and destruction of implementations before and after calling
+ ListExtendedInterfaces to mimic typical usage.
+@SYMTestPriority High
+@SYMTestActions List the extended interfaces. Check expected extended interfaces are returned.
+ Create an implementation. Ensure that Listing of the extended interface
+ still works after the create.
+ Delete the implementation. List extended interfaces again.
+ List the extended interfaces with a PLUGIN1 implementation UID.
+@SYMTestExpectedResults Ensure all ListExtendedInterfaces calls return with expected extended interfaces.
+@SYMEC EC43
+@SYMDEF DEF111196
+*/
+LOCAL_C void ListExtendedInterfaceTestL()
+ {
+ // Test Starts...
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3581 "));
+ const TUid KExample10ImplementationUid = {0x10009E38};
+ const TUid KExample10ImplementationUid2 = {0x10009E3A};
+ const TUid KExample10ImplementationUid3 = {0x10009E3B};
+
+ const TUid KExample10InterfaceUid1 = {0x10009E44};
+ const TUid KExample10InterfaceUid2 = {0x10009E45};
+ const TUid KExample10InterfaceUid3 = {0x10009E46};
+
+ const TUid KImpUidPLUGIN1 = {0x10009DC3};
+
+ RArray<TUid> ifInfo;
+ CleanupClosePushL(ifInfo);
+
+ REComSession::ListExtendedInterfacesL(KExample10ImplementationUid,ifInfo);
+ test(ifInfo.Count() == 3);
+
+ // Checks that expected interfaces are in list.
+ test(ifInfo[0] == KExample10InterfaceUid1);
+ test(ifInfo[1] == KExample10InterfaceUid2);
+ test(ifInfo[2] == KExample10InterfaceUid3);
+ ifInfo.Reset();
+
+ // Creates an implementation
+ // Set up some empty initialisation parameters
+ test.Printf(_L("Loading Plugin..."));
+
+ CExampleInterface* dllPtr = CExampleInterface::NewL2(KExample10ImplementationUid);
+ CleanupStack::PushL(dllPtr);
+
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
+ test(KExample10ImplementationUid == dllPtr->ImplId());
+
+ // Calls extended interface here.
+ MExampleInterfaceExtended* ext1 = static_cast<MExampleInterfaceExtended*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid1));
+ ext1->DoMethodExtended();
+
+ MExampleInterfaceExtended2* ext2 = static_cast<MExampleInterfaceExtended2*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid2));
+ ext2->DoMethodExtended2();
+
+ // Checks that ListExtendedInterfaces works after a Create Implementation
+ REComSession::ListExtendedInterfacesL(KExample10ImplementationUid,ifInfo);
+ test(ifInfo.Count() == 3);
+
+ // Checks that expected interfaces are in list.
+ test(ifInfo[0] == KExample10InterfaceUid1);
+ test(ifInfo[1] == KExample10InterfaceUid2);
+ test(ifInfo[2] == KExample10InterfaceUid3);
+ ifInfo.Reset();
+
+ test.Printf(_L("Destroying Plugin..."));
+ CleanupStack::Pop(dllPtr);
+
+ delete dllPtr;
+
+ // Test fetch of extended interfaces for an implementation that has no extended interfaces
+ REComSession::ListExtendedInterfacesL(KExample10ImplementationUid2,ifInfo);
+ test(ifInfo.Count() == 0);
+ ifInfo.Reset();
+
+ // Test fetch of extended interfaces for an implementation that does not exist
+ TRAPD(err,REComSession::ListExtendedInterfacesL(KNullUid,ifInfo));
+ TEST_OOM_ERR;
+ test(err == KErrNotFound);
+ ifInfo.Reset();
+
+ // Test fetch of extended interfaces for an implementation that has one extended interface
+ REComSession::ListExtendedInterfacesL(KExample10ImplementationUid3,ifInfo);
+ test(ifInfo.Count() == 1);
+ ifInfo.Reset();
+
+ // Test fetch of extended interfaces for an implementation with PLUGIN1 IIC that has no extended interfaces
+ REComSession::ListExtendedInterfacesL(KImpUidPLUGIN1,ifInfo);
+ test(ifInfo.Count() == 0);
+ ifInfo.Reset();
+
+ // Close array, finished with it.
+ CleanupStack::PopAndDestroy(&ifInfo);
+ // Test Ends...
+ }
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3596
+@SYMTestCaseDesc Try to load a PLUGIN3 DLL with a version one resource file. Also try to load a PLUGIN1 DLL
+ with a version three resource file. Tests UID mismatch specified in the DLL .mmp file and
+ the resource type in the resource file.
+@SYMTestPriority High
+@SYMTestActions Create an implementation using the invalid plugin.
+@SYMTestExpectedResults The plugin should not have been loaded due to a UID1 mismatch.
+@SYMEC EC43
+*/
+LOCAL_C void CreateImplementationTest1()
+ {
+ // Test Starts...
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3596 "));
+ TUid instanceKey;
+
+ // Set up some empty initialisation parameters
+ CExampleInterface::TExampleInterfaceInitParams initParams;
+ initParams.integer = 0;
+ initParams.descriptor = NULL;
+
+ test.Printf(_L("Loading Plugin..."));
+
+ // Interface with NULL get and release function pointers
+ const TUid KExample12InvalidDllImplementationUid = {0x10009E39};
+
+ TRAPD(err, TAny* dllPtr = REComSession::CreateImplementationL(KExample12InvalidDllImplementationUid,instanceKey,&initParams));
+
+ // The plugin should not have been loaded due to a UID1 mismatch. This is specified as the resource
+ // type in the resource file and UID1 in the DLL itself.
+ test(err==KErrNotFound);
+
+ // Load a PLUGIN1 DLL with a version three resource file
+ const TUid KExample14InvalidDllImplementationUid = {0x10009E48};
+
+ TRAP(err, TAny* dllPtr = REComSession::CreateImplementationL(KExample14InvalidDllImplementationUid,instanceKey,&initParams));
+
+ // The plugin should not have been loaded due to a UID1 mismatch. This is specified as the resource
+ // type in the resource file and UID1 in the DLL itself.
+ test(err==KErrNotFound);
+ // Test Ends...
+ }
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3585
+@SYMTestCaseDesc Get and release extended interfaces in cases in which both get and release function pointers
+ do not exist. The tests will be:
+ 1) Get/release function pointers are NULL
+ 2) Only get function, no release function
+ 3) Test with a PLUGIN1 DLL (get/release function pointers should be NULL)
+@SYMTestPriority High
+@SYMTestActions Create an implementation.
+ Try getting and releasing interfaces even though no get and release function pointers exist
+ Test with get extended interface function pointer and no release function pointer
+@SYMTestExpectedResults NULL should be returned if get and release function pointers do not exist
+ Releasing an interface that has no release function pointer should finish with
+ no errors.
+@SYMEC EC43
+*/
+LOCAL_C void ReleaseExtendedInterfaceTest1L()
+ {
+ // Test Starts...
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3585 "));
+ test.Printf(_L("Loading Plugin..."));
+ // Interface with NULL get and release function pointers
+ const TUid KExample10ImplementationUid = {0x10009E3A};
+
+ CExampleInterface* dllPtr = CExampleInterface::NewL2(KExample10ImplementationUid);
+ CleanupStack::PushL(dllPtr);
+
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
+ test(KExample10ImplementationUid == dllPtr->ImplId());
+
+ // Call extended interface here.
+ const TUid KExample10InterfaceUid1 = {0x10009E44};
+ const TUid KExample10InterfaceUid2 = {0x10009E45};
+
+ // Try getting and releasing interfaces even though no get and release function pointers exist
+ MExampleInterfaceExtended* ext1 = static_cast<MExampleInterfaceExtended*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid1));
+ test(ext1 == NULL);
+
+ MExampleInterfaceExtended2* ext2 = static_cast<MExampleInterfaceExtended2*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid2));
+ test(ext2 == NULL);
+
+ dllPtr->ManuallyReleaseExtendedInterfaceL(KExample10InterfaceUid2);
+
+ test.Printf(_L("Destroying Plugin 1..."));
+ CleanupStack::Pop(dllPtr);
+ delete dllPtr;
+
+ // Test with get extended interface function pointer and no release function pointer
+ const TUid KExample10ImplementationUidNoRelease = {0x10009E3B};
+
+ dllPtr = CExampleInterface::NewL2(KExample10ImplementationUidNoRelease);
+ CleanupStack::PushL(dllPtr);
+
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUidNoRelease);
+ test(KExample10ImplementationUidNoRelease == dllPtr->ImplId());
+
+ // Try releasing interfaces even though no release function pointer exists
+ MExampleInterfaceExtended* ext = static_cast<MExampleInterfaceExtended*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid1));
+ ext->DoMethodExtended();
+
+ // This should do nothing
+ dllPtr->ManuallyReleaseExtendedInterfaceL(KExample10InterfaceUid1);
+
+ test.Printf(_L("Destroying Plugin 2..."));
+ CleanupStack::Pop(dllPtr);
+ delete dllPtr;
+
+ // PLUGIN1 test. Try getting and releasing interfaces even though no get and release function pointers exist.
+ dllPtr = CExampleInterface::NewL2(KCExampleImplUid);
+ CleanupStack::PushL(dllPtr);
+
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KCExampleImplUid);
+ test(KCExampleImplUid == dllPtr->ImplId());
+
+ // Call extended interface here.
+ // Try getting and releasing interfaces even though no get and release function pointers exist
+ MExampleInterfaceExtended* ext3 = static_cast<MExampleInterfaceExtended*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid1));
+ test(ext3 == NULL);
+
+ // Nothing should happen when releasing an extended interface for a PLUGIN1 DLL
+ dllPtr->ManuallyReleaseExtendedInterfaceL(KExample10InterfaceUid1);
+
+ test.Printf(_L("Destroying Plugin 3..."));
+ CleanupStack::Pop(dllPtr);
+ delete dllPtr;
+ // Test Ends...
+ }
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-4002
+@SYMTestCaseDesc Tests ManuallyReleaseExtendedInterfaceL with invalid instance keys
+@SYMTestPriority High
+@SYMTestActions Manually release extended interface using unknown instance key
+ Manually release extended interface using null instance key
+@SYMTestExpectedResults Ensure that correct leaves occur.
+@SYMDEF DEF111553
+*/
+LOCAL_C void ReleaseExtendedInterfaceTest2L()
+ {
+ // Test Starts...
+ // get valid instance key by creating implementation
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-4002 "));
+ const TUid KExample10ImplementationUid = {0x10009E3A};
+ TUid instanceKey;
+ TAny* impl = REComSession::CreateImplementationL(KExample10ImplementationUid, instanceKey, 0);
+
+ // remove implementation
+ REComSession::DestroyedImplementation(instanceKey);
+ delete impl;
+
+ // Attempt to manually release extended interface with instance key that is no longer valid but
+ // passes the ASSERT test
+ const TUid KExample10InterfaceUid1 = {0x10009E44};
+ TRAPD(err, REComSession::ManuallyReleaseExtendedInterfaceL(instanceKey,KExample10InterfaceUid1));
+ test(err = KErrNotFound);
+
+ // Attempt to manually release extended interface with null instance key
+ TRAP(err, REComSession::GetExtendedInterfaceL(KNullUid,KExample10InterfaceUid1));
+ test(err = KErrArgument);
+ // Test Ends...
+ }
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3584
+@SYMTestCaseDesc Tests for GetExtendedInterfaceL, fetching an invalid extended interface
+@SYMTestPriority High
+@SYMTestActions Create an implementation. Fetch two extended interfaces (one build in, and one
+ stand alone and requires release). Fetch an invalid extended interface. Destroy implementation.
+@SYMTestExpectedResults Ensure that the GetExtendedInterfaceL call with the invalid interface returns NULL.
+@SYMEC EC43
+*/
+LOCAL_C void GetExtendedInterfaceTest3L()
+ {
+ //
+ // Testing a overloaded method for CreateImplementationL
+ // ------------------------------------------------------------------
+ //
+ // Test Starts...
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3584 "));
+ test.Printf(_L("Loading Plugin..."));
+ const TUid KExample10ImplementationUid = {0x10009E38};
+
+ CExampleInterface* dllPtr = CExampleInterface::NewL2(KExample10ImplementationUid);
+ CleanupStack::PushL(dllPtr);
+
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
+ test(KExample10ImplementationUid == dllPtr->ImplId());
+
+ // Call extended interface here.
+ const TUid KExample10InterfaceUid1 = {0x10009E44};
+ const TUid KExample10InterfaceUid2 = {0x10009E45};
+ const TUid KExample10InvalidInterfaceUid = {0x10009E49};
+
+ MExampleInterfaceExtended* ext1 = static_cast<MExampleInterfaceExtended*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid1));
+ ext1->DoMethodExtended();
+
+ MExampleInterfaceExtended2* ext2 = static_cast<MExampleInterfaceExtended2*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid2));
+ ext2->DoMethodExtended2();
+
+ // Get an invalid extended interface.
+ MExampleInterfaceExtended2* ext2invalid = static_cast<MExampleInterfaceExtended2*>(dllPtr->GetExtendedInterfaceL(KExample10InvalidInterfaceUid));
+ // No interface should be returned if it is not found.
+ test(ext2invalid == NULL);
+
+ test.Printf(_L("Destroying Plugin..."));
+ CleanupStack::Pop(dllPtr);
+ delete dllPtr;
+
+ // Test Ends...
+ }
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3583
+@SYMTestCaseDesc Tests for GetExtendedInterfaceL, with an invalid instance key.
+@SYMTestPriority High
+@SYMTestActions Call REComSession::GetExtendedInterfaceL() with an invalid instance key.
+ GetExtendedInterfacePanic() and ThreadPanicTest() are used for this test case.
+@SYMTestExpectedResults Ensure that the GetExtendedInterfaceL panics in debug mode and leaves in release
+ mode.
+@SYMEC EC43
+*/
+LOCAL_C void GetExtendedInterfaceTest2L()
+ {
+ // Test Starts...
+ TUid instanceKey;
+ TBool containInvalidExtIf = EFalse;
+ TBool useDefResolver = EFalse;
+ TBool useInitParam = ETrue;
+
+ CExampleInterface* dllPtr = CreateImplementationTestL(containInvalidExtIf,useDefResolver,useInitParam,instanceKey);
+ CleanupStack::PushL(dllPtr);
+
+ const TUid KExtendedInterfaceUid = {0x10009E44};
+ TUid invalidInstanceKey;
+ invalidInstanceKey.iUid = instanceKey.iUid + 1;
+
+ // Fetches an extended interface with invalid instance key.
+ // When passed an invalid instance key, REComSession::GetExtendedInterfaceL() panics
+ // with KErrArgument in debug mode, but leaves with KErrNotFound in release mode.
+ MExampleInterfaceExtended* ext1 = static_cast<MExampleInterfaceExtended*>(REComSession::GetExtendedInterfaceL(invalidInstanceKey,KExtendedInterfaceUid));
+
+ REComSession::DestroyedImplementation(instanceKey);
+ CleanupStack::PopAndDestroy(dllPtr);
+
+ // Test Ends...
+ }
+
+/**
+A thread function.
+Panics in debug mode.
+Returns an error code in release mode.
+*/
+LOCAL_C TInt GetExtendedInterfacePanic(TAny*)
+ {
+ __UHEAP_MARK;
+ CTrapCleanup* threadcleanup = CTrapCleanup::New();
+
+ // In debug mode, GetExtendedInterfaceTest2L panics with reason KErrArgument.
+ // In release mode, it leaves with KErrNotFound.
+ TRAPD(err, GetExtendedInterfaceTest2L());
+
+ delete threadcleanup;
+ __UHEAP_MARKEND;
+
+ return err;
+ }
+
+/**
+The test code is used for capturing the PANIC that occurs as a result of calling GetExtendedInterfaceL
+with an invalid instance key.
+*/
+LOCAL_C void ThreadPanicTest(const TDesC& aName,TThreadFunction aFunction)
+ {
+ test.Next(aName);
+ TRequestStatus threadStatus;
+ RThread thread;
+ TBool jit;
+ jit=User::JustInTime();
+ User::SetJustInTime(EFalse);
+
+ TInt err=thread.Create(aName,aFunction,KDefaultStackSize*8,KMinHeapSize,0x100000,0);
+ test(err==KErrNone);
+ thread.Logon(threadStatus) ;
+ thread.Resume();
+
+ User::WaitForRequest(threadStatus);
+
+ // Different verifications for debug and release mode.
+#ifdef _DEBUG
+ test(thread.ExitType()==EExitPanic);
+ test(thread.ExitReason()==EEComPanic_InvalidImplementationInstanceKey);
+#else
+ test(thread.ExitType()==EExitKill);
+ test(thread.ExitReason()==KErrNotFound);
+#endif
+
+ thread.Close();
+ User::SetJustInTime(jit);
+ }
+
+/**
+@SYMTestCaseID SYSLIB-ECOM-CT-3582
+@SYMTestCaseDesc Tests for GetExtendedInterfaceL, stand alone and built in extended interfaces with
+ valid instance keys.
+@SYMTestPriority High
+@SYMTestActions Create an implementation. Fetch two extended interfaces (one build in, and one
+ stand alone and requires release). Call extended interfaces. Destroy implementation.
+ Re-create the same implementation again. Fetch extended interface. Destroy implementation.
+ Re-create again. Fetch two extended interfaces (both being stand alone and
+ require release).
+@SYMTestExpectedResults Ensure that Extended interfaces can be created, called and cleaned up when
+ implementation is destroyed.
+@SYMEC EC43
+*/
+LOCAL_C void GetExtendedInterfaceTest1L()
+ {
+ // Test Starts...
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3582 "));
+ test.Printf(_L("Loading Plugin..."));
+ const TUid KExample10ImplementationUid = {0x10009E38};
+
+ CExampleInterface* dllPtr = CExampleInterface::NewL2(KExample10ImplementationUid);
+ CleanupStack::PushL(dllPtr);
+
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
+ test(KExample10ImplementationUid == dllPtr->ImplId());
+
+ // Calls extended interface here.
+ const TUid KExample10InterfaceUid1 = {0x10009E44};
+ const TUid KExample10InterfaceUid2 = {0x10009E45};
+
+ // Fetches an extended interface.
+ MExampleInterfaceExtended* ext1 = static_cast<MExampleInterfaceExtended*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid1));
+ // Sanity check by calling extended interface.
+ ext1->DoMethodExtended();
+
+ // Fetches an extended interface. Stand alone interface.
+ MExampleInterfaceExtended2* ext2 = static_cast<MExampleInterfaceExtended2*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid2));
+ // Sanity check by calling extended interface.
+ ext2->DoMethodExtended2();
+
+ // Delete implementation, this will automatically destroy the stand alone interface.
+ test.Printf(_L("Destroying Plugin..."));
+ CleanupStack::Pop(dllPtr);
+ delete dllPtr;
+
+ // Test to ensure that a new interface can be re-created immediately after deletion. This
+ // also tests that no problems occur when no extended interfaces require releasing yet
+ // a release function exists in the plug-in implementation.
+ dllPtr = CExampleInterface::NewL2(KExample10ImplementationUid);
+ CleanupStack::PushL(dllPtr);
+
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
+ test(KExample10ImplementationUid == dllPtr->ImplId());
+
+ // Ensure that the extended interface can also be fetched again
+ MExampleInterfaceExtended* ext = static_cast<MExampleInterfaceExtended*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid1));
+ ext->DoMethodExtended();
+
+ test.Printf(_L("Destroying Plugin..."));
+ CleanupStack::Pop(dllPtr);
+ delete dllPtr;
+
+ // Re-creates implementation. This time create two extended interfaces that require release
+ dllPtr = CExampleInterface::NewL2(KExample10ImplementationUid);
+ CleanupStack::PushL(dllPtr);
+
+ test.Printf(_L("Found dll uid %x, required %x.\n"),dllPtr->ImplId(), KExample10ImplementationUid);
+ test(KExample10ImplementationUid == dllPtr->ImplId());
+
+ MExampleInterfaceExtended2* extension1 = static_cast<MExampleInterfaceExtended2*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid2));
+ extension1->DoMethodExtended2();
+
+ const TUid KExample10InterfaceUid3 = {0x10009E46};
+
+ MExampleInterfaceExtended2* extension2 = static_cast<MExampleInterfaceExtended2*>(dllPtr->GetExtendedInterfaceL(KExample10InterfaceUid3));
+ extension2->DoMethodExtended2();
+
+ // Destroy the implementation. This should automatically delete both extended interfaces above
+ test.Printf(_L("Destroying Plugin..."));
+ CleanupStack::Pop(dllPtr);
+ delete dllPtr;
+ // Test Ends...
+ }
+
+
+typedef void (*ClassFuncPtrL) (void);
+
+/**
+Wrapper function to call all test functions
+@param testFuncL pointer to test function
+@param aTestDesc test function name
+*/
+LOCAL_C void DoBasicTest(ClassFuncPtrL testFuncL, const TDesC& aTestDesc)
+ {
+ test.Next(aTestDesc);
+
+ __UHEAP_MARK;
+ // find out the number of open handles
+ TInt pHCountStart;
+ TInt tHCountStart;
+ RThread().HandleCount(pHCountStart,tHCountStart);
+
+ TRAPD(err, (*testFuncL)());
+ test(KErrNone == err);
+
+ // release handles
+ REComSession::FinalClose();
+
+ // check that no handles have leaked
+ TInt pHCountEnd;
+ TInt tHCountEnd;
+ RThread().HandleCount(pHCountEnd,tHCountEnd);
+
+ test(pHCountStart == pHCountEnd);
+ test(tHCountStart == tHCountEnd);
+ test.Printf(_L("Great ! No handle mismatch."));
+
+ __UHEAP_MARKEND;
+ }
+
+/**
+Wrapper function to call all OOM test functions
+@param testFuncL pointer to OOM test function
+@param aTestDesc test function name
+*/
+LOCAL_C void DoOOMTest(ClassFuncPtrL testFuncL, const TDesC& aTestDesc)
+ {
+ test.Next(aTestDesc);
+ TInt err;
+ TInt failAt = 1;
+
+ do
+ {
+ __UHEAP_MARK;
+ // find out the number of open handles
+ TInt pHCountStart;
+ TInt tHCountStart;
+ RThread().HandleCount(pHCountStart,tHCountStart);
+
+ // Setting Heap failure for OOM test
+ __UHEAP_SETFAIL(RHeap::EDeterministic, failAt++);
+
+ TRAP(err, (*testFuncL)());
+
+ __UHEAP_SETFAIL(RHeap::ENone, 0);
+
+ // release handles
+ REComSession::FinalClose();
+
+ // check that no handles have leaked
+ TInt pHCountEnd;
+ TInt tHCountEnd;
+ RThread().HandleCount(pHCountEnd,tHCountEnd);
+
+ test(pHCountStart == pHCountEnd);
+ test(tHCountStart == tHCountEnd);
+ test.Printf(_L("Great ! No handle mismatch."));
+
+ __UHEAP_MARKEND;
+ } while(err == KErrNoMemory);
+
+ test(err == KErrNone);
+ test.Printf(_L("- server succeeded at heap failure rate of %i\n"), failAt);
+ }
+
+
+void DoTests()
+ {
+ //Basic test...
+ test.Printf(_L("Basic tests...\n"));
+
+ DoBasicTest(&GetExtendedInterfaceTest1L,_L("GetExtendedInterfaceTest1L"));
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3583 "));
+ ThreadPanicTest(_L("GetExtendedInterface Panic Testing"),GetExtendedInterfacePanic);
+ DoBasicTest(&GetExtendedInterfaceTest3L,_L("GetExtendedInterfaceTest3L"));
+ DoBasicTest(&GetExtendedInterfaceTest4L,_L("GetExtendedInterfaceTest4L"));
+ DoBasicTest(&GetExtendedInterfaceTest5L,_L("GetExtendedInterfaceTest5L"));
+ DoBasicTest(&ReleaseExtendedInterfaceTest1L,_L("ReleaseExtendedInterfaceTest1L"));
+ DoBasicTest(&ReleaseExtendedInterfaceTest2L,_L("ReleaseExtendedInterfaceTest2L"));
+ DoBasicTest(&ListExtendedInterfaceTestL,_L("ListExtendedInterfaceTestL"));
+
+ DoBasicTest(&CreateImplementationTest1,_L("CreateImplementationTest1"));
+ DoBasicTest(&CreateImplementationTest2L,_L("CreateImplementationTest2L"));
+ DoBasicTest(&CreateImplementationTest3L,_L("CreateImplementationTest3L"));
+ DoBasicTest(&CreateImplementationTest4L,_L("CreateImplementationTest4L"));
+ DoBasicTest(&CreateImplementationTest5L,_L("CreateImplementationTest5L"));
+ DoBasicTest(&CreateImplementationTest6,_L("CreateImplementationTest6"));
+ DoBasicTest(&CreateImplementationTest7L,_L("CreateImplementationTest7L"));
+ DoBasicTest(&DestroyedImplementationTestL,_L("DestroyedImplementationTestL"));
+
+ DoBasicTest(&ListImplementationTest1L,_L("ListImplementationTest1L"));
+ DoBasicTest(&ListImplementationTest2L,_L("ListImplementationTest2L"));
+ DoBasicTest(&ListImplementationTest3L,_L("ListImplementationTest3L"));
+ DoBasicTest(&ListImplementationTest4L,_L("ListImplementationTest4L"));
+ DoBasicTest(&ListImplementationTest5L,_L("ListImplementationTest5L"));
+
+ DoBasicTest(&DummyUidTestL,_L("CreateImplementation and ListImplementation Dummy UID test"));
+
+ // OOM test...
+ test.Printf(_L("OOM tests...\n"));
+
+ DoOOMTest(&GetExtendedInterfaceTest1L,_L("OOM GetExtendedInterfaceTest1L"));
+ // GetExtendedInterfaceTest2L is a special test case, cannot do OOM testing.
+ DoOOMTest(&GetExtendedInterfaceTest3L,_L("OOM GetExtendedInterfaceTest3L"));
+ DoOOMTest(&GetExtendedInterfaceTest4L,_L("OOM GetExtendedInterfaceTest4L"));
+ DoOOMTest(&GetExtendedInterfaceTest5L,_L("OOM GetExtendedInterfaceTest5L"));
+ DoOOMTest(&ReleaseExtendedInterfaceTest1L,_L("OOM ReleaseExtendedInterfaceTest1L"));
+ DoOOMTest(&ReleaseExtendedInterfaceTest2L,_L("OOM ReleaseExtendedInterfaceTest2L"));
+ DoOOMTest(&ListExtendedInterfaceTestL,_L("OOM ListExtendedInterfaceTestL"));
+
+ // CreateImplementationTest1 is a special test case, cannot do OOM testing.
+ DoOOMTest(&CreateImplementationTest2L,_L("OOM CreateImplementationTest2L"));
+ DoOOMTest(&CreateImplementationTest3L,_L("OOM CreateImplementationTest3L"));
+ DoOOMTest(&CreateImplementationTest4L,_L("OOM CreateImplementationTest4L"));
+ DoOOMTest(&CreateImplementationTest5L,_L("OOM CreateImplementationTest5L"));
+ // CreateImplementationTest6 is a special test case, cannot do OOM testing.
+ DoOOMTest(&CreateImplementationTest7L,_L("OOM CreateImplementationTest7L"));
+ DoOOMTest(&DestroyedImplementationTestL,_L("OOM DestroyedImplementationTestL"));
+
+ DoOOMTest(&ListImplementationTest1L,_L("OOM ListImplementationTest1L"));
+ DoOOMTest(&ListImplementationTest2L,_L("OOM ListImplementationTest2L"));
+ DoOOMTest(&ListImplementationTest3L,_L("OOM ListImplementationTest3L"));
+ DoOOMTest(&ListImplementationTest4L,_L("OOM ListImplementationTest4L"));
+ DoOOMTest(&ListImplementationTest5L,_L("OOM ListImplementationTest5L"));
+ }
+
+
+GLDEF_C TInt E32Main()
+ {
+ __UHEAP_MARK;
+ test.Title();
+
+ test.Start(_L("ExtendedInterfaces tests."));
+
+ // get clean-up stack
+ CTrapCleanup* cleanup = CTrapCleanup::New();
+
+ //The reason for the folowing delay is:
+ //ECOM server could be already started. It means that when we copy some
+ //ECOM plugins from Z: to C: drive - ECOM server should look for and
+ //find the new ECOM plugins. The ECOM server uses for that CDiscoverer::CIdleScanningTimer
+ //which is an active object. So the discovering service is asynchronous. We have to
+ //wait some time until it finishes. Otherwise ListImplementationsL could fail to find
+ //requested implementations.
+ User::After(KOneSecond * 5);
+
+ DoTests();
+
+ delete cleanup;
+
+ test.End();
+ test.Close();
+ __UHEAP_MARKEND;
+ return(0);
+ }