--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/test/tman/TKREPEAT.CPP Tue Jun 22 15:21:29 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);
+ }
+