diff -r 000000000000 -r 5d03bc08d59c graphicsdeviceinterface/directgdi/test/tclipping.cpp --- /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); + } + }