/*
* Copyright (c) 1995-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 "T_FNTMEM.H"
#include "T_FSOPEN.H"
#include <graphics/openfontrasterizer.h>

#ifdef __WINS__
	_LIT(KEonFontFileName,"z:\\resource\\fonts\\eon14.gdr");
#else
	_LIT(KEonFontFileName,"z:\\resource\\fonts\\eon.gdr");
#endif

// 'dummy' open fonts, as used by T_FSOPEN
_LIT(KFontDummy,"z:\\PlatTest\\Graphics\\TestData\\dummy_fonts\\dummy");
//_LIT(KFontDummy_b,"z:\\PlatTest\\Graphics\\TestData\\dummy_fonts\\dummy_b");
//_LIT(KFontDummy_i,"z:\\PlatTest\\Graphics\\TestData\\dummy_fonts\\dummy_i");
//_LIT(KFontDummy_bi,"z:\\PlatTest\\Graphics\\TestData\\dummy_fonts\\dummy_bi");



CTFntMem::CTFntMem(CTestStep* aStep):
	CTGraphicsBase(aStep),
	iHeap(NULL)
	{
	iHeap = UserHeap::ChunkHeap(NULL,0x80000,0x80000);
	INFO_PRINTF1(_L("FontStore"));
	}

void CTFntMem::RunTestCaseL(TInt aCurTestCase)
	{
	((CTFntMemStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
	switch(aCurTestCase)
		{
	case 1:
		((CTFntMemStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-0024"));
		TRAPD(err,TestNewL());
		TEST(err == KErrNone);
		break;
	case 2: // OOM handling for bitmap fonts
		((CTFntMemStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-0025"));
		TRAP(err,TestAddFileL(KEonFontFileName));
		TEST(err == KErrNone);
		break;
	case 3: // OOM handling for open fonts
		((CTFntMemStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-0025"));
		TRAP(err,TestAddFileL(KFontDummy));
		TEST(err == KErrNone);
		break;
	case 5: // OOM handling for second reference to a bitmap font
		((CTFntMemStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-0026"));
		TRAP(err,TestAddFileTwiceL(KEonFontFileName));
		TEST(err == KErrNone);
		break;
	case 6: // OOM handling for second reference to an open font
		((CTFntMemStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-0026"));
		TRAP(err,TestAddFileTwiceL(KFontDummy));
		TEST(err == KErrNone);
		break;
	case 7:
		((CTFntMemStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-0027"));
		TRAP(err,TestGetNearestFontToDesignHeightInTwipsL());
		TEST(err == KErrNone);
		break;
	case 8:
		((CTFntMemStep*)iStep)->SetTestStepID(_L("GRAPHICS-NearestOpenFontLeaksDEF095184-0001"));
		TRAP(err,TestGetNearestOpenFontLeaksL());
		TEST(err == KErrNone);
		break;
	case 9:
		((CTFntMemStep*)iStep)->SetTestStepID(_L("GRAPHICS-CTFbs-TestDuplicateFontFileEntries-0002"));
		TRAP(err,TestDuplicateBitmapFontFileEntriesL());
		TEST(err == KErrNone);
		break;
	case 10:
		((CTFntMemStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
		((CTFntMemStep*)iStep)->CloseTMSGraphicsStep();
		TestComplete();				
		break;
	default:
		((CTFntMemStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
		break;
	}
	((CTFntMemStep*)iStep)->RecordTestResultL();
	}

/**
	@SYMTestCaseID
	GRAPHICS-FNTSTORE-0024

	@SYMTestCaseDesc
	Simulates out of memory errors of the heap when trying to allocate
	memory for a CFontStore object.

	@SYMTestActions
	1. Cancels simulated heap allocation failure for the current thread's heap.
	2. Simulates heap allocation failure for the current thread's heap.
	3. Marks the start of checking the current thread's heap. 
	4. In a loop, tries to create a new CFontStore object with a pointer to 
	   the heap class used for memory allocation.
	5. Checking is done to see if the CFontStore was allocated or
	   if out of memory. The loop is broken when an object is created correctly.  	
	
	@SYMTestExpectedResults
	Test should pass
*/
void CTFntMem::TestNewL()
	{
	INFO_PRINTF1(_L("NewL"));

	TInt ret=KErrGeneral;
	CFontStore *fs=NULL;
	TInt failRate=1;

	while (ret!=KErrNone)
		{
		__UHEAP_RESET;
		__UHEAP_SETFAIL(RHeap::EDeterministic,failRate);
		__UHEAP_MARK;
		TRAP(ret,fs=CFontStore::NewL(iHeap));
		RDebug::Print(_L("fs %d failrate %d, error %d\n"),fs,failRate, ret);
		if (ret==KErrNoMemory)
			{
			__UHEAP_MARKEND;
			__UHEAP_RESET;
			TEST(fs==NULL);
			}
		else if(ret==KErrNone)
			{
			delete fs;
			__UHEAP_MARKEND;
			__UHEAP_RESET;
			__UHEAP_SETFAIL(RHeap::ENone,failRate);
			}
		else
			User::Panic(_L("Unknown error"),ret);
		failRate++;
		}
	}

