diff -r e20de85af2ee -r ce057bb09d0b lowlevellibsandfws/pluginfw/Framework/ResolverTest/t_resolver.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lowlevellibsandfws/pluginfw/Framework/ResolverTest/t_resolver.cpp Fri Jun 04 16:20:51 2010 +0100 @@ -0,0 +1,808 @@ +// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// This file contains test classes and their implementations that test +// class CDefaultResolver. Demonstrates a simple set of derived class +// implementations using RTest. +// +// + +#include +#include "EComUidCodes.h" +#include "RegistryData.h" +#include "Registrar.h" +#include "RegistrarObserver.h" +#include "EComResolverParams.h" +#include "DefaultResolver.h" +#include "../EcomTestUtils/EcomTestUtils.h" +#include "DriveInfo.h" +#include "RegistryResolveTransaction.h" + + +#include +#include +#include +#include + +// Used for suppressing warning in OOM tests +#define __UNUSED_VAR(var) var = var + +// Used for OOM test +#define TEST_OOM_ERR if(err == KErrNoMemory) User::Leave(err) + +// Interface Uids used within tests +const TUid KCExampleInterfaceUid = {0x10009DC0}; +const TUid KCExampleInterfaceImp = {0x10009DC1}; +const TInt KOneSecond = 1000000; + +// Interface Implementation Uids used for testing +const TInt KUidImplementation1 = 0x10009DC3; +const TInt KUidImplementation2 = 0x10009DC4; + +// Dlls copied to RAM for testing purpose +_LIT(KEComExDllOnZ, "z:\\RAMOnly\\EComExample5.dll"); + +// Contains .rsc files of dlls that be copied to RAM +// for testing purpose +_LIT(KEComExDllOnC, "c:\\sys\\bin\\EComExample5.dll"); +_LIT(KEComRscFileOnZ, "z:\\RAMOnly\\EComExample5.rsc"); +_LIT(KEComRscFileOnC, "c:\\resource\\plugins\\EComExample5.rsc"); + +_LIT(KEComExampleDllOnC, "C:\\sys\\bin\\EComExample.dll"); +_LIT(KEComExample2DllOnC, "C:\\sys\\bin\\EComExample2.dll"); +_LIT(KEComExample3DllOnC, "C:\\sys\\bin\\EComExample3.dll"); + +_LIT(KEComExampleRscOnC, "C:\\resource\\plugins\\EComExample.rsc"); +_LIT(KEComExample2RscOnC, "C:\\resource\\plugins\\EComExample2.rsc"); +_LIT(KEComExample3RscOnC, "C:\\resource\\plugins\\EComExample3.rsc"); + +_LIT(KEComExampleRscOnZ, "Z:\\RAMOnly\\EComExample.rsc"); +_LIT(KEComExample2RscOnZ, "Z:\\RAMOnly\\EComExample2.rsc"); +_LIT(KEComExample3RscOnZ, "Z:\\RAMOnly\\EComExample3.rsc"); + + +_LIT(KEComExampleDllOnZ, "Z:\\RAMOnly\\EComExample.dll"); +_LIT(KEComExample2DllOnZ, "Z:\\RAMOnly\\EComExample2.dll"); +_LIT(KEComExample3DllOnZ, "Z:\\RAMOnly\\EComExample3.dll"); + +// Datatype on implementations that .rsc file contains +_LIT8(KResolveMatchType, "text/wml"); +// Datatype to look for +_LIT8(KResolveImplementationType, "text/wml||data"); + +LOCAL_D CTrapCleanup* TheTrapCleanup=NULL; + +LOCAL_D CActiveScheduler* TheActiveScheduler=NULL; + +LOCAL_D RFs TheFs; + +LOCAL_D RTest test(_L("t_resolver.exe")); + +//LOCAL_D TCapabilitySet dummycaps; +// Utility clean up function +LOCAL_C void CleanupEComPtrArray(TAny* aArray); + +/** +This friend class allows us to access private and protected members of production +code class CDefaultResolver +*/ +class TDefaultResolver_StateAccessor + { +public: + //Auxiliary methods that provide access to private members + TBool Match(CDefaultResolver& aResolver, + const TDesC8& aImplementationType, + const TDesC8& aMatchType, + TBool aIsGeneric) const; + + TUid Resolve(CDefaultResolver& aResolver, + RImplInfoArray& aImplementationInfo, + const TEComResolverParams& aAdditionalParameters) const; + }; + +/** +Searches for a match of a data type on an implementation type. +Match returns ETrue if aMatchType is found within aImplementationType +@param aResolver resolver object on which implementations are matched +@param aImplementationType The implementation data type to search for a match +@param aMatchType Search data that identifies/matches to implementations +@param aIsGeneric ETrue if wildcard matching is allowed +@return TBool ETrue if a match is found, EFalse if match is not found +*/ +TBool TDefaultResolver_StateAccessor::Match(CDefaultResolver& aResolver, + const TDesC8& aImplementationType, + const TDesC8& aMatchType, + TBool aIsGeneric) const + { + return aResolver.Match(aImplementationType, aMatchType, aIsGeneric); + } + +/** +Selects an appropriate implementation from a list of possibles +@param aResolver resolver object on which implementations are resolved +@param aImplementationInfo Information on the potential implementations +@param aAdditionalParameters The data to match against to determine the + implementation +@return The Uid of a suitable implementation +*/ +TUid TDefaultResolver_StateAccessor::Resolve(CDefaultResolver& aResolver, + RImplInfoArray& aImplementationInfo, + const TEComResolverParams& aAdditionalParameters) const + { + return aResolver.Resolve(aImplementationInfo, aAdditionalParameters); + } + +/** +The implementation of the abstract Registrar Observer class, +used for recieving notifications of registry changes. +Stub class(for CEComServer) used for the creation of CRegistrar class object. +CEComServer class acts as observer for CRegistrar. +*/ +class CTestRegistrarObserver : public MRegistrarObserver + { +public: + // This function is used by RegistrarObserver (i.e.CEComServer) to notify its + // clients(REComSession objects) that some change has happened in Registry. + // Here we have no clients to notify, so no implementaion. + void Notification( TInt /*aNotification*/ ) {} + }; + +/** +Test class encloses necessary members that aid to test CDefaultResolver +*/ +class CResolverTest: public CBase + { +public: + static CResolverTest* NewL(); + virtual ~CResolverTest(); + + void IdentifyImplementationTestL(); + void ListAllTestL(); + void MatchTest(); + void ResolveTestL(); + +private: + CResolverTest(); + void ConstructL(); + +public: + /** The instance of the class under test */ + CDefaultResolver* iDefaultResolver; + /** The data store which is used by the resolver */ + CRegistryData* iRegistryData; + /** Friend class pointer used for accessing private members */ + TDefaultResolver_StateAccessor* iStateAccessor; + /** An array of potential implementations to resolve between */ + RImplInfoArray iImplementationData; + /** ECom example interface Uid */ + TUid iInterfaceUid; + /** The Uid returned by IdentifyImplementationL(), used to resolve + the implementation. */ + TUid iResolvedImpUid; + /** Additional parameters used for resolving between implementations */ + TEComResolverParams iAdditionalParameters; + /** CRegistrar */ + CRegistrar* iRegistrar; + /** Registrar observer test class */ + CTestRegistrarObserver* iRegistrarObserver; + /** CRegistryResolveTransaction */ + CRegistryResolveTransaction* iRegistryResolveTransaction; + /** ExtendedInterfaces List*/ + RArray iExtendedInterfaces; + /** Client Request*/ + TClientRequest iClientReq; + }; + +/** +Create a CResolverTest object on the CleanupStack +@return A pointer to the newly created class. +*/ +CResolverTest* CResolverTest::NewL() + { + CResolverTest* self = new (ELeave) CResolverTest(); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + +/** +Standardized default constructor +@post CRegistrarTest is fully constructed. +*/ +CResolverTest::CResolverTest() +: CBase() + { + // Interface uid to find implemenations + iInterfaceUid.iUid = KCExampleInterfaceUid.iUid; + } + +/** +Standardized 2nd(Initialization) phase of two phase construction. +Completes the safe construction of the CResolverTest object +@post CRegistrarTest is fully constructed. +@leave KErrNoMemory. +*/ +void CResolverTest::ConstructL() + { + iStateAccessor = new(ELeave) TDefaultResolver_StateAccessor; + iRegistryData = CRegistryData::NewL(TheFs); + iRegistrarObserver=new (ELeave) CTestRegistrarObserver; + // construct the registry resolve transaction object here + TBool capability= ETrue; + iRegistryResolveTransaction = CRegistryResolveTransaction::NewL(*iRegistryData,iExtendedInterfaces,iClientReq,capability); + iRegistrar=CRegistrar::NewL(*iRegistryData, *iRegistrarObserver, TheFs); + iRegistrar->ProcessSSAEventL(EStartupStateNonCritical); + // next the default resolver + iDefaultResolver = CDefaultResolver::NewL(*iRegistryResolveTransaction); + } + +/** +Standardized default destructor +@post This object is properly destroyed. +*/ +CResolverTest::~CResolverTest() + { + delete iStateAccessor; + delete iDefaultResolver; + delete iRegistrar; + delete iRegistrarObserver; + delete iRegistryData; + delete iRegistryResolveTransaction; + iExtendedInterfaces.Close(); + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-0659 +@SYMTestCaseDesc Create and delete Resolver object test +@SYMTestPriority High +@SYMTestActions Creates and deletes the resolver object +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +LOCAL_C void CreateDeleteTestL() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0659 CreateDeleteTestL ")); + // + // Creates and deletes resolver object + // ------------------------------------------------------------------ + // + // Set up for heap leak checking + __UHEAP_MARK; + // and leaking thread handles + TInt startProcessHandleCount; + TInt startThreadHandleCount; + TInt endProcessHandleCount; + TInt endThreadHandleCount; + + // Test Starts... + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount); + + CResolverTest* theTest=NULL; + + TRAPD(err, theTest = CResolverTest::NewL()); + test(err == KErrNone); + delete theTest; + + // Check for open handles + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount); + test(startThreadHandleCount == endThreadHandleCount); + + // Test Ends... + __UHEAP_MARKEND; + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-1324 +@SYMTestCaseDesc Tests for CDefaultResolver::IdentifyImplementationL() function +@SYMTestPriority High +@SYMTestActions Tests that the resolver identifies most appropriate + interface implementation +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +void CResolverTest::IdentifyImplementationTestL() + { + // Tests that the resolver identifies most appropriate + // interface implementation + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1324 ")); + iAdditionalParameters.SetDataType(KResolveMatchType); + iAdditionalParameters.SetGenericMatch(ETrue);//Allow wildcard matching + TRAPD(err, iResolvedImpUid = + iDefaultResolver->IdentifyImplementationL(iInterfaceUid, iAdditionalParameters)); + TEST_OOM_ERR; + test(err == KErrNone); + // Check the Appropriate implementation id that should be identified + test(iResolvedImpUid.iUid == KUidImplementation1); + + test.Printf(_L("Interface Uid 0x%08x\n"), iInterfaceUid); + test.Printf(_L("Resolved Implementation Uid = 0x%08x\n"), iResolvedImpUid); + + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-1325 +@SYMTestCaseDesc Tests for CDefaultResolver::ListAllL() function +@SYMTestPriority High +@SYMTestActions The test executes by sending an interface id and data type to match. + Prints all the implementation for the interface id +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +void CResolverTest::ListAllTestL() + { + // Tests that ListAll() lists implementations for a specified interface + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1325 ")); + + // set datatype to text/wml and enable wildcard match + iAdditionalParameters.SetDataType(KResolveMatchType); + iAdditionalParameters.SetGenericMatch(ETrue); + RImplInfoArray* implData=NULL; + + /* This should list two implementations given below + depending on additional parameter and wildcard match + 10009DC3 Ver 2/"text/ wml"/10009DB3 + 10009DC4 Ver 2/"text/ *"/10009DB3 + */ + TRAPD(err, implData = iDefaultResolver->ListAllL(iInterfaceUid, iAdditionalParameters)); + + TEST_OOM_ERR; + test(err == KErrNone); + CleanupStack::PushL(TCleanupItem(CleanupEComPtrArray, implData)); + + const TInt availCount = implData->Count(); + test(availCount == 2); + + test.Printf(_L("Found %d implementations.\n"),availCount); + + for (TInt count=0;countDrive().Name(); + test.Printf(_L("%d. uid={%x} version=%d on drive %S\n"), count+1, + info->ImplementationUid(), info->Version(), &driveName); + + switch(info->ImplementationUid().iUid) + { + case KUidImplementation1: + test(info->Version()==2); + test(info->Drive()==EDriveC); + break; + + case KUidImplementation2: + test(info->Version()==2); + test(info->Drive()==EDriveC); + break; + + default: + test.Printf(_L("Mismatched implementation Uid\n")); + test(EFalse); + } + } + // Empty the array of implementations + CleanupStack::PopAndDestroy();//ifArray, results in a call to CleanupEComPtrArray + + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-1326 +@SYMTestCaseDesc Tests for TDefaultResolver_StateAccessor::Match() function +@SYMTestPriority High +@SYMTestActions The test executes by searching for a match of a data type on an implementation type +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +void CResolverTest::MatchTest() + { + // 1.Search using search parameters that result in a Match to a particular + // Implementation. + // 2.Search using search parameters that result in a mismatch. + // 3.Finally, search using search parameters with wildcards that result in a Match + + // Searches for KResolveMatchType (text/wml) on implementations + // KResolveImplementationType(text/wml||data) + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1326 ")); + TBool matchResult = iStateAccessor->Match(*iDefaultResolver, + KResolveImplementationType, + KResolveMatchType, + EFalse); + test(matchResult); + + _LIT8(KUnResolveableImplType, "Abc||xyz"); + // Pass data "Abc||xyz" which is not present on implementation type + // to look for and test for failure + matchResult = iStateAccessor->Match(*iDefaultResolver, + KUnResolveableImplType, + KResolveMatchType, + EFalse); + test(!matchResult); + + // Wild card in data type + _LIT8(KResolveWildImplType, "text*||xyz"); + + // Set to enable wild card search and test for success + matchResult = iStateAccessor->Match(*iDefaultResolver, + KResolveWildImplType, + KResolveMatchType, + ETrue); + test(matchResult); + + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-1327 +@SYMTestCaseDesc Tests the TDefaultResolver_StateAccessor::Resolve() function +@SYMTestPriority High +@SYMTestActions The test executes by sending an implementation data with additional parameter +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +void CResolverTest::ResolveTestL() + { + // Resolves a appropriate implementation from a list of possibles + + // Create iImplementationType on heap so that address can be passed to + // CImplementationInformation::NewL method + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-1327 ")); + HBufC8* implementationType = HBufC8::NewL(KResolveImplementationType().Length()); + CleanupStack::PushL(implementationType); + TPtr8 impPtr = implementationType->Des(); + impPtr = KResolveImplementationType; + + // Interface Uid to create an item of implementation data + iResolvedImpUid.iUid=KCExampleInterfaceImp.iUid; + + TDriveUnit drive(EDriveC); + CImplementationInformation* impData = CImplementationInformation::NewL(iResolvedImpUid, + 0, + NULL, + implementationType, + NULL, + drive, + EFalse, + EFalse); + // Pop now before pushing impData since ownership is not with it + CleanupStack::Pop(implementationType); + CleanupStack::PushL(impData); + // Add implementation data so that you can resolve the same + User::LeaveIfError(iImplementationData.Append(impData)); + CleanupStack::Pop(impData); + + // set datatype to text/wml and enable wildcard match + iAdditionalParameters.SetDataType(KResolveMatchType); + iAdditionalParameters.SetGenericMatch(ETrue); + + // Newly resolved id + TUid resolvedUid; + TRAPD(err, resolvedUid = iStateAccessor->Resolve(*iDefaultResolver, + iImplementationData, + iAdditionalParameters)); + TEST_OOM_ERR; + test(err == KErrNone); + // confirm newly created interface id + test(resolvedUid == iResolvedImpUid); + + // Logging and cleaning up the array elements + while(iImplementationData.Count()) + { + // Fetch the address at first location and empty it + CImplementationInformation* impInfo = iImplementationData[0]; + test.Printf(_L("Resolved Uid is 0x%x \n"), impInfo->ImplementationUid()); + iImplementationData.Remove(0); + delete impInfo; + } + iImplementationData.Reset(); + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-0660 +@SYMTestCaseDesc Tests for OOM while create and delete test +@SYMTestPriority High +@SYMTestActions Calls the CResolverTest test function +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +LOCAL_C void OOMCreateDeleteTest() + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0660 OOM CreateDeleteTest")); + TInt err; + TInt failAt = 1; + __UNUSED_VAR(failAt); + + CResolverTest* resolverTest = NULL; + + do + { + __UHEAP_MARK; + // find out the number of open handles + TInt startProcessHandleCount; + TInt startThreadHandleCount; + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount); + + __UHEAP_SETFAIL(RHeap::EDeterministic, failAt+=100); + + TRAP(err, resolverTest = CResolverTest::NewL()); + + __UHEAP_SETFAIL(RHeap::ENone, 0); + + delete resolverTest; + resolverTest = NULL; + + // check that no handles have leaked + TInt endProcessHandleCount; + TInt endThreadHandleCount; + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount); + + test(startProcessHandleCount == endProcessHandleCount); + test(startThreadHandleCount == endThreadHandleCount); + + __UHEAP_MARKEND; + } + while(err == KErrNoMemory); + + test.Printf(_L("- Succeeded at heap failure rate of %i\n"), failAt); + test(err == KErrNone); + } + +// Type definition for pointer to member function. +// Used in calling the CResolverTest member function for testing. +typedef void (CResolverTest::*ClassFuncPtrL) (void); + +/** +This function is used to force a discovery prior to the tests commencing. +*/ +LOCAL_C void ForceDiscovery() + { + CTestRegistrarObserver* registrarObserver = new (ELeave) CTestRegistrarObserver; + CleanupStack::PushL(registrarObserver); + CRegistryData* registryData = CRegistryData::NewL(TheFs); + CleanupStack::PushL(registryData); + CRegistrar* registrar = CRegistrar::NewL(*registryData, *registrarObserver, TheFs); + CleanupStack::PushL(registrar); + registrar->ProcessSSAEventL(EStartupStateNonCritical); + + CleanupStack::PopAndDestroy(registrar); + CleanupStack::PopAndDestroy(registryData); + CleanupStack::PopAndDestroy(registrarObserver); + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-0661 +@SYMTestCaseDesc Wrapper function which calls other test functions +@SYMTestPriority High +@SYMTestActions Calls the CResolverTest test function +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +/** +Wrapper function to call all test functions + +@param testFunc pointer to test function +@param aTestDesc test function name +*/ +LOCAL_C void DoBasicTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0661 ")); + test.Next(aTestDesc); + + __UHEAP_MARK; + // find out the number of open handles + TInt startProcessHandleCount; + TInt startThreadHandleCount; + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount); + + CResolverTest* resolverTest = CResolverTest::NewL(); + CleanupStack::PushL(resolverTest); + + (resolverTest->*testFuncL)(); + + CleanupStack::PopAndDestroy(resolverTest); + + // check that no handles have leaked + TInt endProcessHandleCount; + TInt endThreadHandleCount; + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount); + + test(startProcessHandleCount == endProcessHandleCount); + test(startThreadHandleCount == endThreadHandleCount); + + __UHEAP_MARKEND; + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-0662 +@SYMTestCaseDesc Function to call all OOM test functions +@SYMTestPriority High +@SYMTestActions Calls the CResolverTest test function +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +/** +Wrapper function to call all OOM test functions + +@param testFuncL pointer to OOM test function +@param aTestDesc test function name +*/ +LOCAL_C void DoOOMTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0662 ")); + test.Next(aTestDesc); + + TInt err; + TInt tryCount = 0; + do + { + __UHEAP_MARK; + // find out the number of open handles + TInt startProcessHandleCount; + TInt startThreadHandleCount; + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount); + + CResolverTest* resolverTest = CResolverTest::NewL(); + CleanupStack::PushL(resolverTest); + + __UHEAP_SETFAIL(RHeap::EDeterministic, ++tryCount); + + TRAP(err, (resolverTest->*testFuncL)()); + + __UHEAP_SETFAIL(RHeap::ENone, 0); + + CleanupStack::PopAndDestroy(resolverTest); + resolverTest = NULL; + // check that no handles have leaked + TInt endProcessHandleCount; + TInt endThreadHandleCount; + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount); + + test(startProcessHandleCount == endProcessHandleCount); + test(startThreadHandleCount == endThreadHandleCount); + + __UHEAP_MARKEND; + } while(err == KErrNoMemory); + + test(err == KErrNone); + test.Printf(_L("- server succeeded at heap failure rate of %i\n"), tryCount); + } + +LOCAL_C void DoTestsL() + { + __UHEAP_MARK; + + // Force a discovery to ensure that the ecom.dat file is updated with the data from the plugins + // required for this test. The plugins for this test are copied by calling CopyPlugins() from E32Main(). + // They are deleted by calling DeleteTestPlugin() also from E32Main(). + ForceDiscovery(); + + // Basic tests + CreateDeleteTestL(); + DoBasicTestL(&CResolverTest::IdentifyImplementationTestL, _L("Identify implementation test")); + DoBasicTestL(&CResolverTest::ListAllTestL, _L("ListAllTestL")); + DoBasicTestL(&CResolverTest::MatchTest, _L("MatchTest")); + DoBasicTestL(&CResolverTest::ResolveTestL, _L("ResolveTestL")); + + // OOM tests + OOMCreateDeleteTest(); + DoOOMTestL(&CResolverTest::IdentifyImplementationTestL, _L("OOM IdentifyImplementationTestL")); + DoOOMTestL(&CResolverTest::ListAllTestL, _L("OOM ListAllTestL")); + DoOOMTestL(&CResolverTest::MatchTest, _L("OOM MatchTest")); + DoOOMTestL(&CResolverTest::ResolveTestL, _L("OOM ResolveTestL")); + + __UHEAP_MARKEND; + } + +/** +This function is used for cleanup support of locally declared arrays +*/ +LOCAL_C void CleanupEComPtrArray(TAny* aArray) + { + + (static_cast(aArray))->Reset(); + delete aArray;// delete here + + } + +/** +Copies the Plugins to specific folder for testing purpose +*/ +LOCAL_C void CopyPlugins() + { + // Copy the dlls and .rsc files on to RAM + TRAPD(err, EComTestUtils::FileManCopyFileL(KEComExDllOnZ, KEComExDllOnC)); + test(err==KErrNone); + + TRAP(err, EComTestUtils::FileManCopyFileL(KEComRscFileOnZ, KEComRscFileOnC)); + test(err==KErrNone); + + TRAP(err, EComTestUtils::FileManCopyFileL(KEComExampleDllOnZ, KEComExampleDllOnC)); + test(err==KErrNone); + TRAP(err, EComTestUtils::FileManCopyFileL(KEComExample2DllOnZ, KEComExample2DllOnC)); + test(err==KErrNone); + TRAP(err, EComTestUtils::FileManCopyFileL(KEComExample3DllOnZ, KEComExample3DllOnC)); + test(err==KErrNone); + + TRAP(err, EComTestUtils::FileManCopyFileL(KEComExampleRscOnZ, KEComExampleRscOnC)); + test(err==KErrNone); + TRAP(err, EComTestUtils::FileManCopyFileL(KEComExample2RscOnZ, KEComExample2RscOnC)); + test(err==KErrNone); + TRAP(err, EComTestUtils::FileManCopyFileL(KEComExample3RscOnZ, KEComExample3RscOnC)); + test(err==KErrNone); + } + +// Deleting plugin from the RAM for cleanup purpose +inline LOCAL_C void DeleteTestPlugin() + { + TRAPD(err, EComTestUtils::FileManDeleteFileL(KEComExDllOnC)); + TRAP(err, EComTestUtils::FileManDeleteFileL(KEComRscFileOnC)); + TRAP(err, EComTestUtils::FileManDeleteFileL(KEComExampleDllOnC)); + TRAP(err, EComTestUtils::FileManDeleteFileL(KEComExample2DllOnC)); + TRAP(err, EComTestUtils::FileManDeleteFileL(KEComExample3DllOnC)); + TRAP(err, EComTestUtils::FileManDeleteFileL(KEComExampleRscOnC)); + TRAP(err, EComTestUtils::FileManDeleteFileL(KEComExample2RscOnC)); + TRAP(err, EComTestUtils::FileManDeleteFileL(KEComExample3RscOnC)); + } + +//Initialise the Active Scheduler +LOCAL_C void SetupL() + { + // Construct and install the Active Scheduler. The Active Schedular is needed + // by components used by this test as they are ActiveObjects. + TheActiveScheduler = new(ELeave)CActiveScheduler; + CActiveScheduler::Install(TheActiveScheduler); + } + + +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + + test.Printf(_L("\n")); + test.Title(); + test.Start(_L("Resolver Tests")); + + TheTrapCleanup = CTrapCleanup::New(); + + TRAPD(err, SetupL()); + test(err == KErrNone); + + // Connect the file server instance + User::LeaveIfError(TheFs.Connect()); + + CopyPlugins(); + + // Wait, so that ECom server looks for plugins copied from Z: to C drive + // 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 * 3); + + TRAP(err, DoTestsL()); + test(err == KErrNone); + + // Cleanup files. If the cleanup fails that is no problem, + // as any subsequent tests will replace them. The only downside + // would be the disk not being tidied + DeleteTestPlugin(); + + TheFs.Close(); + delete TheTrapCleanup; + delete TheActiveScheduler; + test.End(); + test.Close(); + + __UHEAP_MARKEND; + return(KErrNone); + }