/*

* 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