/**
	@SYMTestCaseID
	GRAPHICS-FNTSTORE-0025

	@SYMTestCaseDesc
	Tests the Out Of Memory handling for bitmap- and open fonts.

	@SYMTestActions
	1. Finds or creates a font file object to support a font file.
	   If an appropriate font file object exists then no new open font file is created. 
	   In this case the reference count of the font file object is incremented.
	2. Allocates the object from the heap and then initialises its contents
	   to binary zeroes.
	3. Installs and takes ownership of an Open Font rasterizer
	4. Releases a hold on one or all font file objects (COpenFontFiles or CFontStoreFiles)
	   If aFileUid identifies a font file object, then the reference count for this 
       object is decremented. If this brings the reference count down to zero then 
       the font file object is removed from the font store, as well as the fonts 
       and typefaces associated with this file.
       If, on the other hand, aFileUid's value is NULL, then all font file objects 
	   are removed, along with all fonts and typefaces in the font store.
	5. Simulates heap allocation failure for the current thread's heap.
	6. Tries to add a font file to the font store and checks for memory allocation errors.
		
	@SYMTestExpectedResults
	Test should pass
*/
void CTFntMem::TestAddFileL(const TDesC& aFileName)
	{
	INFO_PRINTF2(_L("AddFileL(\"%S\")"), &aFileName);
	TInt failRate=1;
	CFontStore *fs=CFontStore::NewL(iHeap);

	// Install the dummy rasterizer - used for 'Open Font's
	COpenFontRasterizer* r = CDummyRasterizer::NewL();
	CleanupStack::PushL(r);
	fs->InstallRasterizerL(r);
	CleanupStack::Pop();

	(void)fs->AddFileL(aFileName);
	fs->RemoveFile(KNullUid);
	TInt ret=KErrGeneral;

	while (ret!=KErrNone)
		{
		__UHEAP_RESET;
		__UHEAP_MARK;
		__UHEAP_SETFAIL(RHeap::EDeterministic,failRate);
		TRAP(ret, (void)fs->AddFileL(aFileName));
		RDebug::Print(_L("NumTypefaces %d failrate %d, error %d\n"),fs->NumTypefaces(), failRate, ret);
		if (ret==KErrNoMemory)
			{
			fs->RemoveFile(KNullUid);
			__UHEAP_MARKEND;
			__UHEAP_RESET;
			TEST(fs->NumTypefaces()==0);
			}
		else if(ret==KErrNone)
			{
			fs->RemoveFile(KNullUid);
			delete fs;
			__UHEAP_MARKEND;
			__UHEAP_RESET;
			__UHEAP_SETFAIL(RHeap::ENone,failRate);
			}
		else
			User::Panic(_L("Unknown error"),ret);
		failRate++;
		}
	}
		
