// Copyright (c) 2009-2010 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 - Internal Symbian test code 

*/

#include <test/graphicsfontutils.h>

#include <graphics/fbsglyphdataiterator.h>

#include <graphics/fbsglyphmetricsarray.h>

#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

#include <sgresource/sgimage.h>

#include <egl/egl.h>

#include <vg/openvg.h>

typedef EGLBoolean (*TvgCreateEGLImageTargetKHRTypefPtr) (VGeglImageKHR image);

#endif

#include "tfbsglyphdata.h"

// Size of EGLSurface used for rendering to, in pixels.

const TSize KEglTargetSize(512, 512);

CTFbsGlyphData::CTFbsGlyphData()

	{

	SetTestStepName(KTFbsGlyphData);

	}

CTFbsGlyphData::~CTFbsGlyphData()

	{

	}

TVerdict CTFbsGlyphData::doTestStepPreambleL()

    {

#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

    User::LeaveIfError(iFbs.Connect());

	User::LeaveIfError(iSgDriver.Open());

#endif

	iCharCodeConverter = CCharCodeConverter::NewL();

    return CTe_graphicsperformanceSuiteStepBase::doTestStepPreambleL();

    }

TVerdict CTFbsGlyphData::doTestStepPostambleL()

    {

    delete iCharCodeConverter;

    iCharCodeConverter = NULL;

#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

    iSgDriver.Close();

    iFbs.Disconnect();

#endif

    return CTe_graphicsperformanceSuiteStepBase::doTestStepPostambleL();

    }

TVerdict CTFbsGlyphData::doTestStepL()

	{

#ifndef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

    INFO_PRINTF1(_L("CTFbsGlyphData can only be run with SgImage 'Lite'"));

    return TestStepResult();

#else

	SetTestStepID(_L("GRAPHICS-UI-BENCH-0178"));

	GlyphMetricsArrayL(ETestLanguageLatin, ETrue, 1000);

	RecordTestResultL();

	SetTestStepID(_L("GRAPHICS-UI-BENCH-0179"));

	GlyphMetricsArrayL(ETestLanguageLatin, EFalse, 50000);

	RecordTestResultL();

    // Tests 180 and 181 require a CMap table in order to convert CharacterCodes to GlyphCodes.

	SetTestStepID(_L("GRAPHICS-UI-BENCH-0180"));

	GlyphMetricsArrayL(ETestLanguageHindi, ETrue, 25);

	RecordTestResultL();

	SetTestStepID(_L("GRAPHICS-UI-BENCH-0181"));

	GlyphMetricsArrayL(ETestLanguageHindi, EFalse, 50000);

	RecordTestResultL();

	SetTestStepID(_L("GRAPHICS-UI-BENCH-0182"));

	GlyphMetricsQuerySingleGlyphL();

	RecordTestResultL();

	SetTestStepID(_L("GRAPHICS-UI-BENCH-0183"));

	GlyphDataIteratorOpenL(ETestLanguageLatin, ETrue, 50);

	RecordTestResultL();

	SetTestStepID(_L("GRAPHICS-UI-BENCH-0184"));

	GlyphDataIteratorOpenL(ETestLanguageLatin, EFalse, 500);

	RecordTestResultL();

    // Tests 185 and 186 require a CMap table in order to convert CharacterCodes to GlyphCodes.

	SetTestStepID(_L("GRAPHICS-UI-BENCH-0185"));

	GlyphDataIteratorOpenL(ETestLanguageHindi, ETrue, 10);

	RecordTestResultL();

	SetTestStepID(_L("GRAPHICS-UI-BENCH-0186"));

	GlyphDataIteratorOpenL(ETestLanguageHindi, EFalse, 5000);

	RecordTestResultL();

	SetTestStepID(_L("GRAPHICS-UI-BENCH-0187"));

	GlyphDataIteratorOpenSingleFontL();

	RecordTestResultL();

	SetTestStepID(_L("GRAPHICS-UI-BENCH-0188"));

	GlyphMetricsQueryUnrasterizedL();

	RecordTestResultL();

	SetTestStepID(_L("GRAPHICS-UI-BENCH-0189"));

	GlyphMetricsQueryPreRasterizedL();

	RecordTestResultL();

	SetTestStepID(_L("GRAPHICS-UI-BENCH-0190"));

	GlyphRenderingL();

	RecordTestResultL();

	return TestStepResult();

#endif

    }

