// Copyright (c) 2003-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 <random.h>

#include <s32file.h>

#include <e32math.h>

#include <hal.h>

#include <s32mem.h>

#include <graphics/gdi/gdiconsts.h>

#include <e32cmn.h>

#include "BITPANIC.H"

#include "TDefect2.h"

#include "fbsmessage.h"

//===================================================================

//In order to test multiple screens creation process on the Emulator, 

//you have to extend your epoc.ini file with the following lines

//_NewScreen_

//ScreenWidth 640

//ScreenHeight 480

//===================================================================

//

//

//Globals

LOCAL_D RFs		FServSession;

//

//

//Test file names

_LIT(KArchiveFileName, "C:\\FbsBitGcArchive.dat");

//

//

//Create/Destroy test environment global functions

//Delete "aFullName" file.

LOCAL_C void DeleteDataFile(const TDesC& aFullName)

	{

	RFs fsSession;

	TInt err = fsSession.Connect();

	if(err == KErrNone)

		{

		TEntry entry;

		if(fsSession.Entry(aFullName, entry) == KErrNone)

			{

			RDebug::Print(_L("Deleting \"%S\" file.\n"), &aFullName);

			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);

			if(err != KErrNone) 

				{

				RDebug::Print(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);

				}

			err = fsSession.Delete(aFullName);

			if(err != KErrNone) 

				{

				RDebug::Print(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);

				}

			}

		fsSession.Close();

		}

	else

		{

		RDebug::Print(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);

		}

	}

//

CTDefect2::CTDefect2(CTestStep* aStep):

	CTGraphicsBase(aStep),

	iScrDev(NULL),

	iGc(NULL),

	iSize(0, 0),

	iCurrentMode(ENone),

	iBitmap(NULL),

	iBmpDevice(NULL)

	{

	}

CTDefect2::~CTDefect2()

	{

	DestroyFont();

	DeleteBitmap();

	DeleteGraphicsContext();

	DeleteBitmapDevice();

	DeleteScreenDevice();

	}

void CTDefect2::ConstructL()

	{

	User::LeaveIfError(::FServSession.Connect());

	}

