// 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:

// Converted from TMan test code May 2001

// Keyboard repeat test

// 

//

#include "TKRepeat.H"

#define LOGGING 1

//

// CRKWindow, class //

//

CRKWindow::CRKWindow(CTKRepeat *aTest) : CTWin(), iTest(aTest)

	{

	}

void CRKWindow::SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc)

	{

	ConstructExtLD(*parent,pos,size);

	iWin.SetBackgroundColor(TRgb::Gray256(230));

	Activate();

	AssignGC(aGc);

	}

void CRKWindow::Draw()

	{

	iGc->Clear();

	switch(iState)

		{

		case EStateWaitingForKeyDown:

			iGc->DrawText(_L("Press and hold the space bar"), TPoint(10,20));

			break;

		case EStateWaitingForFirstRepeat:

		case EStateWaitingForNthRepeat:

			{

			TBuf<0x40> buf;

			buf.Format(TRefByValue<const TDesC>(_L("Keep space bar down (%d repeats so far)")),iRepCount);

			iGc->DrawText(buf, TPoint(10,20));

			}

			break;

		case EStateWaitingForKeyUp:

			iGc->DrawText(_L("Release space bar"), TPoint(10,20));

		default:

			break;

		}

	}

void CRKWindow::SetState(TRKStates aState)

	{

#if defined(LOGGING)

	TLogMessageText logMessageText;

	_LIT(KStateChange,"State Change  Old=%d  New=%d");

	logMessageText.Format(KStateChange,iState,aState);

	iTest->LOG_MESSAGE(logMessageText);

#endif

	iState=aState;

	DrawNow();

	TheClient->WaitForRedrawsToFinish();

	SendEvent();

	}

void CRKWindow::SendEvent()

	{

	switch (iState)

		{

	case EStateWaitingForKeyDown:

	case EStateWaitingForKeyUp:

	#if defined(LOGGING)

		_LIT(KKeyUp,"Send key up event  substate 0");

		_LIT(KKeyDown,"Send key down event  substate 4");

		iTest->LOG_MESSAGE(iState==EStateWaitingForKeyDown ? KKeyDown() : KKeyUp());

	#endif

		iTest->TestBase()->SimulateKey((iState==EStateWaitingForKeyDown ? TRawEvent::EKeyDown : TRawEvent::EKeyUp),EStdKeySpace);

		break;

	case EStateWaitingForKeyCode:

	case EStateWaitingForFirstRepeat:

	case EStateWaitingForNthRepeat:

	case EStateInactive:

	case EStateError:

	#if defined(LOGGING)

		_LIT(KLog,"SendEvent:  substate %d so no event to send");

		iTest->LOG_MESSAGE2(KLog,iState);

	#endif

		break;

		}

	}

TBool CRKWindow::CheckResults()

	{

//

// Checks repeat results, first convert everything to 10th's as that what is actually used 

// for the timer in the window server.

//

// Return ETrue if the inacuracy in the average time is greater than 1/10th either way

// Allow initial 2/10ths either

// Allow min 2/10ths below

// Allow max 2/10ths above

//

	if (iState!=EStateInactive)

		return(ETrue);

	TInt initial=iInitialGap.Int()/100000;

	TInt initialX=iInitialRepeatSet.Int()/100000;

	if (initialX==0)

		initialX=1;

	TInt average=(iTotalGap.Int()/100000)/(iRepCount-1);

	TInt repeatX=iRepeatSet.Int()/100000;

	if (repeatX==0)

		repeatX=1;

	TInt min=iMinGap.Int()/100000;

	TInt max=iMaxGap.Int()/100000;

	if (average>(repeatX+1) || average<(repeatX-1))

		return(ETrue);

	if (initial>(initialX+2) || initial<(initialX-2))

		return(ETrue);

#if defined(__MARM_ARM4__)

	if (min>(repeatX+1) || min<(repeatX-2) || max>(repeatX+3) || max<repeatX)

		{

		if (max<min || (max+min)<2*(repeatX-2) || (max+min)>2*(repeatX+2))

			return(ETrue);

		}

#else

	if (min>(repeatX+1) || min<(repeatX-2))

		return(ETrue);

	if (max>(repeatX+3) || max<repeatX)

		return(ETrue);

#endif

	return(EFalse);

	}