#ifdef SYMBIAN_GRAPHICS_EGL_SGIMAGELITE

/**

@SYMTestCaseID GRAPHICS-UI-BENCH-0178...0181

@SYMTestType UT

@SYMPREQ PREQ2678

@SYMTestCaseDesc 

Measures the performance of calling RFbsGlyphMetricsArray::Get() with different sample data.

The sample data can be a single word, or a very long array of glyphs, in latin or non-latin

alphabets. At each repetition a different font is used, cycled over nine fonts, to reduce the

effect of having cached glyphs.

@SYMTestActions

i. Create some sample fonts to cycle through. 

ii. Load sample data from config file, specified by aSampleDataKey.

iii. Create RFbsGlyphMetricsArray, open on sample data.

iv. For each repetition, call RFbsGlyphMetricsArray::Get(), adjusting font at each repetition.

v. Measure time from from first to last repetition.

@param aLanguage The language this test will use.

@param aLongData If ETrue, tells the test to use the long sample data string for the test, EFalse

	will make the test use the short string data.

@param aReps The number of times to repeat the test.

*/

void CTFbsGlyphData::GlyphMetricsArrayL(TTestLanguage aLanguage, TBool aLongData, TInt aReps)

	{

	TBuf<128> KTestName;

	TPtrC KTestVariant = ConfigKeyNameL(aLanguage, aLongData);

	KTestName.Format(_L("GlyphMetricsArray %S"), &KTestVariant);

	// Create some test fonts using the font factory.

	CTFontFactory* fontFactory = CTFontFactory::NewLC();

	fontFactory->CreateFontsL(aLanguage, 9);

	// Load the sample string data from the config file.

	TInt numGlyphCodes = 0;

	TUint* glyphCodes;

	LoadConfigSampleDataL(fontFactory->NextFont(), aLanguage, aLongData, glyphCodes, numGlyphCodes);

	// Run the test.

	TInt err = KErrNone;

	RFbsGlyphMetricsArray array;

	CleanupClosePushL(array);

	iProfiler->InitResults();

	for (TInt rep = aReps; (rep != 0) && (err == KErrNone); --rep)

		{

		err = array.Get(*(fontFactory->NextFont()), glyphCodes, numGlyphCodes);

		}

	iProfiler->MarkResultSetL();

	TESTE(err == KErrNone, err);

	iProfiler->ResultsAnalysisGlyphRate(KTestName, 0, 0, 0, aReps, numGlyphCodes);

	CleanupStack::PopAndDestroy(2); // array, fontFactory

	delete [] glyphCodes;

	}

/**

@SYMTestCaseID GRAPHICS-UI-BENCH-0182

@SYMTestType UT

@SYMPREQ PREQ2678

@SYMTestCaseDesc 

Measures the performance of calling RFbsGlyphDataIterator::Get() with a single glyph,

versus CFont::GetCharacterData(). Using a single glyph code is a very common use case.

The glyph and the font is changed at each iteration.

@SYMTestActions

i. Create some sample fonts to cycle through. 

ii. Create RFbsGlyphMetricsArray.

iii. For each repetition, call RFbsGlyphMetricsArray::Get(), adjusting the glyph at 

	each iteration.

iv. Measure time from from first to last iteration.

v. Repeat steps iii. and iv. with CFont::GetCharacterData().

*/

