diff -r 000000000000 -r 1fb32624e06b fontservices/fontstore/tfs/T_LinkedFonts2.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/fontservices/fontstore/tfs/T_LinkedFonts2.cpp Tue Feb 02 02:02:46 2010 +0200 @@ -0,0 +1,1306 @@ +/* +* 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: +* +*/ + + +/** + @file + @test + @internalComponent +*/ + +#include "T_LinkedFonts2.h" +#include "linkedfontsprivate.h" +#include +#include + +CTLinkedFonts2::CTLinkedFonts2(CTestStep* aStep) +: CTGraphicsBase(aStep) + { + + } + +CTLinkedFonts2::~CTLinkedFonts2() + { + delete iGc; + delete iDev; + if (iFbs) + iFbs->Disconnect(); + } + +void CTLinkedFonts2::TestPanic(TInt aPanic) + { + _LIT(KFntTestStorePanicCategory,"TestFntStore"); + User::Panic(KFntTestStorePanicCategory,aPanic); + } + +void CTLinkedFonts2::RunTestCaseL(TInt aCurTestCase) + { + ((CTLinkedFonts2Step*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName); + switch (aCurTestCase) + { + case 1: + ((CTLinkedFonts2Step*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-LINKEDFONTS-0046")); + InitializeTestHarnessL(); + break; + case 2: + ((CTLinkedFonts2Step*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-LINKEDFONTS-0001")); + TestLinkedClientGettersAndSettersL(); + break; + case 3: + ((CTLinkedFonts2Step*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-LINKEDFONTS-0002")); + TestLinkedClientAddAndRemoveL(); + break; + case 4: + ((CTLinkedFonts2Step*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-LINKEDFONTS-0003")); + TestOpenClientAddAndRemoveL(); + break; + case 5: +/** +@SYMTestCaseID GRAPHICS-FNTSTORE-LINKEDFONTS-0004 +*/ + ((CTLinkedFonts2Step*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-LINKEDFONTS-0004")); + TestLinkedRegistrationAndFetchL(); + break; + case 6: + ((CTLinkedFonts2Step*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-LINKEDFONTS-0100")); + TestComplexLinkedFontsBasicL(); + break; + case 7: + ((CTLinkedFonts2Step*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + //((CTLinkedFonts2Step*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-LINKEDFONTS-0101")); + //TestBitmapFontsL(); + break; + default: + CloseTestHarnessL(); + TestComplete(); + ((CTLinkedFonts2Step*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + ((CTLinkedFonts2Step*)iStep)->CloseTMSGraphicsStep(); + break; + } + ((CTLinkedFonts2Step*)iStep)->RecordTestResultL(); + } + +/** + @SYMTestCaseID + GRAPHICS-FNTSTORE-LINKEDFONTS-0046 + + @SYMTestCaseDesc + Starts a server session with the font and bitmap server. + + @SYMTestActions + 1. Creates a session with the Font and Bitmap server. + 2. Gets the current Font and Bitmap server session. + 3. Creates a CFbsScreenDevice object. + 4. Sets screen device to null. + 5. Sets auto update to true. + 6. Creates a font and bitmap server graphics context for the + device and activates it. + + @SYMTestExpectedResults + All steps 1-6 above succeed. +*/ +void CTLinkedFonts2::StartServer() + { + TInt ret = RFbsSession::Connect(); + TEST2(ret, KErrNone); + iFbs = RFbsSession::GetSession(); + TEST(iFbs != NULL); + + if (iFbs==NULL) + { + //cannot continue + TestComplete(); + return; + } + + TInt err; + TDisplayMode mode[4] = {EColor16MA,EColor16MU,EColor64K,EColor16MAP}; + + TInt count; + for (count=0; count < (sizeof(mode)/sizeof(mode[0])) ;count++) + { + TRAP(err, iDev = CFbsScreenDevice::NewL(KNullDesC, mode[count])); + if (err!=KErrNotSupported) + { + break; + } + } + + if(err == KErrNone) + { + INFO_PRINTF2(_L("%d screen mode created"),mode[count]); + iDev->ChangeScreenDevice(NULL); + iDev->SetAutoUpdate(ETrue); + iDev->CreateContext(iGc); + + //use and create a font + //otherwise for memory tests there is a leak reported since the first AllocL + //creates the space for the array (e.g. CTypefaceStore::AddFontL()) and + //although the array is emptied the array element storage is not deleted + //until everything is closed + _LIT(KSansSerif, "DejaVu Sans Condensed"); + TTypeface typeface; + typeface.iName = KSansSerif; + TFontSpec fs; + fs.iTypeface = typeface; + fs.iHeight = 20; + CFbsFont* font = NULL; + TInt err1 = iDev->GetNearestFontToDesignHeightInPixels(font, fs); + TEST(err1==KErrNone); + if (err1 == KErrNone) + { + TSize scrSize = iDev->SizeInPixels(); + iGc->UseFont(font); + _LIT(KTestText,"TEST"); + iGc->DrawText(KTestText, TPoint((scrSize.iWidth / 2) + 50, 50)); + iGc->DiscardFont(); + iDev->ReleaseFont(font); + } + } + else + { + INFO_PRINTF2(_L("Could not create screen mode error %d"),err); + } + } + + +void CTLinkedFonts2::InitializeTestHarnessL() + { + INFO_PRINTF1(_L("Initialising the test harness T_LinkedFonts2 (PREQ2146)")); + StartServer(); + } + +void CTLinkedFonts2::CloseTestHarnessL() + { + } +/** +@SYMTestCaseID +GRAPHICS-FNTSTORE-LINKEDFONTS-0001 + +@SYMPREQ +PREQ2146 + +@SYMREQ +PREQ2146 + +@SYMTestCaseDesc +Create a linked typeface element & group. Set the parameters they provide. + +@SYMTestPriority +Critical + +@SYMTestStatus +Implemented + +@SYMTestActions +Tests that the values set are stored correctly by the linked typeface element & group. + +@SYMTestExpectedResults +Values are set correctly +*/ +void CTLinkedFonts2::TestLinkedClientGettersAndSettersL() + { + INFO_PRINTF1(_L("CTLinkedFonts2::TestLinkedClientGettersAndSettersL")); + CLinkedTypefaceElementSpec *elementSpec; + _LIT(KLinkedTypefaceName, "TypefaceNumberOne"); + elementSpec = CLinkedTypefaceElementSpec::NewLC(KLinkedTypefaceName, 10); + + elementSpec->SetCanonical(ETrue); + TEST(elementSpec->Canonical()); + + //Test Remaining Getters & Setters + elementSpec->SetCanonical(EFalse); + + CleanupStack::PopAndDestroy(elementSpec); + + CLinkedTypefaceGroup* grp = CLinkedTypefaceGroup::NewLC(10); + const TInt KPercentageValue = 50; + TInt ret; + + grp->SetBoldnessPercentage(KPercentageValue); + ret = grp->BoldnessPercentage(); + TEST2(ret, KPercentageValue); + + grp->SetItalicAngle(KPercentageValue); + ret = grp->ItalicAngle(); + TEST2(ret, KPercentageValue); + + grp->SetBaselineShift(CLinkedTypefaceGroup::ENoBaselineShift); + CLinkedTypefaceGroup::TBaselineShift ret2 = grp->BaselineShift(); + TEST2(ret2, CLinkedTypefaceGroup::ENoBaselineShift); + + CleanupStack::PopAndDestroy(grp); + } + +/** +@SYMTestCaseID +GRAPHICS-FNTSTORE-LINKEDFONTS-0002 + +@SYMPREQ +PREQ2146 + +@SYMREQ +PREQ2146 + +@SYMTestCaseDesc +Tests construction of a Linked Typeface specification with both valid & invalid data. + +@SYMTestPriority +Critical + +@SYMTestStatus +Implemented + +@SYMTestActions +Tests a number of different combinations (listed) of adding, removing and updating groups and +elements from a linked typeface specification. + +Tests applicable to CLinkedTypefaceGroup / CLinkedTypefaceSpecification + +1. Adding a valid group +2. Adding a duplicate group +3. Adding a group with the same Id as an existing one +4. Removal of group +12. Remove invalid GroupId +13. Adding more than KMaxLinkedTypefaceGroups groups +14. Retrieve Group with index out of bounds + + +Tests applicable to CLinkedTypefaceElementSpec / CLinkedTypefaceSpecification + +5. Adding a valid element +6. Adding a duplicate element +7. Ensuring ordering of elements is as specified +8. Ensure canonical index is correct when element moved/removed +9. Ensuring correct error if extra canonical added +10. Ensuring correct error if canonical activated "in-place" +11. Removal of element +15. Create Specification & Element with too short (0)/long (KMaxTypefaceNameLength) names. +16. Adding more than KMaxLinkedTypefaces Elements +17. Retrieve Typeface with index out of bounds + +@SYMTestExpectedResults +The canonical index is expected to be set to the values provided through the test after the +various operations performed. Addition & removal should provide success or fail error codes +as indicated throughout the test. Actions are referenced within the code with expected results. +*/ +void CTLinkedFonts2::TestLinkedClientAddAndRemoveL() + { + INFO_PRINTF1(_L("TestLinkedClientAddAndRemoveL")); + + CFbsTypefaceStore* store = CFbsTypefaceStore::NewL(NULL); + CleanupStack::PushL(store); + + _LIT(KTestLinkedFont, "TestLinkedFont"); + CLinkedTypefaceSpecification* typefaceSpec = + CLinkedTypefaceSpecification::NewLC(KTestLinkedFont); + + TInt canIndex = typefaceSpec->CanonicalIndex(); + TEST(canIndex == KErrNotFound); + TRAPD(ret, typefaceSpec->RegisterLinkedTypefaceL(*store)); + TEST(ret == KErrNotFound); + + + const TInt KGroup1Id = 1; + CLinkedTypefaceGroup* group1 = CLinkedTypefaceGroup::NewLC(KGroup1Id); + //Action 1 : Valid group + TRAP(ret, typefaceSpec->AddLinkedTypefaceGroupL(*group1)); + TEST(ret == KErrNone); + CleanupStack::Pop(group1); + + //Action 2 : Same group again + TRAP(ret, typefaceSpec->AddLinkedTypefaceGroupL(*group1)); + TEST(ret == KErrAlreadyExists); + + //Action 3 : Group with existing Id + CLinkedTypefaceGroup* duplicateGroup = CLinkedTypefaceGroup::NewLC(KGroup1Id); + TRAP(ret, typefaceSpec->AddLinkedTypefaceGroupL(*duplicateGroup)); + TEST(ret == KErrAlreadyExists); + CleanupStack::PopAndDestroy(duplicateGroup); + + //Action 1 : Valid group + const TInt KGroup2Id = 2; + CLinkedTypefaceGroup* group2 = CLinkedTypefaceGroup::NewLC(KGroup2Id); + group2->SetBaselineShift(CLinkedTypefaceGroup::EBaselineShift); + group2->SetScalingOption(CLinkedTypefaceGroup::EScalingUpOrDown); + TRAP(ret, typefaceSpec->AddLinkedTypefaceGroupL(*group2)); + TEST(ret == KErrNone); + CleanupStack::Pop(group2); + + const TInt KGroup3Id = 4; + CLinkedTypefaceGroup* group3 = CLinkedTypefaceGroup::NewLC(KGroup3Id); + TRAP(ret, typefaceSpec->AddLinkedTypefaceGroupL(*group3)); + TEST(ret == KErrNone); + CleanupStack::Pop(group3); + + //Action 5 : Japanese typefaces + _LIT(KJapaneseElement, "Japanese"); + CLinkedTypefaceElementSpec* element1 = CLinkedTypefaceElementSpec::NewLC(KJapaneseElement, KGroup2Id); + TRAP(ret, typefaceSpec->AddTypefaceAtBackL(*element1)); + CleanupStack::Pop(element1); + + //Action 5: Add the canonical element (Latin) + _LIT(KLatinElement, "DejaVu Sans Mono Bold"); + CLinkedTypefaceElementSpec* element2 = CLinkedTypefaceElementSpec::NewLC(KLatinElement, KGroup1Id); + element2->SetCanonical(ETrue); + + TRAP(ret, typefaceSpec->AddTypefaceAtIndexL(*element2,0)); + TEST(ret == KErrNone); + CleanupStack::Pop(element2); + + //Action 8 : Check Canonical Index is correct + canIndex = typefaceSpec->CanonicalIndex(); + TEST(canIndex == 0); + + //Action 5 : Hindi typefaces + _LIT(KHindiElement, "Chandas"); + CLinkedTypefaceElementSpec* element3 = CLinkedTypefaceElementSpec::NewLC(KHindiElement, KGroup3Id); + TRAP(ret, typefaceSpec->AddTypefaceAtBackL(*element3)); + TEST(ret == KErrNone); + CleanupStack::Pop(element3); + + //Action 6 : Same element again + TRAP(ret, typefaceSpec->AddTypefaceAtBackL(*element3)); + TEST(ret == KErrAlreadyExists); + + //Action 7 : Check ordering is correct + TEST2(element1, typefaceSpec->Typeface(1)); + TEST2(element2, typefaceSpec->Typeface(0)); + TEST2(element3, typefaceSpec->Typeface(2)); + + _LIT(KDummyTypeface, "DummyTypeface"); + CLinkedTypefaceElementSpec* dummyElement1 = CLinkedTypefaceElementSpec::NewLC(KDummyTypeface, KGroup2Id); + + //Action 9 : Add second canonical + dummyElement1->SetCanonical(ETrue); + TRAP(ret, typefaceSpec->AddTypefaceAtBackL(*dummyElement1)); + TEST(ret == KErrArgument); + + //Add at front of typeface to check canonical index is updated. + dummyElement1->SetCanonical(EFalse); + TRAP(ret, typefaceSpec->AddTypefaceAtIndexL(*dummyElement1, 0)); + TEST(ret == KErrNone); + CleanupStack::Pop(dummyElement1); + + canIndex = typefaceSpec->CanonicalIndex(); + TEST(canIndex == 1); + + dummyElement1 = CLinkedTypefaceElementSpec::NewLC(KDummyTypeface, 180); + TRAP(ret, typefaceSpec->AddTypefaceAtIndexL(*dummyElement1, 0)); + TEST(ret == KErrArgument); + CleanupStack::PopAndDestroy(dummyElement1); + + //Action 11 : Remove Element + typefaceSpec->RemoveTypeface(0); + TEST2(element2, typefaceSpec->Typeface(0)); + + //Action 8 : Check canonical index is correct + canIndex = typefaceSpec->CanonicalIndex(); + TEST(canIndex == 0); + + //Action 10 : Check error if extra canonical activated "in place" + typefaceSpec->Typeface(1)->SetCanonical(ETrue); + canIndex = typefaceSpec->CanonicalIndex(); + TEST(canIndex == KErrOverflow); + TRAP(ret, typefaceSpec->RegisterLinkedTypefaceL(*store)); + TEST(ret == KErrOverflow); + //Reset back to be non-canonical + typefaceSpec->Typeface(1)->SetCanonical(EFalse); + + //Action 8 : Check canonical index is correct + typefaceSpec->RemoveTypeface(0); + TEST2(element1, typefaceSpec->Typeface(0)); + + //Action 8 : Check canonical index is correct + canIndex = typefaceSpec->CanonicalIndex(); + TEST(canIndex == -1); + + //Action 4 : Remove the group + TRAP(ret, typefaceSpec->RemoveLinkedTypefaceGroup(KGroup3Id)); + TEST(ret == KErrNone); + CLinkedTypefaceGroup* groupRet = typefaceSpec->GroupById(KGroup3Id); + TEST(groupRet == NULL); + + TEST2(element1, typefaceSpec->Typeface(0)); + + //Action 12 : Remove invalid group + ret = typefaceSpec->RemoveLinkedTypefaceGroup(180); + TEST(ret == KErrNotFound); + //Action 4 : Remove group + ret = typefaceSpec->RemoveLinkedTypefaceGroup(KGroup1Id); + TEST(ret == KErrNone); + groupRet = typefaceSpec->GroupById(KGroup1Id); + TEST(groupRet == NULL); + + CleanupStack::PopAndDestroy(typefaceSpec); + + //Negative Name length tests + _LIT(KEmptyTypefaceName, ""); + //Action 15 : Create Specification & Element with 0 length names + TRAP(ret, typefaceSpec = CLinkedTypefaceSpecification::NewLC(KEmptyTypefaceName)); + TEST(ret == KErrArgument); + TRAP(ret, dummyElement1 = CLinkedTypefaceElementSpec::NewLC(KEmptyTypefaceName,1)); + TEST(ret < KErrNone); + //Action 15: Create Specification & Element with name longer than KMaxTypefaceNameLength + _LIT(KLongTypefaceName, "KErrArgumentKErrArgumentKErrArgument"); + TRAP(ret, typefaceSpec = CLinkedTypefaceSpecification::NewLC(KLongTypefaceName)); + TEST(ret == KErrArgument); + TRAP(ret, dummyElement1 = CLinkedTypefaceElementSpec::NewLC(KLongTypefaceName,1)); + TEST(ret < KErrNone); + + typefaceSpec = CLinkedTypefaceSpecification::NewLC(KTestLinkedFont); + TInt i; + for (i = 0 ; i <= KMaxLinkedTypefaceGroups+1 ; i++) + { + CLinkedTypefaceGroup* group = CLinkedTypefaceGroup::NewLC(i); + + if (i < KMaxLinkedTypefaceGroups) + { + //Add Groups 1-KMaxLinkedTypefaceGroups + TRAP(ret, typefaceSpec->AddLinkedTypefaceGroupL(*group)); + CleanupStack::Pop(group); + } + else + { + //Action 13 : Add group at KMaxLinkedTypefaceGroups+1 + TRAP(ret, typefaceSpec->AddLinkedTypefaceGroupL(*group)); + TEST(ret == KErrOverflow); + CleanupStack::PopAndDestroy(group); + } + } + + _LIT(KFormatElementName, "Element%d"); + for (i = 0 ; i <= KMaxLinkedTypefaces ; i++) + { + TBuf<18> elementName; + elementName.Format(KFormatElementName,i); + CLinkedTypefaceElementSpec* element = CLinkedTypefaceElementSpec::NewLC(elementName,i); + if (i < KMaxLinkedTypefaces) + { + //Add Elements 1-KMaxLinkedTypefaces + TRAP(ret,typefaceSpec->AddTypefaceAtBackL(*element)); + CleanupStack::Pop(element); + } + else + { + //Action 16 : Add element KMaxLinkedTypefaces+1 + TRAP(ret,typefaceSpec->AddTypefaceAtBackL(*element)); + TEST(ret == KErrOverflow); + CleanupStack::PopAndDestroy(element); + } + } + + //Action 14 : Retrieve out of bounds groups + TEST2(typefaceSpec->Group(-1), NULL); + TEST2(typefaceSpec->Group(typefaceSpec->GroupCount()+1), NULL); + //Action 17 : Retrieve typeface with index out of bounds + TEST2(typefaceSpec->Typeface(-1), NULL); + TEST2(typefaceSpec->Typeface(typefaceSpec->TypefaceCount()+1), NULL); + //Action 11 : Remove typeface with index out of bounds + TEST2(typefaceSpec->RemoveTypeface(-1), KErrNotFound); + TEST2(typefaceSpec->RemoveTypeface(typefaceSpec->TypefaceCount()+1), KErrNotFound); + + CleanupStack::PopAndDestroy(2, store); + } + +/** +@SYMTestCaseID +GRAPHICS-FNTSTORE-LINKEDFONTS-0003 + +@SYMPREQ +PREQ2146 + +@SYMREQ +PREQ2146 + +@SYMTestCaseDesc +Tests the Add & RemoveTypeface functions provided by COpenFontLinkedTypefaceSpecification + +@SYMTestPriority +Critical + +@SYMTestStatus +Implemented + +@SYMTestActions +Tests applicable to CLinkedTypefaceGroup / COpenFontLinkedTypefaceSpecification + +1. Adding a valid group +2. Adding a duplicate group (same object) +3. Adding a group with the same Id as an existing one +4. Removal of group +12. Remove invalid GroupId +13. Adding more than KMaxLinkedTypefaceGroups groups +14. Retrieve Group with index out of bounds + +Tests applicable to COpenFontLinkedTypefaceElementSpec / COpenFontLinkedTypefaceSpecification + +5. Adding a valid element +6. Adding a duplicate element (same object) +7. Ensuring ordering of elements is as specified +8. Ensure canonical index is correct when element moved/removed +9. Ensuring correct error if extra canonical added +10. Ensuring correct error if canonical activated "in-place" +11. Removal of element +15. Create Specification & Element with too short (0)/long (KMaxTypefaceNameLength) names. +16. Adding more than KMaxLinkedTypefaces Elements +17. Retrieve Typeface with index out of bounds + +@SYMTestExpectedResults +The canonical index is expected to be set to the values provided through the test after the +various operations performed. Addition & removal should provide success or fail error codes +as indicated throughout the test. Actions are referenced within the code with expected results. +*/ +void CTLinkedFonts2::TestOpenClientAddAndRemoveL() + { + INFO_PRINTF1(_L("TestOpenClientAddAndRemoveL")); + + _LIT(KTestLinkedFont, "TestLinkedFont"); + COpenFontLinkedTypefaceSpecification* typefaceSpec = + COpenFontLinkedTypefaceSpecification::NewLC(KTestLinkedFont); + + TInt canIndex = typefaceSpec->CanonicalIndex(); + TEST(canIndex == -1); + + TInt ret; + + //Action 1 : Add a valid group + const TInt KGroup1Id = 1; + CLinkedTypefaceGroup* group1 = CLinkedTypefaceGroup::NewLC(KGroup1Id); + TRAP(ret, typefaceSpec->AddLinkedTypefaceGroupL(*group1)); + TEST(ret == KErrNone); + CleanupStack::Pop(group1); + + //Action 2 : Add a duplicate group + TRAP(ret, typefaceSpec->AddLinkedTypefaceGroupL(*group1)); + TEST(ret == KErrAlreadyExists); + + //Action 3 : Add a group with the same id + CLinkedTypefaceGroup* duplicateGroup = CLinkedTypefaceGroup::NewLC(KGroup1Id); + TRAP(ret, typefaceSpec->AddLinkedTypefaceGroupL(*duplicateGroup)); + TEST(ret == KErrAlreadyExists); + CleanupStack::PopAndDestroy(duplicateGroup); + + //Action 5 : Add a valid element + const TInt KGroup2Id = 2; + CLinkedTypefaceGroup* group2 = CLinkedTypefaceGroup::NewLC(KGroup2Id); + group2->SetBaselineShift(CLinkedTypefaceGroup::EBaselineShift); + group2->SetScalingOption(CLinkedTypefaceGroup::EScalingUpOrDown); + TRAP(ret, typefaceSpec->AddLinkedTypefaceGroupL(*group2)); + TEST(ret == KErrNone); + CleanupStack::Pop(group2); + + const TInt KGroup3Id = 4; + CLinkedTypefaceGroup* group3 = CLinkedTypefaceGroup::NewLC(KGroup3Id); + TRAP(ret, typefaceSpec->AddLinkedTypefaceGroupL(*group3)); + TEST(ret == KErrNone); + CleanupStack::Pop(group3); + + //Action 5 : Add a valid element + _LIT(KJapaneseElement, "Japanese"); + COpenFontLinkedTypefaceElementSpec* element1 = COpenFontLinkedTypefaceElementSpec::NewLC(KJapaneseElement, KGroup2Id); + TRAP(ret, typefaceSpec->AddTypefaceAtBackL(*element1)); + CleanupStack::Pop(element1); + + //Action 5 : Add a valid element + _LIT(KLatinElement, "DejaVu Sans Mono Bold"); + COpenFontLinkedTypefaceElementSpec* element2 = COpenFontLinkedTypefaceElementSpec::NewLC(KLatinElement, KGroup1Id); + element2->SetCanonical(ETrue); + + TRAP(ret, typefaceSpec->AddTypefaceAtIndexL(*element2,0)); + TEST(ret == KErrNone); + CleanupStack::Pop(element2); + + //Action 8 : Ensure canonical index correct + canIndex = typefaceSpec->CanonicalIndex(); + TEST(canIndex == 0); + + _LIT(KHindiElement, "Chandas"); + COpenFontLinkedTypefaceElementSpec* element3 = COpenFontLinkedTypefaceElementSpec::NewLC(KHindiElement, KGroup3Id); + TRAP(ret, typefaceSpec->AddTypefaceAtBackL(*element3)); + TEST(ret == KErrNone); + CleanupStack::Pop(element3); + + //Action 6 : Duplicate element + TRAP(ret, typefaceSpec->AddTypefaceAtBackL(*element3)); + TEST(ret == KErrAlreadyExists); + + //Action 7 : Ensure ordering correct + TEST2(element1, typefaceSpec->Typeface(1)); + TEST2(element2, typefaceSpec->Typeface(0)); + TEST2(element3, typefaceSpec->Typeface(2)); + + _LIT(KDummyTypeface, "DummyTypeface"); + COpenFontLinkedTypefaceElementSpec* dummyElement1 = COpenFontLinkedTypefaceElementSpec::NewLC(KDummyTypeface, KGroup2Id); + + //Action 9 : Add 2nd canonical + dummyElement1->SetCanonical(ETrue); + TRAP(ret, typefaceSpec->AddTypefaceAtBackL(*dummyElement1)); + TEST(ret == KErrArgument); + + //Add at front of typeface to check canonical index is updated. + dummyElement1->SetCanonical(EFalse); + TRAP(ret, typefaceSpec->AddTypefaceAtIndexL(*dummyElement1, 0)); + TEST(ret == KErrNone); + CleanupStack::Pop(dummyElement1); + + //Action 8 : Check canonical updated + canIndex = typefaceSpec->CanonicalIndex(); + TEST(canIndex == 1); + + //Action 11 : Remove element + typefaceSpec->RemoveTypeface(0); + TEST2(element2, typefaceSpec->Typeface(0)); + + //Action 8 : Check canonical updated + canIndex = typefaceSpec->CanonicalIndex(); + TEST(canIndex == 0); + + //Action 10 : Additional canonical set in-place + typefaceSpec->Typeface(1)->SetCanonical(ETrue); + canIndex = typefaceSpec->CanonicalIndex(); + TEST(canIndex == KErrOverflow); + typefaceSpec->Typeface(1)->SetCanonical(EFalse); + + //Action 11 : Remove element + typefaceSpec->RemoveTypeface(0); + TEST2(element1, typefaceSpec->Typeface(0)); + + //Action 8 : Canonical updated + canIndex = typefaceSpec->CanonicalIndex(); + TEST(canIndex == -1); + + //Action 4 : Remove group + TRAP(ret, typefaceSpec->RemoveLinkedTypefaceGroup(KGroup3Id)); + TEST(ret == KErrNone); + CLinkedTypefaceGroup* groupRet = typefaceSpec->GroupById(KGroup3Id); + TEST(groupRet == NULL); + + TEST2(element1, typefaceSpec->Typeface(0)); + + //Action 12 : Remove invalid group Id + ret = typefaceSpec->RemoveLinkedTypefaceGroup(180); + TEST(ret == KErrNotFound); + ret = typefaceSpec->RemoveLinkedTypefaceGroup(KGroup1Id); + TEST(ret == KErrNone); + + CleanupStack::PopAndDestroy(typefaceSpec); + + //Negative Name length tests + _LIT(KEmptyTypefaceName, ""); + //Action 15 : Create Specifications + TRAP(ret, typefaceSpec = COpenFontLinkedTypefaceSpecification::NewLC(KEmptyTypefaceName)); + TEST(ret == KErrArgument); + TRAP(ret, dummyElement1 = COpenFontLinkedTypefaceElementSpec::NewLC(KEmptyTypefaceName,1)); + TEST(ret < KErrNone); + _LIT(KLongTypefaceName, "KErrArgumentKErrArgumentKErrArgument"); + TRAP(ret, typefaceSpec = COpenFontLinkedTypefaceSpecification::NewLC(KLongTypefaceName)); + TEST(ret == KErrArgument); + TRAP(ret, dummyElement1 = COpenFontLinkedTypefaceElementSpec::NewLC(KLongTypefaceName,1)); + TEST(ret < KErrNone); + + typefaceSpec = COpenFontLinkedTypefaceSpecification::NewLC(KTestLinkedFont); + TInt i; + for (i = 0 ; i <= KMaxLinkedTypefaceGroups+1 ; i++) + { + CLinkedTypefaceGroup* group = CLinkedTypefaceGroup::NewLC(i); + + if (i < KMaxLinkedTypefaceGroups) + { + TRAP(ret, typefaceSpec->AddLinkedTypefaceGroupL(*group)); + CleanupStack::Pop(group); + } + else + { + TRAP(ret, typefaceSpec->AddLinkedTypefaceGroupL(*group)); + TEST(ret == KErrOverflow); + CleanupStack::PopAndDestroy(group); + } + } + + _LIT(KFormatElementName, "Element%d"); + for (i = 0 ; i <= KMaxLinkedTypefaces ; i++) + { + TBuf<18> elementName; + elementName.Format(KFormatElementName,i); + COpenFontLinkedTypefaceElementSpec* element = COpenFontLinkedTypefaceElementSpec::NewLC(elementName,i); + if (i < KMaxLinkedTypefaces) + { + TRAP(ret,typefaceSpec->AddTypefaceAtBackL(*element)); + CleanupStack::Pop(element); + } + else + { + TRAP(ret,typefaceSpec->AddTypefaceAtBackL(*element)); + TEST(ret == KErrOverflow); + CleanupStack::PopAndDestroy(element); + } + } + + TEST2(typefaceSpec->Group(-1), NULL); + TEST2(typefaceSpec->Group(typefaceSpec->GroupCount()+1), NULL); + TEST2(typefaceSpec->Typeface(-1), NULL); + TEST2(typefaceSpec->Typeface(typefaceSpec->TypefaceCount()+1), NULL); + TEST2(typefaceSpec->RemoveTypeface(-1), KErrNotFound); + TEST2(typefaceSpec->RemoveTypeface(typefaceSpec->TypefaceCount()+1), KErrNotFound); + CleanupStack::PopAndDestroy(typefaceSpec); + } + +/* Function is used to determine if complex fonts are available. It looks for a +test Devanagari font +*/ +TBool CTLinkedFonts2::ComplexFontAvailable() + { + _LIT(KTypefaceOT, "Chandas"); + + // Create the linked font + TTypeface typeface; + typeface.iName = KTypefaceOT; + TFontSpec fs1; + fs1.iTypeface = typeface; + fs1.iHeight = 4; + CFbsFont* font = NULL; + TInt err = iDev->GetNearestFontToDesignHeightInPixels(font, fs1); + if (font) + { + TFontSpec fs2 = font->FontSpecInTwips(); + iDev->ReleaseFont(font); + if (fs2.iTypeface.iName.Compare(KTypefaceOT) == 0) + { + return ETrue; + } + } + INFO_PRINTF1(_L("(N.B. Complex font not available so complex parts of test skipped)")); + return EFalse; + } + +/** + @SYMTestCaseID GRAPHICS-FNTSTORE-LINKEDFONTS-0100 + + @SYMPREQ PREQ2146 + + @SYMREQ REQ10924, REQ10925, REQ10926 + + @SYMTestCaseDesc To ensure that a linked typeface including a complex font can be created + and used. Test access to characters in a complex linked font. + + @SYMTestPriority Critical + + @SYMTestStatus Implemented + + @SYMTestActions (1) Create a linked font with a complex typeface. Draw text, + and compare against text drawn using a non-linked font. + + @SYMTestExpectedResults (1) - test allows a linked font with a complex typeface to be created +*/ +void CTLinkedFonts2::TestComplexLinkedFontsBasicL() + { + INFO_PRINTF1(_L("LinkedFonts2::TestComplexLinkedFontsBasicL")); + + CFbsTypefaceStore* store = CFbsTypefaceStore::NewL(iDev); + CleanupStack::PushL(store); + + TBool testComplex = ComplexFontAvailable(); + if (testComplex) + { + // Create typeface to be linked + _LIT(KLinkedTypefaceTT, "DejaVu Sans Condensed"); + _LIT(KLinkedTypefaceOT, "Chandas"); + + CLinkedTypefaceSpecification *typefaceSpec; + _LIT(KLinkedTypefaceTTOT, "LinkedTypefaceComp"); + + typefaceSpec = CLinkedTypefaceSpecification::NewLC(KLinkedTypefaceTTOT); + + CLinkedTypefaceGroup* group1 = CLinkedTypefaceGroup::NewLC(1); + typefaceSpec->AddLinkedTypefaceGroupL(*group1); + CleanupStack::Pop(); + + CLinkedTypefaceGroup* group2 = CLinkedTypefaceGroup::NewLC(2); + typefaceSpec->AddLinkedTypefaceGroupL(*group2); + CleanupStack::Pop(); + + // Add first typeface + CLinkedTypefaceElementSpec *elementSpec1; + elementSpec1 = CLinkedTypefaceElementSpec::NewLC(KLinkedTypefaceTT, 1); + + CLinkedTypefaceElementSpec *elementSpec2; + elementSpec2 = CLinkedTypefaceElementSpec::NewLC(KLinkedTypefaceOT, 2); + elementSpec2->SetCanonical(ETrue); + + typefaceSpec->AddTypefaceAtBackL(*elementSpec1); + typefaceSpec->AddTypefaceAtBackL(*elementSpec2); + CleanupStack::Pop(2, elementSpec1); + + TEST(typefaceSpec->TypefaceCount() == 2); + TEST(typefaceSpec->Name() == KLinkedTypefaceTTOT); + + // Now try registering the linked typeface + TRAPD(ret, typefaceSpec->RegisterLinkedTypefaceL(*store)); + + if (ret == KErrNotSupported) + { + INFO_PRINTF1(_L("No Rasterizer is present that supports the extended Font Linking interface. This test case has been skipped.")); + CleanupStack::PopAndDestroy(2,store); + } + else + { + TEST(ret == KErrNone); + + // Create the linked font + TTypeface typeface; + typeface.iName = KLinkedTypefaceTTOT; + TFontSpec fs; + fs.iTypeface = typeface; + fs.iHeight = 35; + CFbsFont* font = NULL; + TInt err = iDev->GetNearestFontToDesignHeightInPixels(font, fs); + + //check the font is the one requested + TFontSpec fontSpec = font->FontSpecInTwips(); + TEST(fontSpec.iTypeface.iName == KLinkedTypefaceTTOT); + + _LIT16(KEnglish1,"ABCD12345 "); + _LIT16(KHindi1,"\x0915\x094D\x0937\x0924\x094D\x0930\x093F\x092F\x0020"); + TEST(font != NULL); + const TPoint englishLinked(10,75); + const TPoint hindiLinked(10,150); + if (font) + { + // Use the font + iGc->UseFont(font); + iGc->Clear(); + iGc->DrawText(KEnglish1, englishLinked); + iGc->DrawText(KHindi1, hindiLinked); + iGc->DiscardFont(); + iDev->Update(); + User::After(1000*1000*5); + } + + // All the CFont functions can use a linked font and a non-linked + // font - with the same base font, results should be the same. + // Compare with the test function. + + //output the Hindi text + TTypeface typeface2; + typeface2.iName = KLinkedTypefaceOT; + TFontSpec fs2; + fs2.iTypeface = typeface2; + fs2.iHeight = 35; + CFbsFont* font2 = NULL; + err = iDev->GetNearestFontToDesignHeightInPixels(font2, fs2); + TEST(font2 != NULL); + + //check the font is the one requested + fontSpec = font2->FontSpecInTwips(); + TEST(fontSpec.iTypeface.iName == KLinkedTypefaceOT); + + const TPoint englishHindiFont(240, 75); + const TPoint hindiHindiFont(240, 150); + if (font2) + { + // Use the font + iGc->UseFont(font2); + iGc->DrawText(KEnglish1, englishHindiFont); + iGc->DrawText(KHindi1, hindiHindiFont); + iGc->DiscardFont(); + iDev->Update(); + User::After(1000*1000); + iDev->ReleaseFont(font2); + } + + //output the English text + TTypeface typeface3; + typeface3.iName = KLinkedTypefaceTT; + TFontSpec fs3; + fs3.iTypeface = typeface3; + fs3.iHeight = 35; + CFbsFont* font3 = NULL; + err = iDev->GetNearestFontToDesignHeightInPixels(font3, fs3); + TEST(font3 != NULL); + + //check the font is the one requested + fontSpec = font3->FontSpecInTwips(); + TEST(fontSpec.iTypeface.iName == KLinkedTypefaceTT); + + const TPoint englishSansSerifFont(440, 75); + const TPoint hindiSansSerifFont(440, 150); + if (font3) + { + // Use the font + iGc->UseFont(font3); + iGc->DrawText(KEnglish1, englishSansSerifFont); + iGc->DrawText(KHindi1, hindiSansSerifFont); + iGc->DiscardFont(); + iDev->Update(); + User::After(1000*1000); + iDev->ReleaseFont(font3); + } + + //compare rects. + if (font) + { + CFont::TMeasureTextOutput compareEnglish; + CFont::TMeasureTextOutput compareHindi; + //get the size of a text box to do the comparison + font->MeasureText(KEnglish1, NULL, &compareEnglish); + font->MeasureText(KHindi1, NULL, &compareHindi); + + //compare English + TRect englishLinkedRect (englishLinked.iX,englishLinked.iY, + englishLinked.iX+compareEnglish.iBounds.Width(), + englishLinked.iY+compareEnglish.iBounds.Height()); + TRect englishSansSerifRect (englishSansSerifFont.iX,englishSansSerifFont.iY, + englishSansSerifFont.iX+compareEnglish.iBounds.Width(), + englishSansSerifFont.iY+compareEnglish.iBounds.Height()); + + TBool val = iDev->RectCompare(englishLinkedRect, *iDev,englishSansSerifRect); + //this value is not compared since the rasterizer may resize/reposition fonts + + //compare Hindi + TRect hindiLinkedRect (hindiLinked.iX,hindiLinked.iY, + hindiLinked.iX+compareHindi.iBounds.Width(), + hindiLinked.iY+compareHindi.iBounds.Height()); + TRect hindiHindiRect (hindiHindiFont.iX,hindiHindiFont.iY, + hindiHindiFont.iX+compareHindi.iBounds.Width(), + hindiHindiFont.iY+compareHindi.iBounds.Height()); + val=iDev->RectCompare(hindiLinkedRect, *iDev,hindiHindiRect); + //do not call TEST(val) since size/position may be slightly different + iDev->ReleaseFont(font); + } + CleanupStack::PopAndDestroy(2, store); + } + } + } + +/** + @SYMTestCaseID GRAPHICS-FNTSTORE-LINKEDFONTS-0101 + + @SYMPREQ PREQ2146 + + @SYMREQ REQ10924, REQ10925, REQ10926 + + @SYMTestCaseDesc To test PREQ2146 linked fonts with bitmap fonts. Bitmap fonts are not + supported so an error needs to be returned on registration. + + @SYMTestPriority Critical + + @SYMTestStatus Implemented + + @SYMTestActions (1) Create a linked typeface elements, with one of them from a bitmap font + try registering, and KErrNotSupported error should be returned + + @SYMTestExpectedResults (1) - registering a bitmap font returns KErrNotSupported. +*/ +void CTLinkedFonts2::TestBitmapFontsL() + { + INFO_PRINTF1(_L("LinkedFonts2::TestBitmapFontsL")); + + CFbsTypefaceStore* store = CFbsTypefaceStore::NewL(iDev); + CleanupStack::PushL(store); + + // Create typeface to be linked + _LIT(KLinkedTypefaceTT, "DejaVu Sans Condensed"); + _LIT(KLinkedTypeFace1, "LinkedFont1"); //this is a bitmap font + + CLinkedTypefaceSpecification *typefaceSpec; + _LIT(KLinkedTypefaceBitmap, "LinkedTypefaceBitmap"); + + typefaceSpec = CLinkedTypefaceSpecification::NewLC(KLinkedTypefaceBitmap); + + CLinkedTypefaceGroup* group1 = CLinkedTypefaceGroup::NewLC(1); + typefaceSpec->AddLinkedTypefaceGroupL(*group1); + CleanupStack::Pop(); + + CLinkedTypefaceGroup* group2 = CLinkedTypefaceGroup::NewLC(2); + typefaceSpec->AddLinkedTypefaceGroupL(*group2); + CleanupStack::Pop(); + + // Add first typeface + CLinkedTypefaceElementSpec *elementSpec1; + elementSpec1 = CLinkedTypefaceElementSpec::NewLC(KLinkedTypefaceTT, 2); + + CLinkedTypefaceElementSpec *elementSpec2; + elementSpec2 = CLinkedTypefaceElementSpec::NewLC(KLinkedTypeFace1, 1); + elementSpec2->SetCanonical(ETrue); + + typefaceSpec->AddTypefaceAtBackL(*elementSpec1); + typefaceSpec->AddTypefaceAtBackL(*elementSpec2); + CleanupStack::Pop(2, elementSpec1); + + TEST(typefaceSpec->TypefaceCount() == 2); + TEST(typefaceSpec->Name() == KLinkedTypefaceBitmap); + + // Now try regstering the linked typeface + TRAPD(ret, typefaceSpec->RegisterLinkedTypefaceL(*store)); + TEST(ret == KErrNotSupported); + CleanupStack::PopAndDestroy(2, store); + } + +/** + @SYMTestCaseID GRAPHICS-FNTSTORE-LINKEDFONTS-0109 + + @SYMPREQ PREQ2146 + + @SYMREQ REQ10924, REQ10925, REQ10926 + + @SYMTestCaseDesc To test PREQ2146 linked fonts updates to the TOpenFontCharMetrics class. + + @SYMTestPriority Critical + + @SYMTestStatus Implemented + + @SYMTestActions (1) Create a TOpenFontCharMetrics object. + (2) Check that nothing is set + (3) Set a small positive baseline + (4) Check that the baseline is as set and the glyph type is still not set + (5) Set a large positive baseline + (6) Check that the baseline is as set and the glyph type is still not set + (7) Set a large negative baseline + (8) Check that the baseline is as set and the glyph type is still not set + (9) Set the glyph type. + (10) Check that the baseline is as set and the glyph type is as set + (11) Set the baseline to a again to various values + (12) Check that the baseline is as set and the glyph type has not changed + + @SYMTestExpectedResults (2) the default values are 0 for baseline and EGlyphBitmapTypeNotDefined for glyph type + (4)(6)(8)(10)(12) The values are are set, and setting the baseline does + not alter the glyph type and vice-versa. +*/ +void CTLinkedFonts2::TestTOpenFontMetrics() + { + TOpenFontMetrics metrics; + + TInt len = metrics.BaselineCorrection(); + TEST(len==0); + + metrics.SetBaselineCorrection(22); + len = metrics.BaselineCorrection(); + TEST(len==22); + + metrics.SetBaselineCorrection(444); + len = metrics.BaselineCorrection(); + TEST(len==444); + + metrics.SetBaselineCorrection(-333); + len = metrics.BaselineCorrection(); + TEST(len==-333); + + metrics.SetBaselineCorrection(444); + len = metrics.BaselineCorrection(); + TEST(len==444); + + metrics.SetBaselineCorrection(-1); + len = metrics.BaselineCorrection(); + TEST(len==-1); + + } + +void CTLinkedFonts2::TestLinkedRegistrationAndFetchL() + { + INFO_PRINTF1(_L("CTLinkedFonts2::TestLinkedRegistrationAndFetchL")); + CFbsTypefaceStore* store = CFbsTypefaceStore::NewL(iDev); + CleanupStack::PushL(store); + + //Create and register a dummy linked typeface to register. + _LIT(KFetchTypefaceName, "FetchFont"); + CLinkedTypefaceSpecification* typefaceSpec = CLinkedTypefaceSpecification::NewLC(KFetchTypefaceName); + + CLinkedTypefaceGroup* group1 = CLinkedTypefaceGroup::NewLC(1); + group1->SetBoldnessPercentage(20); + group1->SetItalicAngle(10); + group1->SetBaselineShift(CLinkedTypefaceGroup::EBaselineShift); + group1->SetScalingOption(CLinkedTypefaceGroup::EScalingDown); + + typefaceSpec->AddLinkedTypefaceGroupL(*group1); + CleanupStack::Pop(group1); + + CLinkedTypefaceGroup* group2 = CLinkedTypefaceGroup::NewLC(2); + group2->SetBoldnessPercentage(21); + group2->SetItalicAngle(11); + group2->SetBaselineShift(CLinkedTypefaceGroup::ENoBaselineShift); + group2->SetScalingOption(CLinkedTypefaceGroup::EScalingUp); + + typefaceSpec->AddLinkedTypefaceGroupL(*group2); + CleanupStack::Pop(group2); + + _LIT(KElement1Name, "DejaVu Sans Condensed"); + CLinkedTypefaceElementSpec* element1 = CLinkedTypefaceElementSpec::NewLC(KElement1Name, 1); + element1->SetCanonical(ETrue); + typefaceSpec->AddTypefaceAtBackL(*element1); + CleanupStack::Pop(element1); + + _LIT(KElement2Name, "Chandas"); + CLinkedTypefaceElementSpec* element2 = CLinkedTypefaceElementSpec::NewLC(KElement2Name, 2); + typefaceSpec->AddTypefaceAtBackL(*element2); + CleanupStack::Pop(element2); + + TRAPD(ret, typefaceSpec->RegisterLinkedTypefaceL(*store)); + if (ret == KErrNotSupported) + { + INFO_PRINTF1(_L("No Rasterizer is present that supports the extended Font Linking interface. This test case has been skipped.")); + CleanupStack::PopAndDestroy(2,store); + } + else + { + TEST(ret == KErrNone); + + CLinkedTypefaceSpecification* fetchSpec = CLinkedTypefaceSpecification::NewLC(KFetchTypefaceName); + TRAP(ret, fetchSpec->FetchLinkedTypefaceSpecificationL(*store)); + TEST(ret == KErrNone); + + //Compare Groups. Ordering isn't important so can get group by id rather than index. + TEST(typefaceSpec->GroupCount() == fetchSpec->GroupCount()); + CLinkedTypefaceGroup* groupf = fetchSpec->GroupById(1); + TEST(CompareGroups(group1,groupf)); + + groupf = fetchSpec->GroupById(2); + TEST(CompareGroups(group2,groupf)); + + //Check elements match + TEST(fetchSpec->TypefaceCount() == fetchSpec->TypefaceCount()); + + CLinkedTypefaceElementSpec* elementf = fetchSpec->Typeface(0); + TEST(CompareElementSpecs(elementf, element1)); + elementf = fetchSpec->Typeface(1); + TEST(CompareElementSpecs(elementf, element2)); + + CleanupStack::PopAndDestroy(3,store); + } + } + +/** + @SYMTestCaseID GRAPHICS-FNTSTORE-LINKEDFONTS-0110 + + @SYMDEF DEF137360 + + @SYMTestCaseDesc Ensure that font full names are used to build a linked font + + @SYMTestPriority Critical + + @SYMTestStatus Implemented + + @SYMTestActions Attempt to register a linked font using a font full name rather than a family + name. DejaVu Sans Condensed is both a family name and a full name. DejaVu Sans Mono Bold is full name only. + + @SYMTestExpectedResults Registration of the linked font will be sucessful. + Failing with KErrNotFound means either the test font is not available or there is a regression. +*/ +void CTLinkedFonts2::TestFontNameUsage() + { + CFbsTypefaceStore* store = CFbsTypefaceStore::NewL(NULL); + CleanupStack::PushL(store); + + CLinkedTypefaceSpecification* nameSpec = CLinkedTypefaceSpecification::NewLC(_L("FullNameTest")); + + CLinkedTypefaceGroup* group = CLinkedTypefaceGroup::NewLC(1); + nameSpec->AddLinkedTypefaceGroupL(*group); + CleanupStack::Pop(group); + + //Use a font whose name doesn't match a family name + CLinkedTypefaceElementSpec* element1 = CLinkedTypefaceElementSpec::NewLC(_L("DejaVu Sans Mono Bold"), 1); + element1->SetCanonical(ETrue); + nameSpec->AddTypefaceAtBackL(*element1); + CleanupStack::Pop(element1); + + CLinkedTypefaceElementSpec* element2 = CLinkedTypefaceElementSpec::NewLC(_L("Chandas"), 1); + nameSpec->AddTypefaceAtBackL(*element2); + CleanupStack::Pop(element2); + + TRAPD(ret, store->RegisterLinkedTypeface(*nameSpec)); + + TEST(ret == KErrNone); + + CleanupStack::PopAndDestroy(2, store); + } + +TBool CTLinkedFonts2::CompareElementSpecs(CLinkedTypefaceElementSpec* aSpec1, CLinkedTypefaceElementSpec* aSpec2) + { + if ( (aSpec1 == NULL ) && (aSpec2 == NULL) ) + return ETrue; + if ( (aSpec1 == NULL) || (aSpec2 == NULL) ) + return EFalse; + if (aSpec1->ElementName().Compare(aSpec2->ElementName()) != 0) + return EFalse; + if (aSpec1->Canonical() != aSpec2->Canonical()) + return EFalse; + if (aSpec1->GroupId() != aSpec2->GroupId()) + return EFalse; + + return ETrue; + } + +TBool CTLinkedFonts2::CompareElementSpecs(COpenFontLinkedTypefaceElementSpec* aSpec1, COpenFontLinkedTypefaceElementSpec* aSpec2) + { + if ( (aSpec1 == NULL ) && (aSpec2 == NULL) ) + return ETrue; + if ( (aSpec1 == NULL) || (aSpec2 == NULL) ) + return EFalse; + if (aSpec1->ElementName().Compare(aSpec2->ElementName()) != 0) + return EFalse; + if (aSpec1->Canonical() != aSpec2->Canonical()) + return EFalse; + if (aSpec1->GroupId() != aSpec2->GroupId()) + return EFalse; + + return ETrue; + } +/** +Compare two linked typeface groups; the first varable should be a locally created group and the second one fetched from the +rasterizer. If the local group has thresholds / metrics set to -1 ("best guess by rasterizer") then the differences between the +values are ignored. + */ +TBool CTLinkedFonts2::CompareGroups(CLinkedTypefaceGroup* aLocalGroup, CLinkedTypefaceGroup* aFetchedGroup) + { + if ( (aLocalGroup == NULL) && (aFetchedGroup == NULL) ) + return ETrue; + if ( (aLocalGroup == NULL) || (aFetchedGroup == NULL) ) + { + INFO_PRINTF1(_L("One of the specified groups is NULL")); + return EFalse; + } + + if (aLocalGroup->BaselineShift() != aFetchedGroup->BaselineShift()) + return EFalse; + + /*if (aLocalGroup->BoldnessPercentage() != -1) + { + if (aLocalGroup->BoldnessPercentage() != aFetchedGroup->BoldnessPercentage()) + { + INFO_PRINTF1(_L("Fail below caused by non-matching boldness percentages")); + return EFalse; + } + } + + if (aLocalGroup->ItalicAngle() != -1) + { + if (aLocalGroup->ItalicAngle() != aFetchedGroup->ItalicAngle()) + { + INFO_PRINTF1(_L("Fail below caused by non-matching italic angles")); + return EFalse; + } + } + */ + if (aLocalGroup->ScalingOption() != aFetchedGroup->ScalingOption()) + return EFalse; + if (aLocalGroup->GroupId() != aFetchedGroup->GroupId()) + return EFalse; + + return ETrue; + } + +__CONSTRUCT_STEP__(LinkedFonts2)