/*

* Copyright (c) 2006-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 "FNTSTD.H"

#include "t_linkedfontsmemory.h"

#include "T_LinkedFonts2.h"

#include "fbsmessage.h"

#include <hal.h>

#include <linkedfonts.h>

class CTLinkedFontsMemory : public CTLinkedFonts2

	{

public:

	CTLinkedFontsMemory(CTestStep* aStep);

	~CTLinkedFontsMemory();

	//base class static void TestPanic(TInt aPanic);

protected:

// From CTGraphicsStep

	virtual void RunTestCaseL(TInt aCurTestCase);

private:

	TInt TestLinkedFontsMemory1L(TInt aTypefaces);

	void TestLinkedFontsMemory1L();

	TInt TestLinkedFontsCreateLinkedTypefacesL(const TDesC& aName,TInt aTypefaces);

	TInt TestLinkedFontsMemory_Part2(const TDesC& aName);

	void TestLinkedFontsMemory2();

	void TestLinkedFontsMemory3();

	void TestLinkedFontsMemory4();

	void TestMemoryUsage();

	void SetHeapFail(RFbsSession::THeapFailType aType, TInt aFailures);

	TInt HeapCount(RFbsSession::THeapFailType aType);

	void SetHeapReset(RFbsSession::THeapFailType aType);

	void SetHeapCheck(RFbsSession::THeapFailType aType);

	void TestCompareText();

	TInt FontAndBitmapServerSharedHeap();

	void DisplayRamInfo(const TDesC &aTextInfo) const;

	TBool CheckRasterizerInstalledL();

	};

CTLinkedFontsMemory::CTLinkedFontsMemory(CTestStep* aStep)

	:	CTLinkedFonts2(aStep)

	{

	}	

CTLinkedFontsMemory::~CTLinkedFontsMemory()

	{

	}

void CTLinkedFontsMemory::SetHeapFail(RFbsSession::THeapFailType aType, TInt aFailures)

	{

	__ASSERT_ALWAYS(iFbs, TestPanic(KErrGeneral));

	iFbs->SendCommand(EFbsMessSetHeapFail, aType, aFailures);

	}

TInt CTLinkedFontsMemory::HeapCount(RFbsSession::THeapFailType aType)

	{

	__ASSERT_ALWAYS(iFbs, TestPanic(KErrGeneral));

	return iFbs->SendCommand(EFbsMessHeapCount, aType);

	}

void CTLinkedFontsMemory::SetHeapReset(RFbsSession::THeapFailType aType)

	{

	__ASSERT_ALWAYS(iFbs, TestPanic(KErrGeneral));

	iFbs->SendCommand(EFbsMessSetHeapReset, aType);

	}

void CTLinkedFontsMemory::SetHeapCheck(RFbsSession::THeapFailType aType)

	{

	__ASSERT_ALWAYS(iFbs, TestPanic(KErrGeneral));

	iFbs->SendCommand(EFbsMessSetHeapCheck, aType);

	}

TInt CTLinkedFontsMemory::FontAndBitmapServerSharedHeap()

	{

	__ASSERT_ALWAYS(iFbs, TestPanic(KErrGeneral));

	return iFbs->SendCommand(EFbsMessHeap);

	}

_LIT(KLinkedFontsMemoryTestFont,"MemTestLinkedFnt");

TBool CTLinkedFontsMemory::CheckRasterizerInstalledL()

	{

	CFbsTypefaceStore* store = CFbsTypefaceStore::NewL(iDev);

	CleanupStack::PushL(store);

	// Create typeface to be linked

	CLinkedTypefaceSpecification *typefaceSpec;

	typefaceSpec = CLinkedTypefaceSpecification::NewLC(KLinkedFontsMemoryTestFont);

	CLinkedTypefaceGroup* group1 = CLinkedTypefaceGroup::NewLC(1);

	typefaceSpec->AddLinkedTypefaceGroupL(*group1);

	CleanupStack::Pop();

	// Add first typeface

	CLinkedTypefaceElementSpec *elementSpec1;

	_LIT(KLinkedTypefaceTT, "DejaVu Sans Condensed");

	elementSpec1 = CLinkedTypefaceElementSpec::NewLC(KLinkedTypefaceTT, 1);

	elementSpec1->SetCanonical(ETrue);

	typefaceSpec->AddTypefaceAtBackL(*elementSpec1);

	CleanupStack::Pop(1, elementSpec1);

	// Now try regstering the linked typeface

	TRAPD(ret, typefaceSpec->RegisterLinkedTypefaceL(*store));

	CleanupStack::PopAndDestroy(2, store);

	switch (ret)

		{

		case KErrAlreadyExists:

		case KErrNone:

			return ETrue;

		default:

			INFO_PRINTF1(_L("Linked fonts memory: no linked fonts rasterizer found"));

			return EFalse;

		}

	}

_LIT(KDrawMe, "lInKED FOnTS");

void CTLinkedFontsMemory::TestCompareText()

	{

	_LIT(KWithout, "WithoutLinkedFontTT");

	TTypeface typeface;

	typeface.iName = KWithout;

	TFontSpec fs;

	fs.iTypeface = typeface;

	fs.iHeight = 20;

	CFbsFont* font = NULL;

	TInt err1 = iDev->GetNearestFontToDesignHeightInPixels(font, fs);

	if (font && err1 == KErrNone)

		{

		// Use the font

		TSize scrSize = iDev->SizeInPixels();

		iGc->UseFont(font);

		iGc->DrawText(KDrawMe, TPoint((scrSize.iWidth / 2) + 50, 50));

		iGc->DiscardFont();

		iDev->ReleaseFont(font);

		TPoint left(0, 0);

		TPoint right(scrSize.iWidth / 2, 0);

		TBool val = iDev->RectCompare(TRect(left, TPoint(scrSize.iWidth / 2, scrSize.iHeight)), *iDev,TRect(right, TPoint(scrSize.iWidth, scrSize.iHeight)));

		if (!val)

			{

			iGc->DrawRect(TRect(left, TPoint(scrSize.iWidth / 2, scrSize.iHeight)));

			iGc->DrawRect(TRect(right, TPoint(scrSize.iWidth, scrSize.iHeight)));

			}

		TEST(val);

		}

	else

		{

		TEST(0);  //there is a failure

		}

	}

/** these fonts need to be provided, and are used for creating linked typefaces

TLinkedFont1.ttf

Typeface name: LinkedFont1

This will be the dominant font. It contains 178 characters.

Some of the characters (13) are deleted from this file and separated in to other three files.

Characters missing are F, D, J, M, P, S, V, X, Z, a, n, l, y.

TLinkedFont2.ttf

Typeface name: LinkedFont2

Characters available (7):	F, J, M, S, Z, a, y.

TLinkedFont3.ttf

Typeface name: LinkedFont3

Characters available (4):	D, P, x, l

TLinkedFont4.ttf

Typeface name: LinkedFont4

Characters available (2):	V, n

TWithoutLinkedFont.ttf

Typeface name: WithoutLinkedFont

Characters available:	It contains 191 characters U+0020-U+007E and U+00A0-U+00FF

*/	