void CTFbsGlyphData::GlyphMetricsQuerySingleGlyphL()

	{

	_LIT(KTestName, "GlyphMetricsQuerySingleGlyph");

	const TInt KNumIterations = 50000;

	TInt err = KErrNone;

	TBuf<128> KTestNameVariant;

	// Create some test fonts using the font factory.

	CTFontFactory* fontFactory = CTFontFactory::NewLC();

	// Run the test for RFbsGlyphMetricsArray, with a different character 

	// and font for each iteration.

	KTestNameVariant.Format(_L("%S RFbsGlyphMetricsArray"), &KTestName);

	fontFactory->CreateFontsL(ETestLanguageLatin, 9);

	RFbsGlyphMetricsArray array;

	CleanupClosePushL(array);

	iProfiler->InitResults();

	for (TInt rep = KNumIterations; rep != 0 && (err == KErrNone); --rep)

		{

		const TUint KGlyphCode = 32 + (rep % 96);

		err = array.Get(*(fontFactory->NextFont()), &KGlyphCode, 1);

		}

	iProfiler->MarkResultSetL();

	TESTE(err == KErrNone, err);

	CleanupStack::PopAndDestroy(1); // array

	iProfiler->ResultsAnalysisGlyphRate(KTestNameVariant, 0, 0, 0, KNumIterations, 1);

	fontFactory->ReleaseFonts();

	// Run the test for GetCharacterData(), with a different character

	// and font for each iteration.

	KTestNameVariant.Format(_L("%S GetCharacterData"), &KTestName);

	fontFactory->CreateFontsL(ETestLanguageLatin, 9);

	TOpenFontCharMetrics metrics;

	const TUint8* bitmapData = NULL;

	TSize bitmapSize;

	iProfiler->InitResults();

	for (TInt rep = KNumIterations; rep != 0; --rep)

		{

		const TUint KGlyphCode = 32 + (rep % 96);

		fontFactory->NextFont()->GetCharacterData(KGlyphCode, metrics, bitmapData, bitmapSize);

		}

	iProfiler->MarkResultSetL();

	iProfiler->ResultsAnalysisGlyphRate(KTestNameVariant, 0, 0, 0, KNumIterations, 1);

	CleanupStack::PopAndDestroy(1); // fontFactory

	}

/**

@SYMTestCaseID GRAPHICS-UI-BENCH-0183...0186

@SYMTestType UT

@SYMPREQ PREQ2678

@SYMTestCaseDesc 

Measures the performance of calling RFbsGlyphDataIterator::Open() with different 

sample data, and iterating through the data with RFbsGlyphDataIterator::Next(). 

The sample data can be a single word, or a very long array of glyphs,

in various languages. At each repetition a different font is used, cycled

over nine fonts.

@SYMTestActions

i. Create some sample fonts to cycle through. 

ii. Create RFbsGlyphDataIterator.

iii. For each repetition, call RFbsGlyphDataIterator::Open(), adjusting the glyph at each 

	iteration. The font is changed at each repetition.

iv. Measure time from from first to last repetition.

@param aLanguage The language this test will use.

@param aLongData If ETrue, tells the test to use the long sample data string for the test, EFalse

	will make the test use the short string data.

@param aReps The number of times to repeat the test.

 */

void CTFbsGlyphData::GlyphDataIteratorOpenL(TTestLanguage aLanguage, TBool aLongData, TInt aReps)

	{

	TBuf<128> KTestName;

	TPtrC KTestVariant = ConfigKeyNameL(aLanguage, aLongData);

	KTestName.Format(_L("GlyphDataIteratorOpen %S"), &KTestVariant);

	// Create some test fonts using the font factory.

	CTFontFactory* fontFactory = CTFontFactory::NewLC();

	fontFactory->CreateFontsL(aLanguage, 9);

	// Load the sample string data from the config file.

	TInt numGlyphCodes = 0;

	TUint* glyphCodes;

	LoadConfigSampleDataL(fontFactory->NextFont(), aLanguage, aLongData, glyphCodes, numGlyphCodes);

	// Run the test.

	TInt err = KErrNotFound;

	RFbsGlyphDataIterator iter;

	CleanupClosePushL(iter);

	iProfiler->InitResults();

	for (TInt rep = aReps; (rep != 0) && (err == KErrNotFound); --rep)

		{

		err = iter.Open(*(fontFactory->NextFont()), glyphCodes, numGlyphCodes);

		for (; err == KErrNone; err = iter.Next())

			{

			// no operation

			}

		iter.Close();

		}

	iProfiler->MarkResultSetL();

	TESTE(err == KErrNotFound, err);

	CleanupStack::PopAndDestroy(2); // iter, fontFactory

	iProfiler->ResultsAnalysisGlyphRate(KTestName, 0, 0, 0, aReps, numGlyphCodes);

	delete [] glyphCodes;

	}

/**

@SYMTestCaseID GRAPHICS-UI-BENCH-0187

@SYMTestType UT

@SYMPREQ PREQ2678

@SYMTestCaseDesc 

Measures the performance of calling RFbsGlyphDataIterator::Open() with different 

lengthed arrays but the same font. The sample data is a long array of characters.

@SYMTestActions

i. Create a single test font 

ii. Create RFbsGlyphDataIterator.

iii. Pass an array to RFbsGlyphDataIterator::Open(), starting with a single glyph.

	For each iteration, increase the length of the array by one until the entire

	string has been opened.

iv. Measure the time to perform all the iterations.

@param aSampleDataKey The string key to lookup under the GlyphArraySampleText section of the 

	config file where the sample data is read.

@param aReps The number of times to repeat the test.

 */

