// 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 "toptimisedbmp.h"

 #include "fbsmessage.h"

 #include <test/tefunit.h>

 #include <hal.h>

 // The following line must be disabled for testing with the background compression code

 // When enabled foreground bitmap compression will take place.

 // #define FORCE_FOREGROUND_COMPRESSION

 // Number of times to repeat the tests

 const TInt KRepeatTestCount = 100;

 // The source bitmaps, only use the bitmaps from UIBENCH

 _LIT( KmbmFilesInRom, "z:\\system\\data\\uibench_*.mbm" );

 // The 16bit rle compressed source bitmap on Z drive

 _LIT( Kmbm16bppRleComprFileInRom, "z:\\system\\data\\rlecompr_16bpp.mbm" );

 // The 32bit alpha rle compressed source bitmap on Z drive

 _LIT( Kmbm32abppRleComprFileInRom, "z:\\system\\data\\rlecompr_32abpp.mbm" );

 // The 16bit rle compressed source bitmap on C drive

 _LIT( Kmbm16bppRleComprFileOnC, "c:\\compressedBitmaps\\rlecompr_16bpp.mbm" );

 #ifdef _DEBUG

 // The 32bit alpha  rle compressed source bitmap on C drive

 _LIT( Kmbm32abppRleComprFileOnC, "c:\\compressedBitmaps\\rlecompr_32abpp.mbm" );

 #endif

 // The resouce mbm file

 _LIT( KmbmResouceFile, "z:\\resource\\32bit20col.mbm" );

 // The directory to copy the bitmaps to

 _LIT( KDirectoryFilesOnC , "c:\\bitmapOptimisation\\" );

 // The directory to copy the compressed bitmaps to

 _LIT( KDirectoryComprBmpFilesOnC , "c:\\compressedBitmaps\\" );

 CTOptimisedBmp::CTOptimisedBmp()

 	{

 	SetTestStepName(KTOptimisedBmpStep);

 	}

 CTOptimisedBmp::~CTOptimisedBmp()

 	{

 	// clear test files

 	if (iFileMan)

 		{

 		TBuf <255> filePath;

 		_LIT(KFormat, "%S*.mbm");

 		filePath.Format(KFormat, &KDirectoryFilesOnC);

 		iFileMan->Delete(filePath);

 		//remove filepath for compressed bitmap

 		filePath.Format(KFormat, &KDirectoryComprBmpFilesOnC);		

 		iFileMan->Delete(filePath);

 		delete iFileMan;

 		}	

 	iFs.RmDir(KDirectoryFilesOnC);

 	//remove directory for compressed bitmap

 	iFs.RmDir(KDirectoryComprBmpFilesOnC);	

 	iFs.Close();

 	}

 /**

 Override of base class virtual

 @return - TVerdict code

 */

 TVerdict CTOptimisedBmp::doTestStepPreambleL()

 	{

 	CTe_graphicsperformanceSuiteStepBase::doTestStepPreambleL();

 	// copy all of the files in ROM z: to c:

 	TInt err =  iFs.Connect();

 	User::LeaveIfError(err);		

 	iFs.ShareProtected();

 	err =  iFs.MkDir(KDirectoryFilesOnC);

 	if (err != KErrNone && err != KErrAlreadyExists)

 		{

 		User::Leave(err);

 		}

 	//create directory to store rle-compressed bitmap	

 	err =  iFs.MkDir(KDirectoryComprBmpFilesOnC);

 	if (err != KErrNone && err != KErrAlreadyExists)

 		{

 		User::Leave(err);

 		}

 	iFileMan = CFileMan::NewL( iFs );

 	err =  iFileMan->Copy( KmbmFilesInRom, KDirectoryFilesOnC );

 	TESTL(err == KErrNone);

 	//Copying compressed mbm files to C drive

 	err =  iFileMan->Copy( Kmbm16bppRleComprFileInRom, KDirectoryComprBmpFilesOnC );

 	TESTL(err == KErrNone);

 	err =  iFileMan->Copy( Kmbm32abppRleComprFileInRom, KDirectoryComprBmpFilesOnC );

 	TESTL(err == KErrNone);

 	return TestStepResult();

 	}

 /**

 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 CTOptimisedBmp::doTestStepL()

 	{

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0021

 @SYMTestCaseDesc

 The test determines how long it takes to compress bitmaps, and how long it takes to bitblt the original and the compressed bitmaps.

 @SYMTestActions

 1. Over a number of iterations, measure time taken to compress a bitmap loaded from mbm file.  Each iteration the mbm is loaded from scratch.

 2. Over a number of iterations, measure time taken to blit an uncompressed bitmap loaded from mbm file. This mbm file is the same as in step 1.

 3. Over a number of iterations, measure time taken to blit the compressed bitmap loaded from step 1.

 4. Check that the blits of the uncompressed bitmap and the compressed bitmap are the same.

 Each of these steps is performed with various screen display modes and various display modes of the bitmap.

 @SYMTestExpectedResults

 Test should pass and display total and per bitmap compression, bitblt for uncompressed and compressed time.

 */

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

 	CompressedBitmapTestL();	

 	RecordTestResultL();

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0058

 @SYMTestCaseDesc

 The test determines how long it takes to load 16bpp compressed bitmaps.

 @SYMDEF INC095318

 @SYMTestPriority High

 @SYMTestActions

 Compare the results over time.

 @SYMTestExpectedResults

 Test should pass and logs the time taken to load compressed bitmap .

 */

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

 	TestDecompressBitmapL(Kmbm16bppRleComprFileOnC, _L("Load-Compressed-Bitmap-16bit"));

 	RecordTestResultL();

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0059

 @SYMTestCaseDesc

 The test determines how long it takes to load 32 bpp compressed alpha bitmaps.

 @SYMDEF DEF095361

 @SYMTestPriority Low

 @SYMTestActions

 Compare the results over time.

 @SYMTestExpectedResults

 Test should pass and logs the time taken to load compressed bitmap .

 */

 #ifdef _DEBUG

 	//It uses Heap Allocation failure macro 

 	//which is supported only for debug mode	

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

 	TestDecompressBitmapAltL(Kmbm32abppRleComprFileOnC, _L("Load-Compressed-Bitmap-32abit"));

 	RecordTestResultL();

 #endif

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

 	GetScanLineTestL();

 	RecordTestResultL();

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0085

 @SYMTestCaseDesc

 The test determines how long it takes to load a bitmap from the resource folder.

 @SYMDEF DEF105049

 @SYMTestPriority Medium

 @SYMTestActions

 Compare the results over time.

 @SYMTestExpectedResults

 Test should pass and display load time / bitmap.

 */

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

 	ResourceBitmapLoadL(KmbmResouceFile, 0, ETrue, _L("Resouce Bitmap Load"));

 	RecordTestResultL();

 	return TestStepResult();

 	}

 void CTOptimisedBmp::CompressedBitmapTestL()

 	{

 	_LIT(KTestName1, "CompressBitmap");

 	_LIT(KTestName2, "BlitUncompressedBitmap");

 	_LIT(KTestName3, "BlitCompressedBitmap");

 	// strings for writing target output

 	_LIT(KTargetString, "_TGT=");

 	_LIT(KSourceString, "_SRC=");

 	// for each of the files in the directory

 	// load, compress & compare size before and after

 	TBufC<KMaxFileName> fileName(KDirectoryFilesOnC);

 	TInt dirLen = KDirectoryFilesOnC().Length();

 	CDir* fileList;

 	TInt err = iFs.GetDir(KDirectoryFilesOnC, KEntryAttNormal, ESortBySize, fileList);

 	User::LeaveIfError(err);

 	CleanupStack::PushL(fileList);

 #ifdef FORCE_FOREGROUND_COMPRESSION

 	_LIT(KForceForegroundCompression, "Force Foreground Compression");

 	INFO_PRINTF2(KForceForegroundCompression);

 	RFbsSession* fbs = RFbsSession::GetSession();

 	if (!fbs)

 		{

 		ERR_PRINTF1("Error: fbs cannot be NULL");

 		SetTestStepError();

 		}		

 	fbs->SendCommand(EFbsCompress, 1); // force to compress the bitmaps in the foreground

 #endif // FORCE_FOREGROUND_COMPRESSION

 	CFbsBitmap* fbsBitmap = new(ELeave) CFbsBitmap;

 	CleanupStack::PushL(fbsBitmap);

 	CFbsBitmap* fbsCompressed = new(ELeave) CFbsBitmap;

 	CleanupStack::PushL(fbsCompressed);

 	for (TInt dispModeIndex = 0; dispModeIndex < KNumValidDisplayModes; dispModeIndex++)

 		{

 		SetScreenModeL(KValidDisplayModes[dispModeIndex], ETrue);

 		iGc->SetOrientation(CFbsBitGc::EGraphicsOrientationNormal);

 		TSize scrSize = iScreenDevice->SizeInPixels();

 		TPoint left(0 ,0);

 		TPoint right(scrSize.iWidth / 2, 0);

 		for (TInt ii = 0; ii < fileList->Count(); ++ii)

 			{

 			// Load uncompressed bitmap

 			const TEntry entry((*fileList)[ii]);

 			TPtr fnamePtr = fileName.Des();

 			fnamePtr.SetLength(dirLen);

 			fnamePtr.Append(entry.iName);

 			err = fbsBitmap->Load(fnamePtr, 0, EFalse);

 			if (err != KErrNone)

 				{

 				INFO_PRINTF3(_L("Error %d loading bitmap (%S)"), err, &fnamePtr);

 				fbsBitmap->Reset();

 				continue;

 				}

 			TDisplayMode bitmapDispMode = fbsBitmap->DisplayMode();  //same display mode used for fbsCompressed

 			TDisplayMode screenDispMode = iScreenDevice->BitmapDevice().DisplayMode();

 			TInt rpt;

 			// Test speed of compressing an image

 			iProfiler->InitResults();

 			for (rpt = 0; rpt < KRepeatTestCount; ++rpt)

 				{

 				// Load bitmap to be compressed

 				err = fbsCompressed->Load(fnamePtr, 0, EFalse);

 				if (err != KErrNone)

 					{

 					INFO_PRINTF4(_L("Error %d loading the bitmap (%S), rpt = %d"), err, &fnamePtr, rpt);

 					fbsCompressed->Reset();

 					break;

 					}

 				iProfiler->StartTimer();

 				fbsCompressed->Compress();

 				iProfiler->MarkResultSetL();

 				// on last iteration, don't reset fbsCompressed

 				if (rpt < KRepeatTestCount-1)

 					{

 					fbsCompressed->Reset();

 					}

 				}

 			iProfiler->ResultsAnalysis(KTestName1, CFbsBitGc::EGraphicsOrientationNormal, bitmapDispMode, screenDispMode, KRepeatTestCount);

 			// Clip rect size to half-screen width and screen height

 			TSize sizeInPixels = fbsBitmap->SizeInPixels();

 			if (sizeInPixels.iWidth > scrSize.iWidth / 2)

 				sizeInPixels.iWidth = scrSize.iWidth / 2;

 			if (sizeInPixels.iHeight > scrSize.iHeight)

 				sizeInPixels.iHeight = scrSize.iHeight;

 			TRect blitRect(TPoint(0,0), sizeInPixels);

 			TInt numPixels = sizeInPixels.iHeight * sizeInPixels.iWidth;

 			// Test pixel rate of blitting uncompressed bitmap

 			iProfiler->InitResults();

 			for (rpt = 0; rpt < KRepeatTestCount; ++rpt)

 				{

 				iGc->BitBlt(left, fbsBitmap, blitRect);

 				}

 			iProfiler->MarkResultSetL();

 			iProfiler->ResultsAnalysisPixelRate(KTestName2, CFbsBitGc::EGraphicsOrientationNormal, bitmapDispMode, screenDispMode, KRepeatTestCount, numPixels);

 			// Test pixel rate of blitting compressed bitmap

 			iProfiler->InitResults();

 			for (rpt = 0; rpt < KRepeatTestCount; ++rpt)

 				{

 				iGc->BitBlt(right, fbsCompressed, blitRect);

 				}

 			iProfiler->MarkResultSetL();

 			iProfiler->ResultsAnalysisPixelRate(KTestName3, CFbsBitGc::EGraphicsOrientationNormal, bitmapDispMode, screenDispMode, KRepeatTestCount, numPixels);

 			// Sanity check that uncompressed and compressed bitmaps display the same

 			CBitmapDevice& bmpDevice = iScreenDevice->BitmapDevice();

 			if (iScreenDevice->isScreenDevice())

 				{

 				TEST(((CFbsScreenDevice&)bmpDevice).RectCompare(TRect(left, sizeInPixels), (CFbsScreenDevice&)bmpDevice, TRect(right, sizeInPixels)));

 				}

 			else

 				{

 				TEST(((CFbsBitmapDevice&)bmpDevice).RectCompare(TRect(left, sizeInPixels), (CFbsBitmapDevice&)bmpDevice, TRect(right, sizeInPixels)));

 				}

 			fbsBitmap->Reset();

 			fbsCompressed->Reset();

 			// Save offscreen bitmap to mbm file

 			TBuf<KMaxFileName> testFileName;

 			testFileName.Append(KTestName1);

 			testFileName.Append(KTargetString);

 			TBuf<10> string;

 			string.Format(_L("%d"),screenDispMode);

 			testFileName.Append(string);

 			testFileName.Append(KSourceString);

 			string.Format(_L("%d"),bitmapDispMode);

 			testFileName.Append(string);

 			WriteTargetOutput(testFileName);

 			}

 		}

 	CleanupStack::PopAndDestroy(3, fileList); // fbsCompressed, fbsBitmap, fileList

 #ifdef FORCE_FOREGROUND_COMPRESSION

 	fbs->SendCommand(EFbsCompress, 0); // resume normal background compression

 #endif // FORCE_FOREGROUND_COMPRESSION

 	}

 void CTOptimisedBmp::StripeBitmap(CFbsBitmap& aBitmap) // Compression friendly bitmap filling

 	{

 	TSize size = aBitmap.SizeInPixels();

 	TInt dataLength = CFbsBitmap::ScanLineLength(size.iWidth,aBitmap.DisplayMode()) * size.iHeight;

 	aBitmap.LockHeap();

 	TUint8* bmpBits = (TUint8*)aBitmap.DataAddress();

 	aBitmap.UnlockHeap();

 	TUint8* bmpBitsLimit = bmpBits + dataLength;

 	TInt64 seed = aBitmap.Handle();

 	if (aBitmap.DisplayMode() != EColor4K)

 		{

 		while (bmpBits < bmpBitsLimit)

 			{

 			TUint8* tempBmpBitsLimit = Min(bmpBitsLimit, bmpBits + (TUint8)Math::Rand(seed));

 			while (bmpBits < tempBmpBitsLimit)

 				*bmpBits++ = 0;

 			tempBmpBitsLimit = Min(bmpBitsLimit, bmpBits + (TUint8)Math::Rand(seed));

 			while (bmpBits < tempBmpBitsLimit)

 				*bmpBits++ = 0xff;

 			}

 		}

 	else

 		{

 		Mem::FillZ(bmpBits,dataLength);

 		while (bmpBits < bmpBitsLimit)

 			{

 			TUint8* tempBmpBitsLimit = Min(bmpBitsLimit, bmpBits + (TUint8)(Math::Rand(seed) * 2));

 			while (bmpBits < tempBmpBitsLimit)

 				{

 				*bmpBits++ = 0;

 				*bmpBits++ = 0;

 				}

 			tempBmpBitsLimit = Min(bmpBitsLimit, bmpBits + (TUint8)Math::Rand(seed));

 			while (bmpBits < tempBmpBitsLimit)

 				{

 				*bmpBits++ = 0xff;

 				*bmpBits++ = 0x0f;

 				}

 			}		

 		}

 	}

 /**

 Logs the time taken to load the bitmap file identified by the filename.

 @param aFileName the mbm file that is to be loaded

 @param aTestCaseName the name of the test case

 */

 void CTOptimisedBmp::TestDecompressBitmapL(const TDesC& aFileName, const TDesC& aTestCaseName)

 	{

 	TInt err = KErrNone;

 	iProfiler->InitResults(); //initializes the timer

 	for (TInt rpt = 0; rpt < KRepeatTestCount; ++rpt)

 		{

 		CFbsBitmap* fbsCompressed = new (ELeave) CFbsBitmap;

 		CleanupStack::PushL( fbsCompressed );

 		//Load mbm file identified by aFileName

 		err = fbsCompressed->Load( aFileName, 0, EFalse ); //when there is no memory constraints

 		TEST(err == KErrNone);

 		fbsCompressed->Reset();

 		CleanupStack::PopAndDestroy( fbsCompressed );

 		iProfiler->MarkResultSetL();

 		} // rpt loop

 	//Logs the time taken to load the bmp file	

 	iProfiler->ResultsAnalysis(aTestCaseName, 0, 0, 0, KRepeatTestCount);

 	}

 #ifdef _DEBUG

 /**

 This test will only work correctly under UDEB builds of the OS.

 It is same as CTOptimisedBmp::TestDecompressBitmapL function except that it also simulates the 

 lack of memory use case while loading bitmap.

 @param aFileName the mbm file that is to be loaded

 @param aTestCaseName the name of the test case

 */

 void CTOptimisedBmp::TestDecompressBitmapAltL(const TDesC& aFileName, const TDesC& aTestCaseName)

 	{

 	TInt err = KErrNone;

 	RFbsSession* fbsSession = RFbsSession::GetSession();

 	if (!fbsSession)

 		{

 		INFO_PRINTF1(_L("Error: fbs cannot be NULL"));

 		ASSERT_NOT_NULL(fbsSession);

 		}

 	else

 		{

 		CFbsBitmap* fbsCompressed = new (ELeave) CFbsBitmap;

 		CleanupStack::PushL( fbsCompressed );

 		iProfiler->InitResults(); //initializes the timer

 		for (TInt rpt = 0; rpt < KRepeatTestCount; ++rpt)

 			{

 			//Load mbm file identified by aFileName

 			//Consider no memory case

 			for (TInt count = 1; ; count++)

 				{

 				//Explicitly make the memory fails to check how will it loads bmp

 				fbsSession->SendCommand(EFbsMessDefaultAllocFail,count);

 				fbsSession->SendCommand(EFbsMessDefaultMark);

 				fbsSession->SendCommand(EFbsMessUserMark);

 				err = fbsCompressed->Load( aFileName, 0, EFalse );

 				if (err == KErrNoMemory)

 					{

 					fbsSession->SendCommand(EFbsMessDefaultMarkEnd);

 					fbsSession->SendCommand(EFbsMessUserMarkEnd);

 					}

 				else if (err == KErrNone)

 					{

 					fbsSession->SendCommand(EFbsMessUserMarkEnd);

 					break;

 					}

 				}

 			iProfiler->MarkResultSetL();

 				fbsCompressed->Reset();

 			} // rpt loop

 		CleanupStack::PopAndDestroy( fbsCompressed );

 		//Logs the time taken to load the bmp file	

 		iProfiler->ResultsAnalysis(aTestCaseName, 0, 0, 0, KRepeatTestCount);

 		}

 	}

 #endif

 /**

 @SYMTestCaseID

 GRAPHICS-UI-BENCH-0076

 @SYMDEF DEF105392

 @SYMTestCaseDesc

 Tests the performance of GetScanLine function for various display modes.

 Also it tests the performance of various GetScanLineColorXX

 (where XX => display mode, for eg. GetScanLineColor64K)

 and TScanLineDecompressor::CopyPixel functions.

 To test the performance of GetScanLineColorXX and other functions for any display mode, it creates

 a bitmap of that display mode and passes it to CTOptimisedBmp::ScanlineTestL function

 along with the display mode which was used for creating it and

 the other display mode which will be used for reading this bitmap while logging the performance.

 @SYMTestActions

 Compare the results over time, and before and after changes to GetScanLine and CopyPixel code.

 @SYMTestExpectedResults

 Test should pass and display average time

 */

 void CTOptimisedBmp::GetScanLineTestL()

 	{

 	CFbsBitmap bmp;

 	const TSize bmpSize(22,5);

 	_LIT(KTestCaseName,"GetScanLine");

 	const TDisplayMode KTestDisplayModes[] = {EColor4K, EColor64K, EColor16M, EColor16MU, EColor16MA, EColor16MAP};

 	const TInt KTestDisplayModeCnt = sizeof(KTestDisplayModes)/sizeof(TDisplayMode);

 	for(TInt srcDispModeIndex = 0; srcDispModeIndex < KTestDisplayModeCnt; srcDispModeIndex++)

 		{

 		TDisplayMode displayMode = KTestDisplayModes[srcDispModeIndex];

 		User::LeaveIfError(bmp.Create(bmpSize,displayMode));

 		StripeBitmap(bmp);

 		bmp.Compress();

 		for(TInt destDispModeIndex = 0; destDispModeIndex < KTestDisplayModeCnt; destDispModeIndex++)

 			{

 			ScanlineTestL(bmp,displayMode,KTestDisplayModes[destDispModeIndex],KTestCaseName);

 			}

 		bmp.Reset();

 		}

 	}

 /**

 It reads a bitmap (aBitmap) of given display mode (aSrcDisplayMode) as a bitmap of

 another display mode (aDestDisplayMode) and logs the performance for it.

 @param aBitmap a bitmap

 @param aSrcDisplayMode The used display mode when bitmap was created. 

 						It is passed in this function just for logging purpose.

 @param aDestDisplayMode The display mode used for reading the bitmap aBitmap

 @param aTestCaseName The name of the test case

 */

 void CTOptimisedBmp::ScanlineTestL(const CFbsBitmap& aBitmap, TDisplayMode aSrcDisplayMode, TDisplayMode aDestDisplayMode, const TDesC& aTestCaseName)

 	{

 	const TSize bmpSize(aBitmap.SizeInPixels());

 	TInt byteWidth = CFbsBitmap::ScanLineLength(bmpSize.iWidth,aDestDisplayMode);

 	TUint8* buffer = new (ELeave) TUint8[byteWidth];

 	CleanupStack::PushL(buffer);

 	TPtr8 scanLine(buffer,byteWidth,byteWidth);

 	iProfiler->InitResults();

 	for(TInt count=0;count<KRepeatTestCount;count++)

 		{

 		// For performance testing on same scanline, read the few pixels from bitmap.

 		// And for a comprehensive testing, vary the start pixel and the number of pixels to get.

 		for(TInt xStart = 0; xStart <= 11; xStart++)

 			{

 			for (TInt xLength = 1; xLength <= 11; xLength++)

 				{

 				TInt xEnd = xStart + xLength;

 				if (xEnd <= bmpSize.iWidth)

 					{

 					aBitmap.GetScanLine(scanLine,TPoint(xStart,0),xLength,aDestDisplayMode);

 					}

 				}

 			}

 		// Test the performance of reading different scanlines.

 		for(TInt yy = 0; yy < bmpSize.iHeight; yy++)

 			{

 			aBitmap.GetScanLine(scanLine,TPoint(0,yy),bmpSize.iWidth,aDestDisplayMode);

 			}

 		iProfiler->MarkResultSetL();

 		}

 	iProfiler->ResultsAnalysis(aTestCaseName, 0, aSrcDisplayMode, aDestDisplayMode, KRepeatTestCount);

 	CleanupStack::PopAndDestroy(buffer);

 	}

 /**

 Logs the time taken to load the bitmap file identified by the filename and file id.

 @param aFileName the mbm or rsc file that is to be loaded

 @param aId The bitmap identifier

 @param aShareIfLoaded Specifies whether or not the loaded bitmap will be made available for sharing between font and bitmap server clients.

 @param aTestCaseName the name of the test case

 */

 void CTOptimisedBmp::ResourceBitmapLoadL(const TDesC& aFileName, TInt32 aId, TBool aShareIfLoaded, const TDesC& aTestCaseName)

 	{

 	TInt err = KErrNone;

 	iProfiler->InitResults(); //initializes the timer

 	for (TInt rpt = 0; rpt < KRepeatTestCount; ++rpt)

 		{

 		CFbsBitmap* resourceBitmap = new (ELeave) CFbsBitmap;

 		CleanupStack::PushL(resourceBitmap);

 		iProfiler->StartTimer();

 		//Load mbm or rsc file identified by aFileName

 		err = resourceBitmap->Load( aFileName, aId, aShareIfLoaded ); //when there is no memory constraints

 		iProfiler->MarkResultSetL();

 		TEST(err == KErrNone);

 		resourceBitmap->Reset();

 		CleanupStack::PopAndDestroy( resourceBitmap );

 		}

 	//Logs the time taken to load the bmp file

 	iProfiler->ResultsAnalysis(aTestCaseName, 0, 0, 0, KRepeatTestCount);

 	}