_LIT(KLinkedFont1, "LinkedFont1TT");

_LIT(KLinkedFont2, "LinkedFont2TT");

_LIT(KLinkedFont3, "LinkedFont3TT");

_LIT(KLinkedFont4, "LinkedFont4TT");

/** Memory test helper function to create different typefaces.  Function adds from 1 to four

 typefaces.

*/

TInt CTLinkedFontsMemory::TestLinkedFontsCreateLinkedTypefacesL(const TDesC &aName,TInt aTypefaces)

	{

	TInt ret = KErrNone;

	CLinkedTypefaceSpecification *typefaceSpec;

	typefaceSpec = CLinkedTypefaceSpecification::NewLC(aName);

	CLinkedTypefaceGroup* group1;

	group1 = CLinkedTypefaceGroup::NewLC(1); //may well leave, function trapped, groupID = 1

	typefaceSpec->AddLinkedTypefaceGroupL(*group1);

	CleanupStack::Pop(); //pop the group, now referenced via typeface

	CLinkedTypefaceElementSpec *elementSpec1;

	elementSpec1 = CLinkedTypefaceElementSpec::NewLC(KLinkedFont1, 1);	

	elementSpec1->SetCanonical(ETrue);

	typefaceSpec->AddTypefaceAtBackL(*elementSpec1);

	CleanupStack::Pop();  //pop the element, now referenced via typeface

	// Create and add second linked typeface

	if (aTypefaces>=2)

		{

		CLinkedTypefaceElementSpec *elementSpec2;

		elementSpec2 = CLinkedTypefaceElementSpec::NewLC(KLinkedFont2, 1);	

		typefaceSpec->AddTypefaceAtBackL(*elementSpec2);

		CleanupStack::Pop();  //pop the element, now referenced via typeface

		}

	// Create and add third typeface to be linked

	if (aTypefaces>=3)

		{

		CLinkedTypefaceElementSpec *elementSpec3;

		elementSpec3 = CLinkedTypefaceElementSpec::NewLC(KLinkedFont3, 1);	

		typefaceSpec->AddTypefaceAtBackL(*elementSpec3);

		CleanupStack::Pop();  //pop the element, now referenced via typeface

		}

	// Create and add fourth typeface to be linked

	if (aTypefaces>=4)

		{

		CLinkedTypefaceElementSpec *elementSpec4;

		elementSpec4 = CLinkedTypefaceElementSpec::NewLC(KLinkedFont4, 1);	

		TRAP(ret,typefaceSpec->AddTypefaceAtBackL(*elementSpec4));

		CleanupStack::Pop();  //pop the element, now referenced via typeface

		}

	// Try registering the typeface

	CFbsTypefaceStore* store = CFbsTypefaceStore::NewL(iDev);

	CleanupStack::PushL(store);

	typefaceSpec->RegisterLinkedTypefaceL(*store);

	CleanupStack::PopAndDestroy(2, typefaceSpec); //store and typefaceSpec

	return ret;

	}