void CTFbsGlyphData::GlyphDataIteratorOpenSingleFontL()

	{

	_LIT(KTestName, "GlyphDataIteratorOpenSingleFont");

	// A cap on the max number of iterations to complete.

	const TInt KMaxNumIterations = 200;

    const TTestLanguage KTestLanguage = ETestLanguageHindi;

	// Create some test fonts using the font factory.

	CTFontFactory* fontFactory = CTFontFactory::NewLC();

	fontFactory->CreateFontsL(KTestLanguage, 1);

	CFbsFont* font = fontFactory->NextFont();

	// Load the sample string data from the config file.

	TInt numGlyphCodes = 0;

	TUint* glyphCodes;

	LoadConfigSampleDataL(font, KTestLanguage, ETrue, glyphCodes, numGlyphCodes); 

	const TInt KNumRepetitions = Min<TInt>(numGlyphCodes - 1, KMaxNumIterations);

	RFbsGlyphDataIterator iter;

	CleanupClosePushL(iter);

	TInt iterErr = KErrNone;

	TInt glyphCount = 0;

	iProfiler->InitResults();

	for (glyphCount = 1; (glyphCount < KNumRepetitions); ++glyphCount)

		{

		iterErr = iter.Open(*font, glyphCodes, glyphCount);

		for (; iterErr == KErrNone; iterErr = iter.Next())

			{

			// no operation

			}

		iter.Close();

		}

	iProfiler->MarkResultSetL();

	TEST(glyphCount == KNumRepetitions);

	TESTE(iterErr == KErrNotFound, iterErr);

	const TInt KAvgNumCharsPerIteration = KNumRepetitions/2;

	iProfiler->ResultsAnalysisGlyphRate(KTestName, 0, 0, 0, KNumRepetitions, KAvgNumCharsPerIteration);

	CleanupStack::PopAndDestroy(2); // iter, fontFactory

	delete [] glyphCodes;

	}

/**

@SYMTestCaseID GRAPHICS-UI-BENCH-0188

@SYMTestType UT

@SYMPREQ PREQ2678

@SYMTestCaseDesc 

Measures the performance of querying the TOpenFontCharMetrics using the different

available APIs. RFbsGlyphMetricsArray, RFbsGlyphDataIterator, and CFont::GetCharacterData()

are compared against each other, using the same fonts, and same sample data.

This test uses glyphs that have not been rasterized before, therefore for certain

APIs this will mean rasterizing the glyphs.

@SYMTestActions

i. Load sample text data from config file.

ii. For each of RFbsGlyphMetricsArray, RFbsGlyphDataIterator, and CFont::GetCharacterData():

	1. Create 50 new fonts.

	2. Run the test, calling the necessary API once per font/loop.

	3. For GetCharacterData() and RFbsGlyphDataIterator(), cycle through each glyph

		to ensure all metrics have been retrieved. This is not necessary for 

		RFbsGlyphMetricsArray.

	4. Measure time between first and last font/loop.

	5. Destroy test fonts so that next test has to re-rasterize the glyphs.	

@SYMTestExpectedResults

Since this test uses non-rasterized fonts, RFbsGlyphMetricsArray should be faster than

GetCharacterData() and RFbsGlyphDataIterator, which both rasterize the glyphs in order to 

get their metrics information.

 */

