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

// Test the text cursor.

//

// This suite of tests checks to see if the TextCursors are operating

// correctly for a number of use case scenarios; see doxygen comments

// for each sub-test.  This test suite is applicable on both winscw

// emulator and armv5 target hardware.  However, it must be noted that

// text cursors are special due to their timeliness.  The text cursor

// must flash every second: half a second ON, half a second OFF.  One

// consequence of this is that when the test suite is run on emulator,

// the PC must be otherwise quiescent.  No other IO or CPU intensive

// activities may occur on the system, because these will cause delays

// to the flashing of the text cursor giving unreliable results.

// Where timeliness is a consideration, we use TEST_SOFTFAIL_WINSCW so

// that if the test fails and we are running on the PC emulator, we only

// record the fact, but don't mark the test as failing.

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "TTEXTCURS.H"

#include "graphics/windowserverconstants.h"

const TInt KNumberOfCustoTextCursors	= 3;

const TInt KTextCursorInitialIdValue	= 1001;

const TInt KTextCursorPanicUid1			= 200;

const TInt KTextCursorPanicUid2			= 2000;

const TInt KTextCursorPanicUid3			= 3000;

const TInt KTextCursorPanicUid4			= 4000;

const TInt KTextCursorPanicUid5			= 5000;

CTestBase* CTCursorTest::iStaticTest = NULL;

const TInt kWinWidth=400;

const TInt kWinHeight=100;

const TSize kWinSize(kWinWidth,kWinHeight);

const TInt kWinXPos=150;

const TInt kCursorWidth = 10;

const TInt kCursorHeight = 20;

const TSize kCursorSize(kCursorWidth,kCursorHeight);

const TPoint kWin1TopLeft(kWinXPos,0);

const TPoint kWin2TopLeft(kWinXPos,kWinHeight+10);

LOCAL_D void DeleteSpriteMember(TAny* aSpriteMember)

	{

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

	delete member->iBitmap;

	member->iBitmap=NULL;

	delete member->iMaskBitmap;

	member->iMaskBitmap=NULL;

	}

CCustomTextCursor::~CCustomTextCursor()

	{

	const TInt count = iSpriteMemberArray.Count();

	for (TInt index=0; index<count; ++index)

		{

		DeleteSpriteMember(&iSpriteMemberArray[index]);

		}

	iSpriteMemberArray.Close();

	}

CCustomTextCursor::CCustomTextCursor(CTestBase* aTest)

	: iTest(aTest)

	{	

	}

void CCustomTextCursor::ConstructL(TInt aScreenNumber,TInt aBmpIndex)

	{

	ASSERT(aBmpIndex < KNumberOfCustoTextCursors);

	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);

	// create unique-id accross screens

	//

	iIdentifier = KTextCursorInitialIdValue + aScreenNumber*KNumberOfCustoTextCursors + aBmpIndex;

	iAlignment = (RWsSession::TCustomTextCursorAlignment)(aBmpIndex);

	}

CCustomTextCursor* CCustomTextCursor::CreateCustomTextCursorL(TInt aScreenNumber,TInt aBmpIndex,CTestBase* aTest)

	{

	CCustomTextCursor* customTextCursor = new (ELeave) CCustomTextCursor(aTest);

	CleanupStack::PushL(customTextCursor);

	customTextCursor->ConstructL(aScreenNumber,aBmpIndex);

	CleanupStack::Pop(customTextCursor);

	return customTextCursor;

	}

/*

 * Wrapper class for a list of custom text cursor.

 */

class CCustomTextCursorsWrapper : public CBase

	{

public:

	static CCustomTextCursorsWrapper* NewLC(TInt aScreenNumber,CTestBase* aTest);

	~CCustomTextCursorsWrapper();

	inline RPointerArray<CCustomTextCursor>& CustomTextCursorsArray();

	inline CCustomTextCursor& CustomTextCursor(TInt aIndex);

private:

	void ConstructL(TInt aScreenNumber,CTestBase* aTest);

private:

	RPointerArray<CCustomTextCursor> iCustomTextCursors;

	};

inline RPointerArray<CCustomTextCursor>& CCustomTextCursorsWrapper::CustomTextCursorsArray()

		{

		return iCustomTextCursors;

		}

inline CCustomTextCursor& CCustomTextCursorsWrapper::CustomTextCursor(TInt aIndex)

		{

		return *(iCustomTextCursors[aIndex]);

		}