/**
	@SYMTestCaseID
	GRAPHICS-FNTSTORE-0026

	@SYMTestCaseDesc
	Tests the Out Of Memory handling for second reference to a bitmap font and open fonts.

	@SYMTestActions
	1. Finds or creates a font file object to support a font file.
	   If an appropriate font file object exists then no new open font file is created. 
	   In this case the reference count of the font file object is incremented.
	2. Allocates the object from the heap and then initialises its contents.
	   to binary zeroes.
	3. Installs and takes ownership of an Open Font rasterizer.
	4. Loads a font file.
	5. Simulates heap allocation failure for the current thread's heap.
	6. Tries to add a font file a second time to the font store and checks for memory allocation errors.
	7. Removes all font file objects.
	
	@SYMTestExpectedResults
	Test should pass
*/
void CTFntMem::TestAddFileTwiceL(const TDesC& aFileName)
	{
	INFO_PRINTF2(_L("AddFileTwiceL(\"%S\")"), &aFileName);
	TInt failRate=1;
	CFontStore *fs=CFontStore::NewL(iHeap);

	// Install the dummy rasterizer - used for 'Open Font's
	COpenFontRasterizer* r = CDummyRasterizer::NewL();
	CleanupStack::PushL(r);
	fs->InstallRasterizerL(r);
	CleanupStack::Pop();

	// load the font file
	(void)fs->AddFileL(aFileName);
	TInt ret=KErrGeneral;

	while (ret!=KErrNone)
		{
		__UHEAP_SETFAIL(RHeap::EDeterministic,failRate);
		__UHEAP_MARK;
		TRAP(ret, (void)fs->AddFileL(aFileName));
		RDebug::Print(_L("NumTypefaces %d failrate %d, error %d\n"),fs->NumTypefaces(), failRate, ret);

		// neither success or failure should use more memory
		__UHEAP_MARKEND;
		__UHEAP_RESET;

		if ( (ret != KErrNoMemory) && (ret != KErrNone) )
			{
			User::Panic(_L("Unknown error"),ret);
			}
		failRate++;
		}

	fs->RemoveFile(KNullUid);
	delete fs;
	}
	
/**
	@SYMTestCaseID
	GRAPHICS-FNTSTORE-0027

	@SYMTestCaseDesc
	Tests the function GetNearestFontToDesignHeightInTwips in Out Of Memory 
	error conditions.

	@SYMTestActions
	1. Creates a new CFontStore object.
	2. Adds a font file to the font store.
	3. Creates a bitmap font object.
	4. Gets the nearest font to design height in twips of the DejaVu Sans Condensed font.
	5. Releases a hold on one or all font file objects (COpenFontFiles or CFontStoreFiles)
	   If aFileUid identifies a font file object, then the reference count for this 
       object is decremented. If this brings the reference count down to zero then 
       the font file object is removed from the font store, as well as the fonts 
       and typefaces associated with this file.
       If, on the other hand, aFileUid's value is NULL, then all font file objects 
	   are removed, along with all fonts and typefaces in the font store.
	6. Simulates heap allocation failure for the current thread's heap.
	7. Tries to get the nearest font to design height in twips for the font and 
	   checks for memory allocation errors.
	8. Deallocates the CFontStore object.
	
	@SYMTestExpectedResults
	Test should pass
*/
void CTFntMem::TestGetNearestFontToDesignHeightInTwipsL()
	{
	INFO_PRINTF1(_L("GetNearestFontToDesignHeightInTwips"));
	CFontStore *fs=CFontStore::NewL(iHeap);
	(void)fs->AddFileL(KEonFontFileName);
	TInt failRate=1;
	CBitmapFont *font;
	TFontSpec spec(_L("DejaVu Sans Condensed"),200);
	TInt ret;
	ret=fs->GetNearestFontToDesignHeightInTwips((CFont *&) font,spec);
	TEST(ret==KErrNone);
	if (ret!=KErrNone || font==NULL)
		return;	//otherwise the memory faulting test loop will deadlock!
	fs->ReleaseFont(font);
	ret=KErrNoMemory;
	while(ret!=KErrNone)
		{
		__UHEAP_RESET;
		__UHEAP_SETFAIL(RHeap::EDeterministic,failRate);
		__UHEAP_MARK;
		__RHEAP_MARK(iHeap);
		font=NULL;
		ret=fs->GetNearestFontToDesignHeightInTwips((CFont *&) font,spec);
		RDebug::Print(_L("Font %d failrate %d\n"),font,failRate);
		if (ret==KErrNoMemory)
			{
			TEST(font==NULL);
			__RHEAP_MARKEND(iHeap);
			__UHEAP_MARKEND;
			}
		else if(ret==KErrNone)
			{
			fs->ReleaseFont(font);
			font=NULL;
			__RHEAP_MARKEND(iHeap);
			__UHEAP_MARKEND;
			__UHEAP_SETFAIL(RHeap::ENone,failRate);
			}
		else
			User::Panic(_L("Unknown error"),ret);
		failRate++;
		}
				 
	delete fs;
	}
