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

*/

#include "tfbsbitmaphandleperf.h"

const TInt KIterationsToTest = 1000;

const TInt KMaxNumSmallTestBitmaps = 40;

const TInt KMaxNumLargeTestBitmaps = 4;

const TInt KNumTestBitmapSizes = 8;

const TDisplayMode KTestDisplayMode = EColor256;

const TDisplayMode KTestDisplayMode2 = EColor64K;

CTFbsBitmapHandlePerf::CTFbsBitmapHandlePerf()

	{

	SetTestStepName(KTFbsBitmapHandlePerfName);

	} 

CTFbsBitmapHandlePerf::~CTFbsBitmapHandlePerf()

	{

	iTestBitmaps.ResetAndDestroy();

	}

/**

Override of base class pure virtual

Our implementation only gets called if the base class doTestStepPreambleL() did

not leave. That being the case, the current test result value will be EPass.

@return - TVerdict code

*/

TVerdict CTFbsBitmapHandlePerf::doTestStepL()

	{

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

	SmallBitmapCreationL(KTestDisplayMode, _L("Small Bitmap-Create")); //8 bit

	RecordTestResultL();

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

	LargeBitmapCreationL(KTestDisplayMode, _L("Large Bitmap-Create"));

	RecordTestResultL();

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

	SmallBitmapCreationSimpleL();

	RecordTestResultL();

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

	LargeBitmapCreationSimpleL();

	RecordTestResultL();

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

	BitmapDuplicateL();		

	RecordTestResultL();

	return TestStepResult();

	}

/**

Creates and destroys bitmaps KIterationsToTest times with various sizes

using a pseudo-random sequence to try to simulate real usage patterns.

@param aSizes Array of KNumTestBitmapSizes sizes to create bitmaps with.

@param aMaxNumBitmaps Maximum number of created but not yet deleted bitmaps at any given time.

@param aDisplayMode The display mode to create bitmaps with.

*/

void CTFbsBitmapHandlePerf::BitmapCreationL(const TSize aSizes[], TInt aMaxNumBitmaps, const TDisplayMode aDisplayMode)

	{

	TInt64 seed = 0;

	iProfiler->InitResults();

	for (TInt count = KIterationsToTest; count > 0; --count)

		{

		CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;

		CleanupStack::PushL(bitmap);

		TInt err = bitmap->Create(aSizes[count % KNumTestBitmapSizes], aDisplayMode);

		User::LeaveIfError(err);

		iTestBitmaps.AppendL(bitmap);

		CleanupStack::Pop(bitmap);

		if (iTestBitmaps.Count() >= aMaxNumBitmaps)

			{

			TInt i = Math::Rand(seed) % aMaxNumBitmaps;

			delete iTestBitmaps[i];

			iTestBitmaps.Remove(i);

			}

		iProfiler->MarkResultSetL();

		}

	iTestBitmaps.ResetAndDestroy();

	}

/**

Creates and destroys bitmaps of the same size KIterationsToTest times.

@param aWidth The width of the created bitmaps.

@param aHeight  The height of the created bitmaps.

@param aDisplayMode The display mode to create bitmaps with.

@param aTestDescription The description of the test.

*/

void CTFbsBitmapHandlePerf::BitmapCreationSimpleL(const TInt aWidth, const TInt aHeight, const TDisplayMode aDisplayMode, const TDesC& aTestDescription)

	{

	iProfiler->InitResults();

	for (TInt count = KIterationsToTest; count > 0; --count)

		{

		CFbsBitmap bitmap;

		TInt err = bitmap.Create(TSize(aWidth, aHeight), aDisplayMode);

		User::LeaveIfError(err);

		iProfiler->MarkResultSetL();

		}

	iProfiler->ResultsAnalysis(aTestDescription, aDisplayMode, 0, 0, KIterationsToTest);

	}

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0074

@SYMTestCaseDesc

The test determines how long it takes to create and destroy small bitmap objects.

@SYMTestActions

Compare the results over time, and before and after changes to bitmap construction and destruction code.

@SYMTestExpectedResults

Test should pass and display total test time and time per bitmap

@param aDisplayMode The display mode to create bitmaps with.

@param aTestDescription The description of the test.

*/

void CTFbsBitmapHandlePerf::SmallBitmapCreationL(const TDisplayMode aDisplayMode, const TDesC& aTestDescription)

	{

	// width X height X bytes per pixel < KMaxLargeBitmapAlloc (16KB as of writing)

	const TSize KSmallSizes[KNumTestBitmapSizes] =

		{

		TSize(20, 20), // 1st

		TSize(22, 22), // 2nd

		TSize(24, 24), // 3rd

		TSize(28, 28), // 4th

		TSize(32, 32), // 5th

		TSize(40, 40), // 6th

		TSize(48, 48), // 7th

		TSize(60, 60)  // 8th

		};

	BitmapCreationL(KSmallSizes, KMaxNumSmallTestBitmaps, aDisplayMode);

	iProfiler->ResultsAnalysis(aTestDescription, aDisplayMode, 0, 0, KIterationsToTest);

	}

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0006

