diff -r 000000000000 -r bde4ae8d615e os/graphics/graphicsdeviceinterface/directgdi/test/tbitbltmasked.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/graphics/graphicsdeviceinterface/directgdi/test/tbitbltmasked.cpp Fri Jun 15 03:10:57 2012 +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())); + } + +