--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/fontstore/tfs/T_FSOPEN.CPP	Tue Feb 02 02:02:46 2010 +0200
@@ -0,0 +1,699 @@
+/*
+* 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();
+	}