diff -r 000000000000 -r bde4ae8d615e os/ossrv/lowlevellibsandfws/pluginfw/Framework/MagicServerTest/MagicServerTest.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/lowlevellibsandfws/pluginfw/Framework/MagicServerTest/MagicServerTest.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,474 @@ +// Copyright (c) 1997-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: +// CEComServer and CEComSession OOM tests +// +// + +#include +#include +#include +#include "EComServerStart.h" +#include "EComServer.h" +#include "EComServerSession.h" +#include "EcomTestUtils.h" +#include "EcomTestIniFileUtils.h" +#include "ServerStartupManager.h" +#include "Discoverer.h" +#include "DiscovererObserver.h" + +static RTest TheTest(_L("ECOM Server - OOM test")); +const TUid KCExampleInterfaceUid = {0x10009DC0}; +static RFs TheFs; + +static void KillEComServerL() + { + //Need to ensure that the EComServer process is killed before even starting this test by using + //the EComTestUtils library + _LIT(KEComServerProcessName,"ecomserver"); + TRAPD(error, EComTestUtils::KillProcessL(KEComServerProcessName)); + error=error; + } + +// +// +//Test macroes and functions +// +// + +static void Check(TInt aValue, TInt aLine) + { + if(!aValue) + { + TheTest(EFalse, aLine); + } + } +static void Check(TInt aValue, TInt aExpected, TInt aLine) + { + if(aValue != aExpected) + { + RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue); + TheTest(EFalse, aLine); + } + } +#define TEST(arg) ::Check((arg), __LINE__) +#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__) + +// +// + +void NewLC_OOMTestL() + { + TInt processHandlesS = 0; + TInt threadHandlesS = 0; + TInt processHandlesE = 0; + TInt threadHandlesE = 0; + RThread().HandleCount(processHandlesS, threadHandlesS); + for(TInt count=1;;count +=100) + { + // Setting Heap failure for OOM test + __UHEAP_SETFAIL(RHeap::EDeterministic, count); + __UHEAP_MARK; + + CEComServer* ecomServer = NULL; + TRAPD(err, ecomServer = CEComServer::NewLC(); + CleanupStack::PopAndDestroy(ecomServer)); + if(err == KErrNoMemory) + { + __UHEAP_MARKEND; + } + else if(err == KErrNone) + { + __UHEAP_MARKEND; + RDebug::Print(_L("The test succeeded at heap failure rate=%d.\n"), count); + break; + } + else + { + __UHEAP_MARKEND; + TEST2(err, KErrNone); + } + __UHEAP_RESET; + } + __UHEAP_RESET; + RThread().HandleCount(processHandlesE, threadHandlesE); + TEST(processHandlesS == processHandlesE); + TEST(threadHandlesS == threadHandlesE); + } + +void ListImplementations_OOMTestL() + { + TInt processHandlesS = 0; + TInt threadHandlesS = 0; + TInt processHandlesE = 0; + TInt threadHandlesE = 0; + RThread().HandleCount(processHandlesS, threadHandlesS); + + + for(TInt count=1;;++count) + { + CEComServer* ecomServer = CEComServer::NewLC(); + // Setting Heap failure for OOM test + __UHEAP_SETFAIL(RHeap::EDeterministic, count); + __UHEAP_MARK; + + TClientRequest clientReq; + RArray extendedInterfaces; + CleanupClosePushL(extendedInterfaces); + RImplInfoArray* ifArray=NULL; + TRAPD(err, ifArray = ecomServer->ListImplementationsL(KCExampleInterfaceUid,extendedInterfaces,clientReq)); + CleanupStack::PopAndDestroy(&extendedInterfaces); + if (ifArray!=NULL) + { + ifArray->Close(); + delete ifArray; + } + if(err == KErrNoMemory) + { + CleanupStack::PopAndDestroy(ecomServer); + __UHEAP_MARKEND; + } + else if(err == KErrNone) + { + CleanupStack::PopAndDestroy(ecomServer); + __UHEAP_MARKEND; + //implInfoArray should not be deleted! The caller does not take the ownership. + RDebug::Print(_L("The test succeeded at heap failure rate=%d.\n"), count); + break; + } + else + { + CleanupStack::PopAndDestroy(ecomServer); + __UHEAP_MARKEND; + TEST2(err, KErrNone); + } + __UHEAP_RESET; + } + __UHEAP_RESET; + //CleanupStack::PopAndDestroy(ecomServer); + RThread().HandleCount(processHandlesE, threadHandlesE); + TEST(processHandlesS == processHandlesE); + TEST(threadHandlesS == threadHandlesE); + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-3714 +@SYMTestCaseDesc Tests CEComServer::ListImplementationsL with customer resolver. +@SYMTestPriority High +@SYMTestActions Calls ListImplementationsL(TUid,TUid,const RExtendedInterfacesArray&,const TClientRequest&) + with customer resolver. +@SYMTestExpectedResults No OOM errors. +@SYMDEF DEF111196 +*/ +void ListImplementations_OOMTest1L() + { + TInt processHandlesS = 0; + TInt threadHandlesS = 0; + TInt processHandlesE = 0; + TInt threadHandlesE = 0; + RThread().HandleCount(processHandlesS, threadHandlesS); + + + for(TInt count=1;;++count) + { + CEComServer* ecomServer = CEComServer::NewLC(); + // Setting Heap failure for OOM test + __UHEAP_SETFAIL(RHeap::EDeterministic, count); + __UHEAP_MARK; + + TUid resolverUid = {0x10009DD0}; + + TClientRequest clientReq; + RArray extendedInterfaces; + CleanupClosePushL(extendedInterfaces); + RImplInfoArray* ifArray=NULL; + + TRAPD(err, ifArray = ecomServer->ListImplementationsL(KCExampleInterfaceUid,resolverUid,extendedInterfaces,clientReq)); + CleanupStack::PopAndDestroy(&extendedInterfaces); + if (ifArray!=NULL) + { + ifArray->Close(); + delete ifArray; + } + if(err == KErrNoMemory) + { + CleanupStack::PopAndDestroy(ecomServer); + __UHEAP_MARKEND; + } + else if(err == KErrNone) + { + CleanupStack::PopAndDestroy(ecomServer); + __UHEAP_MARKEND; + //implInfoArray should not be deleted! The caller does not take the ownership. + RDebug::Print(_L("The test succeeded at heap failure rate=%d.\n"), count); + break; + } + else + { + CleanupStack::PopAndDestroy(ecomServer); + __UHEAP_MARKEND; + TEST2(err, KErrNone); + } + __UHEAP_RESET; + } + __UHEAP_RESET; + //CleanupStack::PopAndDestroy(ecomServer); + RThread().HandleCount(processHandlesE, threadHandlesE); + TEST(processHandlesS == processHandlesE); + TEST(threadHandlesS == threadHandlesE); + } + +void GetResolvedDllInfo_OOMTestL() + { + TInt processHandlesS = 0; + TInt threadHandlesS = 0; + TInt processHandlesE = 0; + TInt threadHandlesE = 0; + RThread().HandleCount(processHandlesS, threadHandlesS); + + CEComServer* ecomServer = CEComServer::NewLC(); + TClientRequest clientReq; + RArray extendedInterfaces; + CleanupClosePushL(extendedInterfaces); + RImplInfoArray* implInfoArray = ecomServer->ListImplementationsL(KCExampleInterfaceUid,extendedInterfaces,clientReq); + CleanupStack::PopAndDestroy(&extendedInterfaces); + + TEST(implInfoArray->Count() > 0); + + for(TInt count=1;;++count) + { + // Setting Heap failure for OOM test + __UHEAP_SETFAIL(RHeap::EDeterministic, count); + __UHEAP_MARK; + + TEntry dllInfo; + TUid dtorIdKey; + TClientRequest clntRq; + CImplementationInformation* info = (*implInfoArray)[0]; + TRAPD(err, ecomServer->GetResolvedDllInfoL(info->ImplementationUid(), + dllInfo, dtorIdKey, clntRq)); + if(err == KErrNoMemory) + { + __UHEAP_MARKEND; + } + else if(err == KErrNone) + { + __UHEAP_MARKEND; + RDebug::Print(_L("The test succeeded at heap failure rate=%d.\n"), count); + break; + } + else + { + __UHEAP_MARKEND; + TEST2(err, KErrNone); + } + __UHEAP_RESET; + } + __UHEAP_RESET; + //implInfoArray should be deleted! The caller takes the ownership. + if (implInfoArray!=NULL) + { + implInfoArray->Close(); + delete implInfoArray; + } + CleanupStack::PopAndDestroy(ecomServer); + RThread().HandleCount(processHandlesE, threadHandlesE); + TEST(processHandlesS == processHandlesE); + TEST(threadHandlesS == threadHandlesE); + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-0177 +@SYMTestCaseDesc Check that IsSSA works when ecomsrvr has different values. +@SYMTestPriority High +@SYMTestActions Check that IsSSA returns ETrue when ecomsrvr ini does not exist. + Check that IsSSA returns the value in the ecomsrvr ini file when + the file exists. +@SYMTestExpectedResults The test must not fail. +@SYMPREQ PREQ967 +*/ +void IsSsa_TestL() + { + TInt processHandlesS = 0; + TInt threadHandlesS = 0; + TInt processHandlesE = 0; + TInt threadHandlesE = 0; + RThread().HandleCount(processHandlesS, threadHandlesS); + + TBool res; + + TestEnableDisableSsaL(TheTest, TheFs); + + /*****************************************************************/ + //test that IsSSA() returns ETrue when ecomsrvr.ini file does + //not exist. + + //enable ssa + EnableSsa(TheTest, TheFs); + + //test that IsSSA() returns ETrue + CEComServer* server=CEComServer::NewLC(); + res = server->IsSSA(TheFs); + CleanupStack::PopAndDestroy(); + ResetSsa(TheTest, TheFs); + TEST(res); + + /*****************************************************************/ + //test that IsSSA() returns EFalse when ecomsrvr.ini file exists. + + //disable ssa + DisableSsa(TheTest, TheFs); + + //test that IsSSA() returns EFalse + server=CEComServer::NewLC(); + res = server->IsSSA(TheFs); + CleanupStack::PopAndDestroy(); + ResetSsa(TheTest, TheFs); + TEST(!res); + + RThread().HandleCount(processHandlesE, threadHandlesE); + TEST(processHandlesS == processHandlesE); + TEST(threadHandlesS == threadHandlesE); + } + + +/** +Thread entry point for test thread. +Kills the existing ECOM server and launches a new instance + +*/ +TInt ServerStartThreadEntryL(TAny* /*a*/) + { + __UHEAP_MARK; + + //Threshold set so that a OOM failure occur whilst constructing CEComServer::iRegistryData + const TInt KFailThreshold = 500; + + TInt dummy; + TAny* ptr = NULL; + + ::KillEComServerL(); + + //Invoking OOM failure by allocating most of the heap before running the server + RHeap heap = User::Heap(); + TInt avail = heap.Available(dummy); + ptr = User::Alloc(avail-KFailThreshold); + + TEST(ptr != NULL); //Check that the allocation was sucessful + + TInt result = ServerStart(); + delete ptr; + + __UHEAP_MARKEND; + + return result; + } + +/** +@SYMTestCaseID SYSLIB-ECOM-CT-3163 +@SYMTestCaseDesc Verify the startup behaviour of the ECOM server under OOM conditions +@SYMTestPriority High +@SYMTestActions Generate an OOM condition. + Create a new thread which will launch the ECOM server. + Wait for the thread to exit and check the thread exit type + and reason to verify behaviour. +@SYMTestExpectedResults The test must not fail. +@SYMDEF DEF094675 +*/ +void StartServer_OOMTest() + { + + _LIT(KStartThreadName,"Server Start Thread"); + + //Create a new thread to launch the ECOM server + RThread testThread; + testThread.Create(KStartThreadName, ServerStartThreadEntryL, + KDefaultStackSize,KMinHeapSize,KMinHeapSize,NULL); + TRequestStatus status; + testThread.Logon(status); + testThread.Resume(); + + //Wait for the thread to exit + User::WaitForRequest(status); + + //Obtain exit type and reason for test thread + TExitType exitType = testThread.ExitType(); + TInt exitReason = testThread.ExitReason(); + + //close the thread handle + testThread.Close(); + + //Verify the exit reason and exit code + //Exit type is TExitType::EExitKill when E32Main() exit normally + TEST(exitType == EExitKill); + TEST(exitReason == KErrNoMemory); + + } + +void DoTestL() + { + TheTest.Start(_L("CEComServer::NewLC - OOM test")); + ::NewLC_OOMTestL(); + + TheTest.Next(_L("CEComServer::ListImplementationsL - OOM test")); + ::ListImplementations_OOMTestL(); + + TheTest.Next(_L("CEComServer::GetResolvedDllInfoL - OOM test")); + ::GetResolvedDllInfo_OOMTestL(); + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0177 CEComServer::IsSsa test ")); + ::IsSsa_TestL(); + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3163 Server Startup Panic test ")); + ::StartServer_OOMTest(); + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3714 CEComServer::ListImplementationsL with customer resolver - OOM test ")); + ::ListImplementations_OOMTest1L(); + + } + +TInt E32Main() + { + __UHEAP_MARK; + + ::KillEComServerL(); + + CTrapCleanup* tc = CTrapCleanup::New(); + TEST(tc != NULL); + + TEST2(TheFs.Connect(), KErrNone); + + CActiveScheduler* activeSched = new CActiveScheduler; + TEST(activeSched != NULL); + CActiveScheduler::Install(activeSched); + + TheTest.Title(); + TRAPD(err, ::DoTestL()); + TEST2(err, KErrNone); + + ResetSsa(TheTest, TheFs); + + TheTest.End(); + TheTest.Close(); + + delete activeSched; + + TheFs.Close(); + + delete tc; + + __UHEAP_MARKEND; + + User::Heap().Check(); + return KErrNone; + }