// Copyright (c) 1997-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 <hal.h>

#include <e32test.h>

#include <bitdraw.h>

#include <graphics/gdi/gdiconsts.h>

#include "TAUTO.H"

#include <graphics/fbsdefs.h>

TInt PanicTestThread(TAny* aOption);

enum TPanicOption

	{

	EFirst,

	EPolygonFiller,

	EBitmapDevice,

	EDrawBmp1,

	EDrawBmp2,

	EDrawBmp3,

	EGcDevice1,

	EGcDevice2,

	EGcRegion1,

	EGcRegion2,

	EUseBrush1,

	EUseBrush2,

	EUseBrush3,

	EUseFont,

	EDrawText1,

	EDrawText2,

	EDrawText3,

	ELast

	};

CTAuto::CTAuto(CTestStep* aStep):

	CTGraphicsBase(aStep),

	iScreenDevice(NULL),

	iHalfScreen()

	{

	iTestRect[0].SetRect(21,10,22,50);

	iTestRect[1].SetRect(10,21,50,22);

	iTestRect[2].SetRect(11,20,90,30);

	iTestRect[3].SetRect(10,71,90,80);

	iTestRect[4].SetRect(20,10,31,90);

	iTestRect[5].SetRect(70,10,80,91);

	iTestRect[6].SetRect(10,10,90,90);

	iTestRect[7].SetRect(32,32,96,96);

	INFO_PRINTF1(_L(" "));

	}

CTAuto::~CTAuto()

	{

	}

