--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsdeviceinterface/directgdi/test/tdirectgdicontext.cpp Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,835 @@
+// 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();
+
+ }