// Copyright (c) 2004-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 <e32math.h>
#include <hal.h>
#include <bitdraw.h>
#include <bitdrawscaling.h>
#include <bitdraworigin.h>
#include <bitdrawinterfaceid.h>
#include <graphics/gdi/gdiconsts.h>
#include "TScdvScaling.h"



//Test line properties: 
//[iX, iY] - the starting point of the line
//iLength - line length
struct TLineProps
	{
	TInt iX;
	TInt iY;
	TInt iLength;
	};
//
//Constants
//
//This structure defines [TDrawMode <-> clear screen color value] relation
//When the test uses KDrawMode[i].iDrawMode, then the screen will be cleared using
//KDrawMode[i].iClearColorVal value
struct TDrawModeProps
	{
	CGraphicsContext::TDrawMode iDrawMode;
	// keep the color value 8-bit in both EColor256 and EColor64K, special care need
	// to be done when filling the buffer, e.g color=0x55 
	// in EColor256 clearing means filling 0x55 0x55 0x55 etc, but
	// in EColor64K it has to be 0x0055 0x0055 0x0055 etc
	TUint8 iClearColorVal;
	};
const TDrawModeProps KDrawMode[] = 
	{
		{CGraphicsContext::EDrawModePEN,		0xFF},
		{CGraphicsContext::EDrawModeAND,		0x37},
		{CGraphicsContext::EDrawModeXOR,		0x38},
		{CGraphicsContext::EDrawModeOR,			0xB1},
		{CGraphicsContext::EDrawModeNOTSCREEN,	0xC0},
		{CGraphicsContext::EDrawModeNOTPEN,		0x1D}
	};
const TInt KDrawModesCnt = sizeof(KDrawMode) / sizeof(KDrawMode[0]);
//Shadow/Fade modes
const CFbsDrawDevice::TShadowMode KShadowMode[] = 
	{
	CFbsDrawDevice::EShadow,
	CFbsDrawDevice::EFade,
	CFbsDrawDevice::EShadowFade
	};
const TInt KShadowModesCnt = sizeof(KShadowMode) / sizeof(KShadowMode[0]);
//Test pixel color value
const TUint8 KTestColorVal = 0x55;
//All possible orientations
const CFbsDrawDevice::TOrientation KOrientation[] = 
	{
	CFbsDrawDevice::EOrientationNormal,
	CFbsDrawDevice::EOrientationRotated90,
	CFbsDrawDevice::EOrientationRotated180,
	CFbsDrawDevice::EOrientationRotated270
	};
const TInt KOrientationsCnt = sizeof(KOrientation) / sizeof(KOrientation[0]);
//Width and Height of legacy application screen
const TInt KLegacyAppSizeWidth = 60;
const TInt KLegacyAppSizeHeight = 40;
//Scaling factors: X and Y
const TInt KScalingFactorX = 3;
const TInt KScalingFactorY = 2;
const TInt KMaxScalingFactor = 3;		//Max of previous 2 values

//
//Declarations
//
GLDEF_C TInt ByteSize(TDisplayMode aDisplayMode,TInt aWidth)
	{
	TInt wordSize=aWidth;
	switch(aDisplayMode)
		{
		case EGray2:
			wordSize = (wordSize + 31) / 32;
			break;
		case EGray4:
			wordSize = (wordSize + 15) / 16;
			break;
		case EGray16:
		case EColor16:
			wordSize = (wordSize + 7) / 8;
			break;
		case EGray256:
		case EColor256:
			wordSize = (wordSize + 3) / 4;
			break;
		case EColor4K:
		case EColor64K:
			wordSize = (wordSize + 1) / 2;
			break;
		case EColor16M:
			wordSize = ((wordSize + 3) / 4) * 3;
			break;
		case EColor16MU:
		case EColor16MA:
			//Doesn't need changing
			break;
		default:
			break;
		};
	return wordSize * 4;
	}

static inline TInt ByteSize(TDisplayMode aDisplayMode, TSize aSize)
	{
	return ByteSize(aDisplayMode,aSize.iWidth) * aSize.iHeight;
	}

template <class TPixelType> 
inline void MemFill(TPixelType* aBuffer, TInt aSize, TPixelType aValue)
	{
	TPixelType* p = aBuffer;
	TInt i = 0;
	while (i++<aSize)
		*p++ = aValue;
	}
	
//Generic test class for both Color256 and Color64K
template <class TPixelType> class CTScaling: public CTGraphicsBase
	{
public:
	CTScaling(CTestStep *aTest, TDisplayMode aDisplayMode);
	~CTScaling();
	void RunTestCaseL(TInt aCurTestCase);
private:
	void ConstructL();
	void CreateScreenDeviceL();
	void SetScalingSettings(const TPoint& aOrigin, TInt aFx, TInt aFy, TInt aDivX, TInt aDivY);
	void CheckLine(const TLineProps& aLineProps, const TPoint& aOrg, const TDrawModeProps& aDrawModeProps, TPixelType aClearColorValue);
	void CheckWriteRgbMulti(const TRect& aRcProps, const TPoint& aOrg, const TDrawModeProps& aDrawModeProps, TPixelType aClearColorValue);
	void CheckRgbAlphaLine(const TLineProps& aLineProps, const TPoint& aOrg, TPixelType aClearColorValue);
	void CheckRect(const TRect& aRc, const TPoint& aOrg, TPixelType aClearColorValue);
	void WriteLine();
	void ClearScreen(const TDrawModeProps& aDrawModeProps);
	void SetTestData();
	void CheckChangedPixels(TInt aChangedPixelsCnt, TPixelType aClearColorVal);
	void CheckWriteBinary(const TPoint& aPt, const TPoint& aOrg, TPixelType aClearColorValue, TInt aLength, TInt aHeight);
	void CheckVertLine(const TLineProps& aLineProps, const TPoint& aOrg, TPixelType aClearColorValue);
	void WriteRgb();
	void WriteRgbMulti();
	void WriteRgbAlphaLine();
	void WriteBinary();
	void WriteBinaryLineVertical();
	void WriteBinaryLine();
	void WriteRgbAlphaMulti();
	void ShadowArea();
	void WriteRgbAlphaLine2();
	void TestScalingSettingsInterface();
	void PerformanceTest();
private:
	//Test data array
	TPixelType iTestData[KLegacyAppSizeWidth];
	//The device used in the tests
	CFbsDrawDevice* iDrawDevice;
	//Width and Height of the screen
	TSize iPhysSize;
	//The test allocates block of memory for a screen with PhysSize size 
	//mode. iBits will point to the allocated memory block.
	TPixelType* iBits;
	TDisplayMode iDisplayMode;
	//The scaling interface
	MScalingSettings* iScalingSettings;
	//The origin interface
	MDrawDeviceOrigin* iOriginInterface;
	TInt iCurOrientation;
	TInt iScalingFactorX;
	TInt iScalingFactorY;
	};
