--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/tauto/TKRepeat.CPP Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,464 @@
+// 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)
+