void CTDefect2::RunTestCaseL(TInt aCurTestCase)

	{

	((CTDefect2Step*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

	_LIT(KTest1,"SubTest %d: DEF039237");

	_LIT(KTest2,"SubTest %d: DEF039331");

	_LIT(KTest3,"SubTest %d: DEF039650");

	_LIT(KTest4,"SubTest %d: CFbsBitmap::GetPixel() performance");

	_LIT(KTest5,"SubTest %d: Rotate/Move text");

	_LIT(KTest6,"SubTest %d: SwapWidthAndHeight");

	_LIT(KTest7,"SubTest %d: Create multiple screens");

	_LIT(KTest8,"SubTest %d: Clear with non-zero origin");

	_LIT(KTest9,"SubTest %d: DEF115395: DrawBitmap & DrawBitmapMasked with a sourceRect out of the Bitmap bounds");

	_LIT(KTest10,"SubTest %d: INC119063: General test CopyRect rewrite for low color depth (8,4,2, pixels per byte)");

	_LIT(KTest11,"SubTest %d: INC120917: Dirty Mask Bitmap not remapped in BitBltMasked");

	_LIT(KTest12,"SubTest %d: Zero-sized brush pattern bitmaps");

	_LIT(KTest13,"SubTest %d: CopyRect with non-trivial alpha");

	_LIT(KTest14,"SubTest %d: INC119063: CopyRect reading past end of bitmap data at unallocated pages");

	_LIT(KTest15,"SubTest %d: INC128813 : CFbsBitGc::InternalizeL handle duplicate fail testing");

	_LIT(KTest16,"SubTest %d: DEF132331 : CFbsScreenDevice PixelsToTwips conversions faulty with large inputs");

	_LIT(KTest17,"SubTest %d: DEF137103: CFbsBitmapDevice::SetBits() should check bitmap size");

	switch(aCurTestCase)

		{

	case 1:

		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0066"));

		INFO_PRINTF2(KTest1,aCurTestCase);

		DEF039237L();

		break;

	case 2:

		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0067"));

		INFO_PRINTF2(KTest2,aCurTestCase);

		DEF039331L();

		break;

	case 3:

		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0068"));

		INFO_PRINTF2(KTest3,aCurTestCase);

		DEF039650L();

		break;

	case 4:

		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0069"));

		INFO_PRINTF2(KTest4,aCurTestCase);

		GetPixelPerformance1L();

		break;

	case 5:

		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0070"));

		INFO_PRINTF2(KTest5,aCurTestCase);

		RotateMoveTextL();

		break;

	case 6:

		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0071"));

		INFO_PRINTF2(KTest6,aCurTestCase);

		SwapWidthAndHeightL();

		break;

	case 7:

		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0072"));

		INFO_PRINTF2(KTest7,aCurTestCase);

		CreateScreenDeviceL();

		break;

	case 8:

		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0073"));

		INFO_PRINTF2(KTest8,aCurTestCase);

		NonZeroOriginClearL();

		break;

	case 9:

		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0097"));

		INFO_PRINTF2(KTest9,aCurTestCase);

		DEF115395L();

		break;

	case 10:

		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0099"));

		INFO_PRINTF2(KTest10,aCurTestCase);

		ExerciseCopyRect();

		break;

	case 11:

		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0101"));

		INFO_PRINTF2(KTest11,aCurTestCase);

		TestDirtyMaskBitmapL();

		break;

	case 12:

		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0108"));

		INFO_PRINTF2(KTest12,aCurTestCase);

		ZeroSizedPatternBrushL();

		break;

	case 13:

		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0113"));

		INFO_PRINTF2(KTest13,aCurTestCase);

		CopyRectAlphaL();

		break;

	case 14: 	

		//Note: This test generates panic windows... you may need to put your test before it.

		//They will be closed at the end of the test set, but they may get in the way of your next test, sorry.

		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0098"));

		INFO_PRINTF2(KTest14,aCurTestCase);

		CopyRectReadOutsideBitmap();

		break;

	case 15:

		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0110"));

		INFO_PRINTF2(KTest15,aCurTestCase);

		CFbsBitGcInternalizeLFailL();

		break;

	case 16:

		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0111"));

		INFO_PRINTF2(KTest16,aCurTestCase);

		PixelsToTwipsConversionCheck();

		break;

	case 17:

		((CTDefect2Step*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0112"));

		INFO_PRINTF2(KTest17,aCurTestCase);

		TestSetBitsL();

		break;

    case 18:

        INFO_PRINTF1(_L("PDEF141192: test CFbsBitGc::DrawBitmapMasked()"));

        INFO_PRINTF1(_L("Test Red Channel"));

        TestMaskForSelectedValuesL(0);

        INFO_PRINTF1(_L("Test Green Channel"));

        TestMaskForSelectedValuesL(1);

        INFO_PRINTF1(_L("Test Blue Channel"));

        TestMaskForSelectedValuesL(2);

        break;

	//Insert tests here

	case 19:

		((CTDefect2Step*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

		((CTDefect2Step*)iStep)->CloseTMSGraphicsStep();

		TestComplete();

		break;

		}

	((CTDefect2Step*)iStep)->RecordTestResultL();

	}

/**

 * @SYMTestCaseID GRAPHICS-BITGDI-0101

 *

 * @SYMDEF INC120917

 *

 * @SYMTestCaseDesc If mask bitmap has been dirtied (by resize/compress) 

 * 						then bitbltmasked should not read old memory contents

 *

 * @SYMTestPriority Normal

 *

 * @SYMTestStatus Implemented

 *

 * @SYMTestActions Create image and mask bitmap with  pattern and blit them for reference

 * 					create duplicate handle 

 * 					resize the mask on duplicate

 * 					verify that blit produces same result for same area on larger mask 

 * 					and change pattern

 * 					blit using duplicate handle and source

 * 					blit using original handle and source

 * 						in defect scenario these results are different (original same as reference)

 * 						in fix scenario they should be same (different to reference)

 * 					revalidate original handle reblit and verify now correct

 * 

 * 					repeat above steps: 

 * 					(this proves duplicate change causes original flag, not just duplication)

 * 					resize the mask on duplicate

 * 					verify that blit produces same result for same area on larger mask 

 * 					and change pattern

 * 					blit using duplicate handle and source

 * 					blit using original handle and source

 * 						in defect scenario these results are different (original same as reference)

 * 						in fix scenario they should be same (different to reference)

 * 					revalidate original handle reblit and verify now correct

 */	

void  CTDefect2::TestDirtyMaskBitmapL()

	{

	const TInt 	KWidth=120;

	const TInt	KHeight=50;

	const TInt	KBigger=50;

	enum

		{

		EStepBefore=0,

		EStepVerifyDupGrow,

		EStepDupDiffAfterRefill,

		EStepOriginalDiffAfterRefill,

		EStepOriginalDiffAfterRefillAndGetAddress,

		EStepDupDiffAfterRefill2,

		EStepOriginalDiffAfterRefill2,

		ENumSteps

		};

	TInt pushcount=0;

	//set up the target

	CFbsBitmap* targetBmp=new(ELeave) CFbsBitmap();

	CleanupStack::PushL(targetBmp);pushcount++;	

	User::LeaveIfError(targetBmp->Create(TSize(KWidth,KHeight*ENumSteps), EColor16MU));	

	CFbsBitmapDevice* bmpDevice=CFbsBitmapDevice::NewL(targetBmp);

	CleanupStack::PushL(bmpDevice);pushcount++;	

	CBitmapContext* bmpContext;

	User::LeaveIfError(bmpDevice->CreateBitmapContext(bmpContext));

	CleanupStack::PushL(bmpContext);pushcount++;		

	bmpContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

	bmpContext->SetBrushColor(KRgbRed);	

	bmpContext->Clear();

	//set up source and mask

	CFbsBitmap* sourceBmp=new(ELeave) CFbsBitmap();

	CleanupStack::PushL(sourceBmp);pushcount++;		

	User::LeaveIfError(sourceBmp->Create(TSize(KWidth,KHeight), EColor16MU));

	TUint32* sourceData=sourceBmp->DataAddress();

	TInt 	 sourceLength=(sourceBmp->DataStride()>>2)*KHeight;

	CFbsBitmap* maskBmp=new(ELeave) CFbsBitmap();

	CleanupStack::PushL(maskBmp);pushcount++;		

	User::LeaveIfError(maskBmp->Create(TSize(KWidth,KHeight), EGray2));

	TUint32* maskDataStart=maskBmp->DataAddress();

	TInt 	 maskLength=(maskBmp->DataStride()>>2)*KHeight;

	TUint32* targetData=targetBmp->DataAddress();

	TInt targetCopySize=((targetBmp->DataStride()+3)>>2)*KHeight;

	TUint32 blueint=KRgbBlue.Color16MU();

	for (TInt fillIndex=0;fillIndex<sourceLength;fillIndex++)

		{

		sourceData[fillIndex]=blueint;

		}

	TInt maskPattern=0x12345678;

	for (TInt fillIndex=0;fillIndex<maskLength;fillIndex++)

		{

		maskDataStart[fillIndex]=maskPattern;

		}

	//Initial result of blit operation

	bmpContext->BitBltMasked(TPoint(0,KHeight*EStepBefore),sourceBmp,TSize(KWidth,KHeight),maskBmp,EFalse);

	//duplicate the mask handle

	CFbsBitmap* maskBmpDup=new(ELeave) CFbsBitmap();

	CleanupStack::PushL(maskBmpDup);pushcount++;	

	maskBmpDup->Duplicate(maskBmp->Handle());

	TUint32* maskDataDup=maskBmpDup->DataAddress();

	TEST(maskDataDup==maskDataStart);	//not expected to fail

	//resize duplicate handle bigger

	maskBmpDup->Resize(TSize(KWidth+KBigger,KHeight));

	maskDataDup=maskBmpDup->DataAddress();

	TEST(maskDataDup!=maskDataStart);	//not expected to fail

	//At this point the duplicate handle is referencing a different address to the original handle.

	//With the defect in place this remains uncorrected, 

	//and is demonstrated by comparing the output contents of blitting using each of the handles. 

	//verify that the resizing of the mask preserved the original mask data, so the resize has no effect on small area blit

	bmpContext->BitBltMasked(TPoint(0,KHeight*EStepVerifyDupGrow),sourceBmp,TSize(KWidth,KHeight),maskBmpDup,EFalse);

	//If this cmp fails: blit or resize is not working properly on the duplicate handle - not caused by this defect (very unexpected)

	TEST(0==Mem::Compare((TUint8*)(targetData),targetCopySize*4,(TUint8*)(targetData+targetCopySize*EStepVerifyDupGrow),targetCopySize*4));

	//Change the mask using the address in the duplicate handle

	//As we want to fill the whole mask with a known pattern we need to recalculate the mask size.

	TInt newMaskLength=(maskBmpDup->DataStride()>>2)*KHeight;

	maskPattern=0xAAAAAAAA;

	for (TInt fillIndex=0;fillIndex<newMaskLength;fillIndex++)

		{	

		maskDataDup[fillIndex]=maskPattern;

		}

	//compare the results of blitting using this new mask using each of the two handles to the same mask

	bmpContext->BitBltMasked(TPoint(0,KHeight*EStepDupDiffAfterRefill),sourceBmp,TSize(KWidth,KHeight),maskBmpDup,EFalse);

	//This blit should not crash, even if the defect is present because the previous sized bitmap should not be released until all references have been updated.

	bmpContext->BitBltMasked(TPoint(0,KHeight*EStepOriginalDiffAfterRefill),sourceBmp,TSize(KWidth,KHeight),maskBmp,EFalse);

	//If this cmp fails: data change had no effect for duplicate handle (very unexpected)

	TEST(0!=Mem::Compare((TUint8*)(targetData),targetCopySize*4,(TUint8*)(targetData+targetCopySize*EStepDupDiffAfterRefill),targetCopySize*4));

	//Check that the result of both blits is the same.

	//If this cmp fails: defect is demonstrated. This is the main defect demonstration test.

	TEST(0==Mem::Compare((TUint8*)(targetData+targetCopySize*EStepDupDiffAfterRefill),targetCopySize*4,(TUint8*)(targetData+targetCopySize*EStepOriginalDiffAfterRefill),targetCopySize*4));

	//This revalidates the original handle, hiding the defect

	TUint32* maskDataRevalid=maskBmp->DataAddress();

	TEST(maskDataDup==maskDataRevalid);

	//This blit should not crash as the original handle has now been revalidated to point to allocated data. 

	bmpContext->BitBltMasked(TPoint(0,KHeight*EStepOriginalDiffAfterRefillAndGetAddress),sourceBmp,TSize(KWidth,KHeight),maskBmp,EFalse);

	//If this cmp fails: original was not revalidated by DataAddress - content is not same as duplicate

	TEST(0==Mem::Compare((TUint8*)(targetData+targetCopySize*EStepDupDiffAfterRefill),targetCopySize*4,(TUint8*)(targetData+targetCopySize*EStepOriginalDiffAfterRefillAndGetAddress),targetCopySize*4));

	//Extra testing... do we handle situation where the duplicated handle is changed more than once?

	//Basically repeats the test sequence above.

	//Repeat the resize even bigger using duplicate handle

	//resize duplicate handle bigger

	maskBmpDup->Resize(TSize(KWidth+KBigger,KHeight+KBigger));

	maskDataDup=maskBmpDup->DataAddress();

	TEST(maskDataDup!=maskDataRevalid);

	//Change the mask using the address in the duplicate handle

	//As we want to fill the whole mask with a known pattern we need to recalculate the mask size.

	newMaskLength=(maskBmpDup->DataStride()>>2)*(KHeight+KBigger);

	maskPattern=0x55555555;

	for (TInt fillIndex=0;fillIndex<newMaskLength;fillIndex++)

		{	

		maskDataDup[fillIndex]=maskPattern;

		}

	//compare the results of blitting using this new mask using each of the two handles to the same mask

	bmpContext->BitBltMasked(TPoint(0,KHeight*EStepDupDiffAfterRefill2),sourceBmp,TSize(KWidth,KHeight),maskBmpDup,EFalse);

	//This blit should not crash, even if the defect is present because the previous sized bitmap should not be released until all references have been updated.

	//If it does crash then this demonstrates the defect in that the original address is being used in error and has been freed and paged out

	bmpContext->BitBltMasked(TPoint(0,KHeight*EStepOriginalDiffAfterRefill2),sourceBmp,TSize(KWidth,KHeight),maskBmp,EFalse);

	//If this cmp fails: data change  had no effect for duplicate handle (very unexpected)

	TEST(0!=Mem::Compare((TUint8*)(targetData+targetCopySize*EStepDupDiffAfterRefill),targetCopySize*4,(TUint8*)(targetData+targetCopySize*EStepDupDiffAfterRefill2),targetCopySize*4));

	//Check that the result of both blits is the same.

	//If this cmp fails: defect is demonstrated. This is the main defect demonstration test.

	TEST(0==Mem::Compare((TUint8*)(targetData+targetCopySize*EStepDupDiffAfterRefill2),targetCopySize*4,(TUint8*)(targetData+targetCopySize*EStepOriginalDiffAfterRefill2),targetCopySize*4));

	CleanupStack::PopAndDestroy(pushcount,targetBmp);

	}

 /**

  * @SYMTestCaseID GRAPHICS-BITGDI-0097

  *

  * @SYMDEF DEF115395

  *

  * @SYMTestCaseDesc Robustness in the CFbsBitGc::DrawBitmap & CFbsBitGc::DrawBitmapMasked functions:

  * when a sourceRect is used to capture only a part of the bitmap,

  * we have to make sure that the sourceRect is not out of border of the image!

  * (if it's the case, we just draw nothing)

  *

  * @SYMTestPriority Normal

  *

  * @SYMTestStatus Implemented

  *

  * @SYMTestActions We create a 8x8 KRgbRed Bitmap and 8x8 Mask (color TRgb(30, 30, 30))

  * We try the 2 functions CFbsBitGc::DrawBitmap and CFbsBitGc::DrawBitmapMasked

  * with a out of bounds source rectangle on a white output image.

  * The output should stay all white.                

  *

  */  

void CTDefect2::DEF115395L()

	{

	const TSize size=TSize(8, 8);

	const TPoint origin=TPoint(0, 0);

	const TPoint vector=TPoint(2, 2);

	const TRect destRect=TRect(origin, size);

	const TRect srcRect=TRect(origin-vector, size);

	const TBool invertMask=EFalse;

	const TRgb maskColor=TRgb(30, 30, 30);

	TBool succeed=ETrue;

	// Bitmap creation

	CFbsBitmap* myBmp=new(ELeave) CFbsBitmap();

	CleanupStack::PushL(myBmp);

	User::LeaveIfError(myBmp->Create(size, EColor16MU));

	CFbsBitmapDevice* bmpDevice=CFbsBitmapDevice::NewL(myBmp);

	CleanupStack::PushL(bmpDevice);

	CBitmapContext* bmpContext;

	User::LeaveIfError(bmpDevice->CreateBitmapContext(bmpContext));

	CleanupStack::PushL(bmpContext);

	bmpContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

	bmpContext->SetBrushColor(KRgbRed);

	bmpContext->Clear();

	CleanupStack::PopAndDestroy(2, bmpDevice); // bmpContext, bmpDevice

	// Mask creation

	CFbsBitmap* myMaskBmp=new(ELeave) CFbsBitmap();

	CleanupStack::PushL(myMaskBmp);

	User::LeaveIfError(myMaskBmp->Create(size, EGray256));

	bmpDevice = CFbsBitmapDevice::NewL(myMaskBmp);

	CleanupStack::PushL(bmpDevice);     

	User::LeaveIfError(bmpDevice->CreateBitmapContext(bmpContext));

	CleanupStack::PushL(bmpContext);

	bmpContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

	bmpContext->SetBrushColor(maskColor);

	bmpContext->Clear();

	CleanupStack::PopAndDestroy(2, bmpDevice); // bmpContext, bmpDevice

	// Output Image

	CFbsBitmap* outputImg=new(ELeave) CFbsBitmap();

	CleanupStack::PushL(outputImg);

	User::LeaveIfError(outputImg->Create(size, EColor16MU));

	bmpDevice = CFbsBitmapDevice::NewL(outputImg);

	CleanupStack::PushL(bmpDevice);

	User::LeaveIfError(bmpDevice->CreateBitmapContext(bmpContext));

	CleanupStack::PushL(bmpContext);

	bmpContext->SetBrushStyle(CGraphicsContext::ESolidBrush);

	bmpContext->SetBrushColor(KRgbWhite);

	bmpContext->Clear();

	bmpContext->DrawBitmapMasked(destRect, myBmp, srcRect, myMaskBmp, invertMask);   

	TRgb pixelColor;

	TInt ii,jj;

	for (ii=0;ii<=size.iWidth;ii++)

		{

		for (jj=0;jj<=size.iHeight;jj++)

			{

			outputImg->GetPixel(pixelColor, TPoint(ii,jj));

			if (pixelColor!=KRgbWhite)

				{

				succeed=EFalse;

				break;

				}

			}

		if (!succeed)

			{

			break;

			}

		}

	bmpContext->Clear();

	bmpContext->DrawBitmap(destRect, myBmp, srcRect);

	for (ii=0;ii<=size.iWidth;ii++)

		{

		for (jj=0;jj<=size.iHeight;jj++)

			{

			outputImg->GetPixel(pixelColor, TPoint(ii,jj));

			if (pixelColor!=KRgbWhite)

				{

				succeed=EFalse;

				break;

				}

			}

		if (!succeed)

			{

			break;

			}

		}

	TEST(succeed);

	CleanupStack::PopAndDestroy(5);