// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "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:

 // This test should not depend on any external data files and should work with

 // the default (empty) epoc.ini file.

 // The test should be run without the Graphics GCE enabled but with the Base GCE

 // driver enabled. On the emulator this can be done by launcing with -Dtextshell --

 // and on the H4 build a textshell ROM with -DSYMBIAN_BASE_USE_GCE but NOT 

 // -DSYMBIAN_GRAPHICS_USE_GCE

 // In the visual tests some flickering may occur due to updates to the console. On

 // the emulator it is possible to configure a second screen so that the console updates

 // will only happen on one screen. The test automatically runs on every screen available.

 // 

 //

 #define __E32TEST_EXTENSION__

 #include <dispchannel.h>

 #include <e32std.h>

 #include <e32std_private.h>

 #include <e32def.h>

 #include <e32def_private.h>

 #include <e32svr.h>

 #include <e32test.h>

 #include <pixelformats.h>

 #include <hal.h>

 RTest test(_L("Display Channel device driver unit tests"));

 /** Maximum probable pixel resolution width or height */

 static const TInt KMaxExpectedPixelRes = 10000;

 /** Unlikely to ever have a > 1000 Hz refresh rate */

 static const TInt KMaxExpectedRefreshRate = 1000;

 /** Time (in microseconds) for each visual test */

 static const TInt KDrawWaitTime = 1000000;

 /** Array of supported rotations */

 static const RDisplayChannel::TDisplayRotation KRotations[] = {

 		RDisplayChannel::ERotationNormal, 

 		RDisplayChannel::ERotation90CW,

 		RDisplayChannel::ERotation180,

 		RDisplayChannel::ERotation270CW};

 static const TInt KNumRotations = sizeof(KRotations) / sizeof(RDisplayChannel::TDisplayRotation);

 /** Array of pixel formats to try for visual test */

 static const RDisplayChannel::TPixelFormat KPixelFormats[] = {

 	EUidPixelFormatYUV_422Interleaved16bit,	// not supported on emulator but should not be a fatal error

 	EUidPixelFormatXRGB_4444,	

 	EUidPixelFormatARGB_4444,

 	EUidPixelFormatRGB_565,

 	EUidPixelFormatXRGB_8888,

 	EUidPixelFormatARGB_8888,

 	EUidPixelFormatARGB_8888_PRE	

 };

 static const TInt KNumPixelFormats = sizeof(KPixelFormats) / sizeof(RDisplayChannel::TPixelFormat);

 /**

 Encapsulates display related HAL information. 

 */

 class THalDisplayInfo 

 	{

 public:

 	TBool iIsMono;

 	TBool iIsPalettized;

 	TInt iBitsPerPixel;

 	TInt iMemoryAddress;

 	TInt iMemoryHandle;

 	TInt iState;

 	TInt iColors;

 	TInt iXPixels;

 	TInt iYPixels;

 	TInt iXTwips;

 	TInt iYTwips;

 	TInt iNumModes;	

 	TInt iMode;

 	TInt iOffsetBetweenLines;

 	TInt iOffsetToFirstPixel;

 	TBool iIsPixelOrderRGB;

 	TBool iIsPixelOrderLandscape;

 	};

 /**

 Helper class that waits for RDisplayChannel asynchronous requests and

 can cancel them if necessary. The purpose of this class is so that the main 

 test class can create an asynchronous request and also simulate the completion

 of that request e.g. faking a display change event.

 */

 class CAsyncHelper : public CActive

 	{

 public:

 	inline CAsyncHelper(RDisplayChannel& aDisp);

 	inline ~CAsyncHelper();

 	inline TRequestStatus& Status();

 	void WaitForOperation(TInt* aResult);

 private:

 	// From CActive

 	inline void DoCancel();

 	inline void RunL();	

 private:

 	RDisplayChannel& iDisp;

 	TInt* iResult;

 	};

 inline CAsyncHelper::CAsyncHelper(RDisplayChannel& aDisp) : CActive(EPriorityHigh), iDisp(aDisp) {CActiveScheduler::Add(this);}

 inline CAsyncHelper::~CAsyncHelper() {Deque();}

 inline TRequestStatus& CAsyncHelper::Status() {return iStatus;}

 // Writes the iStatus.Int() to the address defined by the client of this AO

 inline void CAsyncHelper::RunL() {*iResult = iStatus.Int();}

 void CAsyncHelper::WaitForOperation(TInt* aResult)

 /**

 Invokes SetActive() to wait for the asynchronous operation to complete. The completion

 code is copied to the aResult when RunL is invoked.

 @param aResult	out parameter that will be set to iStatus.Int()

 */

 	{

 	iResult = aResult; 	

 	// Set the result to default value that is unlikely to be returned by the real API

 	*aResult = KMaxTInt;

 	SetActive();

 	}

 void CAsyncHelper::DoCancel()

 	{

 	// Driver should fail if cancel is called when there is not standing request

 	// so cancel just attempts to cancel everything.

 	iDisp.CancelGetCompositionBuffer();

 	iDisp.CancelPostUserBuffer();

 	iDisp.CancelWaitForPost();

 	iDisp.NotifyOnDisplayChangeCancel();

 	}

 /**

 Class to test device driver for RDisplayChannel

 */

 class CDisplayChannelTest : public CActive

 	{

 	enum TTestState {

 		ETestDisplayInfo,

 		ETestCompositionBuffers,

 		ETestUserBuffers,

 		ETestRotations,

 		ETestDisplayChange,

 		ETestDisplayChangeDoCancel,

 		ETestDisplayChangeCheckCancel,

 		ETestGetCompositionBufferDoCancel,

 		ETestGetCompositionBufferCheckCancel,

 		ETestWaitForPostDoCancel,

 		ETestWaitForPostCheckCancel,

 		ETestResolutions,

 		ETestPixelFormats,

 		ETestBufferFormats,

 		ETestV11inV10,

 		EVisualTest,

 		ETestSecondHandle,

 		ETestBufferTransitions,

 		ETestFinished

 	};

 	public:

 		static CDisplayChannelTest* NewLC(TInt aScreenId);

 		void Start();

 		~CDisplayChannelTest();

 	private:		

 		// From CActive

 		void DoCancel();

 		TInt RunError(TInt aError);

 		void RunL();

 	private:		

 		CDisplayChannelTest(TInt aScreenId);

 		void CompleteSelf(TTestState aNextState);

 		// The tests

 		void CheckDisplayInfo();

 		void CheckResolutions();

 		void CheckPixelFormats();

 		void CheckDisplayChange();

 		void CheckCompositionBuffers();

 		void CheckBufferFormat();

 		void CheckUserBuffers();

 		void CheckRotations();

 		TBool IsValidRotation(RDisplayChannel::TDisplayRotation aRotation);

 		TBool IsValidPixelFormat(RDisplayChannel::TPixelFormat aPixelFormat);		

 		void CheckSetRotation(TUint aSupported, RDisplayChannel::TDisplayRotation aNewRotation);

 		void CheckV11inV10();

 		void VisualTest();

 		void DrawLegacyBuffer(TInt aStep);

 		void DrawFillToMemory(TUint8* aFirstPixelAddr, TInt aOffsetBetweenLines, 

 				RDisplayChannel::TPixelFormat aPixelFormat, TInt aWidth, TInt aHeight, TInt aStep);

 		void DrawCompositionBuffer(

 				RDisplayChannel::TPostCount& aPostCount, 

 				RDisplayChannel::TBufferFormat aBufferFormat,

 				RDisplayChannel::TDisplayRotation aRotation, TInt aStep);

 		void GetHalDisplayInfo();

 		void CheckSecondHandle();

 		void TestBufferTransitions();

 	private:

 		RDisplayChannel iDisp;			/// handle to display channel device driver

 		TVersion iVersion;				/// version number of disp channel driver interface

 		THalDisplayInfo iHalInfo;		/// info about legacy buffer from HAL

 		TInt iScreenId;					/// run tests on each screen

 		TTestState iState;				/// the current test

 		CAsyncHelper *iAsyncHelper;				

 		TInt iAsyncHelperResult;		/// set to iAyncHelper::iStatus.Int()

 		RArray<RDisplayChannel::TResolution> iResolutions;

 		RArray<RDisplayChannel::TPixelFormat> iPixelFormats;

 		TInt iVisualTestFormatIndex;		/// index of the current pixel format in visual test 

 		TInt iVisualTestRotationIndex;		/// index of the current rotation in the visual test

 		TUint iDummyCompositionBuffer;		/// dummy var used to test cancel of GetCompositionBuffer

 		RDisplayChannel::TPostCount iDummyPostCount;	/// dummy var used to test CancelWaitForPost 

 	};

 // Gets a HAL value, logs the result and errors if HAL::Get failed

 #define DBG_HAL(DEVICE, ATT, VAL, ERR, IN) \

 	{ \

 	VAL = IN;\

 	ERR = HAL::Get(DEVICE, ATT, VAL); \

 	test.Printf(_L(#ATT)); \

 	test.Printf(_L(" device %d err = %d, val = %d\n"), DEVICE, ERR, VAL); \

 	test_KErrNone(ERR); \

 	}

 void CDisplayChannelTest::GetHalDisplayInfo()

 /**

 Retrieves display related HAL settings. This also initialises the legacy buffer by retrieving

 HAL::EDisplayMemoryAddress

 */

 	{

 	TInt err = KErrNotSupported;	

 	DBG_HAL(iScreenId, HAL::EDisplayMemoryAddress, iHalInfo.iMemoryAddress, err, 0);

 	iHalInfo.iMemoryHandle = 0;

 	err = HAL::Get(iScreenId, HAL::EDisplayMemoryHandle, iHalInfo.iMemoryHandle);

 	test(err == KErrNone || err == KErrNotSupported);

 	test.Printf(_L("HAL::EDisplayMemoryHandle returned err %d\n"), err);

 	if (err == KErrNone)

 		{

 		// Handle is not needed so don't leak it

 		RHandleBase h;

 		h.SetHandle(iHalInfo.iMemoryHandle);

 		h.Close();

 		}

 	// This is mostly for information purposes to ensure the legacy buffer is sane.

 	DBG_HAL(iScreenId, HAL::EDisplayState, iHalInfo.iState, err, 0);

 	DBG_HAL(iScreenId, HAL::EDisplayColors, iHalInfo.iColors, err, 0);

 	DBG_HAL(iScreenId, HAL::EDisplayXPixels, iHalInfo.iXPixels, err, 0);

 	DBG_HAL(iScreenId, HAL::EDisplayYPixels, iHalInfo.iYPixels, err, 0);

 	DBG_HAL(iScreenId, HAL::EDisplayXTwips, iHalInfo.iXTwips, err, 0);

 	DBG_HAL(iScreenId, HAL::EDisplayYTwips, iHalInfo.iYTwips, err, 0);	

 	DBG_HAL(iScreenId, HAL::EDisplayIsPixelOrderRGB, iHalInfo.iIsPixelOrderRGB, err, 0);

 	DBG_HAL(iScreenId, HAL::EDisplayIsPixelOrderLandscape, iHalInfo.iIsPixelOrderLandscape, err, 0);

 	DBG_HAL(iScreenId, HAL::EDisplayNumModes, iHalInfo.iNumModes, err, 0);		

 	DBG_HAL(iScreenId, HAL::EDisplayMode, iHalInfo.iMode, err, 0);

 	// Get info for current display mode

 	DBG_HAL(iScreenId, HAL::EDisplayIsMono, iHalInfo.iIsMono, err, iHalInfo.iMode);

 	DBG_HAL(iScreenId, HAL::EDisplayBitsPerPixel, iHalInfo.iBitsPerPixel, err, iHalInfo.iMode);

 	DBG_HAL(iScreenId, HAL::EDisplayOffsetBetweenLines, iHalInfo.iOffsetBetweenLines, err, iHalInfo.iMode);

 	DBG_HAL(iScreenId, HAL::EDisplayOffsetToFirstPixel, iHalInfo.iOffsetToFirstPixel, err, iHalInfo.iMode);

 	DBG_HAL(iScreenId, HAL::EDisplayIsPalettized, iHalInfo.iIsPalettized, err, iHalInfo.iMode);

 	}

 CDisplayChannelTest::CDisplayChannelTest(TInt aScreenId)

 /**

 Constructor

 @param aScreenId	the screen number to run the test on

 */

 	: CActive(EPriorityStandard), iScreenId(aScreenId)

 	{	

 	TVersion versionRequired = iDisp.VersionRequired();

 	test.Printf(_L("*** Opening display channel for screen %d. Test compiled against version %d.%d.%d ***\n"),

 			iScreenId, versionRequired.iMajor, versionRequired.iMinor, versionRequired.iBuild);

 	TInt err = iDisp.Open(iScreenId);

 	test_KErrNone(err);

 	test.Printf(_L("Successfully opened display channel for screen %d\n"), iScreenId);

 	// This test should be updated if a change to the driver requires a version change

 	err = iDisp.Version(iVersion);

 	if (err == KErrNotSupported)

 		{

 		test.Printf(_L("Version API not supported. Assuming v1.0.0\n"));

 		iVersion.iMajor = 1;

 		iVersion.iMinor = 0;

 		iVersion.iBuild = 0;

 		}

 	else

 		{

 		test.Printf(_L("Display channel driver version %d.%d.%d\n"), 

 				iVersion.iMajor, iVersion.iMinor, iVersion.iBuild);

 		test_KErrNone(err);

 		}

 	test(iVersion.iMajor >= 1 && iVersion.iMinor >= 0);		

 	GetHalDisplayInfo();

 	CActiveScheduler::Add(this);

 	iAsyncHelper = new CAsyncHelper(iDisp);

 	test_NotNull(iAsyncHelper);

 	}

 CDisplayChannelTest::~CDisplayChannelTest()

 /**

 Destructor

 */

 	{

 	Deque();

 	delete iAsyncHelper;

 	iPixelFormats.Close();

 	iResolutions.Close();

 	iDisp.Close();	

 	}

 CDisplayChannelTest* CDisplayChannelTest::NewLC(TInt aScreenId)

 /**

 Factory method that creates a new instance of the screen

 display channel unit test object and places a pointer to this on the cleanup stack

 @param aScreenId	the screen number to run the test on

 @return	a pointer to the new CDisplayTest object.

 */

 	{

 	CDisplayChannelTest* self = new(ELeave) CDisplayChannelTest(aScreenId);

 	CleanupStack::PushL(self);

 	return self;

 	}

 void CDisplayChannelTest::CheckDisplayInfo()

 /**

 Check the values returned by CheckDisplayInfo

 */

 	{

 	test.Next(_L("Test GetDisplayInfo"));

 	TPckgBuf<RDisplayChannel::TDisplayInfo> infoPkg;

 	test_KErrNone(iDisp.GetDisplayInfo(infoPkg));

 	// This test only works with 24 and 32 BPP displays and crashes otherwise.  Test for this and display

 	// a nice human readable message rather than just crashing

 	if ((infoPkg().iBitsPerPixel != 24) && (infoPkg().iBitsPerPixel != 32))

 		{

 		TBuf<256> message;

 		message.Format(_L("*** Error! %d bits per pixel displays are not supported. ***\n*** Please configure your ROM to use 24 or 32 bits per pixel.  ***\n"), infoPkg().iBitsPerPixel);

 		test.Printf(message);

 		// And fail the test for the benefit of automated ONB tests

 		test_Equal(infoPkg().iBitsPerPixel, 24);

 		}

 	test_Compare(infoPkg().iBitsPerPixel, >=, 1);

 	test_Compare(infoPkg().iAvailableRotations, !=, 0);

 	// check for invalid rotations i.e. those not defined by TRotation

 	test((infoPkg().iAvailableRotations & 0xFFF0) == 0);

 	// Check that the refresh rate field isn't garbage

 	test_Compare(infoPkg().iRefreshRateHz, >=, 1);

 	test_Compare(infoPkg().iRefreshRateHz, <=, KMaxExpectedRefreshRate);

 	// Should always be at least one composition buffer

 	test_Compare(infoPkg().iNumCompositionBuffers, >=, 1);

 	}

 void CDisplayChannelTest::CheckResolutions()

 /**

  Validate that the APIs to get / set resolutions.

  Tests<br>

  NumberOfResolutions, GetResolutions, GetResolution, GetRotation

  */

 	{

 	test.Next(_L("Test NumberOfResolutions, GetResolutions, GetResolution, GetRotation"));

 	// Get and reserve space for expected number of resolutions

 	TInt n = iDisp.NumberOfResolutions();

 	test_Compare(n, >=, 1);

 	iResolutions.Reset();

 	test_KErrNone(iResolutions.Reserve(n));

 	for (TInt i = 0; i < n; ++i)

 		{

 		test_KErrNone(iResolutions.Append(RDisplayChannel::TResolution(TSize(0,0), TSize(0,0), 0)));

 		}

 	// Retrieve the resolutions and make sure the number of resolutions returned matches the 

 	// expected number. It is assumed that the display state won't be changed during the execution

 	// of this test.

 	TInt actualResolutions = 0;	

 	TPtr8 resPtr(reinterpret_cast<TUint8*>(&iResolutions[0]), 

 			sizeof(RDisplayChannel::TResolution) * n, sizeof(RDisplayChannel::TResolution) * n);

 	test_KErrNone(iDisp.GetResolutions(resPtr, actualResolutions));

 	test_Equal(n, actualResolutions);	

 	test.Printf(_L("Supported resolutions"));

 	for (TInt res = 0; res < n; ++res)

 		{

 		RDisplayChannel::TResolution& r = iResolutions[res];

 		test.Printf(_L("pixelX = %d heightX = %d twipsX = %d twipsY = %d flags = 0x%08x\n"), 

 				r.iPixelSize.iWidth, r.iPixelSize.iHeight, r.iTwipsSize.iWidth, r.iTwipsSize.iHeight, r.iFlags);		

 		// If either pixel height or pixel width is zero then both must be zero

 		// If either pixel height or pixel width is non-zero then both must be positive

 		test((r.iPixelSize.iHeight == 0 && r.iPixelSize.iWidth == 0) ||

 			 (r.iPixelSize.iHeight > 0 && r.iPixelSize.iWidth > 0));

 		// Test resolutions are sane

 		test(r.iPixelSize.iHeight <= KMaxExpectedPixelRes && r.iPixelSize.iWidth <= KMaxExpectedPixelRes);

 		// If either twips height or pixel width is zero then both must be zero

 		// If either twips height or pixel width is non-zero then both must be positive

 		test((r.iTwipsSize.iHeight == 0 && r.iTwipsSize.iWidth == 0) ||

 			 (r.iTwipsSize.iHeight > 0 && r.iTwipsSize.iWidth > 0));

 		// twips resolution can be zero iff pixel resolution is also zero

 		test((r.iPixelSize.iHeight == 0 && r.iTwipsSize.iHeight == 0) ||

 			 (r.iPixelSize.iHeight > 0  && r.iTwipsSize.iHeight > 0));

 		// At least one rotation must be supported. Ignore other bits in the flags field

 		test(r.iFlags & RDisplayChannel::ERotationAll != 0);

 		}

 	// Get current resolution in pixels

 	TSize currentResolution;

 	test_KErrNone(iDisp.GetResolution(currentResolution));

 	// Get current resolution in twips

 	TSize currentTwips;

 	test_KErrNone(iDisp.GetTwips(currentTwips));

 	RDisplayChannel::TDisplayRotation currentRotation = iDisp.CurrentRotation();

 	test(IsValidRotation(currentRotation));

 	// The current resolution and rotation must be in the list of supported resolutions

 	TBool foundCurrentRes = EFalse;

 	for (TInt j = iResolutions.Count() - 1; j >= 0; --j)

 		{

 		if (iResolutions[j].iPixelSize == currentResolution &&

 			iResolutions[j].iTwipsSize == currentTwips &&

 			iResolutions[j].iFlags & currentRotation)

 			{

 			foundCurrentRes = ETrue;

 			break;

 			}

 		}

 	test(foundCurrentRes);

 	// Now and try every supported resolution

 	TInt err;

 	for (TInt k = iResolutions.Count() - 1; k >= 0; --k)

 		{

 		err = iDisp.SetResolution(iResolutions[k].iPixelSize);

 		test(err == KErrNone || err == KErrNotSupported);

 		}

 	// attempt to set back to original resolution, this could fail

 	err = iDisp.SetResolution(currentResolution);

 	test(err == KErrNone || err == KErrNotSupported);

 	}

 void CDisplayChannelTest::CheckPixelFormats()

 /**

  Validates that the pixel format APIs are sane/consistent.

  In version 1.1 the APIs are just stubs that return KErrNotSupported

  */

 	{

 	test.Next(_L("Test NumberOfPixelFormats, GetPixelFormats"));

 	// At least one pixel format must be supported

 	TInt n = iDisp.NumberOfPixelFormats();

 	if (iVersion.iMajor == 1 && iVersion.iMinor <= 1)

 		{

 		test_Compare(n, ==, KErrNotSupported);

 		n = 1; // Override return to test stub for GetPixelFormats

 		}

 	else

 		{

 		test_Compare(n, >=, 1);

 		}

 	TInt err = iPixelFormats.Reserve(n);

 	test_KErrNone(err);

 	for (TInt i = 0; i < n; ++i)

 		{

 		test_KErrNone(iPixelFormats.Append(-1));

 		}

 	TPtr8 pixelFormatsPtr(reinterpret_cast<TUint8*>(&iPixelFormats[0]),

 			sizeof(RDisplayChannel::TPixelFormat) * n, sizeof(RDisplayChannel::TPixelFormat) * n);		

 	TInt actualFormats = -1;	

 	if (iVersion.iMajor == 1 && iVersion.iMinor <= 1)

 		{

 		test_Compare(iDisp.GetPixelFormats(pixelFormatsPtr, actualFormats), ==, KErrNotSupported);

 		}

 	else

 		{		

 		test_KErrNone(iDisp.GetPixelFormats(pixelFormatsPtr, actualFormats));

 		// The number of formats shouldn't have changed whilst this test is running

 		test_Equal(n, actualFormats);			

 		RArray<RDisplayChannel::TPixelFormat> pixelFormatsArray(

 				reinterpret_cast<RDisplayChannel::TPixelFormat*>(&pixelFormatsPtr[0]), actualFormats);

 		// Check the pixel formats returned are all valid

 		for (TInt pf = pixelFormatsArray.Count() - 1; pf >= 0; --pf)

 			{

 			IsValidPixelFormat(pixelFormatsArray[pf]);

 			}		

 		}

 	}

 void CDisplayChannelTest::CheckDisplayChange()

 /**

  Register for display change notification then immediately cancel.

  */

 	{

 	test.Next(_L("Test NotifyOnDisplayChange, NotifyOnDisplayChangeCancel"));

 	// Cancel should be allowed even if NotifyOnyDisplayChange has not been called

 	iDisp.NotifyOnDisplayChangeCancel();

 	iDisp.NotifyOnDisplayChange(iAsyncHelper->Status());

 	iAsyncHelper->WaitForOperation(&iAsyncHelperResult);

 	}

 void CDisplayChannelTest::DrawFillToMemory(

 		TUint8* aFirstPixelAddr, 

 		TInt aOffsetBetweenLines, 

 		RDisplayChannel::TPixelFormat aPixelFormat, 

 		TInt aWidth, 

 		TInt aHeight, 

 		TInt aStep)

 /** 

  Draws a shaded fill to a memory region

  @param	aFirstPixelAddr			the address of the first pixel in the buffer.

  @param	aOffsetBetweenLines		offset between pixels at the start of each line

  @param aBpp					bits per pixel

  @param	aWidth					width of the region in pixels

  @param aHeight					height of the region in pixels

  @aStep	aStep					integer >= 1 to vary the pattern by test number 

  */	{

 	test.Printf(_L("DrawFileToMemory\npixelformat = 0x%08x offsetbetweenlines = %d pixel address = 0x%08x width=%d height = %d\n"), 

 			aPixelFormat, aOffsetBetweenLines, aFirstPixelAddr, aWidth, aHeight);	

 	TInt xShadeMax = 0xFF;

 	TInt yShadeMax = 0xFF;

 	if (aPixelFormat == EUidPixelFormatRGB_565)

 		{

 		xShadeMax = 0x3F;	// 6 bits for green

 		yShadeMax = 0x1F;

 		}

 	else if (aPixelFormat == EUidPixelFormatARGB_4444 || aPixelFormat == EUidPixelFormatXRGB_4444)

 		{

 		xShadeMax = 0x0F;

 		yShadeMax = 0x0F;

 		}

 	aStep = Max(1, aStep);

 	TUint8* lineAddr = aFirstPixelAddr;

 	for (TInt y = 0; y < aHeight; ++y)

 		{

 		TInt yShade = (y * yShadeMax) / aHeight;

 		TUint8* pixelAddr = lineAddr;

 		for (TInt x = 0; x < aWidth; ++x)

 			{

 			TInt xShade = (x * xShadeMax) / aWidth;			

 			TUint8 red = 0;

 			TUint8 green = 0;

 			TUint8 blue = 0;

 			if ( aStep == 0 || y > aStep * 10)

 				{

 				// Green top left, blue bottom right

 				green = static_cast<TUint8>(xShadeMax - xShade);

 				blue = static_cast<TUint8>(yShade);

 				}							

 			else

 				{

 				// The size of the red band indicates different test steps			

 				red = static_cast<TUint8>((yShadeMax * x) / aWidth);

 				}

 			if (aPixelFormat == EUidPixelFormatRGB_565)

 				{

 				*pixelAddr++ = static_cast<TUint8>(blue | (green << 5));

 				*pixelAddr++ = static_cast<TUint8>((green >> 3) | (red << 3));

 				}

 			else if (aPixelFormat == EUidPixelFormatARGB_4444 || aPixelFormat == EUidPixelFormatXRGB_4444)

 				{

 				*pixelAddr++ = static_cast<TUint8>(blue | (green << 4));

 				*pixelAddr++ = red;					

 				}

 			else if (aPixelFormat == EUidPixelFormatXRGB_8888 || aPixelFormat == EUidPixelFormatARGB_8888 

 					|| aPixelFormat == EUidPixelFormatARGB_8888)

 				{

 				*pixelAddr++ = blue;

 				*pixelAddr++ = green;

 				*pixelAddr++ = red;

 				*pixelAddr++ = 0xFF;	// unused

 				}

 			}

 		lineAddr += aOffsetBetweenLines;

 		}

 	}

 void CDisplayChannelTest::DrawLegacyBuffer(TInt aStep)

 	{

 	test.Printf(_L("DrawLegacyBuffer\n"));

 	TInt oldMode;

 	TInt err;

 	err = HAL::Get(iScreenId, HAL::EDisplayMode, oldMode);

 	for (TInt i = 0; i < iHalInfo.iNumModes; ++i)

 		{

 		// Attempt to set the legacy buffer to a mode supporting 32bit (RGBA or RGBX)

 		TInt modeBpp = i;

 		err = HAL::Get(iScreenId, HAL::EDisplayBitsPerPixel, modeBpp);

 		test_KErrNone(err);				

 		if ((modeBpp == 24 || modeBpp == 32))

 			{

 			TInt newMode = i;

 			err = HAL::Set(iScreenId, HAL::EDisplayMode, newMode);

 			break;

 			}

 		}

 	GetHalDisplayInfo();

 	err = HAL::Set(iScreenId, HAL::EDisplayMode, oldMode);

 	TUint8* firstPixelAddr = reinterpret_cast<TUint8*>(iHalInfo.iMemoryAddress + iHalInfo.iOffsetToFirstPixel);

 	TInt offsetBetweenLines = iHalInfo.iOffsetBetweenLines;

 	TInt width = iHalInfo.iXPixels;

 	TInt height = iHalInfo.iYPixels;

 	if ((! iHalInfo.iIsPalettized) && iHalInfo.iIsPixelOrderRGB)

 		{		

 		DrawFillToMemory(firstPixelAddr, offsetBetweenLines,

 				EUidPixelFormatXRGB_8888, width, height, aStep);

 		}

 	}

 void CDisplayChannelTest::DrawCompositionBuffer(

 		RDisplayChannel::TPostCount& aPostCount,

 		RDisplayChannel::TBufferFormat aBufferFormat,

 		RDisplayChannel::TDisplayRotation aRotation, TInt aStep)

 /**

 Attempts to set the requested buffer format and rotation then draws a shaded fill 

 to the buffer returned by RDisplayChannel::GetCompositionBuffer.

 If it is not possible to set the desired buffer format then the actual buffer format

 is used.

 @param	aPostCount		out parameter that is set to the post count returned by PostCompositionBuffer

 @param	aBufferFormat	the buffer format to use for this test step

 @param	aRotation		the rotation to set for this test step

 @param	aStep			test step number

 */

 	{

 	test.Printf(_L("DrawCompositionBuffer\n"));

 	TBool configChanged;

 	TInt err;

 	RDisplayChannel::TBufferFormat actualBufferFormat(TSize(0,0),0);

 	if (iVersion.iMajor > 1 || iVersion.iMinor > 0)

 		{

 		// It should be possible to set the rotation and the buffer format in either order.

 		// To test this the order is swapped every test step

 		if (aStep % 2 == 0)

 			{

 			test_KErrNone(iDisp.SetRotation(aRotation, configChanged));

 			err = iDisp.SetBufferFormat(aBufferFormat);

 			}

 		else

 			{

 			err = iDisp.SetBufferFormat(aBufferFormat);		

 			test_KErrNone(iDisp.SetRotation(aRotation, configChanged));		

 			}

 		if (err != KErrNone)

 			{

 			test.Printf(_L("Unable to set buffer format 0x%08x width %d height %d"),

 					aBufferFormat.iPixelFormat, aBufferFormat.iSize.iWidth, aBufferFormat.iSize.iHeight);

 			}			

 		test_KErrNone(iDisp.GetBufferFormat(actualBufferFormat));

 		}

 	else

 		{

 		// buffer format not switched in v1.1 so test just validates post / wait for post

 		TPckgBuf<RDisplayChannel::TDisplayInfo> infoPkg;

 		test_KErrNone(iDisp.GetDisplayInfo(infoPkg));

 		err = iDisp.SetRotation(aRotation, configChanged);

 		TInt expectedErr = KErrNone;

 		if ((!IsValidRotation(aRotation)) || ((infoPkg().iAvailableRotations & aRotation) == 0))

 			{

 			expectedErr = KErrArgument;

 			}

 		test(err == expectedErr);

 		actualBufferFormat = aBufferFormat;

 		}

 	// Get the composition buffer index

 	TUint bufferIndex;

 	TRequestStatus status;

 	iDisp.GetCompositionBuffer(bufferIndex, status);

 	User::WaitForRequest(status);

 	test(status == KErrNone);

 	// Now get access to the composition buffer

 	RChunk compChunk;

 	TInt offset = 0;

 	err = iDisp.GetCompositionBufferInfo(bufferIndex, compChunk, offset);

 	test_KErrNone(err);	

 	TUint8* baseAddr = compChunk.Base();

 	TPckgBuf<RDisplayChannel::TDisplayInfo> infoPkg;

 	err = iDisp.GetDisplayInfo(infoPkg);

 	test_KErrNone(err);

 	test.Printf(_L("DrawCompositionBuffer::GetCompositionBufferInfo index = 0x%08x base = 0x%08x offset = 0x%08x\n"),

 			bufferIndex, baseAddr, offset);

 	// Find out structure of the buffer

 	TUint8* firstPixelAddr = baseAddr + offset;	

 	// Find out current display dimensions

 	TInt width;

 	TInt height;	

 	RDisplayChannel::TDisplayRotation currentRotation = iDisp.CurrentRotation();

 	test(IsValidRotation(currentRotation));

 	if (currentRotation == RDisplayChannel::ERotationNormal ||

 		currentRotation == RDisplayChannel::ERotation180)

 		{

 		width = actualBufferFormat.iSize.iWidth;

 		height = actualBufferFormat.iSize.iHeight;

 		}

 	else

 		{

 		height = actualBufferFormat.iSize.iWidth;

 		width = actualBufferFormat.iSize.iHeight;

 		}	

 	TInt offsetBetweenLines;

 	if (iVersion.iMajor > 1 || iVersion.iMinor > 0)

 		{

 		 offsetBetweenLines = iDisp.NextLineOffset(actualBufferFormat, 0);

 		}

 	else

 		{

 		// NextLineOffset not supported in v1.0 and displayinfo offset doesn't work on H4

 		offsetBetweenLines = 4 * width;

 		}

 	DrawFillToMemory(firstPixelAddr, offsetBetweenLines, actualBufferFormat.iPixelFormat, 

 			width, height, aStep);

 	err = iDisp.PostCompositionBuffer(NULL, aPostCount);

 	test_KErrNone(err);

 	User::After(KDrawWaitTime);

 	compChunk.Close();

 	}

 void CDisplayChannelTest::CheckCompositionBuffers()

 /**

  Retrieves the current composition buffer index and checks the information about

  this buffer.

  */

 	{

 	test.Next(_L("Test GetCompositionBuffer, CancelGetCompositionBuffer, GetCompositionBufferInfo, PostLegacyBuffer"));

 	iDisp.CancelGetCompositionBuffer();	// Test cancel without an outstanding call

 	TUint bufferIndex;

 	TRequestStatus status;

 	// Get with immediate cancel

 	iDisp.GetCompositionBuffer(bufferIndex, status);

 	iDisp.CancelGetCompositionBuffer();

 	test(status == KErrNone || status == KErrCancel);

 	iDisp.GetCompositionBuffer(bufferIndex, status);	// Get, no cancel

 	User::WaitForRequest(status);

 	test(status == KErrNone);

 	RChunk compChunk;

 	TInt offset = 0;

 	test_KErrNone(iDisp.GetCompositionBufferInfo(bufferIndex, compChunk, offset));

 	// client must be able to read and write to the chunk

 	test(compChunk.IsReadable());

 	test(compChunk.IsWritable());

 	test_Compare(offset, >=, 0);

 	RDisplayChannel::TPostCount postCountA;

 	RDisplayChannel::TPostCount postCountB;

 	test_KErrNone(iDisp.PostCompositionBuffer(NULL, postCountA));

 	test_KErrNone(iDisp.PostCompositionBuffer(NULL, postCountB));

 	test_Compare(postCountB - postCountA, >=, 1);

 	// Wait for first postcount value

 	iDisp.WaitForPost(postCountA, status);

 	User::WaitForRequest(status);

 	test(status == KErrNone);

 	// It should be possible to wait again on postCountA

 	// and this should complete immediately with KErrNone. However, there

 	// there is bug in the emulator causes this to wait forever.

 	compChunk.Close();

 	// Legacy buffer should have been initialised by retrieval of HAL::EDisplayMemoryAddress 

 	test_KErrNone(iDisp.PostLegacyBuffer(NULL, postCountA));

 	test_Compare(postCountA - postCountB, >=, 1);	

 	}

 void CDisplayChannelTest::VisualTest()

 /**

 Iterates over the arrays of pixel formats and rotations attempting to 

 draw a shaded fill to the composition buffer

 */

 	{

 	test.Next(_L("Visual test"));	

 	RDisplayChannel::TPostCount postCount;	

 	if (iVisualTestFormatIndex < KNumPixelFormats)

 		{

 		RDisplayChannel::TBufferFormat bufferFormat(TSize(0,0), 0);		

 		if (iVersion.iMajor == 1 && iVersion.iMinor == 0)

 			{

 			// only one format supported in v1.0 so only one loop needed

 			bufferFormat.iPixelFormat = EUidPixelFormatXRGB_8888;

 			iVisualTestFormatIndex = KNumPixelFormats - 1; 	

 			TPckgBuf<RDisplayChannel::TDisplayInfo> infoPkg;

 			iDisp.GetDisplayInfo(infoPkg);

 			bufferFormat.iSize.iWidth = infoPkg().iNormal.iWidth;

 			bufferFormat.iSize.iHeight = infoPkg().iNormal.iHeight;

 			}

 		else

 			{			

 			test_KErrNone(iDisp.GetBufferFormat(bufferFormat));

 			bufferFormat.iPixelFormat = KPixelFormats[iVisualTestFormatIndex];			

 			}

 		DrawCompositionBuffer(postCount, bufferFormat, KRotations[iVisualTestRotationIndex], iVisualTestRotationIndex);	

 		iVisualTestRotationIndex++;

 		if (iVisualTestRotationIndex >= KNumRotations)

 			{

 			iVisualTestRotationIndex = 0;

 			iVisualTestFormatIndex++;

 			}

 		iDisp.WaitForPost(postCount, iStatus);

 		SetActive();

 		}

 	else

 		{

 		// Test drawing to the legacy buffer

 		test.Printf(_L("Drawing to legacy buffer\n"));

 		TBool configChanged;

 		iDisp.SetRotation(KRotations[0], configChanged);		

 		DrawLegacyBuffer(20); // Make legacy buffer obviously different

 		test_KErrNone(iDisp.PostLegacyBuffer(NULL, postCount));

 		CompleteSelf(ETestSecondHandle);

 		User::After(KDrawWaitTime);

 		}

 	}

 void CDisplayChannelTest::CheckBufferFormat()

 /**

  Tests the APIs for getting and setting the buffer format.

   In version 1.1 these APIs are only stubs that return KErrNotSupported

  @pre CheckResolutions must have called prior to calling this method

  @pre CheckPixelFormats must have been called prior to calling this method.

  */

 	{

 	test.Next(_L("Test GetBufferFormat, SetBufferFormat, NextLineOffset, NextPlaneOffset"));

 	RDisplayChannel::TBufferFormat bufferFormat(TSize(0,0), 0);

 	TInt err = iDisp.GetBufferFormat(bufferFormat);

 	if (iVersion.iMajor == 1 && iVersion.iMinor <= 1)

 		{

 		test_Compare(err, ==, KErrNotSupported);

 		}

 	else

 		{

 		test(IsValidPixelFormat(bufferFormat.iPixelFormat));

 		test(bufferFormat.iSize.iHeight > 0 && bufferFormat.iSize.iHeight > 0);

 		// Check that the buffer is at least as large as the current pixel resolution

 		TSize resSize;

  		test_KErrNone(iDisp.GetResolution(resSize));

 		test(bufferFormat.iSize.iHeight >= resSize.iHeight && bufferFormat.iSize.iWidth >= resSize.iWidth);

 		}

 	RDisplayChannel::TBufferFormat newBufferFormat(TSize(iHalInfo.iXPixels, iHalInfo.iYPixels), 0);

 	if (iVersion.iMajor == 1 && iVersion.iMinor <= 1)

 		{

 		// API not support in 1.1

 		test_Compare(iDisp.SetBufferFormat(newBufferFormat), ==, KErrNotSupported);

 		}

 	else

 		{

 		// Tests assumes that 32bpp XRGB888 is supported on most hardware

 		RDisplayChannel::TBufferFormat newBufferFormat(TSize(0,0), EUidPixelFormatXRGB_8888);

 		test_Compare(iDisp.SetBufferFormat(newBufferFormat), ==, KErrArgument);	// buffer must be large enough for resolution

 		// Should be able to current buffer format

 		test_KErrNone(iDisp.SetBufferFormat(bufferFormat));

 		}

 	// Get current information and check this against new APIs that give 

 	// line and plane information for any mode.

 	TSize currentPixelRes;

 	TSize currentTwipRes;

 	RDisplayChannel::TDisplayRotation currentRotation = iDisp.CurrentRotation();

 	RDisplayChannel::TBufferFormat currentBufferFormat(TSize(0,0), 0);

 	test_KErrNone(iDisp.GetResolution(currentPixelRes));

 	test_KErrNone(iDisp.GetTwips(currentTwipRes));

 	test_KErrNone(iDisp.GetBufferFormat(currentBufferFormat));

 	RDisplayChannel::TResolution res(currentPixelRes, currentTwipRes, currentRotation);

 	TInt planeOffset = iDisp.NextPlaneOffset(currentBufferFormat, 0);

 	if (iVersion.iMajor == 1 && iVersion.iMinor <= 1)

 		{

 		test_Compare(planeOffset, ==, KErrNotSupported);

 		}

 	else

 		{

 		// Supported in v1.1

 		test_Compare(planeOffset, >=, 0);

 		if (iVersion.iMajor > 1 || iVersion.iMinor > 1)

 			{

 			// Extended API in v1.2

 			test.Printf(_L("Check that planeoffset APIs match"));

 			TInt planeOffset2 = iDisp.NextPlaneOffset(currentBufferFormat, res, currentRotation, 0);

 			test_Compare(planeOffset, ==, planeOffset2);		

 			// check that invalid buffer formats are rejected

 			RDisplayChannel::TBufferFormat badBufferFormat(currentBufferFormat);

 			badBufferFormat.iPixelFormat = -1;

 			test(iDisp.NextPlaneOffset(badBufferFormat, res, currentRotation, 0) == KErrArgument);

 			}

 		}

 	TInt lineOffset = iDisp.NextLineOffset(currentBufferFormat, 0);	

 	if (iVersion.iMajor == 1 && iVersion.iMinor <= 1)

 		{

 		test_Compare(lineOffset, ==, KErrNotSupported);

 		}

 	else

 		{

 		test_Compare(lineOffset, >, 0);	// supported in v1.1

 		if (iVersion.iMajor > 1 || iVersion.iMinor > 1)

 			{

 			// Extended API in v1.2

 			test.Printf(_L("Check that lineoffset APIs match"));

 			TInt lineOffset2 = iDisp.NextLineOffset(currentBufferFormat, res, currentRotation, 0);

 			// stride values must be the same and > 0 for any non-zero resolution and the current

 			// resolution should not be zero in size.

 			test_Compare(lineOffset, ==, lineOffset2);

 			// check that invalid buffer formats are rejected

 			RDisplayChannel::TBufferFormat badBufferFormat(currentBufferFormat);

 			badBufferFormat.iPixelFormat = -1;

 			test(iDisp.NextLineOffset(badBufferFormat, res, currentRotation, 0) == KErrArgument);

 			}

 		}

 	}

 void CDisplayChannelTest::CheckUserBuffers()

 /**

  Test APIs that manage user composition buffers. Since this unit test doesn't

  have access to the real surfaces the tests are mostly robustness tests.

  */

 	{

 	test.Next(_L("Test WaitForPost, DeRegisterUserBuffer"));

 	// Cancel should not fail even if WaitForPost has not been called

 	iDisp.CancelWaitForPost();

 	// Check that cancelling a non-existent post request doesn't fail

 	iDisp.CancelPostUserBuffer();

 	// Make sure wait immediately followed by cancel doesn't crash

 	TRequestStatus status;

 	RDisplayChannel::TPostCount postCount = 0;

     iDisp.WaitForPost(postCount, status);

     iDisp.CancelWaitForPost();

 	test(status == KErrNone || status == KErrCancel);

 	// De-register a non-existent buffer id

 	RDisplayChannel::TBufferId badBufferId(42);

 	TInt err = iDisp.DeregisterUserBuffer(badBufferId);

 	// emulator KErrArugment but on H4 KErrNotFound	

 	test(err == KErrArgument || err == KErrNotFound);

 	// Create and use a new buffer, should fail because chunk must be a SHARED chunk

 	RChunk myChunk;

 	const TInt chunkSize = 320 * 200 * 4; // actual size is not important because this should fail

 	err =  myChunk.CreateGlobal(KNullDesC, chunkSize, chunkSize, EOwnerProcess);

 	test_KErrNone(err); // Allocation should not fail under normal conditions

 	RDisplayChannel::TBufferId myBufferId;

 	err = iDisp.RegisterUserBuffer(myBufferId, myChunk, 0);

 	// emulator KErrBadHandle but on H4 KErrArgument

 	test(err == KErrBadHandle || err == KErrArgument);

 	myChunk.Close();

 	// Try to post a request from a bad buffer id

 	iDisp.PostUserBuffer(badBufferId, status, NULL, postCount);

 	User::WaitForRequest(status);

 	// Emulator KErrArgument H4 KErrNotFound

 	test(status.Int() == KErrArgument || status.Int() == KErrNotFound);

 	// Attempt to register an already existing buffer as a user buffer

 	TUint compId;

 	iDisp.GetCompositionBuffer(compId, status);

 	User::WaitForRequest(status);

 	RChunk compChunk;

 	TInt offset;

 	test_KErrNone(iDisp.GetCompositionBufferInfo(compId, compChunk, offset));

 	test_KErrNone(iDisp.RegisterUserBuffer(myBufferId, compChunk, offset));

 	err = iDisp.DeregisterUserBuffer(myBufferId);

 	test(err == KErrNone || err == KErrInUse);

 	compChunk.Close();

 	}

 TBool CDisplayChannelTest::IsValidPixelFormat(RDisplayChannel::TPixelFormat aPixelFormat)

 /**

 Validates whether the value of aPixelFormat corresponds to a valid enum in TUidPixelFormat

 @param	aPixelFormat	the pixel format value to test

 @return	ETrue if aPixelFormat is valid; otherwise, EFalse is returned.

 */

 	{

 	switch (aPixelFormat)

 		{

 		case EUidPixelFormatUnknown:

 		case EUidPixelFormatXRGB_8888:

 		case EUidPixelFormatBGRX_8888:

 		case EUidPixelFormatXBGR_8888:

 		case EUidPixelFormatBGRA_8888:

 		case EUidPixelFormatARGB_8888:

 		case EUidPixelFormatABGR_8888:

 		case EUidPixelFormatARGB_8888_PRE:

 		case EUidPixelFormatABGR_8888_PRE:

 		case EUidPixelFormatBGRA_8888_PRE:

 		case EUidPixelFormatARGB_2101010:

 		case EUidPixelFormatABGR_2101010:

 		case EUidPixelFormatBGR_888:

 		case EUidPixelFormatRGB_888:

 		case EUidPixelFormatRGB_565:

 		case EUidPixelFormatBGR_565:

 		case EUidPixelFormatARGB_1555:

 		case EUidPixelFormatXRGB_1555:

 		case EUidPixelFormatARGB_4444:

 		case EUidPixelFormatARGB_8332:

 		case EUidPixelFormatBGRX_5551:

 		case EUidPixelFormatBGRA_5551:

 		case EUidPixelFormatBGRA_4444:

 		case EUidPixelFormatBGRX_4444:

 		case EUidPixelFormatAP_88:

 		case EUidPixelFormatXRGB_4444:

 		case EUidPixelFormatXBGR_4444:

 		case EUidPixelFormatRGB_332:

 		case EUidPixelFormatA_8:

 		case EUidPixelFormatBGR_332:

 		case EUidPixelFormatP_8:

 		case EUidPixelFormatP_4:

 		case EUidPixelFormatP_2:

 		case EUidPixelFormatP_1:

 		case EUidPixelFormatYUV_420Interleaved:

 		case EUidPixelFormatYUV_420Planar:

 		case EUidPixelFormatYUV_420PlanarReversed:

 		case EUidPixelFormatYUV_420SemiPlanar:

 		case EUidPixelFormatYUV_422Interleaved:

 		case EUidPixelFormatYUV_422Planar:

 		case EUidPixelFormatYUV_422Reversed:

 		case EUidPixelFormatYUV_422SemiPlanar:

 		case EUidPixelFormatYUV_422InterleavedReversed:

 		case EUidPixelFormatYUV_422Interleaved16bit:

 		case EUidPixelFormatYUV_444Interleaved:

 		case EUidPixelFormatYUV_444Planar:

 		case EUidPixelFormatL_8:

 		case EUidPixelFormatL_4:

 		case EUidPixelFormatL_2:

 		case EUidPixelFormatL_1:

 		case EUidPixelFormatSpeedTaggedJPEG:

 		case EUidPixelFormatJPEG:

 			return ETrue;

 		default:

 			return EFalse;

 		}

 	}

 TBool CDisplayChannelTest::IsValidRotation(RDisplayChannel::TDisplayRotation aRotation)

 /**

 Checks whether the supplied rotation is a valid rotation. <br>

 N.B. Only single rotations are accepted so EFalse is returned for ERotationAll.

 @param	aRotation	the rotation to validate

 @return ETrue if the supplied rotation is valid; otherwise, EFalse is returned.

 */

 	{

 	switch (aRotation)

 		{

 		case RDisplayChannel::ERotationNormal:

 		case RDisplayChannel::ERotation90CW:

 		case RDisplayChannel::ERotation180:

 		case RDisplayChannel::ERotation270CW:

 			return ETrue;

 		default:

 			return EFalse;

 		}

 	}

 void CDisplayChannelTest::CheckSetRotation(TUint aSupported, RDisplayChannel::TDisplayRotation aNewRotation)

 /**

 Tests the SetRotation API attempting to set the requested resolution. If the resolution is supported

 then SetRotation should succeed and the CurrentRotation should change. Otherwise, SetResolution should

 fail and the current rotation should be unchanged.

 @param	aSupported		The set of supported resolutions for TDisplayInfo

 @param	aNewRotation	The new rotation to set

 */

 	{

 	RDisplayChannel::TDisplayRotation currentRotation = iDisp.CurrentRotation();

 	test(IsValidRotation(currentRotation));

 	TBool displayConfigChanged = EFalse;

 	TInt err = iDisp.SetRotation(aNewRotation, displayConfigChanged);

 	TInt expectedErr = KErrNone;

 	if ((!IsValidRotation(aNewRotation)) || ((aSupported & aNewRotation) == 0))

 		{

 		expectedErr = KErrArgument;

 		}

 	test(err == expectedErr);

 	// Check whether the rotation should / shouldn't have changed

 	test (iDisp.CurrentRotation() == (err == KErrNone ? aNewRotation : currentRotation));

 	}

 void CDisplayChannelTest::CheckRotations()

 /**

 Tests the SetRotation and GetRotation APIs by attempting to set each valid rotation

 plus some invalid rotation values.

 If a rotation is valid but not supported then KErrNotSupported should be returned.

 */

 	{

 	test.Next(_L("Test CurrentRotation, SetRotation"));

 	// Find out supported resolutions

 	TPckgBuf<RDisplayChannel::TDisplayInfo> infoPkg;

 	test_KErrNone(iDisp.GetDisplayInfo(infoPkg));

 	CheckSetRotation(infoPkg().iAvailableRotations, RDisplayChannel::ERotationNormal);

 	CheckSetRotation(infoPkg().iAvailableRotations, RDisplayChannel::ERotation90CW);

 	CheckSetRotation(infoPkg().iAvailableRotations, RDisplayChannel::ERotation180);

 	CheckSetRotation(infoPkg().iAvailableRotations, RDisplayChannel::ERotation270CW);

 	CheckSetRotation(infoPkg().iAvailableRotations, RDisplayChannel::ERotationNormal);

 	CheckSetRotation(infoPkg().iAvailableRotations, static_cast<RDisplayChannel::TDisplayRotation>(-1));

 	CheckSetRotation(infoPkg().iAvailableRotations, static_cast<RDisplayChannel::TDisplayRotation>(0));

 	}

 void CDisplayChannelTest::CheckV11inV10()

 /**

 The purpose of this test is to verify that v1.0 of the display channel driver

 returns KErrNotSupported for methods that only exist in newer versions as opposed

 to panicking.

 To run this test for real t_display needs to be built against v1.1 and then copied

 to a v1.0 environment.

 If the version number is > 1.0 then this method does nothing.

 */

 	{

 	if (iVersion.iMajor > 1 || iVersion.iMinor > 0)

 		{

 		return;

 		}

 	test.Next(_L("Test check v1.1 functions fail gracefully in v1.0"));

 	// APIs should fail before evaluating parameters

 	TInt intDummy;

 	TInt err;

 	TBuf8<256> buf;

 	TSize size;

 	test.Printf(_L("Testing display change APIs\n"));

 	iDisp.NotifyOnDisplayChangeCancel();

 	TRequestStatus status;	

 	iDisp.NotifyOnDisplayChange(status);

 	test(status == KErrNotSupported);

 	err = iDisp.NumberOfResolutions();

 	test(err == KErrNotSupported);

 	err = iDisp.GetResolutions(buf, intDummy);

 	test(err == KErrNotSupported);

 	err = iDisp.GetResolution(size);

 	test(err == KErrNotSupported);

 	err = iDisp.GetTwips(size);

 	test(err == KErrNotSupported);

 	err = iDisp.NumberOfPixelFormats();

 	test(err == KErrNotSupported);

 	err = iDisp.GetPixelFormats(buf, intDummy);

 	test(err == KErrNotSupported);

 	RDisplayChannel::TBufferFormat bufferFormat(TSize(0,0),0);

 	err = iDisp.GetBufferFormat(bufferFormat);

 	test(err == KErrNotSupported);

 	err = iDisp.SetBufferFormat(bufferFormat);

 	test(err == KErrNotSupported);

 	err = iDisp.NextPlaneOffset(bufferFormat, 0);

 	test(err == KErrNotSupported);

 	err = iDisp.NextLineOffset(bufferFormat, 0);

 	test(err == KErrNotSupported);

 	}

 void CDisplayChannelTest::CheckSecondHandle()

 /**

 Opens a second RDisplayChannel. 

 The driver may not support this but must not crash. 

 */

 	{

 	test.Next(_L("Open a second handle"));

 	RDisplayChannel disp2;

 	TInt err = disp2.Open(iScreenId);

 	test(err == KErrNone || err == KErrInUse);

 	disp2.Close();

 	}

 void CDisplayChannelTest::TestBufferTransitions()

 /**

 Because different buffer types (ie. composition, legacy and user) complete differently, we must test

 switching between those different types of buffers to ensure that this is taken into account.

 */

 	{

 	// The support code required for this test exists only in the separated GCE display LDD, not in the

 	// legacy monolithic WINSCW LDD

 #if defined(_DEBUG) && !defined(__WINS__)

 	test.Next(_L("Test transitions between buffer types"));

 	TPckgBuf<RDisplayChannel::TDisplayInfo> displayInfo;

 	test_KErrNone(iDisp.GetDisplayInfo(displayInfo));

 	RChunk chunk;

 	RDisplayChannel::TBufferFormat bufferFormat(TSize(iHalInfo.iXPixels, iHalInfo.iYPixels), displayInfo().iPixelFormat);

 	test.Next(_L("Get the LDD to create a user buffer"));

 	TInt err = iDisp.CreateUserBuffer(bufferFormat, chunk);

 	test_KErrNone(err);

 	test.Next(_L("Register a user buffer"));

 	RDisplayChannel::TBufferId bufferId;

 	err = iDisp.RegisterUserBuffer(bufferId, chunk, 0);

 	test_KErrNone(err);

 	test.Next(_L("Post a user buffer"));

 	TRequestStatus status;

 	RDisplayChannel::TPostCount postCount;

 	iDisp.PostUserBuffer(bufferId, status, NULL, postCount);

 	iDisp.PostLegacyBuffer(NULL, postCount);

 	test.Printf(_L("Waiting for user buffer\n"));

 	User::WaitForRequest(status);

 	test(status.Int() == KErrNone || status.Int() == KErrCancel);

 	test.Printf(_L("Waiting for legacy buffer\n"));

 	iDisp.WaitForPost(postCount, status);

 	User::WaitForRequest(status);

 	test_KErrNone(status.Int());

 	test.Printf(_L("Getting composition buffer\n"));

 	TUint bufferIndex;

 	iDisp.GetCompositionBuffer(bufferIndex, status);

 	User::WaitForRequest(status);

 	test_KErrNone(status.Int());

 	iDisp.PostUserBuffer(bufferId, status, NULL, postCount);

 	iDisp.PostCompositionBuffer(NULL, postCount);

 	test.Printf(_L("Waiting for user buffer\n"));

 	User::WaitForRequest(status);

 	test(status.Int() == KErrNone || status.Int() == KErrCancel);

 	test.Printf(_L("Waiting for composition buffer\n"));

 	iDisp.WaitForPost(postCount, status);

 	User::WaitForRequest(status);

 	test_KErrNone(status.Int());

 	test.Printf(_L("Deregistering user buffers\n"));

 	err = iDisp.DeregisterUserBuffer(bufferId);

 	test_KErrNone(err);

 	test.Printf(_L("Done, closing shared chunk\n"));

 	chunk.Close();

 #endif // defined(_DEBUG) && !defined(__WINS__)

 	}

 void CDisplayChannelTest::Start()

 /**

  Run all of the test cases

  */

 	{

 	CompleteSelf(ETestDisplayInfo);

 	}

 void CDisplayChannelTest::CompleteSelf(TTestState aNextState)

 /*

 Advances to the next test state for test steps that don't invoke

 asynchronous requests on this AO. 

 */

 	{	

 	iState = aNextState;

 	TRequestStatus* status = &iStatus;	

 	SetActive();

 	User::RequestComplete(status, KErrNone);

 	}

 void CDisplayChannelTest::DoCancel()

 	{	

 	iAsyncHelper->Cancel();

 	}

 TInt CDisplayChannelTest::RunError(TInt aError)

 	{

 	test_KErrNone(aError);

 	return KErrNone;

 	}

 void CDisplayChannelTest::RunL()

 /**

  Run all of the tests where the API is defined for that version.

  */

 	{

 	test_KErrNone(iStatus.Int());

 	test.Printf(_L("Test state %d\n"), iState);

 	switch (iState)

 		{

 		case ETestDisplayInfo:

 			CheckDisplayInfo();

 			CompleteSelf(ETestCompositionBuffers);

 			break;

 		case ETestCompositionBuffers:

 			CheckCompositionBuffers();

 			CompleteSelf(ETestUserBuffers);

 			break;

 		case ETestUserBuffers:

 			CheckUserBuffers();

 			CompleteSelf(ETestRotations);

 			break;

 		case ETestRotations:

 			CheckRotations();			

 			CompleteSelf(ETestWaitForPostDoCancel);				

 			break;

 		case ETestWaitForPostDoCancel:

 			// Post the composition buffer, register wait and cancel wait.

 			iDisp.PostCompositionBuffer(NULL, iDummyPostCount);

 			iDisp.WaitForPost(iDummyPostCount, iAsyncHelper->Status());

 			iAsyncHelper->WaitForOperation(&iAsyncHelperResult);

 			iDisp.CancelWaitForPost();

 			CompleteSelf(ETestWaitForPostCheckCancel);

 			break;

 		case ETestWaitForPostCheckCancel:

 			test(iAsyncHelperResult == KErrCancel || iAsyncHelperResult == KErrNone);

 			CompleteSelf(ETestGetCompositionBufferDoCancel);

 			break;

 		case ETestGetCompositionBufferDoCancel:

 			iDisp.GetCompositionBuffer(iDummyCompositionBuffer, iAsyncHelper->Status());

 			iAsyncHelper->WaitForOperation(&iAsyncHelperResult);

 			iDisp.CancelGetCompositionBuffer();

 			CompleteSelf(ETestGetCompositionBufferCheckCancel);

 			break;

 		case ETestGetCompositionBufferCheckCancel:

 			test(iAsyncHelperResult == KErrCancel || iAsyncHelperResult == KErrNone);

 			if (iVersion.iMajor == 1 && iVersion.iMinor == 0)

 				{

 				CompleteSelf(ETestV11inV10);

 				}

 			else

 				{

 				CompleteSelf(ETestDisplayChange);

 				}

 			break;

 		case ETestDisplayChange:	// API in v1.1 +

 			CheckDisplayChange();

 			CompleteSelf(ETestDisplayChangeDoCancel);

 			break;			

 		case ETestDisplayChangeDoCancel:	// API in v1.1 +

 			iDisp.NotifyOnDisplayChangeCancel();

 			CompleteSelf(ETestDisplayChangeCheckCancel);

 			break;

 		case ETestDisplayChangeCheckCancel:	// API in v1.1 +

 			test(iAsyncHelperResult == KErrCancel);	// display should not have changed

 			CompleteSelf(ETestResolutions);

 			break;

 		case ETestResolutions:	// API in v1.1 +

 			CheckResolutions();

 			CompleteSelf(ETestPixelFormats);

 			break;

 		case ETestPixelFormats:	// API in v1.1 +

 			CheckPixelFormats();

 			CompleteSelf(ETestBufferFormats);

 			break;

 		case ETestBufferFormats:	// API in v1.1 +

 			CheckBufferFormat();

 			CompleteSelf(EVisualTest);

 			break;

 		case ETestV11inV10:			

 			CheckV11inV10();

 			CompleteSelf(EVisualTest);

 			break;

 		case EVisualTest:

 			VisualTest();	// visual test is async because of WaitForPost

 			break;

 		case ETestSecondHandle:

 			CheckSecondHandle();

 			CompleteSelf(ETestBufferTransitions);

 			break;

 		case ETestBufferTransitions:

 			TestBufferTransitions();

 			CompleteSelf(ETestFinished);

 			break;

 		case ETestFinished:

 			CActiveScheduler::Stop();

 			break;

 		default:

 			test(EFalse);		

 		}

 	}

 void MainL()

 /**

  Initialise RTest and run the tests

  */

 	{

 	test.Start(_L("Testing display channel driver"));

 	// If the device driver does not exist then this is considered a pass

 	// because the display channel is not a mandatory part of the base port

 	_LIT(KLdd, "display0.ldd");

 	test.Printf(_L("Loading logical %S\n"), &KLdd);

 	TInt err = User::LoadLogicalDevice(KLdd);	

 	test(err == KErrNone || err == KErrAlreadyExists || err == KErrNotFound);		

 	// Only test for kenel memory leaks for non WINSCW builds as the WINSCW LDD is obsolete and would

 	// take forever to debug

 #ifndef __WINS__

 	__KHEAP_MARK;

 #endif // ! __WINS__

 	if (err == KErrNone || err == KErrAlreadyExists)

 		{

 		TInt numberOfScreens;

 		User::LeaveIfError(HAL::Get(HAL::EDisplayNumberOfScreens, numberOfScreens));

 		for (TInt screenNum  = 0; screenNum < numberOfScreens; ++screenNum)

 			{

 			CActiveScheduler* s = new(ELeave) CActiveScheduler();

 			CActiveScheduler::Install(s);

 			CleanupStack::PushL(s);

 			CDisplayChannelTest* displayTest = CDisplayChannelTest::NewLC(screenNum);

 			displayTest->Start();

 			s->Start();

 			CleanupStack::PopAndDestroy(2, s);	// s, displayTest 

 			}

 		}

 	else

 		{

 		test.Printf(_L("display0.ldd not present. Finishing test.\n"));

 		}

 #ifndef __WINS__

 	__KHEAP_MARKEND;

 #endif // ! __WINS__

 	test.End();

 	}

 TInt E32Main()

 /**

  Create cleanup stack, initialise memory checks and run the tests.

  */

 	{

 	CTrapCleanup* cleanup = CTrapCleanup::New();

 	if (!cleanup)

 		{

 		return KErrNoMemory;

 		}

 	__UHEAP_MARK;

 	test.Title();

 	TRAPD(err, MainL());

 	test.Close();

 	__UHEAP_MARKEND;

 	delete cleanup;

 	return err;

 	}