// Copyright (c) 1996-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:

//

#include <s32file.h>

#include <graphics/bitmapuid.h>

#include "../sfbs/UTILS.H"

#include "TFBS.H"

#include "TALLOC.H"

#include "../sfbs/fbsbitmapasyncstreamer.h"

#include "fbsmessage.h"

#include "fbsdefs.h"

const TSize KLargeSize(4096 + 100, 1);

const TSize KLargeSizeAlt(4096 + 200, 2);

const TSize KSmallSize(10, 10);

const TSize KSmallSizeAlt(20, 20);

CTAlloc::CTAlloc(CTestStep* aStep):

	CTGraphicsBase(aStep), 

	iFbs(NULL),

	iStore(NULL),

	iBitmap(NULL),

	iBitmap2(NULL)

	{

	INFO_PRINTF1(_L("Font/Bitmap Server Alloc Failure Recovery Testing"));

	}

CTAlloc::~CTAlloc()

	{

	if (iShutdownFbs)

		{

		iFbs->SendCommand(EFbsMessShutdown);

		}

	iFbs->Disconnect();

	delete iStore;

	}

void CTAlloc::ConstructL()

	{

	iStore = CFbsTypefaceStore::NewL(NULL);

	if(RFbsSession::Connect()==KErrNone)

		{

		RFbsSession::Disconnect();

		iShutdownFbs = EFalse;

		}

	else

		{

		FbsStartup();

		iShutdownFbs = ETrue;

		}

	}

