1 // Copyright (c) 2006-2009 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 // This test step contains a series of tests cases to validate the correct behaviour of PREQ1246 implementation.

    15 // In order to create these test cases, basic implementations of the objects involved in this PREQ will be created,

    16 // .i.e. CWsGraphic-derived objects (generically named CWsGraphicTest) and CWsGraphicDrawer-derived objects

    17 // (generically named CWsGraphicDrawerTest).

    18 // Actual construction is performed by a UI-specific entity such as a theme manager. The test code shall replace

    19 // that theme manager functionality, in terms of being the test code who owns a collection of CWsGraphicTest

    20 // objects.

    21 // 

    22 //

    23 

    24 /**

    25  @file

    26  @test

    27  @internalComponent - Internal Symbian test code

    28 */

    29 

    30 #include "TWSGRAPHS.H"

    31 #include "../inc/WSGRAPHICDRAWERARRAY.H"

    32 #include "../../nga/graphicdrawer/panics.h"

    33 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

    34 #include "wsbufferdrawer.h"

    35 #endif

    36 

    37 _LIT(KTestExe, "TWSGRAPHICTEST.exe");

    38 _LIT(KSpace, " ");

    39 

    40 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

    41 const TInt KCustomTextCursorId = TTextCursor::ETypeLastBasic + 57; // 57 is arbitrary

    42 #endif

    43 

    44 CCrWin* CCrWin::NewL(TInt aScreenId, TBool aDraw)

    45 	{

    46 	CCrWin* win = new(ELeave) CCrWin;

    47 	CleanupStack::PushL(win);

    48 	win->ConstructL(aScreenId, aDraw);

    49 	CleanupStack::Pop(win);

    50 	return win;

    51 	}

    52 

    53 CCrWin::~CCrWin()

    54 	{

    55 	iWin.Close();

    56 	iGroup.Close();

    57 	delete iGc;

    58 	delete iScr;

    59 	iWs.Close();

    60 	}

    61 

    62 void CCrWin::ConstructL(TInt aScreenId, TBool aDraw)

    63 	{

    64 	User::LeaveIfError(iWs.Connect());

    65 	iScr = new(ELeave) CWsScreenDevice(iWs);

    66 	User::LeaveIfError(iScr->Construct(aScreenId));

    67 	User::LeaveIfError(iScr->CreateContext(iGc));

    68 	iGroup = RWindowGroup(iWs);

    69 	User::LeaveIfError(iGroup.Construct(0xbadbabe,ETrue));

    70 	iGroup.SetOrdinalPosition(0,100);

    71 	iWin = RWindow(iWs);

    72 	User::LeaveIfError(iWin.Construct(iGroup,0xbadcafe));

    73 	iWin.SetRequiredDisplayMode(EColor64K);

    74 	iWin.Activate();

    75 	iWs.Flush();

    76 	if (aDraw)

    77 	Draw();

    78 	}

    79 

    80 void CCrWin::Draw()

    81 	{

    82 	iWin.BeginRedraw();

    83 	iGc->Activate(iWin);

    84 	iGc->SetBrushColor(KRgbRed);

    85 	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

    86 	TRect rect(iScr->SizeInPixels());

    87 	iGc->DrawRect(rect);

    88 	iGc->SetBrushColor(KRgbBlue);

    89 	iGc->DrawEllipse(TRect(rect.iTl.iX,rect.iTl.iY,rect.iBr.iX/2,rect.iBr.iY));

    90 	iGc->DrawEllipse(TRect(rect.iBr.iX/2,rect.iTl.iY,rect.iBr.iX,rect.iBr.iY));

    91 	iGc->Deactivate();

    92 	iWin.EndRedraw();

    93 	iWs.Flush();

    94 	}

    95 

    96 

    97 void CCrWin::DrawFirstHalf()

    98 	{

    99 	iWin.BeginRedraw();

   100 	iGc->Activate(iWin);

   101 	iGc->SetBrushColor(KRgbRed);

   102 	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

   103 	TRect rect(TPoint(0,0),TSize(iScr->SizeInPixels().iWidth/2,iScr->SizeInPixels().iHeight));

   104 	iGc->DrawRect(rect);

   105 	iWs.Flush();	

   106 	}

   107 

   108 void CCrWin::DrawSecondHalf()

   109 	{

   110 	TRect rect(TPoint(iScr->SizeInPixels().iWidth/2,0),TSize(iScr->SizeInPixels().iWidth/2,iScr->SizeInPixels().iHeight));

   111 	iGc->DrawRect(rect);

   112 	iGc->Deactivate();

   113 	iWin.EndRedraw();	

   114 	iWs.Flush();		

   115 	}

   116 

   117 /** 

   118 The objective of this function is, two animations should run independently

   119 with respective frame rate in the given time interval.

   120 The time delay allows to draw animations freely and the plug-in

   121 calculates number of times DoDraw() function called during this interval.

   122 

   123 @param TInt Wsgrphic test plug-in id.

   124 */

   125 void CCrWin::DrawGraphic(TInt aWsId)

   126 	{

   127 	// draw the animation in two positions

   128 	const TSize screenSize = iScr->SizeInPixels();	

   129 	const TRect position(0,0,screenSize.iWidth/2,screenSize.iHeight);

   130 	const TRect position2((screenSize.iWidth/2)+1,0,screenSize.iWidth,screenSize.iHeight);

   131 	//PeterI if CWsGraphic animation areas overlap then when one redraws the other will as well.

   132 	//2 separate positions are needed otherwise the framerates will be identical.

   133 	

   134 	iWin.BeginRedraw();

   135 	iGc->Activate(iWin);

   136 	const TUint8 animid1=0;

   137 	const TUint8 fps1=20;

   138 	TBuf8<2> animData1;

   139 	animData1.Append(animid1);   //animId1

   140 	animData1.Append(fps1); //20fps

   141 	iGc->DrawWsGraphic(aWsId,position,animData1);

   142 	iWs.Flush();

   143 	User::After(200000);

   144 	const TUint8 animid2=1;

   145 	const TUint8 fps2=60;

   146 	TBuf8<2> animData2;

   147 	animData2.Append(animid2);   //animId2

   148 	animData2.Append(fps2); //60fps

   149 	iGc->DrawWsGraphic(aWsId,position2,animData2);

   150 	iWs.Flush();

   151 	User::After(200000);

   152 	iGc->Deactivate();

   153 	iWin.EndRedraw();

   154 	iWs.Flush();

   155 	}

   156 

   157 /**

   158  * Set a standard text cursor on this window.

   159  * @see RWindowGroup::SetTextCursor()

   160  */

   161 void CCrWin::SetTextCursor(const TPoint &aPos, const TTextCursor &aCursor)

   162 	{

   163 	iGroup.SetTextCursor(iWin, aPos, aCursor);

   164 	}

   165 

   166 /**

   167  * Cancel a text cursor from this window.

   168  * @see RWindowGroup::CancelTextCursor()

   169  */

   170 void CCrWin::CancelTextCursor()

   171 	{

   172 	iGroup.CancelTextCursor();

   173 	}

   174 

   175 CCrAlphaWin* CCrAlphaWin::NewL(TInt aScreenId)

   176 	{

   177 	CCrAlphaWin* win = new(ELeave) CCrAlphaWin;

   178 	CleanupStack::PushL(win);

   179 	win->ConstructL(aScreenId);

   180 	CleanupStack::Pop(win);

   181 	return win;

   182 	}

   183 

   184 CCrAlphaWin::~CCrAlphaWin()

   185 	{

   186 	iWin.Close();

   187 	iGroup.Close();

   188 	delete iScr;

   189 	iWs.Close();

   190 	}

   191 

   192 void CCrAlphaWin::ConstructL(TInt aScreenId)

   193 	{

   194 	User::LeaveIfError(iWs.Connect());

   195 	iScr = new(ELeave) CWsScreenDevice(iWs);

   196 	User::LeaveIfError(iScr->Construct(aScreenId));

   197 	iGroup = RWindowGroup(iWs);

   198 	User::LeaveIfError(iGroup.Construct(0xbadc0de,ETrue));

   199 	iGroup.SetOrdinalPosition(0,100);

   200 	iWin = RWindow(iWs);

   201 	User::LeaveIfError(iWin.Construct(iGroup,0xbadbeef));

   202 	iWin.SetRequiredDisplayMode(EColor64K);

   203 	iWin.SetTransparencyAlphaChannel();

   204 	iWin.SetBackgroundColor(TRgb(0xff,0xff,0,0x80));

   205 	iWin.Activate();

   206 	iWs.Flush();

   207 	}

   208 

   209 

   210 //

   211 //  CTWsGraphs

   212 //

   213 

   214 CTWsGraphs::CTWsGraphs(CTestStep* aStep):

   215 	CTWsGraphicsBase(aStep)

   216 	{

   217 	}

   218 

   219 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

   220 LOCAL_D void DeleteSpriteMember(TAny* aSpriteMember)

   221 	{

   222 	TSpriteMember* member=reinterpret_cast<TSpriteMember*>(aSpriteMember);

   223 	delete member->iBitmap;

   224 	member->iBitmap=NULL;

   225 	delete member->iMaskBitmap;

   226 	member->iMaskBitmap=NULL;

   227 	}

   228 #endif

   229 

   230 CTWsGraphs::~CTWsGraphs()

   231 	{

   232 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

   233 	DeleteSpriteMember(&iSpriteMemberArray[0]);

   234 	iSpriteMemberArray.Close();

   235 #endif

   236 	delete iGdCoverage;

   237 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

   238 	delete iAfter;

   239 	delete iBefore;

   240 	delete iBackCopy;

   241 	delete iFrontCopy;

   242 #endif

   243 	delete iListen;

   244 	delete iNotify2;

   245 	delete iNotify1;

   246 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

   247 	delete iRedir;

   248 #endif

   249 	}

   250 

   251 void CTWsGraphs::ConstructL()

   252 	{

   253 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

   254 	iRedir = CWsRedir::NewL(iTest->iScreenNumber,ETrue);

   255 	iRedir->SetCallBack(TCallBack(CTWsGraphs::PluginCallBack,this));

   256 #endif

   257 	iNotify1 = CWsNotify::NewL(EFalse);

   258 	iNotify2 = CWsNotify::NewL(ETrue);

   259 	iListen = CWsListen::NewL(ETrue);

   260 	iListen->SetCallBack(TCallBack(CTWsGraphs::PluginCallBack,this));

   261 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

   262 	iFrontCopy = new(ELeave) CFbsBitmap;

   263 	iBackCopy = new(ELeave) CFbsBitmap;

   264 	iBefore = new(ELeave) CFbsBitmap;

   265 	User::LeaveIfError(iBefore->Create(TheClient->iScreen->SizeInPixels(), EColor64K));

   266 	iAfter = new(ELeave) CFbsBitmap;

   267 	User::LeaveIfError(iAfter->Create(TheClient->iScreen->SizeInPixels(), EColor64K));

   268 #endif

   269 	iGdCoverage = CWsGdCoverage::NewL();

   270 	iGdCoverage->SetCallBack(TCallBack(CTWsGraphs::PluginCallBack,this));

   271 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

   272 	TSpriteMember spriteMember;

   273 	spriteMember.iBitmap = NULL;

   274 	spriteMember.iMaskBitmap = NULL;

   275 	spriteMember.iInvertMask =EFalse;

   276 	spriteMember.iDrawMode = CGraphicsContext::EDrawModePEN;

   277 	spriteMember.iOffset = TPoint();

   278 	spriteMember.iInterval = TTimeIntervalMicroSeconds32(0);

   279 	CleanupStack::PushL(TCleanupItem(DeleteSpriteMember, &spriteMember));

   280 	spriteMember.iBitmap = new (ELeave) CFbsBitmap;

   281 	User::LeaveIfError(spriteMember.iBitmap->Load(TEST_BITMAP_NAME, EMbmWsautotestBmp1));

   282 	spriteMember.iMaskBitmap = new (ELeave) CFbsBitmap;

   283 	User::LeaveIfError(spriteMember.iMaskBitmap->Load(TEST_BITMAP_NAME, EMbmWsautotestBmp1mask));

   284 	User::LeaveIfError(iSpriteMemberArray.Append(spriteMember));

   285 	CleanupStack::Pop(&spriteMember);

   286 #endif

   287 	}

   288 

   289 void CTWsGraphs::LaunchNewProcess(const TDesC& aExecutable)

   290 	{

   291 	TBuf<128> args;

   292  	args.Append(KSpace);

   293 	args.AppendNum(iTest->iScreenNumber);

   294 	RProcess pr;

   295 	TInt err = pr.Create(aExecutable,args);

   296 	if (err == KErrNone)

   297 		{

   298 		TRequestStatus status;

   299 		pr.Logon(status);

   300 		pr.Resume();

   301 		User::WaitForRequest(status);

   302 		err = pr.ExitReason();

   303 		pr.Close();

   304 		if (err != KErrNone)

   305 			{

   306 			_LIT(KLog,"%S returned error: %d. Check RDebug output.");

   307 			LOG_MESSAGE3(KLog, &aExecutable, err);

   308 			}

   309 		}

   310 	else

   311 		{

   312 		_LIT(KLog,"Can't create the process (%S), err=%d");

   313 		LOG_MESSAGE3(KLog, &aExecutable, err);

   314 		}

   315 	TEST(err == KErrNone);

   316 	// Restore main test group to foreground.

   317 	TheClient->iGroup->GroupWin()->SetOrdinalPosition(0);

   318 	}

   319 

   320 TInt CTWsGraphs::PluginCallBack(TAny* /*aArg*/)

   321 	{

   322 	return (TInt)EWait;

   323 	}

   324 

   325 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

   326 

   327 /**

   328  @SYMTestCaseID				GRAPHICS-WSERV-0371

   329  @SYMREQ					GT247-CR0714

   330  @SYMTestCaseDesc			Test interface extension

   331  @SYMTestPriority			High

   332  @SYMTestStatus				Implemented

   333  @SYMTestActions			Retrieves object interfaces from Content Rendering Plugin (plugin).

   334 							Actions step:

   335 							-Create plugin

   336 							-Query interfaces obtained from plugin side

   337  @SYMTestExpectedResults	Supported interfaces should return non null

   338 */

   339 TestState CTWsGraphs::TestInterfaceExtensionL()

   340 	{

   341 	if (iSubState==0)

   342 		{

   343 		_LIT(KTestInterfaceExtension, "TestInterfaceExtension");

   344 		INFO_PRINTF1(KTestInterfaceExtension);

   345 

   346 		++iSubState;

   347 		Mem::FillZ(&iRedirInfo, sizeof(TRedirectorInfo));

   348 		iRedir->QueryPlugin(iRedirInfo);

   349 		return EWait;

   350 		}

   351 	TEST(iRedirInfo.iScreenConfigInterface!=NULL);

   352 	TEST(iRedirInfo.iFrontBufferInterface!=NULL);

   353 	TEST(iRedirInfo.iScreenBitmapHandle!=0);

   354 	iFrontCopy->Duplicate(iRedirInfo.iScreenBitmapHandle);

   355 

   356 	if (TransparencySupportedL()!=KErrNotSupported)

   357 		{

   358 		TEST(iRedirInfo.iBackBufferInterface!=NULL);

   359 		TEST(iRedirInfo.iFlickerBitmapHandle!=0);

   360 		iBackCopy->Duplicate(iRedirInfo.iFlickerBitmapHandle);

   361 		}

   362 

   363 	++(iTest->iState);

   364 	iSubState = 0;

   365 	return ENext;

   366 	}

   367 

   368 #endif // TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

   369 

   370 void CTWsGraphs::CreateWindowL(TBool aDraw)

   371 	{

   372 	iWin = CCrWin::NewL(iTest->iScreenNumber, aDraw);

   373 	}

   374 

   375 void CTWsGraphs::DestroyWindowL()

   376 	{

   377 	delete iWin;

   378 	iWin = NULL;

   379 	}

   380 

   381 void CTWsGraphs::CreateAlphaWindowL()

   382 	{

   383 	iAlpha = CCrAlphaWin::NewL(iTest->iScreenNumber);

   384 	}

   385 

   386 void CTWsGraphs::DestroyAlphaWindowL()

   387 	{

   388 	delete iAlpha;

   389 	iAlpha = NULL;

   390 	}

   391 

   392 TBool CTWsGraphs::CompareBitmapArea16Bpp(CFbsBitmap* aBmp1, const TPoint& aPos1, CFbsBitmap* aBmp2, const TPoint& aPos2, const TSize& aSize)

   393 	{

   394 	const TDisplayMode dispmode = aBmp1->DisplayMode();

   395 	if (dispmode!=aBmp2->DisplayMode())

   396 		return EFalse;

   397 	const TInt stride1 = aBmp1->DataStride();

   398 	const TInt stride2 = aBmp2->DataStride();

   399 	const TInt linebytes = aSize.iWidth * 2;

   400 	const TInt pixelbytes = 2;

   401 	aBmp1->LockHeap();

   402 	const TUint8* p1 = ((const TUint8*)aBmp1->DataAddress())+aPos1.iY*stride1+aPos1.iX*pixelbytes;

   403 	const TUint8* p2 = ((const TUint8*)aBmp2->DataAddress())+aPos2.iY*stride2+aPos2.iX*pixelbytes;

   404 	for (TInt y=0; y<aSize.iHeight; ++y)

   405 		{

   406 		if (Mem::Compare(p1+y*stride1,linebytes,p2+y*stride2,linebytes)!=0)

   407 			{

   408 			aBmp1->UnlockHeap();

   409 			return EFalse;

   410 			}

   411 		}

   412 	aBmp1->UnlockHeap();

   413 	return ETrue;

   414 	}

   415 

   416 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

   417 TestState CTWsGraphs::TestScreenRedirectionL()

   418 	{

   419 	if (iSubState==0)

   420 		{

   421 		_LIT(KTestScreenRedirection, "TestScreenRedirection");

   422 		INFO_PRINTF1(KTestScreenRedirection);

   423 

   424 		++iSubState;

   425 		/**

   426 		 @SYMTestCaseID				GRAPHICS-WSERV-0372

   427 		 @SYMREQ					GT247-CR0714

   428 		 @SYMTestCaseDesc			Redirect wserv screen drawing to custom graphics context

   429 		 @SYMTestPriority			High

   430 		 @SYMTestStatus				Implemented

   431 		 @SYMTestActions			Redirects wserv screen drawing to bitmap context owned by plugin.

   432 									Actions step:

   433 									-Draw opaque window.

   434 									-Save screen content to a bitmap

   435 									-Instruct plugin to redirect wserv screen drawing to a bitmap device

   436 									-Draw the same window again

   437 									-Retrieve plugin bitmap and compare against  the saved bitmap

   438 		 @SYMTestExpectedResults	Bitmap content match

   439 		*/

   440 		CreateWindowL();		

   441 		TheClient->iScreen->CopyScreenToBitmap(iBefore);

   442 		DestroyWindowL();

   443 		iRedir->Redirect(CWsRedir::EFrontBuffer, ETrue);

   444 		return EWait;

   445 		}

   446 

   447 	if (iSubState==1)

   448 		{

   449 		++iSubState;

   450 		CreateWindowL();

   451 		TSize sz = iBefore->SizeInPixels();

   452 		TInt bytes = sz.iWidth*sz.iHeight*2; // EColor64K

   453 		iBefore->LockHeap();

   454 		TEST(Mem::Compare((const TUint8*)iFrontCopy->DataAddress(),bytes,(const TUint8*)iBefore->DataAddress(),bytes)==0);

   455 		iBefore->UnlockHeap();

   456 

   457 		Mem::FillZ(&iRedirInfo, sizeof(TRedirectorInfo));			

   458 		iRedir->QueryPlugin(iRedirInfo);

   459 		return EWait;

   460 		}

   461 

   462 	if (iSubState==2)

   463 		{

   464 		++iSubState;

   465 		/**

   466 		 @SYMTestCaseID				GRAPHICS-WSERV-0047

   467 		 @SYMTestCaseDesc			Screen update event

   468 		 @SYMTestPriority			Medium

   469 		 @SYMTestStatus				Implemented

   470 		 @SYMTestActions			Check plugin receive screen update event during redirection

   471 		 @SYMTestExpectedResults	Counter is non-zero

   472 		*/

   473 		TEST(iRedirInfo.iUpdateCounter>0);

   474 

   475 		DestroyWindowL();

   476 		/**

   477 		 @SYMTestCaseID				GRAPHICS-WSERV-0373

   478 		 @SYMREQ					GT247-CR0714

   479 		 @SYMTestCaseDesc			Stop wserv screen drawing redirection

   480 		 @SYMTestPriority			High

   481 		 @SYMTestStatus				Implemented

   482 		 @SYMTestActions			Stop wserv screen drawing redirection.

   483 									Actions step:

   484 									-Instruct plugin to stop wserv screen drawing redirection

   485 									-Draw the same window again

   486 									-Save screen content to another bitmap

   487 									-Compare the saved bitmap against newly saved bitmap

   488 		 @SYMTestExpectedResults	Bitmap content match

   489 		*/

   490 		iRedir->Redirect(CWsRedir::EFrontBuffer, EFalse);

   491 		return EWait;

   492 		}

   493 

   494 	if (iSubState==3)

   495 		{

   496 		++iSubState;

   497 		CreateWindowL();

   498 		TheClient->iScreen->CopyScreenToBitmap(iAfter);

   499 		TSize sz = iBefore->SizeInPixels();	

   500 		TInt bytes = sz.iWidth*sz.iHeight*2; // EColor64K	

   501 		iAfter->LockHeap();

   502 		TEST(Mem::Compare((const TUint8*)iAfter->DataAddress(),bytes,(const TUint8*)iBefore->DataAddress(),bytes)==0);

   503 		iAfter->UnlockHeap();

   504 		DestroyWindowL();

   505 

   506 		Mem::FillZ(&iRedirInfo, sizeof(TRedirectorInfo));			

   507 		iRedir->QueryPlugin(iRedirInfo);

   508 		return EWait;

   509 		}

   510 

   511 	/**

   512 	 @SYMTestCaseID				GRAPHICS-WSERV-0374

   513 	 @SYMTestCaseDesc			Screen update event

   514 	 @SYMTestPriority			Medium

   515 	 @SYMTestStatus				Implemented

   516 	 @SYMTestActions			Check plugin receive no screen update event when redirection is terminated

   517 	 @SYMTestExpectedResults	Counter is zero

   518 	*/

   519 	TEST(iRedirInfo.iUpdateCounter==0);

   520 

   521 	++(iTest->iState);

   522 	iSubState = 0;

   523 

   524 	return ENext;

   525 	}

   526 

   527 TestState CTWsGraphs::TestTextCursorUnderRedirectionL(TTestCursorType aCursorType)

   528 	{

   529 	/**

   530 	 @SYMTestCaseID				GRAPHICS-WSERV-0363

   531 	 @SYMTestCaseDesc			Text Cursor when drawing redirected

   532 	 @SYMTestPriority			Medium

   533 	 @SYMTestStatus				Implemented

   534 	 @SYMTestActions			Action steps:

   535 	 							- Draw the text cursor in the left side of the screen

   536 	 							- Re-direct the Front Buffer

   537 	 							- Move the text cursor to the right side of the screen

   538 	 							- Pause 0.5 seconds because this amount of time is needed

   539 								  to change from the flash ON phase to the flash OFF phase

   540 	 							- Stop re-directing

   541 	 							- See if when we exit re-direction in a different place in

   542 	 							  the phase of the text cursor flashing, whether we get

   543 	 							  non-text cursor drawing artefacts in the old location

   544 	 							  where the text cursor used to be

   545 	 @SYMTestExpectedResults	Left side of the screen does not show a Text Cursor

   546 	 */

   547 	

   548 	ASSERT(aCursorType == ETestStandardTextCursor || aCursorType == ETestCustomTextCursor);

   549 	

   550 	// Cursor Flash Period is 1 second (comprising two phases; ON and OFF)

   551 	const TInt KCursorFlashPeriod = 1000000;

   552 	const TInt KWaitForNextFlashPhase = KCursorFlashPeriod / 2;

   553 	

   554 	// Size of the cursor; it may be either a standard or custom text cursor

   555 	TSize cursorSize = (aCursorType == ETestStandardTextCursor) ? TSize(15, 20) : TSize(80, 80);

   556 		

   557 	// Original Text Cursor position in the left part of the screen

   558 	const TPoint originalCursorPos(45, 40);

   559 	

   560 	// New Text Cursor position in the right half of the screen

   561 	const TPoint newCursorPos((TheClient->iScreen->SizeInPixels().iWidth/2) + 45, 40);

   562 	

   563 	// Clean area of the screen which never had a text cursor

   564 	const TPoint cleanReferencePos(45, 40 + 80);

   565 	

   566 	/* Initial setup to get a window with a standard flashing text cursor */

   567 	if (iSubState == 0)

   568 		{

   569 		++iSubState;			

   570 		CreateWindowL(ETrue);

   571 		

   572 		if (aCursorType == ETestStandardTextCursor)

   573 			{

   574 			_LIT(KTestTextCursorUnderRedirection, "TestTextCursorUnderRedirection(Standard Cursor)");

   575 			INFO_PRINTF1(KTestTextCursorUnderRedirection);	

   576 			iTextCursor.iType=TTextCursor::ETypeRectangle;

   577 			iTextCursor.iHeight=cursorSize.iHeight;

   578 			iTextCursor.iAscent=0;

   579 			iTextCursor.iWidth=cursorSize.iWidth;

   580 			iTextCursor.iFlags=0; 			// means flash the cursor

   581 			iTextCursor.iColor=KRgbGreen;

   582 			iWin->SetTextCursor(originalCursorPos, iTextCursor);

   583 			}

   584 		else if (aCursorType == ETestCustomTextCursor)

   585 			{

   586 			_LIT(KTestTextCursorUnderRedirection, "TestTextCursorUnderRedirection(Custom Cursor)");

   587 			INFO_PRINTF1(KTestTextCursorUnderRedirection);	

   588 

   589 			TInt err = TheClient->iWs.SetCustomTextCursor(

   590 					KCustomTextCursorId,

   591 					iSpriteMemberArray.Array(),

   592 					ESpriteFlash,

   593 					RWsSession::ECustomTextCursorAlignTop

   594 					);

   595 			iTextCursor.iType=KCustomTextCursorId;

   596 			iTextCursor.iHeight=cursorSize.iHeight;

   597 			iTextCursor.iAscent=0;

   598 			iTextCursor.iWidth=cursorSize.iWidth;

   599 			iTextCursor.iFlags=TTextCursor::EFlagClipHorizontal; // means flash the cursor and clip the sprite

   600 			iTextCursor.iColor=KRgbCyan;

   601 			iWin->SetTextCursor(originalCursorPos, iTextCursor);

   602 			}

   603 		else

   604 			{

   605 			// unknown type of test being requested

   606 			ASSERT(0);

   607 			}

   608 		iWin->DrawFirstHalf();	

   609 		return EWait;

   610 		}

   611 	/*

   612 	 * Re-direct drawing to another Front Buffer.  Whilst re-directed, change the

   613 	 * position of the text cursor.  Then pause 0.5 seconds because this is how

   614 	 * long it will take to enter the next phase in the flashing cycle.  Finally

   615 	 * stop re-directing.  We exit the re-direction in a different point in the

   616 	 * phase of the text cursor from when we entered it.

   617 	 * This is key to testing for faulty behaviour.

   618 	 */

   619 	if (iSubState==1)

   620 		{

   621 		++iSubState;

   622 		User::After(KCursorFlashPeriod * 2);  // so its easy to visually review progress

   623 		iRedir->Redirect(CWsRedir::EFrontBuffer, ETrue);

   624 		iWin->SetTextCursor(newCursorPos, iTextCursor);

   625 		User::After(KWaitForNextFlashPhase);

   626 		iRedir->Redirect(CWsRedir::EFrontBuffer, EFalse);

   627 		return EWait;

   628 		}

   629 	/*

   630 	 * Paint the right hand side of the screen which should now have a text cursor.

   631 	 */

   632 	if (iSubState==2)

   633 		{

   634 		++iSubState;

   635 		iWin->DrawSecondHalf();

   636 		return EWait;

   637 		}

   638 	/*

   639 	 * Let the cursor flash a few times, as it assists manual viewing of the progress

   640 	 * of the test.

   641 	 */

   642 	if (iSubState==3)

   643 		{

   644 		++iSubState;

   645 		User::After(KCursorFlashPeriod * 3);

   646 		return EWait;

   647 		}

   648 	/*

   649 	 * Check to see if the text cursor did move to the right of the screen.

   650 	 */

   651 	if (iSubState==4)

   652 		{

   653 		++iSubState;

   654 		

   655 		/* When we do a screen comparison, we supply flag 0, which means

   656 		 * don't include the text cursor.  We do this because we are interested

   657 		 * in screen artefacts.

   658 		 */

   659 		TEST(TheClient->iScreen->RectCompare(

   660 				TRect(originalCursorPos, cursorSize),

   661 				TRect(cleanReferencePos, cursorSize),

   662 				0)); // must not supply CWsScreenDevice::EIncludeTextCursor

   663 		

   664 		return EWait;

   665 		}

   666 	/* Clean up */

   667 	if (iSubState==5)

   668 		{

   669 		++iSubState;

   670 		iWin->CancelTextCursor();

   671 		DestroyWindowL();

   672 		}

   673 	

   674 	iSubState = 0;

   675 

   676 	return ENext;

   677 	}

   678 

   679 /**

   680  @SYMTestCaseID				GRAPHICS-WSERV-0375

   681  @SYMREQ					GT247-CR0714

   682  @SYMTestCaseDesc			Redirect wserv flickerfree drawing to custom graphics context

   683  @SYMTestPriority			Medium

   684  @SYMTestStatus				Implemented

   685  @SYMTestActions			Redirect wserv flickerfree buffer drawing.

   686 							Action step:

   687 							-Draw opaque window (as background) and transparent window

   688 							-Save screen content to a bitmap

   689 							-Instruct plugin to redirect wserv flickerfree buffer drawing

   690 							-Draw the same opaque window and transparent window again

   691 							-Retrieve plugin bitmap and compare against the saved bitmap

   692  @SYMTestExpectedResults	Bitmap content match

   693 */

   694 /**

   695  @SYMTestCaseID				GRAPHICS-WSERV-0376

   696  @SYMREQ					GT247-CR0714

   697  @SYMTestCaseDesc			Stop wserv flickerfree drawing redirection

   698  @SYMTestPriority			Medium

   699  @SYMTestStatus				Implemented

   700  @SYMTestActions			Stop wserv flickerfree buffer drawing redirection.

   701 							Action step:

   702 							-Instruct plugin to stop wserv filckerfree drawing redirection

   703 							-Draw the same opaque and transparent window

   704 							-Save screen content to another bitmap

   705 							-Compare saved bitmap against newly saved bitmap

   706  @SYMTestExpectedResults	Bitmap content match

   707 */

   708 

   709 TestState CTWsGraphs::TestFlickerRedirectionL()

   710 	{

   711 	if (TransparencySupportedL()==KErrNotSupported)

   712 		{

   713 		++(iTest->iState);

   714 		return ENext;

   715 		}

   716 

   717 	// flush transparent window destruction created in TransparencySupportedL before

   718 	// proceeding with the test

   719 

   720 	TheClient->iWs.Flush();

   721 

   722 	if (iSubState==0)

   723 		{

   724 		_LIT(KTestFlickerRedirection, "TestFlickerRedirection");

   725 		INFO_PRINTF1(KTestFlickerRedirection);

   726 

   727 		++iSubState;

   728 

   729 		CreateWindowL();

   730 		CreateAlphaWindowL();

   731 		TheClient->iScreen->CopyScreenToBitmap(iBefore);

   732 		DestroyAlphaWindowL();

   733 		DestroyWindowL();

   734 		iRedir->Redirect(CWsRedir::EBackBuffer, ETrue);

   735 		return EWait;

   736 		}

   737 

   738 	if (iSubState==1)

   739 		{

   740 		++iSubState;

   741 		CreateWindowL();

   742 		CreateAlphaWindowL();

   743 		TSize sz = iBefore->SizeInPixels();

   744 		TInt bytes = sz.iWidth*sz.iHeight*2; // EColor64K

   745 		iBefore->LockHeap();

   746 		TInt ret=Mem::Compare((const TUint8*)iBackCopy->DataAddress(),bytes,(const TUint8*)iBefore->DataAddress(),bytes);

   747 		TEST(ret==0);

   748 		if (ret!=0)

   749 			{

   750 			_LIT(KLog,"The memory of two bitmaps doesn't match");

   751 			LOG_MESSAGE(KLog);

   752 			}

   753 		iBefore->UnlockHeap();

   754 		DestroyAlphaWindowL();

   755 		DestroyWindowL();

   756 		iRedir->Redirect(CWsRedir::EBackBuffer, EFalse);

   757 		return EWait;

   758 		}

   759 

   760 	CreateWindowL();

   761 	CreateAlphaWindowL();

   762 	TheClient->iScreen->CopyScreenToBitmap(iAfter);

   763 	TSize sz = iBefore->SizeInPixels();

   764 	TInt bytes = sz.iWidth*sz.iHeight*2; // EColor64K

   765 	iAfter->LockHeap();

   766 	TEST(Mem::Compare((const TUint8*)iAfter->DataAddress(),bytes,(const TUint8*)iBefore->DataAddress(),bytes)==0);

   767 	iAfter->UnlockHeap();

   768 	DestroyAlphaWindowL();

   769 	DestroyWindowL();

   770 

   771 	++(iTest->iState);

   772 	iSubState = 0;

   773 	return ENext;

   774 	}

   775 

   776 #endif // TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

   777 

   778 /**

   779  @SYMTestCaseID				GRAPHICS-WSERV-0377

   780  @SYMREQ					GT247-CR0714

   781  @SYMTestCaseDesc			Enable event notification

   782  @SYMTestPriority			Medium

   783  @SYMTestStatus				Implemented

   784  @SYMTestActions			Enable plugin to register to event notification.

   785 							Action step:

   786 							-Instruct plugin to register event handler

   787 							-Draw fullscreen window (plugin will receive window visibility changed event)

   788 							-Query visibility region from plugin side

   789 							-Compare window visible region against value obtained by plugin

   790  @SYMTestExpectedResults	Visible region match

   791 */

   792 /**

   793  @SYMTestCaseID				GRAPHICS-WSERV-0378

   794  @SYMREQ					GT247-CR0714

   795  @SYMTestCaseDesc			Disable event notification

   796  @SYMTestPriority			Medium

   797  @SYMTestStatus				Implemented

   798  @SYMTestActions			Disable plugin to register to event notification.

   799 							Action step:

   800 							-Instruct plugin to unregister event handler

   801 							-Destroy fullscreen window (plugin will not receive window visibility changed event)

   802 							-Query visibility region from plugin side

   803 

   804  @SYMTestExpectedResults	Plugin does not receive events notification

   805 */

   806 TestState CTWsGraphs::TestEventNotificationL()

   807 	{

   808 	if (iSubState==0)

   809 		{

   810 		_LIT(KTestEventNotification, "TestEventNotification");

   811 		INFO_PRINTF1(KTestEventNotification);

   812 

   813 		++iSubState;

   814 		iListen->Enable(ETrue);

   815 		CreateWindowL();

   816 		Mem::FillZ(&iListenInfo, sizeof(TListenerInfo));

   817 		TheClient->iWs.Finish();

   818 		TheClient->WaitForRedrawsToFinish();

   819 		iListen->QueryPlugin(iListenInfo);

   820 		return EWait;

   821 		}

   822 

   823 	if (iSubState==1)

   824 		{

   825 		++iSubState;

   826 		iListen->Enable(EFalse);

   827 		TEST(iListenInfo.iNumRect==1);

   828 		TEST(iListenInfo.iRect==TRect(TPoint(0,0),TheClient->iScreen->SizeInPixels()));

   829 		DestroyWindowL();

   830 		Mem::FillZ(&iListenInfo, sizeof(TListenerInfo));

   831 		iListen->QueryPlugin(iListenInfo);

   832 		iListen->Enable(EFalse);

   833 		DestroyWindowL();

   834 		return EWait;

   835 		}

   836 		

   837 	TEST(iListenInfo.iNumRect==0);

   838 	

   839 	++(iTest->iState);

   840 	iSubState = 0;

   841 	return ENext;

   842 	}

   843 

   844 #ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

   845 

   846 TestState CTWsGraphs::TestRedirectionUsingWsBackBufferL()

   847 	{

   848 	if (TransparencySupportedL()==KErrNotSupported)

   849 		{

   850 		++(iTest->iState);

   851 		return ENext;

   852 		}

   853 

   854 	// flush transparent window destruction created in TransparencySupportedL before

   855 	// proceeding with the test

   856 

   857 	TheClient->iWs.Flush();

   858 

   859 	if (iSubState==0)

   860 		{

   861 		_LIT(KTestRedirectionWsBack, "TestRedirectionUsingWsBackBuffer");

   862 		INFO_PRINTF1(KTestRedirectionWsBack);

   863 		

   864 		++iSubState;

   865 

   866 		/**

   867 		 @SYMTestCaseID				GRAPHICS-WSERV-0379

   868 		 @SYMTestCaseDesc			Redirect wserv flickerfree to MWsBackBuffer object

   869 		 @SYMTestPriority			Medium

   870 		 @SYMTestStatus				Implemented

   871 		 @SYMTestActions			-Draw opaque window (as background) and transparent window

   872 									-Save screen content to a bitmap

   873 									-Instruct plugin to redirect flickerfree buffer to MWsBackBuffer object

   874 									-Draw the same opaque window and transparent window again

   875 									-Retrieve plugin bitmap and compare against the saved bitmap

   876 		 @SYMTestExpectedResults	Bitmap content match

   877 		*/

   878 		((CTWsGraphsStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0379"));

   879 		CreateWindowL();

   880 		CreateAlphaWindowL();

   881 		TheClient->iScreen->CopyScreenToBitmap(iBefore);

   882 		DestroyAlphaWindowL();		

   883 		DestroyWindowL();		

   884 		iRedir->RedirectUsingWsBackBuffer(ETrue);

   885 		return EWait;

   886 		}

   887 

   888 	if (iSubState==1)

   889 		{

   890 		++iSubState;

   891 		CreateWindowL();

   892 		CreateAlphaWindowL();

   893 		TSize sz = iBefore->SizeInPixels();

   894 		TInt bytes = sz.iWidth*sz.iHeight*2; // EColor64K

   895 		iBefore->LockHeap();

   896 		TInt ret=Mem::Compare((const TUint8*)iBackCopy->DataAddress(),bytes,(const TUint8*)iBefore->DataAddress(),bytes);

   897 		TEST(ret==0);

   898 		if (ret!=0)

   899 			{

   900 			_LIT(KLog,"The memory of two bitmaps doesn't match");

   901 			LOG_MESSAGE(KLog);

   902 			}

   903 		iBefore->UnlockHeap();

   904 		DestroyAlphaWindowL();

   905 		DestroyWindowL();

   906 

   907 		/**

   908 		 @SYMTestCaseID				GRAPHICS-WSERV-0380

   909 		 @SYMTestCaseDesc			Restore wserv flickerfree redirection from MWsBackBuffer object

   910 		 @SYMTestPriority			Medium

   911 		 @SYMTestStatus				Implemented

   912 		 @SYMTestActions			-Instruct plugin to stop wserv filckerfree drawing redirection

   913 									-Draw the same opaque and transparent window

   914 									-Save screen content to another bitmap

   915 									-Compare saved bitmap against newly saved bitmap

   916 		 @SYMTestExpectedResults	Bitmap content match

   917 		*/

   918 		((CTWsGraphsStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0380"));

   919 		iRedir->RedirectUsingWsBackBuffer(EFalse);

   920 		return EWait;

   921 		}

   922 

   923 	CreateWindowL();

   924 	CreateAlphaWindowL();

   925 	TheClient->iScreen->CopyScreenToBitmap(iAfter);

   926 	TSize sz = iBefore->SizeInPixels();

   927 	TInt bytes = sz.iWidth*sz.iHeight*2; // EColor64K

   928 	iAfter->LockHeap();

   929 	TEST(Mem::Compare((const TUint8*)iAfter->DataAddress(),bytes,(const TUint8*)iBefore->DataAddress(),bytes)==0);

   930 	iAfter->UnlockHeap();

   931 	DestroyAlphaWindowL();

   932 	DestroyWindowL();

   933 /**

   934 	@SYMTestCaseID	GRAPHICS-WSERV-0527

   935 */

   936 	((CTWsGraphsStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0527"));

   937 	++(iTest->iState);

   938 	iSubState = 0;

   939 	return ENext;

   940 	}

   941 

   942 #endif // TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

   943 

   944 //A call to do coverage through a plugin. 

   945 //This can serve as a basis for future coverage to objects exposed by the

   946 //plugin. For now a single simple test is implmeneted.

   947 TestState CTWsGraphs::TestGraphicDrawerCoverage()

   948 	{

   949 	__ASSERT_ALWAYS(iGdCoverage->RunTest(1)==KErrNone||KErrNotReady, User::Invariant());

   950 	return ENext;

   951 	}

   952 

   953 //Simplified non-functional class to create a few dummy CWsGraphicDrawer instances.

   954 //This code is intended to test the Array class, not the Drawer.

   955 //Note that this object is not at all functional! The only guaranteed method is Id().

   956 //WsGraphicDrawer is declared as a friend and is actually intended to be the factory class for CWsGraphicDrawer

   957 class WsGraphicDrawer:public CWsGraphicDrawer

   958 	{

   959 public:

   960 	WsGraphicDrawer()

   961 		{

   962 		}

   963 	//stub for virtual construction. Most members are ignored

   964 	virtual void ConstructL(MWsGraphicDrawerEnvironment& ,const TGraphicDrawerId& id,MWsClient& ,const TDesC8& )

   965 		{

   966 		ConstructL(id);

   967 		}

   968 	//simplified custom construction

   969 	void ConstructL(const TGraphicDrawerId& id)

   970 		{

   971 		MWsGraphicDrawerEnvironment* nullEnv=NULL;

   972 		MWsGraphicDrawerEnvironment& aEnv=*nullEnv;

   973 		MWsClient* nullClient=NULL;

   974 		MWsClient& aOwner=*nullClient;

   975 		this->BaseConstructL(aEnv,id,aOwner);

   976 		this->iDtor_ID_Key=TUid::Null();

   977 		

   978 		}

   979 	//stubs for pure virtual methods

   980 	virtual void HandleMessage(const TDesC8& )

   981 		{}

   982 	virtual void DoDraw(MWsGc& ,const TRect& ,const TDesC8& ) const

   983 		{}

   984 	

   985 	};

   986 //Class to allow me to pre-allocate the CWsGraphicDrawerArray so it doesn't pop up a false-positive memory allocation!

   987 class DummyCleanup:public TCleanupItem

   988 	{

   989 public:

   990 	static void CleanUp(TAny*)		{}

   991 	DummyCleanup(): TCleanupItem(CleanUp,this)	{}

   992 	operator DummyCleanup*()	{	return this;	}

   993 	

   994 	};

   995 

   996 //Helper function to explain test fails. Most other tests are against KErrNone

   997 void CTWsGraphs::ReportNegativeResultfail(TInt aLine,TInt aResult,TInt aExpectedResult)

   998 	{

   999 	testBooleanTrue((aResult==aExpectedResult), (TText8*)__FILE__, aLine);

  1000 	if (aResult!=aExpectedResult)

  1001 		{

  1002 		INFO_PRINTF3(_L("Expected return code %i, got %i"),aExpectedResult,aResult);	

  1003 		}

  1004 	

  1005 	}

  1006 	

  1007 //This is an attempt to use wserv test's pre-existing Panic handler to perform some negative tests.

  1008 //At present this handler appears to be broken:

  1009 // 1) It doesn't write to the correct html log file

  1010 // 2) It no longer writes to the WSERV.LOG file it was writing to a few versions ago

  1011 // 3) It doesn't close the panic window so subsequent tests that check the display output fail.

  1012 //That was a waste of effort.

  1013 struct CTWsGraphs::WrapTestCall

  1014 	{

  1015 	CTWsGraphs* thisThis;

  1016 	TUint		testCount;

  1017 	TBool		continueTests;

  1018 	TUint 		testFailedLine;

  1019 	//This field was intended to allow threaded panicing tests to report other errors

  1020 	//As I can't get threaded panicing tests to operate correctly, I have not implemented support for the field.

  1021 	//TBuf<1024>	errorMessages;	

  1022 		

  1023 	WrapTestCall (	CTWsGraphs* thisThis,	TUint		testCount):

  1024 		thisThis(thisThis),	testCount(testCount)

  1025 		{	continueTests=false;testFailedLine=0;	}

  1026 	};

  1027 	

  1028 TInt	CTWsGraphs::DoNegTestCall(TInt /*aInt*/, TAny *aPtr)

  1029 	{

  1030 	CTWsGraphs::WrapTestCall* aWrap=static_cast<CTWsGraphs::WrapTestCall*>(aPtr);

  1031 	aWrap->continueTests=aWrap->thisThis->NegTestAddSwapGDArrayL(aWrap->testCount,aWrap);	

  1032 	return 0;

  1033 	}

  1034 	

  1035 TBool	CTWsGraphs::LaunchNegTestCall(TUint		aTestCount,TUint PanicCode,const TDesC &aPanicCategory)

  1036 	{

  1037 	WrapTestCall wt(this,aTestCount);

  1038 	(void)PanicCode;

  1039 	(void)aPanicCategory;

  1040 //I have disabled the panicing tests because they don't output diagnostics 

  1041 //and the open panic window causes subsequent screen bitmap comparrisson tests to fail.

  1042 //	iTest->TestPanicL(DoNegTestCall,aPanicCode,3,&wt,aPanicCategory);

  1043 	return wt.continueTests;	

  1044 	}

  1045 

  1046 /**

  1047 	Loops through all the positive and negative tests associated with the  GraphicDrawerArray.

  1048 	The aim is to perform isolated testing of these classes as some are not currently being used.

  1049 	

  1050 **/

  1051 void CTWsGraphs::TestAddSwapGDArrayL()

  1052 	{

  1053 

  1054 

  1055 	INFO_PRINTF1(_L("Positive tests for GraphicDrawerArray"));

  1056 	for (TInt i=0;PosTestAddSwapGDArrayL(i);i++)

  1057 		{}

  1058 

  1059 

  1060 

  1061 	INFO_PRINTF1(_L("Verifying that negative tests for GraphicDrawerArray don't actually panic"));

  1062 	for (TInt i=1;NegTestAddSwapGDArrayL(i);i++)

  1063 		{}

  1064 	}

  1065 /**

  1066 	Resets and deallocates the GDA withoud deleting the objects.

  1067 	@param 	 testArray	the array to reset

  1068 	@return true if the array was already empty.

  1069 **/

  1070 static bool	ResetArray(CWsGraphicDrawerArray& testArray)

  1071 {

  1072 	bool rv=(testArray.IsEmpty());

  1073 	MWsClient* nullClient=NULL;

  1074 	testArray.RemoveAll(*nullClient);

  1075 	testArray.ResetAndDestroy();		

  1076 	return rv;

  1077 }

  1078 /**

  1079    @SYMTestCaseID GRAPHICS-WSERV-AddSwapGDArray-0001

  1080    @SYMDEF			DEF093926  

  1081   

  1082    @SYMTestCaseDesc DEF093926: Check for stability of Add and Swap unwind methods in isolation.

  1083    		Note that this code is testing the functionality of a class internal to CWindowServer.

  1084    		At present CWindowServer presents just a simple shim on this class, 

  1085    		but if that implementation of  CWindowServer changes than this test will be redudant.

  1086    

  1087    @SYMTestPriority High

  1088    

  1089    @SYMTestStatus Implemented

  1090    

  1091    @SYMTestActions

  1092 	The sequence for each of these positive test sections is pretty much the same:

  1093 	Add one record with id 1234(test for errors)

  1094 	Add one record with id Badf00d

  1095 	Swap with another record with id Badf00d

  1096 	Remove 2 records

  1097 	result=no leaks

  1098 	

  1099 		Add/Swap: no Cleanup item - no leaks after Remove the added items

  1100    	    AddTLC/SwapTLC: Cleanup item requires Commit - check for no leaks after Remove.

  1101    	    AddTLC/SwapTLC: Cleanup item gets executed by forced Leave  - check for no leaks after.

  1102 		AddTLC, SwapTLC in allocation failure scenarios. Add/Swap don't allocate anything!

  1103 		obsoleted AddLC/SwapLC to ensure correct function when forced Leave - check for no leaks after

  1104 		obsoleted AddLC/SwapLC to ensure correct function. These will always leak in good case.

  1105    @SYMTestExpectedResults 

  1106    		no exceptions or panics within this fn. 

  1107    		only the old AddLC and SwapLC should leak as indicated.

  1108  */

  1109 TBool CTWsGraphs::PosTestAddSwapGDArrayL(TInt testcase)

  1110 	{

  1111 	((CTWsGraphsStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-AddSwapGDArray-0001"));

  1112     CWsGraphicDrawerArray testArray;

  1113     //Represents the memory cached in the array once it has been used even when it is then resized to zero

  1114 #if defined(_DEBUG)

  1115     const TInt KArrayMemUseBaseline=1;

  1116 #endif

  1117     //Use testArray.IsEmpty() to prove the array is clear when it should be!

  1118     TGraphicDrawerId id1234=  	{  	1234,		EFalse    	};

  1119     TGraphicDrawerId idBADF00D=	{  	0xBADF00D,	EFalse    	};

  1120     WsGraphicDrawer dg1234;		

  1121     dg1234.ConstructL(id1234);

  1122     WsGraphicDrawer dgBADF00D;	

  1123     dgBADF00D.ConstructL(idBADF00D);

  1124     WsGraphicDrawer dgBADF00D_2;

  1125     dgBADF00D_2.ConstructL(idBADF00D);

  1126     CWsGraphicDrawerArray::XRollBackBase* rollBack1;

  1127  	TInt errCode=KErrAbort;

  1128 	TInt leaveCode=KErrNone;

  1129 	DummyCleanup markerCleanup;

  1130 	CleanupStack::PushL(markerCleanup);	 //This allows me to check the stack is clear!

  1131 	//expected result of this fn: no exceptions or panics. 

  1132 	//Put as much as you like in here, so long as it shouldn't fail.

  1133 	

  1134 	__UHEAP_MARK;