@SYMTestCaseDesc

The test determines how long it takes to create and destroy large bitmap objects.

@SYMTestActions

Compare the results over time, and before and after changes to bitmap construction and destruction code.

@SYMTestExpectedResults

Test should pass and display total test time and time per bitmap

@param aDisplayMode The display mode to create bitmaps with.

@param aTestDescription The description of the test.

*/

void CTFbsBitmapHandlePerf::LargeBitmapCreationL(const TDisplayMode aDisplayMode, const TDesC& aTestDescription)

	{

	// width X height X bytes per pixel > KMaxLargeBitmapAlloc (16KB as of writing)

	const TSize KLargeSizes[KNumTestBitmapSizes] =

		{

		TSize(200, 200), // 1st

		TSize(220, 220), // 2nd

		TSize(240, 240), // 3rd

		TSize(280, 280), // 4th

		TSize(320, 320), // 5th

		TSize(400, 400), // 6th

		TSize(480, 480), // 7th

		TSize(600, 600)  // 8th

		};

	BitmapCreationL(KLargeSizes, KMaxNumLargeTestBitmaps, aDisplayMode);

	iProfiler->ResultsAnalysis(aTestDescription, aDisplayMode, 0, 0, KIterationsToTest);

	}

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0007

@SYMTestCaseDesc

Tests how long it takes to duplicate a bitmap

@SYMTestActions

Compare the results over time, and before and after changes to bitmap duplication code.

@SYMTestExpectedResults

Test should pass and display total test time and time per bitmap

*/

void CTFbsBitmapHandlePerf::BitmapDuplicateL()

	{

	TSize size(200,200);

	TInt err;

	RArray<TInt> handles;

	RPointerArray<CFbsBitmap> bitmapArray;

	CleanupClosePushL(bitmapArray);

	// Create bitmaps for each display mode and store in array

	for(TInt count=KNumValidBitmapModes-1; count>=0; --count)

		{

		CFbsBitmap* bitmap=new(ELeave) CFbsBitmap;

		CleanupStack::PushL(bitmap);

		TDisplayMode mode = KValidBitmapModes[count];

		err = bitmap->Create(size, mode);

		User::LeaveIfError(err);

		User::LeaveIfError(bitmapArray.Append(bitmap));

		CleanupStack::Pop(bitmap);

		User::LeaveIfError(handles.Append(bitmap->Handle()));		

		}

	// Duplicate each bitmap in the array and measure performance

	iProfiler->InitResults();

	for(TInt count=KIterationsToTest; count>=0; --count)

		{

		CFbsBitmap* duplicateBitmap=new (ELeave) CFbsBitmap;

		CleanupStack::PushL(duplicateBitmap);

		TInt hn=count%KNumValidBitmapModes;

		TInt handle=handles[hn];

		err=duplicateBitmap->Duplicate(handle);

		User::LeaveIfError(err);

		CleanupStack::PopAndDestroy(duplicateBitmap);

		iProfiler->MarkResultSetL();

		}	

	iProfiler->ResultsAnalysis(_L("Bitmap-Duplicate"), 0, 0, 0, KIterationsToTest);	

	handles.Reset();

	bitmapArray.ResetAndDestroy();	

	CleanupStack::PopAndDestroy(&bitmapArray);

	}

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0087

@SYMTestCaseDesc

The test determines how long it takes to create and destroy small simple bitmap objects.

@SYMTestActions

Compare the results over time, and before and after changes to bitmap construction and destruction code.

@SYMTestExpectedResults

Test should pass and display total test time and time per bitmap

@param aDisplayMode The display mode to create bitmaps with.

@param aTestDescription The description of the test.

*/

void CTFbsBitmapHandlePerf::SmallBitmapCreationSimpleL()

	{

	BitmapCreationSimpleL(32, 32, KTestDisplayMode2, _L("Small Bitmap-Create-64K-Simple"));

	}

/**

@SYMTestCaseID

GRAPHICS-UI-BENCH-0088

@SYMTestCaseDesc

The test determines how long it takes to create and destroy large simple bitmap objects.

@SYMTestActions

Compare the results over time, and before and after changes to bitmap construction and destruction code.

@SYMTestExpectedResults

Test should pass and display total test time and time per bitmap

@param aDisplayMode The display mode to create bitmaps with.

@param aTestDescription The description of the test.

*/

void CTFbsBitmapHandlePerf::LargeBitmapCreationSimpleL()

	{

	BitmapCreationSimpleL(500, 500, KTestDisplayMode2, _L("Large Bitmap-Create-64K-Simple"));

	}