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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 /**

    17  @file

    18 */

    19 #include "wsdynamicresbasic.h"

    20 #include <test/extendtef.h>

    21 #include "globalsettings.h"

    22 #include <w32debug.h>

    23 #include <w32stdgraphic.h>

    24 #include "regionextend.h"

    25 #include <fbs.h>

    26 #include <e32svr.h>

    27 #include <u32hal.h>

    28 #include <graphics/surfaceconfiguration.h>

    29 #include "surfaceutility.h"

    30 #include <graphics/testscreencapture.h>

    31 

    32 //verify which base code is available to the test

    33 #include <dispchannel.h>

    34 #if (!defined(K_DISPLAY_CH_MAJOR_VERSION_NUMBER) && !defined(K_DISPLAY_CH_MINOR_VERSION_NUMBER))

    35 #define MODE_CHANGE_BASE_FUNCTIONALITY_NOT_PRESENT_IN_HEADER

    36 #endif

    37 

    38 

    39 //#define VISIBLE_PAUSES 1000

    40 #define OVERLAPPING_CELL	0	//'m'	//0 indicates cells do not overlap

    41 /*

    42  * CWsGceTestPlaceSurfExtra implementation

    43  * 

    44  * 

    45  * 

    46  * 

    47  */

    48 CWsDynamicResBasic::CWsDynamicResBasic()

    49 {

    50 }

    51 

    52 CWsDynamicResBasic::~CWsDynamicResBasic()

    53 {

    54 }

    55 

    56 void CWsDynamicResBasic::SetupL()

    57 	{

    58 	MyBase::SetupL();

    59 	}

    60 void CWsDynamicResBasic::TearDownL()

    61 	{

    62 	MyBase::TearDownL();

    63 	

    64 	}

    65 void CWsDynamicResBasic::TearDownFromDeleteL()

    66 	{

    67 	MyBase::TearDownFromDeleteL();

    68 	}

    69 

    70 

    71 CTestSuite* CWsDynamicResBasic::CreateSuiteL( const TDesC& aName )

    72 	{

    73 	//Create the surface manager here, before the test suite creates additional threads

    74 	if (GCEIsSupportedStatic())

    75 		{

    76 		TRAP_IGNORE(PostTestCleanupInstance().CreateSharedUtilityL());

    77 		}

    78 	

    79 	SUB_SUITE_OPT(CWsDynamicResBasic,NULL);

    80 

    81 		//BASIC

    82 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0001L);

    83 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0002L);

    84 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0003L);

    85 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0004L);

    86 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0005L);

    87 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0006L);

    88 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0007L);

    89 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0008L);

    90 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0009L);

    91 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0010L);	//only run on screen 1

    92 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0011L);

    93 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0012L);	//only run on screen 0

    94 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0013L);

    95 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0014L);	//only run on screen 1

    96 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0015L);	//only run with no scaling

    97 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0016L);	//only run with anisotropic scaling

    98 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0017L);	//only run with integer scaling

    99 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0018L);

   100 

   101 		ADD_TEST_STEP_PARAM_BOOL(GRAPHICS_WSERV_DYNAMICRES_0021L);	//only run on screen 1

   102 		

   103 		//OOM

   104 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0031L);

   105 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0032L);

   106 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0033L);

   107 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0034L);	//dont run with no scaling on screen 0

   108 

   109 		//SCREEN CAPTURE

   110 		ADD_TEST_STEP_PARAM_BOOL(GRAPHICS_WSERV_DYNAMICRES_0041L);

   111 		ADD_TEST_STEP_PARAM_BOOL(GRAPHICS_WSERV_DYNAMICRES_0042L);

   112 		

   113 		//DYNAMIC SCREEN MODE - only run these with no scaling and isotropic scaling

   114 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0051L);	

   115 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0052L);	//only run on screen 1 (multiple resolutions)

   116 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0053L);

   117 

   118 		//DEFECT

   119 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0101L);

   120 		ADD_THIS_TEST_STEP(GRAPHICS_WSERV_DYNAMICRES_0102L);

   121 

   122 	END_SUITE;

   123 	}

   124 

   125 #define LOG_AND_PANIC_IF_NOT_GCE											\

   126 		{																	\

   127 		if (!GCEIsSupported())												\

   128 			{																\

   129 			INFO_PRINTF1(_L("Test skipped: GCE support is not loaded"));	\

   130 			User::Panic(_L("GCE.Wrong.Mode"),1);							\

   131 			return;															\

   132 			}																\

   133 		}

   134 

   135 CWsDisplayEvent::CWsDisplayEvent(RWsSession *aWs):

   136 CActive(EPriorityStandard), iWs(aWs), iConfigSpinner(0), iResListSpinner(0),iReceivedEventCount(0), 

   137 iReceivedPointerEventCount(0), iPointerPosTestPass(ETrue) 

   138 	{

   139 	CActiveScheduler::Add(this);

   140 	}

   141 CWsDisplayEvent::~CWsDisplayEvent()

   142 	{

   143 	Cancel();

   144 	}

   145 

   146 void CWsDisplayEvent::DoCancel()

   147 	{

   148 	iWs->EventReadyCancel();

   149 	}

   150 

   151 void CWsDisplayEvent::Request()

   152 	{

   153 	iWs->EventReady(&iStatus);

   154 	SetActive();

   155 	}

   156 

   157 void CWsDisplayEvent::RunL()

   158 	{

   159 	TWsEvent event;

   160 	iWs->GetEvent(event);

   161 	

   162 	if(iStatus == KErrNone)

   163 		{

   164 		switch(event.Type())

   165 			{

   166 			case EEventScreenDeviceChanged:

   167 				{

   168 				iReceivedDeviceEventCount++;

   169 				}

   170 			case EEventPointer:

   171 				{

   172 				iReceivedPointerEventCount++;

   173 				TPointerEvent* ptEvent = event.Pointer();

   174 				//make 1 pixels distance allowance, as non integer scalling from composition to app may occur

   175 				//1 pixels allowance because we never scale greater than 2 times

   176 				if(ptEvent->iPosition.iX < iPointerPos.iX - 1 && ptEvent->iPosition.iX > iPointerPos.iX + 1

   177 						&& ptEvent->iPosition.iY < iPointerPos.iY - 1 &&ptEvent->iPosition.iY > iPointerPos.iY + 1)

   178 					{

   179 					iPointerPosTestPass = EFalse;

   180 					}

   181 				}

   182 			case EEventDisplayChanged:

   183 				{

   184 				iConfigSpinner = event.DisplayChanged()->iConfigurationChangeId;

   185 				iResListSpinner = event.DisplayChanged()->iResolutionListChangeId;

   186 				iReceivedEventCount++;

   187 				}

   188 				break;

   189 			default:

   190 				break;

   191 			}

   192 		}

   193 	else

   194 		User::Leave(iStatus.Int());

   195 	

   196 	Request();

   197 	}

   198 

   199 CEventTimer* CEventTimer::NewL()

   200 	{

   201 	CEventTimer* self = new (ELeave) CEventTimer;

   202 	CleanupStack::PushL(self);

   203 	self->ConstructL();

   204 	CleanupStack::Pop(self);

   205 	return self;

   206 	}

   207       

   208 void CEventTimer::ConstructL()

   209 	{

   210 	User::LeaveIfError(iTimer.CreateLocal());

   211 	CActiveScheduler::Add(this);

   212 	}

   213  

   214 CEventTimer::CEventTimer() : CActive(EPriorityStandard)

   215 	{

   216 	

   217 	}

   218 

   219 CEventTimer::~CEventTimer()

   220 	{

   221 	Cancel();

   222 	iTimer.Close();

   223 	}

   224 

   225 void CEventTimer::DoCancel()

   226 	{

   227 	iTimer.Cancel();

   228 	CActiveScheduler::Stop();

   229 	}

   230 

   231 void CEventTimer::RunL()

   232 	{

   233 	CActiveScheduler::Stop();

   234 	}

   235 

   236 void CEventTimer::Wait(TInt aDelay)

   237 	{

   238 	iTimer.After(iStatus, aDelay);

   239 	SetActive();

   240 	CActiveScheduler::Start();

   241 	}

   242 

   243 //Set display state to normal and to the first decent resolution

   244 //A failed test could leave it in a bad state

   245 void CWsDynamicResBasic::ResetScreens()

   246 	{

   247 	Pause(1000);

   248 #ifndef MODE_CHANGE_BASE_FUNCTIONALITY_NOT_PRESENT_IN_HEADER

   249 	TInt displayState = ENormalResolution; 

   250 	UserSvr::HalFunction(EHalGroupDisplay | (iScreenDevice->GetScreenNumber()<<16), EDisplayHalSetDisplayState, &displayState, NULL);

   251 #endif

   252 	MDisplayControl* interface = static_cast<MDisplayControl*>

   253 				(iScreenDevice->GetInterface(MDisplayControl::ETypeId));

   254 	ASSERT_TRUE(interface);

   255 	

   256 	RArray<TInt> appModeIndexList;

   257 	TInt currMode=iScreenDevice->CurrentScreenMode();

   258 	iScreenDevice->GetScreenSizeModeList(&appModeIndexList);

   259 	if (appModeIndexList[0]!=currMode)

   260 		{

   261 		iScreenDevice->SetAppScreenMode(appModeIndexList[0]);

   262 		iScreenDevice->SetScreenMode(appModeIndexList[0]);

   263 		}

   264 	appModeIndexList.Close();

   265 	

   266 	TInt resolutions = interface->NumberOfResolutions();

   267 	ASSERT_TRUE (resolutions > 0);

   268 	RArray<MDisplayControl::TResolution> resolutionList1;

   269 	TInt error = interface->GetResolutions(resolutionList1);

   270 	ASSERT_EQUALS(error,KErrNone);

   271 	ASSERT_EQUALS(resolutionList1.Count(), resolutions);

   272 	TDisplayConfiguration config;

   273 	TInt goodRes=0;

   274 	if (resolutionList1[goodRes].iPixelSize==TSize())

   275 		{

   276 		goodRes++;

   277 		ASSERT_TRUE(resolutions>goodRes);		//First res was blank, and no more to choose!

   278 		}

   279 	config.SetResolution(resolutionList1[goodRes].iPixelSize);

   280 	error=interface->SetConfiguration(config);

   281 	ASSERT_EQUALS(error,KErrNone);

   282 	resolutionList1.Close();

   283 	}

   284 

   285 /**

   286 @SYMTestCaseID			GRAPHICS_WSERV_DYNAMICRES_0001L

   287 @SYMTestCaseDesc		WSERV Screen Device GetInterface returns known interface

   288 @SYMREQ					REQ10325

   289 @SYMPREQ				PREQ2102

   290 @SYMTestType			CT

   291 @SYMTestPriority		1

   292 @SYMTestPurpose			Basic classic behaviour

   293 @SYMTestActions			

   294 	Call GetInterface with a well known GUID

   295 @SYMTestExpectedResults	

   296 	Returns a pointer

   297 */

   298 void	CWsDynamicResBasic::GRAPHICS_WSERV_DYNAMICRES_0001L()

   299 	{

   300 	LOG_AND_PANIC_IF_NOT_GCE;

   301 	MakeTitleAndCompareWindowsL(_L("GRAPHICS_WSERV_DYNAMICRES_0001L"),_L("Basic Dynamic Resolution test"));

   302 	

   303 	MDisplayControlBase* interface1 = static_cast<MDisplayControlBase*>

   304 			(iScreenDevice->GetInterface(MDisplayControlBase::ETypeId));

   305 	ASSERT_TRUE(interface1);

   306 	

   307 	MDisplayControl* interface2 = static_cast<MDisplayControl*>

   308 			(iScreenDevice->GetInterface(MDisplayControl::ETypeId));

   309 	ASSERT_TRUE(interface2);

   310 	

   311 	MDisplayMappingBase* interface3 = static_cast<MDisplayMappingBase*>

   312 			(iScreenDevice->GetInterface(MDisplayMappingBase::ETypeId));

   313 	ASSERT_TRUE(interface3);

   314 	

   315 	MDisplayMapping* interface4 = static_cast<MDisplayMapping*>

   316 			(iScreenDevice->GetInterface(MDisplayMapping::ETypeId));

   317 	ASSERT_TRUE(interface4);

   318 	}

   319 

   320 /**

   321 @SYMTestCaseID			GRAPHICS_WSERV_DYNAMICRES_0002L

   322 @SYMTestCaseDesc		Basic test for NumberOfResolutions

   323 @SYMREQ					REQ10328

   324 @SYMPREQ				PREQ2102

   325 @SYMTestType			CT

   326 @SYMTestPriority		1

   327 @SYMTestPurpose			NumberOfResolutions returns correctly

   328 @SYMTestActions			

   329 	GetInterface

   330 	then call NumberOfResolutions.

   331 @SYMTestExpectedResults	

   332 	It shouldn't return KErrNotSupported

   333 */

   334 void	CWsDynamicResBasic::GRAPHICS_WSERV_DYNAMICRES_0002L()

   335 	{

   336 	LOG_AND_PANIC_IF_NOT_GCE;

   337 	MDisplayControl* interface = static_cast<MDisplayControl*>

   338 				(iScreenDevice->GetInterface(MDisplayControl::ETypeId));

   339 	ASSERT_TRUE(interface);

   340 	TInt resolutions = interface->NumberOfResolutions();

   341 	ASSERT_TRUE (resolutions != KErrNotSupported);

   342 	}

   343 

   344 /**

   345 @SYMTestCaseID			GRAPHICS_WSERV_DYNAMICRES_0003L

   346 @SYMTestCaseDesc		Basic test for GetResolutions

   347 @SYMREQ					REQ10328

   348 @SYMPREQ				PREQ2102

   349 @SYMTestType			CT

   350 @SYMTestPriority		

   351 @SYMTestPurpose			Check GetResolutions returns a valid TSize RArray

   352 @SYMTestActions			

   353 	GetInterface

   354 	Call NumberOfResolutions

   355 	Create an array and garbage fill based on amount of resolutions

   356 	Call GetResolutions on this array

   357 	Create an array (dont garbage fill)

   358 	Call GetResolutions on this empty array

   359 	Create an array with smaller size than required

   360 	Call GetResolutions on this array

   361 	Create an array with larger size than required

   362 	Call GetResolutions on this array

   363 @SYMTestExpectedResults	

   364 	For both GetResolutions calls, it should allocate memory if needed, and fill

   365 	with correct sizes

   366 */

   367 void	CWsDynamicResBasic::GRAPHICS_WSERV_DYNAMICRES_0003L()

   368 	{

   369 	LOG_AND_PANIC_IF_NOT_GCE;

   370 	TInt count;

   371 	TInt error;

   372 	

   373 	MDisplayControl* interface = static_cast<MDisplayControl*>

   374 				(iScreenDevice->GetInterface(MDisplayControl::ETypeId));

   375 	ASSERT_TRUE(interface);

   376 	

   377 	TInt resolutions = interface->NumberOfResolutions();

   378 	ASSERT_TRUE (resolutions > 0);

   379 	

   380 	RArray<MDisplayControl::TResolution> resolutionList1;

   381 	for (count=0;count<resolutions;count++)

   382 		{

   383 		resolutionList1.Append(MDisplayControl::TResolution(TSize(),TSize()));

   384 		}

   385 	error = interface->GetResolutions(resolutionList1);

   386 	ASSERT_EQUALS(error,KErrNone);

   387 	ASSERT_EQUALS(resolutionList1.Count(), resolutions);

   388 	

   389 	RArray<MDisplayControl::TResolution> resolutionList2;

   390 	error = interface->GetResolutions(resolutionList2);

   391 	ASSERT_EQUALS(error,KErrNone);

   392 	ASSERT_EQUALS(resolutionList2.Count(), resolutions);

   393 	

   394 	RArray<MDisplayControl::TResolution> resolutionList3;

   395 	for (count=0;count<resolutions-1;count++)

   396 		{

   397 		resolutionList3.Append(MDisplayControl::TResolution(TSize(),TSize()));

   398 		}

   399 	error = interface->GetResolutions(resolutionList3);

   400 	ASSERT_EQUALS(error,KErrNone);

   401 	ASSERT_EQUALS(resolutionList3.Count(), resolutions);

   402 	

   403 	RArray<MDisplayControl::TResolution> resolutionList4;

   404 	for (count=0;count<resolutions+2;count++)

   405 		{

   406 		resolutionList4.Append(MDisplayControl::TResolution(TSize(),TSize()));

   407 		}

   408 	error = interface->GetResolutions(resolutionList4);

   409 	ASSERT_EQUALS(error,KErrNone);

   410 	ASSERT_EQUALS(resolutionList4.Count(), resolutions);

   411 	

   412 	for (count=0;count<resolutions;count++)

   413 		{

   414 		ASSERT_EQUALS(resolutionList1[count].iPixelSize,resolutionList2[count].iPixelSize);

   415 		ASSERT_EQUALS(resolutionList1[count].iPixelSize,resolutionList3[count].iPixelSize);

   416 		ASSERT_EQUALS(resolutionList1[count].iPixelSize,resolutionList4[count].iPixelSize);

   417 		

   418 		ASSERT_EQUALS(resolutionList1[count].iTwipsSize,resolutionList2[count].iTwipsSize);

   419 		ASSERT_EQUALS(resolutionList1[count].iTwipsSize,resolutionList3[count].iTwipsSize);

   420 		ASSERT_EQUALS(resolutionList1[count].iTwipsSize,resolutionList4[count].iTwipsSize);

   421 		

   422 		if (!(resolutionList1[count].iFlags == resolutionList2[count].iFlags))

   423 			{

   424 			ASSERT_TRUE(EFalse);

   425 			}

   426 		if (!(resolutionList1[count].iFlags == resolutionList3[count].iFlags))

   427 			{

   428 			ASSERT_TRUE(EFalse);

   429 			}

   430 		if (!(resolutionList1[count].iFlags == resolutionList4[count].iFlags))

   431 			{

   432 			ASSERT_TRUE(EFalse);

   433 			}

   434 		}

   435 	resolutionList1.Close();

   436 	resolutionList2.Close();

   437 	resolutionList3.Close();

   438 	resolutionList4.Close();

   439 	}

   440 

   441 /**

   442 @SYMTestCaseID			GRAPHICS_WSERV_DYNAMICRES_0004L

   443 @SYMTestCaseDesc		Test for GetConfiguration

   444 @SYMREQ					REQ10328

   445 @SYMPREQ				PREQ2102

   446 @SYMTestType			CT

   447 @SYMTestPriority		1

   448 @SYMTestPurpose			Check GetConfiguration returns a configuration object

   449 @SYMTestActions			

   450 	GetInterface

   451 	GetConfiguration with standard TDisplayConfiguration

   452 	GetResolution from the TDisplayConfiguration object

   453 	GetConfiguration with TDisplayConfiguration object with a greater version/size

   454 	GetResolution from the TDisplayConfiguration object

   455 	GetConfiguration with TDisplayConfiguration object with a smaller version/size -- equal to TDisplayConfiguration1

   456 	GetResolution from the TDisplayConfiguration object

   457 	Check all the resolutions should be same

   458 @SYMTestExpectedResults	

   459 	

   460 */

   461 void	CWsDynamicResBasic::GRAPHICS_WSERV_DYNAMICRES_0004L()

   462 	{

   463 	LOG_AND_PANIC_IF_NOT_GCE;

   464 			

   465 	MDisplayControl* interface = static_cast<MDisplayControl*>

   466 				(iScreenDevice->GetInterface(MDisplayControl::ETypeId));

   467 	ASSERT_TRUE(interface);

   468 	

   469 	TDisplayConfiguration dispConfig;

   470 	interface->GetConfiguration(dispConfig);

   471 	ASSERT_TRUE(dispConfig.IsDefined(TDisplayConfigurationBase::EResolution));

   472 	TSize size;

   473 	TSize twips;

   474 	ASSERT_TRUE(dispConfig.GetResolution(size));

   475 	ASSERT_TRUE(dispConfig.GetResolutionTwips(twips));

   476 	

   477 	TDisplayConfiguration dispConfig1(TDisplayConfiguration().Version() + 10);

   478 	interface->GetConfiguration(dispConfig1);

   479 	ASSERT_TRUE(dispConfig1.IsDefined(TDisplayConfigurationBase::EResolution));

   480 	TSize size1;

   481 	TSize twips1;

   482 	ASSERT_TRUE(dispConfig1.GetResolution(size1));

   483 	ASSERT_TRUE(dispConfig1.GetResolutionTwips(twips1));

   484 	

   485 	TDisplayConfiguration dispConfig2(TDisplayConfiguration1().Version());

   486 	interface->GetConfiguration(dispConfig2);

   487 	ASSERT_TRUE(dispConfig2.IsDefined(TDisplayConfigurationBase::EResolution));

   488 	TSize size2;

   489 	TSize twips2;

   490 	ASSERT_TRUE(dispConfig2.GetResolution(size2));

   491 	ASSERT_TRUE(dispConfig2.GetResolutionTwips(twips2));

   492 	

   493 	ASSERT_EQUALS(size, size1);

   494 	ASSERT_EQUALS(size, size2);

   495 	ASSERT_EQUALS(twips, twips1);

   496 	ASSERT_EQUALS(twips, twips2);

   497 	}

   498 

   499 /**

   500 @SYMTestCaseID			GRAPHICS_WSERV_DYNAMICRES_0005L

   501 @SYMTestCaseDesc		Test getting display change event from event queue

   502 @SYMREQ					REQ10329 REQ10330

   503 @SYMPREQ				PREQ2102

   504 @SYMTestType			CT

   505 @SYMTestPriority		1

   506 @SYMTestPurpose			Verify the correct behaviour of display change notification

   507 @SYMTestActions			

   508 	Run through various ways of changing resolution

   509 	For each, check if event has been received

   510 @SYMTestExpectedResults	

   511 	Based on type of change, check event

   512 */

   513 void	CWsDynamicResBasic::GRAPHICS_WSERV_DYNAMICRES_0005L()

   514 	{

   515 	LOG_AND_PANIC_IF_NOT_GCE;

   516 	ResetScreens();

   517 #ifdef MODE_CHANGE_BASE_FUNCTIONALITY_NOT_PRESENT_IN_HEADER

   518 	ASSERT_FALSE("Display connection test not compiled because MODE_CHANGE_BASE_FUNCTIONALITY_NOT_PRESENT_IN_HEADER");

   519 #else

   520 	TInt screenNo = iScreenDevice->GetScreenNumber();

   521 	

   522 	MDisplayControl* interface = static_cast<MDisplayControl*>

   523 				(iScreenDevice->GetInterface(MDisplayControl::ETypeId));

   524 	ASSERT_TRUE(interface);

   525 	interface->EnableDisplayChangeEvents(ETrue);

   526 	ASSERT_TRUE(interface->DisplayChangeEventsEnabled());

   527 	

   528 	CWsDisplayEvent* displayEventAO = new(ELeave) CWsDisplayEvent(&iSession);

   529 	CleanupStack::PushL(displayEventAO);

   530 	displayEventAO->Request();

   531 	CEventTimer *timer = CEventTimer::NewL();

   532 	CleanupStack::PushL(timer);

   533 	TInt dispSpinnerValue = displayEventAO->ResListSpinner();

   534 	TInt configSpinnerValue = displayEventAO->ConfigSpinner();

   535 	

   536 	iSession.Flush();		

   537 	TInt displayState = EDisconnect;

   538 	UserSvr::HalFunction(EHalGroupDisplay | (screenNo<<16), EDisplayHalSetDisplayState, &displayState, NULL);

   539 	

   540 	timer->Wait(100000);

   541 	ASSERT_TRUE(displayEventAO->ConfigSpinner() >= configSpinnerValue); //this is also a config change

   542 	ASSERT_TRUE(displayEventAO->ResListSpinner() > dispSpinnerValue); //1st display change event

   543 	dispSpinnerValue = displayEventAO->ResListSpinner();

   544 	configSpinnerValue = displayEventAO->ConfigSpinner();

   545 	

   546 	

   547 	interface->EnableDisplayChangeEvents(ETrue);//enable again

   548 	ASSERT_TRUE(interface->DisplayChangeEventsEnabled());

   549 	interface->EnableDisplayChangeEvents(EFalse);//disable

   550 	ASSERT_FALSE(interface->DisplayChangeEventsEnabled());

   551 	interface->EnableDisplayChangeEvents(EFalse);//disable again

   552 	interface->EnableDisplayChangeEvents(ETrue);//enable again

   553 	iSession.Flush();

   554 	

   555 	TDisplayConfiguration disconnectedConfig;

   556 	disconnectedConfig.SetResolution(TSize(10,11));

   557 	disconnectedConfig.SetResolutionTwips(TSize(12,13));

   558 	disconnectedConfig.SetRotation(TDisplayConfiguration1::ERotationNormal);

   559 	interface->GetConfiguration(disconnectedConfig);

   560 	ASSERT_FALSE(disconnectedConfig.IsDefined(disconnectedConfig.EResolution));

   561 	ASSERT_FALSE(disconnectedConfig.IsDefined(disconnectedConfig.EResolutionTwips));

   562 	ASSERT_FALSE(disconnectedConfig.IsDefined(disconnectedConfig.ERotation));

   563 	

   564 	displayState = ENormalResolution; 

   565 	UserSvr::HalFunction(EHalGroupDisplay | (screenNo<<16), EDisplayHalSetDisplayState, &displayState, NULL);

   566 	

   567 	timer->Wait(1000000);

   568 	ASSERT_TRUE(displayEventAO->ConfigSpinner() >= configSpinnerValue); //this is a config change if display policy is enabled. not a change otherwise

   569 	ASSERT_TRUE(displayEventAO->ResListSpinner() > dispSpinnerValue); //display change event	

   570 	dispSpinnerValue = displayEventAO->ResListSpinner();

   571 	configSpinnerValue = displayEventAO->ConfigSpinner();

   572 	

   573 	TDisplayConfiguration dispConfig, dispConfig2;

   574 	TSize resolution,resolution2;

   575 	interface->GetConfiguration(dispConfig2);

   576 	dispConfig2.GetResolution(resolution2);

   577 	RArray<MDisplayControl::TResolution> resolutions;

   578 	TInt err = interface->GetResolutions(resolutions);

   579 	ASSERT_EQUALS(err, KErrNone);

   580 	dispConfig.SetResolution(resolutions[resolutions.Count()/2].iPixelSize);

   581 	err = interface->SetConfiguration(dispConfig);

   582 	ASSERT_EQUALS(err, KErrNone);

   583 	interface->GetConfiguration(dispConfig);

   584 	

   585 	timer->Wait(100000);

   586 	

   587 	if(!(dispConfig2 == dispConfig))

   588 		{

   589 		ASSERT_TRUE(displayEventAO->ConfigSpinner() > configSpinnerValue); //a config change, but on screen 0 with DP disabled, as we only have 1 resolution when DP disabled

   590 		}

   591 	else

   592 		{

   593 		ASSERT_TRUE(displayEventAO->ConfigSpinner() == configSpinnerValue);

   594 		}

   595 	ASSERT_EQUALS(displayEventAO->ResListSpinner(), dispSpinnerValue); //this is not a display change event	

   596 	dispSpinnerValue = displayEventAO->ResListSpinner();

   597 	configSpinnerValue = displayEventAO->ConfigSpinner();

   598 	resolutions.Close();

   599 	

   600 	//here we flood the event queue with key events, so the next display change

   601 	//can't put event and queue and force the retry AO on server side to kick off

   602 	iSession.SetFocusScreen(TGlobalSettings::Instance().iScreen);

   603 	for(TInt scanCode = 'a'; scanCode < 't'; scanCode ++)

   604 		{

   605 		TRawEvent rawEvent;

   606 		rawEvent.Set(TRawEvent::EKeyDown,scanCode);

   607 		iSession.SimulateRawEvent(rawEvent);

   608 		rawEvent.Set(TRawEvent::EKeyUp,scanCode);

   609 		iSession.SimulateRawEvent(rawEvent);

   610 		}

   611 	iSession.Flush();

   612 

   613 	TInt eventCount1 = displayEventAO->ReceivedEventCount(); 

   614 	//we should still receive this

   615 	displayState = EDisconnect; 

   616 	UserSvr::HalFunction(EHalGroupDisplay | (screenNo<<16), EDisplayHalSetDisplayState, &displayState, NULL);

   617 	//let retry AO retry more times before we try to get it

   618 	User::After(1000000);

   619 	

   620 	timer->Wait(10000000);

   621 	ASSERT_TRUE(displayEventAO->ConfigSpinner()> configSpinnerValue ); //4th config change

   622 	ASSERT_TRUE(displayEventAO->ResListSpinner() > dispSpinnerValue); //4th display change event

   623 	

   624 	//This part is doomed as well. Now the received event count includes all the pointer, device and display change event

   625 	/*

   626 	TInt eventCount2 = displayEventAO->ReceivedEventCount();

   627 	//make sure retry AO is stopped - we only receive 1 display event

   628 	ASSERT_EQUALS(eventCount1 + 1, eventCount2);

   629 	*/

   630 	displayState = ENormalResolution; 

   631 	UserSvr::HalFunction(EHalGroupDisplay | (screenNo<<16), EDisplayHalSetDisplayState, &displayState, NULL);

   632 	

   633 	CleanupStack::PopAndDestroy(2, displayEventAO);

   634 #endif

   635 	}

   636 

   637 //Adds the first rotation defined in the TResolution to the display configuration

   638 void CWsDynamicResBasic::SetRotation (TDisplayConfiguration& aConfig, const MDisplayControl::TResolution& aResolution)

   639 	{

   640 	if (aResolution.iFlags.IsSet(MDisplayControlBase::TResolution::ERotationNormalSupported))

   641 		{

   642 		aConfig.SetRotation(TDisplayConfiguration1::ERotationNormal);

   643 		}

   644 	else if (aResolution.iFlags.IsSet(MDisplayControlBase::TResolution::ERotation90Supported))

   645 		{

   646 		aConfig.SetRotation(TDisplayConfiguration1::ERotation90CW);

   647 		}

   648 	else if (aResolution.iFlags.IsSet(MDisplayControlBase::TResolution::ERotation180Supported))

   649 		{

   650 		aConfig.SetRotation(TDisplayConfiguration1::ERotation180);

   651 		}

   652 	else if (aResolution.iFlags.IsSet(MDisplayControlBase::TResolution::ERotation270Supported))

   653 		{

   654 		aConfig.SetRotation(TDisplayConfiguration1::ERotation270CW);

   655 		}

   656 	ASSERT_TRUE(aConfig.IsDefined(aConfig.ERotation));

   657 	}

   658 	

   659 /**

   660 @SYMTestCaseID			GRAPHICS_WSERV_DYNAMICRES_0006L

   661 @SYMTestCaseDesc		Set Screen display res

   662 @SYMREQ					REQ10326

   663 @SYMPREQ				PREQ2102

   664 @SYMTestType			CT

   665 @SYMTestPriority		

   666 @SYMTestPurpose			Checking window and layer extents continue working

   667 @SYMTestActions			

   668 	Get resolution list

   669 	For every resolution

   670 		Set resolution

   671 		Draw many rectangles that shrink to demonstrate scaling issues

   672 		Draw surface

   673 		Move window around

   674 @SYMTestExpectedResults	

   675 	Every resolution that is supported by current app mode should successfully be set

   676 	All rectangles and surface should be visible

   677 	As the window moves, the rectangles and surface should move with it, keeping visible

   678 */

   679 void	CWsDynamicResBasic::GRAPHICS_WSERV_DYNAMICRES_0006L()

   680 	{

   681 	LOG_AND_PANIC_IF_NOT_GCE;

   682 	ResetScreens();

   683 	TInt error;

   684 	MakeTitleAndCompareWindowsL(_L("GFX_WSERV_DYNAMICRES_0006L"),_L("Change Resolution"));

   685 

   686 	iTestBack=RWindow(iSession);

   687 	ASSERT_EQUALS(iTestBack.Construct(iGroup, ++iWindowHandle), KErrNone);

   688 	iTestBack.SetRequiredDisplayMode(iDisplayMode);

   689 	iTestBack.SetBackgroundColor(TRgb(255,0,0));

   690 	iTestBack.SetExtent(iTestPos.iTl,iTestPos.Size());

   691 	iTestBack.Activate();

   692 	iTestBack.BeginRedraw();

   693 	ActivateWithWipe(iGc,iTestBack,TRgb(255,0,0));

   694 	iGc->Deactivate();

   695 	iTestBack.EndRedraw();

   696 	iTestBack.SetVisible(ETrue);

   697 	

   698 	struct DrawCompare

   699 		{

   700 		static void Draw(CWindowGc*	aGc)

   701 			{

   702 			aGc->SetPenStyle(aGc->ESolidPen);

   703 			aGc->SetPenColor(TRgb(255,255,255));

   704 			aGc->SetBrushColor(TRgb(0,0,0));

   705 			TRect r(2,2,82,82);

   706 			while(r.Width()>0)

   707 				{

   708 				aGc->DrawRect(r);

   709 				r.Shrink(2,2);

   710 				}

   711 			}

   712 		};

   713 	TSurfaceId surfaceID;

   714 	TRAPD(err, surfaceID = iUtility->CreateSurfaceL(TSize(200,200), 

   715 			KSurfaceFormat, 200 * KBytesPerPixel));

   716 	ASSERT_EQUALS(err,KErrNone);

   717 	TRAP(err,iUtility->FanFillSurfaceL(surfaceID,iYellow,iRed,iMagenta));

   718 	ASSERT_EQUALS(err,KErrNone);

   719 	TSurfaceConfiguration surfConf;

   720 	surfConf.SetSurfaceId(surfaceID);

   721 	

   722 	surfConf.SetExtent(TRect(2,84,82,166));

   723 	iCompare.SetBackgroundSurface(surfConf,EFalse);

   724 	

   725 	if (CWindowGc*	gc=BeginActivateWithWipe(ETrue,iCompare,TRgb(128,128,128)))

   726 		{

   727 		DrawCompare::Draw(gc);

   728 		gc->Deactivate();

   729 		iCompare.EndRedraw();

   730 		

   731 		}

   732 	iSession.Finish(ETrue);

   733 	Pause(1000);

   734 	

   735 	MDisplayControl* interface = static_cast<MDisplayControl*>

   736 				(iScreenDevice->GetInterface(MDisplayControl::ETypeId));

   737 	ASSERT_TRUE(interface);

   738 	

   739 	TInt resolutions = interface->NumberOfResolutions();

   740 	ASSERT_TRUE (resolutions > 0);

   741 	

   742 	RArray<MDisplayControl::TResolution> resolutionList1;

   743 	error = interface->GetResolutions(resolutionList1);

   744 	ASSERT_EQUALS(error,KErrNone);

   745 	ASSERT_EQUALS(resolutionList1.Count(), resolutions);

   746 	

   747 	TDisplayConfiguration dispConfigBefore;

   748 	interface->GetConfiguration(dispConfigBefore);

   749 	ASSERT_TRUE(dispConfigBefore.IsDefined(dispConfigBefore.EResolution))

   750 	if (resolutions>1)

   751 		{

   752 		//Got a mode to change to!

   753 		TSize resBefore;

   754 		TBool ok=dispConfigBefore.GetResolution(resBefore);

   755 		ASSERT_TRUE(ok);	//we "know" this should be ok, as we just asserted the flag

   756 		TBool foundBeforeRes=EFalse;

   757 		for (TInt res=0;res<resolutionList1.Count();res++)

   758 			{

   759 //			if (resolutionList1[res].iPixelSize!=resBefore)

   760 				{

   761 				if (resolutionList1[res].iPixelSize!=TSize(0,0))	//this test is not about turning the display off

   762 					{

   763 					TDisplayConfiguration dispConfigReq;

   764 					dispConfigReq.SetResolution(resolutionList1[res].iPixelSize);

   765 					ASSERT_TRUE(dispConfigReq.IsDefined(dispConfigReq.EResolution));

   766 					

   767 					SetRotation(dispConfigReq,resolutionList1[res]);	//set rotation to first defined in res list

   768 					

   769 					TInt errCode=interface->SetConfiguration(dispConfigReq);

   770 					//ASSERT_EQUALS(errCode,KErrNone);

   771 					if (errCode != KErrNone)

   772 						{

   773 						//Probably current size mode does not support the rotation of the passed in configuration

   774 						

   775 						ASSERT_EQUALS(errCode,KErrArgument);	//failed to find compatible res in the policy

   776 						continue;

   777 						}

   778 					Pause(300);

   779 					TRect outerrect(iTestPos.iTl,resolutionList1[res].iPixelSize.AsPoint());

   780 					iTestBack.SetExtent(outerrect.iTl,outerrect.Size());

   781 					iSession.Finish(ETrue);

   782 					Pause(300);

   783 					if (CWindowGc*	gc=BeginActivateWithWipe(ETrue,iCompare,TRgb(128,128,128)))

   784 						{

   785 						DrawCompare::Draw(gc);

   786 						gc->Deactivate();

   787 						iCompare.EndRedraw();

   788 						}

   789 					TBuf16<20> s;

   790 					s.AppendNum(res);

   791 					UpdateTitleWindowL(s,2);

   792 					s.Zero();

   793 					s.AppendNum(resolutionList1[res].iPixelSize.iWidth);

   794 					s.Append('x');

   795 					s.AppendNum(resolutionList1[res].iPixelSize.iHeight);

   796 					UpdateTitleWindowL(s,3);

   797 					

   798 					iSession.Finish(ETrue);

   799 					Pause(300);

   800 					outerrect.iBr.iX-=5;

   801 					outerrect.iBr.iY-=5;

   802 					iTestBack.SetExtent(outerrect.iTl,outerrect.Size());

   803 					iSession.Finish(ETrue);

   804 					Pause(300);

   805 					TPoint winpos=iCompare.AbsPosition();

   806 					TSize winsize=iCompare.Size();

   807 //					iInfoScreenDevice->ReleaseTwipsCache();

   808 					RepaintTitleWindowL();

   809 					for (TSize z=TSize(1,1);z!=TSize(-1,-1);)

   810 						{

   811 						for (TInt i=0;i<15;i++)

   812 							{

   813 							winpos+=z;

   814 							iCompare.SetExtent(winpos,winsize);

   815 							iSession.Finish(ETrue);

   816 							Pause(100);

   817 							}

   818 						if (z.iHeight && z.iWidth)

   819 							z=TSize(0,-1);

   820 						else

   821 						if (z.iHeight)

   822 							z=TSize(-1,0);

   823 						else

   824 							z=TSize(-1,-1);

   825 						}

   826 					TDisplayConfiguration dispConfigAfter;

   827 					interface->GetConfiguration(dispConfigAfter);

   828 					TSize resAfter;

   829 					TBool ok=dispConfigAfter.GetResolution(resAfter);

   830 					ASSERT_TRUE(ok);

   831 					if (resolutionList1[res].iPixelSize!=resAfter)

   832 						{

   833 						INFO_PRINTF3(_L("Did not receive expected resolution %ix%i"),resolutionList1[res].iPixelSize.iWidth,resolutionList1[res].iPixelSize.iHeight);

   834 						INFO_PRINTF3(_L("Instead got %ix%i"),resAfter.iWidth,resAfter.iHeight);

   835 						}

   836 					}

   837 				}

   838 			if (resolutionList1[res].iPixelSize==resBefore)

   839 				{

   840 				foundBeforeRes=ETrue;

   841 				}

   842 			}

   843 		ASSERT_TRUE(foundBeforeRes);

   844 		//restore initial res

   845 		interface->SetConfiguration(dispConfigBefore);

   846 		Pause(1000);

   847 		TDisplayConfiguration dispConfigAfter;

   848 		interface->GetConfiguration(dispConfigAfter);

   849 		TSize resAfter;

   850 		ok=dispConfigAfter.GetResolution(resAfter);

   851 		ASSERT_TRUE(ok);	

   852 		ASSERT_EQUALS(resBefore,resAfter);

   853 		}

   854 	else

   855 		{

   856 		INFO_PRINTF1(_L("Only 1 resolution configured on this screen - res change test skipped."));

   857 		}

   858 	resolutionList1.Close();

   859 	}

   860 

   861 /**

   862 @SYMTestCaseID			GRAPHICS_WSERV_DYNAMICRES_0007L

   863 @SYMTestCaseDesc		Coordinates Mapping

   864 @SYMREQ					REQ10336

   865 @SYMPREQ				PREQ2102

   866 @SYMTestType			CT

   867 @SYMTestPurpose			Basic call to mapcoordinates

   868 @SYMTestActions			

   869 	Call mapCoordinates

   870 @SYMTestExpectedResults	

   871 	targetRect should be correctly filled in with same rect as sourceRect

   872 */

   873 void	CWsDynamicResBasic::GRAPHICS_WSERV_DYNAMICRES_0007L()

   874 	{

   875 	MDisplayMapping* interface = static_cast<MDisplayMapping*>

   876 			(iScreenDevice->GetInterface(MDisplayMapping::ETypeId));

   877 	ASSERT_TRUE(interface);

   878 	TRect sourceRect(10, 10, 30, 50);

   879 	TRect targetRect(5,5,10,10);

   880 	TInt err = interface->MapCoordinates(EApplicationSpace, sourceRect, EApplicationSpace, targetRect);

   881 	ASSERT_EQUALS(err, KErrNone);

   882 	ASSERT_EQUALS(sourceRect, targetRect);

   883 	}

   884 

   885 /**

   886 @SYMTestCaseID			GRAPHICS_WSERV_DYNAMICRES_0008L

   887 @SYMTestCaseDesc		SetModes and mapCoordinates

   888 @SYMREQ					REQ10336

   889 @SYMPREQ				PREQ2102

   890 @SYMTestType			CT

   891 @SYMTestPurpose			Basic SetSizeMode and complex MapCoordinates function

   892 @SYMTestActions			

   893 	Set a new size mode

   894 	Perform many rect conversions using MapCoordinates

   895 @SYMTestExpectedResults	

   896 	Ensure that through multiple conversions, accuracy is not lost

   897 */

   898 void	CWsDynamicResBasic::GRAPHICS_WSERV_DYNAMICRES_0008L()

   899 	{

   900 	LOG_AND_PANIC_IF_NOT_GCE;

   901 	ResetScreens();

   902 	TInt error;

   903 	MakeTitleAndCompareWindowsL(_L("GFX_WSERV_DYNAMICRES_0008L"),_L("Change Size Mode"));

   904 

   905 	iTestBack=RWindow(iSession);

   906 	ASSERT_EQUALS(iTestBack.Construct(iGroup, ++iWindowHandle), KErrNone);

   907 	iTestBack.SetRequiredDisplayMode(iDisplayMode);

   908 	iTestBack.SetBackgroundColor(TRgb(255,0,0));

   909 	iTestBack.SetExtent(iTestPos.iTl,iTestPos.Size());

   910 	iTestBack.Activate();

   911 	iTestBack.BeginRedraw();

   912 	ActivateWithWipe(iGc,iTestBack,TRgb(255,0,0));

   913 	iGc->Deactivate();

   914 	iTestBack.EndRedraw();

   915 	iTestBack.SetVisible(ETrue);

   916 	

   917 	

   918 	if (CWindowGc*	gc=BeginActivateWithWipe(ETrue,iCompare,TRgb(128,128,128)))

   919 		{

   920 		gc->SetPenStyle(gc->ESolidPen);

   921 		gc->SetPenColor(TRgb(255,255,255));

   922 		gc->SetBrushColor(TRgb(0,0,0));

   923 		TRect r(2,2,22,22);

   924 		while(r.Width()>0)

   925 			{

   926 			gc->DrawRect(r);

   927 			r.Shrink(2,2);

   928 			}

   929 		gc->Deactivate();

   930 		iCompare.EndRedraw();

   931 		

   932 		}

   933 	iSession.Finish(ETrue);

   934 	Pause(1000);

   935 	

   936 	MDisplayControl* interface = static_cast<MDisplayControl*>

   937 				(iScreenDevice->GetInterface(MDisplayControl::ETypeId));

   938 	ASSERT_TRUE(interface);

   939 	

   940 	TInt resolutions = interface->NumberOfResolutions();

   941 	ASSERT_TRUE (resolutions > 0);

   942 	

   943 	RArray<MDisplayControl::TResolution> resolutionList1;

   944 	error = interface->GetResolutions(resolutionList1);

   945 	ASSERT_EQUALS(error,KErrNone);

   946 	ASSERT_EQUALS(resolutionList1.Count(), resolutions);

   947 	

   948 	TDisplayConfiguration dispConfigBefore;

   949 	interface->GetConfiguration(dispConfigBefore);

   950 	ASSERT_TRUE(dispConfigBefore.IsDefined(dispConfigBefore.EResolution));

   951 	

   952 	RArray<TInt> screenModeList;

   953 	iInfoScreenDevice->GetScreenSizeModeList(&screenModeList);

   954 	ASSERT_TRUE (screenModeList.Count() > 1);

   955 	iScreenDevice->SetAppScreenMode(screenModeList[1]);

   956 	iScreenDevice->SetScreenMode(screenModeList[1]);

   957 	iSession.Finish(ETrue);

   958 	Pause(1000);

   959 	

   960 	MDisplayMapping* interfaceM = static_cast<MDisplayMapping*>

   961 			(iScreenDevice->GetInterface(MDisplayMapping::ETypeId));

   962 	TRect appRect(20, 40, 193, 110);

   963 	TRect uiRect(1,2,3,4);

   964 	TRect compRect(5,6,7,8);

   965 	TRect tempRect(10,11,12,13);

   966 	TInt err;

   967 	while (ETrue)

   968 		{

   969 		//quick get for a print

   970 		err = interfaceM->MapCoordinates(EApplicationSpace, appRect, EFullScreenSpace, uiRect);

   971 		err = interfaceM->MapCoordinates(EApplicationSpace, appRect, ECompositionSpace, compRect);

   972 		

   973 //		print

   974 //		INFO_PRINTF5(_L("appRect : %d , %d - %d , %d"),appRect.iTl.iX,appRect.iTl.iY,appRect.iBr.iX,appRect.iBr.iY);

   975 //		INFO_PRINTF5(_L("uiRect : %d , %d - %d , %d"),uiRect.iTl.iX,uiRect.iTl.iY,uiRect.iBr.iX,uiRect.iBr.iY);

   976 //		INFO_PRINTF5(_L("compRect : %d , %d - %d , %d"),compRect.iTl.iX,compRect.iTl.iY,compRect.iBr.iX,compRect.iBr.iY);

   977 //		INFO_PRINTF1(_L("  "));

   978 		

   979 		//longer process to insure conversions both ways dont lose accuracy

   980 		err = interfaceM->MapCoordinates(EApplicationSpace, appRect, EFullScreenSpace, uiRect);

   981 		err = interfaceM->MapCoordinates(EFullScreenSpace, uiRect, EApplicationSpace, tempRect);

   982 		ASSERT_EQUALS(tempRect,appRect);

   983 		

   984 		err = interfaceM->MapCoordinates(EApplicationSpace, appRect, ECompositionSpace, compRect);

   985 		err = interfaceM->MapCoordinates(ECompositionSpace, compRect, EApplicationSpace, tempRect);

   986 		ASSERT_EQUALS(tempRect,appRect);

   987 		

   988 		err = interfaceM->MapCoordinates(EApplicationSpace, appRect, EFullScreenSpace, uiRect);

   989 		err = interfaceM->MapCoordinates(EFullScreenSpace, uiRect, ECompositionSpace, compRect);

   990 		err = interfaceM->MapCoordinates(ECompositionSpace, compRect, EFullScreenSpace, tempRect);

   991 		ASSERT_EQUALS(tempRect,uiRect);

   992 		

   993 		appRect.iBr.iX--;

   994 		appRect.iBr.iY--;

   995 		if (appRect.IsEmpty())

   996 			{

   997 			break;

   998 			}

   999 		}

  1000 	

  1001 	TRect rect1(5,5,10,10);

  1002 	TRect rect2(15,15,20,20);

  1003 	TRect rect3(50,50,50,50);

  1004 	//1

  1005 	err = interfaceM->MapCoordinates(ECompositionSpace, rect1, ECompositionSpace, rect2);

  1006 	err = interfaceM->MapCoordinates(EFullScreenSpace, rect2, ECompositionSpace, rect3);

  1007 	ASSERT_EQUALS(rect1,rect2);

  1008 	

  1009 	err = interfaceM->MapCoordinates(ECompositionSpace, rect1, EFullScreenSpace, rect2);

  1010 	err = interfaceM->MapCoordinates(EFullScreenSpace, rect2, ECompositionSpace, rect3);

  1011 	ASSERT_EQUALS(rect1,rect3);

  1012 

  1013 	err = interfaceM->MapCoordinates(ECompositionSpace, rect1, EApplicationSpace, rect2);

  1014 	err = interfaceM->MapCoordinates(EApplicationSpace, rect2, ECompositionSpace, rect3);

  1015 	ASSERT_EQUALS(rect1,rect3);

  1016 	

  1017 	err = interfaceM->MapCoordinates(ECompositionSpace, rect1, EDirectScreenAccessSpace, rect2);

  1018 	err = interfaceM->MapCoordinates(EDirectScreenAccessSpace, rect2, ECompositionSpace, rect3);

  1019 	ASSERT_EQUALS(rect1,rect3);

  1020 	

  1021 	//2

  1022 	err = interfaceM->MapCoordinates(EFullScreenSpace, rect1, EFullScreenSpace, rect2);

  1023 	ASSERT_EQUALS(rect1,rect2);

  1024 	

  1025 	err = interfaceM->MapCoordinates(EFullScreenSpace, rect1, EApplicationSpace, rect2);

  1026 	err = interfaceM->MapCoordinates(EApplicationSpace, rect2, EFullScreenSpace, rect3);

  1027 	ASSERT_EQUALS(rect1,rect3);

  1028 	

  1029 	err = interfaceM->MapCoordinates(EFullScreenSpace, rect1, EDirectScreenAccessSpace, rect2);

  1030 	err = interfaceM->MapCoordinates(EDirectScreenAccessSpace, rect2, EFullScreenSpace, rect3);

  1031 	ASSERT_EQUALS(rect1,rect3);

  1032 	

  1033 	//3

  1034 	err = interfaceM->MapCoordinates(EApplicationSpace, rect1, EApplicationSpace, rect2);

  1035 	ASSERT_EQUALS(rect1,rect2);

  1036 	

  1037 	err = interfaceM->MapCoordinates(EApplicationSpace, rect1, EDirectScreenAccessSpace, rect2);

  1038 	err = interfaceM->MapCoordinates(EDirectScreenAccessSpace, rect2, EApplicationSpace, rect3);

  1039 	ASSERT_EQUALS(rect1,rect3);

  1040 	

  1041 	//4

  1042 	err = interfaceM->MapCoordinates(EDirectScreenAccessSpace, rect1, EDirectScreenAccessSpace, rect2);

  1043 	ASSERT_EQUALS(rect1,rect2);

  1044 	

  1045 	//invalid

  1046 	err = interfaceM->MapCoordinates(ECompositionSpace, rect1, (TCoordinateSpace)0, rect2);

  1047 	ASSERT_EQUALS(err,KErrNotSupported);

  1048 	err = interfaceM->MapCoordinates(EFullScreenSpace, rect1, (TCoordinateSpace)0, rect2);

  1049 	ASSERT_EQUALS(err,KErrNotSupported);

  1050 	err = interfaceM->MapCoordinates(EApplicationSpace, rect1, (TCoordinateSpace)0, rect2);

  1051 	ASSERT_EQUALS(err,KErrNotSupported);

  1052 	err = interfaceM->MapCoordinates(EDirectScreenAccessSpace, rect1, (TCoordinateSpace)0, rect2);

  1053 	ASSERT_EQUALS(err,KErrNotSupported);

  1054 	err = interfaceM->MapCoordinates((TCoordinateSpace)0, rect1, EDirectScreenAccessSpace, rect2);

  1055 	ASSERT_EQUALS(err,KErrNotSupported);

  1056 	

  1057 	TDisplayConfiguration dispConfigAfter;

  1058 	interface->GetConfiguration(dispConfigAfter);

  1059 

  1060 	screenModeList.Close();

  1061 	resolutionList1.Close();

  1062 	iScreenDevice->SetAppScreenMode(0);

  1063 	iScreenDevice->SetScreenMode(0);

  1064 	}

  1065 

  1066 /**

  1067 @SYMTestCaseID			GRAPHICS_WSERV_DYNAMICRES_0009L

  1068 @SYMTestCaseDesc		Set Screen display res using app mode

  1069 @SYMREQ					REQ10336

  1070 @SYMPREQ				PREQ2102

  1071 @SYMTestType			CT

  1072 @SYMTestPurpose			SetScreenMode functions correctly

  1073 @SYMTestActions			

  1074 	Similar to 0006, but setting every available screen mode instead of resolution

  1075 @SYMTestExpectedResults	

  1076 	Every set should work, including modes that involve a rotation!

  1077 */

  1078 void	CWsDynamicResBasic::GRAPHICS_WSERV_DYNAMICRES_0009L()

  1079 	{

  1080 	LOG_AND_PANIC_IF_NOT_GCE;

  1081 	ResetScreens();

  1082 	TInt error;

  1083 	iSession.Finish(ETrue);

  1084 	MakeTitleAndCompareWindowsL(_L("GFX_WSERV_DYNAMICRES_0009L"),_L("Change Size Mode"));

  1085 	iSession.Finish(ETrue);

  1086 

  1087 	iTestBack=RWindow(iSession);

  1088 	ASSERT_EQUALS(iTestBack.Construct(iGroup, ++iWindowHandle), KErrNone);

  1089 	iTestBack.SetRequiredDisplayMode(iDisplayMode);

  1090 	iTestBack.SetBackgroundColor(TRgb(255,0,0));

  1091 	iTestBack.SetExtent(iTestPos.iTl,iTestPos.Size());

  1092 	iTestBack.Activate();

  1093 	iTestBack.BeginRedraw();

  1094 	ActivateWithWipe(iGc,iTestBack,TRgb(255,0,0));

  1095 	iGc->Deactivate();

  1096 	iTestBack.EndRedraw();

  1097 	iTestBack.SetVisible(ETrue);

  1098 	iSession.Finish(ETrue);

  1099 	

  1100 	struct DrawCompare

  1101 		{

  1102 		static void Draw(CWindowGc*	aGc)

  1103 			{

  1104 			aGc->SetPenStyle(aGc->ESolidPen);

  1105 			aGc->SetPenColor(TRgb(255,255,255));

  1106 			aGc->SetBrushColor(TRgb(0,0,0));

  1107 			TRect r(2,2,82,82);

  1108 			while(r.Width()>0)

  1109 				{

  1110 				aGc->DrawRect(r);

  1111 				r.Shrink(2,2);

  1112 				}

  1113 			}

  1114 		};

  1115 	TSurfaceId surfaceID;

  1116 	TRAPD(err, surfaceID = iUtility->CreateSurfaceL(TSize(200,200), 

  1117 			KSurfaceFormat, 200 * KBytesPerPixel));

  1118 	ASSERT_EQUALS(err,KErrNone);

  1119 	TRAP(err,iUtility->FanFillSurfaceL(surfaceID,iYellow,iRed,iMagenta));

  1120 	ASSERT_EQUALS(err,KErrNone);

  1121 	TSurfaceConfiguration surfConf;

  1122 	surfConf.SetSurfaceId(surfaceID);

  1123 	

  1124 	surfConf.SetExtent(TRect(2,84,82,166));

  1125 	iCompare.SetBackgroundSurface(surfConf,EFalse);

  1126 	

  1127 	if (CWindowGc*	gc=BeginActivateWithWipe(ETrue,iCompare,TRgb(128,128,128)))

  1128 		{

  1129 		DrawCompare::Draw(gc);

  1130 		gc->Deactivate();

  1131 		iCompare.EndRedraw();

  1132 		

  1133 		}

  1134 	iSession.Finish(ETrue);

  1135 	Pause(1000);