CCustomTextCursorsWrapper* CCustomTextCursorsWrapper::NewLC(TInt aScreenNumber,CTestBase* aTest)

	{

	CCustomTextCursorsWrapper* self = new(ELeave) CCustomTextCursorsWrapper();

	CleanupStack::PushL(self);

	self->ConstructL(aScreenNumber,aTest);

	return self;

	}

CCustomTextCursorsWrapper::~CCustomTextCursorsWrapper()

	{

	iCustomTextCursors.ResetAndDestroy();

	iCustomTextCursors.Close();

	}

void CCustomTextCursorsWrapper::ConstructL(TInt aScreenNumber, CTestBase* aTest)

	{

	for (TInt index=0; index<KNumberOfCustoTextCursors; ++index)

		{

		CCustomTextCursor* customTextCursor=CCustomTextCursor::CreateCustomTextCursorL(aScreenNumber,index, aTest);

		CleanupStack::PushL(customTextCursor);

		User::LeaveIfError(iCustomTextCursors.Append(customTextCursor));

		CleanupStack::Pop(customTextCursor);

		}

	}

CTCursorTest::CTCursorTest(CTestStep* aStep) :

	CTWsGraphicsBase(aStep)

	{

	iCursorType = TTextCursor::ETypeFirst;

	iStaticTest=iTest;

	}

CTCursorTest::~CTCursorTest()

	{

	delete iWorkInProgress;

	delete iComparisonWindow;

	}

