--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/fontservices/fontstore/tfs/t_linkedfontscomparison.cpp Tue Feb 02 02:02:46 2010 +0200
@@ -0,0 +1,1288 @@
+/*
+* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+
+#include "FNTSTD.H"
+#include "t_linkedfontscomparison.h"
+#include <hal.h>
+#include <test/thashreferenceimages.h>
+#include <linkedfonts.h>
+
+/**
+@file
+
+@SYMPurpose structures used to define linked typefaces used in this test, create and
+use linked typefaces, and check against a hash value
+*/
+
+/** this is for the group entries
+ */
+struct TTGroup
+ {
+ CLinkedTypefaceGroup::TBaselineShift iBaselineShift;
+ CLinkedTypefaceGroup::TScalingOption iScalingOption;
+ TInt iAntiAliasThreshold; //KMinTInt for do not set;
+ TInt iBoldnessPercentage; //KMinTInt for do not set;
+ TInt iItalicAngle; //KMinTInt for do not set;
+ };
+
+/** this is for linked font elements
+ */
+struct TTLinkedFontElement
+ {
+ const TPtrC iTypefaceName;
+ TInt iGroup;
+ TBool iIsCanonical;
+ };
+
+/** this is for the linked typeface table
+ */
+struct TTLinkedTypeface
+ {
+ const TPtrC iTypefaceName;
+ const TTLinkedFontElement* iElements;
+ };
+
+/** this is a plain group
+ */
+const TTGroup KPlainGroup =
+ {
+ CLinkedTypefaceGroup::ENoBaselineShift,
+ CLinkedTypefaceGroup::EScalingNone,
+ KMinTInt, //this value means do not set
+ KMinTInt, //this value means do not set
+ KMinTInt, //this value means do not set
+ };
+
+const TTGroup KGroup1 =
+ {
+ CLinkedTypefaceGroup::ENoBaselineShift,
+ CLinkedTypefaceGroup::EScalingNone,
+ KMinTInt, //this value means do not set - antialiased
+ KMinTInt, //this value means do not set - boldness percentage
+ KMinTInt, //this value means do not set - italic angle
+ };
+
+const TTGroup KGroup2 =
+ {
+ CLinkedTypefaceGroup::EBaselineShift,
+ CLinkedTypefaceGroup::EScalingUp,
+ KMinTInt, //this value means do not set
+ KMinTInt, //this value means do not set
+ KMinTInt, //this value means do not set
+ };
+const TTGroup KGroup3 =
+ {
+ CLinkedTypefaceGroup::EBaselineShift,
+ CLinkedTypefaceGroup::EScalingUpOrDown,
+ KMinTInt, //this value means do not set
+ KMinTInt, //this value means do not set
+ KMinTInt, //this value means do not set
+ };
+const TTGroup KGroup4 =
+ {
+ CLinkedTypefaceGroup::ENoBaselineShift,
+ CLinkedTypefaceGroup::EScalingNone,
+ 14, //antialiased
+ KMinTInt, //this value means do not set
+ KMinTInt, //this value means do not set
+ };
+const TTGroup KGroup5 =
+ {
+ CLinkedTypefaceGroup::ENoBaselineShift,
+ CLinkedTypefaceGroup::EScalingNone,
+ 10, //antialiased
+ KMinTInt, //this value means do not set
+ KMinTInt, //this value means do not set
+ };
+const TTGroup KGroup6 =
+ {
+ CLinkedTypefaceGroup::ENoBaselineShift,
+ CLinkedTypefaceGroup::EScalingNone,
+ KMinTInt, //this value means do not set
+ 100, //boldness percentage
+ KMinTInt, //this value means do not set
+ };
+const TTGroup KGroup7 =
+ {
+ CLinkedTypefaceGroup::ENoBaselineShift,
+ CLinkedTypefaceGroup::EScalingNone,
+ KMinTInt, //this value means do not set
+ 10, //boldness percentage
+ KMinTInt, //this value means do not set
+ };
+const TTGroup KGroup8 =
+ {
+ CLinkedTypefaceGroup::ENoBaselineShift,
+ CLinkedTypefaceGroup::EScalingNone,
+ KMinTInt, //this value means do not set
+ KMinTInt, //this value means do not set
+ 10, //italic angle
+ };
+const TTGroup KGroup9 =
+ {
+ CLinkedTypefaceGroup::EBaselineShift,
+ CLinkedTypefaceGroup::EScalingNone,
+ KMinTInt, //this value means do not set
+ KMinTInt, //this value means do not set
+ KMinTInt, //this value means do not set
+ };
+const TTGroup KGroup10 =
+ {
+ CLinkedTypefaceGroup::ENoBaselineShift,
+ CLinkedTypefaceGroup::EScalingNone,
+ KMinTInt, //this value means do not set
+ KMinTInt, //this value means do not set
+ 40, //large italic angle
+ };
+
+/** all the groups are added to every linked typeface
+if there are too many groups then there may be a need for a group list
+per linked typeface. Can have a maximum of 12 groups
+*/
+const TTGroup* KGroupList[]=
+ {
+ &KPlainGroup, /* index 0 */
+ &KGroup1,
+ &KGroup2,
+ &KGroup3,
+ &KGroup4,
+ &KGroup5,
+ &KGroup6,
+ &KGroup7,
+ &KGroup8,
+ &KGroup9,
+ &KGroup10,
+ };
+
+/** typeface element definitions
+ */
+
+/** Latin font
+ */
+const TTLinkedFontElement KLatinFontCanonical =
+ {
+ _L("DejaVu Sans Condensed"),0, ETrue //name, group zero, is canonical
+ };
+
+/**
+ */
+const TTLinkedFontElement KJapaneseNotCanonical =
+ {
+ _L("TBKomachiG-R"), 0, EFalse //name, group zero, not canonical
+ };
+
+/** Japanese - to be updated
+ */
+const TTLinkedFontElement KJapaneseNotCanonicalGroup1 =
+ {
+ _L("TBKomachiG-R"), 1, EFalse //name, group , not canonical
+ };
+const TTLinkedFontElement KJapaneseNotCanonicalGroup3 =
+ {
+ _L("TBKomachiG-R"), 3, EFalse //name, group, not canonical
+ };
+const TTLinkedFontElement KJapaneseNotCanonicalGroup4 =
+ {
+ _L("TBKomachiG-R"), 4, EFalse //name, group, not canonical
+ };
+const TTLinkedFontElement KJapaneseNotCanonicalGroup6 =
+ {
+ _L("TBKomachiG-R"), 6, EFalse //name, group, not canonical
+ };
+const TTLinkedFontElement KJapaneseNotCanonicalGroup8 =
+ {
+ _L("TBKomachiG-R"), 8, EFalse //name, group, not canonical
+ };
+const TTLinkedFontElement KJapaneseNotCanonicalGroup9 =
+ {
+ _L("TBKomachiG-R"), 9, EFalse //name, group, not canonical
+ };
+const TTLinkedFontElement KJapaneseNotCanonicalGroup10 =
+ {
+ _L("TBKomachiG-R"), 10, EFalse //name, group, not canonical
+ };
+
+const TTLinkedFontElement KLatinFontTTNotCanonicalGroup0 =
+ {
+ _L("LinkedFontTestFont"), 0, EFalse
+ };
+
+const TTLinkedFontElement KLatinFontTTCanonicalGroup0 =
+ {
+ _L("LinkedFontTestFont"), 0, ETrue
+ };
+
+/* for use case testing */
+const TTLinkedFontElement KLatinFontTTCanonicalGroup2 =
+ {
+ _L("LinkedFontTestFont"), 2, ETrue
+ };
+const TTLinkedFontElement KLatinFontTTCanonicalGroup3 =
+ {
+ _L("LinkedFontTestFont"), 3, ETrue
+ };
+const TTLinkedFontElement KLatinFontTTCanonicalGroup5 =
+ {
+ _L("LinkedFontTestFont"), 5, ETrue
+ };
+const TTLinkedFontElement KLatinFontTTCanonicalGroup7 =
+ {
+ _L("LinkedFontTestFont"), 7, ETrue
+ };
+const TTLinkedFontElement KLatinFontTTCanonicalGroup8 =
+ {
+ _L("LinkedFontTestFont"), 8, ETrue
+ };
+const TTLinkedFontElement KLatinFontTTCanonicalGroup9 =
+ {
+ _L("LinkedFontTestFont"), 9, ETrue
+ };
+const TTLinkedFontElement KLatinFontTTCanonicalGroup10 =
+ {
+ _L("LinkedFontTestFont"), 10, ETrue
+ };
+
+/** Chandas
+ */
+const TTLinkedFontElement KHindiCanonical =
+ {
+ _L("Chandas"), 0, ETrue
+ };
+
+/** Chandas
+ */
+const TTLinkedFontElement KHindiNotCanonical =
+ {
+ _L("Chandas"), 0, EFalse
+ };
+
+/** Information about linked fonts
+TLinkedFont1.ttf
+Typeface name: LinkedFont1
+This will be the dominant font. It contains 178 characters.
+Some of the characters (13) are deleted from this file and separated in to other three files.
+Characters missing are F, D, J, M, P, S, V, X, Z, a, n, l, y.
+
+TLinkedFont2.ttf
+Typeface name: LinkedFont2
+Characters available (7): F, J, M, S, Z, a, y.
+
+TLinkedFont3.ttf
+Typeface name: LinkedFont3
+Characters available (4): D, P, x, l
+
+TLinkedFont4.ttf
+Typeface name: LinkedFont4
+Characters available (2): V, n
+
+TWithoutLinkedFont.ttf
+Typeface name: WithoutLinkedFont
+Characters available: It contains 191 characters U+0020-U+007E and U+00A0-U+00FF
+*/
+
+/** LinkedFont1TT
+ */
+const TTLinkedFontElement KLinkedFont1TT =
+ {
+ _L("LinkedFont1TT"), 0, EFalse
+ };
+
+/** LinkedFont2TT
+ */
+const TTLinkedFontElement KLinkedFont2TTCanonical =
+ {
+ _L("LinkedFont2TT"), 0, ETrue
+ };
+
+/** LinkedFont3TT
+ */
+const TTLinkedFontElement KLinkedFont3TT =
+ {
+ _L("LinkedFont3TT"), 0, EFalse
+ };
+
+/** LinkedFont4TT
+ */
+const TTLinkedFontElement KLinkedFont4TT =
+ {
+ _L("LinkedFont4TT"), 0, EFalse
+ };
+
+/** KNullDesC
+ */
+const TTLinkedFontElement KNullElement =
+ {
+ _L(""), 0, EFalse
+ };
+
+/** linked typeface, this list is terminated by KNullElement
+ */
+const TTLinkedFontElement KLatinFontHindi[]=
+ {
+ KLatinFontTTNotCanonicalGroup0,
+ KHindiCanonical,
+ KNullElement,
+ };
+/** linked typeface, this list is terminated by KNullElement
+ */
+const TTLinkedFontElement KLatinFontJapanese[]=
+ {
+ KLatinFontCanonical,
+ KJapaneseNotCanonical,
+ KNullElement
+ };
+/** linked typeface, this list is terminated by KNullElement
+ */
+const TTLinkedFontElement KLinkedFontTestFonts[]=
+ {
+ KLinkedFont1TT,
+ KLinkedFont2TTCanonical,
+ KLinkedFont3TT,
+ KLinkedFont4TT,
+ KNullElement
+ };
+
+const TTLinkedFontElement KJapaneseLatinFontTypeface1[]=
+ {
+ KLatinFontTTCanonicalGroup2,
+ KJapaneseNotCanonicalGroup1,
+ KNullElement
+ };
+const TTLinkedFontElement KJapaneseLatinFontTypeface2[]=
+ {
+ KLatinFontTTCanonicalGroup3,
+ KJapaneseNotCanonicalGroup3,
+ KNullElement
+ };
+const TTLinkedFontElement KJapaneseLatinFontTypeface3[]=
+ {
+ KLatinFontTTCanonicalGroup5,
+ KJapaneseNotCanonicalGroup4,
+ KNullElement
+ };
+const TTLinkedFontElement KJapaneseLatinFontTypeface4[]=
+ {
+ KLatinFontTTCanonicalGroup7,
+ KJapaneseNotCanonicalGroup6,
+ KNullElement
+ };
+const TTLinkedFontElement KJapaneseLatinFontTypeface5[]=
+ {
+ KLatinFontTTCanonicalGroup8,
+ KJapaneseNotCanonicalGroup8,
+ KNullElement
+ };
+const TTLinkedFontElement KJapaneseLatinFontTypeface6[]=
+ {
+ KLatinFontTTCanonicalGroup9,
+ KJapaneseNotCanonicalGroup9,
+ KNullElement
+ };
+
+const TTLinkedFontElement KJapaneseLatinFontTypeface7[]=
+ {
+ KLatinFontTTCanonicalGroup10,
+ KJapaneseNotCanonicalGroup10,
+ KNullElement
+ };
+
+const TTLinkedFontElement KEnglishJapanseHindiFont[]=
+ {
+ KLatinFontTTCanonicalGroup0,
+ KJapaneseNotCanonical,
+ KHindiNotCanonical,
+ KNullElement
+ };
+
+/** the linked typeface set, no need to null terminate, sizeof is used for this array
+ */
+const TTLinkedTypeface KLinkedTypefaces[] =
+ {
+ //name, list of linked font elements
+ {_L("LinkedFontTestFont"), KLinkedFontTestFonts},
+ {_L("LatinFontHindi"), KLatinFontHindi},
+ {_L("LatinFontJapanese"), KLatinFontJapanese},
+ {_L("EnglishJapaneseHindi"), KEnglishJapanseHindiFont},
+ {_L("UseCaseFont1"), KJapaneseLatinFontTypeface1},
+ {_L("UseCaseFont2"), KJapaneseLatinFontTypeface2},
+ {_L("UseCaseFont3"), KJapaneseLatinFontTypeface3},
+ {_L("UseCaseFont4"), KJapaneseLatinFontTypeface4},
+ {_L("UseCaseFont5"), KJapaneseLatinFontTypeface5},
+ {_L("UseCaseFont6"), KJapaneseLatinFontTypeface6},
+ {_L("UseCaseFont7"), KJapaneseLatinFontTypeface7},
+ };
+
+/** Enum which constains bitwise flags for attrbutes which can be set for each font
+ */
+enum TFontEffectsFlags
+ {
+ ENoEffect = 0x0,
+ EDropShadowOn = 0x1,
+ EOutlineOn = 0x2,
+ ESetMonochromeGlyphBitmap = 0x4,
+ ESetAntiAliasedGlyphBitmap = 0x8,
+ ESetFourColourBlendGlyphBitmap = 0x10,
+ EVerticalDraw = 0x20,
+ ERotate90Degrees = 0x40,
+ EIsStrikethroughOn = 0x80,
+ EIsUnderlineOn = 0x100,
+ ESoftEdgeOn = 0x200,
+ EAlgorithmicBoldOn = 0x400,
+ EDrawUp = 0x800,
+ EItalicOn = 0x1000,
+ ERegularBoldOn = 0x2000,
+ EEndOfList = 0x80000000 //a meta flag
+ };
+
+const TInt KLengthOfHashValue = 1000;
+
+/** table used to produce hash string from attributes
+ */
+const TPtrC KFontEffectsFlagsString[32]=
+ {
+ _L("ENoEffect"),
+ _L("EDropShadowOn"),
+ _L("EOutlineOn"),
+ _L("ESetMonochromeGlyphBitmap"),
+ _L("ESetAntiAliasedGlyphBitmap"),
+ _L("ESetFourColourBlendGlyphBitmap"),
+ _L("EVerticalDraw"),
+ _L("ERotate90Degrees"),
+ _L("EIsStrikethroughOn"),
+ _L("EIsUnderlineOn"),
+ _L("ESoftEdgeOn"),
+ _L("EAlgorithmicBoldOn"),
+ _L("EDrawUp"),
+ _L("EItalicOn"),
+ _L("ERegularBoldOn"),
+ _L(""),
+ _L(""),
+ _L(""),
+ _L(""),
+ _L(""),
+ _L(""),
+ _L(""),
+ _L(""),
+ _L(""),
+ _L(""),
+ _L(""),
+ _L(""),
+ _L(""),
+ _L(""),
+ _L(""),
+ _L(""),
+ _L("EEndOfList"),
+ };
+
+
+/**this structure is used to define a test case
+ */
+struct TTestCase
+ {
+ const TPtrC iTypeFaceName; //typeface name
+ const TDesC* iOutputString; //the output string
+ const TDesC* iTestDecription; //test description
+ const TPoint iPosition; //the position
+ const TInt* iSizes; // a list of sizes
+ const TUint32* iFontAttributes; //a list of font attrbutes (bitwise flags, see above
+ };
+
+/** an array of sizes used during testing, terminated by zero
+ */
+const TInt KFontSizeNormalTesting[]=
+ {
+ 10,
+ 20,
+ 35,
+ 0
+ };
+
+const TInt KFontSizeUseCaseTesting[]=
+ {
+ 8,
+ 12,
+ 16,
+ 35,
+ 0
+ };
+
+/** an array of attributes used during font testing, terminated by EEndOfList
+ */
+const TUint32 KFontAttributesNormalTest[] =// probably need to expand this with position
+ {
+ ENoEffect,
+ EIsUnderlineOn,
+ EIsStrikethroughOn,
+ ESetFourColourBlendGlyphBitmap,
+ EIsUnderlineOn| EIsStrikethroughOn,
+ EAlgorithmicBoldOn,
+ EVerticalDraw,
+ EVerticalDraw | EIsUnderlineOn,
+ EVerticalDraw | EIsUnderlineOn | ERotate90Degrees,
+ EEndOfList,
+ };
+
+const TUint32 KFontAttributesUseCaseTest[] =// probably need to expand this with position
+ {
+ ENoEffect,
+ ERegularBoldOn,
+ ESetAntiAliasedGlyphBitmap,
+ EItalicOn,
+ EEndOfList,
+ };
+
+// here are the output strings which are used for testing
+_LIT(KHindiText,"\x0915\x094D\x0937\x0924\x094D\x0930\x093F\x092F\x0020");
+_LIT(KEnglishText,"The quick brown fox 123");
+_LIT(KEnglishHindiText,"TEST 123 \x0915\x094D\x0937\x0924\x094D\x0930\x093F\x092F\x0020");
+_LIT(KEnglishJapaneseText,"T\x308a\x3093\x3054 ESghy LINKED FONTS 123");
+_LIT(KEnglishJapaneseHindiText, "T\x308a\x3093\x3054\x306e EST FOnTS LINKED \x0915\x094D\x0937\x0924\x094D\x0930\x093F\x092F\x0020 123");
+_LIT(KLinkedFontTestString,"lInKED FOnTS");
+
+
+// test descriptions
+_LIT(KEnglishTest,"EnglishTest");
+_LIT(KHindiTest,"HindiTest");
+_LIT(KEnglishHindiTest,"EnglishHindiTest");
+_LIT(KEnglishJapaneseTest,"EnglishJapaneseTest");
+_LIT(KLinkedFontTest1,"LinkedFontTest-withLinking");
+_LIT(KLinkedFontTest2,"LinkedFontTest-unlinkedFont");
+_LIT(KEnglishJapaneseHindiTest,"EnglishJapaneseHindiTest");
+_LIT(KUseCaseTest,"UseCaseTest");
+
+
+
+_LIT(KTestName0001,"TestCase001");
+/** this table defines the test cases:
+ font name, string, position, sizes(array), attributes(array)
+ */
+const TTestCase KTestCases[]=
+ {
+ {_L("LatinFontHindi"), &KHindiText,&KHindiTest, TPoint(50,50),KFontSizeNormalTesting, KFontAttributesNormalTest},
+ {_L("LatinFontHindi"), &KEnglishText, &KEnglishTest, TPoint(50,50),KFontSizeNormalTesting, KFontAttributesNormalTest},
+ {_L("LatinFontHindi"), &KEnglishHindiText, &KEnglishHindiTest, TPoint(50,50),KFontSizeNormalTesting, KFontAttributesNormalTest},
+ {_L("LatinFontJapanese"),&KEnglishText, &KEnglishTest, TPoint(50,50),KFontSizeNormalTesting, KFontAttributesNormalTest},
+ {_L("LatinFontJapanese"),&KEnglishJapaneseText, &KEnglishJapaneseTest, TPoint(50,50),KFontSizeNormalTesting, KFontAttributesNormalTest},
+ {_L("LinkedFontTestFont"),&KLinkedFontTestString, &KLinkedFontTest1, TPoint(50,50),KFontSizeNormalTesting, KFontAttributesNormalTest},
+ {_L("WithoutLinkedFontTT"),&KLinkedFontTestString, &KLinkedFontTest2, TPoint(50,50),KFontSizeNormalTesting, KFontAttributesNormalTest},
+ {_L("EnglishJapaneseHindi"),&KEnglishJapaneseHindiText, &KEnglishJapaneseHindiTest, TPoint(50,50),KFontSizeNormalTesting, KFontAttributesNormalTest},
+
+ //use case testing
+ {_L("UseCaseFont1"),&KEnglishJapaneseText, &KUseCaseTest, TPoint(50,50),KFontSizeUseCaseTesting, KFontAttributesUseCaseTest},
+ {_L("UseCaseFont2"),&KEnglishJapaneseText, &KUseCaseTest, TPoint(50,50),KFontSizeUseCaseTesting, KFontAttributesUseCaseTest},
+ {_L("UseCaseFont3"),&KEnglishJapaneseText, &KUseCaseTest, TPoint(50,50),KFontSizeUseCaseTesting, KFontAttributesUseCaseTest},
+ {_L("UseCaseFont4"),&KEnglishJapaneseText, &KUseCaseTest, TPoint(50,50),KFontSizeUseCaseTesting, KFontAttributesUseCaseTest},
+ {_L("UseCaseFont5"),&KEnglishJapaneseText, &KUseCaseTest, TPoint(50,50),KFontSizeUseCaseTesting, KFontAttributesUseCaseTest},
+ {_L("UseCaseFont6"),&KEnglishJapaneseText, &KUseCaseTest, TPoint(50,50),KFontSizeUseCaseTesting, KFontAttributesUseCaseTest},
+ {_L("UseCaseFont7"),&KEnglishJapaneseText, &KUseCaseTest, TPoint(50,50),KFontSizeUseCaseTesting, KFontAttributesUseCaseTest},
+ };
+
+/** Class used to register the linked typefaces
+ */
+class CTLinkedTypefaceCreator : public CBase
+ {
+public:
+ static CTLinkedTypefaceCreator* NewL(CTestStep* aStep);
+ void CreateL(); //creates the linked typefaces - will not leave with a registration error, but try the next
+ ~CTLinkedTypefaceCreator();
+private:
+ CTLinkedTypefaceCreator(CTestStep* aStep);
+ void CreateGroupsL(const TTGroup* aElement[],TInt aNumberOfElements);
+ void CreateElementsL(const TTLinkedFontElement* aElements);
+ void ConstructL();
+
+private:
+ CTestStep* iStep; //for recording failures, not owned
+ RPointerArray<CLinkedTypefaceGroup> iGroups; //owned
+ RPointerArray<CLinkedTypefaceElementSpec> iElements; //owned
+ CFbsScreenDevice* iDev; //owned
+ };
+
+/** static NewL
+@return CTLinkedTypefaceCreator*
+ */
+CTLinkedTypefaceCreator* CTLinkedTypefaceCreator::NewL(CTestStep* aStep)
+ {
+ CTLinkedTypefaceCreator* ptr = new (ELeave) CTLinkedTypefaceCreator(aStep);
+ CleanupStack::PushL(ptr);
+ ptr->ConstructL();
+ CleanupStack::Pop();
+ return ptr;
+ }
+
+CTLinkedTypefaceCreator::CTLinkedTypefaceCreator(CTestStep* aStep):iStep(aStep)
+ {
+
+ }
+
+void CTLinkedTypefaceCreator::ConstructL()
+ {
+ TDisplayMode mode[4]= {EColor16MAP, EColor16MA, EColor16MU, EColor64K};
+
+ TInt err=KErrNone;
+ for (TInt count=0;count<(sizeof(mode)/sizeof(mode[0]));count++)
+ {
+ TRAP(err, iDev = CFbsScreenDevice::NewL(KNullDesC, mode[count]));
+ if (err!=KErrNotSupported)
+ {
+ return;
+ }
+ }
+
+ User::LeaveIfError(err);
+ }
+
+CTLinkedTypefaceCreator::~CTLinkedTypefaceCreator()
+ {
+ delete iDev;
+ iGroups.ResetAndDestroy();
+ iElements.ResetAndDestroy();
+ }
+
+/** function used to create the linked typefaces
+ */
+void CTLinkedTypefaceCreator::CreateL()
+ {
+ CFbsTypefaceStore* store = CFbsTypefaceStore::NewL(iDev);
+ CleanupStack::PushL(store);
+
+ for (TInt counter=0; counter< sizeof(KLinkedTypefaces)/sizeof(TTLinkedTypeface);counter++)
+ {
+ //creating the groups needs to be done for every typeface since ownwership is taken
+ //after adding the group to one linked typeface specification
+ //leave on any failure e.g. out of memory, which is not expected
+ CreateGroupsL(KGroupList, sizeof(KGroupList)/sizeof(TTGroup*));
+
+ //create the linked typeface elements for this linked typeface
+ CreateElementsL(KLinkedTypefaces[counter].iElements);
+
+ //add the groups and elements, but first create the spec
+ CLinkedTypefaceSpecification* spec = CLinkedTypefaceSpecification::NewLC(KLinkedTypefaces[counter].iTypefaceName);
+
+ //add the groups
+ for (TInt groupCounter=0; groupCounter<iGroups.Count();groupCounter++)
+ {
+ spec->AddLinkedTypefaceGroupL(*iGroups[groupCounter]);//ownership is taken
+ iGroups[groupCounter]=NULL;
+ }
+
+ //add the elements
+ for (TInt elementCounter=0; elementCounter<iElements.Count();elementCounter++)
+ {
+ spec->AddTypefaceAtBackL(*iElements[elementCounter]);//ownership is taken
+ iElements[elementCounter]=NULL;
+ }
+ iElements.ResetAndDestroy();
+ iGroups.ResetAndDestroy();
+
+ //register
+ TInt err=KErrNone;
+ TRAP(err,spec->RegisterLinkedTypefaceL(*store)); //may fail if something is wrong with the tables, want to try to continue
+
+ //do not report test failure if already registered
+ iStep->testBooleanTrue(err==KErrNone || err==KErrAlreadyExists, (TText8*)__FILE__, __LINE__);
+
+ //delete spec
+ CleanupStack::PopAndDestroy();
+ }
+ CleanupStack::PopAndDestroy();//store
+ }
+
+/** function used to create the groups, note all groups are created at once, and
+added to all linked typefaces
+
+@param aElement array of pointers to groups
+@param aNumberOfElements the number of elements in the group
+*/
+void CTLinkedTypefaceCreator::CreateGroupsL(const TTGroup* aElement[],TInt aNumberOfElements)
+ {
+ for (TInt counter =0; counter<aNumberOfElements;counter++)
+ {
+ CLinkedTypefaceGroup* groupPtr= CLinkedTypefaceGroup::NewLC(counter);
+ groupPtr->SetScalingOption(aElement[counter]->iScalingOption);
+ groupPtr->SetBaselineShift(aElement[counter]->iBaselineShift);
+
+ if (aElement[counter]->iBoldnessPercentage!=KMinTInt)
+ {
+ groupPtr->SetBoldnessPercentage(aElement[counter]->iBoldnessPercentage);
+ }
+ if (aElement[counter]->iItalicAngle!=KMinTInt)
+ {
+ groupPtr->SetItalicAngle(aElement[counter]->iItalicAngle);
+ }
+ iGroups.AppendL(groupPtr);
+ CleanupStack::Pop();//ptr is now on the RArray
+ }
+ }
+
+/** creates all the elements for one typeface
+iElements is updated
+
+@param aElements pointer to a list of elements, terminated by a typeface with null name
+*/
+
+void CTLinkedTypefaceCreator::CreateElementsL(const TTLinkedFontElement* aElements)
+ {
+ const TTLinkedFontElement* ptrElementSpec = aElements;
+
+ //need a loop to go through all the typefaces
+ for (;ptrElementSpec->iTypefaceName!=KNullDesC;ptrElementSpec++)
+ {
+ CLinkedTypefaceElementSpec* elementSpec = CLinkedTypefaceElementSpec::NewLC(ptrElementSpec->iTypefaceName,ptrElementSpec->iGroup);
+ elementSpec->SetCanonical(ptrElementSpec->iIsCanonical);
+ iElements.AppendL(elementSpec);
+ CleanupStack::Pop();
+ }
+ }
+
+// Code for creating fonts, drawing text, and comparing hash value
+
+//Considering the intersection of the screen size for both hw and emulator so that same
+//baselined hash can be used to test for both
+#define KScreenWidth 320
+#define KScreenHeight 240
+
+const TInt KNumOfDisplayModes = 12;
+
+/** table of strings of display modes
+ */
+const TPtrC KDisplayModeNames[KNumOfDisplayModes] =
+ {
+ _L("EGray2"),
+ _L("EGray4"),
+ _L("EGray16"),
+ _L("EGray256"),
+ _L("EColor16"),
+ _L("EColor256"),
+ _L("EColor64K"),
+ _L("EColor16M"),
+ _L("EColor4K"),
+ _L("EColor16MU"),
+ _L("EColor16MA"),
+ _L("EColor16MAP"),
+ };
+
+/** a mapping table index from DisplayMode into the table of strings
+for supported colour modes.
+The tables of strings do not include ERgb, or ENone. The value in the table is also
+needed for compatibility with CTHashReferenceImages
+*/
+const TInt KSupportDisplayStringIndex[14] =
+ {
+ 0, //ENone - use EGray2 output string
+ 0, //EGray2,
+ 1, //EGray4,
+ 2, //EGray16,
+ 3, //EGray256,
+ 4, //EColor16,
+ 5, //EColor256,
+ 6, //EColor64K,
+ 7, //EColor16M,
+ 7, //ERgb
+ 8, //EColor4K,
+ 9, //EColor16MU,
+ 10,//EColor16MA,
+ 11,//EColor16MAP,
+ };
+
+/** a helper cleanup class
+ */
+typedef struct
+ {
+ CBitmapDevice* device;
+ CFont* font;
+ } SCleanFont;
+
+/** path where the output file are to be stored (if this is configured in chashreferenceimages.cpp
+*/
+_LIT(KPath,"c:\\fntstoretest\\%S.mbm");
+
+/** constructor
+@param aStep the test step
+ */
+CTLinkedFontsComparison::CTLinkedFontsComparison(CTestStep *aStep):CTGraphicsBase(aStep),iStep(aStep)
+ {
+ }
+
+/** ConstructL
+ */
+void CTLinkedFontsComparison::ConstructL()
+ {
+ iFbs = RFbsSession::GetSession();
+ User::LeaveIfNull(iFbs);
+ iHashUtil = CTHashReferenceImages::NewL(iStep,iFbs,&KPath);
+ }
+
+/** Destructor
+ */
+CTLinkedFontsComparison::~CTLinkedFontsComparison()
+ {
+ FreeScreenDevice();
+ delete iHashUtil;
+ if (iFbs)
+ iFbs->Disconnect();
+ }
+
+/**
+Auxilary function will be called in case of a leave to release the font
+@param aCleanFont font to be released
+*/
+void CleanUpFont(TAny* aCleanFont)
+ {
+ SCleanFont* cleanFont= static_cast<SCleanFont*>(aCleanFont);
+ (cleanFont->device)->ReleaseFont(cleanFont->font);
+ }
+
+
+class CFbsFontEx : public CFbsFont
+ {
+public:
+ static CBitmapFont* FontAddress(CFbsFont* aFont);
+ };
+
+CBitmapFont* CFbsFontEx::FontAddress(CFbsFont* aFont)
+ {
+ return(((CFbsFontEx*)aFont)->Address());
+ }
+
+/**
+ @SYMTestCaseID GRAPHICS-FNTSTORE-LINKEDFONTS-0107
+
+ @SYMPREQ PREQ2146
+
+ @SYMREQ REQ10924, REQ10925, REQ10926, REQ10927, REQ10942, REQ10943, REQ10947, REQ10949
+
+ @SYMTestCaseDesc This test registers linked typefaces with defintions coming from tables.
+
+ @SYMTestActions Register a number of linked typefaces which are defined in a set of tables.
+
+ Groups can have the following attributes:
+ CLinkedTypefaceGroup::TBaselineShift
+ CLinkedTypefaceGroup::TScalingOption
+ AntiAliasingThreshold (integer value)
+ BoldnessPercentage (integer value)
+ ItalicAngle (integer value)
+
+ Typeface elements can have the following attributes:
+ Name
+ Group
+ Is canonical
+
+ Linked typefaces can have the following attributes:
+ Name
+ Linked typeface elements
+ Groups
+
+ For each linked typeface to be created
+ create linked typeface specification
+ create groups
+ add groups to linked typeface specification
+ create linked typeface elements
+ add linked typeface elements to linked typeface specification
+ register the specification
+
+ To produce new linked typefaces it should be possible to do this by updating
+ the table entries.
+
+ The linked typefaces should be valid. This test requires that the internal test
+ fonts be present.
+
+ @SYMTestPriority Critical
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions (1)For each linked typeface, create the groups, create the linked typeface elements,
+ create a linked typeface, add the groups and elements, and
+ register the linked typeface with the font and bitmap server.
+
+ @SYMTestExpectedResults (1) - linked font registration succeeds with no panics or leaves. If the test is run a
+ second time then KErrAlreadyExists is returned, which is not a failure.
+*/
+void CTLinkedFontsComparison::RegisterLinkedTypefacesL()
+ {
+ CTLinkedTypefaceCreator* creator = CTLinkedTypefaceCreator::NewL(iStep);
+ CleanupStack::PushL(creator);
+ creator->CreateL();
+ CleanupStack::PopAndDestroy();
+ }
+
+/** Create the screen device.
+@param aMode display mode for which device has to be created
+*/
+void CTLinkedFontsComparison::CreateBitmapDeviceL(TDisplayMode aMode)
+ {
+ iBitmap = new(ELeave) CFbsBitmap;
+ //Considering the intersection of the screen size for both hw and emulator so that same
+ //baselined hash can be used to test for both
+ iBitmap->Create(TSize(KScreenWidth, KScreenHeight), aMode);
+ iBitmapDevice = CFbsBitmapDevice::NewL(iBitmap);
+ User::LeaveIfError(iBitmapDevice->CreateContext((CGraphicsContext*&)iGc));
+ iHashUtil->SetScreenDeviceAndBitmap(iBitmapDevice,iBitmap,iGc);
+ }
+
+/**
+Delete the devices created and gc.
+*/
+void CTLinkedFontsComparison::FreeScreenDevice()
+ {
+ delete iBitmapDevice;
+ delete iBitmap;
+ delete iGc;
+ iBitmapDevice = NULL;
+ iBitmap = NULL;
+ iGc = NULL;
+ }
+
+/** Function to generate a meaningful hash string from the test attributes
+
+@param aSize the size of the font
+@param aAttributes the attributes of the font
+@see TFontEffectsFlags
+@param aTypefaceName the typeface name
+
+@return the buffer with a text description, used for inclusion in the hash string
+*/
+HBufC* CTLinkedFontsComparison::GenerateTestDescriptionLC(TInt aSize,TUint32 aAttributes, const TPtrC &aTypefaceName, const TDesC &aTestDescription)
+ {
+ TBuf<KLengthOfHashValue> tempBuffer;
+
+ //append the name
+ tempBuffer.Append(_L("_"));
+ tempBuffer.Append(aTypefaceName);
+ tempBuffer.Append(_L("_"));
+ tempBuffer.Append(aTestDescription);
+ tempBuffer.Append(_L("_"));
+
+ //append the size
+ tempBuffer.AppendFormat(_L("_size-%d"),aSize);
+ if (aAttributes == 0)
+ {
+ //output no attributes
+ tempBuffer.Append(_L("_"));
+ tempBuffer.Append(KFontEffectsFlagsString[0]); //no attributes string
+ }
+ else
+ {
+ for (TInt counter=0;counter<31;counter++)
+ {
+ TInt bit = 1<<counter; //1,2,4,8 etc
+ if (bit&aAttributes)
+ {
+ tempBuffer.Append(_L("_"));
+ tempBuffer.Append(KFontEffectsFlagsString[counter+1]);
+ }
+ }
+ }
+ return tempBuffer.AllocLC();
+ }
+
+/**
+ @SYMTestCaseID GRAPHICS-FNTSTORE-LINKEDFONTS-0108
+
+ @SYMPREQ PREQ2146
+
+ @SYMREQ REQ10924, REQ10925, REQ10926, REQ10927, REQ10942, REQ10943, REQ10947, REQ10949
+
+ @SYMTestCaseDesc This test draws fonts and compares a hash value from the output against
+ a value stored in a file.
+
+ @SYMTestActions The fonts used for this test come from a table, and each font can
+ be tested with a different output string, size, and creation flag.
+ The sizes are typically, 10, 20, 35 pixels.
+
+ Steps for each font in the test table entry:
+ (1)Create the font
+ (2)For each size
+ (3) For each attribute
+ (4)Draw the text and compare against the stored hash value
+
+
+ The font creation parameters are typically:
+ ENoEffect : plain font
+ EIsUnderlineOn : have underline
+ EIsStrikethroughOn : have strikethrough
+ ESetFourColourBlendGlyphBitmap : for shadow and outline
+ EIsUnderlineOn, EIsStrikethroughOn : both underline and strikethrough
+ EAlgorithmicBoldOn : algorithmic bold on
+ EVerticalDraw : vertical text
+ EVerticalDraw, EIsUnderlineOn : vertical text and underline
+
+ If more fonts or attribute combinations are required to be tested, then this should be
+ achievable by adding table entries.
+
+ To produce the hash values the test needs to be run with a special version
+ of test harness where APPEND_NEW_OR_MISSING_HASH_DATA and SAVEBITMAP macros are defined
+ in thashreferenceimages.cpp. The saved mbm files should be converted to bitmap
+ for manual checking.
+
+ The fonts used for this tests should have been registered beforehand with
+ test GRAPHICS-FNTSTORE-LINKEDFONTS-0107.
+
+ @SYMTestPriority Critical
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions (1) Create the font. Draw text, and compare the hash value against
+ the value in the file tlinkedfontcomparison.ini. Note that having the same hash
+ value as the ini file does not necessarily mean that the output is correct.
+
+ @SYMTestExpectedResults (1) - font creation succeeds
+ (4) - the hash values are the same for each text string output
+*/
+void CTLinkedFontsComparison::TestDrawTextUsingLinkedFontsL()
+ {
+ INFO_PRINTF1(_L("TestDrawTextUsingLinkedFontsL()"));
+ FreeScreenDevice();
+ const TDisplayMode displayMode = EColor16MAP;
+
+ CreateBitmapDeviceL(displayMode);
+
+ INFO_PRINTF2(_L("Display mode: %S"), &KDisplayModeNames[KSupportDisplayStringIndex[displayMode]]);
+
+ //for all the tests
+ TInt numberOfTestsRun=0;
+ for (TInt testCounter = 0; testCounter< sizeof(KTestCases)/sizeof(TTestCase); testCounter++)
+ {
+
+ //for all the sizes
+ const TInt* ptrSizes = KTestCases[testCounter].iSizes;
+ for (; *ptrSizes!=0 ;ptrSizes++)
+ {
+ TInt size = *ptrSizes;
+
+ // for all the attributes
+ const TUint32 *ptrAttributes = KTestCases[testCounter].iFontAttributes;
+ for (;*ptrAttributes!=EEndOfList;ptrAttributes++)
+
+ {
+ TUint32 attributes = *ptrAttributes;
+
+ HBufC* testDescription = GenerateTestDescriptionLC(size,attributes,KTestCases[testCounter].iTypeFaceName,*( KTestCases[testCounter].iTestDecription));
+ //this function is used for a fuller description
+
+ //conversion from HBufC to TPtrC
+ //need this an an argument to the generate hash id function
+ TPtrC ptr = TPtrC(testDescription->Des());
+
+ //construct a desriptor string, function in hashutility KTestName0001
+ HBufC* hashIdString = iHashUtil->GenerateHashIdStringLC(
+ KTestName0001,//general name for test
+ numberOfTestsRun, //number of sub test
+ &ptr,
+ 0, //fontFaceIndex, index into the name array above, must be zero
+ KSupportDisplayStringIndex[static_cast<TInt>(displayMode)],//display mode, converted to text
+ //in the hash code this is an index to a string table, which is missing ENone and ERgb
+ attributes //was orientation, but just integer at end, no use attributes
+ );
+
+ DoTestDrawingOutputL(*hashIdString, KTestCases[testCounter].iTypeFaceName, *(KTestCases[testCounter].iOutputString),
+ KTestCases[testCounter].iPosition,size,attributes);
+
+ numberOfTestsRun++;
+ CleanupStack::PopAndDestroy(2,testDescription);
+ }
+ }//sizes
+ }//test array
+ }
+
+/**
+Function to create a font, draw the text, and compare the hash value
+
+@param aHashId a string with the hash ID.
+@param aFont the font name
+@param aOutputString the output string
+@param aPosition the position where to draw the text
+@param aSize the height of the font in pixels
+@param aAttributes the attributes for the font
+@see TFontEffectsFlags
+*/
+void CTLinkedFontsComparison::DoTestDrawingOutputL(const TDesC& aHashId, const TPtrC& aFont, const TDesC& aOutputString,
+ TPoint aPosition, TInt aSize, TUint32 aAttributes)
+ {
+ TFontSpec fontSpec;
+ PrepareTestEnvironment(fontSpec, aFont, aSize, aAttributes, ETrue, ETrue);
+ CFont* font;
+ TEST(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)font, fontSpec) == KErrNone);
+ SCleanFont cleanupFont = {iBitmapDevice, font};
+ CleanupStack::PushL(TCleanupItem(CleanUpFont, &cleanupFont));
+
+ //may need to add attributes for the font
+ CBitmapFont* bitmapFont=CFbsFontEx::FontAddress(static_cast<CFbsFont*>(font));
+ if (aAttributes& EItalicOn)
+ {
+ bitmapFont->iAlgStyle.SetIsItalic(ETrue);
+ }
+ if (aAttributes& ERegularBoldOn)
+ {
+ bitmapFont->iAlgStyle.SetIsBold(ETrue);
+ }
+
+ iGc->SetBrushColor(KRgbWhite);
+ iGc->Clear();
+ iGc->SetBrushColor(KRgbYellow);
+ iGc->UseFont(font);
+ if(EVerticalDraw & aAttributes)
+ {
+ iGc->DrawTextVertical(aOutputString, aPosition, ERotate90Degrees & aAttributes);
+ }
+ else
+ {
+ iGc->DrawText(aOutputString, aPosition);
+ }
+ iHashUtil->CompareHashValuesL(aHashId);
+ CleanupStack::Pop();//font
+ iBitmapDevice->ReleaseFont(font);
+ iGc->DiscardFont();
+ }
+
+/**
+Sets the fontspec and gc attributes according to the flags set in STestFontParameters for the test.
+Before setting gc attributes it is cleared and reset.
+@param aFontSpec holds all effective font settings
+@param aSettings holds the flags for setting the fontspec and gc
+@param aFontIndex the fonts index of KFontFace to be set as typeface
+@param aSetEffects ETrue will set the effects on in fontspec if their flags are enabled. By default it is ETrue.
+@param aSetColors ETrue will set the colours in gc from STestFontParameters. By default it is EFalse.
+*/
+void CTLinkedFontsComparison::PrepareTestEnvironment(TFontSpec &aFontSpec, const TPtrC& aFont, TInt aSize, TUint32 aAttributes,
+ TBool aSetEffects, TBool aSetColors)
+ {
+ //Set the typeface from the font face array
+ aFontSpec.iTypeface.iName = aFont;
+ aFontSpec.iHeight = aSize;
+
+ //Set the effects on if any of flags for the effects are set in aSettings and aSetEffects is ETrue
+ if(aSetEffects)
+ {
+ aFontSpec.iFontStyle.SetEffects(FontEffect::EDropShadow, EDropShadowOn & aAttributes);
+ aFontSpec.iFontStyle.SetEffects(FontEffect::EOutline, EOutlineOn & aAttributes);
+ aFontSpec.iFontStyle.SetEffects(FontEffect::ESoftEdge, ESoftEdgeOn & aAttributes);
+ aFontSpec.iFontStyle.SetEffects(FontEffect::EAlgorithmicBold, EAlgorithmicBoldOn & aAttributes);
+ }
+
+ iGc->Reset();
+ iGc->Clear();
+ iGc->SetPenColor(KRgbBlack);
+ iGc->SetStrikethroughStyle((EIsStrikethroughOn & aAttributes) ? EStrikethroughOn : EStrikethroughOff);
+ iGc->SetUnderlineStyle((EIsUnderlineOn & aAttributes) ? EUnderlineOn : EUnderlineOff);
+
+ //Set the glyph bitmap type
+ if(ESetMonochromeGlyphBitmap & aAttributes)
+ {
+ aFontSpec.iFontStyle.SetBitmapType(EMonochromeGlyphBitmap);
+ }
+ else if(ESetAntiAliasedGlyphBitmap & aAttributes)
+ {
+ aFontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap);
+ }
+
+ //Set the colours in gc if asked for
+ if(aSetColors)
+ {
+ iGc->SetBrushColor(KRgbYellow);
+ iGc->SetPenColor(KRgbBlack);
+ iGc->SetShadowColor(KRgbGray);
+ }
+ }
+
+/** Function to determine if the rasterizer has the linked typeface extended interface.
+
+@return ETrue if the linked fonts rasterizer is present. EFalse otherwise
+*/
+TBool CTLinkedFontsComparison::CheckMonoTypeInstalledL()
+ {
+ CreateBitmapDeviceL(EColor16MU); //this is just for the bitmap device to get the font
+
+ CFbsTypefaceStore* store = CFbsTypefaceStore::NewL(iBitmapDevice);
+ CleanupStack::PushL(store);
+
+ // Create typeface to be linked
+ _LIT(KLinkedTypefaceTT, "LinkedFont1TT");
+
+ CLinkedTypefaceSpecification *typefaceSpec;
+ _LIT(KLinkedFont1TTLinkingTest, "LinkedFont1TTLinkingTest");
+
+ typefaceSpec = CLinkedTypefaceSpecification::NewLC(KLinkedFont1TTLinkingTest);
+
+ CLinkedTypefaceGroup* group1 = CLinkedTypefaceGroup::NewLC(1);
+ typefaceSpec->AddLinkedTypefaceGroupL(*group1);
+ CleanupStack::Pop();
+
+ // Add first typeface
+ CLinkedTypefaceElementSpec *elementSpec1;
+ elementSpec1 = CLinkedTypefaceElementSpec::NewLC(KLinkedTypefaceTT, 1);
+ elementSpec1->SetCanonical(ETrue);
+
+ typefaceSpec->AddTypefaceAtBackL(*elementSpec1);
+ CleanupStack::Pop(1, elementSpec1);
+
+ // Now try regstering the linked typeface
+ TRAPD(ret, typefaceSpec->RegisterLinkedTypefaceL(*store));
+ CleanupStack::PopAndDestroy(2, store);
+
+ if (ret == KErrNone|| ret== KErrAlreadyExists)
+ {
+ return ETrue;
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Linked fonts comparison: no linked fonts rasterizer found"));
+ return EFalse;
+ }
+ }
+
+/** regular RunTestCaseL, a virtual function called by the test framework
+ */
+void CTLinkedFontsComparison::RunTestCaseL(TInt aCurTestCase)
+ {
+ ((CTLinkedFontsComparisonStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
+ switch (aCurTestCase)
+ {
+ case 1:
+ {
+ ((CTLinkedFontsComparisonStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+ if (!CheckMonoTypeInstalledL())
+ {
+ TestComplete();
+ };
+ break;
+ }
+ case 2:
+ {
+ ((CTLinkedFontsComparisonStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-LINKEDFONTS-0107"));
+ RegisterLinkedTypefacesL();
+ break;
+ }
+ case 3:
+ {
+ ((CTLinkedFontsComparisonStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-LINKEDFONTS-0108"));
+ TestDrawTextUsingLinkedFontsL();
+ break;
+ }
+ default:
+ {
+ ((CTLinkedFontsComparisonStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
+ ((CTLinkedFontsComparisonStep*)iStep)->CloseTMSGraphicsStep();
+ TestComplete();
+ break;
+ }
+ }
+ ((CTLinkedFontsComparisonStep*)iStep)->RecordTestResultL();
+ }
+
+__CONSTRUCT_STEP__(LinkedFontsComparison)