// 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 <e32test.h>

 #include <e32math.h>

 #include <bautils.h>

 #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<TUid> 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<TUid> 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<TUid> 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;

 	}