/*
* 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 )
	{
		
	((CTLinkedFontsMemoryStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
	switch ( aCurTestCase )
		{
	case 1:
		((CTLinkedFontsMemoryStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
		StartServer();
		if (!CheckRasterizerInstalledL())
			{
			TestComplete();
			return;
			}
		break;
	case 2:
		((CTLinkedFontsMemoryStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-LINKEDFONTS-0102"));
#ifdef _DEBUG
		//memory tests are not valid under DEBUG/ urel, and they will fail
		__UHEAP_MARK;
		// This is for client side memory
		TestLinkedFontsMemory1L();
		__UHEAP_MARKEND;
		__UHEAP_RESET;
#endif
		break;
	case 3:
		((CTLinkedFontsMemoryStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
#ifdef _DEBUG
		__UHEAP_MARK;
		//((CTLinkedFontsMemoryStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-LINKEDFONTS-0103"));
		// This is for server side memory
		//TestLinkedFontsMemory2(); //- test crashes the server (from the rasterizer)
		//TEST(EFalse);
		__UHEAP_MARKEND;
		__UHEAP_RESET;
#endif
		break;
	case 4:
		((CTLinkedFontsMemoryStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-LINKEDFONTS-0104"));
#ifdef _DEBUG
		__UHEAP_MARK;
		// This is to check that there are no leaks getting and releasing fonts
		//TestLinkedFontsMemory3();
		__UHEAP_MARKEND;
		__UHEAP_RESET;
#endif
		break;
	case 5:
		((CTLinkedFontsMemoryStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-LINKEDFONTS-0105"));
#ifdef _DEBUG
		__UHEAP_MARK;
		// This is for heap memory
		//TestLinkedFontsMemory4();
		__UHEAP_MARKEND;
		__UHEAP_RESET;
#endif
		break;

	case 6:
#ifdef _DEBUG
		__UHEAP_MARK;
#endif		
		((CTLinkedFontsMemoryStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-LINKEDFONTS-0106"));
		TestMemoryUsage();
#ifdef _DEBUG		
		__UHEAP_MARKEND;
		__UHEAP_RESET;
#endif		
		break;	
	case 7:
		((CTLinkedFontsMemoryStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
		((CTLinkedFontsMemoryStep*)iStep)->CloseTMSGraphicsStep();
		TestComplete();
		break;
		}
	((CTLinkedFontsMemoryStep*)iStep)->RecordTestResultL();
	}

// --------------
__CONSTRUCT_STEP__(LinkedFontsMemory)