// 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;
	}