diff -r 000000000000 -r 5d03bc08d59c graphicstest/uibench/src/tfbsfonthandleperf.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graphicstest/uibench/src/tfbsfonthandleperf.cpp Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,1128 @@ +// Copyright (c) 2005-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: +// fbsfonthandleperf.cpp +// +// + +/** + @file + @test + @internalComponent - Internal Symbian test code +*/ + +#include "tfbsfonthandleperf.h" +#include + +const TInt KIterationsToTest = 150; +const TInt KShortIterationsToTest = 100; +const TInt KMinimumIterations = 51; +const TInt KEqual = 0; + +// Define font typefaces to test +_LIT(KTestOpenFontName,"DejaVu Sans Condensed"); +_LIT(KTestFontTypefaceFnt,"fnt"); +_LIT(KTestInvalidFontName,"Invalid"); +_LIT(KHindiFontName,"Devanagari OT Eval"); +_LIT(KHindiShort,"\x0915\x094D\x0937\x0924\x094D\x0930\x093F\x092F\x0020"); // 9 characters +_LIT(KEnglishShort,"The quick"); //9 characters +_LIT(K4thFontText,"HALGEBICK"); //9 characters from LinkedFont1 +_LIT(KWithoutlinkedfont,"Withoutlinkedfont"); + +// hindi sample text - these have repeat characters - alternative phrases - use number 9 since it is the longest +// sample 1 +#if 0 +_LIT16(KHindi1,"\x0915\x094D\x0937\x0924\x094D\x0930\x093F\x092F\x0020\x0909\x0926\x094D\x0926\x0947\x0936\x094D\x0020\x0915\x094D\x0937\x093F\x092A\x094D\x0930"); +_LIT16(KHindi2,"\x092d\x0942\x0930\x094d\x092d\x0941\x0935\x0903\x0020\x0938\x094d\x0935\x0903\x0020\x0924\x0924\x094d\x0938\x0935\x093f\x0924\x0941\x0930\x094d\x0935\x0930\x0947\x0923\x094d\x092f\x0902"); +_LIT16(KHindi3,"\x092d\x0930\x094d\x0917\x094b\x0020\x0926\x0947\x0935\x0938\x094d\x092f\x0020\x0927\x0940\x092e\x0939\x093f\x0020\x0927\x093f\x092f\x094b\x0020\x092f\x094b\x0928\x0903\x0020\x092a\x094d\x0930\x091a\x094b\x0926\x092f\x093e\x0924\x094d\x0020"); + +// sample 2 +_LIT16(KHindi4,"\x092f\x0924\x094d\x0930\x0020\x092f\x094b\x0917\x0947\x0936\x094d\x0935\x0930\x0020\x0915\x0943\x0937\x094d\x0923\x094b\x0020\x092f\x0924\x094d\x0930\x0020\x092a\x093e\x0930\x094d\x0925\x094b\x0020\x0927\x0930\x094d\x0928\x0941\x0927\x0930\x0903"); +_LIT16(KHindi5,"\x0924\x0924\x094d\x0930\x0020\x0936\x094d\x0930\x0940\x0930\x094d\x0935\x093f\x091c\x092f\x094b\x0020\x092d\x0942\x0924\x093f\x0930\x094d\x0927\x0941\x0935\x093e\x0020\x0928\x0940\x0924\x093f\x0930\x094d\x092e\x0924\x093f\x0930\x094d\x092e\x092e"); +_LIT16(KHindi6,"\x0915\x0941\x0924\x0938\x094d\x0924\x094d\x0935\x093e\x0020\x0915\x0936\x094d\x092e\x0932\x092e\x093f\x0926\x0902\x0020\x0935\x093f\x0936\x092e\x0947\x0020\x0938\x092e\x0941\x092a\x0938\x094d\x0925\x093f\x0924\x092e\x094d"); + +// sample 3 +_LIT16(KHindi7,"\x0905\x0928\x093e\x0930\x094d\x092f\x091c\x0941\x0937\x094d\x091f\x092e\x0938\x094d\x0935\x0930\x094d\x0917\x094d\x092f\x092e\x0915\x0940\x0930\x094d\x0924\x093f\x0915\x0930\x092e\x0930\x094d\x091c\x0941\x0928"); +_LIT16(KHindi8,"\x0915\x094d\x0932\x0948\x092c\x094d\x092f\x0902\x0020\x092e\x0020\x0938\x094d\x092e\x0020\x0917\x092e\x0903\x0020\x092a\x093e\x0930\x094d\x0925\x0928\x0948\x0924\x0924\x094d\x0924\x094d\x0935\x092f\x094d\x092f\x0941\x092a\x092a\x0926\x094d\x092f\x0924\x0947"); +#endif + +_LIT16(KHindi9,"\x0915\x094d\x0937\x0941\x0926\x094d\x0930\x0902\x0020\x0939\x0943\x0926\x092f\x0926\x094c\x0930\x094d\x092c\x0932\x094d\x092f\x0902\x0020\x0924\x094d\x092f\x0915\x094d\x0924\x094d\x0935\x094b\x0924\x094d\x0924\x093f\x0937\x094d\x091f\x0020\x092a\x0930\x0902\x0924\x092a");//45 characters +_LIT(KEnglishLong,"The quick brown fox jumped over the lazy dog.");//45 characters + + +/** Information about linked fonts +TLinkedFont1.gdr +Typeface name: LinkedFont1 +This will be the dominant font. It contains 177 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.gdr +Typeface name: LinkedFont2 +Characters available (7): F, J, M, S, Z, a, y. + +TLinkedFont3.gdr +Typeface name: LinkedFont3 +Characters available (4): D, P, x, l + +TLinkedFont4.gdr +Typeface name: LinkedFont4 +Characters available (2): V, n + +Withoutlinkedfont.gdr +Typeface name: Withoutlinkedfont +Characters available: It contains all 190 characters +*/ +//Define fonts to test +_LIT(KDummy, "Dummy"); +_LIT(KDummyBold, "Dummy Bold"); +_LIT(KDummyItalic, "Dummy Italic"); +_LIT(KDummyBoldItalic, "Dummy Bold Italic"); + +//Define font paths to test +_LIT(KFontDummy,"z:\\PlatTest\\Graphics\\TestData\\dummy_fonts\\dummyFont"); +_LIT(KFontDummy_b,"z:\\PlatTest\\Graphics\\TestData\\dummy_fonts\\dummyFont_b"); +_LIT(KFontDummy_i,"z:\\PlatTest\\Graphics\\TestData\\dummy_fonts\\dummyFont_i"); +_LIT(KFontDummy_bi,"z:\\PlatTest\\Graphics\\TestData\\dummy_fonts\\dummyFont_bi"); +_LIT(KBitmapFont,"z:\\PlatTest\\Graphics\\TestData\\ceurope.gdr"); + +//Define Test case names +_LIT(KAddRemoveOpenFontFiles, "Add-and-remove-'OpenFont'-files"); +_LIT(KAddOpenedOpenFontFiles, "Add-opened-'OpenFont'-files"); +_LIT(KAddRemoveBitmapFontFiles, "Add-and-remove-bitmap-font-files"); +_LIT(KAddOpenedBitmapFontFiles, "Add-opened-bitmap-font-files"); +_LIT(KFindFontSize, "FontSize"); +_LIT(KAliasedFont,"PerftestAliasedFont"); +_LIT(KFontSansSerif,"DejaVu Sans Condensed"); +_LIT(KFontCreationSansSerif,"FontCreationSansSerif"); +_LIT(KFontCreationAliasedFont,"FontCreationAliasedFont"); + +//*********** DummyFontFile *****************// +/* DummyFontFile class is used to create the Dummy Font File without actually +creating the Font. It is used in AddAndRemoveFilesL() testcase. +*/ +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; + } + +CDummyFontFile::~CDummyFontFile() + { + iFile.Close(); + iFs.Close(); + } + +//*********** Pure Virtual Functions of COpenFontFile **********// +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()); + } + } + +TBool CDummyFontFile::HasUnicodeCharacterL(TInt /*aFaceIndex*/, TInt /*aCode*/) const + { + return EFalse; // this dummy font has no characters + } + +//---------------------------------------------Pure Virtual Functions---------// +void CDummyFontFile::ConstructL() + { + const TDesC& filename = FileName(); + + // for comparative benchmarking at least open the file + User::LeaveIfError(iFs.Connect()); + const TInt openError = iFile.Open(iFs, filename, EFileRead | EFileShareReadersOnly); + User::LeaveIfError(openError); + + // check that file is > 0 bytes + TInt fontFileSize = 0; + User::LeaveIfError(iFile.Size(fontFileSize)); + if (fontFileSize == 0) + { + User::Leave(KErrEof); + } + + TOpenFontFaceAttrib attrib; + + if (KEqual == filename.CompareF(KFontDummy)) + attrib.SetFullName(KDummy); + else if (KEqual == filename.CompareF(KFontDummy_b)) + { + attrib.SetFullName(KDummyBold); + attrib.SetBold(TRUE); + } + else if (KEqual == filename.CompareF(KFontDummy_i)) + { + attrib.SetFullName(KDummyItalic); + attrib.SetItalic(TRUE); + } + else if (KEqual == filename.CompareF(KFontDummy_bi)) + { + attrib.SetFullName(KDummyBoldItalic); + attrib.SetBold(TRUE); + attrib.SetItalic(TRUE); + } + attrib.SetFamilyName(KDummy); + attrib.SetLocalFullName(attrib.FullName()); + attrib.SetCoverage(TOpenFontFaceAttrib::ELatinSet); + attrib.SetMinSizeInPixels(8); + + AddFaceL(attrib); + } + +//*------------------------------------DummyFontFile--*/ + +//************ DummyRasterizer***************// +/* DummyRasterizer class is used in AddAndRemoveFilesL() Test case to use the +Dummy Rasterizer without actually installing the system rasterizer. +*/ +CDummyRasterizer* CDummyRasterizer::NewL() + { + return new(ELeave) CDummyRasterizer; + } + +COpenFontFile* CDummyRasterizer::NewFontFileL(TInt aUid, + const TDesC& aFileName, + RFs& /*aFileSession*/) + { + // Allow 'dummy' 'dummy_bold' 'dummy_italic' 'dummy_bold_italic'. + //Don't actually open a file; just create a dummy font. + if (KEqual == aFileName.CompareF(KFontDummy)|| + KEqual == aFileName.CompareF(KFontDummy_b)|| + KEqual == aFileName.CompareF(KFontDummy_i)|| + KEqual == aFileName.CompareF(KFontDummy_bi)) + { + return CDummyFontFile::NewL(aUid,aFileName); + } + return NULL; + } +//*------------------------------------DummyRasterizer--*// + +//************ DummyFont***************// +/* +DummyFont is used to create a Dummy Font without actually installing it. +It is used by AddAndRemoveFilesL() Testcase. +*/ +CDummyFont* CDummyFont::NewL(RHeap* aHeap,COpenFontSessionCacheList* aSessionCacheList, + CDummyFontFile* aFontFile,TInt aSizeInPixels) + { + CDummyFont* f = reinterpret_cast(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 + } + +//*------------------------------------DummyFont--*// + +CTFbsFontHandlePerf::CTFbsFontHandlePerf() + { + SetTestStepName(KTFbsFontHandlePerfName); + } + +TVerdict CTFbsFontHandlePerf::doTestStepPreambleL() + { + CTe_graphicsperformanceSuiteStepBase::doTestStepPreambleL(); + SetScreenModeL(EColor16MU); + iDevice = &iScreenDevice->BitmapDevice(); + return TestStepResult(); + } + +/** +Override of base class pure virtual +Our implementation only gets called if the base class doTestStepPreambleL() did +not leave. That being the case, the current test result value will be EPass. + +@return - TVerdict code +*/ +TVerdict CTFbsFontHandlePerf::doTestStepL() + { + // Created Linked font with only one typeface + _LIT(KLinkedTypeface,"LinkedTypefaceTest"); + CLinkedTypefaceSpecification *typefaceSpec = CLinkedTypefaceSpecification::NewLC(KLinkedTypeface); + + const TInt KGroup1Id = 1; + CLinkedTypefaceGroup* group1 = CLinkedTypefaceGroup::NewLC(KGroup1Id); + typefaceSpec->AddLinkedTypefaceGroupL(*group1); + CleanupStack::Pop(group1); + + CLinkedTypefaceElementSpec* element1 = CLinkedTypefaceElementSpec::NewLC(KTestOpenFontName, KGroup1Id); + element1->SetCanonical(ETrue); + + typefaceSpec->AddTypefaceAtIndexL(*element1, 0); + CleanupStack::Pop(element1); + + CFbsTypefaceStore* ts = CFbsTypefaceStore::NewL(iDevice); + CleanupStack::PushL(ts); + TInt ret; + ret = ts->RegisterLinkedTypeface(*typefaceSpec); + CleanupStack::PopAndDestroy(2, typefaceSpec); + if (ret == KErrNotSupported) + { + //If the rasterizer does not support the linked fonts feature do not continue the test: + //log and do not fail test. + INFO_PRINTF1(_L("Linked fonts feature is not supported by rasterizer")); + } + else + { + TEST(ret == KErrNone); + + _LIT(KLinkedTypefaceHindi,"HindiLinked"); + typefaceSpec = CLinkedTypefaceSpecification::NewLC(KLinkedTypefaceHindi); + + group1 = CLinkedTypefaceGroup::NewLC(KGroup1Id); + typefaceSpec->AddLinkedTypefaceGroupL(*group1); + CleanupStack::Pop(group1); + + element1 = CLinkedTypefaceElementSpec::NewLC(KHindiFontName, KGroup1Id); + element1->SetCanonical(ETrue); + typefaceSpec->AddTypefaceAtBackL(*element1); + CleanupStack::Pop(element1); + + ts = CFbsTypefaceStore::NewL(iDevice); + CleanupStack::PushL(ts); + ret = ts->RegisterLinkedTypeface(*typefaceSpec); + TEST(ret == KErrNone); + CleanupStack::PopAndDestroy(2, typefaceSpec); + + //register a linked typeface with four fonts. + _LIT(KFourLinked,"FourBitmapLinked"); + _LIT(KLinkedTypeFace1, "DejaVu Sans Condensed"); + _LIT(KLinkedTypeFace2, "Devanagari OT Eval"); + _LIT(KLinkedTypeFace3, "TBKomachiG-R"); + _LIT(KLinkedTypeFace4, "DejaVu Serif Condensed"); + + typefaceSpec = CLinkedTypefaceSpecification::NewLC(KFourLinked); + + group1 = CLinkedTypefaceGroup::NewLC(KGroup1Id); + typefaceSpec->AddLinkedTypefaceGroupL(*group1); + CleanupStack::Pop(group1); + + const TInt KGroup2Id = 4; + CLinkedTypefaceGroup* group2 = CLinkedTypefaceGroup::NewLC(KGroup2Id); + typefaceSpec->AddLinkedTypefaceGroupL(*group2); + CleanupStack::Pop(group2); + + const TInt KGroup3Id = 4; + CLinkedTypefaceGroup* group3 = CLinkedTypefaceGroup::NewLC(KGroup3Id); + typefaceSpec->AddLinkedTypefaceGroupL(*group3); + CleanupStack::Pop(group3); + + element1 = CLinkedTypefaceElementSpec::NewLC(KLinkedTypeFace1, KGroup1Id); + element1->SetCanonical(ETrue); + typefaceSpec->AddTypefaceAtBackL(*element1); + CleanupStack::Pop(element1); + + CLinkedTypefaceElementSpec* element2 = CLinkedTypefaceElementSpec::NewLC(KLinkedTypeFace2, KGroup2Id); + typefaceSpec->AddTypefaceAtBackL(*element2); + CleanupStack::Pop(element2); + + CLinkedTypefaceElementSpec* element3 = CLinkedTypefaceElementSpec::NewLC(KLinkedTypeFace3, KGroup3Id); + typefaceSpec->AddTypefaceAtBackL(*element3); + CleanupStack::Pop(element3); + + CLinkedTypefaceElementSpec* element4 = CLinkedTypefaceElementSpec::NewLC(KLinkedTypeFace4, KGroup3Id); + typefaceSpec->AddTypefaceAtBackL(*element4); + CleanupStack::Pop(element4); + + ts = CFbsTypefaceStore::NewL(iDevice); + CleanupStack::PushL(ts); + ret = ts->RegisterLinkedTypeface(*typefaceSpec); + TEST(ret == KErrNone); + CleanupStack::PopAndDestroy(2, typefaceSpec); + + _LIT(KOneLinked,"OneLinked"); + typefaceSpec = CLinkedTypefaceSpecification::NewLC(KOneLinked); + + group1 = CLinkedTypefaceGroup::NewLC(KGroup1Id); + typefaceSpec->AddLinkedTypefaceGroupL(*group1); + CleanupStack::Pop(group1); + + element1 = CLinkedTypefaceElementSpec::NewLC(KLinkedTypeFace1, KGroup1Id); + element1->SetCanonical(ETrue); + typefaceSpec->AddTypefaceAtBackL(*element1); + CleanupStack::Pop(element1); + + ts = CFbsTypefaceStore::NewL(iDevice); + CleanupStack::PushL(ts); + TRAP(ret, typefaceSpec->RegisterLinkedTypefaceL(*ts)); + TEST(ret == KErrNone); + + TEST(typefaceSpec->RemoveTypeface(3) == KErrNone); + + TRAP(ret, typefaceSpec->UpdateLinkedTypefaceL(*ts)); + + TEST(ret == KErrNone); + + CleanupStack::PopAndDestroy(2, typefaceSpec); + + /** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0052 + + @SYMTestType UT + + @SYMTestPriority Critical + + @SYMPREQ PREQ1431 + + @SYMTestCaseDesc + Test performance timing of linked font creation + + @SYMTestActions + Create a linked font from linked typeface with 1 component font. + + @SYMTestExpectedResults + Measure performance compared with non-linked font + */ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0052")); + + FontGetNearestFontToDesignHeightInPixelsL(KLinkedTypeface, _L("Font-GetNearest-1stLinkedTypeface-Open")); + TInt getNearestFont1stLinkedTime = iProfiler->GetTrimedMean(); + + FontGetNearestFontToDesignHeightInPixelsL(KFourLinked, _L("Font-GetNearest-4LinkedTypeface-Bitmap")); + TInt getNearestFont4thLinkedTime = iProfiler->GetTrimedMean(); + + FontGetNearestFontToDesignHeightInPixelsL(KOneLinked, _L("Font-GetNearest-1LinkedTypeface-Bitmap")); + TInt getNearestFont1stBitmapLinkedTime = iProfiler->GetTrimedMean(); + RecordTestResultL(); + /** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0053 + + @SYMTestType UT + + @SYMTestPriority Critical + + @SYMPREQ PREQ1431 + + @SYMTestCaseDesc + Test performance timing of linked font character access without glyph cache + + @SYMTestActions + Check performance on first access to character in first font of linked font where same character in component font has not yet been accessed + + @SYMTestExpectedResults + Measure performance compared with non-linked font access + */ + // These must be first to avoid using glyph cache + FontDrawStringWithoutGlyphCacheL(KLinkedTypeface, _L("Font-Drawtext-NoCache-1stLinkedTypeface-Open"), 10, KEnglishShort); + TInt drawText1stLinkedWithoutGlyphCacheTime = iProfiler->GetTrimedMean(); + + FontDrawStringWithoutGlyphCacheL(KTestOpenFontName, _L("Font-Drawtext-NoCache-Non-LinkedTypeface-Open"), 11, KEnglishShort); + TInt drawTextNonLinkedWithoutGlyphCacheTime = iProfiler->GetTrimedMean(); + + INFO_PRINTF2(_L("--Font linking DrawText without glyph cache performance compared with non-linked font: %d percent"), iProfiler->PercentageChange(drawTextNonLinkedWithoutGlyphCacheTime, drawText1stLinkedWithoutGlyphCacheTime)); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0053")); + + //now testing complex fonts. + INFO_PRINTF1(_L("Hindi Text output - without Glyph cache")); + FontDrawStringWithoutGlyphCacheL(KLinkedTypefaceHindi, _L("Font-Drawtext-NoCache-Complex-Linked-Open"), 10, KHindiShort); + TInt drawTextHindiLinkedWithoutGlyphCacheTime = iProfiler->GetTrimedMean(); + + FontDrawStringWithoutGlyphCacheL(KHindiFontName, _L("Font-Drawtext-NoCache-Non-Linked-Complex-Open"), 11, KHindiShort); + TInt drawTextHindiNonLinkedWithoutGlyphCacheTime = iProfiler->GetTrimedMean(); + INFO_PRINTF2(_L("--Complex Font linking DrawText without glyph cache performance compared with non-linked font: %d percent"), iProfiler->PercentageChange(drawTextHindiNonLinkedWithoutGlyphCacheTime, drawTextHindiLinkedWithoutGlyphCacheTime)); + + //Compare the difference of complex and normal fonts. + INFO_PRINTF2(_L("Time difference between complex font and regular font (non linked) %d percent"), iProfiler->PercentageChange(drawTextNonLinkedWithoutGlyphCacheTime,drawTextHindiLinkedWithoutGlyphCacheTime)); + + //try drawing text with bitmap fonts + FontDrawStringWithoutGlyphCacheL(KFourLinked, _L("Font-Drawtext-NoCache-Linked Typeface 4th Bitmap"), 11, K4thFontText); + TInt drawTextWithoutGlyphCacheTime4thBitmap = iProfiler->GetTrimedMean(); + + //for comparision - without any linking + FontDrawStringWithoutGlyphCacheL(KWithoutlinkedfont, _L("Font-Drawtext-No Cache-Non Linked Typeface"), 11, K4thFontText); + TInt drawTextWithoutGlyphCacheTimeAllBitmap = iProfiler->GetTrimedMean(); + + //for comparision - linked, with one linked font + FontDrawStringWithoutGlyphCacheL(KOneLinked, _L("Font-Drawtext-No Cache Linked Typeface 1st Bitmap"), 11, K4thFontText); + TInt drawTextWithoutGlyphCacheTime1stBitmap = iProfiler->GetTrimedMean(); + + //Compare the difference of linked and non linked fonts. + INFO_PRINTF2(_L("Non cached Time difference between non linked font and 4th font down (bitmap) %d percent"), iProfiler->PercentageChange(drawTextWithoutGlyphCacheTimeAllBitmap,drawTextWithoutGlyphCacheTime4thBitmap)); + + //Compare the difference of linked and lined 4th font down. + INFO_PRINTF2(_L("Non cached Time difference between 1st linked font and 4th font down (bitmap) %d percent"), iProfiler->PercentageChange(drawTextWithoutGlyphCacheTime1stBitmap,drawTextWithoutGlyphCacheTime4thBitmap)); + + RecordTestResultL(); + /** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0054 + + @SYMTestType UT + + @SYMTestPriority Critical + + @SYMPREQ PREQ1431 + + @SYMTestCaseDesc + Test performance timing of linked font character access with glyph cache + + @SYMTestActions + Check performance on access to character in first font of linked font where same character in component font has been already accessed and stored in the glyph cache + + @SYMTestExpectedResults + Measure performance compared with non-linked font access + */ + // Non-Linked font DrawText + FontDrawTextGlyphCacheL(KLinkedTypeface, _L("Font-Drawtext-Cache-1stLinkedTypeface-Open"),KEnglishLong); + TInt drawText1stLinkedWithGlyphCacheTime = iProfiler->GetTrimedMean(); + + // Linked font DrawText + SetTestStepID(_L("GRAPHICS-UI-BENCH-0054")); + FontDrawTextGlyphCacheL(KTestOpenFontName, _L("Font-Drawtext-Cache-NonLinked-Open"),KEnglishLong); + TInt drawTextNonLinkedWithGlyphCacheTime = iProfiler->GetTrimedMean(); + INFO_PRINTF2(_L("--Font linking DrawText with glyph cache performance compared with non-linked font: %d percent"), iProfiler->PercentageChange(drawTextNonLinkedWithGlyphCacheTime, drawText1stLinkedWithGlyphCacheTime)); + + //Now Hindi with and without + FontDrawTextGlyphCacheL(KLinkedTypefaceHindi, _L("Font-Drawtext-Cache-1stLinkedTypeface-Complex-Open"),KHindi9); + TInt drawText1stComplexLinkedWithGlyphCacheTime = iProfiler->GetTrimedMean(); + + // Non-Linked font DrawText + FontDrawTextGlyphCacheL(KHindiFontName, _L("Font-Drawtext-Cache-NonLinked-Complex-Open"),KHindi9); + TInt drawTextComplexNonLinkedWithGlyphCacheTime = iProfiler->GetTrimedMean(); + INFO_PRINTF2(_L("--Font complex font linking DrawText with glyph cache performance compared with non-linked font: %d percent"), iProfiler->PercentageChange(drawTextComplexNonLinkedWithGlyphCacheTime, drawText1stComplexLinkedWithGlyphCacheTime)); + + //Compare Difference between complex font and normal font + INFO_PRINTF2(_L("--Font complex font not linked DrawText with glyph cache performance compared with non-complex font non linked: %d percent"), iProfiler->PercentageChange(drawTextNonLinkedWithGlyphCacheTime, drawTextComplexNonLinkedWithGlyphCacheTime)); + + //try drawing text with bitmap fonts + FontDrawTextGlyphCacheL(KFourLinked, _L("Font-Drawtext-Cache-Linked Typeface 4th Bitmap"), K4thFontText); + TInt drawTextWithGlyphCacheTime4thBitmap = iProfiler->GetTrimedMean(); + + //for comparision - non linked + FontDrawTextGlyphCacheL(KWithoutlinkedfont, _L("Font-Drawtext-Cache-Non Linked Typeface text as for 4th Bitmap"), K4thFontText); + TInt drawTextWithGlyphCacheTimeAllBitmap = iProfiler->GetTrimedMean(); + + //for comparision - linked at 1st position + FontDrawTextGlyphCacheL(KOneLinked, _L("Font-Drawtext-Cache- Linked Typeface 1st Linked text as for 4th Bitmap"), K4thFontText); + TInt drawTextWithGlyphCacheTime1stBitmap = iProfiler->GetTrimedMean(); + + //Compare the difference of non linked 4th font in stack. + INFO_PRINTF2(_L("Cached Time difference between non linked and 4th font down (bitmap) %d percent"), iProfiler->PercentageChange(drawTextWithGlyphCacheTimeAllBitmap,drawTextWithGlyphCacheTime4thBitmap)); + + //Compare the difference of 1st font in stack and 4th font in stack + INFO_PRINTF2(_L("Cached Time difference between 1st linked font and 4th font down (bitmap) %d percent"), iProfiler->PercentageChange(drawTextWithGlyphCacheTime1stBitmap,drawTextWithGlyphCacheTime4thBitmap)); + + //Compare the difference of non linked and 1st linked in stack + INFO_PRINTF2(_L("Cached Time difference between non linked and 1st font down (bitmap) %d percent"), iProfiler->PercentageChange(drawTextWithGlyphCacheTimeAllBitmap,drawTextWithGlyphCacheTime1stBitmap)); + + RecordTestResultL(); + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0008 + +@SYMTestCaseDesc +Fetches a font with a valid typeface + +@SYMTestActions +Fetch a valid font using FontGetNearestFontToDesignHeightInPixels + +@SYMTestExpectedResults +Measures performance of finding the font speicified +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0008")); + FontGetNearestFontToDesignHeightInPixelsL(KTestOpenFontName, _L("Font-GetNearest-ValidFont")); + TInt getNearestFontNonLinkedTime = iProfiler->GetTrimedMean(); + INFO_PRINTF2(_L("--Font linking GetNearestFont compared with non-linked font: %d percent"), iProfiler->PercentageChange(getNearestFontNonLinkedTime, getNearestFont1stLinkedTime)); + INFO_PRINTF2(_L("--Font linking GetNearestFont 1 linked font compared with linked 4 fonts: %d percent"), iProfiler->PercentageChange(getNearestFont1stBitmapLinkedTime, getNearestFont4thLinkedTime)); + RecordTestResultL(); + } +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0009 + +@SYMTestCaseDesc +Fetches a font with an invalid typeface. + +@SYMTestActions +Fetch a invalid font using FontGetNearestFontToDesignHeightInPixels, this will find the nearest match. +On Techview this by default will give back a bitmap font which is much faster than an Open Font + +@SYMTestExpectedResults +Measures performance of finding a font +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0009")); + FontGetNearestFontToDesignHeightInPixelsL(KTestInvalidFontName, _L("Font-GetNearest-InvalidFont")); + RecordTestResultL(); + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0010 + +@SYMREQ REQ6158 + +@SYMTestCaseDesc +Time to find nearest font when specifying a blank font with no default system typeface name specified + +@SYMTestActions +Ensure no default system typeface name is set and measure time to fetch a blank font typeface name +On Techview this by default will give back a bitmap font "fnt" + +@SYMTestExpectedResults +The time to fetch typeface name +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0010")); + FontGetNearestFontToDesignHeightInPixelsL(KNullDesC, _L("Font-GetNearest-SystemDefaultNoDefault")); + RecordTestResultL(); + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0011 + +@SYMREQ REQ6158 + +@SYMTestCaseDesc +Time to find the nearest font when specifying a blank font with a default system typeface name specified + +@SYMTestActions +Set default system typeface name and measure time to fetch a blank font typeface name +Find a nesrest match font using FontGetNearestFontToDesignHeightInPixels + +@SYMTestExpectedResults +The time to fetch typeface name +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0011")); + ts = CFbsTypefaceStore::NewL(NULL); + CleanupStack::PushL(ts); + ts->SetSystemDefaultTypefaceNameL(KTestFontTypefaceFnt); + FontGetNearestFontToDesignHeightInPixelsL(KNullDesC, _L("Font-GetNearest-SystemDefaultSetDefault")); + // Set system default font back to an emtpy descriptor i.e. turn it off + ts->SetSystemDefaultTypefaceNameL(KNullDesC); + CleanupStack::PopAndDestroy(ts); + + RecordTestResultL(); +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0012 + +@SYMTestCaseDesc +Duplicated a font + +@SYMTestActions +Duplicate a font + +@SYMTestExpectedResults +Measures performance of duplicating a font +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0012")); + FontDuplicateL(); + RecordTestResultL(); + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0048 + +@SYMDEF DEF091107 + +@SYMTestCaseDesc +Measure performance of adding and removing Bitmap font files from a font store. + +@SYMTestActions +Measure the time to add a font file and remove the added font file, repeated 4 times. + +@SYMTestExpectedResults +The time to add and remove a bitmap font file to the font store. +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0048")); + AddAndRemoveFilesL(EFalse); + RecordTestResultL(); + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0049 + +@SYMDEF DEF091107 + +@SYMTestCaseDesc +Measure performance of adding an already opened Bitmap font file to a font store. + +@SYMTestActions +A Bitmap font is loaded into the Font Store. +Measure the time to add the same Bitmap font file again. + +@SYMTestExpectedResults +The time to add an already opened Bitmap font file to the font store. +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0049")); + AddingOpenedFontFilesL(EFalse); + RecordTestResultL(); + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0050 + +@SYMDEF DEF091107 + +@SYMTestCaseDesc +Measure performance of adding and removing Open Font files from a font store. + +@SYMTestActions +Measure the time to add a (dummy) Open Font file and remove the added font file, repeated 4 times. + +@SYMTestExpectedResults +The time to add and remove a dummy Open Font file to the font store. +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0050")); + AddAndRemoveFilesL(ETrue); + RecordTestResultL(); + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0051 + +@SYMDEF DEF091107 + +@SYMTestCaseDesc +Measure performance of adding an already opened Open Font file to a font store. + +@SYMTestActions +A dummy Open Font is loaded into the Font Store. +Measure the time to add the same Open Font file again. + +@SYMTestExpectedResults +The time to add an already opened Open Font file to the font store. +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0051")); + AddingOpenedFontFilesL(ETrue); + RecordTestResultL(); + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0055 + +@SYMDEF DEF095589 + +@SYMTestCaseDesc +Measure performance of finding the fontsize. + +@SYMTestActions +Measure the time to add 4 font files, find the fontsize and remove the 4 added font files. + +@SYMTestExpectedResults +The time to add, find fontsize and remove a dummy font file to the font store. +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0055")); + FindFontSizeL(); + RecordTestResultL(); + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0138 + +@SYMDEF INC127988 + +@SYMTestCaseDesc +Measure performance of creating a non aliased font. + +@SYMTestActions +Measure the time it takes to create a non-aliased font. + +@SYMTestExpectedResults +The time to create a non aliased font is obtained. +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0138")); + NonAliasedFontCreationL(); + RecordTestResultL(); + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0140 + +@SYMDEF INC127988 + +@SYMTestCaseDesc +Measure performance of creating an aliased font. + +@SYMTestActions +Measure the time it takes to create an aliased font (aliased to KFontSansSerif). + +@SYMTestExpectedResults +The time to create an aliased font is obtained. +*/ + SetTestStepID(_L("GRAPHICS-UI-BENCH-0140")); + AliasedFontCreationL(); + RecordTestResultL(); + return TestStepResult(); + } + +// Measure performance for font duplication +void CTFbsFontHandlePerf::FontDuplicateL() + { + CFbsTypefaceStore* ts = CFbsTypefaceStore::NewL(NULL); + CleanupStack::PushL(ts); + CFbsFont* font; + TInt err=ts->GetNearestFontToDesignHeightInPixels((CFont*&)font, TFontSpec(KTestOpenFontName,15)); + User::LeaveIfError(err); + + iProfiler->InitResults(); + for(TInt count=KIterationsToTest; count>=0; --count) + { + CFbsBitGcFont* duplicateFont=new (ELeave) CFbsBitGcFont; + CleanupStack::PushL(duplicateFont); + err=duplicateFont->Duplicate(font->Handle()); + User::LeaveIfError(err); + CleanupStack::PopAndDestroy(duplicateFont); + iProfiler->MarkResultSetL(); + } + TInt64 duration=iProfiler->GetTrimedMean(); + iProfiler->ResultsAnalysis(_L("Font-Duplicate"), 0, 0, 0, KIterationsToTest); + ts->ReleaseFont(font); + CleanupStack::PopAndDestroy(ts); + } + +// Measure performance using get nearest font +void CTFbsFontHandlePerf::FontGetNearestFontToDesignHeightInPixelsL(const TDesC& aFontName, const TDesC& aTestName) + { + CFbsFont* font; + CFbsTypefaceStore* ts = CFbsTypefaceStore::NewL(NULL); + CleanupStack::PushL(ts); + + iProfiler->InitResults(); + for(TInt count=KIterationsToTest; count>=0; --count) + { + TInt err=ts->GetNearestFontToDesignHeightInPixels((CFont*&)font,TFontSpec(aFontName, 15)); + User::LeaveIfError(err); + ts->ReleaseFont(font); // Release font + iProfiler->MarkResultSetL(); + } + TInt64 duration=iProfiler->GetTrimedMean(); + iProfiler->ResultsAnalysis(aTestName, 0, 0, 0, KIterationsToTest); + CleanupStack::PopAndDestroy(ts); + } + +// Add and remove files. +void CTFbsFontHandlePerf::AddAndRemoveFilesL(TBool aTestOpenFont) + { + RHeap* heap = UserHeap::ChunkHeap(NULL,0x10000,0x10000); + if (NULL == heap) + { + _LIT(KLog,"Not enough memory to create heap for test"); + INFO_PRINTF1(KLog); + User::Leave(KErrGeneral); + } + + CFontStore* fontStore = CFontStore::NewL(heap); + CleanupStack::PushL(fontStore); + + // Install the dummy rasterizer. + COpenFontRasterizer* dummyRasterizer = CDummyRasterizer::NewL(); + CleanupStack::PushL(dummyRasterizer); + fontStore->InstallRasterizerL(dummyRasterizer); + CleanupStack::Pop(); + + iProfiler->InitResults(); + for(TInt count=KIterationsToTest; count>=0; --count) + { + if (aTestOpenFont) + { + //Add font files to fontstore + TUid id1 = fontStore->AddFileL(KFontDummy); + TUid id2 = fontStore->AddFileL(KFontDummy_b); + TUid id3 = fontStore->AddFileL(KFontDummy_i); + TUid id4 = fontStore->AddFileL(KFontDummy_bi); + //Remove font files from fontstore + fontStore->RemoveFile(id1); + fontStore->RemoveFile(id2); + fontStore->RemoveFile(id3); + fontStore->RemoveFile(id4); + } + else + { + //Add & remove font file to fontstore + TUid id1=TUid::Null(); + TRAPD(err,id1=fontStore->AddFileL(KBitmapFont)); + if (err!=KErrNone) + { + _LIT(KLog,"Loading font file %S gave error %d"); + INFO_PRINTF3(KLog,&KBitmapFont,err); + User::Leave(err); + } + fontStore->RemoveFile(id1); + // total of 4 times, for comparison with Open Font test + TUid id2 = fontStore->AddFileL(KBitmapFont); + fontStore->RemoveFile(id2); + TUid id3 = fontStore->AddFileL(KBitmapFont); + fontStore->RemoveFile(id3); + TUid id4 = fontStore->AddFileL(KBitmapFont); + fontStore->RemoveFile(id4); + } + + iProfiler->MarkResultSetL(); + } + TInt64 duration=iProfiler->GetTrimedMean(); + if (aTestOpenFont) + { + iProfiler->ResultsAnalysis(KAddRemoveOpenFontFiles, 0, 0, 0, KIterationsToTest); + } + else + { + iProfiler->ResultsAnalysis(KAddRemoveBitmapFontFiles, 0, 0, 0, KIterationsToTest); + } + CleanupStack::PopAndDestroy(fontStore); + + heap->Close(); + } + +// Add fontfile that is already opened. +void CTFbsFontHandlePerf::AddingOpenedFontFilesL(TBool aTestOpenFont) + { + RHeap* heap = UserHeap::ChunkHeap(NULL,0x10000,0x10000); + if (NULL == heap ) + { + User::Leave(KErrGeneral); + } + + CFontStore* fontStore = CFontStore::NewL(heap); + CleanupStack::PushL(fontStore); + + // Install the dummy rasterizer. + COpenFontRasterizer* dummyRasterizer = CDummyRasterizer::NewL(); + CleanupStack::PushL(dummyRasterizer); + fontStore->InstallRasterizerL(dummyRasterizer); + CleanupStack::Pop(); + + // initial load of font file + TUid id = KNullUid; + if (aTestOpenFont) + { + id = fontStore->AddFileL(KFontDummy); + } + else + { + id = fontStore->AddFileL(KBitmapFont); + } + + iProfiler->InitResults(); + for(TInt count=KIterationsToTest; count>=0; --count) + { + //Add font file to fontstore again + if (aTestOpenFont) + { + (void) fontStore->AddFileL(KFontDummy); + } + else + { + (void) fontStore->AddFileL(KBitmapFont); + } + + iProfiler->MarkResultSetL(); + } + TInt64 duration=iProfiler->GetTrimedMean(); + if (aTestOpenFont) + { + iProfiler->ResultsAnalysis(KAddOpenedOpenFontFiles, 0, 0, 0, KIterationsToTest); + } + else + { + iProfiler->ResultsAnalysis(KAddOpenedBitmapFontFiles, 0, 0, 0, KIterationsToTest); + } + CleanupStack::PopAndDestroy(fontStore); + + heap->Close(); + } + +// Measure performance for DrawText without glyph cache +// In order to avoid using the glyph cache a different character must be drawn each time +void CTFbsFontHandlePerf::FontDrawStringWithoutGlyphCacheL(const TDesC& aFontName, const TDesC& aTestName, TInt aFontHeight,const TDesC& aOutputText) + { + CFbsFont* font; + CFbsTypefaceStore* ts = CFbsTypefaceStore::NewL(NULL); + CleanupStack::PushL(ts); + + TInt loopCount; + for (loopCount=0;loopCountGetNearestFontToDesignHeightInPixels((CFont*&)font,TFontSpec(aFontName, aFontHeight)); + aFontHeight+=2; + TEST(err == KErrNone); + iGc->UseFont(font); + + // Construct a descriptor with increasing character codes so that we do not fetch glyphs from the glpyh cache + if (loopCount==0) + iProfiler->InitResults(); + else + iProfiler->StartTimer(); + iGc->DrawText(aOutputText,TPoint(10,100)); + iProfiler->MarkResultSetL(); + ts->ReleaseFont(font); + } + + TInt64 duration=iProfiler->GetTrimedMean(); + iProfiler->ResultsAnalysis(aTestName, 0, 0, 0, KShortIterationsToTest); + CleanupStack::PopAndDestroy(ts); + } + + + +// Measure performance for DrawText using glyph cache +void CTFbsFontHandlePerf::FontDrawTextGlyphCacheL(const TDesC& aFontName, const TDesC& aTestName, const TDesC& aOutputText) + { + CFbsFont* font; + CFbsTypefaceStore* ts = CFbsTypefaceStore::NewL(NULL); + CleanupStack::PushL(ts); + + TInt err=ts->GetNearestFontToDesignHeightInPixels((CFont*&)font,TFontSpec(aFontName, 15)); + TEST(err == KErrNone); + iGc->UseFont(font); + + iGc->DrawText(aOutputText,TPoint(10,100)); + iProfiler->InitResults(); + for(TInt count=KIterationsToTest; count>=0; --count) + { + iGc->DrawText(aOutputText,TPoint(10,100)); + iProfiler->MarkResultSetL(); + } + + TInt64 duration=iProfiler->GetTrimedMean(); + iProfiler->ResultsAnalysis(aTestName, 0, 0, 0, KIterationsToTest); + ts->ReleaseFont(font); // Release font + CleanupStack::PopAndDestroy(ts); + } + + +// Create and release fonts. +void CTFbsFontHandlePerf::FindFontSizeL() + { + RHeap* heap = UserHeap::ChunkHeap(NULL,0x10000,0x10000); + if (NULL == heap ) + { + User::Leave(KErrGeneral); + } + + CFontStore* fontStore = CFontStore::NewL(heap); + CleanupStack::PushL(fontStore); + + // Install the dummy rasterizer. + COpenFontRasterizer* dummyRasterizer = CDummyRasterizer::NewL(); + CleanupStack::PushL(dummyRasterizer); + fontStore->InstallRasterizerL(dummyRasterizer); + CleanupStack::Pop(); + + iProfiler->InitResults(); + for(TInt count=KIterationsToTest; count>=0; --count) + { + //Add font files to fontstore + TUid id1 = fontStore->AddFileL(KFontDummy); + TUid id2 = fontStore->AddFileL(KFontDummy_b); + TUid id3 = fontStore->AddFileL(KFontDummy_i); + TUid id4 = fontStore->AddFileL(KFontDummy_bi); + TInt typefaces = fontStore->NumTypefaces(); + for (TInt typeface = typefaces - 1; typeface >= 0 ; --typeface) + { + TTypefaceSupport support; + fontStore->TypefaceSupport(support,typeface); + TFontSpec fs; + fs.iTypeface = support.iTypeface; + for (int height = 0; height < support.iNumHeights; height++) + { + fs.iHeight = fontStore->FontHeightInTwips(typeface,height); + } + } + //Remove font files from fontstore + fontStore->RemoveFile(id1); + fontStore->RemoveFile(id2); + fontStore->RemoveFile(id3); + fontStore->RemoveFile(id4); + + iProfiler->MarkResultSetL(); + } + + TInt64 duration=iProfiler->GetTrimedMean(); + iProfiler->ResultsAnalysis(KFindFontSize, 0, 0, 0, KIterationsToTest); + + + CleanupStack::PopAndDestroy(fontStore); + heap->Close(); + } + +void CTFbsFontHandlePerf::NonAliasedFontCreationL() + { + CFbsTypefaceStore* ts = CFbsTypefaceStore::NewL(NULL); + CleanupStack::PushL(ts); + FontCreationPerformanceL(ts, KFontSansSerif, KFontCreationSansSerif); + CleanupStack::PopAndDestroy(ts); + } + +void CTFbsFontHandlePerf::AliasedFontCreationL() + { + CFbsTypefaceStore* ts = CFbsTypefaceStore::NewL(NULL); + CleanupStack::PushL(ts); + ts->SetFontNameAliasL(KAliasedFont, KFontSansSerif); + FontCreationPerformanceL(ts, KAliasedFont, KFontCreationAliasedFont); + CleanupStack::PopAndDestroy(ts); + } + +/** Function which is used to measure font creation performance. This is a helper function +and not a stand alone test. The font name is expected to be KFontSansSerif or aliased +to KFontSansSerif. + +@param aTs the CFbsTypefaceStore to be used +@param aFontName the name of the font to be created +@param aTestDescription the description of the test used in logging +*/ +void CTFbsFontHandlePerf::FontCreationPerformanceL(CFbsTypefaceStore* aTs, const TDesC& aFontName, const TDesC& aTestDescription) + { + iProfiler->InitResults(); + CFont* font = NULL; + TFontSpec spec(aFontName, 0); + for(TInt count=KIterationsToTest; count>=0; --count) + { + iProfiler->StartTimer(); + TInt ret = aTs->GetNearestFontToDesignHeightInPixels(font, spec); + iProfiler->MarkResultSetL(); + TEST(ret == KErrNone); + TFontSpec returnedSpecs = font->FontSpecInTwips(); + TEST(returnedSpecs.iTypeface.iName == KFontSansSerif); + aTs->ReleaseFont(font); + } + TInt64 duration=iProfiler->GetTrimedMean(); + iProfiler->ResultsAnalysis(aTestDescription, 0, 0, 0, KIterationsToTest); + }