typedef CTScaling<TUint8> CTestNone;
typedef CTScaling<TUint8> CTestColor256;
typedef CTScaling<TUint16> CTestColor64K;



//
//Test code
//
/*template <class TPixelType>
CTScaling<TPixelType>* CTScaling<TPixelType>::NewL(TDisplayMode aDisplayMode)	
	{
	CTScaling<TPixelType>* self = new (ELeave) CTScaling<TPixelType>;
	CleanupStack::PushL(self);
	self->ConstructL(aDisplayMode);
	CleanupStack::Pop(self);
	return self;
	}
*/	

template <class TPixelType>
CTScaling<TPixelType>::CTScaling(CTestStep *aTest, TDisplayMode aDisplayMode) :
				CTGraphicsBase(aTest),
				iDisplayMode(aDisplayMode)
	{
	INFO_PRINTF1(_L("Scaling tests"));
	}
	

template <class TPixelType>
void CTScaling<TPixelType>::ConstructL()	
	{
	CreateScreenDeviceL();
	}
	
template <class TPixelType>
CTScaling<TPixelType>::~CTScaling()
	{
	((CTScalingStep*)iStep)->CloseTMSGraphicsStep();
	delete[] iBits;
	delete iDrawDevice;	
	}
	
template <class TPixelType>
void CTScaling<TPixelType>::SetScalingSettings(const TPoint& aOrigin, TInt aFx, TInt aFy, TInt aDivX, TInt aDivY)
	{
	TEST(iDrawDevice != NULL);	
	if(!iScalingSettings)
		{
		TInt err = iDrawDevice->GetInterface(KScalingSettingsInterfaceID, 
											  reinterpret_cast <TAny*&> (iScalingSettings));
		TEST2(err, KErrNone);
		}
	TEST(iScalingSettings != NULL);
	TInt err = iScalingSettings->Set(aFx, aFy, aDivX, aDivY);
	TEST2(err, KErrNone);
	if(!iOriginInterface)
		{
		TInt err = iDrawDevice->GetInterface(KDrawDeviceOriginInterfaceID, 
											  reinterpret_cast <TAny*&> (iOriginInterface));
		TEST2(err, KErrNone);
		}
	TEST(iOriginInterface != NULL);
	err = iOriginInterface->Set(aOrigin);
	TEST2(err, KErrNone);
	}

//Clears the screen initializing each screen pixel with aDrawModeProps.iClearColorVal value
template <class TPixelType>
void CTScaling<TPixelType>::ClearScreen(const TDrawModeProps& aDrawModeProps)
	{
	::MemFill(iBits, ::ByteSize(EColor256, iPhysSize), TPixelType(aDrawModeProps.iClearColorVal));
	}

//Initializes iTestData array with KTestColorVal value
template <class TPixelType>
void CTScaling<TPixelType>::SetTestData()
	{
	::MemFill(iTestData, KLegacyAppSizeWidth, TPixelType(KTestColorVal));
	}

template <class TPixelType>
void CTScaling<TPixelType>::CheckChangedPixels(TInt aChangedPixelsCnt, TPixelType aClearColorVal)
	{
	const TInt KByteSize = ::ByteSize(EColor256, iPhysSize);
	TInt changedPixelsCnt = 0;
	for(TInt ii=0;ii<KByteSize;++ii)
		{
		if(iBits[ii]!=aClearColorVal)
			{
			++changedPixelsCnt;
			}
		}
	TEST(changedPixelsCnt == aChangedPixelsCnt);
	if (changedPixelsCnt!=aChangedPixelsCnt)
		{
		_LIT(KLog,"Wrong number of changed pixels, expected=%d, actual=%d, color=0x%x");
		INFO_PRINTF4(KLog,aChangedPixelsCnt,changedPixelsCnt,aClearColorVal);
		}
	}

//Checks a set of horisontal lines , which starting point is 
//[aOrg.iX + aLineProps.iX * iScalingFactorX, aOrg.iY + aLineProps.iY * iScalingFactorY]
//and length is aLineProps.iLength * iScalingFactorX. For each nexh line y-coordinate
//is incremented by 1.
//The screen lines pixel values are tested against aClearColorValue value.
//Then the screen is testsed pixel by pixel that nothing is written outside the tested lines.
template <class TPixelType>
void CTScaling<TPixelType>::CheckLine(const TLineProps& aLineProps, 
					  const TPoint& aOrg, 
					  const TDrawModeProps& aDrawModeProps, 
					  TPixelType aClearColorValue)
	{
	TPixelType data[KLegacyAppSizeWidth * KMaxScalingFactor];
	TInt ii;
	for(ii=0;ii<iScalingFactorY;++ii)
		{
		Mem::Fill(data, sizeof(data), 0x00);
		iDrawDevice->ReadLine(aOrg.iX + aLineProps.iX * iScalingFactorX, 
							   aOrg.iY + aLineProps.iY * iScalingFactorY + ii, 
							   aLineProps.iLength * iScalingFactorX, 
							   data, 
							   iDisplayMode);
		const TInt length=aLineProps.iLength*iScalingFactorX;
		TInt firstErr=length;
		TInt numErrs=0;
		for(TInt jj=0;jj<length;++jj)
			{
			//TEST(data[jj]!=aClearColorValue);
			if (data[jj]==aClearColorValue)
				{
				++numErrs;
				if (jj<firstErr)
					firstErr=jj;
				}
			}
		TEST(numErrs==0);
		if (numErrs>0)
			{
			_LIT(KLog,"Line %d (of %d) of length %d has %d errors first one at %d,  ClearCol=0x%x");
			INFO_PRINTF7(KLog,ii,iScalingFactorY,length,numErrs,firstErr,aClearColorValue);
			}
		}
	TInt changedPixelsCnt = iScalingFactorY * aLineProps.iLength * iScalingFactorX;
	CheckChangedPixels(changedPixelsCnt, aDrawModeProps.iClearColorVal);
	}

