--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsdeviceinterface/directgdi/test/tclipping.cpp Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,337 @@
+// 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 "tclipping.h"
+
+CTClipping::CTClipping()
+ {
+ SetTestStepName(KTDirectGdiClippingStep);
+ }
+
+CTClipping::~CTClipping()
+ {
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-CLIPPING-0001
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9195
+ REQ9201
+ REQ9202
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Tests setting clipping regions.
+
+@SYMTestPriority
+ High
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ Set the clipping region consisting of a number of rectangles. Blit a bitmap.
+ Reset the clipping region.
+
+@SYMTestExpectedResults
+ Bitmap should be drawn only within the clipped regions successfully.
+*/
+void CTClipping::TestClippingBasicL()
+ {
+ _LIT(KTestName, "Clipping-Basic");
+ if(!iRunningOomTests)
+ {
+ INFO_PRINTF1(KTestName);
+ }
+
+ CFbsBitmap* bitmap = CreateCheckedBoardBitmapL(iTestParams.iTargetPixelFormat, TSize(150,150));
+ TESTL(bitmap != NULL);
+ RRegion clippingRegion(8);
+ clippingRegion.AddRect(TRect(10,10,40,40)); // normal square clipping rect
+ clippingRegion.AddRect(TRect(60,70,67,132)); // normal rectangular clipping rect
+ clippingRegion.AddRect(TRect(50,75,110,85)); // clipping rect crosses another clipping rect
+ clippingRegion.AddRect(TRect(125,125,125,125)); // clipping rect with zero size
+ clippingRegion.AddRect(TRect(50,30,45,25)); // clipping rect with negative size
+
+ ResetGc();
+ iGc->SetClippingRegion(clippingRegion);
+ TESTNOERROR(iGc->GetError());
+ iGc->BitBlt(TPoint(0, 0), *bitmap);
+ TESTNOERROR(iGc->GetError());
+ iGc->ResetClippingRegion();
+ TESTNOERROR(iGc->GetError());
+ clippingRegion.Close();
+ delete bitmap;
+ if (iUseDirectGdi && !iUseSwDirectGdi)
+ {
+ iVgImageCache->ResetCache();
+ }
+
+ TESTNOERROR(WriteTargetOutput(iTestParams, TPtrC(KTestName)));
+ }
+
+
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-CLIPPING-0002
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9195
+ REQ9201
+ REQ9202
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Tests the argument checking within SetClippingRegion(TRegion&).
+
+@SYMTestPriority
+ High
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ 1. Test a region that is outside the bounds of the target.
+ 2. Test a region which is partially outside the bounds of the target.
+ 3. Test using a region which has its error flag set.
+
+@SYMTestExpectedResults
+ Test should return KErrArgument.
+*/
+void CTClipping::TestClippingErrors()
+ {
+ _LIT(KTestName, "Clipping-Errors");
+ if(!iRunningOomTests)
+ {
+ INFO_PRINTF1(KTestName);
+ }
+
+ RRegion outOfBoundsRegion(TRect(200,200,220,220)); // clipping rect wholly outside target area
+ RRegion partOutOfBoundsRegion(TRect(80,-10,100,25)); // clipping rect partially outside target area
+ TRegionFix<1> regionWithError(TRect(50,75,110,85));
+ //add more rects than region can hold to set error flag
+ regionWithError.AddRect(TRect(0,0,5,5));
+
+ ResetGc();
+
+ // Test whether setting clipping region returns error when passed invalid clipping regions
+ // 1: Pass region wholly outside of target.
+ iGc->SetClippingRegion(outOfBoundsRegion);
+ TEST(KErrArgument == iGc->GetError());
+ iGc->ResetClippingRegion();
+ TESTNOERROR(iGc->GetError());
+ // 2: Pass region partially outside of target.
+ iGc->SetClippingRegion(partOutOfBoundsRegion);
+ TEST(KErrArgument == iGc->GetError());
+ iGc->ResetClippingRegion();
+ TESTNOERROR(iGc->GetError());
+ // 3: Pass region with error flag set.
+ iGc->SetClippingRegion(regionWithError);
+ TEST(KErrArgument == iGc->GetError());
+ iGc->ResetClippingRegion();
+ TESTNOERROR(iGc->GetError());
+ outOfBoundsRegion.Close();
+ partOutOfBoundsRegion.Close();
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-CLIPPING-0003
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9195
+ REQ9201
+ REQ9202
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Tests using clipping regions while using various APIs to draw images, using a non-zero origin.
+
+@SYMTestPriority
+ High
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ Create a bitmap.
+ Set a clipping region rectangle (50,50) from the top-left of the target.
+ Set the origin to 50,50.
+ Draw an image using BitBlt() at (0,0).
+ Reset the clipping.
+ Set a clipping region rectangle (150,50) from the top-left of the target.
+ Set the origin to 150,50.
+ Draw an image using DrawBitmap() at (0,0).
+ Reset the clipping.
+ Set a clipping region rectangle (50,150) from the top-left of the target.
+ Set the origin to 50,150.
+ Draw an image using BitBltMasked() at (0,0).
+ Reset the clipping.
+ Set a clipping region rectangle (150,150) from the top-left of the target.
+ Set the origin to 150,150.
+ Draw an image using DrawBitmapMasked() at (0,0).
+
+@SYMTestExpectedResults
+ The first bitmap should be drawn, 50,50 from the top-left of the target.
+ The second bitmap should be drawn, 100,50 from the top-left of the target.
+ The third bitmap should be drawn, 50,100 from the top-left of the target.
+ The fourth bitmap should be drawn, 100,100 from the top-left of the target.
+ None of them should be clipped because although it is always being drawn at (0,0), the
+ drawing and the clipping should take into account the Origin offset.
+*/
+void CTClipping::TestClippingWithOriginL()
+ {
+ _LIT(KTestName, "Clipping-WithOrigin");
+ if(!iRunningOomTests)
+ {
+ INFO_PRINTF1(KTestName);
+ }
+
+ ResetGc();
+
+ const TSize bitmapSrcSize = TSize(40,40);
+
+ CFbsBitmap* bitmap = CreateCheckedBoardBitmapL(iTestParams.iTargetPixelFormat, bitmapSrcSize);
+ CleanupStack::PushL(bitmap);
+ CFbsBitmap* mask = CreateBlackWhiteBitmapL(iTestParams.iTargetPixelFormat, bitmapSrcSize, TSize(2,2));
+ CleanupStack::PushL(mask);
+
+ // Test with BitBlt().
+ iGc->SetOrigin(TPoint(50,50));
+ RRegion clippingRegion(1);
+ clippingRegion.AddRect(TRect(TPoint(50,50), TSize(50,50)));
+ iGc->SetClippingRegion(clippingRegion);
+ iGc->BitBlt(TPoint(0,0), *bitmap);
+ iGc->ResetClippingRegion();
+ clippingRegion.Close();
+ TESTNOERROR(iGc->GetError());
+
+ // Test with DrawBitmap() with scaling.
+ iGc->SetOrigin(TPoint(150, 50));
+ clippingRegion.AddRect(TRect(TPoint(150,50), TSize(50,50)));
+ iGc->SetClippingRegion(clippingRegion);
+ iGc->DrawBitmap(TRect(TPoint(0,0), TSize(50,50)), *bitmap, TRect(TPoint(0,0), bitmapSrcSize));
+ iGc->ResetClippingRegion();
+ clippingRegion.Close();
+ TESTNOERROR(iGc->GetError());
+
+ // Test with BitBltMasked().
+ iGc->SetOrigin(TPoint(50, 150));
+ clippingRegion.AddRect(TRect(TPoint(50,150), TSize(50,50)));
+ iGc->SetClippingRegion(clippingRegion);
+ iGc->BitBltMasked(TPoint(0,0), *bitmap, TRect(TPoint(0,0), bitmapSrcSize), *mask, EFalse);
+ iGc->ResetClippingRegion();
+ clippingRegion.Close();
+ TESTNOERROR(iGc->GetError());
+
+ // Test with DrawBitmapMasked().
+ iGc->SetOrigin(TPoint(150, 150));
+ clippingRegion.AddRect(TRect(TPoint(150,150), TSize(50,50)));
+ iGc->SetClippingRegion(clippingRegion);
+ iGc->DrawBitmapMasked(TRect(TPoint(0,0), TSize(50,50)), *bitmap, TRect(TPoint(0,0), bitmapSrcSize), *mask, EFalse);
+ iGc->ResetClippingRegion();
+ clippingRegion.Close();
+ TESTNOERROR(iGc->GetError());
+
+ CleanupStack::PopAndDestroy(2, bitmap);
+ TESTNOERROR(WriteTargetOutput(iTestParams, TPtrC(KTestName)));
+ }
+
+/**
+Override of base class virtual
+@leave Gets system wide error code
+@return - TVerdict code
+*/
+TVerdict CTClipping::doTestStepPreambleL()
+ {
+ CTDirectGdiStepBase::doTestStepPreambleL();
+ return TestStepResult();
+ }
+
+/**
+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 CTClipping::doTestStepL()
+ {
+ // Test for each pixel format
+ for(TInt targetPixelFormatIndex = iTargetPixelFormatArray.Count() - 1; targetPixelFormatIndex >= 0 ; targetPixelFormatIndex--)
+ {
+ iTestParams.iTargetPixelFormat = iTargetPixelFormatArray[targetPixelFormatIndex];
+ SetTargetL(iTestParams.iTargetPixelFormat);
+ RunTestsL();
+ // only run OOM tests for one target pixel format to prevent duplication of tests
+ if (targetPixelFormatIndex == 0)
+ {
+ RunOomTestsL(); //from base class
+ }
+ }
+ CloseTMSGraphicsStep();
+ return TestStepResult();
+ }
+
+/**
+Override of base class pure virtual
+Lists the tests to be run
+*/
+void CTClipping::RunTestsL()
+ {
+ if(iUseDirectGdi && !iUseSwDirectGdi)
+ {
+ // At least one clipping test uses BitBlt() or DrawBitmap().
+ // In the event that a test leaves after a BitBlt() or DrawBitmap() has occurred
+ // the vgimage cache will need to be reset.
+ // This needs to be the first item on the cleanupstack,
+ // as some tests perform pushes and pops of bitmaps.
+ CleanupStack::PushL(TCleanupItem(ResetCache, iVgImageCache));
+ }
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-CLIPPING-0001"));
+ TestClippingBasicL();
+ RecordTestResultL();
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-CLIPPING-0002"));
+ TestClippingErrors();
+ RecordTestResultL();
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-CLIPPING-0003"));
+ TestClippingWithOriginL();
+ RecordTestResultL();
+ if(iUseDirectGdi && !iUseSwDirectGdi)
+ {
+ CleanupStack::PopAndDestroy(iVgImageCache);
+ }
+ }