/*

* Copyright (c) 2006-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: 

* T_NearestFont.cpp

*

*/

/**

 @file

 @test

 @internalComponent Internal Symbian test code

*/

#include "T_GetNearestFont.h"

#include <hal.h>

_LIT( KFontNotAvailable, "NotAvailableOnSystem" );

_LIT( KTypefaceName, "DejaVu Sans Condensed" );

_LIT( KFontAlias, "Alias");

class CTGetNearestFont : public CTGraphicsBase

	{

public:

	CTGetNearestFont(CTestStep* aStep);

	virtual ~CTGetNearestFont();

protected:

//from 	CTGraphicsStep

	virtual void RunTestCaseL(TInt aCurTestCase);

	virtual void ConstructL();

private:

	void TestINC064346();

	void AliasedFontCreationL();

	void TestFontStoreL();

	void TestSystemDefaultFont();

	CFbsTypefaceStore* iTfs;	

	};

CTGetNearestFont::CTGetNearestFont(CTestStep* aStep) :

	CTGraphicsBase(aStep)

	{

	}

void CTGetNearestFont::ConstructL()

	{

	iTfs = CFbsTypefaceStore::NewL(NULL);	

	}	

 CTGetNearestFont::~CTGetNearestFont()

 	{

 	delete iTfs; 	

 	}

