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

 */

	{