--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsdeviceinterface/directgdi/test/tdrawbitmapmasked.cpp Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,680 @@
+// 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 "tdrawbitmapmasked.h"
+
+CTDrawBitmapMasked::CTDrawBitmapMasked()
+ {
+ SetTestStepName(KTDirectGdiDrawBitmapMaskedStep);
+ }
+
+CTDrawBitmapMasked::~CTDrawBitmapMasked()
+ {
+ }
+
+/**
+Override of base class pure virtual
+Lists the tests to be run
+*/
+void CTDrawBitmapMasked::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-DRAWBITMAPMASKED-0003"));
+ TestInvalidParametersL();
+ RecordTestResultL();
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0005"));
+ TestSourceBitmapCloningL();
+ RecordTestResultL();
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0006"));
+ TestMaskCloningL();
+ RecordTestResultL();
+ }
+ do
+ {
+ if(!iLargeTarget)
+ {
+ iTestParams.iDoCompressed = ETrue;
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0001"));
+ TestBasicL();
+ RecordTestResultL();
+ iTestParams.iDoCompressed = EFalse;
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0007"));
+ TestDrawModeL();
+ RecordTestResultL();
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0008"));
+ TestWithSameBitmapsL();
+ RecordTestResultL();
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0009"));
+ TestSetOriginL();
+ RecordTestResultL();
+ }
+ else
+ {
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0002"));
+ TestPositioningL();
+ RecordTestResultL();
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0004"));
+ TestScalingL();
+ RecordTestResultL();
+
+ if (iMaskType == EMaskL8)
+ {
+ iTestParams.iDoCompressed = ETrue;
+ SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0004"));
+ TestScalingL();
+ RecordTestResultL();
+ iTestParams.iDoCompressed = EFalse;
+ }
+ }
+ }
+ while(NextMaskIteration());
+ if (iUseDirectGdi && !iUseSwDirectGdi)
+ {
+ CleanupStack::PopAndDestroy(iVgImageCache);
+ }
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0001
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9199
+ REQ9204
+ REQ9195
+ REQ9201
+ REQ9202
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Bitmap drawing with masking basic functionality test.
+
+@SYMTestPriority
+ Critical
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ Test bitmap drawing with masking for simple and valid parameters.
+
+@SYMTestExpectedResults
+ Source bitmap should be drawn masked in the target area. Valid bitmap
+ should be created. This bitmap shall be compared to a reference bitmap.
+*/
+void CTDrawBitmapMasked::TestBasicL()
+ {
+ _LIT(KTestName, "DrawBitmapMasked-Basic");
+ if(!iRunningOomTests)
+ {
+ INFO_PRINTF1(KTestName);
+ }
+
+ ResetGc();
+
+ CFbsBitmap* bitmap;
+ CFbsBitmap* mask;
+ if(iTestParams.iDoCompressed)
+ {
+ bitmap = iCompressedBitmap;
+ mask = iCompressedMaskL8;
+ }
+ else
+ {
+ bitmap = iCheckedBoardBitmap2;
+ mask = iCurrentMask1;
+ }
+
+ TSize bmpSize(bitmap->SizeInPixels());
+
+ iGc->DrawBitmapMasked(TRect(TPoint(20, 20), bmpSize), *bitmap, TRect(TPoint(0, 0), bmpSize), *mask, iInvertMask);
+
+ TESTNOERRORL(iGc->GetError());
+ if(!iTestParams.iDoCompressed)
+ WriteTargetOutput(KTestName());
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0002
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9199
+ REQ9204
+ REQ9195
+ REQ9201
+ REQ9202
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Test regularity of bitmap with masking positioning.
+
+@SYMTestPriority
+ Critical
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ Test positioning functionality of DrawBitmapMasked() methods.
+ Test boundary conditions and clipping to surface area.
+
+@SYMTestExpectedResults
+*/
+void CTDrawBitmapMasked::TestPositioningL()
+ {
+ _LIT(KTestName, "DrawBitmapMasked-Positioning");
+ if(!iRunningOomTests)
+ {
+ INFO_PRINTF1(KTestName);
+ }
+
+ iTestParams.iDoCompressed = ETrue;
+ TestPositioningBaseL(KTestName(), EDrawBitmapMasked);
+ iTestParams.iDoCompressed = EFalse;
+ TestPositioningBaseL(KTestName(), EDrawBitmapMasked);
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0003
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9199
+ REQ9204
+ REQ9195
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Test functions behaviour after calling with invalid parameters.
+
+@SYMTestPriority
+ Critical
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ Replace valid parameters with invalid ones:
+ Invalid mask
+ zero size mask
+ not initialized mask
+ see DrawBitmap-InvalidParameters for rest of invalid parameters.
+
+@SYMTestExpectedResults
+ Function should detect invalid parameters and return. Nothing should be
+ drawn in target area.
+*/
+void CTDrawBitmapMasked::TestInvalidParametersL()
+ {
+ _LIT(KTestName, "DrawBitmapMasked-InvalidParameters");
+ if(!iRunningOomTests)
+ {
+ INFO_PRINTF1(KTestName);
+ }
+
+ TestInvalidParametersBaseL(KTestName(), EDrawBitmapMasked);
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0004
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9199
+ REQ9204
+ REQ9195
+ REQ9201
+ REQ9202
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Test regularity of bitmap scaling.
+
+@SYMTestPriority
+ Critical
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ Test scaling down and up of a source bitmap. Test scaling down and tiling of a mask.
+
+@SYMTestExpectedResults
+ Scaled bitmap should be drawn in a target area. Masking should be proceeded
+ correctly. Valid bitmap should be created. The bitmap should be properly
+ scaled. This bitmap shall be compared to a reference bitmap.
+*/
+void CTDrawBitmapMasked::TestScalingL()
+ {
+ _LIT(KTestName, "DrawBitmapMasked-Scaling");
+ if(!iRunningOomTests)
+ {
+ INFO_PRINTF1(KTestName);
+ }
+
+ TInt width = iGdiTarget->SizeInPixels().iWidth;
+ TInt height = iGdiTarget->SizeInPixels().iHeight;
+
+ CFbsBitmap* bitmap1 = NULL;
+ CFbsBitmap* bitmap2 = NULL;
+ CFbsBitmap* mask = NULL;
+ if(iTestParams.iDoCompressed)
+ {
+ bitmap1 = iCompressedBitmapSmall;
+ bitmap2 = iCompressedBitmap;
+ mask = iCompressedMaskL8;
+ }
+ else
+ {
+ bitmap1 = iCheckedBoardBitmap1;
+ bitmap2 = iCheckedBoardBitmap2;
+ mask = iCurrentMask1;
+ }
+ TInt bmp1Width = bitmap1->SizeInPixels().iWidth;
+ TInt bmp1Height = bitmap1->SizeInPixels().iHeight;
+
+ TInt bmp2Width = bitmap2->SizeInPixels().iWidth;
+ TInt bmp2Height = bitmap2->SizeInPixels().iHeight;
+
+ ResetGc();
+
+ // small bitmap - extreme magnification
+ TReal32 scale = 1.0f;
+ TReal32 scaleFactor = 1.55f;
+ TInt posX = 1;
+ for(TInt jj=0; jj<6; jj++)
+ {
+ TSize size(static_cast<TInt>(bmp1Width*scale), static_cast<TInt>(bmp1Height*scale));
+ TPoint pos(posX, height/4-size.iHeight/2);
+
+ iGc->DrawBitmapMasked(TRect(pos, size), *bitmap1,
+ TRect(TPoint(0, 0), TSize(bmp1Width, bmp1Height)), *mask, iInvertMask);
+
+ posX += size.iWidth+2;
+ scale *= scaleFactor;
+ }
+
+ // large bitmap - extreme minification
+ scale /= scaleFactor;
+ posX = 1;
+ for(TInt jj=5; jj>=0; jj--)
+ {
+ TSize size(static_cast<TInt>(bmp1Width*scale), static_cast<TInt>(bmp1Height*scale));
+ TPoint pos(posX, 3*height/4-size.iHeight/2);
+
+ iGc->DrawBitmapMasked(TRect(pos, size), *bitmap2,
+ TRect(TPoint(0, 0), bitmap2->SizeInPixels()), *mask, iInvertMask);
+
+ posX += size.iWidth+2;
+ scale /= scaleFactor;
+ }
+
+ TESTNOERRORL(iGc->GetError());
+
+ WriteTargetOutput(KTestName());
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0005
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9199
+ REQ9204
+ REQ9195
+ REQ9201
+ REQ9202
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Deleting source bitmap object after issuing draw bitmap with masking requests.
+
+@SYMTestPriority
+ Critical
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ 1. Call method with valid parameters (see DrawBitmapMasked-Basic).
+ 2. Right after returning from method call, destroy the source bitmap.
+ 3. Call the method again with the same bitmap parameter.
+ Repeat p. 1-3 a few times.
+
+@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 CTDrawBitmapMasked::TestSourceBitmapCloningL()
+ {
+ _LIT(KTestName, "DrawBitmapMasked-SourceBitmapCloning");
+ if(!iRunningOomTests)
+ {
+ INFO_PRINTF1(KTestName);
+ }
+
+ iTestParams.iDoCompressed = ETrue;
+ TestSourceBitmapCloningBaseL(KTestName(), EDrawBitmapMasked);
+ iTestParams.iDoCompressed = EFalse;
+ TestSourceBitmapCloningBaseL(KTestName(), EDrawBitmapMasked);
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0006
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9199
+ REQ9204
+ REQ9195
+ REQ9201
+ REQ9202
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Deleting mask objects after issuing draw bitmap with masking request.
+
+@SYMTestPriority
+ Critical
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ 1. Call DrawBitmapMasked() method with valid parameters (see DrawBitmapMasked-Basic).
+ 2. Right after returning from DrawBitmapMasked() call, destroy the source mask (aMaskBitmap).
+ 3. Call the DrawBitmapMasked() method again with the same mask parameter.
+ Repeat p. 1-3 a few times.
+
+@SYMTestExpectedResults
+ Source bitmap should be copied into target area based on a mask data.
+ Memory leaks should not be created. Valid bitmap should be created. This bitmap
+ should be the same as a reference bitmap.
+*/
+void CTDrawBitmapMasked::TestMaskCloningL()
+ {
+ _LIT(KTestName, "DrawBitmapMasked-MaskCloning");
+ if(!iRunningOomTests)
+ {
+ INFO_PRINTF1(KTestName);
+ }
+
+ iTestParams.iDoCompressed = ETrue;
+ TestMaskCloningBaseL(KTestName(), EDrawBitmapMasked);
+ iTestParams.iDoCompressed = EFalse;
+ TestMaskCloningBaseL(KTestName(), EDrawBitmapMasked);
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0007
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9199
+ REQ9204
+ REQ9195
+ REQ9201
+ REQ9202
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Test correctness of bitmap drawing with mask in all possible draw modes.
+
+@SYMTestPriority
+ Critical
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ Set valid parameters (see DrawBitmapMasked-Basic).
+ Use the semi-transparent source bitmap (aBitmap).
+ Set drawmode to EDrawModeWriteAlpha and call the methods.
+ Set drawmode to EDrawModePEN and call the methods.
+ Set drawmode to EDrawModeWriteAlpha and call the methods.
+
+@SYMTestExpectedResults
+ The image drawn in the center should be drawn masked and blended
+ (EDrawModePEN) and the images at the right and left should be drawn masked and
+ opaque (EDrawModeWriteAlpha). Valid bitmap should be created.
+ This bitmap should be the same as a reference bitmap.
+*/
+void CTDrawBitmapMasked::TestDrawModeL()
+ {
+ _LIT(KTestName, "DrawBitmapMasked-DrawMode");
+ if(!iRunningOomTests)
+ {
+ INFO_PRINTF1(KTestName);
+ }
+
+ ResetGc();
+
+ TSize bmpSize(iCheckedBoardWithAlphaBitmap->SizeInPixels());
+
+ TInt halfHeight = (bmpSize.iHeight >> 1);
+ TInt quaterWidth = (bmpSize.iWidth >> 2);
+ TInt y1 = halfHeight - (bmpSize.iHeight >> 2);
+ TSize vertRectSize (quaterWidth, 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->DrawBitmapMasked(
+ TRect (TPoint(0, 0), vertRectSize),
+ *iCheckedBoardWithAlphaBitmap,
+ TRect(TPoint(0, 0), vertRectSize), *iCurrentMask2, iInvertMask);
+ }
+
+ // Render row in center
+ iGc->SetDrawMode(DirectGdi::EDrawModePEN);
+ iGc->DrawBitmapMasked(
+ TRect (TPoint(0, y1), horizRectSize),
+ *iCheckedBoardWithAlphaBitmap,
+ TRect(TPoint(0, 0), horizRectSize), *iCurrentMask2, iInvertMask);
+
+ // 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->DrawBitmapMasked(
+ TRect (TPoint(bmpSize.iWidth - quaterWidth, 0), vertRectSize),
+ *iCheckedBoardWithAlphaBitmap,
+ TRect(TPoint(0, 0), vertRectSize), *iCurrentMask2, iInvertMask);
+ }
+
+ TESTNOERRORL(iGc->GetError());
+ WriteTargetOutput(KTestName());
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0008
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9199
+ REQ9204
+ REQ9195
+ REQ9201
+ REQ9202
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Test the basic functionality of bit blitting with masking.
+
+@SYMTestPriority
+ Critical
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ Test bitmap drawing with masking for same source and mask bitmaps.
+
+@SYMTestExpectedResults
+ Source bitmap should be copied into target area. A mask should be
+ considered during coping. Valid bitmap should be created. This bitmap
+ shall be compared to a reference bitmap.
+*/
+void CTDrawBitmapMasked::TestWithSameBitmapsL()
+ {
+ _LIT(KTestName, "DrawBitmapMasked-SameBitmaps");
+ ResetGc();
+ TSize bmpSize1(iBlackWhiteBitmap->SizeInPixels());
+ iGc->DrawBitmapMasked(TRect(TPoint(0, 0), bmpSize1), *iBlackWhiteBitmap, TRect(TPoint(0, 0), bmpSize1), *iBlackWhiteBitmap, ETrue);
+ iGc->DrawBitmapMasked(TRect(TPoint(0, 0), bmpSize1), *iBlackWhiteBitmap, TRect(TPoint(0, 0), bmpSize1), *iBlackWhiteBitmap, EFalse);
+ TESTNOERROR(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)
+ {
+ WriteTargetOutput(KTestName());
+ }
+ }
+
+/**
+@SYMTestCaseID
+ GRAPHICS-DIRECTGDI-DRAWBITMAPMASKED-0009
+
+@SYMPREQ
+ PREQ39
+
+@SYMREQ
+ REQ9199
+ REQ9204
+ REQ9195
+ REQ9201
+ REQ9202
+ REQ9222
+ REQ9223
+ REQ9236
+ REQ9237
+
+@SYMTestCaseDesc
+ Test that DrawBitmapMasked() performs correctly if it is called after SetOrigin().
+
+@SYMTestPriority
+ Critical
+
+@SYMTestStatus
+ Implemented
+
+@SYMTestActions
+ Call SetOrigin().
+ Call DrawBitmapMasked().
+
+@SYMTestExpectedResults
+ Source bitmap should be drawn masked in the target area. Valid bitmap
+ should be created. This bitmap shall be compared to a reference bitmap.
+*/
+void CTDrawBitmapMasked::TestSetOriginL()
+ {
+ _LIT(KTestName, "DrawBitmapMasked-SetOrigin");
+
+ // 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;
+ TSize bmpSize(bitmap->SizeInPixels());
+
+ iGc->SetOrigin(TPoint(-35, 80));
+ iGc->DrawBitmapMasked(TRect(TPoint(55, -60), bmpSize), *bitmap, TRect(TPoint(0, 0), bmpSize), *mask, iInvertMask);
+
+ TESTNOERRORL(iGc->GetError());
+ WriteTargetOutput(KTestName());
+ }