void CTGetNearestFont::RunTestCaseL( TInt aCurTestCase )

	{	

	((CTGetNearestFontStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

	switch ( aCurTestCase )

		{

	case 1:

		((CTGetNearestFontStep*)iStep)->SetTestStepID(_L("GRAPHICS-INC064346-0001"));

		INFO_PRINTF1(_L("TestINC064346 Started"));

		TestINC064346();

		INFO_PRINTF1(_L("TestINC064346 Finished"));

		break;

	case 2:

		((CTGetNearestFontStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-0005"));

		INFO_PRINTF1(_L("TestFontStore Started"));

		TestFontStoreL();

		INFO_PRINTF1(_L("TestFontStore Finished"));

		break;	

	case 3:

		((CTGetNearestFontStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-0006"));

		INFO_PRINTF1(_L("Test System default font Started"));

		TestSystemDefaultFont();

		INFO_PRINTF1(_L("Test System default font Finished"));

	break;

	case 4:

		((CTGetNearestFontStep*)iStep)->SetTestStepID(_L("GRAPHICS-FNTSTORE-0051"));

		INFO_PRINTF1(_L("AliasedFontCreationL Started"));

		AliasedFontCreationL();

		INFO_PRINTF1(_L("AliasedFontCreationL Finished"));

		break;

	case 5:

		((CTGetNearestFontStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

		((CTGetNearestFontStep*)iStep)->CloseTMSGraphicsStep();

		TestComplete();		

		break;

		}

	((CTGetNearestFontStep*)iStep)->RecordTestResultL();

	}

void CTGetNearestFont::TestINC064346()

	{

	/**

	@SYMTestCaseID GRAPHICS-INC064346-0001

	@SYMTestType UT

	@SYMTestPriority Medium

	@SYMDEF INC064346

	@SYMTestCaseDesc Tests that the correct font height is returned when matching with a superscript font.

	@SYMTestActions Get nearest font to design height for a font with the following parameters:

		Font name must be specified that is a font that does not exist on the system.

		Font must be superscript, proportional and serif.

	@SYMTestExpectedResults The correct height must be returned for the nearest font found which is checked with the expected value.

	*/

	TInt ret = KErrGeneral;

	CFont* font = NULL;	

	TFontSpec spec(KFontNotAvailable, 15);

	spec.iFontStyle = TFontStyle(EPostureUpright, EStrokeWeightNormal, EPrintPosSuperscript);

	spec.iTypeface.SetIsProportional(ETrue);

	spec.iTypeface.SetIsSerif(ETrue);		

	ret = iTfs->GetNearestFontToDesignHeightInPixels(font, spec);		

	TEST(ret == KErrNone);

	INFO_PRINTF2(_L("Font height = %d"), font->HeightInPixels());		

	TEST(10 == font->HeightInPixels());	

	}

void CTGetNearestFont::TestFontStoreL()

	{

	/**

	@SYMTestCaseID GRAPHICS-FNTSTORE-0005

	@SYMPREQ PREQ1228

	@SYMREQ REQ5921

	@SYMTestCaseDesc Tests the font store optimisation changes for reduce the font load time

	@SYMTestPriority High

	@SYMTestStatus Implemented

	@SYMTestActions Get the nearest font to the design height for a font which exists and one which does not exists

	@SYMTestExpectedResults Time taken for fetching an existing font should be less then time take for fetching a non existent font.

							In addition fetching a non existent font should take almost the same time in principle, as taken by fetching 

							n existing with old method (as old search method checks all existing fonts even if it finds one in between 

							during search procedure).

	*/

	CFont* font = NULL;	

	TFontSpec spec(KFontNotAvailable, 15);

	spec.iHeight = 15;

	spec.iTypeface.iName = KFontNotAvailable;

	spec.iFontStyle = TFontStyle(EPostureUpright, EStrokeWeightNormal, EPrintPosSuperscript);

	spec.iTypeface.SetIsProportional(ETrue);		

	//Set the Bold and Italic attribute for the font

	TOpenFontSpec openFontSpec(spec);

	openFontSpec.SetBold(ETrue);

	openFontSpec.SetItalic(ETrue);

	openFontSpec.GetTFontSpec(spec);

	TInt64 		diffTime[2];

	//Run it twice with same font specifications except different typeface name

	//First iteration for Non Existent font and second iteration for Existent font

	for (TInt cntr = 0; cntr < 2; cntr++)

		{		 	

		TInt 		freq = 0;							

		TUint32	starttime = User::FastCounter();

		TInt ret = iTfs->GetNearestFontToDesignHeightInPixels(font, spec);

		TUint32 endtime = User::FastCounter();

		TEST(ret == KErrNone);

		User::LeaveIfError(HAL::Get(HALData::EFastCounterFrequency, freq));

		TUint32 diff = endtime - starttime;

		diffTime[cntr] = (1000000 * TInt64(diff)) / (TInt64)freq;			

		TFontSpec returnedSpecs = font->FontSpecInTwips();

		INFO_PRINTF3(_L("Font Desired  : Name  = %S Height = %d "), &spec.iTypeface.iName, spec.iHeight);

		INFO_PRINTF4(_L("Font Returned : Name = %S Height = %d Time = %d Microseconds"), &returnedSpecs.iTypeface.iName, font->HeightInPixels(),TUint32(diffTime[cntr]));

		//Change the font spec to specify available typeface			

		spec.iTypeface.iName = KTypefaceName;

		iTfs->ReleaseFont(font);				

		}

	TEST(diffTime[1] < diffTime[0]);

	INFO_PRINTF2(_L("OPTIMISATION Factor %f"), (TReal(1)-(TReal(diffTime[1])/TReal(diffTime[0]))));	

	}

/**

@SYMTestCaseID GRAPHICS-FNTSTORE-0006

@SYMTestPriority Critical

@SYMREQ REQ6158

@SYMTestCaseDesc 

Default system font

@SYMTestActions 

1 - Test without setting system default font

2 - Set the system default font to typeface 1

3 - Set the system default font to typeface 2

4 - Set the system default font to an empty descriptor 

5 - Set the system default font to large descriptor 

6 - Set the system default font to a font that does not exist 

7 - Set system font to an alias font 

@SYMTestExpectedResults 

The following applies when the typeface name is empty when requesting a font:

If a default system typeface is not set then the nearest font to the specified font will be returned.

If a default system typeface name is set then this will be the returned font.

If the character length of the system typeface is greater than KMaxTypefaceNameLength then a KErrTooBig leave will occur.

*/

void CTGetNearestFont::TestSystemDefaultFont()

	{	

	const TInt numTypefaces = iTfs->NumTypefaces();

	TEST(numTypefaces >= 2);	// Must have at least 2 typefaces

	// Get the first typeface

	TTypefaceSupport tfSupport1;

	iTfs->TypefaceSupport(tfSupport1, 0);

	TPtrC typeface1 = tfSupport1.iTypeface.iName;

	// Get the second typeface

	TTypefaceSupport tfSupport2;

	iTfs->TypefaceSupport(tfSupport2, 1);

	TPtrC typeface2 = tfSupport2.iTypeface.iName;

	// Test without setting system default font and the returned font should not be typeface1 or typeface2

	CFont* font = NULL;	

	TFontSpec spec(KNullDesC, 15);		

	spec.iTypeface.SetIsProportional(ETrue);

	spec.iTypeface.SetIsSerif(ETrue);		

	TInt ret = iTfs->GetNearestFontToDesignHeightInPixels(font, spec);

	TEST(ret == KErrNone);	

	TFontSpec returnedSpecs = font->FontSpecInTwips();

	TEST(returnedSpecs.iTypeface.iName != typeface1 && returnedSpecs.iTypeface.iName != typeface2);

	iTfs->ReleaseFont(font);

	// Now set the system default font and the returned font should be typeface1

	iTfs->SetSystemDefaultTypefaceNameL(typeface1);

	ret = iTfs->GetNearestFontToDesignHeightInPixels(font, spec);

	TEST(ret == KErrNone);	

	returnedSpecs = font->FontSpecInTwips();

	TEST(returnedSpecs.iTypeface.iName == typeface1);

	iTfs->ReleaseFont(font);

	// Now set the system default font and the returned font should be typeface2

	iTfs->SetSystemDefaultTypefaceNameL(typeface2);

	ret = iTfs->GetNearestFontToDesignHeightInPixels(font, spec);

	TEST(ret == KErrNone);	

	returnedSpecs = font->FontSpecInTwips();

	TEST(returnedSpecs.iTypeface.iName == typeface2);

	iTfs->ReleaseFont(font);

	// Now set the system default font to an empty descriptor and the font returned should not be typeface1 or typeface2

	iTfs->SetSystemDefaultTypefaceNameL(KNullDesC);

	ret = iTfs->GetNearestFontToDesignHeightInPixels(font, spec);

	TEST(ret == KErrNone);	

	returnedSpecs = font->FontSpecInTwips();

	TEST(returnedSpecs.iTypeface.iName != typeface1 && returnedSpecs.iTypeface.iName != typeface2);

	iTfs->ReleaseFont(font);

	// Set the system default font to large descriptor and we should get an error

	TRAP(ret, iTfs->SetSystemDefaultTypefaceNameL(_L("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz")));

	TEST(ret == KErrTooBig);		

	// Now set the system default font to a font that does not exist and the font returned should not be typeface 1 or typeface2

	_LIT( KFontNotExisting, "FontDoesNotExist" );

	iTfs->SetSystemDefaultTypefaceNameL(KFontNotExisting);

	ret = iTfs->GetNearestFontToDesignHeightInPixels(font, spec);

	TEST(ret == KErrNone);	

	returnedSpecs = font->FontSpecInTwips();

	TEST(returnedSpecs.iTypeface.iName != typeface1 && returnedSpecs.iTypeface.iName != typeface2);

	iTfs->ReleaseFont(font);	

	// Now set the system default font and set an alias on typeface1 - the returned font should still be typeface1

	iTfs->SetSystemDefaultTypefaceNameL(typeface1);

	iTfs->SetFontNameAliasL(typeface1, typeface2);

	ret = iTfs->GetNearestFontToDesignHeightInPixels(font, spec);

	TEST(ret == KErrNone);	

	returnedSpecs = font->FontSpecInTwips();

	TEST(returnedSpecs.iTypeface.iName == typeface1);

	iTfs->ReleaseFont(font);

	// Now set the system default font to an aliased font - the returned font should still be typeface1

	iTfs->SetSystemDefaultTypefaceNameL(KFontAlias);

	iTfs->SetFontNameAliasL(KFontAlias, typeface1);

	ret = iTfs->GetNearestFontToDesignHeightInPixels(font, spec);

	TEST(ret == KErrNone);

	returnedSpecs = font->FontSpecInTwips();

	TEST(returnedSpecs.iTypeface.iName == typeface1);

	iTfs->ReleaseFont(font);

	// tear down the default font

	iTfs->SetSystemDefaultTypefaceNameL(KNullDesC);

	}

/**

@SYMTestCaseID GRAPHICS-FNTSTORE-0051

@SYMTestType UT

@SYMTestPriority Medium

@SYMDEF INC127988

@SYMTestCaseDesc Tests that an alias does not prevent a real font from being loaded.

@SYMTestActions Create an alias using the name of a real font. Get the real font.  

@SYMTestExpectedResults Ensure the real font, not the aliased font is returned.

*/

void CTGetNearestFont::AliasedFontCreationL()

	{

	TInt numTypefaces = iTfs->NumTypefaces();

	TTypefaceSupport tfSupport;

	// Get the first different typeface

	while (--numTypefaces)

		{

		iTfs->TypefaceSupport(tfSupport, numTypefaces);

		if (tfSupport.iTypeface.iName != KTypefaceName)

			{

			break;

			}

		}

	// Make sure we aren't at the end of the list

	TEST(numTypefaces);

	TPtrC typeface = tfSupport.iTypeface.iName;

	// Alias the other font with the same name as the original

	iTfs->SetFontNameAliasL(KTypefaceName, typeface);

	// Request the original font (making sure we don't get the aliased font back)

	CFont* font = NULL;

	TFontSpec spec(KTypefaceName, 0);

	TInt ret = iTfs->GetNearestFontToDesignHeightInPixels(font, spec);

	TEST(ret == KErrNone);

	TFontSpec returnedSpecs = font->FontSpecInTwips();

	TEST(returnedSpecs.iTypeface.iName == KTypefaceName);

	iTfs->ReleaseFont(font);

	}

//--------------

__CONSTRUCT_STEP__(GetNearestFont)