1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/kernelhwsrv/kerneltest/e32test/video/t_video.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1419 @@
1.4 +// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of the License "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +// Overview:
1.18 +// Test the video driver kernel extension
1.19 +// API Information:
1.20 +// HAL, UserSvr
1.21 +// Details:
1.22 +// - Get and report the value for brightness & max brightness. Adjust
1.23 +// the brightness. Verify results are as expected.
1.24 +// - Get and report the value for contrast & max contrast. Adjust the
1.25 +// contrast. Verify results are as expected.
1.26 +// - Get and set backlight status, verify results.
1.27 +// - Get the number of display modes and the current display mode.
1.28 +// - Get screen information for current display mode.
1.29 +// - Get Bits per pixel for current display mode, for an illegal mode
1.30 +// and for all modes.
1.31 +// - Switch display modes and verify results are as expected.
1.32 +// - Get and set palette entries, verify the results.
1.33 +// - Turn the display on and off.
1.34 +// - If additional screens are supported, test each screen as above.
1.35 +// - Test more devices than the kernel supports, verify the results.
1.36 +// Platforms/Drives/Compatibility:
1.37 +// All.
1.38 +// Assumptions/Requirement/Pre-requisites:
1.39 +// Failures and causes:
1.40 +// Base Port information:
1.41 +//
1.42 +//
1.43 +
1.44 +#include <e32test.h>
1.45 +#include <videodriver.h>
1.46 +#include <hal.h>
1.47 +#include <e32svr.h>
1.48 +
1.49 +LOCAL_D RTest test(_L("T_VIDEO"));
1.50 +
1.51 +LOCAL_C void RunTests(void);
1.52 +
1.53 +#ifndef __WINS__
1.54 +#define DUMP(x) test.Printf(_L(#x"= %d =0x%08x\n"), x, x)
1.55 +#endif
1.56 +
1.57 +LOCAL_C void RunTests(void)
1.58 + {
1.59 + TInt ret = KErrNone;
1.60 + TInt HALArg;
1.61 + TInt saved = 0;
1.62 +
1.63 +/* BRIGHTNESS */
1.64 +
1.65 + TBool HALMaxBrightnessSupported = EFalse;
1.66 + TBool HALGetBrightnessSupported = EFalse;
1.67 + TBool HALSetBrightnessSupported = EFalse;
1.68 +
1.69 + test.Next(_L("Max Brightness using HAL"));
1.70 + TInt maxBrightness=-1;
1.71 + ret = HAL::Get(HAL::EDisplayBrightnessMax, maxBrightness);
1.72 + test ((KErrNone == ret) || (KErrNotSupported == ret));
1.73 +
1.74 + if (KErrNone == ret)
1.75 + {
1.76 + HALMaxBrightnessSupported = ETrue;
1.77 + test.Printf(_L("Maximum brightness = %d\n"), maxBrightness);
1.78 + }
1.79 + else
1.80 + test.Printf(_L("Maximum brightness is NOT SUPPORTED by HAL\n"));
1.81 +
1.82 +
1.83 + test.Next(_L("Get Brightness using HAL"));
1.84 + HALArg = -1;
1.85 + ret = HAL::Get(HAL::EDisplayBrightness, HALArg);
1.86 + test ((KErrNone == ret) || (KErrNotSupported == ret));
1.87 + if (KErrNone == ret)
1.88 + {
1.89 + test.Printf(_L("Brightness = %d\n"), HALArg);
1.90 + HALGetBrightnessSupported = ETrue;
1.91 + saved = HALArg;
1.92 + }
1.93 + else
1.94 + {
1.95 + test.Printf(_L("Get Brightness is NOT SUPPORTED by HAL\n"));
1.96 + }
1.97 +
1.98 + test.Next(_L("Test brightness is <= maxBrightness"));
1.99 + test(HALArg <= maxBrightness);
1.100 +
1.101 + test.Next(_L("Set Brightness using HAL"));
1.102 + ret = HAL::Set(HAL::EDisplayBrightness, 0);
1.103 + test ((KErrNone == ret) || (KErrNotSupported == ret) || (KErrArgument == ret));
1.104 + if ((KErrNone == ret) || (KErrArgument == ret))
1.105 + HALSetBrightnessSupported = ETrue;
1.106 + else
1.107 + test.Printf(_L("Set brightness is NOT SUPPORTED by HAL\n"));
1.108 +
1.109 +
1.110 +
1.111 + //if any of the brightness funcs are supported, test they all are
1.112 + //we've already tested Ldd/HAL are giving same support
1.113 + if (HALSetBrightnessSupported && HALGetBrightnessSupported && HALMaxBrightnessSupported)
1.114 + {
1.115 + //all supported
1.116 + //do more comprehensive set/gets
1.117 + test.Next(_L("Set Brightness using HAL to saved value"));
1.118 + ret = HAL::Set(HAL::EDisplayBrightness, saved);
1.119 + test (KErrNone == ret);
1.120 +
1.121 + test.Next(_L("Get Brightness using HAL"));
1.122 + HALArg = -1;
1.123 + ret = HAL::Get(HAL::EDisplayBrightness, HALArg);
1.124 + test (KErrNone == ret);
1.125 + test (saved == HALArg);
1.126 +
1.127 + test.Next(_L("Set Brightness to the max using HAL"));
1.128 + ret = HAL::Set(HAL::EDisplayBrightness, maxBrightness);
1.129 + test.Printf(_L("ret = %d maxbr = %d"),ret, maxBrightness);
1.130 + test (KErrNone == ret);
1.131 +
1.132 + test.Next(_L("Get Brightness using HAL"));
1.133 + HALArg = 0;
1.134 + ret = HAL::Get(HAL::EDisplayBrightness, HALArg);
1.135 + test (KErrNone == ret);
1.136 + test (maxBrightness == HALArg);
1.137 +
1.138 + test.Next(_L("Set Brightness using HAL"));
1.139 + ret = HAL::Set(HAL::EDisplayBrightness, saved);
1.140 + test (KErrNone == ret);
1.141 +
1.142 +
1.143 + //test some out of range values
1.144 + ret = HAL::Get(HAL::EDisplayBrightness, HALArg);
1.145 + test (KErrNone == ret);
1.146 + saved = HALArg;
1.147 +
1.148 + test.Next(_L("Set Brightness too large using HAL"));
1.149 + ret = HAL::Set(HAL::EDisplayBrightness, maxBrightness+1);
1.150 + test (KErrArgument == ret);
1.151 +
1.152 + test.Next(_L("Set Brightness too small using HAL"));
1.153 + ret = HAL::Set(HAL::EDisplayBrightness, -1);
1.154 + test (KErrArgument == ret);
1.155 +
1.156 + }
1.157 + else //check none are supported
1.158 + test(!(HALSetBrightnessSupported || HALGetBrightnessSupported || HALMaxBrightnessSupported));
1.159 +
1.160 +
1.161 +/* CONTRAST */
1.162 +
1.163 + TBool HALMaxContrastSupported = EFalse;
1.164 + TBool HALGetContrastSupported = EFalse;
1.165 + TBool HALSetContrastSupported = EFalse;
1.166 +
1.167 +
1.168 + test.Next(_L("Max Contrast using HAL"));
1.169 + TInt maxContrast=-1;
1.170 + ret = HAL::Get(HAL::EDisplayContrastMax, maxContrast);
1.171 + test ((KErrNone == ret) || (KErrNotSupported == ret));
1.172 +
1.173 + if (KErrNone == ret)
1.174 + {
1.175 + HALMaxContrastSupported = ETrue;
1.176 + test.Printf(_L("Maximum Contrast = %d\n"), maxContrast);
1.177 + }
1.178 + else
1.179 + test.Printf(_L("Maximum Contrast is NOT SUPPORTED by HAL\n"));
1.180 +
1.181 +
1.182 + test.Next(_L("Get Contrast using HAL"));
1.183 + HALArg = -1;
1.184 + ret = HAL::Get(HAL::EDisplayContrast, HALArg);
1.185 + test ((KErrNone == ret) || (KErrNotSupported == ret));
1.186 + if (KErrNone == ret)
1.187 + {
1.188 + test.Printf(_L("Contrast = %d\n"), HALArg);
1.189 + HALGetContrastSupported = ETrue;
1.190 + saved = HALArg;
1.191 + }
1.192 + else
1.193 + {
1.194 + test.Printf(_L("Get Contrast is NOT SUPPORTED by HAL\n"));
1.195 + }
1.196 +
1.197 + test.Next(_L("Test contrast is <= maxcontrast"));
1.198 + test(HALArg <= maxContrast);
1.199 +
1.200 + test.Next(_L("Set Contrast using HAL"));
1.201 + ret = HAL::Set(HAL::EDisplayContrast, 0);
1.202 + test ((KErrNone == ret) || (KErrNotSupported == ret) || (KErrArgument == ret));
1.203 + if ((KErrNone == ret) || (KErrArgument == ret))
1.204 + HALSetContrastSupported = ETrue;
1.205 + else
1.206 + test.Printf(_L("Set Contrast is NOT SUPPORTED by HAL\n"));
1.207 +
1.208 +
1.209 +
1.210 + //if any of the Contrast funcs are supported, test they all are
1.211 + //we've already tested Ldd/HAL are giving same support
1.212 + if (HALSetContrastSupported && HALGetContrastSupported && HALMaxContrastSupported)
1.213 + {
1.214 + //all supported
1.215 + //do more comprehensive set/gets
1.216 + test.Next(_L("Set Contrast using HAL to saved value"));
1.217 + ret = HAL::Set(HAL::EDisplayContrast, saved);
1.218 + test (KErrNone == ret);
1.219 +
1.220 + test.Next(_L("Get Contrast using HAL"));
1.221 + HALArg = -1;
1.222 + ret = HAL::Get(HAL::EDisplayContrast, HALArg);
1.223 + test (KErrNone == ret);
1.224 + test (saved == HALArg);
1.225 +
1.226 + test.Next(_L("Set Contrast to the max using HAL"));
1.227 + ret = HAL::Set(HAL::EDisplayContrast, maxContrast);
1.228 + test (KErrNone == ret);
1.229 +
1.230 + test.Next(_L("Get Contrast using HAL"));
1.231 + HALArg = 0;
1.232 + ret = HAL::Get(HAL::EDisplayContrast, HALArg);
1.233 + test (KErrNone == ret);
1.234 + test (maxContrast == HALArg);
1.235 +
1.236 + test.Next(_L("Set Contrast using HAL"));
1.237 + ret = HAL::Set(HAL::EDisplayContrast, saved);
1.238 + test (KErrNone == ret);
1.239 +
1.240 +
1.241 + //test some out of range values
1.242 + ret = HAL::Get(HAL::EDisplayContrast, HALArg);
1.243 + test (KErrNone == ret);
1.244 + saved = HALArg;
1.245 +
1.246 + test.Next(_L("Set Contrast too large using HAL"));
1.247 + ret = HAL::Set(HAL::EDisplayContrast, maxContrast+1);
1.248 + test (KErrArgument == ret);
1.249 +
1.250 + test.Next(_L("Set Contrast too small using HAL"));
1.251 + ret = HAL::Set(HAL::EDisplayContrast, -1);
1.252 + test (KErrArgument == ret);
1.253 +
1.254 + }
1.255 + else //check none are supported
1.256 + test(!(HALSetContrastSupported || HALGetContrastSupported || HALMaxContrastSupported));
1.257 +
1.258 +
1.259 +
1.260 +/* BACKLIGHT */
1.261 +
1.262 + TBool HALGetBacklightSupported = EFalse;
1.263 + TBool HALSetBacklightSupported = EFalse;
1.264 + TBool lightSupported = EFalse;
1.265 +
1.266 + test.Next(_L("check if backlight supported using HAL"));
1.267 + HALArg = -1;
1.268 + ret = HAL::Get(HAL::EBacklight, lightSupported);
1.269 + test ((KErrNone == ret) || (KErrNotSupported == ret));
1.270 + test.Printf(_L("Backlight supported = %d"), lightSupported);
1.271 +
1.272 +
1.273 +
1.274 + test.Next(_L("Get Backlight state using HAL"));
1.275 + HALArg = -1;
1.276 + ret = HAL::Get(HAL::EBacklightState, HALArg);
1.277 + test ((KErrNone == ret) || (KErrNotSupported == ret));
1.278 + if (KErrNone == ret)
1.279 + {
1.280 + HALGetBacklightSupported = ETrue;
1.281 + test.Printf(_L("Backlight is = %d from HAL\n"), HALArg);
1.282 + }
1.283 + else
1.284 + test.Printf(_L("Get Light is NOT SUPPORTED by HAL\n"));
1.285 +
1.286 +
1.287 + test.Next(_L("Set Backlight state using HAL"));
1.288 + HALArg = 0;
1.289 + ret = HAL::Set(HAL::EBacklightState, HALArg);
1.290 + test ((KErrNone == ret) || (KErrNotSupported == ret));
1.291 + if (KErrNone == ret)
1.292 + {
1.293 + HALSetBacklightSupported = ETrue;
1.294 + test.Printf(_L("Backlight is set to = %d from HAL\n"), HALArg);
1.295 + }
1.296 + else
1.297 + test.Printf(_L("Set Light is NOT SUPPORTED by HAL\n"));
1.298 +
1.299 +
1.300 +
1.301 +
1.302 + if (HALGetBacklightSupported && HALSetBacklightSupported)
1.303 + {
1.304 +
1.305 + test.Next(_L("Get Backlight state using HAL (should be off)"));
1.306 + HALArg = -1;
1.307 + ret = HAL::Get(HAL::EBacklightState, HALArg);
1.308 + test (KErrNone == ret);
1.309 + test (0 == HALArg);
1.310 +
1.311 + test.Next(_L("Set Backlight state to on using HAL"));
1.312 + ret = HAL::Set(HAL::EBacklightState, 1);
1.313 + test (KErrNone == ret);
1.314 +
1.315 + }
1.316 + else
1.317 + test (!HALGetBacklightSupported == !HALSetBacklightSupported);
1.318 +
1.319 +
1.320 + /* maximum display colors*/
1.321 + test.Next(_L("Display Colors"));
1.322 + ret = HAL::Get(HAL::EDisplayColors, HALArg);
1.323 + test (KErrNone == ret);
1.324 +
1.325 +
1.326 + /* DISPLAY MODE */
1.327 + test.Next(_L("Display Modes"));
1.328 + TInt totalModes;
1.329 + ret = HAL::Get(HAL::EDisplayNumModes, totalModes);
1.330 + test (KErrNone == ret);
1.331 +
1.332 + TInt displayMode;
1.333 + ret = HAL::Get(HAL::EDisplayMode, displayMode);
1.334 + test (KErrNone == ret);
1.335 +
1.336 +
1.337 +
1.338 + /* SCREEN INFORMATION*/
1.339 +
1.340 + test.Next(_L("Get Screen Info for current mode using driver"));
1.341 +
1.342 +
1.343 + test.Next(_L("Get screen info using usersvr"));
1.344 + TScreenInfoV01 screenInfo;
1.345 + TPckg<TScreenInfoV01> sI(screenInfo);
1.346 + UserSvr::ScreenInfo(sI);
1.347 + test (screenInfo.iScreenAddressValid != screenInfo.iWindowHandleValid);
1.348 + if (screenInfo.iScreenAddressValid)
1.349 + test (screenInfo.iScreenAddress != 0);
1.350 + if (screenInfo.iWindowHandleValid)
1.351 + test (screenInfo.iWindowHandle != 0);
1.352 +
1.353 +
1.354 + TInt val;
1.355 + test.Next(_L("Get DisplayXPixels using HAL"));
1.356 + ret = HAL::Get(HAL::EDisplayXPixels, val);
1.357 + test (KErrNone == ret);
1.358 + test (val == screenInfo.iScreenSize.iWidth);
1.359 +
1.360 + test.Next(_L("Get DisplayYPixels using HAL"));
1.361 + ret = HAL::Get(HAL::EDisplayYPixels, val);
1.362 + test (KErrNone == ret);
1.363 + test (val == screenInfo.iScreenSize.iHeight);
1.364 +
1.365 + TInt xtwips;
1.366 + test.Next(_L("Get DisplayXTwips using HAL"));
1.367 + ret = HAL::Get(HAL::EDisplayXTwips, xtwips);
1.368 + test (KErrNone == ret);
1.369 +
1.370 + TInt ytwips;
1.371 + test.Next(_L("Get DisplayYTwips using HAL"));
1.372 + ret = HAL::Get(HAL::EDisplayYTwips, ytwips);
1.373 + test (KErrNone == ret);
1.374 +
1.375 + TInt vaddr;
1.376 + test.Next(_L("Get video address using HAL"));
1.377 + ret = HAL::Get(HAL::EDisplayMemoryAddress, vaddr);
1.378 + test (KErrNone == ret);
1.379 +#ifndef __WINS__
1.380 + test (vaddr == (TInt)screenInfo.iScreenAddress);
1.381 +#else
1.382 + test (vaddr == (TInt)screenInfo.iWindowHandle);
1.383 +#endif
1.384 +
1.385 + test.Next(_L("Use machine info"));
1.386 +
1.387 + TMachineInfoV1 mi;
1.388 + TMachineInfoV1Buf mib;
1.389 +
1.390 + UserHal::MachineInfo(mib);
1.391 + mi = mib();
1.392 +
1.393 + 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);
1.394 + test.Printf(_L("xtwips = %d, ytwips = %d, iWidth = %d, iHeight = %d\n"),xtwips, ytwips, mi.iPhysicalScreenSize.iWidth, mi.iPhysicalScreenSize.iHeight);
1.395 +
1.396 + test (screenInfo.iScreenSize.iWidth == mi.iDisplaySizeInPixels.iWidth);
1.397 + test (screenInfo.iScreenSize.iHeight == mi.iDisplaySizeInPixels.iHeight);
1.398 + test (xtwips == mi.iPhysicalScreenSize.iWidth);
1.399 + test (ytwips == mi.iPhysicalScreenSize.iHeight);
1.400 +
1.401 +
1.402 +/* BITS PER PIXEL */
1.403 +
1.404 + test.Next(_L("Get Bits per pixel for current display mode using HAL"));
1.405 +
1.406 + HALArg = displayMode;
1.407 + ret = HAL::Get(HAL::EDisplayBitsPerPixel, HALArg);
1.408 + test (KErrNone == ret);
1.409 +
1.410 +
1.411 + test.Next(_L("Get Bits per pixel with illegal mode using HAL"));
1.412 + HALArg = -1;
1.413 + ret = HAL::Get(HAL::EDisplayBitsPerPixel, HALArg);
1.414 + test (KErrArgument == ret);
1.415 +
1.416 + HALArg = totalModes;
1.417 + ret = HAL::Get(HAL::EDisplayBitsPerPixel, HALArg);
1.418 + test (KErrArgument == ret);
1.419 +
1.420 +
1.421 +/*DISPLAY MODES*/
1.422 + test.Next(_L("loop through the display modes getting the info"));
1.423 +
1.424 + TInt count;
1.425 +
1.426 + TInt fourBppMode = -1;
1.427 +
1.428 + for (count = 0; count < totalModes; count++)
1.429 + {
1.430 +
1.431 + test.Next(_L("Offset To first pixel"));
1.432 + HALArg = count;
1.433 + ret = HAL::Get(HAL::EDisplayOffsetToFirstPixel, HALArg);
1.434 + test (KErrNone == ret);
1.435 + test (HALArg >= 0);
1.436 +
1.437 + test.Next(_L("Test Offset between lines is > 0"));
1.438 + HALArg = count;
1.439 + ret = HAL::Get(HAL::EDisplayOffsetBetweenLines, HALArg);
1.440 + test (KErrNone == ret);
1.441 +#ifndef __WINS__
1.442 + test (HALArg > 0);
1.443 +#else
1.444 + test.Printf(_L("WINS can return 0 here as it doesn't handle the buffer itself, target hardware must return > 0"));
1.445 + test (HALArg >= 0);
1.446 +#endif
1.447 + test.Next(_L("is display mono"));
1.448 + HALArg = count;
1.449 + ret = HAL::Get(HAL::EDisplayIsMono, HALArg);
1.450 + test (KErrNone == ret);
1.451 +
1.452 + test.Next(_L("is display palettized"));
1.453 + HALArg = count;
1.454 + ret = HAL::Get(HAL::EDisplayIsPalettized, HALArg);
1.455 + test (KErrNone == ret);
1.456 +
1.457 + test.Next(_L("bits per pixel"));
1.458 + HALArg = count;
1.459 + ret = HAL::Get(HAL::EDisplayBitsPerPixel, HALArg);
1.460 + test (KErrNone == ret);
1.461 +
1.462 + if (HALArg == 4)
1.463 + fourBppMode = count;
1.464 +
1.465 + }
1.466 +
1.467 +
1.468 + test.Next(_L("switch display modes must be supported if > 1 display mode"));
1.469 +
1.470 + TInt oldMode = displayMode;
1.471 +#ifndef __X86__
1.472 + if (totalModes > 1)
1.473 + {
1.474 + HALArg = displayMode;
1.475 + ret = HAL::Set(HAL::EDisplayMode, HALArg);
1.476 + test.Printf(_L("ret is %d dmode is %d\n"),ret, HALArg);
1.477 + test (KErrNone == ret);
1.478 +
1.479 + ret = HAL::Get(HAL::EDisplayMode, HALArg);
1.480 + test (KErrNone == ret);
1.481 + test (HALArg == displayMode);
1.482 +
1.483 + }
1.484 +#endif
1.485 + for (count = 0; count < totalModes; count++)
1.486 + {
1.487 +
1.488 +#ifndef __X86__
1.489 + if (totalModes > 1) //we must support mode change
1.490 + {
1.491 + test.Printf(_L("Setting Display Mode to %d\n"), count);
1.492 +
1.493 + ret = HAL::Set(HAL::EDisplayMode, count);
1.494 + test (KErrNone == ret);
1.495 +
1.496 + ret = HAL::Get(HAL::EDisplayMode, HALArg);
1.497 + test (KErrNone == ret);
1.498 + test (HALArg == count);
1.499 + }
1.500 +#endif
1.501 +
1.502 + /* PALETTE */
1.503 +
1.504 + //get the palette entries
1.505 + //set a few to something else
1.506 + //set them again
1.507 +
1.508 + TInt palettized = count;
1.509 + test.Next(_L("Get if we are using a palette using HAL"));
1.510 + ret = HAL::Get(HAL::EDisplayIsPalettized, palettized);
1.511 + test (KErrNone == ret);
1.512 +
1.513 + if (palettized)
1.514 + {
1.515 + HALArg = count;
1.516 + ret = HAL::Get(HAL::EDisplayBitsPerPixel, HALArg);
1.517 + test (KErrNone == ret);
1.518 + test.Printf(_L("Bitsperpixel is %d\n"),HALArg);
1.519 + test (HALArg <= 8);
1.520 +
1.521 + TInt max = (1 << HALArg) - 1;
1.522 + test.Printf(_L("number of palette entries is %d\n"),max);
1.523 +
1.524 + test.Next(_L("Get legal Palette entries using HAL and driver in loop"));
1.525 + for (TInt x = 0; x <= max; x++)
1.526 + {
1.527 + HALArg = x;
1.528 + ret = HAL::Get(HAL::EDisplayPaletteEntry, HALArg);
1.529 + test.Printf(_L("getting entry %d, ret is %d\n"),x, ret);
1.530 + test (KErrNone == ret);
1.531 +
1.532 + }
1.533 +
1.534 +
1.535 + //try a few sets
1.536 + TInt saved;
1.537 +
1.538 + test.Next(_L("Set Palette entry 0 to red using HAL"));
1.539 +
1.540 + saved = 0;
1.541 + ret = HAL::Get(HAL::EDisplayPaletteEntry, saved);
1.542 + test (KErrNone == ret);
1.543 +
1.544 + HALArg = 0xF80000;
1.545 + ret = HAL::Set(HAL::EDisplayPaletteEntry, HALArg);
1.546 + test (KErrNone == ret || KErrNotSupported == ret);
1.547 +
1.548 + if (KErrNone == ret)
1.549 + {
1.550 + HALArg = 0;
1.551 + ret = HAL::Get(HAL::EDisplayPaletteEntry, HALArg);
1.552 + test (KErrNone == ret);
1.553 + test ((HALArg & 0xF8FFFF)==0xF80000);
1.554 +
1.555 + ret = HAL::Set(HAL::EDisplayPaletteEntry, saved);
1.556 + test (KErrNone == ret);
1.557 +
1.558 +
1.559 + HALArg = 1;
1.560 + ret = HAL::Get(HAL::EDisplayPaletteEntry, HALArg);
1.561 + test (KErrNone == ret);
1.562 +
1.563 +
1.564 + HALArg = (7 << 24) || 0xFFFF00;
1.565 + ret = HAL::Set(HAL::EDisplayPaletteEntry, HALArg);
1.566 + test (KErrNone == ret);
1.567 +
1.568 +
1.569 + }
1.570 +
1.571 +
1.572 +
1.573 + HALArg = count;
1.574 + test (KErrNone == HAL::Get(HAL::EDisplayBitsPerPixel, HALArg));
1.575 +
1.576 + if (4 == HALArg)
1.577 + {
1.578 + test.Next(_L("Get Illegal palette entry using HAL"));
1.579 + HALArg = 18;
1.580 + ret = HAL::Get(HAL::EDisplayPaletteEntry, HALArg);
1.581 + test (KErrArgument == ret);
1.582 +
1.583 +
1.584 + test.Next(_L("Set Illegal palette entry using HAL"));
1.585 + HALArg = 0x12 << 24 ;
1.586 + ret = HAL::Set(HAL::EDisplayPaletteEntry, HALArg);
1.587 + test (KErrArgument == ret);
1.588 + }
1.589 +
1.590 + }
1.591 + else
1.592 + {
1.593 + //not palettized
1.594 + test.Next(_L("Get palette entry using HAL - should fail"));
1.595 + HALArg = 0;
1.596 + ret = HAL::Get(HAL::EDisplayPaletteEntry, HALArg);
1.597 + test (KErrNotSupported == ret);
1.598 + }
1.599 +
1.600 +
1.601 + }
1.602 +
1.603 +#ifndef __X86__
1.604 + if (totalModes > 1) //we must support mode change
1.605 + {
1.606 + ret = HAL::Set(HAL::EDisplayMode, oldMode);
1.607 + test (KErrNone == ret);
1.608 + }
1.609 +#endif
1.610 +
1.611 +
1.612 +
1.613 +
1.614 + /* DISPLAY ON/OFF */
1.615 +
1.616 + TInt displayState;
1.617 +
1.618 + test.Next(_L("Check Display is on using HAL"));
1.619 + displayState = EFalse;
1.620 + ret = HAL::Get(HAL::EDisplayState, displayState);
1.621 + test (KErrNone == ret);
1.622 + test (displayState!=EFalse);
1.623 +
1.624 + test.Next(_L("Turn Display Off using HAL"));
1.625 + ret = HAL::Set(HAL::EDisplayState, 0);
1.626 + test (KErrNone == ret || KErrNotSupported == ret);
1.627 +
1.628 + if (KErrNone == ret)
1.629 + {
1.630 +// test.Next(_L("Check Display is off using HAL"));
1.631 + displayState = ETrue;
1.632 + ret = HAL::Get(HAL::EDisplayState, displayState);
1.633 + test (KErrNone == ret);
1.634 + test (displayState==EFalse);
1.635 +
1.636 + // test.Next(_L("Display On using HAL"));
1.637 + // ret = HAL::Set(HAL::EDisplayState, 1);
1.638 + // test (KErrNotSupported == ret);
1.639 +
1.640 +
1.641 + //need some way of turning on the display!
1.642 + RTimer timer;
1.643 + test(timer.CreateLocal()==KErrNone);
1.644 + TTime now;
1.645 + now.HomeTime();
1.646 + TTime wakeup;
1.647 + wakeup=now+TTimeIntervalSeconds(10);
1.648 + TRequestStatus done;
1.649 + timer.At(done,wakeup);
1.650 +
1.651 + UserHal::SwitchOff();
1.652 + User::WaitForRequest(done);
1.653 +
1.654 + TRawEvent switchon;
1.655 + switchon.Set(TRawEvent::ESwitchOn);
1.656 + UserSvr::AddEvent(switchon);
1.657 + }
1.658 + else
1.659 + test.Printf(_L("Display On/Off not supported by HAL on this playform\n"));
1.660 +
1.661 +
1.662 + test.Next(_L("Check Display On using HAL"));
1.663 + displayState = EFalse;
1.664 + ret = HAL::Get(HAL::EDisplayState, displayState);
1.665 + test (KErrNone == ret);
1.666 + test (displayState!=EFalse);
1.667 +
1.668 +
1.669 +// !!! Disable platform security tests until we get the new APIs
1.670 +/*
1.671 + test.Next(_L("Check if secure screen supported"));
1.672 + TInt secure = EFalse;
1.673 + ret = HAL::Get(HAL::ESecureDisplay, secure);
1.674 + test (KErrNone == ret || KErrNotSupported == ret);
1.675 + if (KErrNone == ret)
1.676 + {
1.677 + //get the secure address
1.678 + TInt addr = 0;
1.679 + ret = HAL::Get(HAL::ESecureDisplayMemoryAddress, addr);
1.680 + test (KErrNone == ret);
1.681 +
1.682 + //switch to secure screen
1.683 + ret = HAL::Set(HAL::ESecureDisplay, ETrue);
1.684 + test (KErrNone == ret);
1.685 + User::After(2000000);
1.686 +
1.687 + //switch to insecure screen
1.688 + ret = HAL::Set(HAL::ESecureDisplay, EFalse);
1.689 + test (KErrNone == ret);
1.690 + User::After(2000000);
1.691 +
1.692 + //switch to secure screen
1.693 + ret = HAL::Set(HAL::ESecureDisplay, ETrue);
1.694 + test (KErrNone == ret);
1.695 + User::After(2000000);
1.696 +
1.697 + //switch to insecure screen
1.698 + ret = HAL::Set(HAL::ESecureDisplay, EFalse);
1.699 + test (KErrNone == ret);
1.700 + }
1.701 + else
1.702 + test.Printf(_L("secure screen not supported on this platform\n"));
1.703 +*/
1.704 +
1.705 + }
1.706 +
1.707 +
1.708 +//the function above tests HAL APIs where no screen number is specified
1.709 +//and implicitly screen 0 is assumed. This function runs only for additional
1.710 +//screens if any (screen1, screen2 etc.)
1.711 +//this uses the HAL APIs that take a screen number
1.712 +LOCAL_C void RunTestsAdditionalScreens(TInt screen)
1.713 + {
1.714 + TInt ret = KErrNone;
1.715 + TInt HALArg;
1.716 + TInt saved = 0;
1.717 +
1.718 +/* BRIGHTNESS */
1.719 +
1.720 + TBool HALMaxBrightnessSupported = EFalse;
1.721 + TBool HALGetBrightnessSupported = EFalse;
1.722 + TBool HALSetBrightnessSupported = EFalse;
1.723 +
1.724 +
1.725 + test.Next(_L("Max Brightness using HAL"));
1.726 + TInt maxBrightness=-1;
1.727 + ret = HAL::Get(screen, HAL::EDisplayBrightnessMax, maxBrightness);
1.728 + test ((KErrNone == ret) || (KErrNotSupported == ret));
1.729 +
1.730 + if (KErrNone == ret)
1.731 + {
1.732 + HALMaxBrightnessSupported = ETrue;
1.733 + test.Printf(_L("Maximum brightness = %d\n"), maxBrightness);
1.734 + }
1.735 + else
1.736 + test.Printf(_L("Maximum brightness is NOT SUPPORTED by HAL\n"));
1.737 +
1.738 +
1.739 + test.Next(_L("Get Brightness using HAL"));
1.740 + HALArg = -1;
1.741 + ret = HAL::Get(screen, HAL::EDisplayBrightness, HALArg);
1.742 + test ((KErrNone == ret) || (KErrNotSupported == ret));
1.743 + if (KErrNone == ret)
1.744 + {
1.745 + test.Printf(_L("Brightness = %d\n"), HALArg);
1.746 + HALGetBrightnessSupported = ETrue;
1.747 + saved = HALArg;
1.748 + }
1.749 + else
1.750 + {
1.751 + test.Printf(_L("Get Brightness is NOT SUPPORTED by HAL\n"));
1.752 + }
1.753 +
1.754 + test.Next(_L("Test brightness is <= maxBrightness"));
1.755 + test(HALArg <= maxBrightness);
1.756 +
1.757 + test.Next(_L("Set Brightness using HAL"));
1.758 + ret = HAL::Set(screen, HAL::EDisplayBrightness, 0);
1.759 + test ((KErrNone == ret) || (KErrNotSupported == ret) || (KErrArgument == ret));
1.760 + if ((KErrNone == ret) || (KErrArgument == ret))
1.761 + HALSetBrightnessSupported = ETrue;
1.762 + else
1.763 + test.Printf(_L("Set brightness is NOT SUPPORTED by HAL\n"));
1.764 +
1.765 +
1.766 +
1.767 + //if any of the brightness funcs are supported, test they all are
1.768 + //we've already tested Ldd/HAL are giving same support
1.769 + if (HALSetBrightnessSupported && HALGetBrightnessSupported && HALMaxBrightnessSupported)
1.770 + {
1.771 + //all supported
1.772 + //do more comprehensive set/gets
1.773 + test.Next(_L("Set Brightness using HAL to saved value"));
1.774 + ret = HAL::Set(screen, HAL::EDisplayBrightness, saved);
1.775 + test (KErrNone == ret);
1.776 +
1.777 + test.Next(_L("Get Brightness using HAL"));
1.778 + HALArg = -1;
1.779 + ret = HAL::Get(screen, HAL::EDisplayBrightness, HALArg);
1.780 + test (KErrNone == ret);
1.781 + test (saved == HALArg);
1.782 +
1.783 + test.Next(_L("Set Brightness to the max using HAL"));
1.784 + ret = HAL::Set(screen, HAL::EDisplayBrightness, maxBrightness);
1.785 + test.Printf(_L("ret = %d maxbr = %d"),ret, maxBrightness);
1.786 + test (KErrNone == ret);
1.787 +
1.788 + test.Next(_L("Get Brightness using HAL"));
1.789 + HALArg = 0;
1.790 + ret = HAL::Get(screen, HAL::EDisplayBrightness, HALArg);
1.791 + test (KErrNone == ret);
1.792 + test (maxBrightness == HALArg);
1.793 +
1.794 + test.Next(_L("Set Brightness using HAL"));
1.795 + ret = HAL::Set(screen, HAL::EDisplayBrightness, saved);
1.796 + test (KErrNone == ret);
1.797 +
1.798 +
1.799 + //test some out of range values
1.800 + ret = HAL::Get(screen, HAL::EDisplayBrightness, HALArg);
1.801 + test (KErrNone == ret);
1.802 + saved = HALArg;
1.803 +
1.804 + test.Next(_L("Set Brightness too large using HAL"));
1.805 + ret = HAL::Set(screen, HAL::EDisplayBrightness, maxBrightness+1);
1.806 + test (KErrArgument == ret);
1.807 +
1.808 + test.Next(_L("Set Brightness too small using HAL"));
1.809 + ret = HAL::Set(screen, HAL::EDisplayBrightness, -1);
1.810 + test (KErrArgument == ret);
1.811 +
1.812 + }
1.813 + else //check none are supported
1.814 + test(!(HALSetBrightnessSupported || HALGetBrightnessSupported || HALMaxBrightnessSupported));
1.815 +
1.816 +
1.817 +/* CONTRAST */
1.818 +
1.819 + TBool HALMaxContrastSupported = EFalse;
1.820 + TBool HALGetContrastSupported = EFalse;
1.821 + TBool HALSetContrastSupported = EFalse;
1.822 +
1.823 +
1.824 + test.Next(_L("Max Contrast using HAL"));
1.825 + TInt maxContrast=-1;
1.826 + ret = HAL::Get(screen, HAL::EDisplayContrastMax, maxContrast);
1.827 + test ((KErrNone == ret) || (KErrNotSupported == ret));
1.828 +
1.829 + if (KErrNone == ret)
1.830 + {
1.831 + HALMaxContrastSupported = ETrue;
1.832 + test.Printf(_L("Maximum Contrast = %d\n"), maxContrast);
1.833 + }
1.834 + else
1.835 + test.Printf(_L("Maximum Contrast is NOT SUPPORTED by HAL\n"));
1.836 +
1.837 +
1.838 + test.Next(_L("Get Contrast using HAL"));
1.839 + HALArg = -1;
1.840 + ret = HAL::Get(screen, HAL::EDisplayContrast, HALArg);
1.841 + test ((KErrNone == ret) || (KErrNotSupported == ret));
1.842 + if (KErrNone == ret)
1.843 + {
1.844 + test.Printf(_L("Contrast = %d\n"), HALArg);
1.845 + HALGetContrastSupported = ETrue;
1.846 + saved = HALArg;
1.847 + }
1.848 + else
1.849 + {
1.850 + test.Printf(_L("Get Contrast is NOT SUPPORTED by HAL\n"));
1.851 + }
1.852 +
1.853 + test.Next(_L("Test contrast is <= maxcontrast"));
1.854 + test(HALArg <= maxContrast);
1.855 +
1.856 + test.Next(_L("Set Contrast using HAL"));
1.857 + ret = HAL::Set(screen, HAL::EDisplayContrast, 0);
1.858 + test ((KErrNone == ret) || (KErrNotSupported == ret) || (KErrArgument == ret));
1.859 + if ((KErrNone == ret) || (KErrArgument == ret))
1.860 + HALSetContrastSupported = ETrue;
1.861 + else
1.862 + test.Printf(_L("Set Contrast is NOT SUPPORTED by HAL\n"));
1.863 +
1.864 +
1.865 +
1.866 + //if any of the Contrast funcs are supported, test they all are
1.867 + //we've already tested Ldd/HAL are giving same support
1.868 + if (HALSetContrastSupported && HALGetContrastSupported && HALMaxContrastSupported)
1.869 + {
1.870 + //all supported
1.871 + //do more comprehensive set/gets
1.872 + test.Next(_L("Set Contrast using HAL to saved value"));
1.873 + ret = HAL::Set(screen, HAL::EDisplayContrast, saved);
1.874 + test (KErrNone == ret);
1.875 +
1.876 + test.Next(_L("Get Contrast using HAL"));
1.877 + HALArg = -1;
1.878 + ret = HAL::Get(screen, HAL::EDisplayContrast, HALArg);
1.879 + test (KErrNone == ret);
1.880 + test (saved == HALArg);
1.881 +
1.882 + test.Next(_L("Set Contrast to the max using HAL"));
1.883 + ret = HAL::Set(screen, HAL::EDisplayContrast, maxContrast);
1.884 + test (KErrNone == ret);
1.885 +
1.886 + test.Next(_L("Get Contrast using HAL"));
1.887 + HALArg = 0;
1.888 + ret = HAL::Get(screen, HAL::EDisplayContrast, HALArg);
1.889 + test (KErrNone == ret);
1.890 + test (maxContrast == HALArg);
1.891 +
1.892 + test.Next(_L("Set Contrast using HAL"));
1.893 + ret = HAL::Set(screen, HAL::EDisplayContrast, saved);
1.894 + test (KErrNone == ret);
1.895 +
1.896 +
1.897 + //test some out of range values
1.898 + ret = HAL::Get(screen, HAL::EDisplayContrast, HALArg);
1.899 + test (KErrNone == ret);
1.900 + saved = HALArg;
1.901 +
1.902 + test.Next(_L("Set Contrast too large using HAL"));
1.903 + ret = HAL::Set(screen, HAL::EDisplayContrast, maxContrast+1);
1.904 + test (KErrArgument == ret);
1.905 +
1.906 + test.Next(_L("Set Contrast too small using HAL"));
1.907 + ret = HAL::Set(screen, HAL::EDisplayContrast, -1);
1.908 + test (KErrArgument == ret);
1.909 +
1.910 + }
1.911 + else //check none are supported
1.912 + test(!(HALSetContrastSupported || HALGetContrastSupported || HALMaxContrastSupported));
1.913 +
1.914 +
1.915 +
1.916 +/* BACKLIGHT */
1.917 +
1.918 + TBool HALGetBacklightSupported = EFalse;
1.919 + TBool HALSetBacklightSupported = EFalse;
1.920 + TBool lightSupported = EFalse;
1.921 +
1.922 + test.Next(_L("check if backlight supported using HAL"));
1.923 + HALArg = -1;
1.924 + ret = HAL::Get(screen, HAL::EBacklight, lightSupported);
1.925 + test ((KErrNone == ret) || (KErrNotSupported == ret));
1.926 + test.Printf(_L("Backlight supported = %d"), lightSupported);
1.927 +
1.928 +
1.929 +
1.930 + test.Next(_L("Get Backlight state using HAL"));
1.931 + HALArg = -1;
1.932 + ret = HAL::Get(screen, HAL::EBacklightState, HALArg);
1.933 + test ((KErrNone == ret) || (KErrNotSupported == ret));
1.934 + if (KErrNone == ret)
1.935 + {
1.936 + HALGetBacklightSupported = ETrue;
1.937 + test.Printf(_L("Backlight is = %d from HAL\n"), HALArg);
1.938 + }
1.939 + else
1.940 + test.Printf(_L("Get Light is NOT SUPPORTED by HAL\n"));
1.941 +
1.942 +
1.943 + test.Next(_L("Set Backlight state using HAL"));
1.944 + HALArg = 0;
1.945 + ret = HAL::Set(screen, HAL::EBacklightState, HALArg);
1.946 + test ((KErrNone == ret) || (KErrNotSupported == ret));
1.947 + if (KErrNone == ret)
1.948 + {
1.949 + HALSetBacklightSupported = ETrue;
1.950 + test.Printf(_L("Backlight is set to = %d from HAL\n"), HALArg);
1.951 + }
1.952 + else
1.953 + test.Printf(_L("Set Light is NOT SUPPORTED by HAL\n"));
1.954 +
1.955 +
1.956 +
1.957 +
1.958 + if (HALGetBacklightSupported && HALSetBacklightSupported)
1.959 + {
1.960 +
1.961 + test.Next(_L("Get Backlight state using HAL (should be off)"));
1.962 + HALArg = -1;
1.963 + ret = HAL::Get(screen, HAL::EBacklightState, HALArg);
1.964 + test (KErrNone == ret);
1.965 + test (0 == HALArg);
1.966 +
1.967 + test.Next(_L("Set Backlight state to on using HAL"));
1.968 + ret = HAL::Set(screen, HAL::EBacklightState, 1);
1.969 + test (KErrNone == ret);
1.970 +
1.971 + }
1.972 + else
1.973 + test (!HALGetBacklightSupported == !HALSetBacklightSupported);
1.974 +
1.975 +
1.976 + /* maximum display colors*/
1.977 + test.Next(_L("Display Colors"));
1.978 + ret = HAL::Get(screen, HAL::EDisplayColors, HALArg);
1.979 + test (KErrNone == ret);
1.980 +
1.981 +
1.982 + /* DISPLAY MODE */
1.983 + test.Next(_L("Display Modes"));
1.984 + TInt totalModes;
1.985 + ret = HAL::Get(screen, HAL::EDisplayNumModes, totalModes);
1.986 + test (KErrNone == ret);
1.987 +
1.988 + TInt displayMode;
1.989 + ret = HAL::Get(screen, HAL::EDisplayMode, displayMode);
1.990 + test (KErrNone == ret);
1.991 +
1.992 + TInt val;
1.993 + test.Next(_L("Get DisplayXPixels using HAL"));
1.994 + ret = HAL::Get(screen, HAL::EDisplayXPixels, val);
1.995 + test (KErrNone == ret);
1.996 +
1.997 + test.Next(_L("Get DisplayYPixels using HAL"));
1.998 + ret = HAL::Get(screen, HAL::EDisplayYPixels, val);
1.999 + test (KErrNone == ret);
1.1000 +
1.1001 + TInt xtwips;
1.1002 + test.Next(_L("Get DisplayXTwips using HAL"));
1.1003 + ret = HAL::Get(screen, HAL::EDisplayXTwips, xtwips);
1.1004 + test (KErrNone == ret);
1.1005 +
1.1006 + TInt ytwips;
1.1007 + test.Next(_L("Get DisplayYTwips using HAL"));
1.1008 + ret = HAL::Get(screen, HAL::EDisplayYTwips, ytwips);
1.1009 + test (KErrNone == ret);
1.1010 +
1.1011 + TInt vaddr;
1.1012 + test.Next(_L("Get video address using HAL"));
1.1013 + ret = HAL::Get(screen, HAL::EDisplayMemoryAddress, vaddr);
1.1014 + test (KErrNone == ret);
1.1015 +
1.1016 +
1.1017 +/* BITS PER PIXEL */
1.1018 +
1.1019 + test.Next(_L("Get Bits per pixel for current display mode using HAL"));
1.1020 +
1.1021 + HALArg = displayMode;
1.1022 + ret = HAL::Get(screen, HAL::EDisplayBitsPerPixel, HALArg);
1.1023 + test (KErrNone == ret);
1.1024 +
1.1025 +
1.1026 + test.Next(_L("Get Bits per pixel with illegal mode using HAL"));
1.1027 + HALArg = -1;
1.1028 + ret = HAL::Get(screen, HAL::EDisplayBitsPerPixel, HALArg);
1.1029 + test (KErrArgument == ret);
1.1030 +
1.1031 + HALArg = totalModes;
1.1032 + ret = HAL::Get(screen, HAL::EDisplayBitsPerPixel, HALArg);
1.1033 + test (KErrArgument == ret);
1.1034 +
1.1035 +
1.1036 +/*DISPLAY MODES*/
1.1037 + test.Next(_L("loop through the display modes getting the info"));
1.1038 +
1.1039 + TInt count;
1.1040 +
1.1041 + TInt fourBppMode = -1;
1.1042 +
1.1043 + for (count = 0; count < totalModes; count++)
1.1044 + {
1.1045 +
1.1046 + test.Next(_L("Offset To first pixel"));
1.1047 + HALArg = count;
1.1048 + ret = HAL::Get(screen, HAL::EDisplayOffsetToFirstPixel, HALArg);
1.1049 + test (KErrNone == ret);
1.1050 + test (HALArg >= 0);
1.1051 +
1.1052 + test.Next(_L("Test Offset between lines is > 0"));
1.1053 + HALArg = count;
1.1054 + ret = HAL::Get(screen, HAL::EDisplayOffsetBetweenLines, HALArg);
1.1055 + test (KErrNone == ret);
1.1056 +#ifndef __WINS__
1.1057 + test (HALArg > 0);
1.1058 +#else
1.1059 + test.Printf(_L("WINS can return 0 here as it doesn't handle the buffer itself, target hardware must return > 0"));
1.1060 + test (HALArg >= 0);
1.1061 +#endif
1.1062 + test.Next(_L("is display mono"));
1.1063 + HALArg = count;
1.1064 + ret = HAL::Get(screen, HAL::EDisplayIsMono, HALArg);
1.1065 + test (KErrNone == ret);
1.1066 +
1.1067 + test.Next(_L("is display palettized"));
1.1068 + HALArg = count;
1.1069 + ret = HAL::Get(screen, HAL::EDisplayIsPalettized, HALArg);
1.1070 + test (KErrNone == ret);
1.1071 +
1.1072 + test.Next(_L("bits per pixel"));
1.1073 + HALArg = count;
1.1074 + ret = HAL::Get(screen, HAL::EDisplayBitsPerPixel, HALArg);
1.1075 + test (KErrNone == ret);
1.1076 +
1.1077 + if (HALArg == 4)
1.1078 + fourBppMode = count;
1.1079 +
1.1080 + }
1.1081 +
1.1082 +
1.1083 + test.Next(_L("switch display modes must be supported if > 1 display mode"));
1.1084 +
1.1085 + TInt oldMode = displayMode;
1.1086 +#ifndef __X86__
1.1087 + if (totalModes > 1)
1.1088 + {
1.1089 + HALArg = displayMode;
1.1090 + ret = HAL::Set(screen, HAL::EDisplayMode, HALArg);
1.1091 + test.Printf(_L("ret is %d dmode is %d\n"),ret, HALArg);
1.1092 + test (KErrNone == ret);
1.1093 +
1.1094 + ret = HAL::Get(screen, HAL::EDisplayMode, HALArg);
1.1095 + test (KErrNone == ret);
1.1096 + test (HALArg == displayMode);
1.1097 +
1.1098 + }
1.1099 +#endif
1.1100 + for (count = 0; count < totalModes; count++)
1.1101 + {
1.1102 +
1.1103 +#ifndef __X86__
1.1104 + if (totalModes > 1) //we must support mode change
1.1105 + {
1.1106 + test.Printf(_L("Setting Display Mode to %d\n"), count);
1.1107 +
1.1108 + ret = HAL::Set(screen, HAL::EDisplayMode, count);
1.1109 + test (KErrNone == ret);
1.1110 +
1.1111 + ret = HAL::Get(screen, HAL::EDisplayMode, HALArg);
1.1112 + test (KErrNone == ret);
1.1113 + test (HALArg == count);
1.1114 + }
1.1115 +#endif
1.1116 +
1.1117 + /* PALETTE */
1.1118 +
1.1119 + //get the palette entries
1.1120 + //set a few to something else
1.1121 + //set them again
1.1122 +
1.1123 + TInt palettized = count;
1.1124 + test.Next(_L("Get if we are using a palette using HAL"));
1.1125 + ret = HAL::Get(screen, HAL::EDisplayIsPalettized, palettized);
1.1126 + test (KErrNone == ret);
1.1127 +
1.1128 + if (palettized)
1.1129 + {
1.1130 + HALArg = count;
1.1131 + ret = HAL::Get(screen, HAL::EDisplayBitsPerPixel, HALArg);
1.1132 + test (KErrNone == ret);
1.1133 + test.Printf(_L("Bitsperpixel is %d\n"),HALArg);
1.1134 + test (HALArg <= 8);
1.1135 +
1.1136 + TInt max = (1 << HALArg) - 1;
1.1137 + test.Printf(_L("number of palette entries is %d\n"),max);
1.1138 +
1.1139 + test.Next(_L("Get legal Palette entries using HAL and driver in loop"));
1.1140 + for (TInt x = 0; x <= max; x++)
1.1141 + {
1.1142 + HALArg = x;
1.1143 + ret = HAL::Get(screen, HAL::EDisplayPaletteEntry, HALArg);
1.1144 + test.Printf(_L("getting entry %d, ret is %d\n"),x, ret);
1.1145 + test (KErrNone == ret);
1.1146 +
1.1147 + }
1.1148 +
1.1149 +
1.1150 + //try a few sets
1.1151 + TInt saved;
1.1152 +
1.1153 + test.Next(_L("Set Palette entry 0 to red using HAL"));
1.1154 +
1.1155 + saved = 0;
1.1156 + ret = HAL::Get(screen, HAL::EDisplayPaletteEntry, saved);
1.1157 + test (KErrNone == ret);
1.1158 +
1.1159 + HALArg = 0xFF0000;
1.1160 + ret = HAL::Set(screen, HAL::EDisplayPaletteEntry, HALArg);
1.1161 + test (KErrNone == ret || KErrNotSupported == ret);
1.1162 +
1.1163 + if (KErrNone == ret)
1.1164 + {
1.1165 + HALArg = 0;
1.1166 + ret = HAL::Get(screen, HAL::EDisplayPaletteEntry, HALArg);
1.1167 + test (KErrNone == ret);
1.1168 + test (HALArg = 0xFF0000);
1.1169 +
1.1170 + ret = HAL::Set(screen, HAL::EDisplayPaletteEntry, saved);
1.1171 + test (KErrNone == ret);
1.1172 +
1.1173 +
1.1174 + HALArg = 1;
1.1175 + ret = HAL::Get(screen, HAL::EDisplayPaletteEntry, HALArg);
1.1176 + test (KErrNone == ret);
1.1177 +
1.1178 +
1.1179 + HALArg = (7 << 24) || 0xFFFF00;
1.1180 + ret = HAL::Set(screen, HAL::EDisplayPaletteEntry, HALArg);
1.1181 + test (KErrNone == ret);
1.1182 +
1.1183 +
1.1184 + }
1.1185 +
1.1186 +
1.1187 +
1.1188 + HALArg = count;
1.1189 + test (KErrNone == HAL::Get(screen, HAL::EDisplayBitsPerPixel, HALArg));
1.1190 +
1.1191 + if (4 == HALArg)
1.1192 + {
1.1193 + test.Next(_L("Get Illegal palette entry using HAL"));
1.1194 + HALArg = 18;
1.1195 + ret = HAL::Get(screen, HAL::EDisplayPaletteEntry, HALArg);
1.1196 + test (KErrArgument == ret);
1.1197 +
1.1198 +
1.1199 + test.Next(_L("Set Illegal palette entry using HAL"));
1.1200 + HALArg = 0x12 << 24 ;
1.1201 + ret = HAL::Set(screen, HAL::EDisplayPaletteEntry, HALArg);
1.1202 + test (KErrArgument == ret);
1.1203 + }
1.1204 +
1.1205 + }
1.1206 + else
1.1207 + {
1.1208 + //not palettized
1.1209 + test.Next(_L("Get palette entry using HAL - should fail"));
1.1210 + HALArg = 0;
1.1211 + ret = HAL::Get(screen, HAL::EDisplayPaletteEntry, HALArg);
1.1212 + test (KErrNotSupported == ret);
1.1213 + }
1.1214 +
1.1215 +
1.1216 + }
1.1217 +
1.1218 +#ifndef __X86__
1.1219 + if (totalModes > 1) //we must support mode change
1.1220 + {
1.1221 + ret = HAL::Set(screen, HAL::EDisplayMode, oldMode);
1.1222 + test (KErrNone == ret);
1.1223 + }
1.1224 +#endif
1.1225 +
1.1226 +
1.1227 +
1.1228 +
1.1229 + /* DISPLAY ON/OFF */
1.1230 +
1.1231 +
1.1232 + // get current display state
1.1233 + TInt curDisplayState;
1.1234 + ret = HAL::Get(screen, HAL::EDisplayState, curDisplayState);
1.1235 + test (KErrNone == ret);
1.1236 +
1.1237 + test.Next(_L("Turn Display on using HAL"));
1.1238 + ret = HAL::Set(screen, HAL::EDisplayState, 1);
1.1239 + test (KErrNone == ret || KErrNotSupported == ret);
1.1240 +
1.1241 + TInt displayState;
1.1242 +
1.1243 + test.Next(_L("Check Display is on using HAL"));
1.1244 + displayState = EFalse;
1.1245 + ret = HAL::Get(screen, HAL::EDisplayState, displayState);
1.1246 + test (KErrNone == ret);
1.1247 + test (displayState!=EFalse);
1.1248 +
1.1249 + test.Next(_L("Turn Display Off using HAL"));
1.1250 + ret = HAL::Set(screen, HAL::EDisplayState, 0);
1.1251 + test (KErrNone == ret || KErrNotSupported == ret);
1.1252 +
1.1253 + if (KErrNone == ret)
1.1254 + {
1.1255 + test.Next(_L("Check Display is off using HAL"));
1.1256 + displayState = ETrue;
1.1257 + ret = HAL::Get(screen, HAL::EDisplayState, displayState);
1.1258 + test (KErrNone == ret);
1.1259 + test (displayState==EFalse);
1.1260 +
1.1261 + // test.Next(_L("Display On using HAL"));
1.1262 + // ret = HAL::Set(screen, HAL::EDisplayState, 1);
1.1263 + // test (KErrNotSupported == ret);
1.1264 +
1.1265 +
1.1266 + //need some way of turning on the display!
1.1267 + RTimer timer;
1.1268 + test(timer.CreateLocal()==KErrNone);
1.1269 + TTime now;
1.1270 + now.HomeTime();
1.1271 + TTime wakeup;
1.1272 + wakeup=now+TTimeIntervalSeconds(10);
1.1273 + TRequestStatus done;
1.1274 + timer.At(done,wakeup);
1.1275 +
1.1276 + UserHal::SwitchOff();
1.1277 + User::WaitForRequest(done);
1.1278 +
1.1279 + TRawEvent switchon;
1.1280 + switchon.Set(TRawEvent::ESwitchOn);
1.1281 + UserSvr::AddEvent(switchon);
1.1282 + }
1.1283 + else
1.1284 + test.Printf(_L("Display On/Off not supported by HAL on this playform\n"));
1.1285 +
1.1286 + // restore the original display state
1.1287 + ret = HAL::Set(screen, HAL::EDisplayState, curDisplayState);
1.1288 + test (KErrNone == ret || KErrNotSupported == ret);
1.1289 +
1.1290 +
1.1291 +// !!! Disable platform security tests until we get the new APIs
1.1292 +/*
1.1293 + test.Next(_L("Check if secure screen supported"));
1.1294 + TInt secure = EFalse;
1.1295 + ret = HAL::Get(screen, HAL::ESecureDisplay, secure);
1.1296 + test (KErrNone == ret || KErrNotSupported == ret);
1.1297 + if (KErrNone == ret)
1.1298 + {
1.1299 + //get the secure address
1.1300 + TInt addr = 0;
1.1301 + ret = HAL::Get(screen, HAL::ESecureDisplayMemoryAddress, addr);
1.1302 + test (KErrNone == ret);
1.1303 +
1.1304 + //switch to secure screen
1.1305 + ret = HAL::Set(screen, HAL::ESecureDisplay, ETrue);
1.1306 + test (KErrNone == ret);
1.1307 + User::After(2000000);
1.1308 +
1.1309 + //switch to insecure screen
1.1310 + ret = HAL::Set(screen, HAL::ESecureDisplay, EFalse);
1.1311 + test (KErrNone == ret);
1.1312 + User::After(2000000);
1.1313 +
1.1314 + //switch to secure screen
1.1315 + ret = HAL::Set(screen, HAL::ESecureDisplay, ETrue);
1.1316 + test (KErrNone == ret);
1.1317 + User::After(2000000);
1.1318 +
1.1319 + //switch to insecure screen
1.1320 + ret = HAL::Set(screen, HAL::ESecureDisplay, EFalse);
1.1321 + test (KErrNone == ret);
1.1322 + }
1.1323 + else
1.1324 + test.Printf(_L("secure screen not supported on this platform\n"));
1.1325 +*/
1.1326 +
1.1327 + }
1.1328 +
1.1329 +
1.1330 +GLDEF_C TInt E32Main()
1.1331 +//
1.1332 +//
1.1333 + {
1.1334 +
1.1335 + test.Title();
1.1336 +//
1.1337 +#if defined(__EPOC32__) && defined(__CPU_X86)
1.1338 + test.Printf(_L("Doesn't run on X86\n"));
1.1339 +#else
1.1340 +
1.1341 + test.Start(_L("Testing Video extension"));
1.1342 +
1.1343 + RunTests();
1.1344 + TInt screens=1; // assume that we have at least 1 screen in case the HAL attr isn't supported
1.1345 + TInt ret=HAL::Get(HAL::EDisplayNumberOfScreens, screens);
1.1346 + test((ret==KErrNone) || (ret==KErrNotSupported));
1.1347 +
1.1348 + TInt i;
1.1349 + for(i=1;i<screens;i++)
1.1350 + RunTestsAdditionalScreens(i);
1.1351 +
1.1352 + test.Next(_L("Test more devices than the kernel can handle"));
1.1353 + //this constant should have a value > KMaxHalEntries (defined in the kernel)
1.1354 + const TInt KMoreThanKernelAllocates=10;
1.1355 + for(i=screens;i<KMoreThanKernelAllocates;i++)
1.1356 + {
1.1357 + TInt val;
1.1358 + test.Next(_L("Get DisplayXPixels using HAL"));
1.1359 + ret = HAL::Get(i, HAL::EDisplayXPixels, val);
1.1360 + test (KErrNotSupported == ret);
1.1361 +
1.1362 + test.Next(_L("Get DisplayYPixels using HAL"));
1.1363 + ret = HAL::Get(i, HAL::EDisplayYPixels, val);
1.1364 + test (KErrNotSupported == ret);
1.1365 +
1.1366 + TInt xtwips;
1.1367 + test.Next(_L("Get DisplayXTwips using HAL"));
1.1368 + ret = HAL::Get(i, HAL::EDisplayXTwips, xtwips);
1.1369 + test (KErrNotSupported == ret);
1.1370 +
1.1371 + TInt ytwips;
1.1372 + test.Next(_L("Get DisplayYTwips using HAL"));
1.1373 + ret = HAL::Get(i, HAL::EDisplayYTwips, ytwips);
1.1374 + test (KErrNotSupported == ret);
1.1375 +
1.1376 + TInt vaddr;
1.1377 + test.Next(_L("Get video address using HAL"));
1.1378 + ret = HAL::Get(i, HAL::EDisplayMemoryAddress, vaddr);
1.1379 + test (KErrNotSupported == ret);
1.1380 + }
1.1381 +
1.1382 + test.Next(_L("Test HAL::GetAll"));
1.1383 + TInt numEntries;
1.1384 + HAL::SEntry* entries;
1.1385 + ret=HAL::GetAll(numEntries, entries);
1.1386 + test(ret==KErrNone);
1.1387 +
1.1388 + test(numEntries==screens*(TInt)HAL::ENumHalAttributes);
1.1389 +
1.1390 + User::Free(entries);
1.1391 +
1.1392 + test.Next(_L("Test TRawEvent for multiple devices (screens)"));
1.1393 +
1.1394 + TRawEvent event1;
1.1395 + test(event1.Type()==0);
1.1396 + test(event1.DeviceNumber()==KUndefinedDeviceNumber);
1.1397 +
1.1398 + event1.SetDeviceNumber(0);
1.1399 + test(event1.DeviceNumber()==0);
1.1400 +
1.1401 + event1.SetDeviceNumber(KUndefinedDeviceNumber);
1.1402 + test(event1.DeviceNumber()==KUndefinedDeviceNumber);
1.1403 +
1.1404 + test(event1.Type()==0);
1.1405 +
1.1406 + event1.Set(TRawEvent::EKeyDown);
1.1407 + test(event1.Type()==TRawEvent::EKeyDown);
1.1408 +
1.1409 + event1.Set(TRawEvent::EKeyUp,10);
1.1410 + test(event1.Type()==TRawEvent::EKeyUp);
1.1411 +
1.1412 + event1.Set(TRawEvent::EKeyDown,10,10);
1.1413 + test(event1.Type()==TRawEvent::EKeyDown);
1.1414 +
1.1415 + test.End();
1.1416 + test.Close();
1.1417 +
1.1418 +#endif
1.1419 +
1.1420 + return KErrNone;
1.1421 + }
1.1422 +