//Checks the rectangle filled using CFbsScreenDevice::WriteRgbMulti. 
//The screen lines pixel values are tested against aClearColorValue value.
//Then the screen is testsed pixel by pixel that nothing is written outside the tested rectangle.
template <class TPixelType>
void CTScaling<TPixelType>::CheckWriteRgbMulti(const TRect& aRcProps, 
							   const TPoint& aOrg, 
							   const TDrawModeProps& aDrawModeProps, 
							   TPixelType aClearColorValue)
	{
	TPixelType data[KLegacyAppSizeWidth * KMaxScalingFactor];
	TInt ii;
	TInt xx = aOrg.iX + aRcProps.iTl.iX * iScalingFactorX;
	TInt yy = aOrg.iY + aRcProps.iTl.iY * iScalingFactorY;
	for(ii=0;ii<(iScalingFactorY * aRcProps.Height());++ii)
		{
		Mem::Fill(data, sizeof(data), 0x00);
		iDrawDevice->ReadLine(xx, yy+ii, aRcProps.Width()*iScalingFactorX, data, iDisplayMode);
		const TInt width=aRcProps.Width()*iScalingFactorX;
		TInt firstErr=width;
		TInt numErrs=0;
		for(TInt jj=0;jj<width;++jj)
			{
			//TEST(data[jj]!=aClearColorValue);
			if (data[jj]==aClearColorValue)
				{
				++numErrs;
				if (jj<firstErr)
					firstErr=jj;
				}
			}
		TEST(numErrs==0);
		if (numErrs>0)
			{
			_LIT(KLog,"Line %d of width %d has %d errors first one at %d,  ClearCol=0x%x");
			INFO_PRINTF6(KLog,ii,width,numErrs,firstErr,aClearColorValue);
			}
		}
	TInt changedPixelsCnt = iScalingFactorY * aRcProps.Width() * aRcProps.Height() * iScalingFactorX;
	CheckChangedPixels(changedPixelsCnt, aDrawModeProps.iClearColorVal);
	}

//Checks a set of horisontal lines , which starting point is 
//[aOrg.iX + aLineProps.iX * iScalingFactorX, aOrg.iY + aLineProps.iY * iScalingFactorY]
//and length is aLineProps.iLength * iScalingFactorX. For each nexh line y-coordinate
//is incremented by 1.
//The screen lines pixel values are tested against aClearColorValue value.
//Then the screen is testsed pixel by pixel that nothing is written outside the tested lines.
template <class TPixelType>
void CTScaling<TPixelType>::CheckRgbAlphaLine(const TLineProps& aLineProps, 
							  const TPoint& aOrg, 
							  TPixelType aClearColorValue)
	{
	TPixelType data[KLegacyAppSizeWidth * KMaxScalingFactor];
	for(TInt ii=0;ii<iScalingFactorY;++ii)
		{
		Mem::Fill(data, sizeof(data), 0x00);
		iDrawDevice->ReadLine(aOrg.iX + aLineProps.iX * iScalingFactorX, 
							   aOrg.iY + aLineProps.iY * iScalingFactorY + ii, 
							   aLineProps.iLength * iScalingFactorX, 
							   data, 
							   iDisplayMode);
		const TInt length=aLineProps.iLength*iScalingFactorX;
		TInt firstErr=length;
		TInt numErrs=0;
		for(TInt jj=0;jj<(aLineProps.iLength * iScalingFactorX);++jj)
			{
			//TEST(data[jj]!=aClearColorValue);
			if (data[jj]==aClearColorValue)
				{
				++numErrs;
				if (jj<firstErr)
					firstErr=jj;
				}
			}
		TEST(numErrs==0);
		if (numErrs>0)
			{
			_LIT(KLog,"Line %d of length %d has %d errors first one at %d,  ClearCol=0x%x");
			INFO_PRINTF6(KLog,ii,length,numErrs,firstErr,aClearColorValue);
			}
		}
	TInt changedPixelsCnt = iScalingFactorY * aLineProps.iLength * iScalingFactorX;
	CheckChangedPixels(changedPixelsCnt, aClearColorValue);
	}

//Checks the rectangle filled using CFbsScreenDevice::WriteBinary. 
//The screen lines pixel values are tested against aClearColorValue value.
//Then the screen is testsed pixel by pixel that nothing is written outside the tested rectangle.
template <class TPixelType>
void CTScaling<TPixelType>::CheckWriteBinary(const TPoint& aPt, 
							 const TPoint& aOrg, 
							 TPixelType aClearColorValue, 
							 TInt aLength, TInt aHeight)
	{
	TPixelType data[KLegacyAppSizeWidth * KMaxScalingFactor];
	TInt ii;
	TInt xx = aOrg.iX + aPt.iX * iScalingFactorX;
	TInt yy = aOrg.iY + aPt.iY * iScalingFactorY;
	for(ii=0;ii<(iScalingFactorY * aHeight);++ii)
		{
		Mem::Fill(data, sizeof(data), 0x00);
		iDrawDevice->ReadLine(xx, yy + ii, aLength * iScalingFactorX, data, iDisplayMode);
		const TInt length=aLength*iScalingFactorX;
		TInt firstErr=length;
		TInt numErrs=0;
		for(TInt jj=0;jj<length;++jj)
			{
			//TEST(data[jj] != aClearColorValue);
			if (data[jj]==aClearColorValue)
				{
				++numErrs;
				if (jj<firstErr)
					firstErr=jj;
				}
			}
		TEST(numErrs==0);
		if (numErrs>0)
			{
			_LIT(KLog,"Line %d of length %d has %d errors first one at %d,  ClearCol=0x%x");
			INFO_PRINTF6(KLog,ii,length,numErrs,firstErr,aClearColorValue);
			}
		}
	TInt changedPixelsCnt = iScalingFactorY * aLength * aHeight * iScalingFactorX;
	CheckChangedPixels(changedPixelsCnt, aClearColorValue);
	}