/** This is the function which does the operations which are tested, called from OOM loop

 * in general the function does not return a low memory error; the function just leaves.

 * An exception may be for registration.

*/

TInt CTLinkedFontsMemory::TestLinkedFontsMemory1L(TInt aTypefaces)

	{

	TInt ret = KErrNone;

	//these are for the linked typefaces

	_LIT(KLinkedTypeface1, "LinkedMem1-1"); //has LinkedFont1

	_LIT(KLinkedTypeface2, "LinkedMem1-2"); //has LinkedFont1, LinkedFont2

	_LIT(KLinkedTypeface3, "LinkedMem1-3"); //has LinkedFont1, LinkedFont2, LinkedFont3

	_LIT(KLinkedTypeface4, "LinkedMem1-4"); //has LinkedFont1, LinkedFont2, LinkedFont3, LinkedFont4	

	// Create canonical typeface to be linked

	switch (aTypefaces)

		{

		case 1:

			ret = TestLinkedFontsCreateLinkedTypefacesL(KLinkedTypeface1,1);

			break;

		case 2:

			ret = TestLinkedFontsCreateLinkedTypefacesL(KLinkedTypeface2,2);

			break;

		case 3:

			ret = TestLinkedFontsCreateLinkedTypefacesL(KLinkedTypeface3,3);

			break;

		case 4:

			ret = TestLinkedFontsCreateLinkedTypefacesL(KLinkedTypeface4,4);

			break;

		default:

			__ASSERT_ALWAYS(ETrue,Panic(EFntTypefaceIndexOutOfRange));

			break;

		}

	RDebug::Printf("%d TestLinkedFontsMemory1L(%d)", ret, aTypefaces);

	return ret;

	}

/**

   @SYMTestCaseID			GRAPHICS-FNTSTORE-LINKEDFONTS-0102

   @SYMPREQ					PREQ2146

   @SYMREQ					REQ10924, REQ10925, REQ10926

   @SYMTestCaseDesc			To ensure that a linked typeface can be created and registered 

   							without memory leaks, under low memory conditions. 

   @SYMTestPriority			Critical

   @SYMTestStatus			Implemented

   @SYMTestActions			(1) Create an OOM loop,	setting this process's heap memory to fail.

   								testing the client side heap memory allocation.

								In the loop create and register a linked typeface with 1-4

								typefaces

   @SYMTestExpectedResults	(1) - There are no memory leaks, and the test exits the OOM loop.

*/