void CTAlloc::RunTestCaseL(TInt aCurTestCase)

	{

	((CTAllocStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

	switch(aCurTestCase)

		{

	case 1:

		((CTAllocStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0511"));

		Session();

		break;

	case 2:

		{

/**

	@SYMTestCaseID GRAPHICS-FBSERV-0611

*/

		((CTAllocStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0611"));

		TInt ret = RFbsSession::Connect();

		TEST2(ret, KErrNone);

		iFbs = RFbsSession::GetSession();

		TEST(iFbs != NULL);

		}

		break;

	case 4:

		((CTAllocStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0512"));

		BitmapsL();

		break;

	case 5:

		((CTAllocStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0514"));

		BitmapHandlerL();

		break;

	case 6:

		((CTAllocStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0513"));

		TypefaceStoreL();

		break;

	case 7:

		((CTAllocStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-0515"));

		FontStoreL();

		break;

	case 8:

		((CTAllocStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

		((CTAllocStep*)iStep)->CloseTMSGraphicsStep();

		TestComplete();

		break;

	default:

		((CTAllocStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

		break;

		}

	((CTAllocStep*)iStep)->RecordTestResultL();

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0511

	@SYMTestCaseDesc

	Allocated sessions with the FbsServer and simulates memory allocation errors

	@SYMTestActions

	Checks the heap

	@SYMTestExpectedResults

	Test should pass

*/

void CTAlloc::Session()

	{

	INFO_PRINTF1(_L("RFbsSession::Connect()\r\n"));

	for (TInt count = 1; ; count++)

		{

		__UHEAP_FAILNEXT(count);

		__UHEAP_MARK;

		TInt ret = RFbsSession::Connect();

		if (ret == KErrNoMemory)

			{

			__UHEAP_MARKEND;

			}

		else if (ret == KErrNone)

			{

			RFbsSession::Disconnect();

			__UHEAP_MARKEND;

			break;

			}

		else 

			{

			__UHEAP_MARKEND;

			TEST2(ret, KErrNone);

			}

		}

	__UHEAP_RESET;

	}

/**

	@SYMTestCaseID

	GRAPHICS-FBSERV-0512

	@SYMTestCaseDesc

	Creates bitmaps in different ways and checks if memory allocation succeeded 

	@SYMTestActions

	Creates normal size bitmaps, large bitmaps, loads bitmaps, loads shared bitmaps,

	duplicated bitmaps, resizes bitmaps, compresses bitmaps, externalized bitmaps to write store, 

	internalizes bitmaps back again from write store. All ways of creating bitmaps are tested

	against Out Of Memory error conditions	

	@SYMTestExpectedResults

	Test should pass

*/

void CTAlloc::BitmapsL()

	{

	TInt heapMarkCheckFlag;	

	if( !iStep->GetIntFromConfig(KDefaultSectionName, KFbsHeapMarkCheckFlag, heapMarkCheckFlag) )

		{

		INFO_PRINTF1(_L("Error reading ini file"));

		User::Leave(KErrNotFound);

		}

	CFbsBitmap iBitmap;

	CFbsBitmap iBitmap2;

	iTestBitmapName = KTestBitmapOnZ;

	TInt ret = iBitmap.Load(iTestBitmapName,ETfbs,NULL);

	TEST2(ret, KErrNone);

	ret = iBitmap.Create(KLargeSize,EColor256); // Expand server caches

	TEST2(ret, KErrNone);

	iBitmap.Reset();

	TInt count;

// Create bitmap

	INFO_PRINTF1(_L("CFbsBitmap::Create()\r\n"));

	for (count = 1; ; count++)

		{

		iFbs->SendCommand(EFbsMessDefaultAllocFail,count);

		if(heapMarkCheckFlag)

			{

			iFbs->SendCommand(EFbsMessDefaultMark);

			iFbs->SendCommand(EFbsMessUserMark);

			}

		ret = iBitmap.Create(KSmallSize,EColor256);

		if (ret == KErrNoMemory)

			{

			if(heapMarkCheckFlag)

				{

				iFbs->SendCommand(EFbsMessDefaultMark);

				iFbs->SendCommand(EFbsMessUserMark);

				}

			}

		else if (ret == KErrNone)

			{

			iBitmap.Reset();

			if(heapMarkCheckFlag)

				{

				iFbs->SendCommand(EFbsMessDefaultMark);

				iFbs->SendCommand(EFbsMessUserMark);

				}

			break;

			}

		else 

			TEST2(ret, KErrNone);

		}

	iFbs->SendCommand(EFbsMessDefaultAllocFail,0);

	iFbs->SendCommand(EFbsMessUserAllocFail,0);

	TEST(iFbs->ResourceCount()==0);

	for (count = 1; ; count++)

		{

		iFbs->SendCommand(EFbsMessUserAllocFail,count);

		if(heapMarkCheckFlag)

			{

			iFbs->SendCommand(EFbsMessDefaultMark);

			iFbs->SendCommand(EFbsMessUserMark);

			}

		ret=iBitmap.Create(KSmallSize,EGray2);

		if (ret == KErrNoMemory)

			{

			if(heapMarkCheckFlag)

				{

				iFbs->SendCommand(EFbsMessDefaultMarkEnd);

				iFbs->SendCommand(EFbsMessUserMarkEnd);

				}

			}

		else if (ret == KErrNone)

			{

			iBitmap.Reset();

			if(heapMarkCheckFlag)

				{

				iFbs->SendCommand(EFbsMessDefaultMarkEnd);

				iFbs->SendCommand(EFbsMessUserMarkEnd);

				}

			break;

			}

		else 

			TEST2(ret, KErrNone);

		}

	iFbs->SendCommand(EFbsMessDefaultAllocFail,0);

	iFbs->SendCommand(EFbsMessUserAllocFail,0);

	TEST(iFbs->ResourceCount()==0);

// Create (large)

	for (count = 1; ; count++)

		{

		iFbs->SendCommand(EFbsMessDefaultAllocFail,count);

		if(heapMarkCheckFlag)

			{

			iFbs->SendCommand(EFbsMessDefaultMark);

			iFbs->SendCommand(EFbsMessUserMark);

			}

		ret = iBitmap.Create(KLargeSize,EColor256);

		if (ret == KErrNoMemory)

			{

			if(heapMarkCheckFlag)

				{

				iFbs->SendCommand(EFbsMessDefaultMarkEnd);

				iFbs->SendCommand(EFbsMessUserMarkEnd);

				}

			}

		else if (ret == KErrNone)

			{

			iBitmap.Reset();

			if(heapMarkCheckFlag)

				{

				iFbs->SendCommand(EFbsMessDefaultMarkEnd);

				iFbs->SendCommand(EFbsMessUserMarkEnd);

				}

			break;

			}

		else 

			TEST2(ret, KErrNone);

		}

	iFbs->SendCommand(EFbsMessDefaultAllocFail,0);

	iFbs->SendCommand(EFbsMessUserAllocFail,0);

	TEST(iFbs->ResourceCount()==0);

	for (count = 1; ; count++)

		{

		iFbs->SendCommand(EFbsMessUserAllocFail,count);

		if(heapMarkCheckFlag)

			{

			iFbs->SendCommand(EFbsMessDefaultMark);

			iFbs->SendCommand(EFbsMessUserMark);

			}

		ret = iBitmap.Create(KLargeSize,EColor256);

		if (ret == KErrNoMemory)

			{

			if(heapMarkCheckFlag)

				{

				iFbs->SendCommand(EFbsMessDefaultMarkEnd);

				iFbs->SendCommand(EFbsMessUserMarkEnd);

				}

			}

		else if (ret == KErrNone)

			{

			iBitmap.Reset();

			if(heapMarkCheckFlag)

				{

				iFbs->SendCommand(EFbsMessDefaultMarkEnd);

				iFbs->SendCommand(EFbsMessUserMarkEnd);

				}

			break;

			}

		else 

			TEST2(ret, KErrNone);

		}

	iFbs->SendCommand(EFbsMessDefaultAllocFail,0);

	iFbs->SendCommand(EFbsMessUserAllocFail,0);

	TEST(iFbs->ResourceCount()==0);

// Load

	INFO_PRINTF1(_L("CFbsBitmap::Load()\r\n"));

	ret = iBitmap.Load(iTestBitmapName,ETfbs,NULL);

	TEST2(ret, KErrNone);

	iBitmap.Reset();

	for (count = 1; ; count++)

		{

		iFbs->SendCommand(EFbsMessDefaultAllocFail,count);

		if(heapMarkCheckFlag)

			{

			iFbs->SendCommand(EFbsMessDefaultMark);

			iFbs->SendCommand(EFbsMessUserMark);

			}

		ret = iBitmap.Load(iTestBitmapName,ETfbs,NULL);

		if (ret == KErrNoMemory)

			{

			if(heapMarkCheckFlag)

				{

				iFbs->SendCommand(EFbsMessDefaultMarkEnd);

				iFbs->SendCommand(EFbsMessUserMarkEnd);

				}

			}

		else if (ret == KErrNone)

			{

			iBitmap.Reset();

			if(heapMarkCheckFlag)

				{

				iFbs->SendCommand(EFbsMessDefaultMarkEnd);

				iFbs->SendCommand(EFbsMessUserMarkEnd);

				}

			break;

			}

		else 

			TEST2(ret, KErrNone);

		}

	iFbs->SendCommand(EFbsMessDefaultAllocFail,0);

	iFbs->SendCommand(EFbsMessUserAllocFail,0);

	TEST(iFbs->ResourceCount()==0);

	for (count = 1; ; count++)

		{

		iFbs->SendCommand(EFbsMessUserAllocFail,count);

		if(heapMarkCheckFlag)

			{

			iFbs->SendCommand(EFbsMessDefaultMark);

			iFbs->SendCommand(EFbsMessUserMark);

			}

		ret = iBitmap.Load(iTestBitmapName,ETfbs,NULL);

		if (ret == KErrNoMemory)

			{

			if(heapMarkCheckFlag)

				{

				iFbs->SendCommand(EFbsMessDefaultMarkEnd);

				iFbs->SendCommand(EFbsMessUserMarkEnd);

				}

			}

		else if (ret == KErrNone)

			{

			iBitmap.Reset();

			if(heapMarkCheckFlag)

				{

				iFbs->SendCommand(EFbsMessDefaultMarkEnd);

				iFbs->SendCommand(EFbsMessUserMarkEnd);

				}

			break;

			}

		else 

			TEST2(ret, KErrNone);

	}

	iFbs->SendCommand(EFbsMessDefaultAllocFail,0);

	iFbs->SendCommand(EFbsMessUserAllocFail,0);

	TEST(iFbs->ResourceCount()==0);

// Load (shared)

	INFO_PRINTF1(_L("CFbsBitmap::Load() - shared \r\n"));

	// Do an initial load to ensure the StreamId cache does not get updated whilst OOM testing

	ret = iBitmap.Load(iTestBitmapName,ETfbs,ETrue);

	TEST2(ret, KErrNone);

	iBitmap.Reset();

	for (count = 1; ; count++)

		{

		iFbs->SendCommand(EFbsMessDefaultAllocFail,count);

		if(heapMarkCheckFlag)

			{

			iFbs->SendCommand(EFbsMessDefaultMark);

			iFbs->SendCommand(EFbsMessUserMark);

			}

		ret = iBitmap.Load(iTestBitmapName,ETfbs,ETrue);

		if (ret == KErrNoMemory)

			{

			if(heapMarkCheckFlag)

				{

				iFbs->SendCommand(EFbsMessDefaultMarkEnd);

				iFbs->SendCommand(EFbsMessUserMarkEnd);

				}

			continue;

			}

		else if (ret != KErrNone)

			TEST2(ret, KErrNone);

		ret = iBitmap2.Load(iTestBitmapName,ETfbs,ETrue);	

		if (ret == KErrNoMemory)

			{

			iBitmap.Reset();

			if(heapMarkCheckFlag)

				{

				iFbs->SendCommand(EFbsMessDefaultMarkEnd);

				iFbs->SendCommand(EFbsMessUserMarkEnd);

				}

			continue;

			}

		else if (ret == KErrNone)

			{

			iBitmap.Reset();	

			iBitmap2.Reset();

			if(heapMarkCheckFlag)

				{

				iFbs->SendCommand(EFbsMessDefaultMarkEnd);

				iFbs->SendCommand(EFbsMessUserMarkEnd);

				}

			break;

			}

		else 

			TEST2(ret, KErrNone);		

		}

	iFbs->SendCommand(EFbsMessDefaultAllocFail,0);

	iFbs->SendCommand(EFbsMessUserAllocFail,0);

	TEST(iFbs->ResourceCount()==0);

	for (count = 1; ; count++)

		{

		iFbs->SendCommand(EFbsMessUserAllocFail,count);

		if(heapMarkCheckFlag)

			{

			iFbs->SendCommand(EFbsMessDefaultMark);

			iFbs->SendCommand(EFbsMessUserMark);

			}

		ret = iBitmap.Load(iTestBitmapName,ETfbs,ETrue);

		if (ret == KErrNoMemory)

			{

			if(heapMarkCheckFlag)

				{

				iFbs->SendCommand(EFbsMessDefaultMarkEnd);

				iFbs->SendCommand(EFbsMessUserMarkEnd);

				}

			continue;

			}

		else if (ret != KErrNone)

			TEST2(ret, KErrNone);

		ret = iBitmap2.Load(iTestBitmapName,ETfbs,ETrue);

		if (ret == KErrNoMemory)

			{

			iBitmap.Reset();

			if(heapMarkCheckFlag)

				{

				iFbs->SendCommand(EFbsMessDefaultMarkEnd);

				iFbs->SendCommand(EFbsMessUserMarkEnd);

				}

			continue;

			}

		else if (ret == KErrNone)

			{

			iBitmap.Reset();

			iBitmap2.Reset();

			if(heapMarkCheckFlag)