//----------------
/**
@SYMTestCaseID GRAPHICS-NearestOpenFontLeaksDEF095184-0001
@SYMTestPriority Med
@SYMREQ DEF095184

@SYMTestCaseDesc
Leak in font finder

@SYMTestActions
Tests for leak case loading both nearest open and bitmap font.
The first call to GetNearestFontToDesignHeightInTwips loads the bitmap font.
The looped calls change the memory fault frequency until this succeeds, 
but the open font is returned instead, and then until the bitmap font is again returned.
The test fontspec is specially chosen to cause these different results,
 and the test code is not working if the differing results are not fetched.

@SYMTestExpectedResults
failrate 1: KErrNoMemory
failrate 2: Same font returned
failrate 3: Different font returned
failrate 4: Same font returned
No leaks.
Note that the exact results may change fail rates 
if underlying changes are made to the font store.

**/
void CTFntMem::TestGetNearestOpenFontLeaksL()
	{
	INFO_PRINTF1(_L("TestGetNearestOpenFontLeaksL"));
	CFontStore *fs=CFontStore::NewL(iHeap);
	CleanupStack::PushL(fs);
	// Install the dummy rasterizer - used for 'Open Font's
	COpenFontRasterizer* r = CDummyRasterizer::NewL();
	CleanupStack::PushL(r);
	fs->InstallRasterizerL(r);
	//Need one of each font flavour
	(void)fs->AddFileL(KFontDummy);
	(void)fs->AddFileL(KEonFontFileName);
	CleanupStack::Pop(r);
	CleanupStack::Pop(fs);
	bool differentResultFetched=false;	
	CBitmapFont *firstFont;

	//Manufacture this font so that the bitmap font is favoured
	//Note that the best I could do was get them equal, but that is enough to get bitmap chosen!
	//Blank name is required to allow the dummy open font to be selected by similarity
	TFontSpec reqSpec(_L(""),190);
	reqSpec.iFontStyle.SetBitmapType(EMonochromeGlyphBitmap);
	TFontSpec firstSpec;
	TInt ret;	
	//first run - tests that the code actually works before faulting the memory 
	ret=fs->GetNearestFontToDesignHeightInTwips((CFont *&) firstFont,reqSpec);
	TEST(ret==KErrNone);
	TEST(firstFont!=NULL);
	if (ret!=KErrNone || firstFont==NULL)
		{
		return;	//otherwise the memory faulting test loop will deadlock!
		}
	if (firstFont)
		{
		firstSpec=firstFont->FontSpecInTwips();
		fs->ReleaseFont(firstFont);
		}
	ret=KErrNoMemory;
	TInt failRate=1;
	while(ret!=KErrNone || (failRate<30 && !differentResultFetched))
		{
		CBitmapFont *font=NULL;
		__UHEAP_RESET;
		__RHEAP_SETFAIL(iHeap,RHeap::EDeterministic,failRate);
		__UHEAP_MARK;
		__RHEAP_MARK(iHeap);
		TFontSpec spec(reqSpec);
		ret=fs->GetNearestFontToDesignHeightInTwips((CFont *&) font,reqSpec);
		if (ret==KErrNoMemory)
			{
			RDebug::Print(_L("failrate %d: KErrNoMemory\n"),failRate);
			TEST(font==NULL);
			}
		else if(ret==KErrNone)
			{
			TEST(font!=NULL);
			if (font)
				{
				TFontSpec spec=font->FontSpecInTwips();
				if (!(spec==firstSpec))
					{
					differentResultFetched=true;
					ret=KErrNoMemory;			//actually there was a handled memory fault
					RDebug::Print(_L("failrate %d: Different font returned\n"),failRate);
					}
				else
					{
					RDebug::Print(_L("failrate %d: Same font returned\n"),failRate);
					}
				}
			else
				{
				RDebug::Print(_L("failrate %d: Error: NULL font returned\n"),failRate);
				}
			fs->ReleaseFont(font);
			font=NULL;
			}
		else
			{
			User::Panic(_L("Unexpected error"),ret);
			}
		__RHEAP_CHECK(iHeap,0);
		__RHEAP_MARKEND(iHeap);
		__UHEAP_MARKEND;
		__RHEAP_SETFAIL(iHeap,RHeap::ENone,failRate);
		failRate++;
		}
	if (!differentResultFetched)
		{
		INFO_PRINTF1(_L("Test did not return different results under memory stress (unexpected)"));
		}
	delete fs;
	}