//Checks a set of vertical lines , which starting point is 
//[aOrg.iX + aLineProps.iX * iScalingFactorX, aOrg.iY + aLineProps.iY * iScalingFactorY]
//and length is aLineProps.iLength * iScalingFactorX. For each nexh line y-coordinate
//is incremented by 1.
//The screen lines pixel values are tested against aClearColorValue value.
//Then the screen is testsed pixel by pixel that nothing is written outside the tested lines.
template <class TPixelType>
void CTScaling<TPixelType>::CheckVertLine(const TLineProps& aLineProps, const TPoint& aOrg, TPixelType aClearColorValue)
	{
	TInt x = aOrg.iX + aLineProps.iX * iScalingFactorX;
	TInt y = aOrg.iY + aLineProps.iY * iScalingFactorY;
	for(TInt i=0;i<iScalingFactorX;++i)
		{
		for(TInt j=0;j<(aLineProps.iLength * iScalingFactorY);++j)
			{
			TRgb val = iDrawDevice->ReadPixel(x + i, y + j);				   
			switch (iDisplayMode)
				{
				case EColor64K:
				TEST(val.Color64K() != aClearColorValue);
				break;
				
				case EColor256:
				TEST(val.Color256() != aClearColorValue);
				break;
				
				default:
				TEST(EFalse);
				}
			}
		}
	TInt changedPixelsCnt = iScalingFactorX * aLineProps.iLength * iScalingFactorY;
	CheckChangedPixels(changedPixelsCnt, aClearColorValue);
	}

//Checks the rectangle filled using CFbsScreenDevice::ShadowArea
//The screen lines pixel values are tested against aClearColorValue value.
//Then the screen is testsed pixel by pixel that nothing is written outside the tested rectangle.
template <class TPixelType>
void CTScaling<TPixelType>::CheckRect(const TRect& aRc, const TPoint& aOrg, TPixelType aClearColorValue)
	{
	TPixelType data[KLegacyAppSizeWidth * KMaxScalingFactor];
	TInt i;
	TInt x = aOrg.iX + aRc.iTl.iX * iScalingFactorX;
	TInt y = aOrg.iY + aRc.iTl.iY * iScalingFactorY;
	for(i=0;i<(iScalingFactorY * aRc.Height());++i)
		{
		Mem::Fill(data, sizeof(data), 0x00);
		iDrawDevice->ReadLine(x, y + i, aRc.Width() * iScalingFactorX, data, iDisplayMode);
		for(TInt j=0;j<(aRc.Width() * iScalingFactorX);++j)
			{
			TEST(data[j] != aClearColorValue);
			}
		}
	TInt changedPixelsCnt = iScalingFactorY * aRc.Width() * aRc.Height() * iScalingFactorX;
	CheckChangedPixels(changedPixelsCnt, aClearColorValue);
	}

//CFbsScreenDevice::WriteLine() and CFbsScreenDevice::ReadLine() test.
//(Set of test lines) X (Set of origins) X (Set of drawing modes) number of test cases.
template <class TPixelType>
void CTScaling<TPixelType>::WriteLine()
	{
	INFO_PRINTF1(_L("CFbsDrawDevice::WriteLine"));

	TLineProps lineProps[] = 
		{
		{0, 0, KLegacyAppSizeWidth - 1}, 
		{0, KLegacyAppSizeHeight - 1, KLegacyAppSizeWidth - 1},
		{10, 20, KLegacyAppSizeWidth / 2},
		{-2, -5, 20},
		{-3, 1, 21},
		{2, -2, 11},
		{0, -4, 31},
		{-1, 11, 11}
		};
	const TInt KLinesCnt = sizeof(lineProps) / sizeof(lineProps[0]);
	TPoint ptOrg[] = 
		{
		TPoint(13, 21),
		TPoint(10, 17)
		};
	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
	for(TInt ll=0;ll<KOriginsCnt;++ll)
		{
		for(TInt line=0;line<KLinesCnt;++line)
			{
			for(TInt kk=0;kk<KDrawModesCnt;++kk)
				{
				ClearScreen(KDrawMode[kk]);
				SetTestData();
				SetScalingSettings(ptOrg[ll], KScalingFactorX, KScalingFactorY, 1, 1);
				iDrawDevice->WriteLine(lineProps[line].iX, lineProps[line].iY,
									  lineProps[line].iLength, 
									  reinterpret_cast <TUint32*> (iTestData), 
									  KDrawMode[kk].iDrawMode);
				if(KDrawMode[kk].iDrawMode == CGraphicsContext::EDrawModePEN)
					{
					TPixelType writtenData[KLegacyAppSizeWidth];
					Mem::FillZ(writtenData, sizeof(writtenData));
					iDrawDevice->ReadLine(lineProps[line].iX, lineProps[line].iY,
										   lineProps[line].iLength, 
										   writtenData, iDisplayMode);
					for(TInt ii=0;ii<lineProps[line].iLength;++ii)
						{
						TEST(writtenData[ii] == iTestData[ii]);
						}
					}
				SetScalingSettings(TPoint(), 1, 1, 1, 1);
				CheckLine(lineProps[line], ptOrg[ll], KDrawMode[kk], KDrawMode[kk].iClearColorVal);
				}
			}
		}
	}

//CFbsScreenDevice::WriteRgb() and CFbsScreenDevice::ReadPixel() test.
//(Set of test points) X (Set of origins) X (Set of drawing modes) number of test cases.
template <class TPixelType>
void CTScaling<TPixelType>::WriteRgb()
	{
	INFO_PRINTF1(_L("CFbsDrawDevice::WriteRgb"));

	TPoint pt[] = 
		{
		TPoint(0, 0), 
		TPoint(KLegacyAppSizeWidth - 1, 0), 
		TPoint(0, KLegacyAppSizeHeight - 1), 
		TPoint(KLegacyAppSizeWidth - 1, KLegacyAppSizeHeight - 1),
		TPoint(KLegacyAppSizeWidth / 2, KLegacyAppSizeHeight / 2),
		TPoint(-2, -3), 
		TPoint(0, -1),
		TPoint(-3, 0)
		};
	const TInt KPointsCnt = sizeof(pt) / sizeof(pt[0]);
	TPoint ptOrg[] = 
		{
		TPoint(9, 22),
		TPoint(17, 11)
		};
	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
	for(TInt l=0;l<KOriginsCnt;++l)
		{
		for(TInt i=0;i<KPointsCnt;++i)
			{
			for(TInt k=0;k<KDrawModesCnt;++k)
				{
				ClearScreen(KDrawMode[k]);
				SetScalingSettings(ptOrg[l], KScalingFactorX, KScalingFactorY, 1, 1);
				TRgb val(KTestColorVal);
				iDrawDevice->WriteRgb(pt[i].iX, pt[i].iY, val, KDrawMode[k].iDrawMode);
				if(KDrawMode[k].iDrawMode == CGraphicsContext::EDrawModePEN)
					{
					TRgb writtenVal = iDrawDevice->ReadPixel(pt[i].iX, pt[i].iY);
					switch (iDisplayMode)
						{
						case EColor64K:
						TEST(writtenVal == TRgb::Color64K(val.Color64K()));
						break;
						
						case EColor256:
						TEST(writtenVal == val);
						break;
						
						default:
						TEST(EFalse);
						}
					}
				SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
				TLineProps props;
				props.iX = pt[i].iX;
				props.iY = pt[i].iY;
				props.iLength = 1;
				CheckLine(props, ptOrg[l], KDrawMode[k], KDrawMode[k].iClearColorVal);
				}
			}
		}
	}

