diff -r bf7481649c98 -r 7f25ef56562d windowing/windowserver/test/tman/TKREPEAT.CPP
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/test/tman/TKREPEAT.CPP	Wed Jun 23 19:41:15 2010 +0300
@@ -0,0 +1,348 @@
+// 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:
+// Keyboard repeat test
+// 
+//
+
+#include <e32std.h>
+#include <e32svr.h>
+#include "W32STD.H"
+#include "../tlib/testbase.h"
+#include "TMAN.H"
+
+class CRKWindow;
+
+class TKRepeatTest : public CTestBase
+	{
+public:
+	TKRepeatTest();
+	~TKRepeatTest();
+	TestState DoTestL();
+	void ConstructL();
+	void TestKeyboardRepeatRateL(const TTimeIntervalMicroSeconds32 &aInitialTime, const TTimeIntervalMicroSeconds32 &aTime);
+	TBool CheckReportL();
+public:
+	TBool iAbort;
+private:
+	TTimeIntervalMicroSeconds32 iOldInitialTime;
+	TTimeIntervalMicroSeconds32 iOldTime;
+	CRKWindow *iWin;
+	TSize iWinSize;
+	TInt iState;
+	};
+
+class CRKWindow : public CTWin
+	{
+	enum TRKStates {
+		EStateWaitingForKeyDown,
+		EStateWaitingForKeyCode,
+		EStateWaitingForFirstRepeat,
+		EStateWaitingForNthRepeat,
+		EStateWaitingForKeyUp,
+		EStateInactive,
+		EStateError,
+		};
+public:
+	CRKWindow(TKRepeatTest *aTest);
+	void SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc);
+	void SetState(TRKStates aState);
+	void SetKeyboardRepeatRate(const TTimeIntervalMicroSeconds32 &aInitialTime, const TTimeIntervalMicroSeconds32 &aTime);
+	void WinKeyL(const TKeyEvent &,const TTime &);
+	void KeyUpL(const TKeyEvent &aKey,const TTime &aTime);
+	void KeyDownL(const TKeyEvent &aKey,const TTime &aTime);
+	void Draw();
+	TDesC& Report();
+	TBool CheckResults();
+protected:
+	TInt iConnIndex;
+	TKRepeatTest *iTest;
+	TRgb iBack;
+	TRKStates iState;
+	TInt iDownCode;
+	TInt iRepCount;
+	TTimeIntervalMicroSeconds32 iInitialRepeatSet;
+	TTimeIntervalMicroSeconds32 iRepeatSet;
+	TTime iPrevTime;
+	TTimeIntervalMicroSeconds32 iInitialGap;
+	TTimeIntervalMicroSeconds32 iTotalGap;
+	TTimeIntervalMicroSeconds32 iMinGap;
+	TTimeIntervalMicroSeconds32 iMaxGap;
+	TBuf<0x40> iReport;
+	};
+
+GLDEF_C CTestBase *CreateKRepeatTest()
+	{
+	return(new(ELeave) TKRepeatTest());
+	}
+
+//
+// CRKWindow, class //
+//
+
+CRKWindow::CRKWindow(TKRepeatTest *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)
+	{
+	iState=aState;
+	DrawNow();
+	}
+
+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 (min>(repeatX+1) || min<(repeatX-2))
+		return(ETrue);
+	if (max>(repeatX+3) || max<repeatX)
+		return(ETrue);
+	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 &)
+	{
+	switch(iState)
+		{
+		case EStateWaitingForKeyDown:
+			SetState(EStateWaitingForKeyCode);
+			iDownCode=aKey.iScanCode;
+			break;
+		default:;
+		}
+	}
+
+void CRKWindow::KeyUpL(const TKeyEvent &aKey,const TTime &)
+	{
+	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 (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 (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->TestL(EFalse);
+			}
+		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();
+	}
+
+//
+
+TKRepeatTest::TKRepeatTest() : CTestBase(_L("KRepeat"))
+	{}
+
+TKRepeatTest::~TKRepeatTest()
+	{
+	CTWin::Delete(iWin);
+	Client()->iWs.SetKeyboardRepeatRate(iOldInitialTime, iOldTime);
+	}
+
+void TKRepeatTest::ConstructL()
+	{
+	iWin=new(ELeave) CRKWindow(this);
+	TSize screenSize=Client()->iGroup->Size();
+	iWin->SetUpL(TPoint(5,5),TSize(screenSize.iWidth/2,screenSize.iHeight-10),Client()->iGroup,*Client()->iGc);
+	Client()->iGroup->SetCurrentWindow(iWin);
+	Client()->iWs.GetKeyboardRepeatRate(iOldInitialTime, iOldTime);
+	}
+
+TInt TKRepeatTest::CheckReportL()
+	{
+	if (iWin->CheckResults())
+		{
+		CTDialog *dialog=new(ELeave) CTDialog();
+		dialog->SetTitle(_L("Keyboard repeat innacuracies"));
+		dialog->SetLine1(iWin->Report());
+		dialog->SetNumButtons(2);
+		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:
+				TestL(EFalse);
+				break;
+			}
+		}
+	return(EFalse);
+	}
+
+void TKRepeatTest::TestKeyboardRepeatRateL(const TTimeIntervalMicroSeconds32 &aInitialTime, const TTimeIntervalMicroSeconds32 &aTime)
+	{
+	do
+		{
+		Client()->iWs.SetKeyboardRepeatRate(aInitialTime, aTime);
+		iWin->SetKeyboardRepeatRate(aInitialTime, aTime);
+		CActiveScheduler::Start();
+		if (iAbort)
+			AbortL();
+		} while(CheckReportL());
+	}
+
+TestState TKRepeatTest::DoTestL()
+	{
+	switch(iState)
+		{
+		case 0:
+			LogSubTest(_L("Keyboard Repeat"),1);
+			TestKeyboardRepeatRateL(TTimeIntervalMicroSeconds32(1000000), TTimeIntervalMicroSeconds32(500000));
+			LogSubTest(_L("Keyboard Repeat"),2);
+			TestKeyboardRepeatRateL(TTimeIntervalMicroSeconds32(200000), TTimeIntervalMicroSeconds32(100000));
+			LogSubTest(_L("Keyboard Repeat"),3);
+			TestKeyboardRepeatRateL(TTimeIntervalMicroSeconds32(0), TTimeIntervalMicroSeconds32(100000));
+			LogSubTest(_L("Keyboard Repeat"),4);
+			TestKeyboardRepeatRateL(TTimeIntervalMicroSeconds32(100000), TTimeIntervalMicroSeconds32(100000));
+			iState++;
+			break;
+		default:
+			return(EFinished);
+		}
+	return(ENext);
+	}
+