TDesC& CRKWindow::Report()

	{

	if (iState!=EStateInactive)

		{

		iReport.Format(_L("Error, test not completed"));

		}

	else

		{

		TInt initial=iInitialGap.Int()/10000;

		TInt initialX=iInitialRepeatSet.Int()/10000;

		TInt average=(iTotalGap.Int()/10000/(iRepCount-1));

		TInt repeatX=iRepeatSet.Int()/10000;

		TInt min=iMinGap.Int()/10000;

		TInt max=iMaxGap.Int()/10000;

		iReport.Format(TRefByValue<const TDesC>(_L("Initial=%d [%d], Av=%d [%d], Min=%d, Max=%d")),initial,initialX,average,repeatX,min,max);

		}

	return(iReport);

	}

void CRKWindow::KeyDownL(const TKeyEvent &aKey,const TTime &)

	{

#if defined(LOGGING)

	TLogMessageText logMessageText;

	_LIT(KKeyDown,"CRKWindow::KeyDownL  Code=%d '%c'  State=%d (0)");

	logMessageText.Format(KKeyDown,aKey.iScanCode,aKey.iScanCode,iState);

	iTest->LOG_MESSAGE(logMessageText);

#endif

	switch(iState)

		{

		case EStateWaitingForKeyDown:

			SetState(EStateWaitingForKeyCode);

			iDownCode=aKey.iScanCode;

			break;

		default:;

		}

	}

void CRKWindow::KeyUpL(const TKeyEvent &aKey,const TTime &)

	{

#if defined(LOGGING)

	TLogMessageText logMessageText;

	_LIT(KKeyUp,"CRKWindow::KeyUpL  Code=%d (%c)  State=%d  Down=%d");

	logMessageText.Format(KKeyUp,aKey.iScanCode,aKey.iScanCode,iState,iDownCode);

	iTest->LOG_MESSAGE(logMessageText);

#endif

	if (aKey.iScanCode==iDownCode)

		{

		switch(iState)

			{

			case EStateWaitingForKeyUp:

				SetState(EStateInactive);

				break;

			default:

				SetState(EStateError);

				break;

			}

		CActiveScheduler::Stop();

		}

	}

void CRKWindow::WinKeyL(const TKeyEvent &aKey,const TTime &aTime)

	{

	if (aKey.iCode==EKeyEscape)

		{

		CActiveScheduler::Stop();

		iTest->iAbort=ETrue;

		}

#if defined(LOGGING)

	TLogMessageText logMessageText;

	_LIT(KKey,"CRKWindow::WinKeyL  Code=%d (%c)  State=%d  RepeatCount=%d");

	logMessageText.Format(KKey,aKey.iScanCode,aKey.iScanCode,iState,iRepCount);

	iTest->LOG_MESSAGE(logMessageText);

#endif

	if (aKey.iCode==32)

		{

		switch(iState)

			{

			case EStateWaitingForKeyCode:

				SetState(EStateWaitingForFirstRepeat);

				iPrevTime=aTime;

				break;

			case EStateWaitingForFirstRepeat:

				iRepCount=1;

				iInitialGap = I64LOW(aTime.MicroSecondsFrom(iPrevTime).Int64());

				SetState(EStateWaitingForNthRepeat);

				break;

			case EStateWaitingForNthRepeat:

				if (iRepCount==5)

					SetState(EStateWaitingForKeyUp);

				else

					{

					TTimeIntervalMicroSeconds32 gap(I64LOW(aTime.MicroSecondsFrom(iPrevTime).Int64()));

				#if defined(LOGGING)

					TLogMessageText logMessageText;

					_LIT(KRepeatGap,"Repeat after %d");

					logMessageText.AppendFormat(KRepeatGap,gap.Int());

					iTest->LOG_MESSAGE(logMessageText);

					TheClient->Flush();

				#endif

					if (gap<iMinGap)

						iMinGap=gap;

					if (gap>iMaxGap)

						iMaxGap=gap;

					iTotalGap=iTotalGap.Int()+gap.Int();	// Horrible way to do a +=

					iRepCount++;

					SetState(EStateWaitingForNthRepeat);

					}

			case EStateWaitingForKeyUp: 	// Do nothing here

				break;

			default:

				//iTest->Test(EFalse);

				iTest->TestBase()->SimulateKey(TRawEvent::EKeyUp,EStdKeySpace);

				CActiveScheduler::Stop();

			}

		iPrevTime=aTime;

		}

	}