//CFbsScreenDevice::WriteRgbMulti() test.
template <class TPixelType>
void CTScaling<TPixelType>::WriteRgbMulti()
	{
	INFO_PRINTF1(_L("CFbsDrawDevice::WriteRgbMulti"));

	TRect rcProps[] =
		{
		TRect(TPoint(0, 0), TSize(KLegacyAppSizeWidth - 1, KLegacyAppSizeHeight - 1)), 
		TRect(TPoint(17, 11), TSize(KLegacyAppSizeWidth / 2, KLegacyAppSizeHeight / 2)),
		TRect(TPoint(-1, -4), TSize(31, 12)), 
		TRect(TPoint(-3, -1), TSize(11, 11)), 
		TRect(TPoint(0, -2), TSize(6, 17))
		};
	const TInt KRcCnt = sizeof(rcProps) / sizeof(rcProps[0]);
	TPoint ptOrg[] = 
		{
		TPoint(21, 29),
		TPoint(12, 14)
		};
	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
	for(TInt l=0;l<KOriginsCnt;++l)
		{
		for(TInt i=0;i<KRcCnt;++i)
			{
			for(TInt k=0;k<KDrawModesCnt;++k)
				{
				ClearScreen(KDrawMode[k]);
				SetTestData();
				SetScalingSettings(ptOrg[l], KScalingFactorX, KScalingFactorY, 1, 1);
				TRgb val(KTestColorVal);
				iDrawDevice->WriteRgbMulti(rcProps[i].iTl.iX, rcProps[i].iTl.iY,
									  rcProps[i].Width(), rcProps[i].Height(),
									  val, 
									  KDrawMode[k].iDrawMode);
				SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
				CheckWriteRgbMulti(rcProps[i], ptOrg[l], KDrawMode[k], KDrawMode[k].iClearColorVal);
				}
			}
		}
	}

//CFbsScreenDevice::WriteRgbAlphaLine() test.
//(Set of test lines) X (Set of origins) X (Set of drawing modes) number of test cases.
template <class TPixelType>
void CTScaling<TPixelType>::WriteRgbAlphaLine()
	{
	INFO_PRINTF1(_L("CFbsDrawDevice::WriteRgbAlphaLine"));

	TLineProps lineProps[] = 
		{
		{0, 0, KLegacyAppSizeWidth - 1}, 
		{0, KLegacyAppSizeHeight - 1, KLegacyAppSizeWidth - 1},
		{17, 3, KLegacyAppSizeWidth / 2},
		{-1, -2, 11},
		{-4, -5, 1},
		{0, -1, 3},
		{1, -3, 7}
		};
	const TInt KLinesCnt = sizeof(lineProps) / sizeof(lineProps[0]);
	TPoint ptOrg[] = 
		{
		TPoint(19, 17),
		TPoint(29, 25)
		};
	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
	for(TInt l=0;l<KOriginsCnt;++l)
		{
		for(TInt i=0;i<KLinesCnt;++i)
			{
			for(TInt k=0;k<KDrawModesCnt;++k)
				{
				ClearScreen(KDrawMode[k]);
				SetScalingSettings(ptOrg[l], KScalingFactorX, KScalingFactorY, 1, 1);
				TUint8 rgbBuff[KLegacyAppSizeWidth * 3];
				Mem::Fill(rgbBuff, sizeof(rgbBuff), KTestColorVal);
				TUint8 maskBuff[KLegacyAppSizeWidth];
				TUint8 maskChar = 0xF1;
				Mem::Fill(maskBuff, sizeof(maskBuff), maskChar);
				iDrawDevice->WriteRgbAlphaLine(lineProps[i].iX, lineProps[i].iY,
									  lineProps[i].iLength, rgbBuff, maskBuff, CGraphicsContext::EDrawModePEN);
				SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
				CheckRgbAlphaLine(lineProps[i], ptOrg[l], KDrawMode[k].iClearColorVal);
				}
			}
		}
	}

//CFbsScreenDevice::WriteBinary() test.
template <class TPixelType>
void CTScaling<TPixelType>::WriteBinary()
	{
	INFO_PRINTF1(_L("CFbsDrawDevice::WriteBinary"));

	TPoint pt[] =
		{
		TPoint(0, 0), 
		TPoint(27, 19),
		TPoint(-4, -4),
		TPoint(-1, -2),
		TPoint(-1, -2),
		TPoint(5, -5),
		TPoint(-5, 0)
		};
	const TInt KPtCnt = sizeof(pt) / sizeof(pt[0]);
	TPoint ptOrg[] = 
		{
		TPoint(19, 24),
		TPoint(29, 26)
		};
	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
	for(TInt l=0;l<KOriginsCnt;++l)
		{
		for(TInt i=0;i<KPtCnt;++i)
			{
			for(TInt k=0;k<KDrawModesCnt;++k)
				{
				ClearScreen(KDrawMode[k]);
				SetTestData();
				SetScalingSettings(ptOrg[l], KScalingFactorX, KScalingFactorY, 1, 1);
				const TInt KHeight = 5;
				const TInt KLength = 11;
				TUint32 buff[KHeight];
				TUint32 buffChar = 0xFFFFFFFF;
				for(TInt ooo=0;ooo<KHeight;++ooo)
					{
					buff[ooo] = buffChar;
					}
				TRgb val(KTestColorVal);
				iDrawDevice->WriteBinary(pt[i].iX, pt[i].iY, buff, KLength, KHeight,
										  val, KDrawMode[k].iDrawMode);
				SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
				CheckWriteBinary(pt[i], ptOrg[l], KDrawMode[k].iClearColorVal, KLength, KHeight);
				}
			}
		}
	}