void CTAuto::RunTestCaseL(const TInt aCurTestCase)

	{

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

	switch(aCurTestCase)

		{

	case 1:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025"));

		TestMem(EGray2);

		break;

	case 2:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025"));

		TestMem(EGray4);

		break;

	case 3:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025"));

		TestMem(EGray16);

		break;

	case 4:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025"));

		TestMem(EGray256);

		break;

	case 5:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025"));

		TestMem(EColor16);

		break;

	case 6:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025"));

		TestMem(EColor256);

		break;

	case 7:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025"));

		TestMem(EColor4K);

		break;

	case 8:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025"));

		TestMem(EColor64K);

		break;

	case 9:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025"));

		TestMem(EColor16M);

		break;

	case 10:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025"));

		TestMem(EColor16MU);

		break;

	case 11:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026"));

		TestMapL(EGray2,15);

		break;

	case 12:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026"));

		TestMapL(EGray4,5);

		break;

	case 13:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026"));

		TestMapL(EGray16,5);

		break;

	case 14:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026"));

		TestMapL(EGray256,5);

		break;

	case 15:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026"));

		TestMapL(EColor16,5);

		break;

	case 16:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026"));

		TestMapL(EColor256,3);

		break;

	case 17:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026"));

		TestMapL(EColor4K,5);

		break;

	case 18:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026"));

		TestMapL(EColor64K,4);

		break;

	case 19:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026"));

		TestMapL(EColor16M,4);

		break;

	case 20:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026"));

		TestMapL(EColor16MU,4);

		break;

	case 21:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027"));

		TestBmpL(EGray2);

		break;

	case 22:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027"));

		TestBmpL(EGray4);

		break;

	case 23:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027"));

		TestBmpL(EGray16);

		break;

	case 24:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027"));

		TestBmpL(EGray256);

		break;

	case 25:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027"));

		TestBmpL(EColor16);

		break;

	case 26:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027"));

		TestBmpL(EColor256);

		break;

	case 27:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027"));

		TestBmpL(EColor4K);

		break;

	case 28:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027"));

		TestBmpL(EColor64K);

		break;

	case 29:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027"));

		TestBmpL(EColor16M);

		break;

	case 30:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027"));

		TestBmpL(EColor16MU);

		break;

	case 31:		

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027"));

		TestBmpL(EColor16MA);

		break;

	case 32:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025"));

		TestMem(EColor16MA);

		break;

	case 33:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026"));

		TestMapL(EColor16MA,4);

		break;

	case 34:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0027"));

		TestBmpL(EColor16MAP);

		break;

	case 35:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0025"));

		TestMem(EColor16MAP);

		break;

	case 36:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0026"));

		TestMapL(EColor16MAP,4);

		break;

	case 37:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0029"));

		TestFadingL();

		INFO_PRINTF2(_L("TestCase %d - Passed Fading Test\r\n"),aCurTestCase);		

		break;

	case 38:

		((CTAutoStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-0028"));

		TestPanics();

		break;

	case 39: //exit 

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

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

		TestComplete();

		break;		

		}

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

	}

/**

  @SYMTestCaseID GRAPHICS-BITGDI-0025

  @SYMDEF             

  @SYMTestCaseDesc Tests the memory allocation cleanup after allocations fails 

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions sets memory allocation to fail then checks it is cleaned up correctly

  @SYMTestExpectedResults Memory should be successfully cleaned up

*/

void CTAuto::TestMem(TDisplayMode aDispMode)

	{

	LowLevelDevice(aDispMode,EFalse);

	BitmapDevice(aDispMode);

	LowLevelDevice(aDispMode,ETrue);

	ScreenDevice(aDispMode);

	INFO_PRINTF2(_L("Mode %d passed memory test\r\n"),aDispMode);

	}

void CTAuto::ScreenDevice(TDisplayMode aDispMode)

	{

	CFbsScreenDevice* device = NULL;

	for (TInt count = 1; ; count++)

		{

		__UHEAP_SETFAIL(RHeap::EDeterministic,count);

		__UHEAP_MARK;

		TRAPD(err,device = CFbsScreenDevice::NewL(_L("scdv"),aDispMode));

		if (err == KErrNotSupported)

			{

			__UHEAP_MARKEND;

			break;

			}

		else if(err == KErrNoMemory)

			{

			__UHEAP_MARKEND;

			}

		else if (err == KErrNone)

			{

			delete device;

			__UHEAP_MARKEND;

			break;

			}

		else

			{

			__UHEAP_MARKEND;

			User::Panic(_L("CFbsScreenDevice test failed "),err);

			}

		}

	__UHEAP_RESET;

	}

void CTAuto::BitmapDevice(TDisplayMode aDispMode)

	{

	CFbsBitmap bmp;

	TInt ret = bmp.Create(TSize(1,1),aDispMode);

	if (ret != KErrNone)

		User::Panic(_L("Failed to create bitmap"),ret);

	CFbsBitmapDevice* device = NULL;

	for (TInt count = 1; ; count++)

		{

		__UHEAP_SETFAIL(RHeap::EDeterministic,count);

		__UHEAP_MARK;

		TRAPD(err,device = CFbsBitmapDevice::NewL(&bmp));

		if(err == KErrNotSupported)

			{

			__UHEAP_MARKEND;

			break;

			}

		else if(err == KErrNoMemory)

			{

			__UHEAP_MARKEND;

			}

		else if (err == KErrNone)

			{

			delete device;

			__UHEAP_MARKEND;

			break;

			}

		else

			{

			__UHEAP_MARKEND;

			User::Panic(_L("CFbsBitmapDevice test failed "),err);

			}

		}

	__UHEAP_RESET;

	}

void CTAuto::LowLevelDevice(TDisplayMode aDispMode,TBool aScreen)

	{

	TInt address = NULL;

	TSize size(0,0);

	TInt ret = HAL::Get(KDefaultScreenNo, HALData::EDisplayMemoryAddress,address);

	if (ret == KErrNone)

		ret = HAL::Get(KDefaultScreenNo, HALData::EDisplayXPixels,size.iWidth);

	if (ret == KErrNone)

		ret = HAL::Get(KDefaultScreenNo, HALData::EDisplayYPixels,size.iHeight);

	if (ret != KErrNone)

		User::Panic(_L("CFbsDrawDevice test failed "),ret);

	TPckgBuf<TScreenInfoV01> s;

	s().iScreenAddressValid = ETrue;

	s().iScreenAddress = REINTERPRET_CAST(TAny*,address);

	s().iScreenSize = size;

	CFbsDrawDevice* fdd = NULL;

	for(TInt count = 1; ; count++)

		{

		__UHEAP_SETFAIL(RHeap::EDeterministic,count);

		__UHEAP_MARK;

		if (aScreen)

			{

			TRAP(ret,fdd = CFbsDrawDevice::NewScreenDeviceL(s(),aDispMode));

			}

		else

			{

			TRAP(ret, fdd = CFbsDrawDevice::NewBitmapDeviceL(s(), aDispMode, CFbsBitmap::ScanLineLength(size.iWidth, aDispMode)));

			}

		if (ret == KErrNotSupported)

			{

			__UHEAP_MARKEND;

			break;

			}

		else if (ret == KErrNoMemory)

			{

			__UHEAP_MARKEND;

			}

		else if (ret == KErrNone)

			{

			delete fdd;

			__UHEAP_MARKEND;

			break;

			}

		else

			{

			__UHEAP_MARKEND;

			User::Panic(_L("CFbsDrawDevice test failed "),ret);

			}

		}

	__UHEAP_RESET;

	}

/**

  @SYMTestCaseID GRAPHICS-BITGDI-0026

  @SYMDEF             

  @SYMTestCaseDesc Colour mapping testing

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions attempts to map four shades of grey to greys in a colourmap

  @SYMTestExpectedResults All pixels should map to the colourmap correctly

*/

//

// 

//

void CTAuto::TestMapL(TDisplayMode aDispMode,TInt aShadowFactor)

	{

	TRAPD(err,iScreenDevice = CFbsScreenDevice::NewL(_L("scdv"),aDispMode));

	if (err == KErrNotSupported)

		return;

	User::LeaveIfError(err);

	User::LeaveIfError(iScreenDevice->CreateContext(iScreenGc));

	iScreenDevice->ChangeScreenDevice(NULL);

	TestMapColors();

	TestShadowArea(aShadowFactor);

	TestFadeArea();

	delete iScreenGc;

	delete iScreenDevice;

	INFO_PRINTF2(_L("Mode %d passed colour map test\r\n"),aDispMode);

	}

void CTAuto::TestMapColors()

	{

	TRgb colormap[4];

	TRgb screencolor;

	TInt x,y;

	for (TInt count = 0; count < KNumRects; count++)

		{

		for (TInt color = 0; color < 4 && iScreenDevice->DisplayMode() != EGray2; color++)

			{

			Clear(TRgb::Gray4(color));

			TRect r(iTestRect[count]);

			colormap[0] = TRgb::Gray4(color);

			colormap[1] = TRgb::Gray4(3-color);

			colormap[2] = colormap[1];

			colormap[3] = colormap[0];

			if (iScreenDevice->DisplayMode() == EColor64K)

				{

				colormap[0] = TRgb::Color64K(colormap[0].Color64K());

				colormap[1] = TRgb::Color64K(colormap[1].Color64K());

				colormap[2] = colormap[1];

				colormap[3] = colormap[0];

				}

			iScreenGc->MapColors(r,colormap,2);

			for(y=0;y<r.iTl.iY;y++)

				for(x=0;x<100;x++)

					{

					iScreenDevice->GetPixel(screencolor,TPoint(x,y));

					TEST(screencolor.Gray4() == color);

					}

			for(y=r.iTl.iY;y<r.iBr.iY;y++)

				for(x=0;x<r.iTl.iX;x++)

					{

					iScreenDevice->GetPixel(screencolor,TPoint(x,y));

					TEST(screencolor.Gray4() == color);

					}

			for(y=r.iTl.iY;y<r.iBr.iY;y++)

				for(x=r.iBr.iX;x<100;x++)

					{

					iScreenDevice->GetPixel(screencolor,TPoint(x,y));

					TEST(screencolor.Gray4() == color);

					}

			for(y=r.iBr.iY;y<100;y++)

				for(x=0;x<100;x++)

					{

					iScreenDevice->GetPixel(screencolor,TPoint(x,y));

					TEST(screencolor.Gray4() == color);

					}

			for(y=r.iTl.iY;y<r.iBr.iY;y++)

				for(x=r.iTl.iX;x<r.iBr.iX;x++)

					{

					iScreenDevice->GetPixel(screencolor,TPoint(x,y));

					TEST(screencolor.Gray4() == 3-color);

					}

			iScreenGc->MapColors(r,colormap,2);

			for(y=r.iTl.iY;y<r.iBr.iY;y++)

				for(x=r.iTl.iX;x<r.iBr.iX;x++)

					{

					iScreenDevice->GetPixel(screencolor,TPoint(x,y));

					TEST(screencolor.Gray4() == color);

					}

			}

		}

	}

void CTAuto::TestShadowArea(TInt aShadowFactor)

	{

	TRgb screencolor;

	TInt x,y;

	for (TInt count = 0; count < KNumRects; count++)

		{

		for (TInt color = 0; color < 4; color++)

			{

			if (color > 0 && iScreenDevice->DisplayMode() == EGray2)

				color = 3;

			Clear(TRgb::Gray4(color));

			TRect r(iTestRect[count]);

			TRegionFix<1> reg(r);

			iScreenGc->ShadowArea(&reg);

			for(y=0;y<r.iTl.iY;y++)

				for(x=0;x<100;x++)

					{

					iScreenDevice->GetPixel(screencolor,TPoint(x,y));

					TEST(screencolor.Gray4() == color);

					}

			for(y=r.iTl.iY;y<r.iBr.iY;y++)

				for(x=0;x<r.iTl.iX;x++)

					{

					iScreenDevice->GetPixel(screencolor,TPoint(x,y));

					TEST(screencolor.Gray4() == color);