void CTLinkedFontsMemory::TestLinkedFontsMemory1L()

	{

	TInt failures;

	INFO_PRINTF1(_L("TestLinkedFontsMemory"));

	TInt steps;

	for (steps=1;steps<=4;steps++)

		{

		for (failures = 1; ; failures++)

			{

			__UHEAP_SETFAIL(RHeap::EDeterministic,failures);

			__UHEAP_MARK;

			// Test steps

			TInt err;

			TInt val = KErrNone;

			TRAP(err, val= TestLinkedFontsMemory1L(steps));

			__UHEAP_CHECK(0);

			__UHEAP_RESET;

			__UHEAP_MARKEND;

			if (err == KErrNotFound)

				{

				INFO_PRINTF3(_L("Failure below occurred on Step %i; failure=%i"), steps, failures);

				TEST(EFalse);

				break;

				}

			if ((err == KErrNone) && (val == KErrNone))

				{

				break;

				}

			}

		}

	}

/**

   @SYMTestCaseID			GRAPHICS-FNTSTORE-LINKEDFONTS-0103

   @SYMPREQ					PREQ2146

   @SYMREQ					REQ10924, REQ10925, REQ10926

   @SYMTestCaseDesc			To ensure that a linked typeface can be created and fonts created

							and used without memory leaks, under low memory conditions

   @SYMTestPriority			Critical

   @SYMTestStatus			Implemented

   @SYMTestActions			(1) Create an OOM loop, setting the server's heap memory to fail.

								In the loop create and register a linked typeface with 1-4

								typefaces.  

							(2) Draw text with the four linked fonts from the four

								linked typefaces.  

							(3) Compare the text output against an unlinked font with the same 

								character forms.

   @SYMTestExpectedResults	(1) - There are no memory leaks, and the test exits the OOM loop.

   							(2) - The text is draw successfully

   							(3) - The text compares identically.

*/	

void CTLinkedFontsMemory::TestLinkedFontsMemory2()

	{

	TInt failures;

	INFO_PRINTF1(_L("TestLinkedFontsMemory Server Heap"));

	// Initially test for linked typeface creation

	_LIT(name1, "typefaceNameMem2-1");

	_LIT(name2, "typefaceNameMem2-2");

	_LIT(name3, "typefaceNameMem2-3");

	_LIT(name4, "typefaceNameMem2-4");

	TInt steps;

	for (steps=1;steps<=4;steps++)

		{

		INFO_PRINTF2(_L("Testing creating linked typeface %d typefaces"),steps);

		for (failures = 1;;failures++)

			{

			// Try creating the typeface

			TInt err;

			TInt val = KErrNone;

			SetHeapFail(RFbsSession::EHeapFailTypeServerMemory, failures);

			SetHeapCheck(RFbsSession::EHeapFailTypeServerMemory); //on

			SetHeapCheck(RFbsSession::EHeapFailTypeHeapMemory); //on

			switch(steps)

				{

				case 1:

					TRAP(err, val = TestLinkedFontsCreateLinkedTypefacesL(name1, steps));

					break;

				case 2:

					TRAP(err, val = TestLinkedFontsCreateLinkedTypefacesL(name2, steps));

					break;

				case 3:

					TRAP(err, val = TestLinkedFontsCreateLinkedTypefacesL(name3, steps));

					break;

				case 4:

					TRAP(err, val = TestLinkedFontsCreateLinkedTypefacesL(name4, steps));

					break;

				}

			SetHeapReset(RFbsSession::EHeapFailTypeServerMemory);

			SetHeapCheck(RFbsSession::EHeapFailTypeServerMemory); //off

			SetHeapCheck(RFbsSession::EHeapFailTypeHeapMemory); //off

			//If the linked font cannot be created because the typefaces are not present or

			//it has already been created then fail the test.

			if (err == KErrNotFound || err == KErrAlreadyExists)

				{

				INFO_PRINTF1(_L("Failure below caused by missing linked font element file or linked font file already being generated."));

				TEST(EFalse);

				break;

				}

			if ((val >= 0) && (err == KErrNone))

				break;

			}

		}

	INFO_PRINTF1(_L("Testing linked typeface font creation and usage"));

	for(steps=1;steps<=4;steps++)

		{

		INFO_PRINTF2(_L("Testing font usage: linked font with %d fonts"),steps);

		for (failures = 1; ; failures++)

			{

			TInt val = 0;

#ifdef _DEBUG

			TInt serverBefore=HeapCount(RFbsSession::EHeapFailTypeServerMemory);

			TInt countBefore =0;

			RHeap *heap = (RHeap*)FontAndBitmapServerSharedHeap();

			if (heap)

				{

				__RHEAP_MARK(heap);

				countBefore = heap->Count();

				}

			SetHeapFail(RFbsSession::EHeapFailTypeServerMemory, failures);

			SetHeapCheck(RFbsSession::EHeapFailTypeServerMemory); //on

#endif

			switch(steps)

				{

				case 1:

					val=TestLinkedFontsMemory_Part2(name1);

					break;

				case 2:

					val=TestLinkedFontsMemory_Part2(name2);

					break;

				case 3:

					val=TestLinkedFontsMemory_Part2(name3);

					break;

				case 4:

					val=TestLinkedFontsMemory_Part2(name4);

					break;

				}

#ifdef _DEBUG

			TInt serverAfter = HeapCount(RFbsSession::EHeapFailTypeServerMemory);

			TInt countAfter=0;

			TInt badCell=0;

			if (heap)

				{

				countAfter = heap->Count();

				badCell = __RHEAP_MARKEND(heap);

				}

			SetHeapReset(RFbsSession::EHeapFailTypeServerMemory);

			SetHeapCheck(RFbsSession::EHeapFailTypeServerMemory); //off

#endif

			if (val == KErrNone)

				{

				if (steps == 4)

					{

					//do a comparison of the text

					TestCompareText();

					}

				break;

				}

#ifdef _DEBUG

			TEST(badCell == 0);

			TEST(countBefore == countAfter);

			TEST(serverBefore == serverAfter);

#endif

			}

		}

	}