void CTFbsGlyphData::GlyphMetricsQueryUnrasterizedL()

	{

	_LIT(KTestName, "GlyphMetricsQueryUnrasterized");

	TBuf<128> KTestNameVariant;

	// First do the test for the iterator. To ensure fair comparison with

    // RFbsGlyphMetricsArray, cycle through each iteration to ensure the metrics

    // for each glyph is found.

    KTestNameVariant.Format(_L("%S RFbsGlyphDataIterator"), &KTestName);

	const TInt KNumFonts = 50;

	const TTestLanguage KTestLanguage = ETestLanguageLatin;

	// Create some test fonts using the font factory.

	CTFontFactory* fontFactory = CTFontFactory::NewLC();

    fontFactory->CreateFontsL(KTestLanguage, KNumFonts);

	// Load the sample string data from the config file. Both the iterator and the

	// array will use this same sample data.

	TInt numGlyphCodes = 0;

	TUint* glyphCodes;

	LoadConfigSampleDataL(fontFactory->NextFont(), KTestLanguage, ETrue, glyphCodes, numGlyphCodes); 

	RFbsGlyphDataIterator iter;

	CleanupClosePushL(iter);

	TInt iterErr = KErrNone;

	TInt rep = 0;

	iProfiler->InitResults();

	for (rep = KNumFonts; (rep != 0); --rep)

		{

		iterErr = iter.Open(*(fontFactory->NextFont()), glyphCodes, numGlyphCodes);

		for (; iterErr == KErrNone; iterErr = iter.Next())

			{

			// no operation

			}

		iter.Close();

		}

	iProfiler->MarkResultSetL();

	TEST(rep == 0);

	TESTE(iterErr == KErrNotFound, iterErr);

	CleanupStack::PopAndDestroy(1); // iter		

	iProfiler->ResultsAnalysisGlyphRate(KTestNameVariant, 0, 0, 0, KNumFonts, numGlyphCodes);

	// Second, do the test for the array. This should be faster.

	// Destroy the fonts and re-create them so that they have to be re-rasterized

	// for a fair comparison.

	TInt arrayErr = KErrNone;

	KTestNameVariant.Format(_L("%S RFbsGlyphMetricsArray"), &KTestName);

	fontFactory->ReleaseFonts();

	fontFactory->CreateFontsL(KTestLanguage, KNumFonts);

	RFbsGlyphMetricsArray array;

	CleanupClosePushL(array);

	iProfiler->InitResults();	

	for (TInt rep = KNumFonts; (rep != 0) && (arrayErr == KErrNone); --rep)

		{

		arrayErr = array.Get(*(fontFactory->NextFont()), glyphCodes, numGlyphCodes);

		}

	iProfiler->MarkResultSetL();

	CleanupStack::PopAndDestroy(1); // array

	TEST(rep == 0);

	TESTE(arrayErr == KErrNone, arrayErr);

	iProfiler->ResultsAnalysisGlyphRate(KTestNameVariant, 0, 0, 0, KNumFonts, numGlyphCodes);

	// Third, do the test using GetCharacterData() to get the metrics.

	// Destroy the fonts and re-create them so that they have to be re-rasterized

	// for a fair comparison.

	KTestNameVariant.Format(_L("%S GetCharacterData"), &KTestName);

	fontFactory->ReleaseFonts();

	fontFactory->CreateFontsL(KTestLanguage, KNumFonts);	

	iProfiler->InitResults();

	const TUint8* bitmapData = NULL;

	TSize bitmapSize;

	TOpenFontCharMetrics metrics;	

	for (TInt rep = KNumFonts; (rep != 0); --rep)

		{

		CFbsFont* font = fontFactory->NextFont(); 

		for (TInt glyphIndex = 0; glyphIndex < numGlyphCodes; glyphIndex++)

			{

			font->GetCharacterData(glyphCodes[glyphIndex], metrics, bitmapData, bitmapSize);

			}

		}

	iProfiler->MarkResultSetL();

	iProfiler->ResultsAnalysisGlyphRate(KTestNameVariant, 0, 0, 0, KNumFonts, numGlyphCodes);

	CleanupStack::PopAndDestroy(1); // fontFactory

	delete [] glyphCodes;

	}

/**

@SYMTestCaseID GRAPHICS-UI-BENCH-0189

@SYMTestType UT

@SYMPREQ PREQ2678

@SYMTestCaseDesc 

Measures the performance of querying the TOpenFontCharMetrics using the different

available APIs. RFbsGlyphMetricsArray, RFbsGlyphDataIterator, and CFont::GetCharacterData()

are compared against each other, using the same fonts, and same sample data.

This test uses glyphs that have already been rasterized, thereby possibly reducing the 

extra overhead this has.

@SYMTestActions

i. Load sample text data from config file.

ii. Create test font.

iii. Pre-rasterize glyphs using RFbsGlyphDataIterator. This will rasterize the glyphs 

	and cause them to be cached for use by all the APIs tested here.

iv. For each of RFbsGlyphMetricsArray, RFbsGlyphDataIterator, and CFont::GetCharacterData():

	1. Begin the loop, calling the necessary API once per font/loop.

	2. For each glyph, request the glyph metrics.

	3. Measure time between first and last font/loop.

v. Destroy test font.

@SYMTestExpectedResults

All results should be improved over GlyphMetricsQueryUnrasterized (GRAPHICS-UI-BENCH-0187).

since no rasterizing should take place during these tests.

 */