/*

 * Copyright (c) 2007-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: 

 * Tests FNTSTORE with respect to the Open Font system.

 * Creates a dummy rasterizer and tests font file loading and unloading and

 * font creation. This just exercises the way the Open Font system connects to the

 * 'classic' bitmap-font-only font system.

 *

 */

 /**

  @file

  @test

  @internalComponent Internal Symbian test code

 */

 #include "T_FSOPEN.H"

 #include <e32std.h>

 #include <graphics/shaperparams.h>

 #include <graphics/fbsdefs.h>

 #ifdef _DEBUG

 _LIT(KFBSERVFontDir,"\\resource\\fonts\\");

 #endif// _DEBUG

 _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");

 const TUint32 KDevanagariScriptCode = 0x64657661;

 _LIT16(KTextToShape, "\x0915\x094D\x0937\x0924\x094D\x0930\x093F\x092F");

 CDummyShaperFactory* CDummyShaperFactory::NewL()

 	{

 	CDummyShaperFactory* r = new(ELeave) CDummyShaperFactory;

 	return r;

 	}

 CDummyShaperFactory::CDummyShaperFactory()

 	{

 	}

 CDummyShaperFactory::~CDummyShaperFactory()

 	{

 	}

 CShaper* CDummyShaperFactory::NewShaperL(CBitmapFont* aBitmapfont, TInt aScript, TInt aLanguage, RHeap* aHeap)

 	{

 	return CDummyShaper::NewL(aBitmapfont, aScript, aLanguage, aHeap);

 	} 

 void* CShaperFactory::ExtendedInterface(TUid /*aInterfaceId*/)

 	{

 	return 0;

 	}

 CShaper * CDummyShaper::NewL(CBitmapFont* aBitmapfont, TInt aScript, TInt aLanguage, RHeap* aHeap)

 	{

 	CDummyShaper* newShaper = new(ELeave)CDummyShaper();

 	CleanupStack::PushL(newShaper);

 	TInt error = newShaper->ConstructL(aBitmapfont, aScript, aLanguage, aHeap);

 	// if the layout engine fails to construct with this font return NULL

 	if (error == KErrNone )

 		{

 		CleanupStack::Pop(); // newShaper

 		return newShaper;

 		}

 	else

 		{

 		CleanupStack::PopAndDestroy(); 

 		return NULL;		

 		}		

 	} 

 /**

 Construct an instance of CDummyShaper 	

 @param aOpenFont The required font

 @param aHeap The heap to be used for storage by the engine

 @return KErrNone if successful or a system wide error code. 

 Note that KErrGeneral may be returned in certain out of memory situations.

 @see CShaper

  */

  TInt CDummyShaper::ConstructL(CBitmapFont* /*aBitmapfont*/, TInt /*aScript*/, TInt /*aLanguage*/, RHeap* /*aHeap*/ )

 	{

 	return KErrNone;

 	}

 CDummyShaper::CDummyShaper()

 	{

 	}	

 /** 

  Frees all resources owned by ...

  */

  CDummyShaper::~CDummyShaper()

 	{

 	}	

 /** This is implementation of CShaper::ShapeText for the Icu layout Engine

  The data is taken from TInput and pass to the shaper.

  A memory buffer is allocated on aHeapForOutput starting with TShapeHeader is allocated.

  The results of the shaping are copied into this buffer and passed back via aOutput. 

  @param aOutput On success a new structure containing the results allocated on aHeapForOutput.  

  @param aInput The input text and other parameters.

  @param aHeapForOutput On success, aOutput should be allocated from this and nothing else. 

  		On failure, nothing should be allocated from it.

  @return Error value from one of the system-wide error codes on	failure, KErrNone on success.

  @see CShaper::ShapeText

  */		

 TInt CDummyShaper::ShapeText(TShapeHeader*& /*aOutput*/, const TInput& /*aInput*/, RHeap* /*aHeapForOutput*/)

 	{

 	// This shaper doesnt return any results

  	return KErrNotSupported;

 	}

 class CDummyFontFile: public COpenFontFile

 	{

 public:

 	static CDummyFontFile* NewL(TInt aUid,const TDesC& aFileName);

 	TBool GetNearestFontHelperOld(const TOpenFontSpec& aDesiredFontSpec,TInt aPixelWidth,TInt aPixelHeight,

 										TInt& aFaceIndex,TOpenFontSpec& aActualFontSpec) const;

 private:

 	CDummyFontFile(TInt aUid,const TDesC& aFileName);

 	void ConstructL();

 	// From COpenFontFile

 	void GetNearestFontInPixelsL(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList,

 								 const TOpenFontSpec& aDesiredFontSpec,TInt aPixelWidth,TInt aPixelHeight,

 								 COpenFont*& aFont,TOpenFontSpec& aActualFontSpec);

 	void GetNearestFontToDesignHeightInPixelsL(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList,

 								 const TOpenFontSpec& aDesiredFontSpec,TInt aPixelWidth,TInt aPixelHeight,

 								 COpenFont*& aFont,TOpenFontSpec& aActualFontSpec);

 	void GetNearestFontToMaxHeightInPixelsL(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList,

 								 const TOpenFontSpec& aDesiredFontSpec,TInt aPixelWidth,TInt aPixelHeight,

 								 COpenFont*& aFont,TOpenFontSpec& aActualFontSpec, TInt aMaxHeight);

 	virtual TBool HasUnicodeCharacterL(TInt aFaceIndex,TInt aCode) const;

 	};

 class CDummyFont: public COpenFont

 	{

 public:

 	static CDummyFont* NewL(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList,CDummyFontFile* aFontFile,TInt aSizeInPixels);

 private:

 	CDummyFont(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList,CDummyFontFile* aFontFile,TInt aSizeInPixels);

 	// From COpenFont

 	virtual void RasterizeL(TInt aCode,TOpenFontGlyphData* aGlyphData);

 	};

 CTFsOpen::CTFsOpen(CTestStep* aStep) :

 	CTGraphicsBase(aStep)

 	{

 	INFO_PRINTF1(_L("FontStore and the Open Font System"));

 	}

 CTFsOpen::~CTFsOpen()

 	{

 	iFilesys.Close();

 	delete iFontStore;

 	iHeap->__DbgMarkEnd(0);

 	iHeap->Close();

 	__UHEAP_MARKEND;

 	User::Heap().Check();

 	}

 void CTFsOpen::ConstructL()

 	{

 	__UHEAP_MARK;

 	iHeap = UserHeap::ChunkHeap(NULL,0x10000,0x10000);

 	if (iHeap == NULL)

 		User::Leave(KErrGeneral);

 	iHeap->__DbgMarkStart();

 	iFontStore = CFontStore::NewL(iHeap);

 	// Install the dummy rasterizer.

 	COpenFontRasterizer* r = CDummyRasterizer::NewL();

 	CleanupStack::PushL(r);

 	iFontStore->InstallRasterizerL(r);

 	CleanupStack::Pop();

 	// Install the dummy shaper

 	CShaperFactory* shaperFactory = CDummyShaperFactory::NewL();

 	CleanupStack::PushL(shaperFactory);

 	iFontStore->InstallShaperFactoryL(shaperFactory);

 	CleanupStack::Pop();

 	}

 void CTFsOpen::RunTestCaseL(TInt aCurTestCase)

 	{

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

 	switch(aCurTestCase)

 		{

 	case 1:

 		((CTFsOpenStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-0031"));

 		AddAndRemoveFilesL();

 		break;

 	case 2:

 		((CTFsOpenStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-0032"));

 		CreateAndReleaseFontsL();

 		break;

 	case 3:

 		((CTFsOpenStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-0033"));

 #ifdef _DEBUG

 		TestGetNearestFontHelperL();

 #endif //_DEBUG

 		break;

 	case 4:

 		((CTFsOpenStep*)iStep)->SetTestStepID(_L("GRAPHICS-SYSLIB-FNTSTORE-UT-1498"));

 		CreateShaperL();

 		break;

 	case 5:

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

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

 		TestComplete();

 		break;

 		}

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

 	}

 /**

 	@SYMTestCaseID

 	GRAPHICS-FNTSTORE-0031

 	@SYMTestCaseDesc

 	Tests adding and removing files from the font store.

 	@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. Gets the number of typefaces held in the font store.

 	3. Checks all fonts are in the same typeface family.

 	4. Checks all fonts have different FontStore ids.

 	5. Tries to add a font (which has been added once already) and checks it gets 

 	   the same id as when it was added.

 	6. Releases four load fonts.

 	7. Checks font that was loaded twice should still be loaded.

 	8. Removes last reference a font and checks all fonts are unloaded correctly.

 	@SYMTestExpectedResults

 	Test should pass

 */

 void CTFsOpen::AddAndRemoveFilesL()

 	{

 	TEST(iFontStore->NumTypefaces() == 0);

 	INFO_PRINTF1(_L("loading dummy Open Fonts\n"));

 	TUid id1 = iFontStore->AddFileL(KFontDummy);

 	TUid id2 = iFontStore->AddFileL(KFontDummy_b);

 	TUid id3 = iFontStore->AddFileL(KFontDummy_i);

 	TUid id4 = iFontStore->AddFileL(KFontDummy_bi);

 	// all fonts are in the same typeface family

 	INFO_PRINTF1(_L("increasing reference count for for an Open Font file\n"));

 	TEST(iFontStore->NumTypefaces() == 1);

 	// ids should each be different

 	TEST(id1 != id2);

 	TEST(id1 != id3);

 	TEST(id1 != id4);

 	TEST(id2 != id3);

 	TEST(id2 != id4);

 	TEST(id3 != id4);

 	// ask for one of the font files again

 	TUid id5 = iFontStore->AddFileL(KFontDummy_bi);

 	// should get the same UID as the first time

 	TEST(id4 == id5);

 	INFO_PRINTF1(_L("unloading dummy Open Fonts\n"));

 	iFontStore->RemoveFile(id1);

 	iFontStore->RemoveFile(id2);

 	iFontStore->RemoveFile(id3);

 	iFontStore->RemoveFile(id4);

 	// font that was loaded twice should still be loaded

 	TEST(iFontStore->NumTypefaces() == 1);

 	// remove last reference

 	iFontStore->RemoveFile(id5);

 	// all fonts unloaded

 	TEST(iFontStore->NumTypefaces() == 0);

 	}

 void CTFsOpen::TestFont(const TFontSpec& aSpec)

 	{

 	iHeap->__DbgMarkStart();

 	CFont* font = NULL;

 	TInt error = iFontStore->GetNearestFontToDesignHeightInTwips(font,aSpec);

 	TEST(error == KErrNone);

 	TEST(font != NULL);

 	INFO_PRINTF2(_L("desired font spec: %S: "),&aSpec.iTypeface.iName);

 	if (aSpec.iFontStyle.StrokeWeight() == EStrokeWeightBold)

 		INFO_PRINTF1(_L("bold "));

 	if (aSpec.iFontStyle.Posture() == EPostureItalic)

 		INFO_PRINTF1(_L("italic "));

 	INFO_PRINTF2(_L("%dpt"),(aSpec.iHeight + 10) / 20);

 	INFO_PRINTF1(_L("\n"));

 	TFontSpec actual_spec = font->FontSpecInTwips();

 	INFO_PRINTF2(_L("actual font spec: %S: "),&actual_spec.iTypeface.iName);

 	if (actual_spec.iFontStyle.StrokeWeight() == EStrokeWeightBold)

 		INFO_PRINTF1(_L("bold "));

 	if (actual_spec.iFontStyle.Posture() == EPostureItalic)

 		INFO_PRINTF1(_L("italic "));

 	INFO_PRINTF2(_L("%dpt"),(actual_spec.iHeight + 10) / 20);

 	INFO_PRINTF1(_L("\n"));

 	iFontStore->ReleaseFont(font);

 	TEST (iHeap->__DbgMarkEnd(0) == 0);

 	}

 /**

 	@SYMTestCaseID

 	GRAPHICS-FNTSTORE-0032

 	@SYMTestCaseDesc

 	Creates fonts and tests their properties

 	and then releases them.

 	@SYMTestActions

 	1. Adds four files to the font store.

 	2. Retrieves number of typefaces.

 	3. For all of the typefaces available it gets

 	   the typeface support and retrieves its font height

 	   in twips.

 	4. Tests the fonts properties.

 	5. Releases a hold on all font file objects allocated.

 	@SYMTestExpectedResults

 	Test should pass

 */

 void CTFsOpen::CreateAndReleaseFontsL()

 	{

 	TUid id1 = iFontStore->AddFileL(KFontDummy);

 	TUid id2 = iFontStore->AddFileL(KFontDummy_b);

 	TUid id3 = iFontStore->AddFileL(KFontDummy_i);

 	TUid id4 = iFontStore->AddFileL(KFontDummy_bi);

 	int typefaces = iFontStore->NumTypefaces();

 	for (int typeface = 0; typeface < typefaces; typeface++)

 		{

 		TTypefaceSupport support;

 		iFontStore->TypefaceSupport(support,typeface);

 		TFontSpec fs;

 		fs.iTypeface = support.iTypeface;

 		for (int height = 0; height < support.iNumHeights; height++)

 			{

 			fs.iHeight = iFontStore->FontHeightInTwips(typeface,height);

 			TestFont(fs);

 			}

 		}

 	iFontStore->RemoveFile(id1);

 	iFontStore->RemoveFile(id2);

 	iFontStore->RemoveFile(id3);

 	iFontStore->RemoveFile(id4);

 	}

 /**

 @file

 @SYMTestCaseID				GRAPHICS-SYSLIB-FNTSTORE-UT-1498

 @SYMTestCaseDesc 			Test the Shaper API  

 @SYMTestPriority 			High

 @SYMTestActions  			This test checks the CBitmapFont::ShapeTextL() using a dummy font and a dummy shaper

 @SYMTestExpectedResults		The test must not fail.

 @SYMPREQ					PREQ18

 */

 void CTFsOpen::CreateShaperL()

 	{

 	__UHEAP_MARK;

 	INFO_PRINTF1(_L("Creating Shaper and Shaping Text\n"));

 	// Add fonts

 	TUid id1 = iFontStore->AddFileL(KFontDummy);

 	TUid id2 = iFontStore->AddFileL(KFontDummy_b);

 	TUid id3 = iFontStore->AddFileL(KFontDummy_i);

 	TUid id4 = iFontStore->AddFileL(KFontDummy_bi);

 	TInt error = 0;

 	TInt err = 0;

 	int typefaces = iFontStore->NumTypefaces();

 	for (TInt typeface = 0; typeface < typefaces; typeface++)

 		{

 		TTypefaceSupport support;

 		iFontStore->TypefaceSupport(support,typeface);

 		TFontSpec fs;

 		fs.iTypeface = support.iTypeface;

 		for (TInt height = 0; height < support.iNumHeights; height++)

 			{

 			//Create a font

 			CFont* font = NULL;

 			fs.iHeight = iFontStore->FontHeightInTwips(typeface,height);

 			// get a COpenFont object

 			iFontStore->GetNearestFontToDesignHeightInPixels(font, fs);	

 			CleanupStack::PushL(font);

 			 //do some dummy shaping

 			TShapeHeader* shape = 0;

 			TShapeMessageParameters params;

 			params.iStart = 0;

 			params.iEnd = 8;

 			params.iScript = KDevanagariScriptCode;

 			params.iLanguage = 0;

 			TRAP(err, shape = ((CBitmapFont*)font)->ShapeTextL(KTextToShape, 0, params));

 			TEST(err == KErrNotSupported);

 			// Now do some dummy deletion of the TShapeHeader

 			TInt dummyHandle=0;

 			TRAP(error, ((CBitmapFont*)font)->DeleteShape(dummyHandle,shape));

 			TEST(error == KErrNone);

 			CleanupStack::Pop(font);

 			iFontStore->ReleaseFont(font);

 			}

 		}

 	// Remove the fonts

 	iFontStore->RemoveFile(id1);

 	iFontStore->RemoveFile(id2);

 	iFontStore->RemoveFile(id3);

 	iFontStore->RemoveFile(id4);	

 	__UHEAP_MARKEND;	

 	}

 /** End of Shaper Tests*/

 /**

 	@SYMTestCaseID

 	GRAPHICS-FNTSTORE-0033

 	@SYMTestCaseDesc

 	Tests the GetNearestFontHelper function. This function may be used by 

 	derived classes in their GetNearestFontInPixelsL() 

 	implementations. It finds the nearest font in the typeface attribute array, 

 	if any, to the provided font specification. If there is a possible match it 

 	places the face index in aFaceIndex and the actual specification (including 

 	algorithmic effects) in aActualFontSpec.

 	@SYMTestActions

 	1. Connects to the file system.

 	2. Finds a specified file.

 	3. Retrieves a font file.

 	4. Sets different font attributes.

 	5. Calls the GetNearestFontHelper and GetNearestFontHelperOld functions.

 	6. Checks if the two functions give the same result.

 	@SYMTestExpectedResults

 	Test should pass

 */

 #ifdef _DEBUG

 void CTFsOpen::TestGetNearestFontHelperL()

 	{

 	INFO_PRINTF1(_L("GetNearestFontHelper\n"));

 	User::LeaveIfError(iFilesys.Connect());

 	TFindFile file_finder(iFilesys);

 	CDir* file_list = NULL;

 	_LIT(KFBSERVFontFilePattern, "*.ttf");

 	TInt error = file_finder.FindWildByDir(KFBSERVFontFilePattern,KFBSERVFontDir,file_list);

 	while (!error)

 		{

 		CleanupStack::PushL(file_list);

 		for (int i = 0; i < file_list->Count(); i++)

 			{

 			TParse parse;

 			if (parse.Set((*file_list)[i].iName,&file_finder.File(),NULL) == KErrNone)

 				{

 				TPtrC name = parse.Name();

 				INFO_PRINTF2(_L("Font file: %S\r\n"), &name);

 				CDummyFontFile* font_file = CDummyFontFile::NewL(0,parse.FullName());

 				TOpenFontSpec font_spec1;

 				TOpenFontSpec font_spec2_new;

 				TOpenFontSpec font_spec2_old;

 				TInt face_index = 0;

 				font_spec1.SetName(KNullDesC);

 				font_spec1.SetHeight(10);

 				font_spec1.SetCoverage(0,0,0,0);

 				font_spec1.SetBold(EFalse);

 				font_spec1.SetItalic(EFalse);

 				font_spec1.SetSerif(EFalse);

 				font_spec1.SetMonoWidth(EFalse);

 				TBool res1 = font_file->GetNearestFontHelper(font_spec1,0,0,face_index,font_spec2_new);

 				TBool res2 = font_file->GetNearestFontHelperOld(font_spec1,0,0,face_index,font_spec2_old);

 				TEST(res2 ? res1 && (font_spec2_new == font_spec2_old) : ETrue);

 				font_spec1.SetBold(ETrue);

 				res1 = font_file->GetNearestFontHelper(font_spec1,0,0,face_index,font_spec2_new);

 				res2 = font_file->GetNearestFontHelperOld(font_spec1,0,0,face_index,font_spec2_old);

 				TEST(res2 ? res1 && (font_spec2_new == font_spec2_old) : ETrue);

 				font_spec1.SetItalic(ETrue);

 				res1 = font_file->GetNearestFontHelper(font_spec1,0,0,face_index,font_spec2_new);

 				res2 = font_file->GetNearestFontHelperOld(font_spec1,0,0,face_index,font_spec2_old);

 				TEST(res2 ? res1 && (font_spec2_new == font_spec2_old) : ETrue);

 				font_spec1.SetSerif(ETrue);

 				res1 = font_file->GetNearestFontHelper(font_spec1,0,0,face_index,font_spec2_new);

 				res2 = font_file->GetNearestFontHelperOld(font_spec1,0,0,face_index,font_spec2_old);

 				TEST(res2 ? res1 && (font_spec2_new == font_spec2_old) : ETrue);

 				font_spec1.SetMonoWidth(ETrue);

 				res1 = font_file->GetNearestFontHelper(font_spec1,0,0,face_index,font_spec2_new);

 				res2 = font_file->GetNearestFontHelperOld(font_spec1,0,0,face_index,font_spec2_old);

 				TEST(res2 ? res1 && (font_spec2_new == font_spec2_old) : ETrue);

 				font_spec1.SetCoverage(8);

 				font_spec1.SetBold(EFalse);

 				font_spec1.SetItalic(EFalse);

 				font_spec1.SetSerif(EFalse);

 				font_spec1.SetMonoWidth(EFalse);

 				res1 = font_file->GetNearestFontHelper(font_spec1,0,0,face_index,font_spec2_new);

 				res2 = font_file->GetNearestFontHelperOld(font_spec1,0,0,face_index,font_spec2_old);

 				TEST(res2 ? res1 && (font_spec2_new == font_spec2_old) : ETrue);

 				delete font_file;

 				}

 			}

 		CleanupStack::PopAndDestroy(); // file_list

 		if (!error)

 			error = file_finder.FindWild(file_list);

 		}

 	}

 #endif //_DEBUG

 CDummyRasterizer* CDummyRasterizer::NewL()

 	{

 	return new(ELeave) CDummyRasterizer;

 	}

 COpenFontFile* CDummyRasterizer::NewFontFileL(TInt aUid,const TDesC& aFileName,RFs& /*aFileSession*/)

 	{

 	// Allow 'dummy', 'dummy_b', etc. Don't actually open a file; just create a dummy font.

 	if (aFileName.CompareF(KFontDummy) == 0 ||

 		aFileName.CompareF(KFontDummy_b) == 0 ||

 		aFileName.CompareF(KFontDummy_i) == 0 ||

 		aFileName.CompareF(KFontDummy_bi) == 0)

 		return CDummyFontFile::NewL(aUid,aFileName);

 	return NULL;

 	}

 CDummyFontFile::CDummyFontFile(TInt aUid,const TDesC& aFileName):

 	COpenFontFile(aUid,aFileName)

 	{

 	}

 CDummyFontFile* CDummyFontFile::NewL(TInt aUid,const TDesC& aFileName)

 	{

 	CDummyFontFile* f = new(ELeave)CDummyFontFile(aUid,aFileName);

 	CleanupStack::PushL(f);

 	f->ConstructL();

 	CleanupStack::Pop();

 	return f;

 	}

 TBool CDummyFontFile::GetNearestFontHelperOld(const TOpenFontSpec& aDesiredFontSpec,TInt aPixelWidth,TInt aPixelHeight,

 											  TInt& aFaceIndex,TOpenFontSpec& aActualFontSpec) const

 	{

 	return COpenFontFile::GetNearestFontHelperOld(aDesiredFontSpec,aPixelWidth,aPixelHeight,aFaceIndex,aActualFontSpec);

 	}

 void CDummyFontFile::ConstructL()

 	{

 	const TDesC& filename = FileName();

 	TOpenFontFaceAttrib attrib;

 	if (filename.CompareF(KFontDummy) == 0)

 		attrib.SetFullName(_L("Dummy"));

 	else if (filename.CompareF(KFontDummy_b) == 0)

 		{

 		attrib.SetFullName(_L("Dummy Bold"));

 		attrib.SetBold(TRUE);

 		}

 	else if (filename.CompareF(KFontDummy_i) == 0)

 		{

 		attrib.SetFullName(_L("Dummy Italic"));

 		attrib.SetItalic(TRUE);

 		}

 	else if (filename.CompareF(KFontDummy_bi) == 0)

 		{

 		attrib.SetFullName(_L("Dummy Bold Italic"));

 		attrib.SetBold(TRUE);

 		attrib.SetItalic(TRUE);

 		}

 	attrib.SetFamilyName(_L("Dummy"));

 	attrib.SetLocalFullName(attrib.FullName());

 	attrib.SetCoverage(TOpenFontFaceAttrib::ELatinSet);

 	attrib.SetMinSizeInPixels(8);

 	AddFaceL(attrib);

 	}

 void CDummyFontFile::GetNearestFontInPixelsL(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList,

 											 const TOpenFontSpec& aDesiredFontSpec,TInt aPixelWidth,TInt aPixelHeight,

 											 COpenFont*& aFont,TOpenFontSpec& aActualFontSpec)

 	{

 	aFont = NULL;

 	TInt face_index = 0;

 	if (GetNearestFontHelper(aDesiredFontSpec,aPixelWidth,aPixelHeight,face_index,aActualFontSpec))

 		aFont = CDummyFont::NewL(aHeap,aSessionCacheList,this,aActualFontSpec.Height());

 	}

 void CDummyFontFile::GetNearestFontToDesignHeightInPixelsL(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList,

 											 const TOpenFontSpec& aDesiredFontSpec,TInt aPixelWidth,TInt aPixelHeight,

 											 COpenFont*& aFont,TOpenFontSpec& aActualFontSpec)

 	{

 	aFont = NULL;

 	TInt face_index = 0;

 	if (GetNearestFontHelper(aDesiredFontSpec,aPixelWidth,aPixelHeight,face_index,aActualFontSpec))

 		aFont = CDummyFont::NewL(aHeap,aSessionCacheList,this,aActualFontSpec.Height());

 	}

 void CDummyFontFile::GetNearestFontToMaxHeightInPixelsL(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList,

 											 const TOpenFontSpec& aDesiredFontSpec,TInt aPixelWidth,TInt aPixelHeight,

 											 COpenFont*& aFont,TOpenFontSpec& aActualFontSpec,TInt /*aMaxHeight*/)

 	{

 	aFont = NULL;

 	TInt face_index = 0;

 	if (GetNearestFontHelper(aDesiredFontSpec,aPixelWidth,aPixelHeight,face_index,aActualFontSpec))

 		aFont = CDummyFont::NewL(aHeap,aSessionCacheList,this,aActualFontSpec.Height());

 	}

 TBool CDummyFontFile::HasUnicodeCharacterL(TInt /*aFaceIndex*/,TInt /*aCode*/) const

 	{

 	return EFalse; // this dummy font has no characters

 	}

 CDummyFont* CDummyFont::NewL(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList,

 							 CDummyFontFile* aFontFile,TInt aSizeInPixels)

 	{

 	CDummyFont* f = (CDummyFont*)aHeap->AllocL(sizeof(CDummyFont));

 	new(f) CDummyFont(aHeap,aSessionCacheList,aFontFile,aSizeInPixels);

 	return f;

 	}

 CDummyFont::CDummyFont(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList,CDummyFontFile* aFontFile,

 					   TInt aSizeInPixels):

 	COpenFont(aHeap,aSessionCacheList,aFontFile)

 	{

 	iMetrics.SetSize(aSizeInPixels);

 	iMetrics.SetAscent(aSizeInPixels * 3 / 4);

 	iMetrics.SetDescent(aSizeInPixels - iMetrics.Ascent());

 	iMetrics.SetMaxHeight(iMetrics.Ascent());

 	iMetrics.SetMaxDepth(iMetrics.Descent());

 	iMetrics.SetMaxWidth(aSizeInPixels * 2);

 	}

 void CDummyFont::RasterizeL(TInt /*aCode*/,TOpenFontGlyphData* /*aGlyphData*/)

 	{

 	User::Leave(KErrNotSupported); // this dummy font has no glyphs

 	}

 static void ExpandCleanupStackL()

 	{

 	TInt count = 0;

 	for (; count < 10; count++)

 		CleanupStack::PushL((TUint32*)0x1);

 	CleanupStack::Pop(count);

 	}

 //--------------

 __CONSTRUCT_STEP__(FsOpen)

 void CTFsOpenStep::TestSetupL()

 	{

 	ExpandCleanupStackL();

 	}