// Copyright (c) 1996-2010 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 window server events

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#ifndef __INIPARSER_H__

#define __INIPARSER_H__

#endif // __INIPARSER_H__

#include "PARSEINIDATA.H"

#include "TEVENT.H"

#include "W32CLICK.H"

#include <w32debug.h>

#include <hal.h>

#define FAIL_LOGGING on

//#define DETAILED

#define LOGGING 1	//Uncomment this when there is a fail so that you get more logging

_LIT(KKeyClickPluginDll, "click.dll");

const TInt KLongKeyCaptureLowPriority = 1;

const TInt KLongKeyCaptureHighPriority = 2;

CTQueueClient::CTQueueClient(CTEventTest *aTest) : iTest(aTest)

	{

	}

CTQueueClient::~CTQueueClient()

	{

	CloseEventTestGroupOnSecondScreen();

	iGroup->GroupWin()->EnableReceiptOfFocus(EFalse);

	delete iChildWin;

	delete iWin;

	}

void CTQueueClient::ConstructL(TBool aCreateChild)

	{

	CTClient::ConstructL();

	iGroup=new(ELeave) CTQueueWindowGroup(this);

	iGroup->ConstructL();

	iWin=new(ELeave) CTBackedUpWin(EGray4);

	iWin->ConstructExtLD(*iGroup,TPoint(EWinPositionX,EWinPositionY),TSize(EWinWidth,EWinHeight));

	iWin->Activate();

	if (aCreateChild)

		{

		iChildWin=new(ELeave) CTBackedUpWin(EGray4);

		iChildWin->ConstructExtLD(*iWin,ChildTopLeft(),ChildSize());

		iChildWin->Activate();

		}

	iWs.Flush();

	}

void CTQueueClient::ConstructEventHandlerL()

	{

	iEventHandler=new(ELeave) CTQueueTestEvent(&iWs, iTest);

	((CTQueueTestEvent *)iEventHandler)->ConstructL();

	}

TInt CTQueueClient::WindowGroupIdentifier()

	{

	return(iGroup->GroupWin()->Identifier());

	}

CTWinBase* CTQueueClient::GetHandle(TPoint& aPos)

	{

	if (iCapturing)

		return iChildWin;

	if (iChildWin && TRect(ChildTopLeft(),ChildSize()).Contains(aPos))

	//if (iChildWin && TRect(TPoint(),ChildSize()).Contains(aPos))

		{

		aPos-=ChildTopLeft();

		if (iChildCapturing)

			iCapturing=ETrue;

		return iChildWin;

		}

	return iWin;

	}

void CTQueueClient::AddExpectedEvent(TWsEvent &aEvent)

	{

#if defined(DETAILED)

	_LIT(KLog,"   Adding Event Type=%d");

	TLogMessageText buf;

	buf.Format(KLog,aEvent.Type());

	LogMessage(buf);

#endif

	((CTQueueTestEvent *)iEventHandler)->AddExpectedEvent(aEvent);

	}

void CTQueueClient::SetChildCapture(TInt aCaptureFlags)

	{

	if (!iChildWin)

		return;

	iChildWin->BaseWin()->SetPointerCapture(aCaptureFlags);

	if (aCaptureFlags|RWindowBase::TCaptureFlagEnabled)

		iChildCapturing=ETrue;

	}

//

CTQueueTestEvent::CTQueueTestEvent(RWsSession *aWs, CTEventTest *aTest) : CTEvent(aWs)

	{

	iTest = aTest;

	iCheckTimeStamp = EFalse;

	iLastEventError = EFalse;

	}

void CTQueueTestEvent::ConstructL()

	{

	CTEventBase::Construct();

	iEventBuffer.SetLengthL(EEventBufferSize);

	iRedrawType=iTest->TestBase()->RedrawStoreTypeL();

	}

void CTQueueTestEvent::TestL(TInt aTest)

	{

	if (!aTest)

		{

		iTest->Failed();

		User::Leave(ETestFailed);

		}

	}

//#define FAIL_LOGGING yes

