diff -r 000000000000 -r 5d03bc08d59c graphicsdeviceinterface/directgdi/test/tdrawbitmapmasked.cpp --- /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(bmp1Width*scale), static_cast(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(bmp1Width*scale), static_cast(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()); + }