--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsdeviceinterface/directgdi/test/tbitbltmasked.cpp Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,616 @@
+// 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 "tbitbltmasked.h"
+
+CTBitBltMasked::CTBitBltMasked()
+ {
+ SetTestStepName(KTDirectGdiBitBltMaskedStep);
+ }
+
+CTBitBltMasked::~CTBitBltMasked()
+ {
+ }
+
+/**
+Override of base class pure virtual
+Lists the tests to be run
+*/
+void CTBitBltMasked::RunTestsL()
+ {
+ if(iUseDirectGdi && !iUseSwDirectGdi)
+ {
+ // 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));
+ }
+
+ BeginMaskIteration();
+ // to minimize tests call number these tests are processed only for one mask
+ if(!iLargeTarget)
+ {
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-BITBLTMASKED-0003"));
+ TestInvalidParametersL();
+ RecordTestResultL();
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-BITBLTMASKED-0004"));
+ TestSourceBitmapCloningL();
+ RecordTestResultL();
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-BITBLTMASKED-0005"));
+ TestMaskCloningL();
+ RecordTestResultL();
+ }
+ do
+ {
+ if(!iLargeTarget)
+ {
+ iTestParams.iDoCompressed = ETrue;
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-BITBLTMASKED-0001"));
+ TestBasicL();
+ RecordTestResultL();
+ iTestParams.iDoCompressed = EFalse;
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-BITBLTMASKED-0006"));
+ TestDrawModeL();
+ RecordTestResultL();
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-BITBLTMASKED-0007"));
+ TestWithSameBitmapsL();
+ RecordTestResultL();
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-BITBLTMASKED-0008"));
+ TestSetOriginL();
+ RecordTestResultL();
+ }
+ else
+ {
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-BITBLTMASKED-0002"));
+ TestPositioningL();
+ RecordTestResultL();
+ }
+ }
+ while(NextMaskIteration());
+
+ if(iUseDirectGdi && !iUseSwDirectGdi)
+ {
+ CleanupStack::PopAndDestroy(iVgImageCache);
+ }
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-BITBLTMASKED-0001
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9198
+ REQ9204
+ REQ9195
+ REQ9201
+ REQ9202
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Bit blitting with masking basic functionality.
+
+@SYMTestPriority
+ Critical
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ Test bit blitting with masking for basic and valid parameters.
+
+@SYMTestExpectedResults
+ Source bitmap should be copied into target area. Basic or inverted
+ masking should be considered. Valid bitmap should be created. This
+ bitmap should be the same as a reference bitmap.
+*/
+void CTBitBltMasked::TestBasicL()
+ {
+ _LIT(KTestName, "BitBltMasked-Basic");
+ _LIT(KTestNameNegative, "BitBltMasked-Basic-NegativeMaskPosition");
+ if(!iRunningOomTests)
+ {
+ INFO_PRINTF1(KTestName);
+ }
+
+ ResetGc();
+ CFbsBitmap* bitmap;
+ CFbsBitmap* mask;
+ if(iTestParams.iDoCompressed)
+ {
+ bitmap = iCompressedBitmap;
+ mask = iCompressedMaskL8;
+ }
+ else
+ {
+ bitmap = iCheckedBoardBitmap2;
+ mask = iCurrentMask1;
+ }
+
+ TRect bmpRect(TPoint(0, 0), bitmap->SizeInPixels());
+ if(iMaskPixelFormat == EUidPixelFormatL_1)
+ {
+ iGc->BitBltMasked(TPoint(20, 20), *bitmap, bmpRect, *mask, iInvertMask);
+ iGc->BitBltMasked(TPoint(20, 20), *bitmap, bmpRect, *mask, ETrue);
+ }
+ else
+ {
+ iGc->BitBltMasked(TPoint(20, 20), *bitmap, bmpRect, *mask, TPoint(0, 0));
+ }
+ TESTNOERROR(iGc->GetError());
+ if(!iTestParams.iDoCompressed)
+ WriteTargetOutput(KTestName());
+
+ // negative mask position
+ iGc->BitBltMasked(TPoint(-35, 180), *bitmap, bmpRect, *iMask1L8, TPoint(-1, -1));
+ TESTNOERROR(iGc->GetError());
+
+ // mask position greater than mask size
+ iGc->BitBltMasked(TPoint(-35, 200), *bitmap, bmpRect, *iMask1L8, iMask1L8->SizeInPixels().AsPoint());
+ CheckErrorsL(KErrNone, KErrArgument, (TText8*)__FILE__, __LINE__);
+
+ if(!iTestParams.iDoCompressed)
+ TESTNOERRORL(WriteTargetOutput(KTestNameNegative()));
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-BITBLTMASKED-0002
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9197
+ REQ9198
+ REQ9204
+ REQ9195
+ REQ9201
+ REQ9202
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Various combinations of destination positions, source position and size
+ of a bitmap are tested. Test also covers mask alignment, tiling and boundary
+ parameters.
+
+@SYMTestPriority
+ Critical
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ Covers the whole target bitmap starting from TPoint(-30,-30) with staggered blits of a small 8x8 bitmap.
+ Test positioning functionality of BitBltMasked() methods. Test boundary
+ conditions, tiling and clipping to surface area.
+
+@SYMTestExpectedResults
+*/
+void CTBitBltMasked::TestPositioningL()
+ {
+ _LIT(KTestName, "BitBltMasked-Positioning");
+ if(!iRunningOomTests)
+ {
+ INFO_PRINTF1(KTestName);
+ }
+ iTestParams.iDoCompressed = ETrue;
+ TestPositioningBaseL(KTestName(), EBitBltMasked);
+ iTestParams.iDoCompressed = EFalse;
+ TestPositioningBaseL(KTestName(), EBitBltMasked);
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-BITBLTMASKED-0003
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9197
+ REQ9198
+ REQ9204
+ REQ9195
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Calling BitBltMasked() method with invalid parameters
+
+@SYMTestPriority
+ Critical
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ Invalid source rect:
+ - TRect(-30, -30, -10, -10);
+ - TRect(bmpWidth+10, bmpHeight+10, bmpWidth+20, bmpHeight+20);
+ - TRect(bmpWidth, bmpHeight, 0, 0);
+ - TRect(-10, -10, -30, -30);
+ - TRect(0, 0, 0, 0);
+ Invalid mask (aMaskBitmap):
+ - zero size mask
+ - not initialized mask
+ Mask position greater than mask size: aMaskPt = TPoint(mask_width, mask_height)
+ Invalid source bitmap:
+ - zero size bitmap
+ - not initialised bitmap
+
+@SYMTestExpectedResults
+ Function should detect invalid parameters and return. Nothing should be drawn
+ in a target area.
+*/
+void CTBitBltMasked::TestInvalidParametersL()
+ {
+ _LIT(KTestName, "BitBltMasked-InvalidParameters");
+ if(!iRunningOomTests)
+ {
+ INFO_PRINTF1(KTestName);
+ }
+ TestInvalidParametersBaseL(KTestName(), EBitBltMasked);
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-BITBLTMASKED-0004
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9197
+ REQ9204
+ REQ9195
+ REQ9201
+ REQ9202
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Tests that masked bitmaps are drawn correctly if they
+ are deleted immediately after BitBltMasked() is called, but before Finish() is called.
+
+@SYMTestPriority
+ Critical
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ Set valid mask parameters (see BitBltMasked-Basic).
+ For test description see BitBlt-SourceBitmapCloning.
+
+@SYMTestExpectedResults
+ Source bitmap should be copied into target area. Memory leaks should not
+ be created. Valid bitmap should be created. This bitmap should be
+ the same as a reference bitmap.
+*/
+void CTBitBltMasked::TestSourceBitmapCloningL()
+ {
+ _LIT(KTestName, "BitBltMasked-SourceBitmapCloning");
+ if(!iRunningOomTests)
+ {
+ INFO_PRINTF1(KTestName);
+ }
+ iTestParams.iDoCompressed = ETrue;
+ TestSourceBitmapCloningBaseL(KTestName(), EBitBltMasked);
+ iTestParams.iDoCompressed = EFalse;
+ TestSourceBitmapCloningBaseL(KTestName(), EBitBltMasked);
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-BITBLTMASKED-0005
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9197
+ REQ9204
+ REQ9195
+ REQ9201
+ REQ9202
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Tests that masked bitmaps are drawn correctly if the mask
+ is deleted immediately after BitBltMasked() is called, but before Finish() is called.
+
+@SYMTestPriority
+ Critical
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ 1. Invoke the BitBltMasked() method with valid parameters (see BitBltMasked-Basic).
+ 2. Right after returning from BitBltMasked() call, destroy the source mask (aMaskBitmap).
+ 3. Call the BitBltMasked() method again with the same mask parameter.
+ Repeat p. 1-3 a few times.
+
+@SYMTestExpectedResults
+ Source bitmap should be copied into target area and should be correctly masked.
+ Memory leaks should not be created. Valid bitmap should be created. This bitmap
+ should be the same as a reference bitmap.
+*/
+void CTBitBltMasked::TestMaskCloningL()
+ {
+ _LIT(KTestName, "BitBltMasked-MaskCloning");
+ if(!iRunningOomTests)
+ {
+ INFO_PRINTF1(KTestName);
+ }
+ iTestParams.iDoCompressed = ETrue;
+ TestMaskCloningBaseL(KTestName(), EBitBltMasked);
+ iTestParams.iDoCompressed = EFalse;
+ TestMaskCloningBaseL(KTestName(), EBitBltMasked);
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-BITBLTMASKED-0006
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9198
+ REQ9204
+ REQ9195
+ REQ9201
+ REQ9202
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Test correctness of bit blitting with mask in all possible draw modes.
+
+@SYMTestPriority
+ Critical
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ Set valid parameters (see BitBltMasked-Basic).
+ Use the semi-transparent source bitmap (iCheckedBoardWithAlphaBitmap).
+ Set drawmode to EDrawModePEN and call the methods.
+ Set drawmode to EDrawModeWriteAlpha and call the methods.
+
+@SYMTestExpectedResults
+ Semi-transparent (for EDrawModePEN) and opaque (for EDrawModeWriteAlpha)
+ should be copied into rendering target. Valid bitmap should be created.
+ This bitmap should be the same as a reference bitmap.
+*/
+void CTBitBltMasked::TestDrawModeL()
+ {
+ _LIT(KTestName, "BitBltMasked-DrawMode");
+ if(!iRunningOomTests)
+ {
+ INFO_PRINTF1(KTestName);
+ }
+ ResetGc();
+
+ TSize bmpSize(iCheckedBoardWithAlphaBitmap->SizeInPixels());
+
+ TInt halfHeight = (bmpSize.iHeight >> 1);
+ TInt quarterWidth = (bmpSize.iWidth >> 2);
+ TInt y1 = halfHeight - (bmpSize.iHeight >> 2);
+ TSize vertRectSize (quarterWidth, bmpSize.iHeight);
+ TSize horizRectSize (bmpSize.iWidth, halfHeight);
+
+ // EDrawModeWriteAlpha is not supported in the following modes
+ // This is tested under invalid parameter tests.
+ if (!((iMaskPixelFormat == EUidPixelFormatL_8) &&
+ ((iTestParams.iSourcePixelFormat == EUidPixelFormatARGB_8888) ||
+ (iTestParams.iSourcePixelFormat == EUidPixelFormatARGB_8888_PRE))))
+ {
+ // Render column to left
+ iGc->SetDrawMode(DirectGdi::EDrawModeWriteAlpha);
+ iGc->BitBltMasked(
+ TPoint(0, 0),
+ *iCheckedBoardWithAlphaBitmap,
+ TRect(TPoint(0, 0), vertRectSize),
+ *iCurrentMask2,
+ TPoint(0, 0));
+ }
+
+ // Render row in center
+ iGc->SetDrawMode(DirectGdi::EDrawModePEN);
+ iGc->BitBltMasked(
+ TPoint(0, y1),
+ *iCheckedBoardWithAlphaBitmap,
+ TRect(TPoint(0, 0), horizRectSize),
+ *iCurrentMask2,
+ TPoint(0, 0));
+
+ // EDrawModeWriteAlpha is not supported in the following modes
+ // This is tested under invalid parameter tests.
+ if (!((iMaskPixelFormat == EUidPixelFormatL_8) &&
+ ((iTestParams.iSourcePixelFormat == EUidPixelFormatARGB_8888) ||
+ (iTestParams.iSourcePixelFormat == EUidPixelFormatARGB_8888_PRE))))
+ {
+ // Render column to right
+ iGc->SetDrawMode(DirectGdi::EDrawModeWriteAlpha);
+ iGc->BitBltMasked(
+ TPoint(bmpSize.iWidth - quarterWidth, 0),
+ *iCheckedBoardWithAlphaBitmap,
+ TRect(TPoint(0, 0), vertRectSize),
+ *iCurrentMask2,
+ TPoint(0, 0));
+ }
+
+ TESTNOERRORL(iGc->GetError());
+
+ TESTNOERRORL(WriteTargetOutput(KTestName()));
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-BITBLTMASKED-0007
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9198
+ REQ9204
+ REQ9195
+ REQ9201
+ REQ9202
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Test the basic functionality of bit blitting with masking.
+
+@SYMTestPriority
+ Critical
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ Test bit blitting with masking for same source and mask bitmaps.
+
+@SYMTestExpectedResults
+ Source bitmap should be copied into target area. Basic or inverted
+ masking should be considered. Valid bitmap should be created. This
+ bitmap should be the same as a reference bitmap.
+*/
+void CTBitBltMasked::TestWithSameBitmapsL()
+ {
+ _LIT(KTestName, "BitBltMasked-SameBitmaps");
+ ResetGc();
+ TRect bmpRect1(TPoint(0, 0), iBlackWhiteBitmap->SizeInPixels());
+ iGc->SetOrigin(TPoint(30, 30));
+ iGc->BitBltMasked(TPoint(0, 0), *iBlackWhiteBitmap, bmpRect1, *iBlackWhiteBitmap, ETrue);
+ iGc->BitBltMasked(TPoint(0, 0), *iBlackWhiteBitmap, bmpRect1, *iBlackWhiteBitmap, EFalse);
+ TESTNOERRORL(iGc->GetError());
+ //Write target only if image is not empty. BitGDI is producing white images when Mask pixel format is EUidPixelFormatL_8
+ TBool pass = TestTargetL(KRgbWhite);
+ if(!pass)
+ {
+ TESTNOERRORL(WriteTargetOutput(KTestName()));
+ }
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-BITBLTMASKED-0008
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9198
+ REQ9204
+ REQ9195
+ REQ9201
+ REQ9202
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Test that BitBltMasked() performs correctly when it is called after SetOrigin().
+
+@SYMTestPriority
+ Critical
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ Call SetOrigin().
+ Call BitBltMasked().
+
+@SYMTestExpectedResults
+ Source bitmap should be copied into target area. Basic or inverted
+ masking should be considered. Valid bitmap should be created. This
+ bitmap should be the same as a reference bitmap.
+*/
+void CTBitBltMasked::TestSetOriginL()
+ {
+ _LIT(KTestName, "BitBltMasked-SetOrigin");
+ _LIT(KTestNameNegative, "BitBltMasked-SetOrigin-NegativeMaskPosition");
+
+ // Only do test for one pixel format to cut down on the number of images produced
+ // as this is just a positional test and we don't need to test for all pixel formats.
+ if (!((iTestParams.iTargetPixelFormat == EUidPixelFormatRGB_565) && (iTestParams.iSourcePixelFormat == EUidPixelFormatRGB_565)))
+ {
+ return;
+ }
+
+ if(!iRunningOomTests)
+ {
+ INFO_PRINTF1(KTestName);
+ }
+
+ ResetGc();
+ CFbsBitmap* bitmap = iCheckedBoardBitmap2;
+ CFbsBitmap* mask = iCurrentMask1;
+
+ TRect bmpRect(TPoint(0, 0), bitmap->SizeInPixels());
+ iGc->SetOrigin(TPoint(-35, 80));
+ if(iMaskPixelFormat == EUidPixelFormatL_1)
+ {
+ iGc->BitBltMasked(TPoint(55, -60), *bitmap, bmpRect, *mask, iInvertMask);
+ iGc->BitBltMasked(TPoint(55, -60), *bitmap, bmpRect, *mask, ETrue);
+ }
+ else
+ {
+ iGc->BitBltMasked(TPoint(55, -60), *bitmap, bmpRect, *mask, TPoint(0, 0));
+ }
+ TESTNOERROR(iGc->GetError());
+ TESTNOERRORL(WriteTargetOutput(KTestName()));
+
+ // negative mask position
+ iGc->BitBltMasked(TPoint(0, 100), *bitmap, bmpRect, *iMask1L8, TPoint(-1, -1));
+ TESTNOERROR(iGc->GetError());
+
+ // mask position greater than mask size
+ iGc->BitBltMasked(TPoint(0, 120), *bitmap, bmpRect, *iMask1L8, iMask1L8->SizeInPixels().AsPoint());
+ CheckErrorsL(KErrNone, KErrArgument, (TText8*)__FILE__, __LINE__);
+
+ TESTNOERRORL(WriteTargetOutput(KTestNameNegative()));
+ }
+
+