void CTQueueTestEvent::doRunL()

	{

	TWsEvent wsEvent;

	iWs->GetEvent(wsEvent);

	TWsEvent expectedEvent;

#if defined(FAIL_LOGGING)

	TInt eType,wsHan,eHan,wsKeyCode,eKeyCode,wsKeyRepeat,eKeyRepeat,wsKeyScan,eKeyScan;

	TLogMessageText buf;

	_LIT(KStartString,"AUTO  EventTestFail ");

#endif

	TInt wsType=wsEvent.Type();

	if (wsEvent.Type()==EEventNull)

		TestL(wsEvent.Handle()==0);

	else

		{

		TInt count=iEventBuffer.Count();

		if (count==0 && wsType==EEventFocusGained)

			goto End;

		if (iLastEventError

			&& (iRedrawType==EPartialRedraw_FullRedrawSupport || iRedrawType==EPartialRedraw_PreserveStoredCmds)

			&& wsEvent.Type()==EEventErrorMessage /*&& expectedEvent.Type()!=EEventErrorMessage*/)		//Should really check if the next expected event is an error but there is no way to do this without removing it from the buffer

			{

		#if defined(DETAILED)

			_LIT(KLog,"Skip Duplicate Error Message");

			iTest->LOG_MESSAGE(KLog);

		#endif

			return;		//Ignore repeated error events

			}

		do	{

			TestL(iEventBuffer.Remove(&expectedEvent));	//Loop needed for REL Build with DEB WSERV and W32

		#if defined(DETAILED)

			_LIT(KLog,"Skip event while waiting for error message");

			if (expectedEvent.Type()==EEventErrorMessage && wsEvent.Type()!=expectedEvent.Type())

				iTest->LOG_MESSAGE(KLog);

		#endif

			} while (expectedEvent.Type()==EEventErrorMessage && wsEvent.Type()!=expectedEvent.Type());

		++iEventCount;		//iEventSet

	#if defined(FAIL_LOGGING)

		wsType=wsEvent.Type(),eType=expectedEvent.Type(),wsHan=wsEvent.Handle(),eHan=expectedEvent.Handle();

		if (wsType!=eType)

			{

			_LIT(KEventDiff,"Count=%d  Events Differ Exp=%d  Act=%d");

			buf.Copy(KStartString);

			buf.AppendFormat(KEventDiff,iEventCount,eType,wsType);

			iTest->LOG_MESSAGE(buf);

			}

		else

			{

		#if defined(DETAILED)

			_LIT(KLog," Count=%d  Event Type=%d");

			iTest->LOG_MESSAGE3(KLog,iEventCount,wsType);

		#endif

			}

		if (wsHan!=eHan)

			{

			_LIT(KHandlesDiff,"Count=%d  Handles Differ");

			buf.Copy(KStartString);

			buf.AppendFormat(KHandlesDiff,iEventCount);

			iTest->LOG_MESSAGE(buf);

			}

	#endif

		TestL(wsEvent.Type()==expectedEvent.Type() && wsEvent.Handle()==expectedEvent.Handle());

		}		

	iLastEventError=(wsEvent.Type()==EEventErrorMessage);

	switch(wsEvent.Type())

		{

		case EEventKey:

		#if defined(FAIL_LOGGING)

			wsKeyCode=wsEvent.Key()->iCode,eKeyCode=expectedEvent.Key()->iCode;

			if (wsKeyCode!=eKeyCode)

				{

				_LIT(KKeysDiff,"Count=%d  Key Code Exp=%d (%c)  Act=%d (%c)");

				buf.Copy(KStartString);

				buf.AppendFormat(KKeysDiff,iEventCount,eKeyCode,eKeyCode,wsKeyCode,wsKeyCode);

				iTest->LOG_MESSAGE(buf);

				}

			wsKeyRepeat=wsEvent.Key()->iRepeats,eKeyRepeat=expectedEvent.Key()->iRepeats;

			if ((wsKeyRepeat>0)!=(eKeyRepeat>0) || wsKeyRepeat<eKeyRepeat)

				{

				_LIT(KKeysRepDiff,"Count=%d  Key Repeat Exp=%d  Act=%d");

				buf.Copy(KStartString);

				buf.AppendFormat(KKeysRepDiff,iEventCount,eKeyRepeat,wsKeyRepeat);

				iTest->LOG_MESSAGE(buf);

				}

		#endif

			TestL(wsEvent.Key()->iCode==expectedEvent.Key()->iCode &&

				wsEvent.Key()->iRepeats>=expectedEvent.Key()->iRepeats &&

				(wsEvent.Key()->iRepeats>0)==(expectedEvent.Key()->iRepeats>0));

			// Fall Through

		case EEventKeyDown:

		case EEventKeyUp:

			{

			TUint wsModifiers = wsEvent.Key()->iModifiers;

			TUint eModifiers = expectedEvent.Key()->iModifiers;

		#if defined(FAIL_LOGGING)

			wsKeyScan=wsEvent.Key()->iScanCode,eKeyScan=expectedEvent.Key()->iScanCode;

			if (wsKeyScan!=eKeyScan)

				{

				_LIT(KScanDiff,"Count=%d  Scan Code Exp=%d (%c)  Act=%d (%c)");

				buf.Copy(KStartString);

				buf.AppendFormat(KScanDiff,iEventCount,eKeyScan,eKeyScan,wsKeyScan,wsKeyScan);

				iTest->LOG_MESSAGE(buf);

				}

			if (eModifiers != KModifiersIgnore && wsModifiers != eModifiers)

				{

				_LIT(KModDiff,"Count=%d  Modifiers Exp=0x%x  Act=0x%x");

				buf.Copy(KStartString);

				buf.AppendFormat(KModDiff, iEventCount, eModifiers, wsModifiers);

				iTest->LOG_MESSAGE(buf);

				}

		#endif

			TestL(wsEvent.Key()->iScanCode == expectedEvent.Key()->iScanCode &&

				(eModifiers == KModifiersIgnore || wsModifiers == eModifiers));

			}

			break;

		case EEventModifiersChanged:

			{

			TBool changeModifiersOK=(wsEvent.ModifiersChanged()->iChangedModifiers

																==expectedEvent.ModifiersChanged()->iChangedModifiers);

			TBool modifiersOK=((wsEvent.ModifiersChanged()->iModifiers&wsEvent.ModifiersChanged()->iChangedModifiers)==

						(expectedEvent.ModifiersChanged()->iModifiers&wsEvent.ModifiersChanged()->iChangedModifiers));

		#if defined(FAIL_LOGGING)

			if (!changeModifiersOK || !modifiersOK)

				{

				_LIT(KModDiff,"Count=%d  Modifiers");

				buf.Copy(KStartString);

				buf.AppendFormat(KModDiff,iEventCount);

				iTest->LOG_MESSAGE(buf);

				}

		#endif

			TestL(changeModifiersOK);

			TestL(modifiersOK);

			}

			break;

		case EEventPointer:

		case EEventDragDrop:

			{

		#if defined(FAIL_LOGGING)

			TInt expectedType=expectedEvent.Pointer()->iType, actualType=wsEvent.Pointer()->iType;

			TPoint expectedPos=expectedEvent.Pointer()->iPosition, actualPos=wsEvent.Pointer()->iPosition;

			if (actualType!=expectedType)

				{

				_LIT(KPointerDiff,"Count=%d  Pointer Type Exp=%d  Act=%d");

				buf.Copy(KStartString);

				buf.AppendFormat(KPointerDiff,iEventCount,expectedType,actualType);

				iTest->LOG_MESSAGE(buf);

				}

			if (actualPos!=expectedPos)

				{

				_LIT(KPointerPosDiff,"Count=%d  Pointer Pos E=(%d,%d)  A=(%d,%d)");

				buf.Copy(KStartString);

				buf.AppendFormat(KPointerPosDiff,iEventCount,expectedPos.iX,expectedPos.iY

																,actualPos.iX,actualPos.iY);

				iTest->LOG_MESSAGE(buf);

				}

		#endif

			TestL(wsEvent.Pointer()->iType==expectedEvent.Pointer()->iType);

			TestL(wsEvent.Pointer()->iPosition==expectedEvent.Pointer()->iPosition);

			TInt count=iEventBuffer.Count();count++;			//Dummy line to help in debugging.

			}

			break;

		case EEventWindowVisibilityChanged:

			{

		#if defined(FAIL_LOGGING)

			TUint expectedFlags=expectedEvent.VisibilityChanged()->iFlags;

			TUint actualFlags=wsEvent.VisibilityChanged()->iFlags;

			if (actualFlags!=expectedFlags)

				{

				_LIT(KVisibilityDiff,"Count=%d  Visibility Flags Exp=%d  Act=%d");

				buf.Copy(KStartString);

				buf.AppendFormat(KVisibilityDiff,iEventCount,expectedFlags,actualFlags);

				iTest->LOG_MESSAGE(buf);

				}

		#endif

			TestL(wsEvent.VisibilityChanged()->iFlags==expectedEvent.VisibilityChanged()->iFlags);

			TInt count=iEventBuffer.Count();count++;			//Dummy line to help in debugging.

			}

			break;

		case EEventMessageReady:

			{

			const SEventMessageReady message = *(SEventMessageReady*)wsEvent.EventData();

			TestL(message.iMessageUid== TUid::Uid(123));

			}

			break;

		default:;

		}

	if(iCheckTimeStamp)

		{

		const TInt KOffset=100000; //0.1secs

		TInt64 offset = expectedEvent.Time().Int64() - wsEvent.Time().Int64();

		#if defined(FAIL_LOGGING)

			if(Abs(offset)<KOffset)

				{

				_LIT(KTimeStampDiff,"Count=%d  Offset=%d, ExpectedTime=%d, WServEventTime=%d");

				buf.Copy(KStartString);

				buf.AppendFormat(KTimeStampDiff,iEventCount,offset,expectedEvent.Time().Int64(),wsEvent.Time().Int64());

				iTest->LOG_MESSAGE(buf);

				}

		#endif

		TestL(Abs(offset)<KOffset);

		}

	End:

	if (iEventBuffer.Count()==0)

	    {

		TRAPD(err, iTest->NextSetOfEventsL());		//Not allowed to leave

		if(err != KErrNone)

		    {

            buf.Copy(KStartString);

            buf.AppendFormat(_L("Subtest does not follow rules set by TEvent test framework, leave code: %d"), err);

            iTest->TEST(EFalse);

            iTest->LOG_MESSAGE(buf);

            User::Leave(err);

		    }

	    }

	}

