/*
* 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 <graphics/openfontlinkedtypefacespecification.h>
#include <openfontlinkedtypefaceelementspec.h>

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)