// 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 - Internal Symbian test code

 */

 #include "textendedbitmapcommon.h"

 #include "textendedbitmap.h"

 #include "examplerasterizer.h"

 #include <graphics/fbsrasterizerclearcache.h>

 #include <s32mem.h>

 const TUint8 KRepeatTestData[] = "(This pattern is 32 bytes long!)";

 const TInt KRepeatTestDataSize = 32;

 const TInt KLargeDataSize = 0x8000 * KRepeatTestDataSize;

 CTExtendedBitmap::CTExtendedBitmap(CTestStep* aStep):

 	CTFbsBase(aStep, ETrue)

 	{

 	}

 CTExtendedBitmap::~CTExtendedBitmap()

 	{

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

 	User::Free(iLargeData);

 	}

 void CTExtendedBitmap::ConstructL()

 	{	

 	TRAPD(err, iLargeData = static_cast<TUint8*>(User::AllocL(KLargeDataSize)));

 	if (err != KErrNone)

 		{

 		INFO_PRINTF3(_L("Error allocating large data buffer (size %d) in CTExtendedBitmap::ConstructL(), %d"), KLargeDataSize, err);

 		User::Leave(err);

 		}

 	for (TInt i = 0; i < KLargeDataSize; i += KRepeatTestDataSize)

 		{

 		Mem::Copy(PtrAdd(iLargeData, i), KRepeatTestData, KRepeatTestDataSize);

 		}

 	// Save a pointer to the example rasterizer's MFbsRasterizerClearCache interface

 	if (CFbsRasterizer* rasterizer = CFbsBitmap::Rasterizer())

 		{		

 		err = rasterizer->GetInterface(TUid::Uid(KUidFbsRasterizerClearCache), (TAny*&)iRasterizerClearCache);

 		if (err != KErrNone) 

 			{

 			WARN_PRINTF1(_L("Failed to get a MFbsRasterizerClearCache interface for the current rasterizer, tests will panic during OOM testing due to the rasterizer cache not being cleared"));

 			}

 		}

 	}

 void CTExtendedBitmap::RunFbsTestL(TInt aCurTestCase)

     {    

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

 	switch(aCurTestCase)

 		{

 	case 1:

 		((CTExtendedBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0001"));

 		CreateExtendedBitmapL();

 		break;

 	case 2:

 		((CTExtendedBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0002"));

 		CreateLargeExtendedBitmapL();

 		break;

 	case 3:

 		((CTExtendedBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0003"));

 		CreateUsingInitializerL();

 		break;

 	case 4:

 		((CTExtendedBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0004"));

 		ScanLineL(EFalse);

 		break;

 	case 5:

 		((CTExtendedBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0004"));

 		ScanLineL(ETrue);

 		break;

 	case 6:

 		((CTExtendedBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0040"));

 		TestGetPixelL(EFalse);

 		break;

 	case 7:

 		((CTExtendedBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0040"));

 		TestGetPixelL(ETrue);

 		break;

 	case 8:

 		((CTExtendedBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0042"));

 		TestGetVerticalScanLineL(EFalse);

 		break;

 	case 9:

 		((CTExtendedBitmapStep*)iStep)->SetTestStepID(_L("GRAPHICS-FBSERV-EXTENDEDBITMAP-0042"));

 		TestGetVerticalScanLineL(ETrue);

 		// Fall through as last test case

 	default:

 		SetLastTestCase();		

 		break;

 		}

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

     }

 /**

 	@SYMTestCaseID

 	GRAPHICS-FBSERV-EXTENDEDBITMAP-0001

 	@SYMTestCaseDesc

 	Create an extended bitmap and retrieve data

 	@SYMPREQ 

 	PREQ2096

 	@SYMREQ

 	REQ10847

 	REQ10849

 	REQ10850

 	REQ10851

 	REQ10852

 	REQ10853

 	REQ10854

 	REQ10855

 	@SYMTestPriority  

 	High

 	@SYMTestStatus 

 	Implemented

 	@SYMTestActions

 	Creates an extended bitmap using test data and test Uid;

 	Retrieves and validates the data size, data and Uid.

 	@SYMTestExpectedResults

 	Extended bitmap created and information correctly retrieved.

 */

 void CTExtendedBitmap::CreateExtendedBitmapL()

 	{

 	INFO_PRINTF1(_L("Create an extended bitmap"));

 	const TUint8 KTestData[]		= "Extended bitmap test data 123456";

 	const TInt KTestDataSize		= sizeof(KTestData);

 	const TSize KSizeInPixels 		= TSize(50,50);

 	const TDisplayMode KDisplayMode	= EColor64K;

 	CFbsBitmap* bmp = new(ELeave)CFbsBitmap;

 	CleanupStack::PushL(bmp);

 	TInt res = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidTestExtendedBitmap, KTestData, KTestDataSize);

 	TESTNOERRORL(res);

 	bmp->BeginDataAccess();

 	TInt returnedDataSize = bmp->DataSize();

 	TESTEQUALL(KTestDataSize, returnedDataSize);

 	INFO_PRINTF3(_L("Test data size on creation: %i. Test data size returned: %i"), KTestDataSize, returnedDataSize);

 	const TUint8* returnedDataAddress = reinterpret_cast<TUint8*>(bmp->DataAddress());

 	res = Mem::Compare(returnedDataAddress,returnedDataSize, KTestData, KTestDataSize);

 	TESTEQUALL(0, res);

 	TUid returnedUid = bmp->ExtendedBitmapType();

 	TESTEQUALL(KUidTestExtendedBitmap, returnedUid);

 	bmp->EndDataAccess(ETrue);

 	CleanupStack::PopAndDestroy(bmp);

 	}

 /**

 	@SYMTestCaseID

 	GRAPHICS-FBSERV-EXTENDEDBITMAP-0002

 	@SYMTestCaseDesc

 	Create an extended bitmap with data sized 1MB

 	@SYMPREQ 

 	PREQ2096

 	@SYMREQ

 	REQ10847

 	REQ10863

 	@SYMTestPriority  

 	High

 	@SYMTestStatus 

 	Implemented

 	@SYMTestActions

 	Create an extended bitmap with a buffer that is 1MB.

 	@SYMTestExpectedResults

 	No errors or panics should occur.

 */

 void CTExtendedBitmap::CreateLargeExtendedBitmapL()

 	{

 	INFO_PRINTF1(_L("Create an extended bitmap with data size 1MB"));	

 	const TSize KSizeInPixels = TSize(50,50);

 	const TDisplayMode KDisplayMode	= EColor64K;	

 	CFbsBitmap* bmp = new(ELeave)CFbsBitmap;

 	CleanupStack::PushL(bmp);

 	TInt res = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidTestExtendedBitmap, iLargeData, KLargeDataSize);

 	TESTNOERRORL(res);

 	bmp->BeginDataAccess();

 	TInt returnedDataSize = bmp->DataSize();

 	TESTEQUALL(KLargeDataSize, returnedDataSize);

 	INFO_PRINTF3(_L("Test data size on creation: %i. Test data size returned: %i"), KLargeDataSize, returnedDataSize);

 	const TUint8* returnedDataAddress = reinterpret_cast<TUint8*>(bmp->DataAddress());

 	res = Mem::Compare(returnedDataAddress, returnedDataSize, iLargeData, KLargeDataSize);

 	TESTEQUALL(0, res);

 	TUid returnedUid = bmp->ExtendedBitmapType();

 	TESTEQUALL(KUidTestExtendedBitmap, returnedUid);

 	bmp->EndDataAccess(ETrue);

 	CleanupStack::PopAndDestroy(bmp);

 	}

 /**

 	@SYMTestCaseID

 	GRAPHICS-FBSERV-EXTENDEDBITMAP-0003

 	@SYMTestCaseDesc

 	Create an extended bitmap using an MFbsExtendedBitmapInitializer

 	@SYMPREQ 

 	PREQ2096

 	@SYMREQ

 	@SYMTestPriority  

 	High

 	@SYMTestStatus 

 	Implemented

 	@SYMTestActions

 	Create an extended bitmap using an MFbsExtendedBitmapInitializer, with a buffer that is 1MB.

 	@SYMTestExpectedResults

 	Extended bitmap created and information correctly retrieved. 

 */

 void CTExtendedBitmap::CreateUsingInitializerL()

 	{

 	INFO_PRINTF1(_L("Create an extended bitmap using an MFbsExtendedBitmapInitializer"));	

 	const TSize KSizeInPixels = TSize(50,50);

 	const TDisplayMode KDisplayMode	= EColor64K;	

 	CFbsBitmap* bmp = new(ELeave)CFbsBitmap;

 	CleanupStack::PushL(bmp);

 	CTestExtendedBitmapInitializer* initializer = new(ELeave) CTestExtendedBitmapInitializer(iLargeData, KLargeDataSize);

 	CleanupStack::PushL(initializer);

 	TInt res = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidTestExtendedBitmap, KLargeDataSize, *initializer);

 	CleanupStack::PopAndDestroy(initializer);

 	TESTNOERRORL(res);

 	bmp->BeginDataAccess();

 	TInt returnedDataSize = bmp->DataSize();

 	TESTEQUALL(KLargeDataSize, returnedDataSize);

 	INFO_PRINTF3(_L("Test data size on creation: %i. Test data size returned: %i"), KLargeDataSize, returnedDataSize);

 	const TUint8* returnedDataAddress = reinterpret_cast<TUint8*>(bmp->DataAddress());

 	res = Mem::Compare(returnedDataAddress, returnedDataSize, iLargeData, KLargeDataSize);

 	TESTEQUALL(0, res);

 	TUid returnedUid = bmp->ExtendedBitmapType();

 	TESTEQUALL(KUidTestExtendedBitmap, returnedUid);

 	bmp->EndDataAccess(ETrue);

 	CleanupStack::PopAndDestroy(bmp);

 	}

 /**

 	@SYMTestCaseID

 	GRAPHICS-FBSERV-EXTENDEDBITMAP-0004

 	@SYMTestCaseDesc

 	Create an extended bitmap and retrieve scanline

 	@SYMPREQ 

 	PREQ2096

 	@SYMREQ

 	REQ10847

 	@SYMTestPriority  

 	High

 	@SYMTestStatus 

 	Implemented

 	@SYMTestActions

 	Creates an extended bitmap using data compatible with the

 	example rasterizer.

 	If (aUseDuplicateBitmap == ETrue) use CFbsBitmap::Duplicate()

 	to create a duplicate of the extended bitmap just created and 

 	complete the test using the duplicate extended bitmap. 

 	Get a scanline using CFbsBitmap::GetScanLine() and check if

 	it is correct, depending on the presence of the rasterizer.

 	@SYMTestExpectedResults

 	Extended bitmap created and scanline correctly retrieved.

 */

 void CTExtendedBitmap::ScanLineL(TBool aUseDuplicateBitmap)

 	{

 	INFO_PRINTF1(_L("Get a scanline from an extended bitmap"));	

 	const TRgb KColors[] 	= {TRgb(0,0,0), TRgb(255,0,0), TRgb(255,255,0)};

 	// Small size needed for this test O(x^2 * y) iterations run every time

 	const TSize KSizeInPixels 		= TSize(8,5); 

 	const TDisplayMode KDisplayMode	= EColor64K;

 	const TUint8 horizontalStripes = 1;

 	// Check to see if we have an example bitmap rasterizer available for this test run	

 	iRasterizerAvailable = (CFbsBitmap::Rasterizer() != NULL);

 	if (iRasterizerAvailable)

 		{

 		INFO_PRINTF1(_L("Testing WITH the example rasterizer - Rasterizer Available"));	

 		}

 	else

 		{

 		INFO_PRINTF1(_L("Testing WITHOUT the example rasterizer - Rasterizer NOT Available"));

 		}

 	CleanupStack::PushL(TCleanupItem(ClearRasterizerCache, iRasterizerClearCache));

 	TInt dataSize = sizeof(KColors)+sizeof(horizontalStripes); // estimate the data size

 	TUint8* data = new(ELeave) TUint8[dataSize];

 	CleanupStack::PushL(data);	

 	// Write the colours to be used in the extended bitmap to the data

 	RMemWriteStream ws;

 	ws.Open(data, dataSize);

 	CleanupClosePushL(ws);

 	ws << KColors[0] << KColors[1] << KColors[2] << horizontalStripes;

 	dataSize = ws.Sink()->TellL(MStreamBuf::EWrite).Offset(); // get the actual size written

 	CleanupStack::PopAndDestroy(1, &ws);

 	// Create the extended bitmap to be used a a brush

 	CFbsBitmap* bmp = new(ELeave) CFbsBitmap;

 	CleanupStack::PushL(bmp);

 	TInt res = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidExampleExtendedBitmap, data, dataSize);

 	TESTNOERRORL(res);

 	if (aUseDuplicateBitmap)

 		{

 		INFO_PRINTF1(_L("Testing using a duplicated extended bitmap"));

 		CFbsBitmap* duplicateBmp = new(ELeave) CFbsBitmap;

 		CleanupStack::PushL(duplicateBmp);

 		res = duplicateBmp->Duplicate(bmp->Handle());

 		TESTNOERRORL(res);

 		bmp = duplicateBmp;

 		}

 	TInt byteWidth = CFbsBitmap::ScanLineLength(KSizeInPixels.iWidth, KDisplayMode);

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

 	CleanupArrayDeletePushL(buffer);

 	const TUint8 KCheckValue = 0x69; // Pixel value used as guard at the end of the buffer used

 	buffer[byteWidth] = KCheckValue; 

 	TPtr8 scanLine(buffer,byteWidth,byteWidth);

 	TInt x, y;

 	TInt firstStripe, lastStripe;

 	TInt* s;

 	if(horizontalStripes)

 		{

 		firstStripe = KSizeInPixels.iHeight/3;

 		lastStripe = KSizeInPixels.iHeight - firstStripe;

 		s = &y;

 		}

 	else

 		{

 		firstStripe = KSizeInPixels.iWidth/3;

 		lastStripe = KSizeInPixels.iWidth - firstStripe;

 		s = &x;

 		}

 	for(y = 0; y < KSizeInPixels.iHeight; ++y)

 		{

 		for(TInt length = 1; length <= KSizeInPixels.iWidth; ++length)

 			{

 			for(TInt pos = KSizeInPixels.iWidth - length; pos >= 0; --pos)

 				{

 				bmp->GetScanLine(scanLine, TPoint(pos,y), length, KDisplayMode);

 				for(x = pos + length - 1; x >= pos; --x)

 					{

 					TRgb bufferColor = ExtractRgb(buffer, x-pos, KDisplayMode);

 					if(!iRasterizerAvailable)

 						{

 						TESTCOLOREQUALL(bufferColor, KRgbWhite);

 						}

 					else if (*s < firstStripe)

 						{

 						// First stripe

 						TESTCOLOREQUALL(bufferColor, KColors[0]);

 						}

 					else if (*s >= lastStripe)

 						{

 						// Last stripe

 						TESTCOLOREQUALL(bufferColor, KColors[2]);

 						}

 					else

 						{

 						// Middle stripe

 						TESTCOLOREQUALL(bufferColor, KColors[1]);

 						}							

 					}

 				}

 			}

 		}

 	// Check that the guard byte is still intact now that the tests have been run

 	TEST(buffer[byteWidth] == KCheckValue); 

 	if (aUseDuplicateBitmap)

 		{

 		CleanupStack::PopAndDestroy(1);

 		}

 	CleanupStack::PopAndDestroy(4);

 	}

 /**

 	@SYMTestCaseID

 	GRAPHICS-FBSERV-EXTENDEDBITMAP-0040

 	@SYMTestCaseDesc

 	Create an extended bitmap and retrieve pixels

 	@SYMPREQ 

 	CR1804

 	@SYMREQ

 	REQ10858

 	@SYMTestPriority  

 	High

 	@SYMTestStatus 

 	Implemented

 	@SYMTestActions

 	Creates an extended bitmap using data compatible with the

 	example rasterizer.

 	If (aUseDuplicateBitmap == ETrue) use CFbsBitmap::Duplicate()

 	to create a duplicate of the extended bitmap just created and 

 	complete the test using the duplicate extended bitmap. 

 	Get pixel values using CFbsBitmap::GetPixel() and check if

 	they are correct, depending on the presence of the rasterizer.

 	@SYMTestExpectedResults

 	Extended bitmap created and pixels correctly retrieved.

 */

 void CTExtendedBitmap::TestGetPixelL(TBool aUseDuplicateBitmap)

 	{

 	INFO_PRINTF1(_L("Get pixel values from an extended bitmap"));	

 	const TRgb KColors[] 	= {TRgb(0,0,0), TRgb(255,0,0), TRgb(255,255,0)};

 	const TSize KSizeInPixels 		= TSize(8,5); 

 	const TDisplayMode KDisplayMode	= EColor64K;

 	const TUint8 KHorizontalStripes = 1;

 	// Check to see if we have an example bitmap rasterizer available for this test run	

 	iRasterizerAvailable = (CFbsBitmap::Rasterizer() != NULL);

 	if (iRasterizerAvailable)

 		{

 		INFO_PRINTF1(_L("Testing WITH the example rasterizer - Rasterizer Available"));	

 		}

 	else

 		{

 		INFO_PRINTF1(_L("Testing WITHOUT the example rasterizer - Rasterizer NOT Available"));

 		}

 	CleanupStack::PushL(TCleanupItem(ClearRasterizerCache, iRasterizerClearCache));

 	TInt dataSize = sizeof(KColors)+sizeof(KHorizontalStripes); // estimate the data size

 	TUint8* data = new(ELeave) TUint8[dataSize];

 	CleanupStack::PushL(data);	

 	// Write the colours to be used in the extended bitmap to the data

 	RMemWriteStream ws;

 	ws.Open(data, dataSize);

 	CleanupClosePushL(ws);

 	ws << KColors[0] << KColors[1] << KColors[2] << KHorizontalStripes;

 	dataSize = ws.Sink()->TellL(MStreamBuf::EWrite).Offset(); // get the actual size written

 	CleanupStack::PopAndDestroy(1, &ws);

 	// Create the extended bitmap

 	CFbsBitmap* bmp = new(ELeave) CFbsBitmap;

 	CleanupStack::PushL(bmp);

 	TInt res = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidExampleExtendedBitmap, data, dataSize);

 	TESTNOERRORL(res);

 	if (aUseDuplicateBitmap)

 		{

 		INFO_PRINTF1(_L("Testing using a duplicated extended bitmap"));

 		CFbsBitmap* duplicateBmp = new(ELeave) CFbsBitmap;

 		CleanupStack::PushL(duplicateBmp);

 		res = duplicateBmp->Duplicate(bmp->Handle());

 		TESTNOERRORL(res);

 		bmp = duplicateBmp;

 		}

 	TInt firstStripe = KSizeInPixels.iHeight/3;

 	TInt lastStripe = KSizeInPixels.iHeight - firstStripe;

 	TRgb color;

 	for(TInt y = 0; y < KSizeInPixels.iHeight; ++y)

 		{

 		for(TInt x = 0; x < KSizeInPixels.iWidth; ++x)

 			{

 			bmp->GetPixel(color, TPoint(x,y));

 			if(!iRasterizerAvailable)

 				{

 				TESTCOLOREQUALL(color, KRgbWhite);

 				}

 			else if (y < firstStripe)

 				{

 				// First stripe

 				TESTCOLOREQUALL(color, KColors[0]);

 				}

 			else if (y >= lastStripe)

 				{

 				// Last stripe

 				TESTCOLOREQUALL(color, KColors[2]);

 				}

 			else

 				{

 				// Middle stripe

 				TESTCOLOREQUALL(color, KColors[1]);

 				}							

 			}

 		}

 	if (aUseDuplicateBitmap)

 		{

 		CleanupStack::PopAndDestroy(1);

 		}

 	CleanupStack::PopAndDestroy(3);

 	}

 /**

 @SYMTestCaseID

 	GRAPHICS-FBSERV-EXTENDEDBITMAP-0042

 @SYMTestCaseDesc

 	Create an extended bitmap and retrieve vertical scanline

 @SYMPREQ 

 	DEF141346

 @SYMTestPriority  

 	High

 @SYMTestStatus 

 	Implemented

 @SYMTestActions

 	Create an extended bitmap using data compatible with the

 	example rasterizer.

 	If (aUseDuplicateBitmap == ETrue) use CFbsBitmap::Duplicate()

 	to create a duplicate of the extended bitmap just created and 

 	complete the test using the duplicate extended bitmap. 

 	Get a vertical scanline using CFbsBitmap::GetVerticalScanLine() and check

 	if it is correct, depending on the presence of the rasterizer.

 @SYMTestExpectedResults

 	Extended bitmap created and scanline correctly retrieved.

 */

 void CTExtendedBitmap::TestGetVerticalScanLineL(TBool aUseDuplicateBitmap)

 	{

 	INFO_PRINTF1(_L("Get a vertical scanline from an extended bitmap"));	

 		const TRgb KColors[] 	= {TRgb(0,0,0), TRgb(255,0,0), TRgb(255,255,0)};

 		const TSize KSizeInPixels 		= TSize(5,8); 

 		const TDisplayMode KDisplayMode	= EColor64K;

 		const TUint8 KHorizontalStripes = 1;

 		// Check to see if we have an example bitmap rasterizer available for this test run	

 		iRasterizerAvailable = (CFbsBitmap::Rasterizer() != NULL);

 		if (iRasterizerAvailable)

 			{

 			INFO_PRINTF1(_L("Testing WITH the example rasterizer - Rasterizer Available"));	

 			}

 		else

 			{

 			INFO_PRINTF1(_L("Testing WITHOUT the example rasterizer - Rasterizer NOT Available"));

 			}

 		CleanupStack::PushL(TCleanupItem(ClearRasterizerCache, iRasterizerClearCache));

 		TInt dataSize = sizeof(KColors)+sizeof(KHorizontalStripes); // estimate the data size

 		TUint8* data = new(ELeave) TUint8[dataSize];

 		CleanupStack::PushL(data);	

 		// Write the colours to be used in the extended bitmap to the data

 		RMemWriteStream ws;

 		ws.Open(data, dataSize);

 		CleanupClosePushL(ws);

 		ws << KColors[0] << KColors[1] << KColors[2] << KHorizontalStripes;

 		dataSize = ws.Sink()->TellL(MStreamBuf::EWrite).Offset(); // get the actual size written

 		CleanupStack::PopAndDestroy(1, &ws);

 		// Create the extended bitmap

 		CFbsBitmap* bmp = new(ELeave) CFbsBitmap;

 		CleanupStack::PushL(bmp);

 		TInt res = bmp->CreateExtendedBitmap(KSizeInPixels, KDisplayMode, KUidExampleExtendedBitmap, data, dataSize);

 		TESTNOERRORL(res);

 		if (aUseDuplicateBitmap)

 			{

 			INFO_PRINTF1(_L("Testing using a duplicated extended bitmap"));

 			CFbsBitmap* duplicateBmp = new(ELeave) CFbsBitmap;

 			CleanupStack::PushL(duplicateBmp);

 			res = duplicateBmp->Duplicate(bmp->Handle());

 			TESTNOERRORL(res);

 			bmp = duplicateBmp;

 			}

 		TInt byteWidth = CFbsBitmap::ScanLineLength(KSizeInPixels.iHeight, KDisplayMode);

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

 		CleanupArrayDeletePushL(buffer);

 		const TUint8 KCheckValue = 0x69; // Pixel value used as guard at the end of the buffer used

 		buffer[byteWidth] = KCheckValue; 

 		TPtr8 scanLine(buffer,byteWidth,byteWidth);

 		TInt firstStripe = KSizeInPixels.iHeight/3;

 		TInt lastStripe = KSizeInPixels.iHeight - firstStripe;

 		TRgb color;

 		for(TInt x = 0; x < KSizeInPixels.iWidth; ++x)

 			{

 			bmp->GetVerticalScanLine(scanLine, x, KDisplayMode);

 			for(TInt y = 0; y < KSizeInPixels.iHeight; ++y)

 				{

 				TRgb bufferColor = ExtractRgb(buffer, y, KDisplayMode);

 				if(!iRasterizerAvailable)

 					{

 					TESTCOLOREQUALL(bufferColor, KRgbWhite);

 					}

 				else if (y < firstStripe)

 					{

 					// First stripe

 					TESTCOLOREQUALL(bufferColor, KColors[0]);

 					}

 				else if (y >= lastStripe)

 					{

 					// Last stripe

 					TESTCOLOREQUALL(bufferColor, KColors[2]);

 					}

 				else

 					{

 					// Middle stripe

 					TESTCOLOREQUALL(bufferColor, KColors[1]);

 					}							

 				}

 			}

 		// Check that the guard byte is still intact now that the tests have been run

 		TEST(buffer[byteWidth] == KCheckValue); 

 		if (aUseDuplicateBitmap)

 			{

 			CleanupStack::PopAndDestroy(1);

 			}

 		CleanupStack::PopAndDestroy(4);

 	}

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

 __CONSTRUCT_STEP__(ExtendedBitmap)

 /** Method to be used with a TCleanupItem for clearing the extended bitmap rasterizer cache

 from the cleanup stack. Calls the MExampleRasterizerClearCache::ClearCache() method on the

 passed CFbsRasterizer object if the MExampleRasterizerClearCache extension interface is available

 for that object.

 @param aPtr A pointer to the current CFbsRasterizer object, or NULL if no rasterizer

 object is available.

  */

 void CTExtendedBitmap::ClearRasterizerCache(TAny* aPtr)

 	{	

 	if (aPtr)

 		{

 		static_cast<MFbsRasterizerClearCache*>(aPtr)->ClearCache();

 		}

 	}