//The "bad" versions of these standard fonts have been hacked to give specific results
_LIT(KFBSERVFontFileBitmap, 	"Z:\\resource\\fonts\\ceurope.GDR");
//This file has the master GUID nobbled, but all the guid and typeface entries are duplicates.
_LIT(KFBSERVFontFileBadBitmap1, 	"Z:\\PlatTest\\Graphics\\TestData\\uniquified_fonts\\XXeuro.GDR");
//This file has the master GUID nobbled, one of the 8 fonts, and one of the typefaces has also been nobbled.
_LIT(KFBSERVFontFileBadBitmap2, 	"Z:\\PlatTest\\Graphics\\TestData\\uniquified_fonts\\YYeuro.GDR");
enum	{KNobbledFontEnum=0x10ff5912};		//official code for LatinBold17 is 0x10005912
_LIT(NobbledTypefaceName, 	"XatinBold17");


 /**
   @SYMTestCaseID GRAPHICS-CTFbs-TestDuplicateFontFileEntries-0002
  
   @SYMDEF  DEF094692
  
   @SYMTestCaseDesc  If Bitmap fonts are loaded that are marginally unique compared to the 
   					 existing fonts then they are not actually added to the typeface system, and may even be discarded.
   
   @SYMTestPriority Med 
  
   @SYMTestStatus Implemented
   
   @SYMTestActions \n
   		The original versions of the Bitmapfonts are first loaded to ensure that they have actually been loaded.
   		A version of the bitmap font which is identical except for the file UID should be rejected
   		Verify that the unique data for the next test does not already exist
   		A version of the bitmap font which has just 1 unique bitmap will be loaded, but only 1 typeface entry will be added.
   		Verify that the unique data for the previous test now does exist
   	    The memory allocations through these steps should be deterministic
   			
   API Calls:	AddFile\n	
      
   @SYMTestExpectedResults The test expects:
   		The original versions should load without changing the number of typefaces
   		The second load should return the same UID for the font
   		The identical fonts should return captured fail codes, and not change the typeface counts
   		The semi-identical font should perform a single increase to UIDs and typefaces
  */
