// 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]);

			}		

		}