// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// This test step contains a series of tests cases to validate the correct behaviour of PREQ1246 implementation.

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

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

// (generically named CWsGraphicDrawerTest).

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

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

// objects.

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "TWSGRAPHS.H"

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

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

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA

#include "wsbufferdrawer.h"

#endif

_LIT(KTestExe, "TWSGRAPHICTEST.exe");

_LIT(KSpace, " ");

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

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

#endif

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

	{

	CCrWin* win = new(ELeave) CCrWin;

	CleanupStack::PushL(win);

	win->ConstructL(aScreenId, aDraw);

	CleanupStack::Pop(win);

	return win;

	}

CCrWin::~CCrWin()

	{

	iWin.Close();

	iGroup.Close();

	delete iGc;

	delete iScr;

	iWs.Close();

	}

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

	{

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

	iScr = new(ELeave) CWsScreenDevice(iWs);

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

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

	iGroup = RWindowGroup(iWs);

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

	iGroup.SetOrdinalPosition(0,100);

	iWin = RWindow(iWs);

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

	iWin.SetRequiredDisplayMode(EColor64K);

	iWin.Activate();

	iWs.Flush();

	if (aDraw)

	Draw();

	}

void CCrWin::Draw()

	{

	iWin.BeginRedraw();

	iGc->Activate(iWin);

	iGc->SetBrushColor(KRgbRed);

	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	TRect rect(iScr->SizeInPixels());

	iGc->DrawRect(rect);

	iGc->SetBrushColor(KRgbBlue);

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

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

	iGc->Deactivate();

	iWin.EndRedraw();

	iWs.Flush();

	}

void CCrWin::DrawFirstHalf()

	{

	iWin.BeginRedraw();

	iGc->Activate(iWin);

	iGc->SetBrushColor(KRgbRed);

	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

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

	iGc->DrawRect(rect);

	iWs.Flush();	

	}

void CCrWin::DrawSecondHalf()

	{

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

	iGc->DrawRect(rect);

	iGc->Deactivate();

	iWin.EndRedraw();	

	iWs.Flush();		

	}

/** 

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

with respective frame rate in the given time interval.

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

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

@param TInt Wsgrphic test plug-in id.

*/

void CCrWin::DrawGraphic(TInt aWsId)

	{

	// draw the animation in two positions

	const TSize screenSize = iScr->SizeInPixels();	

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

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

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

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

	iWin.BeginRedraw();

	iGc->Activate(iWin);

	const TUint8 animid1=0;

	const TUint8 fps1=20;

	TBuf8<2> animData1;

	animData1.Append(animid1);   //animId1

	animData1.Append(fps1); //20fps

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

	iWs.Flush();

	User::After(200000);

	const TUint8 animid2=1;

	const TUint8 fps2=60;

	TBuf8<2> animData2;

	animData2.Append(animid2);   //animId2

	animData2.Append(fps2); //60fps

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

	iWs.Flush();

	User::After(200000);

	iGc->Deactivate();

	iWin.EndRedraw();

	iWs.Flush();

	}

/**

 * Set a standard text cursor on this window.

 * @see RWindowGroup::SetTextCursor()

 */

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

	{

	iGroup.SetTextCursor(iWin, aPos, aCursor);

	}

/**

 * Cancel a text cursor from this window.

 * @see RWindowGroup::CancelTextCursor()

 */

void CCrWin::CancelTextCursor()

	{

	iGroup.CancelTextCursor();

	}

CCrAlphaWin* CCrAlphaWin::NewL(TInt aScreenId)

	{

	CCrAlphaWin* win = new(ELeave) CCrAlphaWin;

	CleanupStack::PushL(win);

	win->ConstructL(aScreenId);

	CleanupStack::Pop(win);

	return win;

	}

CCrAlphaWin::~CCrAlphaWin()

	{

	iWin.Close();

	iGroup.Close();

	delete iScr;

	iWs.Close();

	}

void CCrAlphaWin::ConstructL(TInt aScreenId)

	{

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

	iScr = new(ELeave) CWsScreenDevice(iWs);

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

	iGroup = RWindowGroup(iWs);

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

	iGroup.SetOrdinalPosition(0,100);

	iWin = RWindow(iWs);

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

	iWin.SetRequiredDisplayMode(EColor64K);

	iWin.SetTransparencyAlphaChannel();

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

	iWin.Activate();

	iWs.Flush();

	}

