// Copyright (c) 2001-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:

// Overview:

// Test the video driver kernel extension

// API Information:

// HAL, UserSvr

// Details:

// - Get and report the value for brightness & max brightness. Adjust 

// the brightness. Verify results are as expected.

// - Get and report the value for contrast & max contrast. Adjust the 

// contrast. Verify results are as expected.

// - Get and set backlight status, verify results.

// - Get the number of display modes and the current display mode.

// - Get screen information for current display mode.

// - Get Bits per pixel for current display mode, for an illegal mode 

// and for all modes.

// - Switch display modes and verify results are as expected.

// - Get and set palette entries, verify the results.

// - Turn the display on and off.

// - If additional screens are supported, test each screen as above.

// - Test more devices than the kernel supports, verify the results.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

#include <videodriver.h>

#include <hal.h>

#include <e32svr.h>

LOCAL_D RTest test(_L("T_VIDEO"));

LOCAL_C void RunTests(void);

#ifndef __WINS__

#define DUMP(x) test.Printf(_L(#x"= %d =0x%08x\n"), x, x)

#endif

LOCAL_C void RunTests(void)

	{

	TInt ret = KErrNone;

	TInt HALArg;

	TInt saved = 0;

/*	BRIGHTNESS	*/

	TBool HALMaxBrightnessSupported = EFalse;

	TBool HALGetBrightnessSupported = EFalse;

	TBool HALSetBrightnessSupported = EFalse;

	test.Next(_L("Max Brightness using HAL"));

	TInt maxBrightness=-1;

	ret = HAL::Get(HAL::EDisplayBrightnessMax, maxBrightness);

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

	if (KErrNone == ret)

		{

		HALMaxBrightnessSupported = ETrue;

		test.Printf(_L("Maximum brightness = %d\n"), maxBrightness);

		}

	else

		test.Printf(_L("Maximum brightness is NOT SUPPORTED by HAL\n"));

	test.Next(_L("Get Brightness using HAL"));

	HALArg = -1;

	ret = HAL::Get(HAL::EDisplayBrightness, HALArg);

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

	if (KErrNone == ret)

		{

		test.Printf(_L("Brightness = %d\n"), HALArg);

		HALGetBrightnessSupported = ETrue;

		saved = HALArg;

		}

	else

		{

		test.Printf(_L("Get Brightness is NOT SUPPORTED by HAL\n"));

		}

	test.Next(_L("Test brightness is <= maxBrightness"));

	test(HALArg <= maxBrightness);

	test.Next(_L("Set Brightness using HAL"));

	ret = HAL::Set(HAL::EDisplayBrightness, 0);

	test ((KErrNone == ret) || (KErrNotSupported == ret) || (KErrArgument == ret));

	if ((KErrNone == ret) || (KErrArgument == ret))

		HALSetBrightnessSupported = ETrue;

	else

		test.Printf(_L("Set brightness is NOT SUPPORTED by HAL\n"));

	//if any of the brightness funcs are supported, test they all are

	//we've already tested Ldd/HAL are giving same support

	if (HALSetBrightnessSupported && HALGetBrightnessSupported && HALMaxBrightnessSupported)

		{

		//all supported

		//do more comprehensive set/gets

		test.Next(_L("Set Brightness using HAL to saved value"));

		ret = HAL::Set(HAL::EDisplayBrightness, saved);

		test (KErrNone == ret);

		test.Next(_L("Get Brightness using HAL"));

		HALArg = -1;

		ret = HAL::Get(HAL::EDisplayBrightness, HALArg);

		test (KErrNone == ret);

		test (saved == HALArg);

		test.Next(_L("Set Brightness to the max using HAL"));

		ret = HAL::Set(HAL::EDisplayBrightness, maxBrightness);

		test.Printf(_L("ret = %d maxbr = %d"),ret, maxBrightness);

		test (KErrNone == ret);

		test.Next(_L("Get Brightness using HAL"));

		HALArg = 0;

		ret = HAL::Get(HAL::EDisplayBrightness, HALArg);

		test (KErrNone == ret);

		test (maxBrightness == HALArg);

		test.Next(_L("Set Brightness using HAL"));

		ret = HAL::Set(HAL::EDisplayBrightness, saved);

		test (KErrNone == ret);

		//test some out of range values

		ret = HAL::Get(HAL::EDisplayBrightness, HALArg);

		test (KErrNone == ret);

		saved = HALArg;

		test.Next(_L("Set Brightness too large using HAL"));

		ret = HAL::Set(HAL::EDisplayBrightness, maxBrightness+1);

		test (KErrArgument == ret);

		test.Next(_L("Set Brightness too small using HAL"));

		ret = HAL::Set(HAL::EDisplayBrightness, -1);

		test (KErrArgument == ret);

		}

		else	//check none are supported

			test(!(HALSetBrightnessSupported || HALGetBrightnessSupported || HALMaxBrightnessSupported));

/*	CONTRAST	*/

	TBool HALMaxContrastSupported = EFalse;

	TBool HALGetContrastSupported = EFalse;

	TBool HALSetContrastSupported = EFalse;

	test.Next(_L("Max Contrast using HAL"));

	TInt maxContrast=-1;

	ret = HAL::Get(HAL::EDisplayContrastMax, maxContrast);

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

	if (KErrNone == ret)

		{

		HALMaxContrastSupported = ETrue;

		test.Printf(_L("Maximum Contrast = %d\n"), maxContrast);

		}

	else

		test.Printf(_L("Maximum Contrast is NOT SUPPORTED by HAL\n"));

	test.Next(_L("Get Contrast using HAL"));

	HALArg = -1;

	ret = HAL::Get(HAL::EDisplayContrast, HALArg);

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

	if (KErrNone == ret)

		{

		test.Printf(_L("Contrast = %d\n"), HALArg);

		HALGetContrastSupported = ETrue;

		saved = HALArg;

		}

	else

		{

		test.Printf(_L("Get Contrast is NOT SUPPORTED by HAL\n"));

		}

	test.Next(_L("Test contrast is <= maxcontrast"));

	test(HALArg <= maxContrast);

	test.Next(_L("Set Contrast using HAL"));

	ret = HAL::Set(HAL::EDisplayContrast, 0);

	test ((KErrNone == ret) || (KErrNotSupported == ret) || (KErrArgument == ret));

	if ((KErrNone == ret) || (KErrArgument == ret))

		HALSetContrastSupported = ETrue;

	else

		test.Printf(_L("Set Contrast is NOT SUPPORTED by HAL\n"));

	//if any of the Contrast funcs are supported, test they all are

	//we've already tested Ldd/HAL are giving same support

	if (HALSetContrastSupported && HALGetContrastSupported && HALMaxContrastSupported)

		{

		//all supported

		//do more comprehensive set/gets

		test.Next(_L("Set Contrast using HAL to saved value"));

		ret = HAL::Set(HAL::EDisplayContrast, saved);

		test (KErrNone == ret);

		test.Next(_L("Get Contrast using HAL"));

		HALArg = -1;

		ret = HAL::Get(HAL::EDisplayContrast, HALArg);

		test (KErrNone == ret);

		test (saved == HALArg);

		test.Next(_L("Set Contrast to the max using HAL"));

		ret = HAL::Set(HAL::EDisplayContrast, maxContrast);

		test (KErrNone == ret);

		test.Next(_L("Get Contrast using HAL"));

		HALArg = 0;

		ret = HAL::Get(HAL::EDisplayContrast, HALArg);

		test (KErrNone == ret);

		test (maxContrast == HALArg);

		test.Next(_L("Set Contrast using HAL"));

		ret = HAL::Set(HAL::EDisplayContrast, saved);

		test (KErrNone == ret);

		//test some out of range values

		ret = HAL::Get(HAL::EDisplayContrast, HALArg);

		test (KErrNone == ret);

		saved = HALArg;

		test.Next(_L("Set Contrast too large using HAL"));

		ret = HAL::Set(HAL::EDisplayContrast, maxContrast+1);

		test (KErrArgument == ret);

		test.Next(_L("Set Contrast too small using HAL"));

		ret = HAL::Set(HAL::EDisplayContrast, -1);

		test (KErrArgument == ret);

		}

		else	//check none are supported

			test(!(HALSetContrastSupported || HALGetContrastSupported || HALMaxContrastSupported));

/*	BACKLIGHT	*/

	TBool HALGetBacklightSupported = EFalse;

	TBool HALSetBacklightSupported = EFalse;

	TBool lightSupported = EFalse;

	test.Next(_L("check if backlight supported using HAL"));

	HALArg = -1;

	ret = HAL::Get(HAL::EBacklight, lightSupported);

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

	test.Printf(_L("Backlight supported = %d"), lightSupported);

	test.Next(_L("Get Backlight state using HAL"));

	HALArg = -1;

	ret = HAL::Get(HAL::EBacklightState, HALArg);

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

	if (KErrNone == ret)

		{

		HALGetBacklightSupported = ETrue;

		test.Printf(_L("Backlight is = %d from HAL\n"), HALArg);

		}

	else

		test.Printf(_L("Get Light is NOT SUPPORTED by HAL\n"));

	test.Next(_L("Set Backlight state using HAL"));

	HALArg = 0;

	ret = HAL::Set(HAL::EBacklightState, HALArg);

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

	if (KErrNone == ret)

		{

		HALSetBacklightSupported = ETrue;

		test.Printf(_L("Backlight is set to = %d from HAL\n"), HALArg);

		}

	else

		test.Printf(_L("Set Light is NOT SUPPORTED by HAL\n"));

	if 	(HALGetBacklightSupported && HALSetBacklightSupported)

		{

		test.Next(_L("Get Backlight state using HAL (should be off)"));

		HALArg = -1;

		ret = HAL::Get(HAL::EBacklightState, HALArg);

		test (KErrNone == ret);

		test (0 == HALArg);

		test.Next(_L("Set Backlight state to on using HAL"));

		ret = HAL::Set(HAL::EBacklightState, 1);

		test (KErrNone == ret);

		}

	else

		test (!HALGetBacklightSupported == !HALSetBacklightSupported);

	/* maximum display colors*/

	test.Next(_L("Display Colors"));

	ret = HAL::Get(HAL::EDisplayColors, HALArg);

	test (KErrNone == ret);

	/*  DISPLAY MODE */

	test.Next(_L("Display Modes"));

	TInt totalModes;

	ret = HAL::Get(HAL::EDisplayNumModes, totalModes);

	test (KErrNone == ret);

	TInt displayMode;

	ret = HAL::Get(HAL::EDisplayMode, displayMode);

	test (KErrNone == ret);

	/* SCREEN INFORMATION*/

	test.Next(_L("Get Screen Info for current mode using driver"));

	test.Next(_L("Get screen info using usersvr"));

	TScreenInfoV01 screenInfo;

	TPckg<TScreenInfoV01> sI(screenInfo);

	UserSvr::ScreenInfo(sI);

	test (screenInfo.iScreenAddressValid != screenInfo.iWindowHandleValid);

	if (screenInfo.iScreenAddressValid)

		test (screenInfo.iScreenAddress != 0);

	if (screenInfo.iWindowHandleValid)

		test (screenInfo.iWindowHandle != 0);

	TInt val;

	test.Next(_L("Get DisplayXPixels using HAL"));

	ret = HAL::Get(HAL::EDisplayXPixels, val);

	test (KErrNone == ret);

	test (val == screenInfo.iScreenSize.iWidth);

	test.Next(_L("Get DisplayYPixels using HAL"));

	ret = HAL::Get(HAL::EDisplayYPixels, val);

	test (KErrNone == ret);

	test (val == screenInfo.iScreenSize.iHeight);

	TInt xtwips;

	test.Next(_L("Get DisplayXTwips using HAL"));

	ret = HAL::Get(HAL::EDisplayXTwips, xtwips);

	test (KErrNone == ret);

	TInt ytwips;

	test.Next(_L("Get DisplayYTwips using HAL"));

	ret = HAL::Get(HAL::EDisplayYTwips, ytwips);

	test (KErrNone == ret);

	TInt vaddr;

	test.Next(_L("Get video address using HAL"));

	ret = HAL::Get(HAL::EDisplayMemoryAddress, vaddr);

	test (KErrNone == ret);

#ifndef __WINS__

	test (vaddr == (TInt)screenInfo.iScreenAddress);

#else

	test (vaddr == (TInt)screenInfo.iWindowHandle);

#endif

	test.Next(_L("Use machine info"));

	TMachineInfoV1 mi;

	TMachineInfoV1Buf mib;

	UserHal::MachineInfo(mib);

	mi = mib();

	test.Printf(_L("si.iWidth = %d,  si.iHeight = %d,  mi.iWidth = %d, mi.iHeight = %d\n"),screenInfo.iScreenSize.iWidth, screenInfo.iScreenSize.iHeight, mi.iDisplaySizeInPixels.iWidth, mi.iDisplaySizeInPixels.iHeight);

	test.Printf(_L("xtwips = %d,  ytwips = %d,  iWidth = %d, iHeight = %d\n"),xtwips, ytwips, mi.iPhysicalScreenSize.iWidth, mi.iPhysicalScreenSize.iHeight);

	test (screenInfo.iScreenSize.iWidth == mi.iDisplaySizeInPixels.iWidth);

	test (screenInfo.iScreenSize.iHeight == mi.iDisplaySizeInPixels.iHeight);

	test (xtwips == mi.iPhysicalScreenSize.iWidth);

	test (ytwips == mi.iPhysicalScreenSize.iHeight);

/* BITS PER PIXEL */

	test.Next(_L("Get Bits per pixel for current display mode using HAL"));

	HALArg = displayMode;

	ret = HAL::Get(HAL::EDisplayBitsPerPixel, HALArg);

	test (KErrNone == ret);

	test.Next(_L("Get Bits per pixel with illegal mode using HAL"));

	HALArg = -1;

	ret = HAL::Get(HAL::EDisplayBitsPerPixel, HALArg);

	test (KErrArgument == ret);

	HALArg = totalModes;

	ret = HAL::Get(HAL::EDisplayBitsPerPixel, HALArg);

	test (KErrArgument == ret);

/*DISPLAY MODES*/

	test.Next(_L("loop through the display modes getting the info"));

	TInt count;

	TInt fourBppMode = -1;

	for (count = 0; count < totalModes; count++)

		{

		test.Next(_L("Offset To first pixel"));

		HALArg = count;

		ret = HAL::Get(HAL::EDisplayOffsetToFirstPixel, HALArg);

		test (KErrNone == ret);

		test (HALArg >= 0);

		test.Next(_L("Test Offset between lines is > 0"));

		HALArg = count;

		ret = HAL::Get(HAL::EDisplayOffsetBetweenLines, HALArg);

		test (KErrNone == ret);

#ifndef __WINS__

		test (HALArg > 0);

#else		

		test.Printf(_L("WINS can return 0 here as it doesn't handle the buffer itself, target hardware must return > 0"));

		test (HALArg >= 0);

#endif

		test.Next(_L("is display mono"));

		HALArg = count;

		ret = HAL::Get(HAL::EDisplayIsMono, HALArg);

		test (KErrNone == ret);

		test.Next(_L("is display palettized"));

		HALArg = count;

		ret = HAL::Get(HAL::EDisplayIsPalettized, HALArg);

		test (KErrNone == ret);

		test.Next(_L("bits per pixel"));

		HALArg = count;

		ret = HAL::Get(HAL::EDisplayBitsPerPixel, HALArg);

		test (KErrNone == ret);

		if (HALArg == 4)

			fourBppMode = count;

		}

	test.Next(_L("switch display modes must be supported if > 1 display mode"));

	TInt oldMode = displayMode;

#ifndef __X86__

	if (totalModes > 1)

		{

		HALArg = displayMode;

		ret = HAL::Set(HAL::EDisplayMode, HALArg);

		test.Printf(_L("ret is %d dmode is %d\n"),ret, HALArg);

		test (KErrNone == ret);

		ret = HAL::Get(HAL::EDisplayMode, HALArg);

		test (KErrNone == ret);

		test (HALArg == displayMode);

		}

#endif

	for (count = 0; count < totalModes; count++)

		{

#ifndef __X86__

		if (totalModes > 1)  //we must support mode change

			{

			test.Printf(_L("Setting Display Mode to %d\n"), count);

			ret = HAL::Set(HAL::EDisplayMode, count);

			test (KErrNone == ret);

			ret = HAL::Get(HAL::EDisplayMode, HALArg);

			test (KErrNone == ret);

			test (HALArg == count);

			}

#endif

		/* PALETTE */

		//get the palette entries

		//set a few to something else

		//set them again

		TInt palettized = count;

		test.Next(_L("Get if we are using a palette using HAL"));

		ret = HAL::Get(HAL::EDisplayIsPalettized, palettized);

		test (KErrNone == ret);

		if (palettized)

			{

			HALArg = count;

			ret = HAL::Get(HAL::EDisplayBitsPerPixel, HALArg);

			test (KErrNone == ret);

			test.Printf(_L("Bitsperpixel is  %d\n"),HALArg);

			test (HALArg <= 8);

			TInt max = (1 << HALArg) - 1;

			test.Printf(_L("number of palette entries is %d\n"),max);

			test.Next(_L("Get legal Palette entries using HAL and driver in loop"));

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

				{

				HALArg = x;

				ret = HAL::Get(HAL::EDisplayPaletteEntry, HALArg);

				test.Printf(_L("getting entry %d, ret is %d\n"),x, ret);

				test (KErrNone == ret);