TInt CTLinkedFontsMemory::TestLinkedFontsMemory_Part2(const TDesC &aName)

	{

	TTypeface Typeface;

	Typeface.iName = aName;

	TFontSpec fs;

	fs.iTypeface = Typeface;

	fs.iHeight = 20;

	CFbsFont* font = NULL;

	TInt err1 = iDev->GetNearestFontToDesignHeightInPixels(font, fs);

	if (font && err1 == KErrNone)

		{

		// Use the font

		iGc->UseFont(font);

		iGc->Clear();

		iGc->DrawText(KDrawMe, TPoint(50, 50));

		iGc->DiscardFont();

		iDev->ReleaseFont(font);

		}

	else if (font == NULL)

		{

		TEST(err1==KErrNoMemory);

		if (err1==KErrNone)

			{

			err1 = KErrGeneral;

			}

		}

	return err1;

	}

/**

   @SYMTestCaseID			GRAPHICS-FNTSTORE-LINKEDFONTS-0104

   @SYMPREQ					PREQ2146

   @SYMREQ					REQ10924, REQ10925, REQ10926

   @SYMTestCaseDesc			To ensure that a linked typeface can be created and fonts created

							and used under low memory conditions

   @SYMTestPriority			Critical

   @SYMTestStatus			Implemented

   @SYMTestActions			(1) This function checks that no memory has been retained from the

								usage of a linked font.  This tests server heap and shared heap

								memory.

   @SYMTestExpectedResults	(1) - There are no memory leaks.

*/

void CTLinkedFontsMemory::TestLinkedFontsMemory3()

	{

	_LIT( KTest1, "typefaceNameMem2-1");

	_LIT( KTest2, "typefaceNameMem2-2");

	_LIT( KTest3, "typefaceNameMem2-3");

	_LIT( KTest4, "typefaceNameMem2-4");

#if _DEBUG

		TInt serverBefore = HeapCount(RFbsSession::EHeapFailTypeServerMemory);

		// need to get heap from client side.

		RHeap *heap = (RHeap*)FontAndBitmapServerSharedHeap();

		TInt countBefore=0;

		if (heap)

			{

			__RHEAP_MARK(heap);

			countBefore = heap->Count();

			}

		TInt serverAfter;

#endif

	for (TInt numRuns = 0 ; numRuns <= 50 ; numRuns++)

		{

		for (TInt steps=1;steps<=4;steps++)

			{

			TTypeface Typeface;

			switch (steps)

				{

				case 1:

					Typeface.iName = KTest1;

					break;

				case 2:

					Typeface.iName = KTest2;

					break;

				case 3:

					Typeface.iName = KTest3;

					break;

				case 4:

					Typeface.iName = KTest4;

					break;

				}

			TFontSpec fs;

			fs.iTypeface = Typeface;

			fs.iHeight = 50;

			TInt count;

			CFbsFont *fnt[10];

			TInt err;

			for (count = 0; count < 10; count++)

				{

				err = iDev->GetNearestFontToDesignHeightInPixels(fnt[count], fs);

				//now try getting the same font twice, if count is 5

				if(count!=5)

					fs.iHeight++;

				TEST(err == KErrNone);

				}

			for (count = 0; count < 10; count++)

				{

				iDev->ReleaseFont(fnt[count]);

				}

			}

		}

#ifdef _DEBUG

		serverAfter = HeapCount(RFbsSession::EHeapFailTypeServerMemory);

		TInt countAfter=0;

		TInt badCell=0;

		if (heap)

			{

			countAfter = heap->Count();

			badCell = __RHEAP_MARKEND(heap);

			}

		TEST(badCell == 0);

		TEST (countAfter <= countBefore);

			RDebug::Printf("serverAfter(%i) <= serverBefore(%i)", serverAfter, serverBefore);

			INFO_PRINTF3(_L("serverAfter(%i) <= serverBefore(%i)"), serverAfter, serverBefore);

		TEST(serverAfter <= serverBefore); // Note some true type tables are freed.

#endif

	}