//CFbsScreenDevice::WriteBinaryLineVertical() test.
template <class TPixelType>
void CTScaling<TPixelType>::WriteBinaryLineVertical()
	{
	INFO_PRINTF1(_L("CFbsDrawDevice::WriteBinaryLineVertical"));

	TLineProps lineProps[] = 
		{
		{0, 0, KLegacyAppSizeHeight - 1}, 
		{KLegacyAppSizeWidth - 1, 0, KLegacyAppSizeHeight - 1},
		{17, 3, 23},
		{-2, -5, 10},
		{-6, 24, 11},
		{18, -6, 12},
		{0, -3, 13},
		{-1, 0, 14}
		};
	const TInt KLinesCnt = sizeof(lineProps) / sizeof(lineProps[0]);
	TPoint ptOrg[] = 
		{
		TPoint(22, 22),
		TPoint(19, 20)
		};
	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
	for(TInt l=0;l<KOriginsCnt;++l)
		{
		for(TInt i=0;i<KLinesCnt;++i)
			{
			for(TInt k=0;k<KDrawModesCnt;++k)
				{
				ClearScreen(KDrawMode[k]);
				SetTestData();
				SetScalingSettings(ptOrg[l], KScalingFactorX, KScalingFactorY, 1, 1);
				const TInt KLength = 30;
				TUint32 buff[KLength];
				TUint32 buffChar = 0xFFFFFFFF;
				for(TInt ooo=0;ooo<KLength;++ooo)
					{
					buff[ooo] = buffChar;
					}
				TRgb val(KTestColorVal);
				iDrawDevice->WriteBinaryLineVertical(lineProps[i].iX, lineProps[i].iY,
													  buff, lineProps[i].iLength, val, 
													  KDrawMode[k].iDrawMode, EFalse);
				SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
				CheckVertLine(lineProps[i], ptOrg[l], KDrawMode[k].iClearColorVal);
				}
			}
		}
	}

//CFbsScreenDevice::WriteBinaryLine() test.
template <class TPixelType>
void CTScaling<TPixelType>::WriteBinaryLine()
	{
	INFO_PRINTF1(_L("CFbsDrawDevice::WriteBinaryLiine"));

	TPoint pt[] =
		{
		TPoint(0, 0), 
		TPoint(1, 7),
		TPoint(18, -8),
		TPoint(-7, 26),
		TPoint(-4, -7),
		TPoint(0, -2),
		TPoint(34, -1),
		TPoint(-1, 17)
		};
	const TInt KPtCnt = sizeof(pt) / sizeof(pt[0]);
	TPoint ptOrg[] = 
		{
		TPoint(21, 35),
		TPoint(40, 28)
		};
	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
	for(TInt l=0;l<KOriginsCnt;++l)
		{
		for(TInt i=0;i<KPtCnt;++i)
			{
			for(TInt k=0;k<KDrawModesCnt;++k)
				{
				ClearScreen(KDrawMode[k]);
				SetTestData();
				SetScalingSettings(ptOrg[l], KScalingFactorX, KScalingFactorY, 1, 1);
				const TInt KHeight = 1;
				const TInt KLength = 11;
				TUint32 buff[KHeight];
				TUint32 buffChar = 0xFFFFFFFF;
				for(TInt ooo=0;ooo<KHeight;++ooo)
					{
					buff[ooo] = buffChar;
					}
				TRgb val(KTestColorVal);
				iDrawDevice->WriteBinaryLine(pt[i].iX, pt[i].iY, buff, KLength,
											  val, KDrawMode[k].iDrawMode);
				SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
				CheckWriteBinary(pt[i], ptOrg[l], KDrawMode[k].iClearColorVal, KLength, KHeight);
				}
			}
		}
	}

//CFbsScreenDevice::WriteRgbAlphaMulti() test.
template <class TPixelType>
void CTScaling<TPixelType>::WriteRgbAlphaMulti()
	{
	INFO_PRINTF1(_L("CFbsDrawDevice::WriteRgbAlphaMulti"));

	TLineProps lineProps[] = 
		{
		{0, 0, KLegacyAppSizeWidth - 1}, 
		{0, KLegacyAppSizeHeight - 1, KLegacyAppSizeWidth - 1},
		{17, 3, KLegacyAppSizeWidth / 2},
		{-8, -8, 11},
		{-3, 15, 12},
		{29, -4, 13},
		{0, -3, 14},
		{-5, 0, 15}
		};
	const TInt KLinesCnt = sizeof(lineProps) / sizeof(lineProps[0]);
	TPoint ptOrg[] = 
		{
		TPoint(24, 17),
		TPoint(27, 20)
		};
	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
	for(TInt l=0;l<KOriginsCnt;++l)
		{
		for(TInt i=0;i<KLinesCnt;++i)
			{
			for(TInt k=0;k<KDrawModesCnt;++k)
				{
				ClearScreen(KDrawMode[k]);
				SetTestData();
				SetScalingSettings(ptOrg[l], KScalingFactorX, KScalingFactorY, 1, 1);
				TUint8 maskBuff[KLegacyAppSizeWidth];
				TUint8 maskChar = 0xF1;
				Mem::Fill(maskBuff, sizeof(maskBuff), maskChar);
				TRgb val(KTestColorVal);
				iDrawDevice->WriteRgbAlphaMulti(lineProps[i].iX, lineProps[i].iY,
												 lineProps[i].iLength, val, maskBuff);
				SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
				CheckRgbAlphaLine(lineProps[i], ptOrg[l], KDrawMode[k].iClearColorVal);
				}
			}
		}
	}

//CFbsScreenDevice::ShadowArea() test.
template <class TPixelType>
void CTScaling<TPixelType>::ShadowArea()
	{
	INFO_PRINTF1(_L("CFbsDrawDevice::ShadowArea"));

	TRect rcProps[] =
		{
		TRect(TPoint(0, 0), TSize(KLegacyAppSizeWidth - 1, KLegacyAppSizeHeight - 1)), 
		TRect(TPoint(17, 11), TSize(KLegacyAppSizeWidth / 2, KLegacyAppSizeHeight / 2)),
		TRect(TPoint(-1, -1), TSize(1, 1)),
		TRect(TPoint(-4, -5), TSize(11, 8)),
		TRect(TPoint(0, -6), TSize(3, 23)),
		TRect(TPoint(-7, 0), TSize(24, 2)),
		TRect(TPoint(5, -2), TSize(8, 9)),
		TRect(TPoint(-4, 16), TSize(11, 8))
		};
	const TInt KRcCnt = sizeof(rcProps) / sizeof(rcProps[0]);
	TPoint ptOrg[] = 
		{
		TPoint(25, 24),
		TPoint(31, 29)
		};
	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
	for(TInt l=0;l<KOriginsCnt;++l)
		{
		for(TInt i=0;i<KRcCnt;++i)
			{
			for(TInt k=0;k<KDrawModesCnt;++k)
				{
				TDrawModeProps drawModeProps(KDrawMode[k]);
				--drawModeProps.iClearColorVal;//I want to avoid "255" clear color value.
				for(TInt m=0;m<KShadowModesCnt;++m)
					{
					iDrawDevice->SetShadowMode(KShadowMode[m]);
					ClearScreen(drawModeProps);
					SetTestData();
					SetScalingSettings(ptOrg[l], KScalingFactorX, KScalingFactorY, 1, 1);
					iDrawDevice->ShadowArea(rcProps[i]);
					SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
					CheckRect(rcProps[i], ptOrg[l], drawModeProps.iClearColorVal);
					}
				}
			}
		}
	iDrawDevice->SetShadowMode(CFbsDrawDevice::ENoShadow);
	}

