/*

* 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);