/**

   @SYMTestCaseID			GRAPHICS-FNTSTORE-LINKEDFONTS-0105

   @SYMPREQ					PREQ2146

   @SYMREQ					REQ10924, REQ10925, REQ10926

   @SYMTestCaseDesc			To ensure that a linked typeface can be created and fonts created

							and used under low memory conditions of the font and bitmap

							server shared heap.

   @SYMTestPriority			Critical

   @SYMTestStatus			Implemented

   @SYMTestActions			(1) Create an OOM loop, setting the shared heap memory to fail.

								In the loop create and register a linked typeface with 1-4

								typefaces.  Draw text with the four linked fonts from the four

								linked typefaces.

   @SYMTestExpectedResults	(1) - There are no memory leaks, and the test exits the OOM loop.

*/

void CTLinkedFontsMemory::TestLinkedFontsMemory4()

	{

	TInt failures;

	INFO_PRINTF1(_L("TestLinkedFontsMemory Shared Heap"));

	// Initially test for linked typeface creation

	// Initially test for linked typeface creation

	_LIT(name1, "typefaceNameMem4-1");

	_LIT(name2, "typefaceNameMem4-2");

	_LIT(name3, "typefaceNameMem4-3");

	_LIT(name4, "typefaceNameMem4-4");

	TInt steps;

	for(steps=1;steps<=4;steps++)

		{

		INFO_PRINTF2(_L("Testing creating linked typeface %d typefaces"),steps);

		for (failures = 1; ; failures++)

			{

			// Try creating the typeface

			TInt err;

			TInt val = KErrNone;

			SetHeapFail(RFbsSession::EHeapFailTypeHeapMemory, failures);

			SetHeapCheck(RFbsSession::EHeapFailTypeServerMemory); //on

			SetHeapCheck(RFbsSession::EHeapFailTypeHeapMemory); //on

			switch(steps)

				{

				case 1:

					TRAP(err, val = TestLinkedFontsCreateLinkedTypefacesL(name1, 1));

					break;

				case 2:

					TRAP(err, val = TestLinkedFontsCreateLinkedTypefacesL(name2, 2));

					break;

				case 3:

					TRAP(err, val = TestLinkedFontsCreateLinkedTypefacesL(name3, 3));

					break;

				case 4:

					TRAP(err, val = TestLinkedFontsCreateLinkedTypefacesL(name4, 4));

					break;

				}

			SetHeapReset(RFbsSession::EHeapFailTypeHeapMemory);

			SetHeapCheck(RFbsSession::EHeapFailTypeServerMemory); //off

			SetHeapCheck(RFbsSession::EHeapFailTypeHeapMemory); //off

			//If the linked font cannot be created because the typefaces are not present or

			//it has already been created then fail the test.

			if (err == KErrNotFound || err == KErrAlreadyExists)

				{

				INFO_PRINTF1(_L("Failure below caused by missing linked font element file or linked font file already being generated."));

				TEST(EFalse);

				break;

				}

			if ((val >= 0) && (err == KErrNone))

				break;

			}

		}

	INFO_PRINTF1(_L("Testing linked typeface font creation and usage"));

	for (steps=1;steps<=4;steps++)

		{

		INFO_PRINTF2(_L("Testing font usage: linked font with %d fonts"), steps);

		for (failures = 1; ; failures++)

			{

			TInt val = 0;

#ifdef _DEBUG

			TInt serverBefore=HeapCount(RFbsSession::EHeapFailTypeServerMemory);

			RHeap *heap=(RHeap*)FontAndBitmapServerSharedHeap();

			TInt countBefore = 0;

			if (heap)

				{

				__RHEAP_MARK(heap);

			 	countBefore = heap->Count();

				}

			SetHeapFail(RFbsSession::EHeapFailTypeHeapMemory, failures);

			SetHeapCheck(RFbsSession::EHeapFailTypeServerMemory); //on

#endif

			switch (steps)

				{

				case 1:

					val = TestLinkedFontsMemory_Part2(name1);

					break;

				case 2:

					val = TestLinkedFontsMemory_Part2(name2);

					break;

				case 3:

					val = TestLinkedFontsMemory_Part2(name3);

					break;

				case 4:

					val = TestLinkedFontsMemory_Part2(name4);

					break;

				}

#ifdef _DEBUG

			TInt serverAfter = HeapCount(RFbsSession::EHeapFailTypeServerMemory);

			TInt countAfter =0;

			TInt badCell = 0;

			if (heap)

				{

				countAfter = heap->Count();

				badCell = __RHEAP_MARKEND(heap);

				}

			SetHeapReset(RFbsSession::EHeapFailTypeHeapMemory);

			SetHeapCheck(RFbsSession::EHeapFailTypeServerMemory); //off

#endif

			if (val == KErrNone)

				{

				if (steps == 4)

					{

					TestCompareText();

					}

				break;

				}

#ifdef _DEBUG

			TEST(badCell == 0);

			TEST (countBefore == countAfter);

			TEST(serverBefore == serverAfter);

#endif

			}

		}

	}

