// Copyright (c) 2007-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:

 //

 #include "tdirectgdiresource.h"

 #include <s32mem.h>

 #include <graphics/directgditypes.h>

 #include <graphics/directgdicontext.h>

 _LIT(KClip, "Clip");

 _LIT(KWriteAlpha, "WriteAlpha");

 const DirectGdi::TGraphicsRotation TestRot[] =

   	{

   	DirectGdi::EGraphicsRotationNone,

   	DirectGdi::EGraphicsRotation90,

   	DirectGdi::EGraphicsRotation180,

   	DirectGdi::EGraphicsRotation270

   	};

 CTDirectGdiResource::CTDirectGdiResource() :

 	CActive(CActive::EPriorityStandard),

 	iCurrentState(EStartup)

 	{

 	SetTestStepName(KTDirectGdiResourceStep);

 	}

 CTDirectGdiResource::~CTDirectGdiResource()

 	{

 	Cancel();

 	DestroyCommonResource();

 	}

 /**

 Writes output image to file. Append dest + src pixel format to the given file name.

 */

 void CTDirectGdiResource::SaveOutput(const TDesC& aName)

 	{

 	TBuf<KFileNameLength> postfix;

 	postfix.Append(KSourceString);

 	postfix.Append(KSeparator);

 	postfix.Append(TDisplayModeMapping::ConvertPixelFormatToShortPixelFormatString(

 				iTestParams.iSourceResourcePixelFormat));

 	TESTNOERROR(WriteTargetOutput(iTestParams, aName, &postfix));

 	}

 /**

 Check to see if the current source resource pixel format contains alpha.

 @return ETrue if the current source resource pixel format contais alpha, EFalse otherwise.

 */

 TBool CTDirectGdiResource::SourceResourceHasAlpha() const

 	{

 	return iTestParams.iSourceResourcePixelFormat==EUidPixelFormatARGB_8888 ||

 		iTestParams.iSourceResourcePixelFormat==EUidPixelFormatARGB_8888_PRE;

 	}

 /**

 Check to see if tests should run that only need to be run with one pixel format,

 for example tests to check that clipping regions are working correctly. Tests that are

 only run once are run when the target pixel format and the source pixel format are

 both EUidPixelFormatARGB_8888_PRE.

 @return ETrue if both the current source and target pixel formats are EUidPixelFormatARGB_8888_PRE.

 */

 TBool CTDirectGdiResource::OneTimeTestEnabled() const

 	{

 	return iTestParams.iTargetPixelFormat==iTestParams.iSourceResourcePixelFormat &&

 		iTestParams.iTargetPixelFormat==EUidPixelFormatARGB_8888_PRE;

 	}

 /**

 Draws an image with 4 different orientation using given position as the

 origin e.g

 A B

  o

 D C

 */

 void CTDirectGdiResource::DrawTestPattern1(const TPoint& aPos)

 	{

 	const TInt w = iImgSz.iWidth;

 	const TInt h = iImgSz.iHeight;

 	iGc->DrawResource(TPoint(aPos.iX-w, aPos.iY-h), iImgSrc, DirectGdi::EGraphicsRotationNone);

 	iGc->DrawResource(TPoint(aPos.iX, aPos.iY-w), iImgSrc, DirectGdi::EGraphicsRotation90);

 	iGc->DrawResource(aPos, iImgSrc, DirectGdi::EGraphicsRotation180);

 	iGc->DrawResource(TPoint(aPos.iX-h, aPos.iY), iImgSrc, DirectGdi::EGraphicsRotation270);

 	}

 /**

 Draws two drawables to fit dest rect in the following pattern:

 AB

 */

 void CTDirectGdiResource::DrawTestPattern1(const TRect& aDestRect,

 			const TDrawableSourceAndEquivRotatedBmps& aDrawable1, const TDrawableSourceAndEquivRotatedBmps& aDrawable2)

 	{

 	const TInt dw = aDestRect.Width();

 	const TInt dh = aDestRect.Height();

 	const TInt xu = dw/2;

 	const TInt yu = dh;

 	iGc->DrawResource(TRect(aDestRect.iTl, TSize(xu, yu)), aDrawable1, KNullDesC8);

 	iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX+xu, aDestRect.iTl.iY), TSize(xu, yu)),

 			aDrawable2, KNullDesC8);

 	}

 /**

 Draws two drawables to fit dest rect in the following pattern:

 A

 B

 */

 void CTDirectGdiResource::DrawTestPattern2(const TRect& aDestRect,

 			const TDrawableSourceAndEquivRotatedBmps& aDrawable1, const TDrawableSourceAndEquivRotatedBmps& aDrawable2)

 	{

 	const TInt dw = aDestRect.Width();

 	const TInt dh = aDestRect.Height();

 	const TInt xu = dw;

 	const TInt yu = dh/2;

 	iGc->DrawResource(TRect(aDestRect.iTl, TSize(xu, yu)), aDrawable1, KNullDesC8);

 	iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX, aDestRect.iTl.iY+yu), TSize(xu, yu)),

 			aDrawable2, KNullDesC8);

 	}

 /**

 Draws image rotated to fit dest rect in the following pattern:

 AB

 CC

 DD

 */

 void CTDirectGdiResource::DrawTestPattern1(const TRect& aDestRect, const TRect* aSrcRect)

 	{

 	const TInt dw = aDestRect.Width();

 	const TInt dh = aDestRect.Height();

 	const TInt xu = dw/2;

 	const TInt yu = dh/5;

 	if (aSrcRect)

 		{

 		// use DrawResource(destRect, img, srcRect, rot) API

 		iGc->DrawResource(TRect(aDestRect.iTl, TSize(xu, yu)), iImgSrc, *aSrcRect, DirectGdi::EGraphicsRotationNone);

 		iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX+xu, aDestRect.iTl.iY), TSize(xu, yu)), iImgSrc,

 				*aSrcRect, DirectGdi::EGraphicsRotation180);

 		iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX, aDestRect.iTl.iY+yu), TSize(dw, 2*yu)), iImgSrc,

 				*aSrcRect, DirectGdi::EGraphicsRotationNone);

 		iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX, aDestRect.iTl.iY+3*yu), TSize(dw, 2*yu)), iImgSrc,

 				*aSrcRect, DirectGdi::EGraphicsRotation180);

 		}

 	else

 		{

 		// use DrawResource(destRect, img, rot) API

 		iGc->DrawResource(TRect(aDestRect.iTl, TSize(xu, yu)), iImgSrc, DirectGdi::EGraphicsRotationNone);

 		iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX+xu, aDestRect.iTl.iY), TSize(xu, yu)), iImgSrc,

 				DirectGdi::EGraphicsRotation180);

 		iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX, aDestRect.iTl.iY+yu), TSize(dw, 2*yu)), iImgSrc,

 				DirectGdi::EGraphicsRotationNone);

 		iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX, aDestRect.iTl.iY+3*yu), TSize(dw, 2*yu)), iImgSrc,

 				DirectGdi::EGraphicsRotation180);

 		}

 	}

 /**

 Draws image rotated to fit dest rect in the following pattern:

 ACD

 BCD

 */

 void CTDirectGdiResource::DrawTestPattern2(const TRect& aDestRect, const TRect* aSrcRect)

 	{

 	const TInt dw = aDestRect.Width();

 	const TInt dh = aDestRect.Height();

 	const TInt xu = dw/5;

 	const TInt yu = dh/2;

 	if (aSrcRect)

 		{

 		// use DrawResource(destRect, img, srcRect, rot) API

 		iGc->DrawResource(TRect(aDestRect.iTl, TSize(xu, yu)), iImgSrc, *aSrcRect, DirectGdi::EGraphicsRotation90);

 		iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX, aDestRect.iTl.iY+yu), TSize(xu, yu)), iImgSrc,

 				*aSrcRect, DirectGdi::EGraphicsRotation270);

 		iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX+xu, aDestRect.iTl.iY), TSize(2*xu, dh)), iImgSrc,

 				*aSrcRect, DirectGdi::EGraphicsRotation90);

 		iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX+3*xu, aDestRect.iTl.iY), TSize(2*xu, dh)), iImgSrc,

 				*aSrcRect, DirectGdi::EGraphicsRotation270);

 		}

 	else

 		{

 		// use DrawResource(destRect, img, rot) API

 		iGc->DrawResource(TRect(aDestRect.iTl, TSize(xu, yu)), iImgSrc, DirectGdi::EGraphicsRotation90);

 		iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX, aDestRect.iTl.iY+yu), TSize(xu, yu)), iImgSrc,

 				DirectGdi::EGraphicsRotation270);

 		iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX+xu, aDestRect.iTl.iY), TSize(2*xu, dh)), iImgSrc,

 				DirectGdi::EGraphicsRotation90);

 		iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX+3*xu, aDestRect.iTl.iY), TSize(2*xu, dh)), iImgSrc,

 				DirectGdi::EGraphicsRotation270);

 		}

 	}

 /**

 Draws image rotated to fit dest rect in the following pattern:

 AB

 CD

 */

 void CTDirectGdiResource::DrawTestPattern3(const TRect& aDestRect, const TRect* aSrcRect)

 	{

 	TInt dw = aDestRect.Width();

 	TInt dh = aDestRect.Height();

 	TInt xu = dw/2;

 	TInt yu = dh/2;

 	if (aSrcRect)

 		{

 		// use DrawResource(destRect, img, srcRect, rot) API

 		iGc->DrawResource(TRect(aDestRect.iTl, TSize(xu, yu)), iImgSrc, *aSrcRect, DirectGdi::EGraphicsRotationNone);

 		iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX+xu, aDestRect.iTl.iY), TSize(xu, yu)), iImgSrc,

 				*aSrcRect, DirectGdi::EGraphicsRotation180);

 		iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX, aDestRect.iTl.iY+yu), TSize(xu, yu)), iImgSrc,

 				*aSrcRect, DirectGdi::EGraphicsRotation90);

 		iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX+xu, aDestRect.iTl.iY+yu), TSize(xu, yu)), iImgSrc,

 				*aSrcRect, DirectGdi::EGraphicsRotation270);

 		}

 	else

 		{

 		// use DrawResource(destRect, img, rot) API

 		iGc->DrawResource(TRect(aDestRect.iTl, TSize(xu, yu)), iImgSrc, DirectGdi::EGraphicsRotationNone);

 		iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX+xu, aDestRect.iTl.iY), TSize(xu, yu)), iImgSrc,

 				DirectGdi::EGraphicsRotation180);

 		iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX, aDestRect.iTl.iY+yu), TSize(xu, yu)), iImgSrc,

 				DirectGdi::EGraphicsRotation90);

 		iGc->DrawResource(TRect(TPoint(aDestRect.iTl.iX+xu, aDestRect.iTl.iY+yu), TSize(xu, yu)), iImgSrc,

 				DirectGdi::EGraphicsRotation270);

 		}

 	}

 /**

 @SYMTestCaseID			

 	GRAPHICS-DIRECTGDI-DRAWRESOURCE-0001

 @SYMTestPriority		

 	Critical

 @SYMPREQ				

 	PREQ39

 @SYMREQ

 	REQ9178 

 	REQ9200 

 	REQ9201 

 	REQ9202 

 	REQ9203 

 	REQ9222 

 	REQ9228 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestStatus			

 	Implemented

 @SYMTestCaseDesc		

 	Draws drawable resources created from RSgDrawable and RSgImage objects.

 @SYMTestActions			

 	Draw drawble resources with the various combination of parameters:

 	-with and without clipping region

 	-drawable from RSgDrawable and RSgImage

 	-in various destination positions and scaling factor

 	-using write or blend

 @SYMTestExpectedResults	

 	Resources are drawn on the given position, scaled to fit the destination

 	rectangle, clipped to current clipping region (if set).

 */

 void CTDirectGdiResource::TestDrawResource_ImageAsDrawableL()

 	{

 	_LIT(KTestName, "DrawResource_ImageAsDrawable");

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestName);

 		}

 	TBuf<KFileNameLength> tag;

 	tag.Append(KTestName);

 	ResetGc();

 	if (iEnableClipRegion)

 		{

 		iGc->SetClippingRegion(iClip);

 		tag.Append(KClip);

 		}

 	if (iUseWriteAlpha)

 		{

 		iGc->SetDrawMode(DirectGdi::EDrawModeWriteAlpha);

 		tag.Append(KWriteAlpha);

 		}

 	DrawTestPattern1(TRect(0,0,100,20), iDwbSrc[0], iDwbSrc[1]);

 	DrawTestPattern2(TRect(0,20,100,100), iDwbSrc[0], iDwbSrc[1]);

 	DrawTestPattern1(TRect(0,100,100,200), iDwbSrc[0], iDwbSrc[1]);

 	DrawTestPattern2(TRect(100,0,200,200), iDwbSrc[0], iDwbSrc[1]);

 	if (iEnableClipRegion)

 		{

 		iGc->ResetClippingRegion();

 		iGc->SetDrawMode(DirectGdi::EDrawModePEN);

 		}

 	SaveOutput(tag);

 	}

 /**

 @SYMTestCaseID			

 	GRAPHICS-DIRECTGDI-DRAWRESOURCE-0002

 @SYMTestPriority		

 	Critical

 @SYMPREQ				

 	PREQ39

 @SYMREQ

 	REQ9178 

 	REQ9200 

 	REQ9201 

 	REQ9202 

 	REQ9203 

 	REQ9222 

 	REQ9228 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestStatus			

 	Implemented

 @SYMTestCaseDesc		

 	Draw an image resource created from RSgImage object.

 @SYMTestActions			

 	Draw an image resource with the various combination of parameters:

 	-with and without clipping region

 	-in various destination positions on/off target

 	-using write or blend

 	-no scaling is performed in this test

 @SYMTestExpectedResults	

 	Resources are drawn on the given position, unscaled, rotated and

 	clipped to current clipping region (if set).

 */

 void CTDirectGdiResource::TestDrawResource_PosL()

 	{

 	_LIT(KTestName, "DrawResource_Pos");

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestName);

 		}

 	TBuf<KFileNameLength> tag;

 	tag.Append(KTestName);

 	ResetGc();

 	if (iEnableClipRegion)

 		{

 		iGc->SetClippingRegion(iClip);

 		tag.Append(KClip);

 		}

 	if (iUseWriteAlpha)

 		{

 		iGc->SetDrawMode(DirectGdi::EDrawModeWriteAlpha);

 		tag.Append(KWriteAlpha);

 		}

 	DrawTestPattern1(TPoint(0,0));

 	DrawTestPattern1(TPoint(100,0));

 	DrawTestPattern1(TPoint(200,0));

 	DrawTestPattern1(TPoint(50,50));

 	DrawTestPattern1(TPoint(150,50));

 	DrawTestPattern1(TPoint(0,100));

 	DrawTestPattern1(TPoint(100,100));

 	DrawTestPattern1(TPoint(200,100));

 	DrawTestPattern1(TPoint(50,150));

 	DrawTestPattern1(TPoint(150,150));

 	DrawTestPattern1(TPoint(0,200));

 	DrawTestPattern1(TPoint(100,200));

 	DrawTestPattern1(TPoint(200,200));

 	if (iEnableClipRegion)

 		{

 		iGc->ResetClippingRegion();

 		iGc->SetDrawMode(DirectGdi::EDrawModePEN);

 		}

 	SaveOutput(tag);

 	}

 /**

 @SYMTestCaseID			

 	GRAPHICS-DIRECTGDI-DRAWRESOURCE-0003

 @SYMTestPriority		

 	Critical

 @SYMPREQ				

 	PREQ39

 @SYMREQ

 	REQ9178 

 	REQ9200 

 	REQ9201 

 	REQ9202 

 	REQ9203 

 	REQ9222 

 	REQ9228 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestStatus			

 	Implemented

 @SYMTestCaseDesc		

 	Draw a scaled image resource created from RSgImage object.

 @SYMTestActions			

 	Draw a scaled image resource with the various combination of parameters:

 	-with and without clipping region

 	-in various destination positions and scaling factor

 	-using write or blend

 	-the destination rectangle that the image is drawn to scaled

 @SYMTestExpectedResults	

 	Resources are drawn on the given position, scaled to fit the

 	destination rectangle, rotated and clipped to current clipping region (if set).

 */

 void CTDirectGdiResource::TestDrawResource_DestRectL()

 	{

 	_LIT(KTestName, "DrawResource_DestRect");

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestName);

 		}

 	TBuf<KFileNameLength> tag;

 	tag.Append(KTestName);

 	ResetGc();

 	if (iEnableClipRegion)

 		{

 		iGc->SetClippingRegion(iClip);

 		tag.Append(KClip);

 		}

 	if (iUseWriteAlpha)

 		{

 		iGc->SetDrawMode(DirectGdi::EDrawModeWriteAlpha);

 		tag.Append(KWriteAlpha);

 		}

 	DrawTestPattern1(TRect(0,0,100,100));

 	DrawTestPattern2(TRect(100,0,200,100));

 	DrawTestPattern3(TRect(0,100,100,200));

 	DrawTestPattern1(TRect(100,100,150,150));

 	DrawTestPattern2(TRect(150,100,200,150));

 	DrawTestPattern3(TRect(100,150,200,200));

 	if (iEnableClipRegion)

 		{

 		iGc->ResetClippingRegion();

 		iGc->SetDrawMode(DirectGdi::EDrawModePEN);		

 		}

 	SaveOutput(tag);

 	}

 /**

 @SYMTestCaseID			

 	GRAPHICS-DIRECTGDI-DRAWRESOURCE-0004

 @SYMTestPriority		

 	Critical

 @SYMPREQ				

 	PREQ39

 @SYMREQ

 	REQ9178 

 	REQ9200 

 	REQ9201 

 	REQ9202 

 	REQ9203 

 	REQ9222 

 	REQ9228 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestStatus			

 	Implemented

 @SYMTestCaseDesc		

 	Draw a scaled portion of an image resource created from RSgImage object.

 @SYMTestActions			

 	Draw a scaled portion of an image resource with the various combination of parameters:

 	-with and without clipping region

 	-various destination positions and size

 	-using write or blend

 	-only a portion of the image resource is drawn, it is drawn scaled

 @SYMTestExpectedResults	

 	Resources are drawn on the given position, scaled to fit the

 	destination rectangle, rotated and clipped to current clipping region (if set).

 */

 void CTDirectGdiResource::TestDrawResource_DestRectSrcRectL()

 	{

 	_LIT(KTestName, "DrawResource_DestRectSrcRect");

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestName);

 		}

 	TBuf<KFileNameLength> tag;

 	tag.Append(KTestName);

 	ResetGc();

 	if (iEnableClipRegion)

 		{

 		iGc->SetClippingRegion(iClip);

 		tag.Append(KClip);

 		}

 	if (iUseWriteAlpha)

 		{

 		iGc->SetDrawMode(DirectGdi::EDrawModeWriteAlpha);

 		tag.Append(KWriteAlpha);

 		}

 	TRect srcRect(TPoint(1,1), TSize(48,18));

 	DrawTestPattern1(TRect(0,0,100,100), &srcRect);

 	DrawTestPattern2(TRect(100,0,200,100), &srcRect);

 	DrawTestPattern3(TRect(0,100,100,200), &srcRect);

 	DrawTestPattern1(TRect(100,100,150,150), &srcRect);

 	DrawTestPattern2(TRect(150,100,200,150), &srcRect);

 	DrawTestPattern3(TRect(100,150,200,200), &srcRect);

 	if (iEnableClipRegion)

 		{

 		iGc->ResetClippingRegion();

 		iGc->SetDrawMode(DirectGdi::EDrawModePEN);		

 		}

 	SaveOutput(tag);

 	}

 /**

 @SYMTestCaseID			

 	GRAPHICS-DIRECTGDI-DRAWRESOURCE-0005

 @SYMTestPriority		

 	Critical

 @SYMPREQ				

 	PREQ39

 @SYMREQ

 	REQ9178 

 	REQ9200 

 	REQ9201 

 	REQ9202 

 	REQ9203 

 	REQ9222 

 	REQ9228 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestStatus			

 	Implemented

 @SYMTestCaseDesc

 	Attempt to draw a resource with a NULL handle for each of the DrawResource methods

 	that draw image sources to improve code coverage.

 @SYMTestActions	

 	Create an RSgImage,

 	Create a RDirectGdiDrawableSource from it,

 	Attempt to draw the RDirectGdiDrawableSource with each of the DrawResource methods.

 	Each method should set an error of KErrBadHandle.

 @SYMTestExpectedResults	

 	Driver returns KErrBadHandle for each attempt to draw invalid resource.

  */

 void CTDirectGdiResource::TestDrawResource_NullHandleL()

 	{

 	_LIT(KTestName, "DrawResource_NullHandle");

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestName);

 		}

 	ResetGc();

 	CDirectGdiDriver* drv = CDirectGdiDriver::Static();

 	TESTL(drv != NULL);

 	// null handle

 	//

 	RDirectGdiDrawableSource dwb(*drv);

 	RDirectGdiDrawableSource img(*drv);

 	// Convert the image source, drawable source and bitmaps to TDrawableSourceAndEquivRotatedBmps so it can be

 	// drawn using the BitGdi test code as well as the DirectGdi code

 	TDrawableSourceAndEquivRotatedBmps imageSource;

 	imageSource.iDrawableSrc = &img;

 	TDrawableSourceAndEquivRotatedBmps drawableSource;

 	drawableSource.iDrawableSrc = &dwb;

 	TPoint pos;

 	TRect dstRect(pos, TSize(100,100));

 	TRect srcRect(pos, TSize(10,10));	

 	// DrawResource(const TRect&, const RDirectGdiDrawableSource&, const TDesC8&)

 	iGc->DrawResource(dstRect, drawableSource, KNullDesC8);

 	TESTL(iGc->GetError() == KErrBadHandle);

 	for (TInt rot=0; rot<sizeof(TestRot)/sizeof(TestRot[0]); ++rot)

 		{

 		// DrawResource(const TPoint&, const RDirectGdiDrawableSource&, DirectGdi::TGraphicsRotation)

 		iGc->DrawResource(pos, imageSource, TestRot[rot]);

 		TESTL(iGc->GetError() == KErrBadHandle);

 		// DrawResource(const TRect&, const RDirectGdiDrawableSource&, DirectGdi::TGraphicsRotation)

 		iGc->DrawResource(dstRect, imageSource, TestRot[rot]);

 		TESTL(iGc->GetError() == KErrBadHandle);

 		// DrawResource(const TRectt&, const RDirectGdiDrawableSource&, const TRect&, DirectGdi::TGraphicsRotation)

 		iGc->DrawResource(dstRect, imageSource, srcRect, TestRot[rot]);

 		TESTL(iGc->GetError() == KErrBadHandle);

 		}

 	}

 /**

 @SYMTestCaseID			

 	GRAPHICS-DIRECTGDI-DRAWRESOURCE-0006

 @SYMTestPriority		

 	Critical

 @SYMPREQ				

 	PREQ39

 @SYMREQ

 	REQ9178 

 	REQ9200 

 	REQ9201 

 	REQ9202 

 	REQ9203 

 	REQ9222 

 	REQ9228 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestStatus			

 	Implemented

 @SYMTestCaseDesc		

 	Draw onto an RSgImage as a target, then convert to it a source and draw that 

 	as a resource.

 @SYMTestActions			

 	Test the use case where we:

 	Draw red, green and blue rectangles to a target.

 	Create a source from the targets' bitmap.

 	Clear the target.

 	Draw the source to the target.

 @SYMTestExpectedResults	

 	The three rectangles should have been appear when the source is copied to the target. 

 */

 void CTDirectGdiResource::TestDrawTargetAsSourceL()

 	{

 	_LIT(KTestName, "DrawResource_TestDrawTargetAsSource");

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestName);

 		}

 	ResetGc();		

 	// draw to the current target

 	TRect rect(20,20,100,100);	

 	iGc->SetPenColor(TRgb(255,0,0));

 	iGc->DrawRect(rect);

 	iGc->SetPenColor(TRgb(0,255,0));

 	rect.Move(20,20);

 	iGc->DrawRect(rect);

 	iGc->SetPenColor(TRgb(0,0,255));

 	rect.Move(20,20);

 	iGc->DrawRect(rect);

 	TESTNOERROR(iGc->GetError());

 	// Only do the second part of the test if using DirectGdi. The resultant test bitmap should looks the

 	// same when using DirectGdi as the one drawn using BitGdi that only uses the above calls.

 	if (iUseDirectGdi)

 		{

 		iGdiTarget->Finish();

 		TESTNOERROR(iGc->GetError());

 		// get the target bitmap

 		CFbsBitmap* bitmap = iGdiTarget->GetTargetFbsBitmapL();

 		TESTL(bitmap != NULL);

 		// Create an RSgImage using the target bitmap	

 		TSgImageInfo imageInfo;

 		imageInfo.iSizeInPixels = bitmap->SizeInPixels();

 		imageInfo.iPixelFormat = iTestParams.iTargetPixelFormat; // only call this test when the target and the source resource pixel format are the same

 		imageInfo.iUsage = ESgUsageDirectGdiSource;

 		RSgImage sgImage;	

 		TInt err = sgImage.Create(imageInfo, bitmap->DataAddress(), bitmap->DataStride());

 		CleanupClosePushL(sgImage);	

 		TESTNOERRORL(err);

 		CDirectGdiDriver* dgdiDriver = CDirectGdiDriver::Static();	

 		TESTL(dgdiDriver != NULL);	

 		// Create a RDirectGdiDrawableSource from the RSgImage

 		RDirectGdiDrawableSource dgdiImageSource(*dgdiDriver);

 		err = dgdiImageSource.Create(sgImage);

 		TESTNOERRORL(err);

 		iGc->Clear();

 		// Convert the image source and bitmap to TDrawableSourceAndEquivRotatedBmps so it can be

 		// drawn using the BitGdi test code as well as the DirectGdi code

 		TDrawableSourceAndEquivRotatedBmps imageSource;

 		imageSource.iDrawableSrc = &dgdiImageSource;

 		imageSource.iBmpRotNone = bitmap;

 		// Draw the RDirectGdiDrawableSource using CDirectGdiContext::DrawResource	

 		iGc->DrawResource(TPoint(0,0), imageSource);		

 		dgdiImageSource.Close();

 		CleanupStack::PopAndDestroy(1, &sgImage);

 		}

 	// Output the target image to make sure it contains what was drawn onto the source

 	TESTNOERROR(WriteTargetOutput(iTestParams, KTestName()));

 	}

 /**

 @SYMTestCaseID				

 	GRAPHICS-DIRECTGDI-DRAWRESOURCE-0007

 @SYMTestPriority			

 	Critical

 @SYMPREQ					

 	PREQ39

 @SYMREQ

 	REQ9178 

 	REQ9200 

 	REQ9201 

 	REQ9202 

 	REQ9203 

 	REQ9222 

 	REQ9228 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestStatus				

 	Implemented

 @SYMTestCaseDesc			

 	Create two CDirectGdiImageSource object from the same RSgImage

 @SYMTestActions				

 	Test the use case where we:

 	Create an RSgImage

 	Create two CDirectGdiImageSource objects.

 	The CDirectGdiImageSource objects should share the EGL image created from

 	the RSgImage

 	as only one EGL image can be created per RSgImage per process.

 	If the EGL image sharing is not working an error will occur when creating the

 	second CDirectGdiImageSource object.

 @SYMTestExpectedResults		

 	This test does not output an image, it is just for testing that no errors or panics occur.

 */

 void CTDirectGdiResource::TestShareEGLImageBetweenSourcesL()

 	{

 	_LIT(KTestName, "ShareEGLImageBetweenSources");

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestName);

 		}

 	ResetGc();	

 	CDirectGdiDriver* dgdiDriver = CDirectGdiDriver::Static();

 	TESTL(dgdiDriver != NULL);	

 	// Create a CFbsBitmap

 	TSize patternSize(90,50);

 	TRect rect(0,0,90,50);

 	CFbsBitmap* bitmap = CreateCheckedBoardBitmapL(iTestParams.iSourceResourcePixelFormat, patternSize);

 	TESTL(NULL != bitmap);

 	CleanupStack::PushL(bitmap);	

 	// Create an RSgImage from the CFbsBitmap

 	TSgImageInfo imageInfo;

 	imageInfo.iSizeInPixels = patternSize;

 	imageInfo.iPixelFormat = iTestParams.iSourceResourcePixelFormat;

 	imageInfo.iUsage = ESgUsageDirectGdiSource;

 	RSgImage sgImage;	

 	TInt res = sgImage.Create(imageInfo, bitmap->DataAddress(), bitmap->DataStride());	

 	TESTNOERRORL(res);	

 	CleanupClosePushL(sgImage);

 	// Create a RDirectGdiDrawableSource from the RSgImage

 	RDirectGdiDrawableSource dgdiImageSource1(*dgdiDriver);	

 	res = dgdiImageSource1.Create(sgImage);		

 	TESTNOERRORL(res);

 	CleanupClosePushL(dgdiImageSource1);

 	// Create a second RDirectGdiDrawableSource from the same RSgImage,

 	// no error should occur here, the underlying EGL images created should be

 	// shared between sources

 	RDirectGdiDrawableSource dgdiImageSource2(*dgdiDriver);	

 	res = dgdiImageSource2.Create(sgImage);		

 	TESTNOERRORL(res);	

 	dgdiImageSource1.Close();

 	dgdiImageSource2.Close();

 	CleanupStack::PopAndDestroy(3, bitmap);

 	}

 /**

 @SYMTestCaseID			

 	GRAPHICS-DIRECTGDI-DRAWRESOURCE-0008

 @SYMTestPriority		

 	Critical

 @SYMPREQ				

 	PREQ39

 @SYMREQ

 	REQ9178 

 	REQ9200 

 	REQ9201 

 	REQ9202 

 	REQ9203 

 	REQ9222 

 	REQ9228 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestStatus			

 	Implemented

 @SYMTestCaseDesc		

 	Draw resource with valid resource but other invalid parameters

 @SYMTestActions			

 	Draw valid RDirectGdiDrawableSource objects with invalid

 	parameters. Test the following for each valid rotation:

 	- drawing a resource where the source rectangle does not intersect the actual image extent

 	- drawing a resource where the source rectangle is not fully contained by the image extent

 @SYMTestExpectedResults	

 	Driver returns KErrArgument for each attempt to draw resource with invalid parameters.

 */

 void CTDirectGdiResource::TestDrawResource_InvalidParameterL()

 	{

 	_LIT(KTestName, "DrawResource_InvalidParameter");

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestName);

 		}

 	ResetGc();

 	// destRect can be anything

 	TPoint pos;

 	TRect dstRect(pos, iImgSz);

 	// srcRect doesn't intersect image extent at all

 	TRect srcRect1(TPoint(1000,1000), TSize(1,1));

 	// srcRect is not fully contained within image extent

 	TRect srcRect2(TPoint(10,10), TSize(1000,1000));

 	TRect srcRect3(TPoint(-10,0), iImgSz);

 	for (TInt rot=0; rot<sizeof(TestRot)/sizeof(TestRot[0]); ++rot)

 		{

 		iGc->DrawResource(dstRect, iImgSrc, srcRect1, TestRot[rot]);

 		TESTL(iGc->GetError() == KErrArgument);

 		iGc->DrawResource(dstRect, iImgSrc, srcRect2, TestRot[rot]);

 		TESTL(iGc->GetError() == KErrArgument);

 		iGc->DrawResource(dstRect, iImgSrc, srcRect3, TestRot[rot]);

 		TESTL(iGc->GetError() == KErrArgument);

 		}

 	}

 /**

 @SYMTestCaseID			

 	GRAPHICS-DIRECTGDI-DRAWRESOURCE-0009

 @SYMTestPriority		

 	Critical

 @SYMPREQ				

 	PREQ39

 @SYMREQ

 	REQ9178 

 	REQ9200 

 	REQ9201 

 	REQ9202 

 	REQ9203 

 	REQ9222 

 	REQ9228 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestStatus			

 	Implemented

 @SYMTestCaseDesc		

 	Draw resources with a non-zero origin set.

 @SYMTestActions			

 	Set drawing context origin to various non-zero values and draw RDirectGdiDrawableSource

 	objects using generic underlying DrawResource implementation that takes destination

 	and source rectangle.

 @SYMTestExpectedResults	

 	Resource drawn at the specified location relative to drawing context origin.

 */

 void CTDirectGdiResource::TestDrawResource_NonZeroOriginL()

 	{

 	_LIT(KTestName, "DrawResource_NonZeroOrigin");

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestName);

 		}

 	const TPoint origin[] = 

 		{

 		TPoint(-100,-100),

 		TPoint(100,-100),

 		TPoint(100,0),

 		TPoint(-100,100),

 		TPoint(0,100),

 		TPoint(100,100)		

 		};

 	for (TInt idx=0; idx<sizeof(origin)/sizeof(origin[0]); ++idx)

 		{

 		TBuf<KFileNameLength> tag;

 		tag.Append(KTestName);

 		tag.AppendNum(idx);

 		ResetGc();	

 		iGc->SetOrigin(origin[idx]);

 		TRect srcRect(TPoint(0,0), iImgSz);

 		DrawTestPattern1(TRect(0,0,100,100), &srcRect);

 		DrawTestPattern2(TRect(100,0,200,100), &srcRect);

 		DrawTestPattern3(TRect(0,100,100,200), &srcRect);

 		DrawTestPattern1(TRect(100,100,150,150), &srcRect);

 		DrawTestPattern2(TRect(150,100,200,150), &srcRect);

 		DrawTestPattern3(TRect(100,150,200,200), &srcRect);

 		SaveOutput(tag);

 		}

 	}

 /**

 @SYMTestCaseID		

 	GRAPHICS-DIRECTGDI-DRAWRESOURCE-0010

 @SYMTestPriority

 	Critical

 @SYMPREQ

 	PREQ39

 @SYMREQ

 	REQ9178 

 	REQ9200 

 	REQ9201 

 	REQ9202 

 	REQ9203 

 	REQ9222 

 	REQ9228 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestCaseDesc

 	Tests if DirectGDI methods returns an error when called on a not constructed RDirectGdiDrawableSource object.

 @SYMTestActions		

 	Create a CFbsBitmap. 

 	Create an RSgImage from the CFbsBitmap.

 	Allocate a RDirectGdiDrawableSource but do not call Create() method.

 	Draw the RDirectGdiDrawableSource using CDirectGdiContext::DrawResource.

 @SYMTestExpectedResults

 	CDirectGdiContext::DrawResource should return KErrBadHandle.

 */

 void CTDirectGdiResource::TestDrawResourceSourceNotCreatedL()

 	{

 	_LIT(KTestName, "DrawResource_SourceNotCreated");

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestName);

 		}

 	if (iUseDirectGdi)

 		{

 		ResetGc();

 		TInt res = CDirectGdiDriver::Open();

 		TESTNOERRORL(res);		

 		CDirectGdiDriver* dgdiDriver = CDirectGdiDriver::Static();

 		TESTL(dgdiDriver != NULL);	

 		CleanupClosePushL(*dgdiDriver);	

 		// Create a CFbsBitmap

 		TSize patternSize(90,50);

 		CFbsBitmap* bitmap = CreateCheckedBoardBitmapL(iTestParams.iSourceResourcePixelFormat, patternSize);

 		TESTL(NULL != bitmap);

 		CleanupStack::PushL(bitmap);	

 		// Create an RSgImage from the CFbsBitmap

 		TSgImageInfo imageInfo;

 		imageInfo.iSizeInPixels = patternSize;

 		imageInfo.iPixelFormat = iTestParams.iSourceResourcePixelFormat;

 		imageInfo.iUsage = ESgUsageDirectGdiSource;

 		RSgImage sgImage;	

 		res = sgImage.Create(imageInfo, bitmap->DataAddress(), bitmap->DataStride());

 		CleanupClosePushL(sgImage);

 		TESTNOERRORL(res);		

 		//allocate RDirectGdiDrawableSource, but do not call Create() method

 		RDirectGdiDrawableSource dgdiImageSource(*dgdiDriver);	

 		// Draw the RDirectGdiDrawableSource using CDirectGdiContext::DrawResource

 		TDrawableSourceAndEquivRotatedBmps imageSource;

 		imageSource.iDrawableSrc = &dgdiImageSource;

 		iGc->DrawResource(TPoint(10,10), imageSource);

 		TESTL(iGc->GetError() == KErrBadHandle);		

 		dgdiImageSource.Close();

 		CleanupStack::PopAndDestroy(3, dgdiDriver); 

 		}

 	}

 /** 

 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.

 @leave Gets system wide error code

 @return TVerdict code

 */	

 TVerdict CTDirectGdiResource::doTestStepL()

 	{			

 	INFO_PRINTF1(_L("DirectGdi Resource Tests"));	

 	// Test for each target pixel format

 	for(TInt targetPixelFormatIndex = iTargetPixelFormatArray.Count() - 1; targetPixelFormatIndex >= 0 ; targetPixelFormatIndex--)

 		{ 

 		iTestParams.iTargetPixelFormat = iTargetPixelFormatArray[targetPixelFormatIndex];

 		TBuf<KPixelFormatNameLength> targetPixelFormatName(TDisplayModeMapping::ConvertPixelFormatToPixelFormatString(iTestParams.iTargetPixelFormat));

 		// Test for each source pixel format

 		for (TInt sourceResourcePixelFormatIndex = iSourceResourcePixelFormatArray.Count() - 1; sourceResourcePixelFormatIndex >= 0; sourceResourcePixelFormatIndex--)

 			{

 			TBool doOOM = EFalse;

 			iTestParams.iSourceResourcePixelFormat = iSourceResourcePixelFormatArray[sourceResourcePixelFormatIndex];

 			if(EUidPixelFormatXRGB_8888 == iTestParams.iSourceResourcePixelFormat)

 				doOOM = ETrue;

 			TBuf<KPixelFormatNameLength> sourcePixelFormatName(TDisplayModeMapping::ConvertPixelFormatToPixelFormatString(iTestParams.iSourceResourcePixelFormat));

 			INFO_PRINTF3(_L("Target Pixel Format: %S;  Source Resource Pixel Format: %S"), &targetPixelFormatName, &sourcePixelFormatName);							

 			SetTargetL(iTestParams.iTargetPixelFormat);

 			CreateCommonResourceL();					

 			RunTestsL();

 			// only run OOM tests for one target pixel format to prevent duplication of tests

 			if (targetPixelFormatIndex == 0 && doOOM)

 				{		

 				RunOomTestsL(); // from base class

 				}

 			DestroyCommonResource();			

 			}

 		}

 	CloseTMSGraphicsStep();

 	return TestStepResult();

 	}

 /**

 Helper function used to create the resources that are shared between all the tests in this file.

  */

 void CTDirectGdiResource::CreateCommonResourceL()

 	{

 	// Create a CFbsBitmap

 	CFbsBitmap* bitmap;

 	RSgDrawable sgDwb;

 	// Generate tiled color pattern, test expects original image size to be 50x20 and has alpha values

 	TSize patternSize(50,20);

 	bitmap = CreateCheckedBoardBitmapL(iTestParams.iSourceResourcePixelFormat, patternSize, TSize(10, 10), ETrue);	

 	iImgSrc.iBmpRotNone = bitmap;		

 	iImgSz = bitmap->SizeInPixels();

 	// Create rotated versions of the bitmap so they can be used when drawing BitGdi equivalent

 	// test images for the new DrawResource methods

 	iImgSrc.iBmpRot90 = new(ELeave) CFbsBitmap;		

 	iImgSrc.iBmpRot180 = new(ELeave) CFbsBitmap;		

 	iImgSrc.iBmpRot270 = new(ELeave) CFbsBitmap;	

 	// Create an RSgImage from the CFbsBitmap

 	TSgImageInfo imageInfo;

 	imageInfo.iSizeInPixels = iImgSz;

 	imageInfo.iPixelFormat = iTestParams.iSourceResourcePixelFormat;

 	imageInfo.iUsage = ESgUsageDirectGdiSource;

 	RSgImage sgImage;	

 	TInt res = sgImage.Create(imageInfo, bitmap->DataAddress(), bitmap->DataStride());

 	TESTNOERRORL(res);

 	CleanupClosePushL(sgImage);	

 	if (iUseDirectGdi)

 		{

 		// Create a RDirectGdiDrawableSource from the RSgImage

 		// Driver must've been initialised by framework, no need to re-open

 		//

 		// Driver behaviour i.e. Sg::Open/Close, CDirectGdiDriver::Open/Close should be tested

 		// somewhere else not in details drawing ops test like this

 		CDirectGdiDriver* drv = CDirectGdiDriver::Static();

 		TEST(drv != NULL);

 		iImgSrc.iDrawableSrc = new RDirectGdiDrawableSource(*drv);

 		TEST(iImgSrc.iDrawableSrc != NULL);

 		res = iImgSrc.iDrawableSrc->Create(sgImage);		

 		TESTNOERRORL(res);	

 		// Create drawable source from drawable

 		res = sgDwb.Open(sgImage.Id());

 		TESTNOERRORL(res);

 		CleanupClosePushL(sgDwb);

 		iDwbSrc[0].iDrawableSrc = new RDirectGdiDrawableSource(*drv);

 		TEST(iDwbSrc[0].iDrawableSrc != NULL);

 		res = iDwbSrc[0].iDrawableSrc->Create(sgDwb);

 		TESTNOERRORL(res);

 		// Create drawable source from image

 		iDwbSrc[1].iDrawableSrc = new RDirectGdiDrawableSource(*drv);

 		TEST(iDwbSrc[1].iDrawableSrc != NULL);

 		res = iDwbSrc[1].iDrawableSrc->Create(sgImage);

 		TESTNOERRORL(res);

 		}

 	else

 		{

 		// Share the bitmaps from iImgSrc with this drawable for testing

 		iDwbSrc[0].iBmpRotNone = iImgSrc.iBmpRotNone; 

 		iDwbSrc[0].iBmpRot90 = iImgSrc.iBmpRot90; 

 		iDwbSrc[0].iBmpRot180 = iImgSrc.iBmpRot180;

 		iDwbSrc[0].iBmpRot270 = iImgSrc.iBmpRot270;

 		// Share the bitmaps from iImgSrc with this drawable for testing

 		iDwbSrc[1].iBmpRotNone = iImgSrc.iBmpRotNone; 

 		iDwbSrc[1].iBmpRot90 = iImgSrc.iBmpRot90; 

 		iDwbSrc[1].iBmpRot180 = iImgSrc.iBmpRot180;

 		iDwbSrc[1].iBmpRot270 = iImgSrc.iBmpRot270;

 		}

 	// Create horizontal and vertical stripe clipping region

 	TInt w = 1;

 	TBool on = EFalse;

 	for (TInt x=0; x<50; x+=w)

 		{

 		on = !on;

 		if (on && x+w<50)

 			{

 			TRect r1(TPoint(x,0), TSize(w, 200));

 			TRect r2(TPoint(100+x,0), TSize(w, 200));

 			iClip.AddRect(r1);

 			iClip.AddRect(r2);

 			}

 		++w;

 		}

 	TInt h = 1;

 	on = EFalse;

 	for (TInt y=0; y<200; y+=h)

 		{

 		on = !on;

 		if (on && y+h<200)

 			{

 			TRect r1(TPoint(0,y), TSize(100, h));

 			TRect r2(TPoint(100,y), TSize(100, h));

 			iClip.AddRect(r1);

 			iClip.AddRect(r2);

 			}

 		++h;

 		}

 	if (!iUseDirectGdi)

 		{

 		// We need to create 3 rotated copies of the bitmap we are drawing when testing using BitGdi

 		// using the CBitmapRotator active object, start rotating the first one here

 		iCurrentState = ERotatingBitmap90;

 		iBitmapRotator->Rotate(&iStatus, *bitmap, *(iImgSrc.iBmpRot90), CBitmapRotator::ERotation90DegreesClockwise);

 		SetActive();

 		CActiveScheduler::Start();

 		}

 	// Destroy bitmap, image and drawable.

 	CleanupStack::PopAndDestroy(iUseDirectGdi ? 2 : 1, &sgImage);

 	}

 /**

 Helper function used to destroy the resources that are shared between all the tests in this file.

  */

 void CTDirectGdiResource::DestroyCommonResource()

 	{

 	if (iImgSrc.iDrawableSrc)

 		{

 		iImgSrc.iDrawableSrc->Close();

 		delete iImgSrc.iDrawableSrc;

 		iImgSrc.iDrawableSrc = NULL;

 		}

 	delete iImgSrc.iBmpRotNone;

 	iImgSrc.iBmpRotNone = NULL;

 	delete iImgSrc.iBmpRot90;

 	iImgSrc.iBmpRot90 = NULL;

 	delete iImgSrc.iBmpRot180;

 	iImgSrc.iBmpRot180 = NULL;

 	delete iImgSrc.iBmpRot270;

 	iImgSrc.iBmpRot270 = NULL;	

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

 		{

 		if (iDwbSrc[ii].iDrawableSrc)

 			{

 			iDwbSrc[ii].iDrawableSrc->Close();

 			delete iDwbSrc[ii].iDrawableSrc;

 			iDwbSrc[ii].iDrawableSrc = NULL;

 			}

 		iDwbSrc[ii].iBmpRotNone = NULL;

 		iDwbSrc[ii].iBmpRot90 = NULL;

 		iDwbSrc[ii].iBmpRot180 = NULL;

 		iDwbSrc[ii].iBmpRot270 = NULL;		

 		}

 	iClip.Close();

 	}

 /**

 Override of base class virtual

 @leave Gets system wide error code

 @return - TVerdict code

 */

 TVerdict CTDirectGdiResource::doTestStepPreambleL()

 	{				

 	CTDirectGdiStepBase::doTestStepPreambleL();

 	CActiveScheduler::Add(this);

 	iBitmapRotator = CBitmapRotator::NewL();		

 	return TestStepResult();

 	}

 /**

 Override of base class virtual

 @leave Gets system wide error code

 @return - TVerdict code

 */

 TVerdict CTDirectGdiResource::doTestStepPostambleL()

 	{		 

 	delete iBitmapRotator;	

 	iBitmapRotator = NULL;

 	CTDirectGdiStepBase::doTestStepPostambleL();

 	return TestStepResult();

 }

 void CTDirectGdiResource::DoDrawTestL()

 	{

 	SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWRESOURCE-0001"));

 	TestDrawResource_ImageAsDrawableL();

 	RecordTestResultL();

 	SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWRESOURCE-0002"));

 	TestDrawResource_PosL();

 	RecordTestResultL();

 	SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWRESOURCE-0003"));

 	TestDrawResource_DestRectL();

 	RecordTestResultL();

 	SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWRESOURCE-0004"));

 	TestDrawResource_DestRectSrcRectL();

 	RecordTestResultL();

 	}

 /**

 Override of base class pure virtual

 Lists the tests to be run

 */

 void CTDirectGdiResource::RunTestsL()

 	{		

 	// For all combination of destination and source pixel format do the following tests

 	//

 	DoDrawTestL();

 	// Extra test using EDrawModeWriteAlpha. Geometry tests are irrelevant here, only contents tests are.

 	//

 	if (SourceResourceHasAlpha())

 		{

 		iUseWriteAlpha = ETrue;

 		DoDrawTestL();

 		iUseWriteAlpha = EFalse;

 		}

 	// Geometry and negative tests doesn't need repeating, do it once

 	//

 	if (OneTimeTestEnabled())

 		{

 		iEnableClipRegion = ETrue;

 		DoDrawTestL();

 		iEnableClipRegion = EFalse;

 		SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWRESOURCE-0009"));

 		TestDrawResource_NonZeroOriginL();

 		RecordTestResultL();

 		if (iUseDirectGdi)

 			{

 			// These test for errors being set that are specific to DirectGdi and

 			// have no output so there is no need to run for BitGdi

 			SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWRESOURCE-0005"));

 			TestDrawResource_NullHandleL();

 			RecordTestResultL();

 			SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWRESOURCE-0008"));

 			TestDrawResource_InvalidParameterL();

 			RecordTestResultL();

 			SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWRESOURCE-0010"));

 			TestDrawResourceSourceNotCreatedL();

 			RecordTestResultL();

 			}		

 		}

 	// This test uses the target as a source, so only call it when the target

 	// pixel format is the same as the source resource pixel format

 	//

 	if (iTestParams.iTargetPixelFormat == iTestParams.iSourceResourcePixelFormat)

 		{

 		SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWRESOURCE-0006"));

 		TestDrawTargetAsSourceL();

 		RecordTestResultL();

 		}

 	if (iUseDirectGdi)

 		{

 		// This test is only appropriate when using DirectGdi as it tests sharing of EGL images

 		SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWRESOURCE-0007"));

 		TestShareEGLImageBetweenSourcesL();

 		RecordTestResultL();

 		}

 	}

 /**

 From CActive

  */

 void CTDirectGdiResource::RunL()

 	{

 	switch (iCurrentState)

 		{

 		case ERotatingBitmap90:

 			// Rotate the next bitmap (180)

 			iCurrentState = ERotatingBitmap180;

 			iBitmapRotator->Rotate(&iStatus, *(iImgSrc.iBmpRotNone), *(iImgSrc.iBmpRot180), CBitmapRotator::ERotation180DegreesClockwise);

 			SetActive();

 			break;

 		case ERotatingBitmap180:

 			// Rotate the next bitmap (270)

 			iCurrentState = ERotatingBitmap270;

 			iBitmapRotator->Rotate(&iStatus, *(iImgSrc.iBmpRotNone), *(iImgSrc.iBmpRot270), CBitmapRotator::ERotation270DegreesClockwise);

 			SetActive();

 			break;

 		case ERotatingBitmap270:

 			// Finished rotating the bitmaps, run the tests now

 			iCurrentState = EDone;			

 			CActiveScheduler::Stop();

 			break;

 		}

 	}

 /**

 From CActive

  */

 void CTDirectGdiResource::DoCancel()

 	{

 	}