diff -r 000000000000 -r 5d03bc08d59c graphicsdeviceinterface/directgdi/test/tdirectgdicontext.cpp --- /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 + +#include + + +_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 testCaseNameA; + TBuf 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 testCaseNameA; + TBuf 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 testCaseNameA; + TBuf 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 testCaseNameA; + TBuf testCaseNameB; + TBuf testCaseNameAB; + TBuf 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 (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 testCaseNameA; + TBuf 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(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(); + + }