void CTLinkedFontsMemory::DisplayRamInfo(const TDesC& aTextInfo) const

	{

	TInt val;

	HAL::Get(HALData::EMemoryRAMFree, val);

	TBuf <80> buf;

	_LIT(KTotalRamText, "RAM free: %d ");

	buf.Format(KTotalRamText,val);

	buf.Append(aTextInfo);

	iStep->INFO_PRINTF1(buf);

	}

/**

   @SYMTestCaseID			GRAPHICS-FNTSTORE-LINKEDFONTS-0106

   @SYMPREQ					PREQ2146

   @SYMREQ					REQ10924, REQ10925, REQ10926

   @SYMTestCaseDesc			To test memory usage performance of linked font creation. 

   							Test memory usage performance of linked font character access.

   @SYMTestPriority			High

   @SYMTestStatus			Implemented

   @SYMTestActions			(1) Display available ram.  Create a linked typeface with 1-4 linked typeface

								and display ram available.

							(2) Create four linked fonts from the four linked typefaces.  After each step

								display the available RAM.

							(3) Use each of the four linked fonts in turn for drawing text, and at each

								step display the available RAM.	

   @SYMTestExpectedResults	(1) (2) (3) RAM usage is displayed.  

   							There are no memory leaks.

*/

void CTLinkedFontsMemory::TestMemoryUsage()

	{

	INFO_PRINTF1(_L("Test Memory Usage 1"));

	// Initially test for linked typeface creation

	// Initially test for linked typeface creation

	_LIT(name0, "WithoutLinkedFontTT");

	_LIT(name1, "typefaceMemUse-1");

	_LIT(name2, "typefaceMemUse-2");

	_LIT(name3, "typefaceMemUse-3");

	_LIT(name4, "typefaceMemUse-4");

	TInt steps;

	_LIT(KPriorToTesting, "Prior to testing");

	DisplayRamInfo(KPriorToTesting);

	TInt err=KErrNone;

	TInt val=KErrNone;

	//get memory after registering a typeface

	for(steps=1;steps<=4;steps++)

		{

		switch(steps)

			{

			case 1:

				TRAP(err, val = TestLinkedFontsCreateLinkedTypefacesL(name1, 1));

				_LIT(KOneTypeface, "Typeface with one typeface created");

				DisplayRamInfo(KOneTypeface);

				break;

			case 2:

				TRAP(err, val = TestLinkedFontsCreateLinkedTypefacesL(name2, 2));

				_LIT(KTwoTypeface, "Typeface with two typefaces created");

				DisplayRamInfo(KTwoTypeface);

				break;

			case 3:

				TRAP(err, val = TestLinkedFontsCreateLinkedTypefacesL(name3, 3));

				_LIT(KThreeTypeface, "Typeface with three typefaces created");

				DisplayRamInfo(KThreeTypeface);

				break;

			case 4:

				TRAP(err,val = TestLinkedFontsCreateLinkedTypefacesL(name4, 4));

				_LIT(KFourTypeface, "Typeface with four typefaces created");

				DisplayRamInfo(KFourTypeface);

				break;

			}

		TEST(err == KErrNone);

		TEST(val == KErrNone);

		}

	CFont* font[5];

	memset (font,0, sizeof(CFont*)*5);

	_LIT(KGettingFonts, "Now getting 5 fonts, the first one of which is not linked");

	DisplayRamInfo(KGettingFonts);

	//get memory after retrieving a font

	for (steps=0;steps<5;steps++)

		{

		switch (steps)

			{

			case 0:

				{

				TTypeface typeface;

				typeface.iName = name0;

				TFontSpec fs;

				fs.iTypeface = typeface;

				fs.iHeight = 20;

				err = iDev->GetNearestFontToDesignHeightInPixels(font[steps], fs);

				TEST(err==KErrNone);

				_LIT(KOneFont, "Non linked font typeface");

				DisplayRamInfo(KOneFont);

				}

			break;

			case 1:

				{

				TTypeface typeface;

				typeface.iName = name1;

				TFontSpec fs;

				fs.iTypeface = typeface;

				fs.iHeight = 20;

				err = iDev->GetNearestFontToDesignHeightInPixels(font[steps], fs);

				TEST(err==KErrNone);

				_LIT(KOneFont, "LinkedFont one typeface");

				DisplayRamInfo(KOneFont);

				}

			break;

			case 2:

				{

				TTypeface typeface;

				typeface.iName = name2;

				TFontSpec fs;

				fs.iTypeface = typeface;

				fs.iHeight = 20;

				err = iDev->GetNearestFontToDesignHeightInPixels(font[steps], fs);

				TEST(err==KErrNone);

				_LIT(KTwoFont, "LinkedFont two typefaces");

				DisplayRamInfo(KTwoFont);

				}

			break;

			case 3:

				{

				TTypeface typeface;

				typeface.iName = name3;

				TFontSpec fs;

				fs.iTypeface = typeface;

				fs.iHeight = 20;

				err = iDev->GetNearestFontToDesignHeightInPixels(font[steps], fs);

				TEST(err==KErrNone);

				_LIT(KThreeFont, "LinkedFont three typefaces");

				DisplayRamInfo(KThreeFont);

				}

			break;

			case 4:

				{

				TTypeface typeface;

				typeface.iName = name4;

				TFontSpec fs;

				fs.iTypeface = typeface;

				fs.iHeight = 20;

				err = iDev->GetNearestFontToDesignHeightInPixels(font[steps], fs);

				TEST(err==KErrNone);

				_LIT(KFourFont, "LinkedFont four typefaces");

				DisplayRamInfo(KFourFont);

				}

			break;

			}

		}

	//get memory after font usage

	const TDesC* string[5];

	_LIT(KString0,"A");

	_LIT(KString1,"B");

	_LIT(KString2,"F");

	_LIT(KString3,"D");

	_LIT(KString4,"V");

	string[0]=&KString0();

	string[1]=&KString1();

	string[2]=&KString2();

	string[3]=&KString3();

	string[4]=&KString4();

	_LIT(KWritingCharacter,"Now outputing a single character from each of the five fonts");

	DisplayRamInfo(KWritingCharacter);

	for (steps=0;steps<5;steps++)

		{

		// Use the font

		iGc->UseFont(font[steps]);

		iGc->Clear();

		_LIT(KNowUsingFont,"Now using font");

		DisplayRamInfo(KNowUsingFont);

		iGc->DrawText(*string[steps], TPoint(100, 100));

		TBuf <80> buf;

		_LIT(KNumberOfSteps,"The font in use has %d linked fonts");

		buf.Format(KNumberOfSteps, steps);

		DisplayRamInfo(buf);

		iGc->DiscardFont();

		}

	//release the fonts

	for (steps=0;steps<5;steps++)

		{

		iDev->ReleaseFont(font[steps]);

		}

	_LIT(KTestEnd,"At the end of the memory test");

	DisplayRamInfo(KTestEnd);

	}

void CTLinkedFontsMemory::RunTestCaseL( TInt aCurTestCase )

	{