//

//  CTWsGraphs

//

CTWsGraphs::CTWsGraphs(CTestStep* aStep):

	CTWsGraphicsBase(aStep)

	{

	}

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

LOCAL_D void DeleteSpriteMember(TAny* aSpriteMember)

	{

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

	delete member->iBitmap;

	member->iBitmap=NULL;

	delete member->iMaskBitmap;

	member->iMaskBitmap=NULL;

	}

#endif

CTWsGraphs::~CTWsGraphs()

	{

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

	DeleteSpriteMember(&iSpriteMemberArray[0]);

	iSpriteMemberArray.Close();

#endif

	delete iGdCoverage;

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

	delete iAfter;

	delete iBefore;

	delete iBackCopy;

	delete iFrontCopy;

#endif

	delete iListen;

	delete iNotify2;

	delete iNotify1;

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

	delete iRedir;

#endif

	}

void CTWsGraphs::ConstructL()

	{

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

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

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

#endif

	iNotify1 = CWsNotify::NewL(EFalse);

	iNotify2 = CWsNotify::NewL(ETrue);

	iListen = CWsListen::NewL(ETrue);

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

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

	iFrontCopy = new(ELeave) CFbsBitmap;

	iBackCopy = new(ELeave) CFbsBitmap;

	iBefore = new(ELeave) CFbsBitmap;

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

	iAfter = new(ELeave) CFbsBitmap;

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

#endif

	iGdCoverage = CWsGdCoverage::NewL();

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

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

	TSpriteMember spriteMember;

	spriteMember.iBitmap = NULL;

	spriteMember.iMaskBitmap = NULL;

	spriteMember.iInvertMask =EFalse;

	spriteMember.iDrawMode = CGraphicsContext::EDrawModePEN;

	spriteMember.iOffset = TPoint();

	spriteMember.iInterval = TTimeIntervalMicroSeconds32(0);

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

	spriteMember.iBitmap = new (ELeave) CFbsBitmap;

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

	spriteMember.iMaskBitmap = new (ELeave) CFbsBitmap;

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

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

	CleanupStack::Pop(&spriteMember);

#endif

	}

void CTWsGraphs::LaunchNewProcess(const TDesC& aExecutable)

	{

	TBuf<128> args;

 	args.Append(KSpace);

	args.AppendNum(iTest->iScreenNumber);

	RProcess pr;

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

	if (err == KErrNone)

		{

		TRequestStatus status;

		pr.Logon(status);

		pr.Resume();

		User::WaitForRequest(status);

		err = pr.ExitReason();

		pr.Close();

		if (err != KErrNone)

			{

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

			LOG_MESSAGE3(KLog, &aExecutable, err);

			}

		}

	else

		{

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

		LOG_MESSAGE3(KLog, &aExecutable, err);

		}

	TEST(err == KErrNone);

	// Restore main test group to foreground.

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

	}

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

	{

	return (TInt)EWait;

	}

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

/**

 @SYMTestCaseID				GRAPHICS-WSERV-0371

 @SYMREQ					GT247-CR0714

 @SYMTestCaseDesc			Test interface extension

 @SYMTestPriority			High

 @SYMTestStatus				Implemented

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

							Actions step:

							-Create plugin

							-Query interfaces obtained from plugin side

 @SYMTestExpectedResults	Supported interfaces should return non null

*/

TestState CTWsGraphs::TestInterfaceExtensionL()

	{

	if (iSubState==0)

		{

		_LIT(KTestInterfaceExtension, "TestInterfaceExtension");

		INFO_PRINTF1(KTestInterfaceExtension);

		++iSubState;

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

		iRedir->QueryPlugin(iRedirInfo);

		return EWait;

		}

	TEST(iRedirInfo.iScreenConfigInterface!=NULL);

	TEST(iRedirInfo.iFrontBufferInterface!=NULL);

	TEST(iRedirInfo.iScreenBitmapHandle!=0);

	iFrontCopy->Duplicate(iRedirInfo.iScreenBitmapHandle);

	if (TransparencySupportedL()!=KErrNotSupported)

		{

		TEST(iRedirInfo.iBackBufferInterface!=NULL);

		TEST(iRedirInfo.iFlickerBitmapHandle!=0);

		iBackCopy->Duplicate(iRedirInfo.iFlickerBitmapHandle);

		}

	++(iTest->iState);

	iSubState = 0;

	return ENext;

	}