TInt CTCursorTest::DoPanicTest(TInt aInt, TAny *aScreenNumber)

	{

	RWsSession ws;

	if (ws.Connect()==KErrNone)

		{

		// use correct screen

		CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws);

		User::LeaveIfError(screen->Construct((TInt)aScreenNumber));

		RWindowGroup group(ws);

		if (group.Construct(444)==KErrNone)

			{

			group.EnableReceiptOfFocus(EFalse);	// Stop auto group switching on close

			RWindow wnd(ws);

			if (wnd.Construct(group, TInt32(&ws))==KErrNone)

				{

				TTextCursor tc;

				tc.iHeight=10;

				tc.iAscent=5;

				tc.iWidth=10;

				tc.iFlags=0;

				tc.iColor=TRgb(0,0,0);

				switch(aInt)

					{

					case 0:

						{

						/* TESTCASE:	6.1

						* TITLE:		Invalid use of a custom text cursor ID (basic text cursor).

						* IMPORTANCE:	1

						* REQUIREMENT:	Unknown.

						* 

						* ACTION:		This test tries to set a text cursor using an ID which is invalid.

						* 

						* CHECK:		The thread should panic with the exit reason EWservPanicInvalidTextCursor

						*/ 

						tc.iType=(TTextCursor::EType)KTextCursorPanicUid1;

						group.SetTextCursor(wnd,TPoint(10,10),tc);

						}

						break;

					case 1:

						{

						/* TESTCASE:	6.2

						* TITLE:		Invalid use of a window for a text cursor.

						* IMPORTANCE:	1

						* REQUIREMENT:	REQ 1079, CR RDEF-5F7Q24 (10/04/2003).

						* 

						* ACTION:		This test tries to set a text cursor using a window which is not part

						*				of the window group calling the setting API.

						* 

						* CHECK:		The thread should panic with the exit reason EWservPanicWindow

						*/ 

						tc.iType=(TTextCursor::EType)KTextCursorPanicUid2;

						group.SetTextCursor(*TestWin->Win(),TPoint(10,10),tc);

						}

						break;

					case 2:

						{

						/* TESTCASE:	6.3

						* TITLE:		Invalid use of a custom text cursor ID.

						* IMPORTANCE:	1

						* REQUIREMENT:	REQ 1079, CR RDEF-5F7Q24 (10/04/2003).

						* 

						* ACTION:		This test tries to set a text cursor using an ID which is associated to

						*				an non-existing custom text cursor.

						* 

						* CHECK:		The thread should panic with the exit reason EWservPanicNoCustomTextCursor

						*/ 

						tc.iType=(TTextCursor::EType)KTextCursorPanicUid3;

						group.SetTextCursor(wnd,TPoint(10,10),tc);

						}

						break;

					case 3:

						{

						/* TESTCASE:	6.4

						* TITLE:		Invalid use of a custom text cursor ID.

						* IMPORTANCE:	1

						* REQUIREMENT:	REQ 1079, CR RDEF-5F7Q24 (10/04/2003).

						* 

						* ACTION:		This test tries to set a custom text cursor which has been set to use

						*				an invalid alignment.

						* 

						* CHECK:		The thread should panic with the exit reason EWservPanicCustomTextCursorAlign

						*/ 

						CCustomTextCursor* customTextCursor=NULL;

						TRAPD(error, customTextCursor=CCustomTextCursor::CreateCustomTextCursorL((TInt)aScreenNumber,0,iStaticTest));

						if (error==KErrNone)

							{

							error = ws.SetCustomTextCursor(KTextCursorPanicUid4, customTextCursor->iSpriteMemberArray.Array(), 0, (RWsSession::TCustomTextCursorAlignment)(RWsSession::ECustomTextCursorAlignBottom+1));

							if (error==KErrNone || error==KErrAlreadyExists)

								{

								tc.iType=(TTextCursor::EType)KTextCursorPanicUid4;

								group.SetTextCursor(wnd,TPoint(10,10),tc);

								}

							}

						delete customTextCursor;

						}

						break;

					case 4:

						{

						/* TESTCASE:	6.5

						* TITLE:		Use of an invalid custom text cursor

						* IMPORTANCE:	1

						* REQUIREMENT:	REQ 1079, CR RDEF-5F7Q24 (10/04/2003).

						* 

						* ACTION:		This test tries to set a custom text cursor which does not have

						*				any sprite member set.

						* 

						* CHECK:		The thread should panic with the exit reason EWservPanicNoSpriteMember

						*/ 

						RArray<TSpriteMember> spriteMemberArray;

						const TInt error = ws.SetCustomTextCursor(KTextCursorPanicUid5, spriteMemberArray.Array(), 0, (RWsSession::TCustomTextCursorAlignment)(RWsSession::ECustomTextCursorAlignBottom));

						if (error==KErrNone || error==KErrAlreadyExists)

							{

							tc.iType=(TTextCursor::EType)KTextCursorPanicUid5;

							group.SetTextCursor(wnd,TPoint(10,10),tc);

							}

						}

						break;

					case 5:

						{

						// Uncover set.cursor.iType < TTextCursor::ETypeFirst code path

						tc.iType=(TTextCursor::EType)TTextCursor::ETypeFirst - 1;

						group.SetTextCursor(wnd,TPoint(10,10),tc);

						}

						break;

					case 6:

						{

						// Uncover (set.cursor.iFlags&static_cast<TUint>(TTextCursor::EPrivateFlags) code path

						tc.iFlags=ETextCursorPrivateFlags;

						group.SetTextCursor(wnd,TPoint(10,10),tc);

						}

						break;

					case 7:

						{

						// Uncover (iGroupWin != searchWin) i.e. bogus group window

						tc.iType=(TTextCursor::EType)TTextCursor::ETypeRectangle;

						RWindow windowNotAssociatedWithAGroup(ws);

						group.SetTextCursor(windowNotAssociatedWithAGroup, TPoint(10,10),tc);

						}

						break;

					}

				}

			ws.Flush();

			}

		}

	return(EWsExitReasonBad);

	}

void CTCursorTest::TestPanicsL()

	{	

		TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicInvalidTextCursor, 0, (TAny*)iTest->iScreenNumber));

		TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicWindow, 1, (TAny*)iTest->iScreenNumber));

		TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicNoCustomTextCursor, 2, (TAny*)iTest->iScreenNumber));

		TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicCustomTextCursorAlign, 3, (TAny*)iTest->iScreenNumber));

		TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicNoSpriteMember, 4, (TAny*)iTest->iScreenNumber));

		TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicInvalidTextCursor, 5, (TAny*)iTest->iScreenNumber));

		TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicInvalidTextCursor, 6, (TAny*)iTest->iScreenNumber));

		TEST(iTest->TestWsPanicL(DoPanicTest, EWservPanicWindow, 7, (TAny*)iTest->iScreenNumber));

		iTest->CloseAllPanicWindows();

	}