//CFbsScreenDevice::WriteRgbAlphaLine() test.
template <class TPixelType>
void CTScaling<TPixelType>::WriteRgbAlphaLine2()
	{
	INFO_PRINTF1(_L("CFbsDrawDevice::WriteRgbAlphaLine-2"));

	TLineProps lineProps[] = 
		{
		{0, 0, KLegacyAppSizeWidth - 1}, 
		{0, KLegacyAppSizeHeight - 1, KLegacyAppSizeWidth - 1},
		{17, 3, KLegacyAppSizeWidth / 2},
		{-1, -7, 11},
		{0, -5, 12},
		{-3, 0, 13},
		{15, -7, 14},
		{-1, -7, 15},
		{-1, -7, 16}
		};
	const TInt KLinesCnt = sizeof(lineProps) / sizeof(lineProps[0]);
	TPoint ptOrg[] = 
		{
		TPoint(18, 28),
		TPoint(15, 15)
		};
	const TInt KOriginsCnt = sizeof(ptOrg) / sizeof(ptOrg[0]);
	for(TInt l=0;l<KOriginsCnt;++l)
		{
		for(TInt i=0;i<KLinesCnt;++i)
			{
			for(TInt k=0;k<KDrawModesCnt;++k)
				{
				ClearScreen(KDrawMode[k]);
				SetTestData();
				SetScalingSettings(ptOrg[l], KScalingFactorX, KScalingFactorY, 1, 1);
				TUint8 rgbBuff1[KLegacyAppSizeWidth * 3];
				TUint8 rgbBuff2[KLegacyAppSizeWidth * 3];
				Mem::Fill(rgbBuff1, sizeof(rgbBuff1), KTestColorVal - 15);
				Mem::Fill(rgbBuff2, sizeof(rgbBuff2), KTestColorVal + 22);
				TUint8 maskBuff[KLegacyAppSizeWidth];
				TUint8 maskChar = 0xF1;
				Mem::Fill(maskBuff, sizeof(maskBuff), maskChar);
				iDrawDevice->WriteRgbAlphaLine(lineProps[i].iX, lineProps[i].iY,
									  lineProps[i].iLength, rgbBuff1, rgbBuff2, maskBuff,
									  KDrawMode[k].iDrawMode);
				SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
				CheckRgbAlphaLine(lineProps[i], ptOrg[l], KDrawMode[k].iClearColorVal);
				}
			}
		}
	}

template <class TPixelType>
void CTScaling<TPixelType>::TestScalingSettingsInterface()
	{
	INFO_PRINTF1(_L("MScalingSettings functionality test"));
	TEST(iDrawDevice != NULL);	

	MScalingSettings* scalingSettings = NULL;
	TInt err = iDrawDevice->GetInterface(KScalingSettingsInterfaceID, 
										  reinterpret_cast <TAny*&> (scalingSettings));
	TEST2(err, KErrNone);
	TEST(scalingSettings != NULL);

	TEST(scalingSettings->IsScalingOff());

	const TInt factorXIn = 10, factorYIn = 13, divisorXIn = 1, divisorYIn = 1;
	TInt factorXOut = -1, factorYOut = -1, divisorXOut = -1, divisorYOut = -1;

	err = scalingSettings->Set(factorXIn, factorYIn, divisorXIn, divisorYIn);
	TEST2(err, KErrNone);
	TEST(!scalingSettings->IsScalingOff());
	scalingSettings->Get(factorXOut, factorYOut, divisorXOut, divisorYOut);

	TEST(factorXOut == factorXOut);
	TEST(factorYIn == factorYOut);
	TEST(divisorXIn == divisorXOut);
	TEST(divisorYIn == divisorYOut);

	MDrawDeviceOrigin* originInterface = NULL;
	err = iDrawDevice->GetInterface(KDrawDeviceOriginInterfaceID, 
									 reinterpret_cast <TAny*&> (originInterface));
	TEST2(err, KErrNone);
	TEST(originInterface != NULL);

	const TPoint ptOriginIn(20, 45);
	TPoint ptOriginOut;
	err = originInterface->Set(ptOriginIn);
	TEST2(err, KErrNone);
	originInterface->Get(ptOriginOut);
	TEST(ptOriginIn == ptOriginOut);

	SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);
	}

//Creates screen device and initializes ::DrawDevice global variable.
template <class TPixelType>
void CTScaling<TPixelType>::CreateScreenDeviceL()
	{
	if (iDisplayMode == ENone)
		return;
	
	TInt address = NULL;
	User::LeaveIfError(HAL::Get(KDefaultScreenNo, HALData::EDisplayMemoryAddress,address));
	User::LeaveIfError(HAL::Get(KDefaultScreenNo, HALData::EDisplayXPixels, iPhysSize.iWidth));
	User::LeaveIfError(HAL::Get(KDefaultScreenNo, HALData::EDisplayYPixels, iPhysSize.iHeight));
	__ASSERT_DEBUG(iPhysSize.iWidth > 0 && iPhysSize.iHeight > 0 && address != NULL, User::Invariant());

	TPckgBuf<TScreenInfoV01> info;
	info().iScreenAddressValid = ETrue;
	info().iScreenAddress = reinterpret_cast <void*> (address);
	info().iScreenSize = iPhysSize;

	iDrawDevice = CFbsDrawDevice::NewScreenDeviceL(info(), iDisplayMode);
	TestScalingSettingsInterface();
	iBits = new (ELeave) TPixelType[::ByteSize(EColor256, iPhysSize)];
	iDrawDevice->SetUserDisplayMode(iDisplayMode);
	iDrawDevice->SetAutoUpdate(EFalse);
	iDrawDevice->SetBits(iBits);
	

	}

