// 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

 	}