#endif // TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

void CTWsGraphs::CreateWindowL(TBool aDraw)

	{

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

	}

void CTWsGraphs::DestroyWindowL()

	{

	delete iWin;

	iWin = NULL;

	}

void CTWsGraphs::CreateAlphaWindowL()

	{

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

	}

void CTWsGraphs::DestroyAlphaWindowL()

	{

	delete iAlpha;

	iAlpha = NULL;

	}

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

	{

	const TDisplayMode dispmode = aBmp1->DisplayMode();

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

		return EFalse;

	const TInt stride1 = aBmp1->DataStride();

	const TInt stride2 = aBmp2->DataStride();

	const TInt linebytes = aSize.iWidth * 2;

	const TInt pixelbytes = 2;

	aBmp1->LockHeap();

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

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

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

		{

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

			{

			aBmp1->UnlockHeap();

			return EFalse;

			}

		}

	aBmp1->UnlockHeap();

	return ETrue;

	}

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

TestState CTWsGraphs::TestScreenRedirectionL()

	{

	if (iSubState==0)

		{

		_LIT(KTestScreenRedirection, "TestScreenRedirection");

		INFO_PRINTF1(KTestScreenRedirection);

		++iSubState;

		/**

		 @SYMTestCaseID				GRAPHICS-WSERV-0372

		 @SYMREQ					GT247-CR0714

		 @SYMTestCaseDesc			Redirect wserv screen drawing to custom graphics context

		 @SYMTestPriority			High

		 @SYMTestStatus				Implemented

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

									Actions step:

									-Draw opaque window.

									-Save screen content to a bitmap

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

									-Draw the same window again

									-Retrieve plugin bitmap and compare against  the saved bitmap

		 @SYMTestExpectedResults	Bitmap content match

		*/

		CreateWindowL();		

		TheClient->iScreen->CopyScreenToBitmap(iBefore);

		DestroyWindowL();

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

		return EWait;

		}

	if (iSubState==1)

		{

		++iSubState;

		CreateWindowL();

		TSize sz = iBefore->SizeInPixels();

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

		iBefore->LockHeap();

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

		iBefore->UnlockHeap();

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

		iRedir->QueryPlugin(iRedirInfo);

		return EWait;

		}

	if (iSubState==2)

		{

		++iSubState;

		/**

		 @SYMTestCaseID				GRAPHICS-WSERV-0047

		 @SYMTestCaseDesc			Screen update event

		 @SYMTestPriority			Medium

		 @SYMTestStatus				Implemented

		 @SYMTestActions			Check plugin receive screen update event during redirection

		 @SYMTestExpectedResults	Counter is non-zero

		*/

		TEST(iRedirInfo.iUpdateCounter>0);

		DestroyWindowL();

		/**

		 @SYMTestCaseID				GRAPHICS-WSERV-0373

		 @SYMREQ					GT247-CR0714

		 @SYMTestCaseDesc			Stop wserv screen drawing redirection

		 @SYMTestPriority			High

		 @SYMTestStatus				Implemented

		 @SYMTestActions			Stop wserv screen drawing redirection.

									Actions step:

									-Instruct plugin to stop wserv screen drawing redirection

									-Draw the same window again

									-Save screen content to another bitmap

									-Compare the saved bitmap against newly saved bitmap

		 @SYMTestExpectedResults	Bitmap content match

		*/

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

		return EWait;

		}

	if (iSubState==3)

		{

		++iSubState;

		CreateWindowL();

		TheClient->iScreen->CopyScreenToBitmap(iAfter);

		TSize sz = iBefore->SizeInPixels();	

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

		iAfter->LockHeap();

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

		iAfter->UnlockHeap();

		DestroyWindowL();

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

		iRedir->QueryPlugin(iRedirInfo);

		return EWait;

		}

	/**

	 @SYMTestCaseID				GRAPHICS-WSERV-0374

	 @SYMTestCaseDesc			Screen update event

	 @SYMTestPriority			Medium

	 @SYMTestStatus				Implemented

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

	 @SYMTestExpectedResults	Counter is zero

	*/

	TEST(iRedirInfo.iUpdateCounter==0);

	++(iTest->iState);

	iSubState = 0;

	return ENext;

	}