template <class TPixelType>
void CTScaling<TPixelType>::PerformanceTest()
	{
	INFO_PRINTF1(_L("CFbsDrawDevice, scaling - WriteRgb() performance test"));

	const TInt KDrawingsCnt = 1000000;
	TInt i, x, y;

	TUint time1 = User::TickCount();
	x = y = 0;
	for(i=0;i<KDrawingsCnt;i++)
		{
		if(++x > 50)
			{
			x = 0;
			if(++y > 50)
				{
				y = 0;
				}
			}
		TRgb val(0x11, 0x12, i);
		iDrawDevice->WriteRgb(x, y, val, CGraphicsContext::EDrawModePEN);
		}
	time1 = User::TickCount() - time1;

	TPoint ptOrigin(5, 3);
	SetScalingSettings(ptOrigin, KScalingFactorX, KScalingFactorY, 1, 1);

	TUint time2 = User::TickCount();
	x = y = 0;
	for(i=0;i<KDrawingsCnt;i++)
		{
		if(++x > 50)
			{
			x = 0;
			if(++y > 50)
				{
				y = 0;
				}
			}
		TRgb val(0x11, 0x12, i);
		iDrawDevice->WriteRgb(x, y, val, CGraphicsContext::EDrawModePEN);
		}
	time2 = User::TickCount() - time2;

	SetScalingSettings(TPoint(0, 0), 1, 1, 1, 1);

	RDebug::Print(_L("Non-scaled device, time=%d\r\n"), time1);
	RDebug::Print(_L("Scaled device, time=%d\r\n"), time2);
	}

template <class TPixelType>
void CTScaling<TPixelType>::RunTestCaseL(TInt aCurTestCase)
	{
	// EColor64K and EColor256 is not supported, stop the test
	if (iDisplayMode == ENone)
		{
		INFO_PRINTF1(_L("EColor64K and EColor256 are not supported, The test is not run"));
		TestComplete();
		}
	
	else
		{
	    ((CTScalingStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);
		switch(aCurTestCase)
			{
		case 1:
			{
			if(iCurOrientation >= KOrientationsCnt)
				{
				((CTScalingStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
				TestComplete();
				}
			else
				{
				((CTScalingStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
				if (iCurOrientation==CFbsDrawDevice::EOrientationRotated90 || iCurOrientation==CFbsDrawDevice::EOrientationRotated270)
					{
					iScalingFactorX=KScalingFactorY;
					iScalingFactorY=KScalingFactorX;
					}
				else
					{
					iScalingFactorX=KScalingFactorX;
					iScalingFactorY=KScalingFactorY;
					}
				INFO_PRINTF3(_L("Set scalling %d,%d"),iScalingFactorX,iScalingFactorY);
				if(iDrawDevice->SetOrientation(KOrientation[iCurOrientation]))
					{
					INFO_PRINTF2(_L("Set orientation: ===EOrientation%S==="),&RotationName(iCurOrientation));
					}
				else
					{
					INFO_PRINTF2(_L("Failed to set orientation: ===EOrientation%S==="),&RotationName(iCurOrientation));
					ResetCounter();
					}
				iCurOrientation++;
				}	
			}	
			break;
		case 2:
/**
	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0022
*/
            ((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0022"));
			WriteLine();
			break;
		case 3:
/**
	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0023
*/
			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0023"));
			WriteRgb();
			break;
		case 4:
/**
	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0024
*/
			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0024"));
			WriteRgbMulti();
			break;
		case 5:
/**
	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0025
*/
			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0025"));
			WriteRgbAlphaLine();
			break;
		case 6:
/**
	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0026
*/
			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0026"));
			WriteBinary();
			break;
		case 7:
/**
	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0027
*/
			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0027"));
			WriteBinaryLineVertical();
			break;
		case 8:
/**
	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0028
*/
			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0028"));
			WriteBinaryLine();
			break;
		case 9:
/**
	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0029
*/
			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0029"));
			WriteRgbAlphaMulti();
			break;
		case 10:
/**
	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0030
*/
			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0030"));
			ShadowArea();
			break;
		case 11:
/**
	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0031
*/
			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0031"));
			WriteRgbAlphaLine2();
			break;
		case 12:
/**
	@SYMTestCaseID GRAPHICS-SCREENDRIVER-0032
*/
			((CTScalingStep*)iStep)->SetTestStepID(_L("GRAPHICS-SCREENDRIVER-0032"));
			PerformanceTest();
			break;
		case 13:
			((CTScalingStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);
			ResetCounter();
			break;
			}
           ((CTScalingStep*)iStep)->RecordTestResultL();
		}
	}
	
static TDisplayMode GetDisplayModeL()
	{
	TDisplayMode mode = EColor64K;
	CFbsDrawDevice* device = NULL;
	TRAPD(err, device = CFbsDrawDevice::NewScreenDeviceL(KDefaultScreenNo, mode));
	if (err!=KErrNone)
		{
		mode = EColor256;
		TRAPD(err, device = CFbsDrawDevice::NewScreenDeviceL(KDefaultScreenNo, mode));
		
		if (err == KErrNotSupported)
			{
			return ENone;
			}
		}
	delete device;
	return mode;
	}

//---------------
CTScalingStep::CTScalingStep() 
	{ 
	SetTestStepName(KTScalingStep); 
	} 
	 
CTGraphicsBase* CTScalingStep::CreateTestL()
	{ 
	CTGraphicsBase* theTest = NULL;
	switch (GetDisplayModeL())
		{
		case EColor64K:
			{
			INFO_PRINTF1(_L("Scaling - EColor64K"));
			theTest = new (ELeave) CTestColor64K(this, EColor64K);
			}
			break;
	
		case EColor256:
			{
			INFO_PRINTF1(_L("Scaling - EColor256"));
			theTest = new (ELeave) CTestColor256(this, EColor256);
			}
			break;

		default:
			INFO_PRINTF1(_L("EColor64K and EColor256 are not supported"));
			theTest = new (ELeave) CTestNone(this, ENone);			
		}
	return 	theTest;		
	} 

void CTScalingStep::TestSetupL()
	{
	TInt temp = 0;
	HAL::Get(KDefaultScreenNo, HALData::EDisplayColors, temp);//force HAL memory allocation
	
	}