void CTFntMem::TestDuplicateBitmapFontFileEntriesL()
	{
	
	INFO_PRINTF1(_L("Test Load semi-duplicate bitmap font files"));
	__RHEAP_MARK(iHeap);
	__UHEAP_MARK;
	CFontStore *fs=CFontStore::NewL(iHeap);
	CleanupStack::PushL(fs);
	
	TInt numFacesBefore=fs->NumTypefaces();
	TUid aIdBitMap1=TUid::Null();
	TUint numAllocsBefore=iHeap->Count();
	TUid aIdBitMap2=TUid::Null();
	TUid aIdBitMap3=TUid::Null();
	//make sure the originals of these fonts were safely opened
	//both should simply cause a reference-count increase on the originator files.
	TRAPD(err1,aIdBitMap1=fs->AddFileL(KFBSERVFontFileBitmap));
	TEST(err1==KErrNone);
	if (err1)
		{
		INFO_PRINTF1(_L("One of the expected fonts was missing. Test abandoned."));
		}
	else
		{
		TInt numFacesAfterLoadOriginals=fs->NumTypefaces();
		TEST(numFacesBefore<numFacesAfterLoadOriginals);
		TUint numAllocsAfterLoadOriginals=iHeap->Count();
		
		
		//This bitmap font file contains no new fonts, so will ultimately be discarded
		//The master UID has been nobbled so the file is not considered identical to its originator
		TRAPD(err3,aIdBitMap2=fs->AddFileL(KFBSERVFontFileBadBitmap1));
		TEST(err3==KErrAlreadyExists && aIdBitMap2==TUid::Null());
		if (err3!=KErrAlreadyExists)
				INFO_PRINTF2(_L("Unexpected error code was %d"),err3);	 
		TInt numFacesAfterLoadBadFile3=fs->NumTypefaces();
		TEST(numFacesAfterLoadOriginals==numFacesAfterLoadBadFile3);
		TUint numAllocsAfterLoadBadFile3=iHeap->Count();
		TEST(numAllocsAfterLoadBadFile3==numAllocsAfterLoadOriginals);
		
		//Before loading the next test check that the new data about to be added does not already exist
		CFont *font=NULL;
		TAlgStyle algStyle;
		TFontSpec fontSpec(NobbledTypefaceName,10);
		
		TInt err5a1=fs->GetFontById(font,TUid::Uid(KNobbledFontEnum),algStyle);
		TEST(font==NULL);	//the nobbled UID should not already exist

		font=NULL;
		
		TInt err5a2=fs->GetNearestFontInPixels(font, fontSpec);
		if (font)
			{
			TFontSpec specNoMatch=font->FontSpecInTwips();
			TEST(specNoMatch.iTypeface.iName!=NobbledTypefaceName);	 //Nobbled font name should not be known yet
			fs->ReleaseFont(font);
			}
		
		//This bitmap font file contains one new typeface and font
		//Actually, they are bit file edited versions of existing ones!
		TInt numAllocsBeforeLoadBadFile5 = iHeap->Count();
		TRAPD(err5,aIdBitMap3=fs->AddFileL(KFBSERVFontFileBadBitmap2));
		TEST(err5==KErrNone); 
		if (err5!=KErrNone)
				INFO_PRINTF2(_L("Unexpected error code was %d"),err5);	 
		
		//The number of typefaces has now increased
		TInt numFacesAfterLoadBadFile5=fs->NumTypefaces();
		TEST(numFacesAfterLoadOriginals+1==numFacesAfterLoadBadFile5);
		TUint numAllocsAfterLoadBadFile5=iHeap->Count();
		TEST(numAllocsAfterLoadBadFile5==numAllocsBeforeLoadBadFile5+2);
		

		TInt err5b1=fs->GetFontById(font,TUid::Uid(KNobbledFontEnum),algStyle);
		TEST(err5b1==KErrNone && font!=NULL);	//the nobbled UID should now exist
		if (err5b1!=KErrNone)
				INFO_PRINTF2(_L("Unexpected error code was %d"),err5b1);	 
		
		CFont *font2=NULL;
		TInt err5b2=fs->GetNearestFontInPixels(font2, fontSpec);
		TEST(err5b2==KErrNone && font2!=NULL);	
		if (err5b2!=KErrNone)
				INFO_PRINTF2(_L("Unexpected error code was %d"),err5b2);	 
		if (font2!=NULL)
			{
			TFontSpec specMatches=font->FontSpecInTwips();
			TEST(specMatches.iTypeface.iName==NobbledTypefaceName);	   //the nobbled typeface should now exist
			}
		TEST(font==font2);
		if (font)
			fs->ReleaseFont(font);
		if (font2)
			fs->ReleaseFont(font2);
		}
	
	if (aIdBitMap1!=TUid::Null())	fs->RemoveFile(aIdBitMap1);
	if (aIdBitMap2!=TUid::Null())	fs->RemoveFile(aIdBitMap2);
	if (aIdBitMap3!=TUid::Null())	fs->RemoveFile(aIdBitMap3);
	
	//The added typeface should have been uninstalled
	TInt numFacesAfterUninstall=fs->NumTypefaces();
	TEST(numFacesAfterUninstall==numFacesBefore);
	TUint numAllocsAfterUninstall=iHeap->Count();
	
	CleanupStack::PopAndDestroy(fs);
	__UHEAP_CHECK(0);
	__UHEAP_MARKEND;
	__RHEAP_CHECK(iHeap,0);
	__RHEAP_MARKEND(iHeap);
	
	}


//--------------
__CONSTRUCT_STEP__(FntMem)