void CRKWindow::SetKeyboardRepeatRate(const TTimeIntervalMicroSeconds32 &aInitialTime, const TTimeIntervalMicroSeconds32 &aTime)

	{

	iInitialRepeatSet=aInitialTime;

	iRepeatSet=aTime;

	iMinGap=TTimeIntervalMicroSeconds32(100000000);	// Any very big number will do

	iMaxGap=TTimeIntervalMicroSeconds32(0);

	iTotalGap=TTimeIntervalMicroSeconds32(0);

	SetState(EStateWaitingForKeyDown);

	Client()->iWs.Flush();

	}

//

CTKRepeat::CTKRepeat(CTestStep* aStep) : CTWsGraphicsBase(aStep)

	{

	}

CTKRepeat::~CTKRepeat()

	{

	CTWin::Delete(iWin);

	Client()->iWs.SetKeyboardRepeatRate(iOldInitialTime, iOldTime);

	}

void CTKRepeat::ConstructL()

	{

	TheClient->iWs.SetFocusScreen(iTest->iScreenNumber);

	iWin=new(ELeave) CRKWindow(this);

	TSize screenSize=Client()->iGroup->Size();

	iWin->SetUpL(TPoint(5,5),TSize(Min(Max(screenSize.iWidth/2,250),screenSize.iWidth-10),screenSize.iHeight-10),Client()->iGroup,*Client()->iGc);

	Client()->iGroup->WinTreeNode()->SetOrdinalPosition(0);

	Client()->iGroup->SetCurrentWindow(iWin);

	Client()->iWs.GetKeyboardRepeatRate(iOldInitialTime, iOldTime);

	iTest->SimulateKeyDownUp(EStdKeyLeftCtrl);

	iTest->SimulateKeyDownUp(EStdKeyRightCtrl);

	TInt mods=Client()->iWs.GetModifierState();

	TheClient->WaitForRedrawsToFinish();		//Let all pending events be processed before test begins

	_LIT(KLog,"Initial Modifiers state 0x%x (ideally should be zero)");

	LOG_MESSAGE2(KLog,mods);

	}

TInt CTKRepeat::CheckReportL()

	{

	if (iWin->CheckResults())

		{

		/*CTDialog *dialog=new(ELeave) CTDialog();

		dialog->SetTitle(_L("Keyboard repeat innacuracies"));

		dialog->SetLine1(iWin->Report());

		dialog->SetNumButtons(3);

		dialog->SetButtonText(0,_L("Okay"));

		dialog->SetButtonText(1,_L("Retest"));

		dialog->SetButtonText(2,_L("Fail"));

		dialog->ConstructLD(*Client()->iGroup,*Client()->iGc);

		switch(dialog->Display())

			{

			case 0:

				break;

			case 1:

				return(ETrue);	// Redo test

			case 2:

				Client()->iGroup->ClearCurrentWindow();

				Test(EFalse);

				break;

			}

		*/}

	return(EFalse);

	}