void CTQueueTestEvent::AddExpectedEvent(TWsEvent &aEvent)

	{

	if(iCheckTimeStamp)

		{

		static_cast<TWsQTEvent&>(aEvent).Time().UniversalTime();

		}

	iEventBuffer.Add(&aEvent);

	}

TInt CTQueueTestEvent::EventsLeft()

	{

	return iEventBuffer.Count();

	}

//

CTQueueWindowGroup::CTQueueWindowGroup(CTClient *aClient) : CTWindowGroup(aClient)

	{}

void CTQueueWindowGroup::ConstructL()

	{

	CTWindowGroup::ConstructL();

	User::LeaveIfError(iGroupWin.EnableOnEvents(EEventControlAlways));

	User::LeaveIfError(iGroupWin.EnableGroupChangeEvents());

	}

//

/**

 Closes and deletes anim DLL.

 @param aAnimDll Pointer to the anim Dll to be closed and deleted

 */

LOCAL_C void DestroyAnimDll(TAny* aAnimDll)

	{

	(static_cast<RAnimDll*>(aAnimDll))->Destroy();

	}

/**

 Destroys an REventAnimBase derived anim

 @param aAnim REventAnimBase derived client-side handle to anim

 */

LOCAL_C void DestroyAnim(TAny* aAnim)

	{

	(static_cast<REventAnimBase*>(aAnim))->Destroy();

	}