void CTCursorTest::TextCursorSetLCoverageTests()

	{

	ValidateWin(BaseWin,TRgb::Gray256(255));

	ValidateWin(TestWin,TRgb::Gray256(255));	

	TTextCursor textCursor;

	textCursor.iHeight = 10;

	textCursor.iAscent = 0;

	textCursor.iWidth = 10;

	textCursor.iFlags = 0;

	textCursor.iColor = KRgbBlack;

	textCursor.iType = (TTextCursor::EType)TTextCursor::ETypeRectangle;

	TPoint position(10, 10);

	TRect clipRect0(10, 10, 10, 10);

	TRect clipRect1(10, 10, 5, 5);

	RWindowGroup *group = TheClient->iGroup->GroupWin(); 

	group->SetTextCursor(*TestWin->Win(), position, textCursor);

	/*

	 * Duplicate the previous SetTextCursor command to uncover the code which checks for any delta in SetL

	 * compared to the current settings.

	 */

	group->SetTextCursor(*TestWin->Win(), position, textCursor);

	/*

	 * Change the type only to pick up that difference in SetL.

	 */

	textCursor.iType++;

	group->SetTextCursor(*TestWin->Win(), position, textCursor);

	textCursor.iType--;

	/*

	 * Vary the clipping rectangle.

	 */

	group->SetTextCursor(*TestWin->Win(), position, textCursor, clipRect0);

	group->SetTextCursor(*TestWin->Win(), position, textCursor, clipRect1);

	/*

	 * Vary the color.

	 */

	textCursor.iColor = KRgbGreen;

	group->SetTextCursor(*TestWin->Win(), position, textCursor);

	textCursor.iColor = KRgbBlack;

	group->SetTextCursor(*TestWin->Win(), position, textCursor);

	/*

	 * Vary the target Window.

	 */

	group->SetTextCursor(*BaseWin->Win(), position, textCursor);

	group->SetTextCursor(*TestWin->Win(), position, textCursor);

	/*

	 * Vary the size of the cursor.

	 */

	textCursor.iWidth++;

	group->SetTextCursor(*TestWin->Win(), position, textCursor);

	textCursor.iWidth--;

	/*

	 * Set different custom cursors.

	 */

	CCustomTextCursorsWrapper* customTextCursorsWrapper = CCustomTextCursorsWrapper::NewLC(iTest->iScreenNumber, iTest);

	const TInt count = customTextCursorsWrapper->CustomTextCursorsArray().Count();

	for (TInt index=0; index<count; ++index)

		{

		CCustomTextCursor& customTextCursor = customTextCursorsWrapper->CustomTextCursor(index);

		textCursor.iType = customTextCursor.iIdentifier;

		group->SetTextCursor(*TestWin->Win(), position, textCursor);

		}			

	CleanupStack::PopAndDestroy(customTextCursorsWrapper);

	/*

	 * Set the last custom cursor from the above loop again so the

	 * product code sees the same Custom Text Cursor settings come

	 * in a second time.

	 */

	group->SetTextCursor(*TestWin->Win(), position, textCursor);

	textCursor.iType = (TTextCursor::EType)TTextCursor::ETypeRectangle;

	/*

	 * Vary the horizontal clipping.

	 */

	textCursor.iFlags = TTextCursor::EFlagClipHorizontal;

	group->SetTextCursor(*TestWin->Win(), position, textCursor);

	/*

	 * Vary the horizontal clipping.

	 */

	textCursor.iFlags = TTextCursor::EFlagClipVertical;

	group->SetTextCursor(*TestWin->Win(), position, textCursor);

	/*

	 * Try both horizontal and vertical clipping.

	 */

	textCursor.iFlags = TTextCursor::EFlagClipVertical|TTextCursor::EFlagClipHorizontal;

	group->SetTextCursor(*TestWin->Win(), position, textCursor);

	textCursor.iFlags = 0;

	TheClient->iWs.Flush();

	CancelTextCursor();

	}

void CTCursorTest::SetCursor(const TPoint &aPos,const TSize &aSize,TRgb aColor, const TRect &aRect, TUint aFlags)

	{

	TTextCursor tc;

	tc.iType=iCursorType;

    tc.iHeight=aSize.iHeight;

    tc.iAscent=aSize.iHeight*4/5;

    tc.iWidth=aSize.iWidth;

    tc.iFlags=aFlags;

	tc.iColor=aColor;

	TheClient->iGroup->GroupWin()->SetTextCursor(*TestWin->Win(),TPoint(aPos.iX,aPos.iY+tc.iAscent),tc,aRect);

	}