TestState CTWsGraphs::TestTextCursorUnderRedirectionL(TTestCursorType aCursorType)

	{

	/**

	 @SYMTestCaseID				GRAPHICS-WSERV-0363

	 @SYMTestCaseDesc			Text Cursor when drawing redirected

	 @SYMTestPriority			Medium

	 @SYMTestStatus				Implemented

	 @SYMTestActions			Action steps:

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

	 							- Re-direct the Front Buffer

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

	 							- Pause 0.5 seconds because this amount of time is needed

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

	 							- Stop re-directing

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

	 							  the phase of the text cursor flashing, whether we get

	 							  non-text cursor drawing artefacts in the old location

	 							  where the text cursor used to be

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

	 */

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

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

	const TInt KCursorFlashPeriod = 1000000;

	const TInt KWaitForNextFlashPhase = KCursorFlashPeriod / 2;

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

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

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

	const TPoint originalCursorPos(45, 40);

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

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

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

	const TPoint cleanReferencePos(45, 40 + 80);

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

	if (iSubState == 0)

		{

		++iSubState;			

		CreateWindowL(ETrue);

		if (aCursorType == ETestStandardTextCursor)

			{

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

			INFO_PRINTF1(KTestTextCursorUnderRedirection);	

			iTextCursor.iType=TTextCursor::ETypeRectangle;

			iTextCursor.iHeight=cursorSize.iHeight;

			iTextCursor.iAscent=0;

			iTextCursor.iWidth=cursorSize.iWidth;

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

			iTextCursor.iColor=KRgbGreen;

			iWin->SetTextCursor(originalCursorPos, iTextCursor);

			}

		else if (aCursorType == ETestCustomTextCursor)

			{

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

			INFO_PRINTF1(KTestTextCursorUnderRedirection);	

			TInt err = TheClient->iWs.SetCustomTextCursor(

					KCustomTextCursorId,

					iSpriteMemberArray.Array(),

					ESpriteFlash,

					RWsSession::ECustomTextCursorAlignTop

					);

			iTextCursor.iType=KCustomTextCursorId;

			iTextCursor.iHeight=cursorSize.iHeight;

			iTextCursor.iAscent=0;

			iTextCursor.iWidth=cursorSize.iWidth;

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

			iTextCursor.iColor=KRgbCyan;

			iWin->SetTextCursor(originalCursorPos, iTextCursor);

			}

		else

			{

			// unknown type of test being requested

			ASSERT(0);

			}

		iWin->DrawFirstHalf();	

		return EWait;

		}

	/*

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

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

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

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

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

	 * This is key to testing for faulty behaviour.

	 */

	if (iSubState==1)

		{

		++iSubState;

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

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

		iWin->SetTextCursor(newCursorPos, iTextCursor);

		User::After(KWaitForNextFlashPhase);

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

		return EWait;

		}

	/*

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

	 */

	if (iSubState==2)

		{

		++iSubState;

		iWin->DrawSecondHalf();

		return EWait;

		}

	/*

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

	 * of the test.

	 */

	if (iSubState==3)

		{

		++iSubState;

		User::After(KCursorFlashPeriod * 3);

		return EWait;

		}

	/*

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

	 */

	if (iSubState==4)

		{

		++iSubState;

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

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

		 * in screen artefacts.

		 */

		TEST(TheClient->iScreen->RectCompare(

				TRect(originalCursorPos, cursorSize),

				TRect(cleanReferencePos, cursorSize),

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

		return EWait;

		}

	/* Clean up */

	if (iSubState==5)

		{

		++iSubState;

		iWin->CancelTextCursor();

		DestroyWindowL();

		}

	iSubState = 0;

	return ENext;

	}

/**

 @SYMTestCaseID				GRAPHICS-WSERV-0375

 @SYMREQ					GT247-CR0714

 @SYMTestCaseDesc			Redirect wserv flickerfree drawing to custom graphics context

 @SYMTestPriority			Medium

 @SYMTestStatus				Implemented

 @SYMTestActions			Redirect wserv flickerfree buffer drawing.

							Action step:

							-Draw opaque window (as background) and transparent window

							-Save screen content to a bitmap

							-Instruct plugin to redirect wserv flickerfree buffer drawing

							-Draw the same opaque window and transparent window again

							-Retrieve plugin bitmap and compare against the saved bitmap

 @SYMTestExpectedResults	Bitmap content match

*/

/**

 @SYMTestCaseID				GRAPHICS-WSERV-0376

 @SYMREQ					GT247-CR0714

 @SYMTestCaseDesc			Stop wserv flickerfree drawing redirection

 @SYMTestPriority			Medium

 @SYMTestStatus				Implemented

 @SYMTestActions			Stop wserv flickerfree buffer drawing redirection.

							Action step:

							-Instruct plugin to stop wserv filckerfree drawing redirection

							-Draw the same opaque and transparent window

							-Save screen content to another bitmap

							-Compare saved bitmap against newly saved bitmap

 @SYMTestExpectedResults	Bitmap content match

*/

TestState CTWsGraphs::TestFlickerRedirectionL()

	{

	if (TransparencySupportedL()==KErrNotSupported)

		{

		++(iTest->iState);

		return ENext;

		}

	// flush transparent window destruction created in TransparencySupportedL before

	// proceeding with the test

	TheClient->iWs.Flush();

	if (iSubState==0)

		{

		_LIT(KTestFlickerRedirection, "TestFlickerRedirection");

		INFO_PRINTF1(KTestFlickerRedirection);

		++iSubState;

		CreateWindowL();

		CreateAlphaWindowL();

		TheClient->iScreen->CopyScreenToBitmap(iBefore);

		DestroyAlphaWindowL();

		DestroyWindowL();

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

		return EWait;

		}

	if (iSubState==1)

		{

		++iSubState;

		CreateWindowL();

		CreateAlphaWindowL();

		TSize sz = iBefore->SizeInPixels();

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

		iBefore->LockHeap();

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

		TEST(ret==0);

		if (ret!=0)

			{

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

			LOG_MESSAGE(KLog);

			}

		iBefore->UnlockHeap();

		DestroyAlphaWindowL();

		DestroyWindowL();

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

		return EWait;

		}

	CreateWindowL();

	CreateAlphaWindowL();

	TheClient->iScreen->CopyScreenToBitmap(iAfter);

	TSize sz = iBefore->SizeInPixels();

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

	iAfter->LockHeap();

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

	iAfter->UnlockHeap();

	DestroyAlphaWindowL();

	DestroyWindowL();

	++(iTest->iState);

	iSubState = 0;

	return ENext;

	}

#endif // TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

/**

 @SYMTestCaseID				GRAPHICS-WSERV-0377

 @SYMREQ					GT247-CR0714

 @SYMTestCaseDesc			Enable event notification

 @SYMTestPriority			Medium

 @SYMTestStatus				Implemented

 @SYMTestActions			Enable plugin to register to event notification.

							Action step:

							-Instruct plugin to register event handler

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

							-Query visibility region from plugin side

							-Compare window visible region against value obtained by plugin

 @SYMTestExpectedResults	Visible region match

*/

/**

 @SYMTestCaseID				GRAPHICS-WSERV-0378

 @SYMREQ					GT247-CR0714

 @SYMTestCaseDesc			Disable event notification

 @SYMTestPriority			Medium

 @SYMTestStatus				Implemented

 @SYMTestActions			Disable plugin to register to event notification.

							Action step:

							-Instruct plugin to unregister event handler

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

							-Query visibility region from plugin side

 @SYMTestExpectedResults	Plugin does not receive events notification

*/

TestState CTWsGraphs::TestEventNotificationL()

	{

	if (iSubState==0)

		{

		_LIT(KTestEventNotification, "TestEventNotification");

		INFO_PRINTF1(KTestEventNotification);

		++iSubState;

		iListen->Enable(ETrue);

		CreateWindowL();

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

		TheClient->iWs.Finish();

		TheClient->WaitForRedrawsToFinish();

		iListen->QueryPlugin(iListenInfo);

		return EWait;

		}

	if (iSubState==1)

		{

		++iSubState;

		iListen->Enable(EFalse);

		TEST(iListenInfo.iNumRect==1);

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

		DestroyWindowL();

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

		iListen->QueryPlugin(iListenInfo);

		iListen->Enable(EFalse);

		DestroyWindowL();

		return EWait;

		}

	TEST(iListenInfo.iNumRect==0);

	++(iTest->iState);

	iSubState = 0;

	return ENext;

	}

#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

TestState CTWsGraphs::TestRedirectionUsingWsBackBufferL()

	{

	if (TransparencySupportedL()==KErrNotSupported)

		{

		++(iTest->iState);

		return ENext;

		}

	// flush transparent window destruction created in TransparencySupportedL before

	// proceeding with the test

	TheClient->iWs.Flush();

	if (iSubState==0)

		{

		_LIT(KTestRedirectionWsBack, "TestRedirectionUsingWsBackBuffer");

		INFO_PRINTF1(KTestRedirectionWsBack);

		++iSubState;

		/**

		 @SYMTestCaseID				GRAPHICS-WSERV-0379

		 @SYMTestCaseDesc			Redirect wserv flickerfree to MWsBackBuffer object

		 @SYMTestPriority			Medium

		 @SYMTestStatus				Implemented

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

									-Save screen content to a bitmap

									-Instruct plugin to redirect flickerfree buffer to MWsBackBuffer object

									-Draw the same opaque window and transparent window again

									-Retrieve plugin bitmap and compare against the saved bitmap

		 @SYMTestExpectedResults	Bitmap content match

		*/

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

		CreateWindowL();

		CreateAlphaWindowL();

		TheClient->iScreen->CopyScreenToBitmap(iBefore);

		DestroyAlphaWindowL();		

		DestroyWindowL();		

		iRedir->RedirectUsingWsBackBuffer(ETrue);

		return EWait;

		}

	if (iSubState==1)

		{

		++iSubState;

		CreateWindowL();

		CreateAlphaWindowL();

		TSize sz = iBefore->SizeInPixels();

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

		iBefore->LockHeap();

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

		TEST(ret==0);

		if (ret!=0)

			{

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

			LOG_MESSAGE(KLog);

			}

		iBefore->UnlockHeap();

		DestroyAlphaWindowL();

		DestroyWindowL();

		/**

		 @SYMTestCaseID				GRAPHICS-WSERV-0380

		 @SYMTestCaseDesc			Restore wserv flickerfree redirection from MWsBackBuffer object

		 @SYMTestPriority			Medium

		 @SYMTestStatus				Implemented

		 @SYMTestActions			-Instruct plugin to stop wserv filckerfree drawing redirection

									-Draw the same opaque and transparent window

									-Save screen content to another bitmap

									-Compare saved bitmap against newly saved bitmap

		 @SYMTestExpectedResults	Bitmap content match

		*/

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

		iRedir->RedirectUsingWsBackBuffer(EFalse);

		return EWait;

		}

	CreateWindowL();

	CreateAlphaWindowL();

	TheClient->iScreen->CopyScreenToBitmap(iAfter);

	TSize sz = iBefore->SizeInPixels();

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

	iAfter->LockHeap();

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

	iAfter->UnlockHeap();

	DestroyAlphaWindowL();

	DestroyWindowL();

/**

	@SYMTestCaseID	GRAPHICS-WSERV-0527

*/

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

	++(iTest->iState);

	iSubState = 0;

	return ENext;

	}

#endif // TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA

//A call to do coverage through a plugin. 

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

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

TestState CTWsGraphs::TestGraphicDrawerCoverage()

	{

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

	return ENext;

	}

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

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

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

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

class WsGraphicDrawer:public CWsGraphicDrawer

	{

public:

	WsGraphicDrawer()

		{

		}

	//stub for virtual construction. Most members are ignored

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

		{

		ConstructL(id);

		}

	//simplified custom construction

	void ConstructL(const TGraphicDrawerId& id)

		{

		MWsGraphicDrawerEnvironment* nullEnv=NULL;

		MWsGraphicDrawerEnvironment& aEnv=*nullEnv;

		MWsClient* nullClient=NULL;

		MWsClient& aOwner=*nullClient;

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

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

		}

	//stubs for pure virtual methods

	virtual void HandleMessage(const TDesC8& )

		{}

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

		{}

	};

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

class DummyCleanup:public TCleanupItem

	{

public:

	static void CleanUp(TAny*)		{}

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

	operator DummyCleanup*()	{	return this;	}

	};