// 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();
	
	}