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

 #include <s32mem.h>

 #include <graphics/directgdicontext.h>

 _LIT16(KAbcd,"Abcd efgh ijkl mnop");

 CTDirectGdiContext::CTDirectGdiContext()

 	{

 	SetTestStepName(KTDirectGdiContextStep);

 	}

 CTDirectGdiContext::~CTDirectGdiContext()

 	{

 	if(iFont)

 		{

 		ReleaseFont(iFont);		

 		}	

 	}

 /**

 @SYMTestCaseID

 	GRAPHICS-DIRECTGDI-CONTEXT-0001

 @SYMTestPriority

 	Critical

 @SYMPREQ

 	PREQ39

 @SYMREQ

 	REQ9195

 	REQ9201 

 	REQ9202 

 	REQ9222 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestCaseDesc

 	Use case - Single context and single target.

 @SYMTestActions		

 	Single context is created and activated on a single target.

 	Then some draw operations are done.

 @SYMTestExpectedResults

 	It should be able to draw using the correct context and target.

 @SYMTestStatus 		

 	Implemented

 */

 void CTDirectGdiContext::OneContextOneTarget()

 	{		

 	_LIT(KTestName, "Context-OneContextOneTarget"); 

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestName);

 		}

 	ResetGc();		

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

 	TEST(iGc->PenColor() == TRgb(255, 0, 0));

 	iGc->DrawEllipse(TRect(0, 0, 60, 60));

 	TESTNOERROR(iGc->GetError());

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

 	}

 /**

 @SYMTestCaseID		

 	GRAPHICS-DIRECTGDI-CONTEXT-0002

 @SYMTestPriority

 	Critical

 @SYMPREQ

 	PREQ39

 @SYMREQ

 	REQ9195

 	REQ9201 

 	REQ9202 

 	REQ9222 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestCaseDesc

 	Use case - Draw to two separate targets using a single context. 	

 @SYMTestActions		

 	Test that a single context can be activated on two different targets.

 	- A single context is created and activated on a target then a green circle is drawn. 

 	- The same context then activated on a second target and a red circle is drawn.  

 @SYMTestExpectedResults

 	It should be able to draw using the correct context and target and context should 

 	be able to switch between the targets. The first target should have a green circle 

 	only drawn on it, the second target should have a red circle only drawn on it.

 @SYMTestStatus 		

 	Implemented

 */

 void CTDirectGdiContext::OneContextTwoTargets()

 	{	

 	TBuf<KTestCaseLength> testCaseNameA;

 	TBuf<KTestCaseLength> testCaseNameB;

 	_LIT(KTestCase, "Context-OneContextTwoTargets");

 	testCaseNameA.Append(KTestCase);

 	testCaseNameB.Append(KTestCase);

 	if(iCaseNum == EOneContextTwoTargets_SamePixelType)

 		{

 		testCaseNameA.Append(KSamePixelType);

 		testCaseNameB.Append(KSamePixelType);

 		}

 	else

 		{

 		testCaseNameA.Append(KDifferentPixelType);

 		testCaseNameB.Append(KDifferentPixelType);

 		}

 	testCaseNameA.Append(KTarget1);

 	testCaseNameB.Append(KTarget2);

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestCase);

 		}

 	ResetGc();

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

 	TEST(iGc->PenColor() == TRgb(0, 255, 0));

 	iGc->DrawEllipse(TRect(0, 0, 60, 60));

 	TESTNOERROR(iGc->GetError());

 	TESTNOERROR(WriteTargetOutput(iTestParams, TPtrC(testCaseNameA)));

 	iGdiTarget2->Activate(iGc);

 	ResetGc();

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

 	TEST(iGc->PenColor() == TRgb(255, 0, 0));

 	iGc->DrawEllipse(TRect(0, 0, 60, 60));

 	TESTNOERROR(iGc->GetError());

 	TESTNOERROR(WriteTargetOutput(iTestParams, TPtrC(testCaseNameB),iGdiTarget2));

 	}

 /**

 @SYMTestCaseID		

 	GRAPHICS-DIRECTGDI-CONTEXT-0003

 @SYMTestPriority

 	Critical

 @SYMPREQ

 	PREQ39

 @SYMREQ

 	REQ9195

 	REQ9201 

 	REQ9202 

 	REQ9222 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestCaseDesc

 	Use case - draw to a single target using two different contexts.

 @SYMTestActions	

 	Test context's creation and activation when drawing using two different contexts to a single target.

 	- Activate the first context on the target and draw a red circle.

 	- Write out the contents of the target.

 	- Activate the second context on the target, clear it and draw a smaller black circle.

 	- Write out the contents of the target.

 @SYMTestExpectedResults

 	It should be able to draw using the correct context and target. The first image written out

 	should contain a red circle, the second image written out should contain a smaller black circle.

 @SYMTestStatus 		

 	Implemented

 */

 void CTDirectGdiContext::TwoContextsOneTarget()

 	{	

 	TBuf<KTestCaseLength> testCaseNameA;

 	TBuf<KTestCaseLength> testCaseNameB;

 	_LIT(KTestCase, "Context-TwoContextsOneTarget");

 	testCaseNameA.Append(KTestCase);

 	testCaseNameB.Append(KTestCase);

 	testCaseNameA.Append(KContext1);

 	testCaseNameB.Append(KContext2);

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestCase);

 		}

 	iGdiTarget->Activate(iGc);

 	ResetGc();

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

 	TEST(iGc->PenColor() == TRgb(255, 0, 0));

 	iGc->DrawEllipse(TRect(0, 0, 60, 60));

 	TESTNOERROR(iGc->GetError());

 	TESTNOERROR(WriteTargetOutput(iTestParams, TPtrC(testCaseNameA)));	

 	iGdiTarget->Activate(iGc2);

 	iGc2->Reset();

 	iGc2->Clear();

 	iGc2->SetPenColor(TRgb(0, 0, 0));

 	TEST(iGc2->PenColor() == TRgb(0, 0, 0));

 	iGc2->DrawEllipse(TRect(0, 0, 30, 30));

 	TESTNOERROR(iGc2->GetError());	

 	TESTNOERROR(WriteTargetOutput(iTestParams, TPtrC(testCaseNameB)));

 	}

 /**

 @SYMTestCaseID		

 	GRAPHICS-DIRECTGDI-CONTEXT-0004

 @SYMTestPriority

 	Critical

 @SYMPREQ

 	PREQ39

 @SYMREQ

 	REQ9195

 	REQ9201 

 	REQ9202 

 	REQ9222 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestCaseDesc

 	Use case - Two contexts and two targets, but there is no sharing

 @SYMTestActions		

 	Two contexts are created and activated on two different targets. There is no sharing between the contexts and targets, they

 	are completely isolated.

 	Then some draw operations are done. 

 @SYMTestExpectedResults

 	It should be able to draw using the correct context and target.

 @SYMTestStatus 		

 	Implemented

 */

 void CTDirectGdiContext::TwoContextsTwoTargets_WithoutSharingL()

 	{	

 	TBuf<KTestCaseLength> testCaseNameA;

 	TBuf<KTestCaseLength> testCaseNameB;

 	_LIT(KTestCase, "Context-TwoContextsTwoTargets_NotSharing");

 	testCaseNameA.Append(KTestCase);

 	testCaseNameB.Append(KTestCase);

 	if(iCaseNum == ETwoContextsTwoTargets_WithoutSharing_SamePixelType)

 		{

 		testCaseNameA.Append(KSamePixelType);

 		testCaseNameB.Append(KSamePixelType);

 		}

 	else

 		{

 		testCaseNameA.Append(KDifferentPixelType);

 		testCaseNameB.Append(KDifferentPixelType);

 		}

 	testCaseNameA.Append(KTarget1);

 	testCaseNameB.Append(KTarget2);

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestCase);

 		}

 	iGdiTarget->Activate(iGc);

 	ResetGc();

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

 	TEST(iGc->PenColor() == TRgb(255, 0, 0));

 	iGc->DrawEllipse(TRect(0, 0, 60, 60));

 	TESTNOERROR(iGc->GetError());

 	iGdiTarget2->Activate(iGc2);

 	iGc2->Reset();

 	iGc2->Clear();

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

 	TEST(iGc2->PenColor() == TRgb(0, 255, 0));

 	iGc2->DrawEllipse(TRect(0, 0, 30, 30));

 	TESTNOERROR(iGc2->GetError());	

 	// Draw to both again twice to make sure that context switching works.

 	iGc->DrawEllipse(TRect(0,0,60,60));

 	TESTNOERROR(iGc->GetError());

 	iGc2->DrawEllipse(TRect(0, 0, 30, 30));

 	TESTNOERROR(iGc2->GetError());

 	iGc->DrawEllipse(TRect(0,0,60,60));

 	TESTNOERROR(iGc->GetError());

 	iGc2->DrawEllipse(TRect(0, 0, 30, 30));

 	TESTNOERROR(iGc2->GetError());

 	TESTNOERROR(WriteTargetOutput(iTestParams, TPtrC(testCaseNameA)));

 	TESTNOERROR(WriteTargetOutput(iTestParams, TPtrC(testCaseNameB),iGdiTarget2));

 	}

 /**

 @SYMTestCaseID		

 	GRAPHICS-DIRECTGDI-CONTEXT-0005

 @SYMTestPriority

 	Critical

 @SYMPREQ

 	PREQ39

 @SYMREQ

 	REQ9195

 	REQ9201 

 	REQ9202 

 	REQ9222 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestCaseDesc

 	Use case - Draw using two contexts and two targets, swapping the targets over half way through the test.

 @SYMTestActions

 	Test that a context can draw to a target that has been previously drawn to using a different context.		

 	Two contexts are created and activated on two different targets. Then some draw operations are done, 

 	a red circle is drawn on the first target and a black circle is drawn on the second target.

 	Then these contexts are activated on the opposite targets. There is sharing between the contexts 

 	and targets (contexts are activated on each other's targets).

 	Then again some draw operations are done, the targets are cleared and a red circle is drawn on each target.

 @SYMTestExpectedResults

 	It should be able to draw using the correct context and target and context should be able to switch between 

 	the targets. 

 	The target 1 drawn to with context 1 should show a red circle, 

 	target 2 drawn to with context2 should show a black circle, 

 	target 1 drawn to with context 2 should show a red circle,

 	target 2 drawn to with context 1 should show a red circle. 

 @SYMTestStatus 		

 	Implemented

 */

 void CTDirectGdiContext::TwoContextsTwoTargets_WithSharingL()

 	{	

 	TBuf<KTestCaseLength> testCaseNameA;

 	TBuf<KTestCaseLength> testCaseNameB;

 	TBuf<KTestCaseLength> testCaseNameAB;

 	TBuf<KTestCaseLength> testCaseNameBA;

 	_LIT(KTestCase, "Context-TwoContextsTwoTargets_Sharing");

 	testCaseNameA.Append(KTestCase);

 	testCaseNameB.Append(KTestCase);

 	testCaseNameAB.Append(KTestCase);

 	testCaseNameBA.Append(KTestCase);

 	if(iCaseNum == ETwoContextsTwoTargets_WithSharing_SamePixelType)

 		{

 		testCaseNameA.Append(KSamePixelType);

 		testCaseNameB.Append(KSamePixelType);

 		testCaseNameAB.Append(KSamePixelType);

 		testCaseNameBA.Append(KSamePixelType);

 		}

 	else

 		{

 		testCaseNameA.Append(KDifferentPixelType);

 		testCaseNameB.Append(KDifferentPixelType);

 		testCaseNameAB.Append(KDifferentPixelType);

 		testCaseNameBA.Append(KDifferentPixelType);

 		}

 	testCaseNameA.Append(KContext1);

 	testCaseNameA.Append(KTarget1);

 	testCaseNameB.Append(KContext2);

 	testCaseNameB.Append(KTarget2);

 	testCaseNameAB.Append(KContext1);

 	testCaseNameAB.Append(KTarget2);

 	testCaseNameBA.Append(KContext2);

 	testCaseNameBA.Append(KTarget1);

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestCase);

 		}

 	iGdiTarget->Activate(iGc);

 	ResetGc();

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

 	TEST(iGc->PenColor() == TRgb(255, 0, 0));

 	iGc->DrawEllipse(TRect(0, 0, 60, 60));

 	TESTNOERROR(iGc->GetError());

 	TESTNOERROR(WriteTargetOutput(iTestParams, TPtrC(testCaseNameA)));	

 	iGdiTarget2->Activate(iGc2);

 	iGc2->Reset();

 	iGc2->Clear();

 	iGc2->SetPenColor(TRgb(0, 0, 0));

 	TEST(iGc2->PenColor() == TRgb(0, 0, 0));

 	iGc2->DrawEllipse(TRect(0, 0, 30, 30));

 	TESTNOERROR(iGc2->GetError());	

 	TESTNOERROR(WriteTargetOutput(iTestParams, TPtrC(testCaseNameB),iGdiTarget2));

 	iGdiTarget->Activate(iGc2);

 	iGdiTarget2->Activate(iGc);

 	ResetGc();

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

 	TEST(iGc->PenColor() == TRgb(255, 0, 0));

 	iGc->DrawEllipse(TRect(0, 0, 60, 60));

 	TESTNOERROR(iGc->GetError());

 	TESTNOERROR(WriteTargetOutput(iTestParams, TPtrC(testCaseNameAB),iGdiTarget2));

 	iGc2->Reset();

 	iGc2->Clear();

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

 	TEST(iGc->PenColor() == TRgb(255, 0, 0));

 	iGc2->DrawEllipse(TRect(0, 0, 60, 60));

 	TESTNOERROR(iGc2->GetError());

 	TESTNOERROR(WriteTargetOutput(iTestParams, TPtrC(testCaseNameBA)));	

 	}

 /**

 @SYMTestCaseID		

 	GRAPHICS-DIRECTGDI-CONTEXT-0006

 @SYMTestPriority

 	Critical

 @SYMPREQ

 	PREQ39

 @SYMREQ

 	REQ9195

 	REQ9201 

 	REQ9202 

 	REQ9222 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestCaseDesc

 	Use case - Single context and single target, but calling activate twice.

 @SYMTestActions		

 	Single context is created and activated twice on the same target, just to prove that there is no affect of calling

 	Activate() twice on the same target by the same context, in succession.

 @SYMTestExpectedResults

 	It should be able to draw using the correct context and target.

 @SYMTestStatus 		

 	Implemented

 */

 void CTDirectGdiContext::OneContextOneTarget_TwiceActivateL()

 	{	

 	_LIT(KTestName, "Context-OneContextOneTargetTwiceActivate");

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestName);

 		}

 	_LIT(KTestNameA, "Context-OneContextOneTarget_TwiceActivateA"); 

 	_LIT(KTestNameB, "Context-OneContextOneTarget_TwiceActivateB"); 

 	ResetGc();

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

 	TEST(iGc->PenColor() == TRgb(255, 0, 0));

 	iGc->DrawEllipse(TRect(0, 0, 60, 60));

 	TESTNOERROR(iGc->GetError());

 	TEST(KErrNone == WriteTargetOutput(iTestParams, TPtrC(KTestNameA)));	

 	iGdiTarget->Activate(iGc);

 	ResetGc();

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

 	TEST(iGc->PenColor() == TRgb(0, 0, 255));

 	iGc->DrawEllipse(TRect(0, 0, 60, 60));

 	TESTNOERROR(iGc->GetError());

 	TESTNOERROR(WriteTargetOutput(iTestParams, TPtrC(KTestNameB)));

 	}

 LOCAL_C void ContextReset(TAny* aPtr)

 	{

 	CTContextBase* gc = reinterpret_cast <CTContextBase*> (aPtr);

 	gc->Reset();

 	}

 /**

 @SYMTestCaseID

 	GRAPHICS-DIRECTGDI-CONTEXT-0007

 @SYMTestPriority

 	Critical

 @SYMPREQ

 	PREQ39

 @SYMREQ

 	REQ9195 

 	REQ9201 

 	REQ9202 

 	REQ9222 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestStatus

 	Complete

 @SYMTestCaseDesc

 	Externalize and internalize a context.

 @SYMTestActions

 	Test the use case where we:

 	Create a new GC for the purpose of the test.

 	Set Pen and Brush colour non-default colours.

 	Set the Pen and Brush styles to non-default styles.

 	Set the clipping regions.

 	Set a font (DirectGdi only, BitGdi causes the font to be cached and UHEAP failures occur).

 	Set the origin and the internal drawing position to non-defaults.

 	Externalise.

 	Reset the context, and set the state to other values.

 	Internalise.

 	Draw a line from the current internal drawing position.

 	Draw a rectangle using current pen and brush styles/colours/size.

 	Destroy the temporary GC and reinstate the original.

 @SYMTestStatus 

 	Implemented

  */

 void CTDirectGdiContext::ExternalizeInternalizeTestL()

 	{

 	__UHEAP_MARK;

 	_LIT(KTestName, "Context-ExternalizeInternalize"); 	

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestName);

 		}

 	const TInt width = iGdiTarget->SizeInPixels().iWidth;

 	const TInt height = iGdiTarget->SizeInPixels().iHeight;

 	// For this test, create a temporary GC which we can delete later.

 	// This is to avoid UHEAP mismatches if we used the original iGc.

 	// Set this to be iGc for this test.	

 	CTContextBase *oldGc = iGc;

 	iGc = NULL;

 	CleanupStack::PushL(oldGc);

 	TESTNOERRORL(iGdiTarget->CreateContext(iGc));

 	ResetGc();

 	// Create some clipping regions. These should not be externalised/internalised.

 	RRegion clippingRegion(2);

 	clippingRegion.AddRect(TRect(width*3/10,0,width*7/10,height));

 	clippingRegion.AddRect(TRect(0,height*3/10,width,height*7/10));

 	CleanupClosePushL(clippingRegion);

 	iGc->SetClippingRegion(clippingRegion);

 	CleanupStack::PushL(TCleanupItem(ContextReset, iGc));

 	// Create a bitmap to use as a brush pattern

 	CFbsBitmap* pattern = CreateCheckedBoardBitmapL(iTestParams.iTargetPixelFormat, TSize(100,100));

 	CleanupStack::PushL(pattern);

 	// Set non-default state.

 	iGc->SetOrigin(TPoint(10,10));

 	iGc->SetPenSize(TSize(3,3));

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

 	iGc->SetPenStyle(DirectGdi::EDashedPen);

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

 	iGc->SetBrushPattern(*pattern);

 	iGc->SetBrushStyle(DirectGdi::EPatternedBrush);

 	iGc->SetBrushOrigin(TPoint(3, 3));

 	iGc->MoveTo(TPoint(10, height/2));

 	iGc->SetDrawMode(DirectGdi::EDrawModePEN);

 	if (iUseDirectGdi)

 		{

 		// Internalizing/externalizing a font in BitGdi will cause the font to be cached and 

 		// memory UHEAP mismatch occurs, so only do it for DirectGdi. We wont draw any text in the image.

 		TESTL(iFont != NULL);

 		iGc->SetFont(iFont);

 		}

 	// create buffer for save/restore

 	CBufFlat* buf = NULL;

 	TRAPD(err, buf=CBufFlat::NewL(512));

 	if(KErrNone != err)

 		{

 		iGc->ResetClippingRegion();

 		User::LeaveIfError(err);

 		}

 	CleanupStack::PushL(buf);

 	// save and then restore

 	RBufWriteStream ws(*buf,0);

 	iGc->ExternalizeL(ws);

 	ws.Close();

 	// Make some modifications to iGc.

 	// The clipping regions should be persistant even after the Internalize().

 	iGc->Reset();

 	iGc->ResetClippingRegion();

 	iGc->ResetFont();

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

 	RRegion tempClippingRegion(1);

 	tempClippingRegion.AddRect(TRect(width/10, height/10, width*9/10, height*9/10));

 	iGc->SetClippingRegion(tempClippingRegion);	

 	CleanupClosePushL(tempClippingRegion);

 	// Internalise the state.

 	RBufReadStream rs(*buf,0);

 	iGc->InternalizeL(rs);

 	rs.Close();

 	// Draw using the newly internalised context.

 	// We don't draw any text as we don't internalize/externalize text for BitGdi.

 	iGc->Clear();

 	iGc->DrawRect(TRect(width/4, height/4, width*3/4, height*3/4));

 	iGc->DrawLineTo(TPoint(width, height/2));

 	TESTNOERROR(iGc->GetError());

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

 	CleanupStack::PopAndDestroy(5);

 	CleanupStack::Pop(1, oldGc);

 	// Destroy the temporary Gc and reinstate the original one.

 	iGdiTarget->Activate(oldGc);

 	delete iGc;

 	iGc = oldGc;

 	__UHEAP_MARKEND;

 	}

 /**

 @SYMTestCaseID		

 	GRAPHICS-DIRECTGDI-CONTEXT-0008

 @SYMTestPriority

 	Critical

 @SYMPREQ

 	PREQ39

 @SYMREQ

 	REQ9195

 	REQ9201 

 	REQ9202 

 	REQ9222 

 	REQ9223 

 	REQ9236 

 	REQ9237

 @SYMTestCaseDesc

 	Use case - two contexts and one target. 

 @SYMTestActions		

 	Two contexts are created and activated on the same target.

 	Then some draw operations are done. 

 	CopySettings() is called to copy settings from first context to the second one.

 	Then again some draw operations are done to verify that settings have been copied properly.

 @SYMTestExpectedResults

 	It should be able to draw using the correct settings of context and target.

 @SYMTestStatus 		

 	Implemented

 */

 void CTDirectGdiContext::TestCopySettings()

 	{	

 	TBuf<KTestCaseLength> testCaseNameA;

 	TBuf<KTestCaseLength> testCaseNameB;

 	_LIT(KTestCase, "Context-CopySettings");

 	if(!iRunningOomTests)

 		{

 		INFO_PRINTF1(KTestCase);

 		}

 	testCaseNameA.Append(KTestCase);

 	testCaseNameB.Append(KTestCase);

 	testCaseNameA.Append(KContext1);

 	testCaseNameB.Append(KContext2);	

 	// Draw to the first graphics context

 	iGdiTarget->Activate(iGc);

 	ResetGc();		

 	iGc->SetPenColor(KRgbRed);

 	iGc->SetPenSize(TSize(3,3));

 	iGc->SetBrushColor(KRgbYellow);

 	iGc->SetBrushStyle(DirectGdi::ESolidBrush);

 	iGc->SetTextShadowColor(KRgbGreen);

 	TEST(iGc->PenColor() == KRgbRed);

 	// Do some drawing

 	iGc->DrawEllipse(TRect(5, 5, 50, 50));	

 	iGc->SetFont(iFont);	

 	iGc->SetStrikethroughStyle(DirectGdi::EStrikethroughOn);

 	iGc->SetCharJustification(10, 10);

 	iGc->SetWordJustification(20, 20);

 	iGc->DrawText(KAbcd, NULL, TPoint(10, 100));

 	TESTNOERROR(iGc->GetError());

 	TESTNOERROR(WriteTargetOutput(iTestParams, TPtrC(testCaseNameA)));	

 	// Activate the second context and reset the context settings

 	iGdiTarget->Activate(iGc2);

 	iGc2->Reset();

 	iGc2->Clear();

 	TEST(iGc2->PenColor() == TRgb(0, 0, 0));

 	// Copy the settings from the first context to the second one

 	iGc2->CopySettings(*iGc);

 	TEST(iGc2->PenColor() == TRgb(255, 0, 0));

 	// Do some drawing, the ellipse is drawn deliberately smaller this time,

 	// the text should look the same as before 

 	iGc2->DrawEllipse(TRect(0, 0, 30, 30));

 	iGc->DrawText(KAbcd, NULL, TPoint(10, 100));

 	TESTNOERROR(iGc2->GetError());	

 	TESTNOERROR(WriteTargetOutput(iTestParams, TPtrC(testCaseNameB)));

 	// Test that the settings from iGc have been copied to iGc2

 	TEST(iGc->PenColor() == iGc2->PenColor());

 	TEST(iGc->BrushColor() == iGc2->BrushColor());

 	TEST(iGc->TextShadowColor() == iGc2->TextShadowColor());

 	iGc->ResetFont();

 	iGc2->ResetFont();

 	// Force a cleanup of the pen array when testing the SW version of DirectGdi, 

 	// if this is not done the OOM tests fail when running this test.

 	iGc->SetPenSize(TSize(1,1));

 	iGc2->SetPenSize(TSize(1,1));

 	}

 /** 

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

 	{			

 	// Test for each pixel format

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

 		{	

 		iTestParams.iTargetPixelFormat = iTargetPixelFormatArray[targetPixelFormatIndex];

 		for(iCaseNum = EOneContextOneTarget; iCaseNum < ELast; ++iCaseNum)

 			{			

 			SetTargetL(iTestParams.iTargetPixelFormat, static_cast<TContextTestCase>(iCaseNum));							

 			// Create fonts outside of the OOM tests to avoid cached fonts being included

 			iFont = GetFont();

 			User::LeaveIfNull(iFont);					

 			RunTestsL();

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

 			if (targetPixelFormatIndex == 0)

 				{

 				RunOomTestsL();  //from base class

 				}		

 			if(iFont)

 				{

 				ReleaseFont(iFont);

 				iFont = NULL;

 				}			

 			}

 		}

 	CloseTMSGraphicsStep();

 	return TestStepResult();

 	}

 /**

 Override of base class virtual

 @leave Gets system wide error code

 @return - TVerdict code

 */

 TVerdict CTDirectGdiContext::doTestStepPreambleL()

 	{			

 	CTDirectGdiStepBase::doTestStepPreambleL();	

 	return TestStepResult();

 	}

 /**

 Override of base class pure virtual

 Lists the tests to be run

 */

 void CTDirectGdiContext::RunTestsL()

 	{

 	SetTestStepID(KUnknownSYMTestCaseIDName);

 	switch(iCaseNum)

 		{

 		case EOneContextOneTarget:

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

 			OneContextOneTarget();

 			if (!iRunningOomTests)

 				{

 				RecordTestResultL();

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

 				ExternalizeInternalizeTestL();

 				}

 			break;

 		case EOneContextTwoTargets_SamePixelType:

 		case EOneContextTwoTargets_DifferentPixelType:

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

 			OneContextTwoTargets();

 			break;

 		case ETwoContextsOneTarget:

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

 			TwoContextsOneTarget();			

 			RecordTestResultL();

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

 			TestCopySettings();			

 			break;

 		case ETwoContextsTwoTargets_WithoutSharing_SamePixelType:

 		case ETwoContextsTwoTargets_WithoutSharing_DifferentPixelType:

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

 			TwoContextsTwoTargets_WithoutSharingL();

 			break;

 		case ETwoContextsTwoTargets_WithSharing_SamePixelType:

 		case ETwoContextsTwoTargets_WithSharing_DifferentPixelType:

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

 			TwoContextsTwoTargets_WithSharingL();

 			break;

 		case EOneContextOneTarget_TwiceActivate:

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

 			OneContextOneTarget_TwiceActivateL();

 			break;				

 		}

 	RecordTestResultL();

 	}