diff -r 000000000000 -r 5d03bc08d59c graphicsdeviceinterface/directgdi/test/tdrawbitmap.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graphicsdeviceinterface/directgdi/test/tdrawbitmap.cpp Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,534 @@ +// 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 "tdrawbitmap.h" + +CTDrawBitmap::CTDrawBitmap() + { + SetTestStepName(KTDirectGdiDrawBitmapStep); + } + +CTDrawBitmap::~CTDrawBitmap() + { + } + +/** +Override of base class pure virtual +Lists the tests to be run +*/ +void CTDrawBitmap::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)); + } + if(!iLargeTarget) + { + iTestParams.iDoCompressed = ETrue; + SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAP-0001")); + TestBasicL(); + RecordTestResultL(); + iTestParams.iDoCompressed = EFalse; + SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAP-0003")); + TestInvalidParametersL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAP-0005")); + TestSourceBitmapCloningL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAP-0006")); + TestDrawModeL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAP-0007")); + TestSetOriginL(); + RecordTestResultL(); + } + else + { + SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAP-0002")); + TestPositioningL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-DIRECTGDI-DRAWBITMAP-0004")); + TestScalingL(); + RecordTestResultL(); + } + if (iUseDirectGdi && !iUseSwDirectGdi) + { + CleanupStack::PopAndDestroy(iVgImageCache); + } + } + +/** +@SYMTestCaseID + GRAPHICS-DIRECTGDI-DRAWBITMAP-0001 + +@SYMPREQ + PREQ39 + +@SYMREQ + REQ9199 + REQ9204 + REQ9195 + REQ9201 + REQ9202 + REQ9222 + REQ9223 + REQ9236 + REQ9237 + +@SYMTestCaseDesc + Bitmap drawing basic functionality test. + +@SYMTestPriority + Critical + +@SYMTestStatus + Implemented + +@SYMTestActions + Test bitmap drawing for simple and valid parameters: + - Set the origin at TPoint(-35,80) + - Draw a stretched bitmap at TPoint(55,-60) + +@SYMTestExpectedResults + Source bitmap should be copied into drawing target. + Valid bitmap should be created. This bitmap shall be compared + to a reference bitmap. +*/ +void CTDrawBitmap::TestBasicL() + { + _LIT(KTestName, "DrawBitmap-Basic"); + if(!iRunningOomTests) + { + INFO_PRINTF1(KTestName); + } + + ResetGc(); + + CFbsBitmap* bitmap; + if(iTestParams.iDoCompressed) + { + bitmap = iCompressedBitmap; + } + else + { + bitmap = iCheckedBoardBitmap2; + } + + iGc->DrawBitmap(TRect(TPoint(20, 20), bitmap->SizeInPixels()), *bitmap, TRect(10, 10, 130, 130)); + TESTNOERRORL(iGc->GetError()); + + if(!iTestParams.iDoCompressed) + WriteTargetOutput(KTestName()); + } + +/** +@SYMTestCaseID + GRAPHICS-DIRECTGDI-DRAWBITMAP-0002 + +@SYMPREQ + PREQ39 + +@SYMREQ + REQ9199 + REQ9204 + REQ9195 + REQ9201 + REQ9202 + REQ9222 + REQ9223 + REQ9236 + REQ9237 + +@SYMTestCaseDesc + Test regularity of bitmap positioning. + +@SYMTestPriority + Critical + +@SYMTestStatus + Implemented + +@SYMTestActions + Test positioning functionality of DrawBitmap() methods. Test boundary + conditions and clipping to surface area. + Covers the whole target bitmap starting from TPoint(-30,-30) with staggered blits of a small 8x8 bitmap. + +@SYMTestExpectedResults + Source bitmap should be drawn tiled in a staggered fashion across the whole target. Clipping should be applied. + Valid bitmap should be created. This bitmap shall be compared to a reference bitmap. +*/ +void CTDrawBitmap::TestPositioningL() + { + _LIT(KTestName, "DrawBitmap-Positioning"); + if(!iRunningOomTests) + { + INFO_PRINTF1(KTestName); + } + iTestParams.iDoCompressed = ETrue; + TestPositioningBaseL(KTestName(), EDrawBitmap); + iTestParams.iDoCompressed = EFalse; + TestPositioningBaseL(KTestName(), EDrawBitmap); + } + +/** +@SYMTestCaseID + GRAPHICS-DIRECTGDI-DRAWBITMAP-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 + Set valid parameters (see DrawBitmap-BasicL). Replace individual parameters + with Invalid ones: + Invalid source rectangles + aSourceRect : negative source rectangle starting point or size + TRect( TPoint( -30, -30), TSize(-10, -10) ) + aSourceRect : source rectangle not compatible with bitmap + TRect( TSize(aBitmap->SizeInPixel(). iWidth + 10, aBitmap->SizeInPixel(). IHeight + 10)) + aSourceRect : swapped points in source rectangle + TRect( TPoint( 100, 100 ) , TPoint( 0, 0 ) ) + Invalid destination rectangle (aDestRect): + negative size + Invalid source bitmap + zero size bitmap + not initialized bitmap + +@SYMTestExpectedResults + Function should detect invalid parameters and return. + Nothing will be drawn on the target surface. +*/ +void CTDrawBitmap::TestInvalidParametersL() + { + _LIT(KTestName, "DrawBitmap-InvalidParameters"); + if(!iRunningOomTests) + { + INFO_PRINTF1(KTestName); + } + + TestInvalidParametersBaseL(KTestName(), EDrawBitmap); + } + +/** +@SYMTestCaseID + GRAPHICS-DIRECTGDI-DRAWBITMAP-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 implementation of DrawBitmap() methods : scaling down of a normal + bitmap and scaling up of a bitmap fragment. + +@SYMTestExpectedResults + Scaled bitmap should be drawn in a target area. Valid bitmap should be created. + The bitmap should be properly scaled. This bitmap shall be compared to a reference + bitmap. +*/ +void CTDrawBitmap::TestScalingL() + { + _LIT(KTestName, "DrawBitmap-Scaling"); + if(!iRunningOomTests) + { + INFO_PRINTF1(KTestName); + } + + TInt width = iGdiTarget->SizeInPixels().iWidth; + TInt height = iGdiTarget->SizeInPixels().iHeight; + + CFbsBitmap* bitmap1 = iCheckedBoardBitmap1; + TInt bmp1Width = bitmap1->SizeInPixels().iWidth; + TInt bmp1Height = bitmap1->SizeInPixels().iHeight; + CFbsBitmap* bitmap2 = iCheckedBoardBitmap2; + TInt bmp2Width = bitmap2->SizeInPixels().iWidth; + TInt bmp2Height = bitmap2->SizeInPixels().iHeight; + + ResetGc(); + + // small bitmap - extrem magnification + TReal32 scale = 1.0f; + TReal32 scaleFactor = 1.55f; + TInt posX = 1; + for(TInt j=0; j<6; j++) + { + TSize size(static_cast(bmp1Width*scale), static_cast(bmp1Height*scale)); + TPoint pos(posX, height/4-size.iHeight/2); + + iGc->DrawBitmap(TRect(pos, size), *bitmap1); + + posX += size.iWidth+2; + scale *= scaleFactor; + } + + // large bitmap - extreme minification + + scale /= scaleFactor; + posX = 1; + for(TInt j=5; j>=0; j--) + { + TSize size(static_cast(bmp1Width*scale), static_cast(bmp1Height*scale)); + TPoint pos(posX, 3*height/4-size.iHeight/2); + + iGc->DrawBitmap(TRect(pos, size), *bitmap2); + + posX += size.iWidth+2; + scale /= scaleFactor; + } + + TESTNOERRORL(iGc->GetError()); + + TBuf<30> testName; + testName.Append(KTestName); + WriteTargetOutput(testName); + } + +/** +@SYMTestCaseID + GRAPHICS-DIRECTGDI-DRAWBITMAP-0005 + +@SYMPREQ + PREQ39 + +@SYMREQ + REQ9199 + REQ9204 + REQ9195 + REQ9201 + REQ9202 + REQ9222 + REQ9223 + REQ9236 + REQ9237 + +@SYMTestCaseDesc + Tests that a bitmap is still drawn successfully if it is deleted + right after the call to DrawBitmap() but before Finish() is called. + +@SYMTestPriority + Critical + +@SYMTestStatus + Implemented + +@SYMTestActions + For each method: + 1. Call method with valid parameters (see DrawBitmap-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 CTDrawBitmap::TestSourceBitmapCloningL() + { + _LIT(KTestName, "DrawBitmap-SourceBitmapCloning"); + if(!iRunningOomTests) + { + INFO_PRINTF1(KTestName); + } + + iTestParams.iDoCompressed = ETrue; + TestSourceBitmapCloningBaseL(KTestName(), EDrawBitmap); + iTestParams.iDoCompressed = EFalse; + TestSourceBitmapCloningBaseL(KTestName(), EDrawBitmap); + } + +/** +@SYMTestCaseID + GRAPHICS-DIRECTGDI-DRAWBITMAP-0006 + +@SYMPREQ + PREQ39 + +@SYMREQ + REQ9199 + REQ9204 + REQ9195 + REQ9201 + REQ9202 + REQ9222 + REQ9223 + REQ9236 + REQ9237 + +@SYMTestCaseDesc + Test correctness of drawing bitmaps in all possible draw modes. + +@SYMTestPriority + Critical + +@SYMTestStatus + Implemented + +@SYMTestActions + Set valid parameters (see DrawBitmap-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 of the test should be drawn blended (EDrawModePEN) + and the images drawn at the left and right sides should be drawn opaque (EDrawModeWriteAlpha). + should be copied into rendering target. Valid bitmap should be created. + This bitmap should be the same as a reference bitmap. +*/ +void CTDrawBitmap::TestDrawModeL() + { + _LIT(KTestName, "DrawBitmap-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); + + // Render column to left + iGc->SetDrawMode(DirectGdi::EDrawModeWriteAlpha); + iGc->DrawBitmap( + TRect (TPoint(0, 0), vertRectSize), + *iCheckedBoardWithAlphaBitmap); + + // Render row in center + iGc->SetDrawMode(DirectGdi::EDrawModePEN); + iGc->DrawBitmap( + TRect(TPoint(0, y1), horizRectSize), + *iCheckedBoardWithAlphaBitmap); + + // Render column to right + iGc->SetDrawMode(DirectGdi::EDrawModeWriteAlpha); + iGc->DrawBitmap( + TRect (TPoint(bmpSize.iWidth - quaterWidth, 0), vertRectSize), + *iCheckedBoardWithAlphaBitmap); + + TESTNOERRORL(iGc->GetError()); + + WriteTargetOutput(KTestName()); + } + +/** +@SYMTestCaseID + GRAPHICS-DIRECTGDI-DRAWBITMAP-0007 + +@SYMPREQ + PREQ39 + +@SYMREQ + REQ9199 + REQ9204 + REQ9195 + REQ9201 + REQ9202 + REQ9222 + REQ9223 + REQ9236 + REQ9237 + +@SYMTestCaseDesc + Test that a bitmap is drawn at the correct position when SetOrigin() is called before + the bitmap is drawn. + +@SYMTestPriority + Critical + +@SYMTestStatus + Implemented + +@SYMTestActions + Call SetOrigin(). + Call DrawBitmap(). + +@SYMTestExpectedResults + Source bitmap should be drawn at the correct position (TPoint(20,20)). Valid bitmap + should be created. This bitmap shall be compared to a reference bitmap. +*/ +void CTDrawBitmap::TestSetOriginL() + { + _LIT(KTestName, "DrawBitmap-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; + iGc->SetOrigin(TPoint(-35, 80)); + iGc->DrawBitmap(TRect(TPoint(55, -60), bitmap->SizeInPixels()), *bitmap, TRect(10, 10, 130, 130)); + TESTNOERRORL(iGc->GetError()); + + WriteTargetOutput(KTestName()); + }