diff -r 000000000000 -r bde4ae8d615e os/ossrv/lowlevellibsandfws/pluginfw/Framework/SuicideTests/t_suicide.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/lowlevellibsandfws/pluginfw/Framework/SuicideTests/t_suicide.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,620 @@ +// Copyright (c) 2005-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 tests for testing resolver related +// functionality linking against ecom.lib, i.e. using public API +// Where necessary stubs are implemented to help in writing test +// harness using RTest. +// This test assumes the following setup: +// DLL /Dll UID +// EComExample /10009DB1 on Z: +// EComExample2/10009DB3 on Z: +// EComExample3/101F8477 on Z: +// EComExample4/101F8479 on Z: +// EComExample5/101F847B on C: +// Suicidal /10009DB2 on Z: +// EComExample6/0x101F847D on Z: +// The tests work by checking that the correct implementations are chosen +// for interface 0x10009DC0 depending on parameters passed +// Implementations: +// Impl ID On C: On Z: e.g:Version/Default_data/dll_uid +// 10009DC3 - Ver 1/"text/ wml"/10009DB1, Ver 2/"text/ wml"/10009DB3 +// 10009DC4 - Ver 1/"text/ *"/10009DB1, Ver 2/"text/ *"/10009DB3 +// 101F8478 - Ver 1/""/101F8477 +// 101F847A - Ver 1/""/101F8479 +// 101F847C Ver 1/""/101F847B - +// 10009DC5 - Ver 1/"Suicide"/10009DB2 +// 101F847E on Z Ver 1/""/101F847D +// +// + +#include +#include "EComUidCodes.h" +#include "Interface.h" // interface to Plugins +#include "../EcomTestUtils/EcomTestUtils.h" + +#include +#include +#include + +LOCAL_D RTest test(_L("t_suicide.exe")); + +LOCAL_D CTrapCleanup* TheTrapCleanup = NULL; + +LOCAL_D CActiveScheduler* TheActiveScheduler = NULL; + +// Used for supressing warning in OOM tests +#define __UNUSED_VAR(var) var = var + +const TInt KOneSecond = 1000000; + +// Interface ID used for testing +const TUid KUidInterface = {0x10009DC0}; + +// Resolver ID used for testing +const TUid KUidResolver = {0x10009DD0}; + +// Implementaion ID used for testing +const TUid KUidTestImplementation = {0x10009DC5}; + +// Interface Implementation Uids used for testing +const TInt KUidImplementation1 = 0x10009DC3; +const TInt KUidImplementation2 = 0x10009DC4; +const TInt KUidImplementation3 = 0x10009DC5; +const TInt KUidImplementation4 = 0x101F8478; +const TInt KUidImplementation5 = 0x101F847A; +const TInt KUidImplementation6 = 0x101F847C; +const TInt KUidImplementation7 = 0x101F847E; + +// Match string used for testing +_LIT8(KInterfaceResolveMatchStr,"suicidal"); + +_LIT(KSysBinDirectoryWildcard, "c:\\sys\\bin\\*.dll"); +_LIT(KResourceDirectoryWildcard, "c:\\resource\\plugins\\*.rsc"); + +// Plugins used for this test program +_LIT(KEComExample5OnZ, "z:\\RAMOnly\\EComExample5.dll"); + +_LIT(KEComExample5OnC, "c:\\sys\\bin\\EComExample5.dll"); +_LIT(KEComExample5RscOnC, "c:\\resource\\plugins\\EComExample5.rsc"); +_LIT(KEComExample4OnC, "c:\\sys\\bin\\EComExample4.dll"); +_LIT(KEComExample4RscOnC, "c:\\resource\\plugins\\EComExample4.rsc"); +// ROM file copied to the RAM for test purposes +_LIT(KEComExample5RscOnZ, "z:\\RAMOnly\\EComExample5.rsc"); + + +// Utility clean up function +LOCAL_C void CleanupEComArray(TAny* aArray); + +//It is used by some test methods which are called two times: +//from normal test and from OOM test. +static void LeaveIfErrNoMemory(TInt aError) + { + if(aError == KErrNoMemory) + { + REComSession::FinalClose(); + User::Leave(aError); + } + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-0709 +@SYMTestCaseDesc Tests for creation of plugin with resolver match string +@SYMTestPriority High +@SYMTestActions Checks for no error condition +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +LOCAL_C void TestCreateImplSuicideL() + { + // Tests creation of plugin with resolver match string + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0709 ")); + + /* This should pick + 10009DC5 Ver 1/"Suicide"/10009DB2 + */ + CExampleInterface* interfaceimpl = NULL; + TRAPD(err, interfaceimpl = CExampleInterface::NewL(KInterfaceResolveMatchStr())); + ::LeaveIfErrNoMemory(err); + test(err == KErrNone); + CleanupStack::PushL(interfaceimpl); + + test(KUidTestImplementation == interfaceimpl->ImplId()); + + TRAP(err, interfaceimpl->DoMethodL()); + ::LeaveIfErrNoMemory(err); + test(err == KErrNone); + + CleanupStack::PopAndDestroy(interfaceimpl); + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-0710 +@SYMTestCaseDesc Tests for Listing all Implementations for the Interface KUidInterface +@SYMTestPriority High +@SYMTestActions Calls up REComSession::ListImplementationsL with interface UID.Picks up 6 implementations. + Checks for no memory exceptions. +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +LOCAL_C void TestListAllImplL() + { + // Test for Listing all Implementations for the Interface KUidInterface + // + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0710 ")); + + RImplInfoPtrArray ifArray; + CleanupStack::PushL(TCleanupItem(CleanupEComArray, &ifArray)); + + TRAPD(err, REComSession::ListImplementationsL(KUidInterface, ifArray)); + ::LeaveIfErrNoMemory(err); + test(err == KErrNone); + + /* This should pick 6 implementations given below + 10009DC3 Ver 2/"text/ wml"/10009DB3 + 10009DC4 Ver 2/"text/ *"/10009DB3 + 101F8478 Ver 1/""/101F8477 + 101F847A Ver 1/""/101F8479 + 101F847C Ver 1/""/101F847B + 10009DC5 Ver 1/"Suicide"/10009DB2 + 101F847E Ver 1/""/101F847D + */ + + const TInt availCount = ifArray.Count(); + test.Printf(_L("Found %d implementations.\n"),availCount); + test(availCount == 7); + + 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()==EDriveZ); + break; + + case KUidImplementation2: + test(info->Version()==2); + test(info->Drive()==EDriveZ); + break; + + case KUidImplementation3: + test(info->Version()==1); + test(info->Drive()==EDriveZ); + break; + + case KUidImplementation4: + test(info->Version()==1); + test(info->Drive()==EDriveZ); + break; + + case KUidImplementation5: + test(info->Version()==1); + test(info->Drive()==EDriveZ); + break; + + case KUidImplementation6: + test(info->Version()==1); + test(info->Drive()==EDriveC); + break; + + case KUidImplementation7: + test(info->Version()==1); + test(info->Drive()==EDriveZ); + break; + + default: + test.Printf(_L("Unknown implementation Uid\n")); + test(EFalse); + } + } + // Empty the array of implementations + CleanupStack::PopAndDestroy();//ifArray, results in a call to CleanupEComArray + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-0711 +@SYMTestCaseDesc Tests to list all implementations for an interface with specified + match string and wildcard match +@SYMTestPriority High +@SYMTestActions Calls up REComSession::ListImplementationsL with interface UID and resolver matching characteristics + Checks for no memory exceptions. +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +LOCAL_C void TestListImplMatchStrWildcardL() + { + // Test to list all implementations for an interface with match string + // and wildcard match + // + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0711 ")); + + TEComResolverParams resolverParams; + _LIT8(KImplementationTest,"text/wml"); + resolverParams.SetDataType(KImplementationTest());//Match string + resolverParams.SetGenericMatch(ETrue); // Allow wildcard matching + + RImplInfoPtrArray ifArray; + CleanupStack::PushL(TCleanupItem(CleanupEComArray, &ifArray)); + + TRAPD(err, REComSession::ListImplementationsL(KUidInterface, resolverParams, ifArray)); + ::LeaveIfErrNoMemory(err); + test(err == KErrNone); + + /* This should pick 2 implementations given below + 10009DC3 Ver 2/"text/ wml"/10009DB3 + 10009DC4 Ver 2/"text/ *"/10009DB3 + */ + + const TInt availCount = ifArray.Count(); + test.Printf(_L("Found %d implementations.\n"),availCount); + test(availCount == 2); + + 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()==EDriveZ); + break; + + case KUidImplementation2: + test(info->Version()==2); + test(info->Drive()==EDriveZ); + break; + + default: + test.Printf(_L("Unknown implementation UID\n")); + test(EFalse); + } + } + + // Empty the array of implementations + CleanupStack::PopAndDestroy();//ifArray, results in a call to CleanupEComArray + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-0712 +@SYMTestCaseDesc Tests to list all implementations for an interface with specified + match string and no wildcard match +@SYMTestPriority High +@SYMTestActions Calls up REComSession::ListImplementationsL with interface UID and resolver matching characteristics + Checks for no memory exceptions. +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +LOCAL_C void TestListImplMatchStrL() + { + // Test to list all implementations for an interface with specified + // match string and no wildcard match + // + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0712 ")); + + TEComResolverParams resolverParams; + _LIT8(KImplementationTest,"text/wml"); + resolverParams.SetDataType(KImplementationTest());//Match string + resolverParams.SetGenericMatch(EFalse); // Don't allow wildcard matching + + RImplInfoPtrArray ifArray; + CleanupStack::PushL(TCleanupItem(CleanupEComArray, &ifArray)); + + TRAPD(err, REComSession::ListImplementationsL(KUidInterface, resolverParams, ifArray)); + ::LeaveIfErrNoMemory(err); + test(err == KErrNone); + + const TInt availCount = ifArray.Count(); + test.Printf(_L("Found %d implementations.\n"),availCount); + test(availCount == 1); + + /* This should pick + 10009DC3 Ver 2/"text/wml"/10009DB3 + */ + + 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()==EDriveZ); + break; + + default: + test.Printf(_L("Unknown implementation Uid\n")); + test(EFalse); + } + } + // Empty the array of implementations + CleanupStack::PopAndDestroy();//ifArray, results in a call to CleanupEComArray + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-0713 +@SYMTestCaseDesc Tests to list all Implementations for an Interface with specified + Resolver ID, Match String and Wildcard match +@SYMTestPriority High +@SYMTestActions Calls up REComSession::ListImplementationsL with interface UID Resolver ID, matching characteristics + Checks for no memory exceptions. +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +LOCAL_C void TestListAllImplResolverIDL() + { + // Test to list all Implementations for an Interface with specified + // Resolver ID, Match String and Wildcard match + // + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0713 ")); + + TEComResolverParams resolverParams; + resolverParams.SetDataType(KInterfaceResolveMatchStr()); + resolverParams.SetGenericMatch(ETrue); // Allow wildcard matching + + RImplInfoPtrArray ifArray; + CleanupStack::PushL(TCleanupItem(CleanupEComArray, &ifArray)); + + TRAPD(err, REComSession::ListImplementationsL(KUidInterface, + resolverParams, + KUidResolver, + ifArray)); + ::LeaveIfErrNoMemory(err); + test(err == KErrNone); + + const TInt availCount = ifArray.Count(); + test.Printf(_L("Found %d implementations.\n"), availCount); + test(availCount == 1); + + /* This should pick + 10009DC5 Ver 1/"Suicide"/10009DB2 + */ + + 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 KUidImplementation3: + test(info->Version()==1); + test(info->Drive()==EDriveZ); + break; + + default: + test.Printf(_L("Unknown implementation UID\n")); + test(EFalse); + } + } + + // Empty the array of implementations + CleanupStack::PopAndDestroy();//ifArray, results in a call to CleanupEComArray + } + +typedef void (*ClassFuncPtrL) (void); + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-0714 +@SYMTestCaseDesc Function to call all test functions +@SYMTestPriority High +@SYMTestActions Calls up test function and checks for handle counts. +@SYMTestExpectedResults The test must not fail. +@SYMREQ REQ0000 +*/ +/** +Wrapper function to call all test functions + +@param testFuncL 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-0714 ")); + test.Next(aTestDesc); + + __UHEAP_MARK; + // find out the number of open handles + TInt startProcessHandleCount; + TInt startThreadHandleCount; + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount); + + //Call the test function + (*testFuncL)(); + + REComSession::FinalClose(); + + // check that no handles have leaked + TInt endProcessHandleCount; + TInt endThreadHandleCount; + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount); + + test(startThreadHandleCount == endThreadHandleCount); + + __UHEAP_MARKEND; + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-0715 +@SYMTestCaseDesc Wrapper function to call all OOM test functions +@SYMTestPriority High +@SYMTestActions Calls up test function and checks for handle counts. +@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 DoOOMTest(ClassFuncPtrL testFuncL, const TDesC& aTestDesc) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0715 ")); + test.Next(aTestDesc); + + TInt err, tryCount = 0; + do + { + __UHEAP_MARK; + // find out the number of open handles + TInt startProcessHandleCount; + TInt startThreadHandleCount; + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount); + + // Setting Heap failure for OOM test + __UHEAP_SETFAIL(RHeap::EDeterministic, ++tryCount); + + TRAP(err, (*testFuncL)()); + + __UHEAP_SETFAIL(RHeap::ENone, 0); + + // release handles + if(err == KErrNone) + { + REComSession::FinalClose(); + } + + // 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; + + // Basic tests + DoBasicTestL(TestCreateImplSuicideL, _L("TestCreateImplSuicideL")); + DoBasicTestL(TestListImplMatchStrL, _L("TestListImplMatchStrL")); + DoBasicTestL(TestListImplMatchStrWildcardL, _L("TestListImplMatchStrWildcardL")); + DoBasicTestL(TestListAllImplL, _L("TestListAllImplL")); + DoBasicTestL(TestListAllImplResolverIDL, _L("TestListAllImplResolverIDL")); + + // OOM tests + DoOOMTest(TestCreateImplSuicideL, _L("OOM TestCreateImplSuicide")); + DoOOMTest(TestListImplMatchStrL, _L("OOM TestListImplMatchStr")); + DoOOMTest(TestListImplMatchStrWildcardL, _L("OOM TestListImplMatchStrWildcard")); + DoOOMTest(TestListAllImplL, _L("OOM TestListAllImpl")); + DoOOMTest(TestListAllImplResolverIDL, _L("OOM TestListAllImplResolverID")); + + __UHEAP_MARKEND; + } + +// This function is used for cleanup support of locally declared arrays +LOCAL_C void CleanupEComArray(TAny* aArray) + { + (static_cast(aArray))->ResetAndDestroy(); + } + +// Deleting plugin from the RAM for cleanup purpose +inline LOCAL_C void DeleteTestPlugins() + { + TRAPD(err, EComTestUtils::FileManDeleteFileL(KSysBinDirectoryWildcard)); + TRAP(err, EComTestUtils::FileManDeleteFileL(KResourceDirectoryWildcard)); + } + +// Copies the Plugins to specific folder for testing purpose +LOCAL_C void CopyPlugins() + { + DeleteTestPlugins(); + + TRAPD(err, EComTestUtils::FileManCopyFileL(KEComExample5OnZ, KEComExample5OnC)); + test(err==KErrNone); + + TRAP(err, EComTestUtils::FileManCopyFileL(KEComExample5RscOnZ, KEComExample5RscOnC)); + test(err==KErrNone); + + // KEComExample4OnC & KEComExample4RscOnC are copied to C: Drive for + // testing in t_listimplementation test program. These files should + // be present in Z:. Please make sure these are present in Z only. + TRAP(err, EComTestUtils::FileManDeleteFileL(KEComExample4OnC)); + TRAP(err, EComTestUtils::FileManDeleteFileL(KEComExample4RscOnC)); + } + + +//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("Suicide Tests")); + + TheTrapCleanup = CTrapCleanup::New(); + TRAPD(err, SetupL()); + test(err == KErrNone); + + CopyPlugins(); + // 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 an active object, + // which scans plugin directories. 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 + DeleteTestPlugins(); + + delete TheActiveScheduler; + delete TheTrapCleanup; + + test.End(); + test.Close(); + + __UHEAP_MARKEND; + return (KErrNone); + }