/**

 Loads the DLL containing the test anims and pushes it onto the cleanup stack.

 This function leaves if the operation was unsuccessful.

 @return A pointer to the DLL containing test anims

 */

RAnimDll* REventAnimBase::LoadL()

	{

	RAnimDll* animDll=new(ELeave) RAnimDll(TheClient->iWs);

	CleanupStack::PushL(TCleanupItem(DestroyAnimDll,animDll));

	User::LeaveIfError(animDll->Load(KAnimDLLName));

	CleanupStack::Pop(animDll);

	return animDll;

	}

/**

 Closes the client-side handle to the anim, destroys the DLL and deletes itself.

 */

void REventAnimBase::Destroy()

	{

	Close();

	delete this;

	}

/**

 Resets server-side state of anim

 */

void REventAnimBase::Reset()

	{

	CommandReply(EADllReset);

	}

/**

 @return Under non-error conditions, returns 0.

 Under error conditions, returns the number of events received

 since the first unexpected event was sent.

 */

TInt REventAnimBase::ErrorCode()

	{

	return CommandReply(EADllErrorCode);

	}

/**

 @return The number of events received by the anim since it was last reset.

 */

TInt REventAnimBase::NumberOfEventsReceived()

	{

	return CommandReply(EADllNumberOfEventsReceived);

	}

