--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsdeviceinterface/bitgdi/tbit/TAUTO.CPP	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,1140 @@
+// 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);
+					}
+
+			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.Gray16() == Max(0,color * 5 - aShadowFactor));
+					}
+			}
+		}
+	}
+
+void CTAuto::TestFadeArea()
+	{
+	DoTestFadeArea(0,255);
+	DoTestFadeArea(0,127);
+	DoTestFadeArea(128,255);
+	DoTestFadeArea(64,192);
+	}
+
+void CTAuto::DoTestFadeArea(TUint8 aBlackMap,TUint8 aWhiteMap)
+	{
+	iScreenGc->SetFadingParameters(aBlackMap,aWhiteMap);
+
+	DoTestFadeArea(KRgbWhite,FadeColor(KRgbWhite,aBlackMap,aWhiteMap));
+	DoTestFadeArea(KRgbBlack,FadeColor(KRgbBlack,aBlackMap,aWhiteMap));
+
+	if (iScreenDevice->DisplayMode() == EGray2)
+		return; // EGray2 mode dithers so only check black & white
+
+	DoTestFadeArea(KRgbGray,FadeColor(KRgbGray,aBlackMap,aWhiteMap));
+	DoTestFadeArea(KRgbDarkGray,FadeColor(KRgbDarkGray,aBlackMap,aWhiteMap));
+
+	if (iScreenDevice->DisplayMode() == EGray4)
+		return; // EGray4 mode dithers so only check four gray scales
+
+	DoTestFadeArea(KRgbRed,FadeColor(KRgbRed,aBlackMap,aWhiteMap));
+	DoTestFadeArea(KRgbGreen,FadeColor(KRgbGreen,aBlackMap,aWhiteMap));
+	DoTestFadeArea(KRgbBlue,FadeColor(KRgbBlue,aBlackMap,aWhiteMap));
+	}
+
+void CTAuto::DoTestFadeArea(TRgb aColor,TRgb aFadedColor)
+	{
+	TRgb screencolor;
+	TInt x,y;
+
+	for (TInt count = 0; count < KNumRects; count++)
+		{
+		Clear(aColor);
+		aColor = MapColorToDisplayMode(aColor);
+
+		TRect r(iTestRect[count]);
+		TRegionFix<1> reg(r);
+
+		iScreenGc->FadeArea(&reg);
+
+		for(y=0;y<r.iTl.iY;y++)
+			for(x=0;x<100;x++)
+				{
+				iScreenDevice->GetPixel(screencolor,TPoint(x,y));
+				TEST(screencolor == aColor);
+				}
+
+		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 == aColor);
+				}
+
+		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 == aColor);
+				}
+
+		for(y=r.iBr.iY;y<100;y++)
+			for(x=0;x<100;x++)
+				{
+				iScreenDevice->GetPixel(screencolor,TPoint(x,y));
+				TEST(screencolor == aColor);
+				}
+
+		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 == aFadedColor);
+				}
+		}
+	}
+
+TRgb CTAuto::FadeColor(TRgb aColor,TInt aBlackMap,TInt aWhiteMap)
+	{
+	aColor = MapColorToDisplayMode(aColor);
+
+	TInt red = ((aColor.Red() * (aWhiteMap - aBlackMap + 1)) >> 8) + aBlackMap;
+	TInt green = ((aColor.Green() * (aWhiteMap - aBlackMap + 1)) >> 8) + aBlackMap;
+	TInt blue = ((aColor.Blue() * (aWhiteMap - aBlackMap + 1)) >> 8) + aBlackMap;
+
+	aColor = TRgb(red,green,blue);
+
+	aColor = MapColorToDisplayMode(aColor);
+
+	return aColor;
+	}
+
+TRgb CTAuto::MapColorToDisplayMode(TRgb aColor)
+	{
+	switch (iScreenDevice->DisplayMode())
+		{
+	case EGray2:
+		aColor = TRgb::Gray2(aColor.Gray2());
+		break;
+	case EGray4:
+		aColor = TRgb::Gray4(aColor.Gray4());
+		break;
+	case EGray16:
+		aColor = TRgb::Gray16(aColor.Gray16());
+		break;
+	case EGray256:
+		aColor = TRgb::Gray256(aColor.Gray256());
+		break;
+	case EColor16:
+		aColor = TRgb::Color16(aColor.Color16());
+		break;
+	case EColor256:
+		aColor = TRgb::Color256(aColor.Color256());
+		break;
+	case EColor4K:
+		aColor = TRgb::Color4K(aColor.Color4K());
+		break;
+	case EColor64K:
+		aColor = TRgb::Color64K(aColor.Color64K());
+		break;
+	case EColor16M:
+		aColor = TRgb::Color16M(aColor.Color16M());
+		break;
+	case EColor16MU:
+		aColor = TRgb::Color16MU(aColor.Color16MU());
+		break;
+	case EColor16MA:
+		aColor = TRgb::Color16MA(aColor.Color16MA());
+		break;
+	case EColor16MAP:
+		aColor = TRgb::Color16MAP(aColor.Color16MAP());
+		break;
+	default:
+		User::Invariant();
+		break;
+		}
+
+	return aColor;
+	}
+
+void CTAuto::Clear(TRgb aColor)
+	{
+	iScreenGc->SetBrushColor(aColor);
+	iScreenGc->Clear();
+	}
+
+
+/**
+  @SYMTestCaseID GRAPHICS-BITGDI-0027
+ 
+  @SYMDEF             
+
+  @SYMTestCaseDesc tests drawing a bitmap to the screen in various colour modes
+   
+  @SYMTestPriority High
+
+  @SYMTestStatus Implemented
+
+  @SYMTestActions draws to a bitmaps gc and the screens gc then compares the result on a per pixel basis
+ 
+  @SYMTestExpectedResults bitmap and screen should be identical
+*/
+//
+// Bitmap drawing testing
+//
+void CTAuto::TestBmpL(TDisplayMode aDispMode)
+	{
+	TRAPD(err,iScreenDevice = CFbsScreenDevice::NewL(_L("scdv"),aDispMode));
+	if (err == KErrNotSupported)
+		return;
+	User::LeaveIfError(err);
+	iScreenDevice->ChangeScreenDevice(NULL);
+	User::LeaveIfError(iScreenDevice->CreateContext((CGraphicsContext*&)iScreenGc));
+
+	iHalfScreen = iScreenDevice->SizeInPixels();
+	iHalfScreen.iWidth /= 2;
+
+	CFbsBitmap bitmap;
+	User::LeaveIfError(bitmap.Create(iHalfScreen,aDispMode));
+
+	CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL(&bitmap);
+	CleanupStack::PushL(bitmapDevice);
+	CFbsBitGc* bitmapGc = NULL;
+	User::LeaveIfError(bitmapDevice->CreateContext(bitmapGc));
+	CleanupStack::PushL(bitmapGc);
+
+	TestGc(iScreenGc,iHalfScreen);
+	TestGc(bitmapGc,iHalfScreen);
+
+	iScreenGc->BitBlt(TPoint(iHalfScreen.iWidth,0),&bitmap);
+
+	TRgb* left = new(ELeave) TRgb[iHalfScreen.iWidth];
+	TRgb* right = new(ELeave) TRgb[iHalfScreen.iWidth];
+
+	TPtr8 leftBuf(REINTERPRET_CAST(TUint8*,left),iHalfScreen.iWidth * sizeof(TRgb),iHalfScreen.iWidth * sizeof(TRgb));
+	TPtr8 rightBuf(REINTERPRET_CAST(TUint8*,right),iHalfScreen.iWidth * sizeof(TRgb),iHalfScreen.iWidth * sizeof(TRgb));
+
+	for (TInt row = 0; row < iHalfScreen.iHeight; row++)
+		{
+		iScreenDevice->GetScanLine(leftBuf,TPoint(0,row),iHalfScreen.iWidth,ERgb);
+		bitmap.GetScanLine(rightBuf,TPoint(iHalfScreen.iWidth,row),iHalfScreen.iWidth,ERgb);
+
+		TRgb* leftPtr = left;
+		TRgb* rightPtr = right;
+
+		for (TInt col = 0; col < iHalfScreen.iWidth; col++)
+			{
+			if (leftPtr[0] != rightPtr[0])
+				User::Panic(_L("Screen/bitmap mismatch!"),KErrGeneral);
+
+			leftPtr++;
+			rightPtr++;
+			}
+		}
+
+	delete[] left;
+	delete[] right;
+	CleanupStack::PopAndDestroy(2); // bitmapGc,bitmapDevice
+	delete iScreenGc;
+	delete iScreenDevice;
+
+	iScreenDevice = NULL;
+	iScreenGc = NULL;
+
+	bitmap.Reset();
+
+	INFO_PRINTF2(_L("Mode %d passed bitmap drawing test\r\n"),aDispMode);
+	}
+
+void CTAuto::TestGc(CFbsBitGc* aGc,const TSize& aSize)
+	{
+	aGc->SetPenStyle(CGraphicsContext::ENullPen);
+	aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+	aGc->SetBrushColor(KRgbBlack);
+	aGc->DrawRect(TRect(TPoint(),iScreenDevice->SizeInPixels()));
+	aGc->SetPenStyle(CGraphicsContext::ESolidPen);
+	aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+
+	Colors(aGc,aSize);
+	Shapes(aGc,aSize);
+	}
+
+void CTAuto::Colors(CFbsBitGc* aGc,const TSize& aSize)
+	{
+	TInt i=0;
+	TInt w=aSize.iWidth;
+	TInt h=aSize.iHeight;
+	TInt xinc = w / 16;
+	TInt lx = 0;
+	TInt rx = xinc - 1;
+
+	for(i=0;i<256;i++)
+		{
+		aGc->SetPenColor(TRgb::Gray256(i));
+		aGc->SetBrushColor(TRgb::Gray256(i));
+		aGc->DrawRect(TRect(lx,i*h/256,rx,(i+1)*h/256));
+		}
+	lx += xinc;
+	rx += xinc;
+	for(i=0;i<16;i++)
+		{
+		aGc->SetPenColor(TRgb::Gray16(i));
+		aGc->SetBrushColor(TRgb::Gray16(i));
+		aGc->DrawRect(TRect(lx,i*h/16,rx,(i+1)*h/16));
+		}
+	lx += xinc;
+	rx += xinc;
+	for(i=0;i<4;i++)
+		{
+		aGc->SetPenColor(TRgb::Gray4(i));
+		aGc->SetBrushColor(TRgb::Gray4(i));
+		aGc->DrawRect(TRect(lx,i*h/4,rx,(i+1)*h/4));
+		}
+	lx += xinc;
+	rx += xinc;
+	for(i=0;i<256;i++)
+		{
+		aGc->SetPenColor(TRgb(i,0,0));
+		aGc->SetBrushColor(TRgb(i,0,0));
+		aGc->DrawRect(TRect(lx,i*h/256,rx,(i+1)*h/256));
+		}
+	lx += xinc;
+	rx += xinc;
+	for(i=0;i<256;i++)
+		{
+		aGc->SetPenColor(TRgb(0,i,0));
+		aGc->SetBrushColor(TRgb(0,i,0));
+		aGc->DrawRect(TRect(lx,i*h/256,rx,(i+1)*h/256));
+		}
+	lx += xinc;
+	rx += xinc;
+	for(i=0;i<256;i++)
+		{
+		aGc->SetPenColor(TRgb(0,0,i));
+		aGc->SetBrushColor(TRgb(0,0,i));
+		aGc->DrawRect(TRect(lx,i*h/256,rx,(i+1)*h/256));
+		}
+	lx += xinc;
+	rx += xinc;
+	for(i=0;i<256;i++)
+		{
+		aGc->SetPenColor(TRgb::Color256(i));
+		aGc->SetBrushColor(TRgb::Color256(i));
+		aGc->DrawRect(TRect(lx,i*h/256,rx,(i+1)*h/256));
+		}
+	lx += xinc;
+	rx += xinc;
+	for(i=0;i<16;i++)
+		{
+		aGc->SetPenColor(TRgb::Color16(i));
+		aGc->SetBrushColor(TRgb::Color16(i));
+		aGc->DrawRect(TRect(lx,i*h/16,rx,(i+1)*h/16));
+		}
+
+	}
+
+void CTAuto::Shapes(CFbsBitGc* aGc,const TSize& aSize)
+	{
+	aGc->SetBrushStyle(CGraphicsContext::ENullBrush);
+	aGc->SetPenColor(KRgbWhite);
+
+	TInt w=aSize.iWidth;
+	TInt h=aSize.iHeight;
+
+	CArrayFixFlat<TPoint>* poly=new(ELeave) CArrayFixFlat<TPoint>(4);
+	TInt a=w>>1;
+	TInt b=a+(a>>1);
+	TPoint temppt(w*5/8,h/48);
+	poly->AppendL(temppt);
+	temppt.SetXY(b-1,h*11/48);
+	poly->AppendL(temppt);
+	temppt.SetXY(a+1,h*11/48);
+	poly->AppendL(temppt);
+	temppt.SetXY(w*5/8,h/48);
+	poly->AppendL(temppt);
+	aGc->DrawPolyLine(poly);
+	delete poly;
+
+	aGc->DrawRect(TRect(a+1,h*7/24,b,h*12/24));
+	aGc->DrawRoundRect(TRect(a+1,h*13/24,b,h*18/24),TSize(w/16,h/12));
+	aGc->DrawEllipse(TRect(a+1,h*19/24,b,h*24/24));
+	aGc->DrawArc(TRect(b+1,h*1/24,w-1,h*6/24),TPoint(w*15/16,h*6/24),TPoint(w*13/16,h*6/24));
+	aGc->DrawPie(TRect(b+1,h*7/24,w-1,h*12/24),TPoint(w*13/16,h*7/24),TPoint(w*15/16,h*7/24));
+	aGc->DrawEllipse(TRect(b+1,h*13/24,w-1,h*18/24));
+	aGc->DrawEllipse(TRect(b+1,h*20/24,w-1,h*23/24));
+	}
+
+
+/**
+  @SYMTestCaseID GRAPHICS-BITGDI-0028
+ 
+  @SYMDEF             
+
+  @SYMTestCaseDesc Tests various graphic panics 
+   
+  @SYMTestPriority High
+
+  @SYMTestStatus Implemented
+
+  @SYMTestActions Starts a thread that causes various graphic panics depending on the chosen option
+ 
+  @SYMTestExpectedResults The thread should panic each time for each chosen option
+*/
+void CTAuto::TestPanics()
+	{
+	for (TInt opt = EFirst + 1; opt < ELast; opt++)
+		{
+		StartThread(opt);
+		INFO_PRINTF2(_L("Panic test %d passed\r\n"),opt);
+		}
+	}
+
+void CTAuto::StartThread(TInt aOption)
+	{
+	RThread thrd;
+	TRequestStatus stat;
+	TBuf<256> threadNameBuf;
+	_LIT(KThreadNameFormat, "ptt%d");
+	threadNameBuf.Format(KThreadNameFormat, aOption);
+	TInt threadCreationVal = thrd.Create(threadNameBuf,PanicTestThread,KDefaultStackSize,0x2000,0x20000,(TAny*)aOption);
+	TEST(threadCreationVal==KErrNone);	
+	thrd.SetPriority(EPriorityMuchMore);
+	thrd.Logon(stat);
+	User::SetJustInTime(EFalse);
+	thrd.Resume();
+	User::WaitForRequest(stat);
+	thrd.Close();
+	User::SetJustInTime(ETrue);
+	}
+
+
+/**
+  @SYMTestCaseID GRAPHICS-BITGDI-0029
+ 
+  @SYMDEF             
+
+  @SYMTestCaseDesc tests fading functionality
+   
+  @SYMTestPriority High
+
+  @SYMTestStatus Implemented
+
+  @SYMTestActions 	Tests fading functionality by drawing two rectangles with different alpha values and compares the results
+  				 					
+  @SYMTestExpectedResults the two bitmaps should be identical after the operations
+*/
+void CTAuto::TestFadingL()
+	{
+	TBool res = EFalse;
+	TRect rectbitmap1(0,0,100,50);
+	TRect rectbitmap2(25,0,75,100);
+	
+	CFbsBitmap* bitmap=new(ELeave) CFbsBitmap;
+	CleanupStack::PushL(bitmap);
+	User::LeaveIfError(bitmap->Create(TSize(100,100), EColor64K));
+	
+	CFbsBitmapDevice* device=CFbsBitmapDevice::NewL(bitmap);		
+	CleanupStack::PushL(device);
+		
+	CFbsBitGc* gc;
+	User::LeaveIfError(device->CreateContext(gc));
+	CleanupStack::PushL(gc);
+	
+	CFbsBitmap* bitmap2=new(ELeave) CFbsBitmap;
+	CleanupStack::PushL(bitmap2);
+	User::LeaveIfError(bitmap2->Create(TSize(100,100), EColor64K));
+	
+	CFbsBitmapDevice* device2=CFbsBitmapDevice::NewL(bitmap2);		
+	CleanupStack::PushL(device2);
+		
+	CFbsBitGc* gc2;
+	User::LeaveIfError(device2->CreateContext(gc2));
+	CleanupStack::PushL(gc2);
+
+	gc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+	gc->SetPenColor(TRgb(0,0,0,0));
+
+	//Draws rectangle with Alpha Value 0 when Fading is turned OFF
+	gc->SetBrushColor(TRgb(0,0,255,255));
+	gc->DrawRect(rectbitmap2);
+	
+ 	//Draws rectangle with Alpha Value 255 when Fading is turned OFF
+	gc->SetBrushColor(TRgb(255,0,0,0));
+	gc->DrawRect(rectbitmap1);
+
+	gc2->SetBrushStyle(CGraphicsContext::ESolidBrush);
+	gc2->SetPenColor(TRgb(0,0,0,0));	
+	
+
+ 	//Draws rectangle with Alpha Value 255 when Fading is turned OFF
+	gc2->SetBrushColor(TRgb(0,0,255,255));
+	gc2->DrawRect(rectbitmap2);
+
+ 	//Draws rectangle with Alpha Value 0 when Fading is turned ON
+ 	//Fade Option Turned ON
+	gc2->SetFaded(ETrue);
+	gc2->SetBrushColor(TRgb(255,0,0,0));
+	gc2->DrawRect(rectbitmap1);
+
+	TRect rect(0,0,100,100);
+	res = device->RectCompare(rect,*device2,rect);
+	
+	CleanupStack::PopAndDestroy(6, bitmap);
+	TEST(res);
+	}
+
+TInt PanicTestThread(TAny* aOption)
+	{
+	CTrapCleanup::New();
+	RFbsSession::Connect();
+
+	CFbsScreenDevice* screendevice=NULL;
+	CFbsBitGc* bitgc=NULL;
+	CPolygonFiller* polyfill=NULL;
+	RRegion region;
+	const TInt option = TInt(aOption);
+	TInt ret;
+
+	switch (option)
+		{
+	case EPolygonFiller:
+		polyfill=(CPolygonFiller*)User::Alloc(sizeof(CPolygonFiller));
+		new(polyfill) CPolygonFiller;
+		break;
+	case EDrawBmp1:
+	case EDrawBmp2:
+	case EDrawBmp3:
+	case EDrawText1:
+	case EDrawText2:
+	case EDrawText3:
+		TRAP(ret,screendevice=CFbsScreenDevice::NewL(_L("scdv"),EColor256));
+		if (ret == KErrNotSupported)
+			TRAP(ret,screendevice=CFbsScreenDevice::NewL(_L("scdv"),EGray4));
+		if (ret == KErrNotSupported)
+			TRAP(ret,screendevice=CFbsScreenDevice::NewL(_L("scdv"),EColor4K));
+		if (ret != KErrNone)
+			User::Panic(_L("screendevice failed"),ret);
+		screendevice->CreateContext((CGraphicsContext*&)bitgc);
+		break;
+	case EGcDevice1:
+	case EGcDevice2:
+	case EGcRegion1:
+	case EGcRegion2:
+	case EUseBrush1:
+	case EUseBrush2:
+	case EUseBrush3:
+	case EUseFont:
+		TRAP(ret,bitgc=CFbsBitGc::NewL());
+		break;
+		};
+
+	switch (option)
+		{
+	case EPolygonFiller:
+		polyfill->Construct(NULL,CGraphicsContext::EAlternate);
+		break;
+	case EBitmapDevice:
+		(void)CFbsBitmapDevice::NewL(NULL);
+		break;
+	case EDrawBmp1:
+		bitgc->DrawBitmap(TPoint(0,0),NULL);
+		break;
+	case EDrawBmp2:
+		bitgc->DrawBitmap(TRect(0,0,0,0),NULL);
+		break;
+	case EDrawBmp3:
+		bitgc->DrawBitmap(TRect(0,0,0,0),NULL,TRect(0,0,0,0));
+		break;
+	case EGcDevice1:
+		bitgc->Resized();
+		break;
+	case EGcDevice2:
+		bitgc->MapColors(TRect(0,0,0,0),NULL,0,EFalse);
+		break;
+	case EGcRegion1:
+		region.ForceError();
+		bitgc->SetClippingRegion(&region);
+		break;
+	case EGcRegion2:
+		region.AddRect(TRect(-1,-1,1,1));
+		bitgc->SetClippingRegion(&region);
+		break;
+	case EUseBrush1:
+		bitgc->UseBrushPattern(NULL);
+		break;
+	case EUseBrush2:
+		bitgc->UseBrushPattern((CFbsBitmap*)bitgc);
+		break;
+	case EUseBrush3:
+		bitgc->UseBrushPattern(0);
+		break;
+	case EUseFont:
+		bitgc->UseFont(NULL);
+		break;
+	case EDrawText1:
+		bitgc->DrawText(_L("abc"),TPoint(0,0));
+		break;
+	case EDrawText2:
+		bitgc->DrawText(_L("abc"),TRect(0,0,1,1),0,0);
+		break;
+	case EDrawText3:
+		bitgc->DrawTextVertical(_L("abc"),EFalse);
+		break;
+	default:
+		User::Panic(_L("Default panic"),KErrGeneral);
+		};
+
+	return KErrNone;
+	}
+//-------
+__CONSTRUCT_STEP__(Auto)
+
+void CTAutoStep::TestSetupL()
+	{
+	FbsStartup();
+	User::LeaveIfError(RFbsSession::Connect());
+	}
+	
+void CTAutoStep::TestClose()
+	{
+	RFbsSession::Disconnect();
+	}