void CTCursorTest::SetCursor(const TPoint &aPos,const TSize &aSize,TRgb aColor, TUint aFlags)

	{

	TTextCursor tc;

	tc.iType=iCursorType;

    tc.iHeight=aSize.iHeight;

    tc.iAscent=aSize.iHeight*4/5;

    tc.iWidth=aSize.iWidth;

    tc.iFlags=aFlags;

	tc.iColor=aColor;

	TheClient->iGroup->GroupWin()->SetTextCursor(*TestWin->Win(),TPoint(aPos.iX,aPos.iY+tc.iAscent),tc);

	}

void CTCursorTest::SetCursorPlusBox(const TPoint &aPos,const TSize &aSize,TRgb aColor, const TRect *aClipRect, TUint aFlags)

	{

	if (aClipRect)

		SetCursor(aPos,aSize,aColor,*aClipRect,aFlags);

	else

		SetCursor(aPos,aSize,aColor,aFlags);

	TRect rect(aPos,aSize);

	if (aClipRect)

		rect.Intersection(*aClipRect);

	rect.Grow(2,2);

	TheClient->iGc->Activate(*(TestWin->Win()));

	TestWin->Invalidate(rect);

	TestWin->Win()->BeginRedraw(rect);

	TheClient->iGc->SetPenColor(aColor);

	TheClient->iGc->SetDrawMode(CGraphicsContext::EDrawModeXOR);

	TheClient->iGc->DrawRect(rect);

	TheClient->iGc->Deactivate();

	TestWin->Win()->EndRedraw();

	}

void CTCursorTest::CancelTextCursor()

	{

	TheClient->iGroup->GroupWin()->CancelTextCursor();

	}

void CTCursorTest::ConstructL()

	{

	// for allocating some cached memory

	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

	CleanupStack::PushL(bitmap);

	User::LeaveIfError(bitmap->Load(TEST_BITMAP_NAME, 0));

	CleanupStack::PopAndDestroy(bitmap);

	CCustomTextCursorsWrapper* customTextCursorsWrapper = CCustomTextCursorsWrapper::NewLC(iTest->iScreenNumber, iTest);

	const TInt count = customTextCursorsWrapper->CustomTextCursorsArray().Count();

	for (TInt index=0; index<count; ++index)

		{

		CCustomTextCursor& customTextCursor = customTextCursorsWrapper->CustomTextCursor(index);

		TInt err = TheClient->iWs.SetCustomTextCursor(customTextCursor.iIdentifier, customTextCursor.iSpriteMemberArray.Array(), customTextCursor.iSpriteFlags, customTextCursor.iAlignment);

		TEST(err == KErrNone || err == KErrAlreadyExists);

		if (err!=KErrNone && err != KErrAlreadyExists)

			INFO_PRINTF4(_L("TheClient->iWs.SetCustomTextCursor return value  - Expected: %d or %d, Actual: %d"), KErrNone, KErrAlreadyExists, err);

		__UHEAP_MARK;

		err = TheClient->iWs.SetCustomTextCursor(customTextCursor.iIdentifier, customTextCursor.iSpriteMemberArray.Array(), customTextCursor.iSpriteFlags, customTextCursor.iAlignment);

		__UHEAP_MARKEND;

		TEST(err == KErrAlreadyExists);

		if (err != KErrAlreadyExists)

			INFO_PRINTF3(_L("TheClient->iWs.SetCustomTextCursor return value  - Expected: %d, Actual: %d"), KErrAlreadyExists, err);

		}

	_LIT(KLog,"Text Cursor: Loaded %d Custom Cursors");

	TLogMessageText buf;

	buf.Format(KLog,count);

	TheClient->LogMessage(buf);

	CleanupStack::PopAndDestroy(customTextCursorsWrapper);

//

	ValidateWin(BaseWin,TRgb::Gray256(204));

	ValidateWin(TestWin,TRgb::Gray256(204));

//

	SetCursor(TPoint(10,90),TSize(80,100),TRgb(255,255,255));

//

	iWinState=0;

	iWinPos=TPoint(2*TheClient->iGroup->Size().iWidth/3,0);

//

	iMoveWin=new(ELeave) CBlankWindow(TRgb::Gray256(220));

	TDisplayMode mode=EGray16;

	TInt testWinWidth = TestWin->Size().iWidth;

	TInt halfTestWinWidth = testWinWidth/2;

	TInt halfTestWinHeight = TestWin->Size().iHeight/2;