/**

 Adds an expected event to the list of events expected by the anim.

 @param aEat Indicates if event is expected to be eaten (ETrue 'indicates expected to be eaten')

 @param aEvent The expected event

 @return KErrNone if succcessful, othewise error code.

 */

TInt REventAnimBase::AddExpectedEvent(TBool aEat, const TRawEvent& aEvent)

	{

	TAnimRawEvent event;

	event.iRawEvent=aEvent;

	event.iEat=aEat;

	return AddExpectedEvent(event);

	}

/**

 Adds an expected event to the list of events expected by the anim.

 @param aEvent The expected event

 @return KErrNone if succcessful, othewise error code.

 */

TInt REventAnimBase::AddExpectedEvent(const TAnimRawEvent& aEvent)

	{

	TPckgBuf<TAnimRawEvent> param;

	param()=aEvent;

	return CommandReply(EADllAddExpectedEvent,param);

	}

//

/**

 Loads the DLL containing the event test anim and creates an anim for event tests

 @param aWin the base window to which the anim is associated (this anim is a Window anim)

 @return A pointer to the new REventAnim

 */

REventAnim* REventAnim::NewL(RWindowBase* aWin, RAnimDll* aDll, REventAnimBase::EAnimationType aType/*=EEventAnim*/)

	{

	REventAnim* self=new(ELeave) REventAnim(aDll);

	CleanupStack::PushL(TCleanupItem(DestroyAnim,self));

	User::LeaveIfError(self->Construct(*aWin,(aType == EEventAnim ? EAnimTypeEventTest : EAnimTypeEventPostingTest), TPtrC8()));

	CleanupStack::Pop(self);

	return self;

	}

/**

 Checks if the anim has received the correct events, and resets the sever-side state of the anim

 @return positive value if events did not match expected showing the first event that didn't match.

         negative value if there were the wrong number of events showing the number of events there were

         0 if correct number of events and they all match

 */

TInt REventAnim::TestFail(TInt aNoEvents)

	{

	TInt events=CommandReply(EADllErrorCode);

	if (events>0)

		return events;

	events=CommandReply(EADllNoEventsAndReset);

	if (events==aNoEvents)

		return 0;

	return -events;

	}

//

/**

 Loads the DLL containing the event test anim and creates an anim for event handler removal tests

 @param aWin the base window to which the anim is associated (this anim is a Window anim)

 @return A pointer to the new REventAnim

 */

RRemovableAnim* RRemovableAnim::NewLC(RWindowBase* aWin, RAnimDll* aDll)

	{

	RRemovableAnim* self=new(ELeave) RRemovableAnim(aDll);

	CleanupStack::PushL(TCleanupItem(DestroyAnim,self));