// 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()));

	}