void CTKRepeat::TestKeyboardRepeatRateL(const TTimeIntervalMicroSeconds32 &aInitialTime, const TTimeIntervalMicroSeconds32 &aTime)

	{

	do

		{

	#if defined(LOGGING)

		const TInt KOneSec=1000000;

		const TInt KOneHundrethSec=KOneSec/100;

		TLogMessageText logMessageText;

		_LIT(KRepeatRate,"Repeat Rate Initial=%d.%02dsecs, Subsequent=%d.%02dsecs");

		logMessageText.Format(KRepeatRate,aInitialTime.Int()/KOneSec,(aInitialTime.Int()%KOneSec)/KOneHundrethSec

																	,aTime.Int()/KOneSec,(aTime.Int()%KOneSec)/KOneHundrethSec);

		LOG_MESSAGE(logMessageText);

	#endif

		TheClient->iWs.SetKeyboardRepeatRate(aInitialTime, aTime);

		iWin->SetKeyboardRepeatRate(aInitialTime, aTime);

		CActiveScheduler::Start();

		if (iAbort)

			{

			iTest->AbortL();

			}

		} while(CheckReportL());

	}

void CTKRepeat::RunTestCaseL(TInt /*aCurTestCase*/)

	{

	_LIT(KTestName1,"Keyboard Repeat 1");

	_LIT(KTestName2,"Keyboard Repeat 2");

	_LIT(KTestName3,"Keyboard Repeat 3");

	_LIT(KTestName4,"Keyboard Repeat 4");

	((CTKRepeatStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

	switch(++iTest->iState)

		{

/**

  @SYMTestCaseID GRAPHICS-WSERV-0311

  @SYMDEF             DEF081259

  @SYMTestCaseDesc Test that a key can be repeatedly struck after a second, then every half second

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Simulate a key being struck first after a second and then repeatedly every

  					half second and check the response time to the key strike is correct 

  @SYMTestExpectedResults Response time each time the key is struck is correct

*/

		case 1:

			((CTKRepeatStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0311"));

			iTest->LogSubTest(KTestName1);

			TestKeyboardRepeatRateL(TTimeIntervalMicroSeconds32(1000000), TTimeIntervalMicroSeconds32(500000));

			break;

/**

  @SYMTestCaseID GRAPHICS-WSERV-0312

  @SYMDEF             DEF081259

  @SYMTestCaseDesc Test that a key can be repeatedly struck after a 5th of a second, then every 10th of a second

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Simulate a key being struck first after a 5th of a second and then repeatedly every

  					10th of a second and check the response time to the key strike is correct 

  @SYMTestExpectedResults Response time each time the key is struck is correct

*/

		case 2:

			((CTKRepeatStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0312"));

			iTest->LogSubTest(KTestName2);

			TestKeyboardRepeatRateL(TTimeIntervalMicroSeconds32(200000), TTimeIntervalMicroSeconds32(100000));

			break;

/**

  @SYMTestCaseID GRAPHICS-WSERV-0313

  @SYMDEF             DEF081259

  @SYMTestCaseDesc Test that a key can be repeatedly struck immediately, then every 10th of a second

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Simulate a key being struck first immediately and then repeatedly every

  					10th of a second and check the response time to the key strike is correct 

  @SYMTestExpectedResults Response time each time the key is struck is correct

*/

		case 3:

			((CTKRepeatStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0313"));

			iTest->LogSubTest(KTestName3);

			TestKeyboardRepeatRateL(TTimeIntervalMicroSeconds32(0), TTimeIntervalMicroSeconds32(100000));

			break;

/**

  @SYMTestCaseID GRAPHICS-WSERV-0314

  @SYMDEF             DEF081259

  @SYMTestCaseDesc Test that a key can be repeatedly struck after a 10 of a second, then every 10th of a second

  @SYMTestPriority High

  @SYMTestStatus Implemented

  @SYMTestActions Simulate a key being struck first after a 10th of a second and then repeatedly every

  					10th of a second and check the response time to the key strike is correct 

  @SYMTestExpectedResults Response time each time the key is struck is correct

*/

		case 4:

			((CTKRepeatStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0314"));

			iTest->LogSubTest(KTestName4);

			TestKeyboardRepeatRateL(TTimeIntervalMicroSeconds32(100000), TTimeIntervalMicroSeconds32(100000));

			break;

		case 5:

			((CTKRepeatStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

			((CTKRepeatStep*)iStep)->CloseTMSGraphicsStep();

			TestComplete();

			break;

		}

	((CTKRepeatStep*)iStep)->RecordTestResultL();

	}

__WS_CONSTRUCT_STEP__(KRepeat)