diff -r bf7481649c98 -r 2717213c588a windowing/windowserver/test/tman/TMCAPKEY.CPP
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/test/tman/TMCAPKEY.CPP	Tue Jun 22 15:21:29 2010 +0300
@@ -0,0 +1,625 @@
+// Copyright (c) 1995-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:
+// Test capture key
+// 
+//
+
+#include <e32std.h>
+#include <e32svr.h>
+#include <e32keys.h>
+#include "W32STD.H"
+#include "../tlib/testbase.h"
+#include "TMAN.H"
+
+enum TTestMode
+	{
+	EModeNormalCapture,
+	EModeWaitingForFirstDown,
+	EModeKeyUpsAndDowns,
+	EModeAbortKeys,
+	};
+enum TCapKeyRetValues
+	{
+	ECapKeyOkay,
+	ECapKeyRetry,
+	ECapKeyFail,
+	};
+
+struct SCapKeyParams
+	{
+	TInt connIndex;		// Connection that should capture this key
+	TUint keyCode;
+	TUint modifier_mask;
+	TUint modifiers;
+	};
+
+struct SCapKeyTestParams
+	{
+	TText *txt;			// Text message telling user what to do
+	TInt connIndex;		// Connection that receive the key press
+	TUint keyCode;		// Expected key code
+	TUint modifier_mask;// Modifiers mask for expected modifiers
+	TUint modifiers;	// Expected modifiers
+	};
+
+struct SAbortKeyTests
+	{
+	TUint keyCode;		// Expected key code
+	TUint modifier_mask;// Modifiers mask for expected modifiers
+	TUint modifiers;	// Expected modifiers
+	};
+
+LOCAL_D SCapKeyParams capKeys[]={
+	{1,19,EModifierFunc|EModifierCtrl,EModifierFunc|EModifierCtrl},
+	{2,'b',EModifierFunc|EModifierCtrl,EModifierFunc},
+	{2,'n',EModifierFunc|EModifierCtrl,EModifierFunc},
+	{0,3,EModifierFunc|EModifierCtrl,EModifierFunc|EModifierCtrl},
+	{2,'q',0,0},
+	{2,'w',0,0},
+	};
+	
+LOCAL_D SCapKeyParams capUpAndDownKeys[]={
+	{2,EStdKeySpace,EModifierFunc|EModifierCtrl|EModifierShift,0},
+	{2,EStdKeyEnter,EModifierFunc|EModifierCtrl|EModifierShift,EModifierShift},
+	};
+	
+LOCAL_D SCapKeyTestParams capKeyTests[]={
+	{(TText *)_S("Press q"),2,'q',EModifierFunc|EModifierCtrl|EModifierShift,0},
+	//{(TText *)_S("Press <Alt>q"),2,'q',EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc},
+	{(TText *)_S("Press <Alt>w"),2,'w',EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc},
+	{(TText *)_S("Press a"),0,'a',0},
+	//{(TText *)_S("Press <Ctrl><Alt>a"),1,1,EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc|EModifierCtrl},
+	{(TText *)_S("Press <Ctrl><Alt>s"),1,19,EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc|EModifierCtrl},
+	//{(TText *)_S("Press <Alt>b"),2,'b',EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc},
+	{(TText *)_S("Press <Alt>n"),2,'n',EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc},
+	{(TText *)_S("Press <Ctrl><Alt>b"),0,2,EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc|EModifierCtrl},
+	//{(TText *)_S("Press <Alt>c"),0,'c',EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc},
+	{(TText *)_S("Press <Alt>d"),0,'d',EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc},
+	{(TText *)_S("Press <Ctrl><Alt>c"),0,3,EModifierFunc|EModifierCtrl|EModifierShift,EModifierFunc|EModifierCtrl},
+//
+// Capture ups and downs
+//
+	{(TText *)_S("Press <Space>"),2,EStdKeySpace,EModifierFunc|EModifierCtrl|EModifierShift,0},
+	{(TText *)_S("Press <Enter>"),0,EStdKeyEnter,EModifierShift,0},
+	{(TText *)_S("Press <Shift><Space>"),0,EStdKeySpace,EModifierFunc|EModifierCtrl|EModifierShift,EModifierShift},
+	{(TText *)_S("Press <Shift><Enter>"),2,EStdKeyEnter,EModifierShift,EModifierShift},
+//
+// Priority keys
+//
+	{(TText *)_S("Press <Ctrl>c"),0,0,0,0},
+	{(TText *)_S("Press <Ctrl>d"),0,0,0,0},
+	{(TText *)_S("Press z"),0,0,0,0},
+	};
+
+LOCAL_D SAbortKeyTests abortKeyTests[]={
+	{3,EModifierCtrl,EModifierCtrl},
+	{4,EModifierCtrl,EModifierCtrl},
+	{'z',EModifierFunc|EModifierCtrl|EModifierShift,0}
+	};
+
+struct SErrorCapKey
+	{
+	TInt keyCode;
+	TUint modifier_mask;
+	TUint modifiers;
+	};
+
+LOCAL_D SErrorCapKey errorKeys[]={
+	{'a',EModifierFunc|EModifierShift,EModifierFunc|EModifierCtrl},
+	{'1',0,EModifierFunc},
+	{3,EModifierCtrl,EModifierCtrl|EModifierShift},
+	};
+
+const TInt numCapKeys=sizeof(capKeys)/sizeof(capKeys[0]);
+const TInt numTests=sizeof(capKeyTests)/sizeof(capKeyTests[0]);
+const TInt numErrorKeys=sizeof(errorKeys)/sizeof(errorKeys[0]);
+const TInt numAbortKeyTests=sizeof(abortKeyTests)/sizeof(abortKeyTests[0]);
+const TInt numUpDownKeys=sizeof(capUpAndDownKeys)/sizeof(capUpAndDownKeys[0]);
+const TInt numUpDownKeyTests=4;
+const TInt numCapKeyTests=numTests-numAbortKeyTests-numUpDownKeyTests;
+
+LOCAL_D TInt capKeyHandle[numCapKeys];
+LOCAL_D TInt capUpDownKeyHandle[numUpDownKeys];
+
+class CCKWindow;
+class TCaptureKeyTest;
+class CCKAbortConnection;
+
+class CCKConnectionBase : public CTClient
+	{
+public:
+	CCKConnectionBase(TCaptureKeyTest *aTest);
+	void ConstructL();
+protected:
+	TCaptureKeyTest *iTest;
+	};
+
+class CCKConnection : public CCKConnectionBase
+	{
+public:
+	CCKConnection(TCaptureKeyTest *aTest, TInt aConnIndex);
+	~CCKConnection();
+	void ConstructL();
+	void CheckKeyL(const SCapKeyTestParams &aKeyTest, const TKeyEvent &aKey);
+	void SubStateChanged();
+	void KeyTestL(TInt aBool);
+	void KeyL(const TKeyEvent &aKey,const TTime &aTime);
+	void CheckUpDownL(const SCapKeyTestParams &aKeyTest, const TKeyEvent &aKey);
+	void CheckUpDownL(const TKeyEvent &aKey);
+	inline TInt Index() {return iConnIndex;}
+protected:
+	TInt iConnIndex;
+	CCKWindow *iWin;
+	};
+
+class CAbortHandler : public CTEventBase
+	{
+public:
+	CAbortHandler(RWsSession *aWs, CCKAbortConnection *aConnection);
+	~CAbortHandler();
+	void Request();
+protected:
+	void DoCancel();
+	void doRunL();
+protected:
+	CCKAbortConnection *iConnection;
+	};
+
+class CCKAbortConnection : public CCKConnectionBase
+	{
+public:
+	CCKAbortConnection(TCaptureKeyTest *aTest);
+	~CCKAbortConnection();
+	void ConstructL();
+	void ReceivedAbortEventL(TInt aHandle, TKeyEvent *aKey);
+	void Foreground();
+protected:
+	CAbortHandler *iAbortHandler;
+	TInt iAbortKeyIndex;
+	};
+
+class CCKWindow : public CTWin
+	{
+public:
+	CCKWindow(TCaptureKeyTest *aTest, TInt aConnIndex);
+	void SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc);
+	void Draw();
+protected:
+	TInt iConnIndex;
+	TCaptureKeyTest *iTest;
+	TRgb iBack;
+	};
+
+class CCKWindowGroup : public CTWindowGroup
+	{
+public:
+	CCKWindowGroup(CTClient *aClient, TCaptureKeyTest *aTest);
+	void KeyL(const TKeyEvent &aKey,const TTime &aTime);
+	void KeyDownL(const TKeyEvent &aKey,const TTime &);
+	void KeyUpL(const TKeyEvent &aKey,const TTime &);
+	void CheckUpDown(const SCapKeyTestParams &aKeyTest, const TKeyEvent &aKey);
+private:
+	TCaptureKeyTest *iTest;
+	};
+
+class TCaptureKeyTest : public CTestBase
+	{
+public:
+	TCaptureKeyTest();
+	~TCaptureKeyTest();
+	TestState DoTestL();
+	void ConstructL();
+	void EndCaptureKeyTest();
+	TInt SubState() const;
+	void IncSubState();
+	void BadParamsL();
+	void CapKeyPurgingL();
+	void SetUpPriorityKeyTest();
+	void TestComplete();
+	void CaptureUpsAndDownsTest();
+	TTestMode Mode();
+	void SetMode(TTestMode aMode);
+private:
+	CCKConnection *iConn1;
+	CCKConnection *iConn2;
+	CCKConnection *iConn3;
+	CCKAbortConnection *iAbortConn;
+	TSize iWinSize;
+	TInt iState;
+	TInt iSubState;
+	TTestMode iMode;
+	};
+
+GLDEF_C CTestBase *CreateMultiCaptureKeyTest()
+	{
+	return(new(ELeave) TCaptureKeyTest());
+	}
+
+//
+// CAbortHandler
+
+CAbortHandler::CAbortHandler(RWsSession *aWs, CCKAbortConnection *aConnection) : CTEventBase(aWs, 10), iConnection(aConnection)
+	{
+	}
+
+CAbortHandler::~CAbortHandler()
+	{
+	Cancel();
+	}
+
+void CAbortHandler::Request()
+	{
+	iWs->PriorityKeyReady(&iStatus);
+	SetActive();
+	}
+
+void CAbortHandler::DoCancel()
+	{
+	iWs->PriorityKeyReadyCancel();
+	}
+
+void CAbortHandler::doRunL()
+	{
+	TWsPriorityKeyEvent abortEvent;
+	iWs->GetPriorityKey(abortEvent);
+	iConnection->ReceivedAbortEventL(abortEvent.Handle(),abortEvent.Key());
+	}
+
+//
+// CCKConnection
+
+CCKConnectionBase::CCKConnectionBase(TCaptureKeyTest *aTest) : iTest(aTest)
+	{
+	}
+
+void CCKConnectionBase::ConstructL()
+	{
+	CTClient::ConstructL();
+	iGroup=new(ELeave) CCKWindowGroup(this, iTest);
+	iGroup->ConstructL();
+	}
+
+CCKConnection::CCKConnection(TCaptureKeyTest *aTest, TInt aConnIndex) : CCKConnectionBase(aTest), iConnIndex(aConnIndex)
+	{
+	}
+
+CCKConnection::~CCKConnection()
+	{
+	for(TInt index=0;index<numCapKeys;index++)
+		if (capKeys[index].connIndex==iConnIndex)
+			iGroup->GroupWin()->CancelCaptureKey(capKeyHandle[index]);
+	for(TInt index2=0;index2<numUpDownKeys;index2++)
+		if (capUpAndDownKeys[index2].connIndex==iConnIndex)
+			iGroup->GroupWin()->CancelCaptureKeyUpAndDowns(capUpDownKeyHandle[index2]);
+	CTWin::Delete(iWin);
+	}
+
+void CCKConnection::SubStateChanged()
+	{
+	iWin->Invalidate();
+	iWs.Flush();
+	}
+
+void CCKConnection::ConstructL()
+	{
+	CCKConnectionBase::ConstructL();
+	for(TInt index=0;index<numCapKeys;index++)
+		if (capKeys[index].connIndex==iConnIndex)
+			capKeyHandle[index]=User::LeaveIfError(iGroup->GroupWin()->CaptureKey(capKeys[index].keyCode,capKeys[index].modifier_mask,capKeys[index].modifiers));
+	for(TInt index2=0;index2<numUpDownKeys;index2++)
+		if (capUpAndDownKeys[index2].connIndex==iConnIndex)
+			capUpDownKeyHandle[index2]=User::LeaveIfError(iGroup->GroupWin()->CaptureKeyUpAndDowns(capUpAndDownKeys[index2].keyCode,
+								capUpAndDownKeys[index2].modifier_mask,capUpAndDownKeys[index2].modifiers));
+	TSize screenSize=iGroup->Size();
+	TInt winWidth=screenSize.iWidth/2;
+	TInt winHeight=screenSize.iHeight-10;
+	iGroup->GroupWin()->AutoForeground(EFalse);		// Don't allow clicking to cause foreground, might mess up test
+	CCKWindow *win=new(ELeave) CCKWindow(iTest, iConnIndex);
+	win->SetUpL(TPoint(5,5),TSize(winWidth,winHeight),iGroup,*iGc);
+	iWin=win;
+	}
+
+void CCKConnection::KeyTestL(TInt aBool)
+	{
+	if (!aBool)
+		{
+		CTDialog *dialog=new(ELeave) CTDialog();
+		TInt ret=0;
+		dialog->ConstructLD(*iGroup,*iGc);
+		dialog->SetTitle(_L("Invalid key press"));
+		dialog->SetLine1(_L("Try again?"));
+		dialog->SetNumButtons(2);
+		dialog->SetButtonText(0,_L("Fail"));
+		dialog->SetButtonText(1,_L("Retry"));
+		ret=dialog->Display();
+		User::Leave(ret==1 ? ECapKeyRetry : ECapKeyFail);
+		}
+	}
+
+void CCKConnection::CheckKeyL(const SCapKeyTestParams &aKeyTest, const TKeyEvent &aKey)
+	{
+	KeyTestL(aKeyTest.connIndex==iConnIndex);
+	KeyTestL(aKeyTest.keyCode==aKey.iCode);
+	KeyTestL(aKeyTest.modifiers==(aKey.iModifiers&aKeyTest.modifier_mask));
+	}
+
+void CCKConnection::CheckUpDownL(const SCapKeyTestParams &aKeyTest, const TKeyEvent &aKey)
+	{
+	KeyTestL(aKeyTest.connIndex==iConnIndex);
+	KeyTestL(aKeyTest.keyCode==(TUint)aKey.iScanCode);
+	KeyTestL(aKeyTest.modifiers==(aKey.iModifiers&aKeyTest.modifier_mask));
+	}
+
+void CCKConnection::KeyL(const TKeyEvent &aKey,const TTime &)
+	{
+	if (iTest->Mode()==EModeNormalCapture)
+		{
+		if (aKey.iCode==EKeyEscape)
+			iTest->AbortL();
+		TRAPD(ret,CheckKeyL(capKeyTests[iTest->SubState()],aKey));
+		if (ret==ECapKeyOkay)
+			iTest->IncSubState();
+		else
+			iTest->TestL(ret==ECapKeyRetry);
+		}
+	}
+
+void CCKConnection::CheckUpDownL(const TKeyEvent &aKey)
+	{
+	CheckUpDownL(capKeyTests[iTest->SubState()],aKey);
+	}
+
+CCKAbortConnection::CCKAbortConnection(TCaptureKeyTest *aTest) : CCKConnectionBase(aTest)
+	{
+	}
+
+CCKAbortConnection::~CCKAbortConnection()
+	{
+	iGroup->GroupWin()->RemovePriorityKey(3,EModifierCtrl,EModifierCtrl);
+	delete iAbortHandler;
+	}
+
+void CCKAbortConnection::ConstructL()
+	{
+	CCKConnectionBase::ConstructL();
+	User::LeaveIfError(iGroup->GroupWin()->AddPriorityKey(abortKeyTests[0].keyCode,abortKeyTests[0].modifier_mask,abortKeyTests[0].modifiers));
+	User::LeaveIfError(iGroup->GroupWin()->AddPriorityKey(abortKeyTests[1].keyCode,abortKeyTests[1].modifier_mask,abortKeyTests[1].modifiers));
+	User::LeaveIfError(iGroup->GroupWin()->AddPriorityKey(abortKeyTests[2].keyCode,abortKeyTests[2].modifier_mask,abortKeyTests[2].modifiers));
+	iAbortHandler=new(ELeave) CAbortHandler(&iWs, this);
+	iAbortHandler->Construct();
+	iWs.Flush();
+	}
+
+void CCKAbortConnection::ReceivedAbortEventL(TInt aHandle, TKeyEvent *aKey)
+	{
+	iTest->TestL(aHandle==(TInt)iGroup);
+	iTest->TestL(aKey->iCode==abortKeyTests[iAbortKeyIndex].keyCode);
+	iTest->TestL((aKey->iModifiers&abortKeyTests[iAbortKeyIndex].modifier_mask)==abortKeyTests[iAbortKeyIndex].modifiers);
+	iAbortKeyIndex++;
+	iTest->IncSubState();
+	}
+
+void CCKAbortConnection::Foreground()
+	{
+	iGroup->GroupWin()->SetOrdinalPosition(0);
+	iWs.Flush();
+	}
+
+//
+// CCKWindowGroup class //
+//
+
+CCKWindowGroup::CCKWindowGroup(CTClient *aClient, TCaptureKeyTest *aTest) : CTWindowGroup(aClient), iTest(aTest)
+	{}
+
+void CCKWindowGroup::KeyL(const TKeyEvent &aKey,const TTime &time)
+	{
+	/*TLogMessageText buf(_S("##Recieved Key: "));
+	buf.Append(aKey.iScanCode);
+	buf.Append('(');
+	buf.AppendNum(aKey.iScanCode);
+	buf.Append(')');
+	if (!iCurWin)
+		{
+		buf.Append('(');
+		buf.AppendNum(((CCKConnection *)iClient)->Index());
+		buf.Append(')');
+		}
+	iClient->iWs.LogMessage(buf);*/
+	if (iCurWin)
+		iCurWin->WinKeyL(aKey,time);
+	else
+		((CCKConnection *)iClient)->KeyL(aKey,time);
+	}
+
+void CCKWindowGroup::KeyDownL(const TKeyEvent &aKey,const TTime &)
+	{
+	if (aKey.iScanCode!=EStdKeyLeftShift && aKey.iScanCode!=EStdKeyRightShift)
+		{
+		if (iTest->Mode()==EModeWaitingForFirstDown)
+			iTest->SetMode(EModeKeyUpsAndDowns);
+		if (iTest->Mode()==EModeKeyUpsAndDowns)
+			((CCKConnection *)iClient)->CheckUpDownL(aKey);
+		}
+	}
+
+void CCKWindowGroup::KeyUpL(const TKeyEvent &aKey,const TTime &)
+	{
+	if (aKey.iScanCode!=EStdKeyLeftShift && aKey.iScanCode!=EStdKeyRightShift)
+		{
+		if (iTest->Mode()==EModeKeyUpsAndDowns)
+			{
+			((CCKConnection *)iClient)->CheckUpDownL(aKey);
+			iTest->IncSubState();
+			}
+		}
+	}
+
+//
+// CCKWindow, class //
+//
+
+CCKWindow::CCKWindow(TCaptureKeyTest *aTest, TInt aConnIndex) : CTWin(), iConnIndex(aConnIndex), iTest(aTest)
+	{
+	iBack=TRgb::Gray256(230);
+	}
+
+void CCKWindow::SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc)
+	{
+	ConstructExtLD(*parent,pos,size);
+	iWin.SetBackgroundColor(iBack);
+	Activate();
+	AssignGC(aGc);
+	}
+
+void CCKWindow::Draw()
+	{
+	iGc->Clear();
+	if (iConnIndex==0)
+		iGc->DrawText(TPtrC(capKeyTests[iTest->SubState()].txt), TPoint(10,20));
+	}
+
+//
+
+TCaptureKeyTest::TCaptureKeyTest() : CTestBase(_L("Capture Key"))
+	{}
+
+TCaptureKeyTest::~TCaptureKeyTest()
+	{
+	delete iConn1;
+	delete iConn2;
+	delete iConn3;
+	delete iAbortConn;
+	}
+
+void TCaptureKeyTest::ConstructL()
+	{
+	iAbortConn=new(ELeave) CCKAbortConnection(this);
+	iAbortConn->ConstructL();
+	iConn3=new(ELeave) CCKConnection(this,2);
+	iConn3->ConstructL();
+	iConn2=new(ELeave) CCKConnection(this,1);
+	iConn2->ConstructL();
+	iConn1=new(ELeave) CCKConnection(this,0);
+	iConn1->ConstructL();
+	iMode=EModeNormalCapture;
+	}
+
+TInt TCaptureKeyTest::SubState() const
+	{
+	return(iSubState);
+	}
+
+void TCaptureKeyTest::IncSubState()
+	{
+	iSubState++;
+	iConn1->SubStateChanged();
+	iConn2->SubStateChanged();
+	iConn3->SubStateChanged();
+	switch(iMode)
+		{
+		case EModeNormalCapture:
+			if (iSubState==numCapKeyTests)
+				TestComplete();
+			break;
+		case EModeKeyUpsAndDowns:
+			if (iSubState==(numCapKeyTests+numUpDownKeyTests))
+				TestComplete();
+			break;
+		case EModeAbortKeys:
+			if (iSubState==(numCapKeyTests+numUpDownKeyTests+numAbortKeyTests))
+				TestComplete();
+			break;
+		default:
+			break;
+		}
+	}
+
+void TCaptureKeyTest::CapKeyPurgingL()
+	{
+	TInt base=Client()->iWs.ResourceCount();
+	RWindowGroup groupWin(Client()->iWs);
+	User::LeaveIfError(groupWin.Construct(ENullWsHandle));
+	TInt capHandle=User::LeaveIfError(groupWin.CaptureKey('a',EModifierFunc,EModifierFunc));
+	User::LeaveIfError(groupWin.CaptureKey('b',EModifierFunc,EModifierFunc));
+	TestL(Client()->iWs.ResourceCount()==(base+3));
+	groupWin.CancelCaptureKey(capHandle);
+	TestL(Client()->iWs.ResourceCount()==(base+2));
+	groupWin.Close();
+	TestL(Client()->iWs.ResourceCount()==base);		// Check it also freed the extra capture key
+	}
+
+void TCaptureKeyTest::BadParamsL()
+	{
+	TInt resCount=Client()->iWs.ResourceCount();
+	for(TInt index=0;index<numErrorKeys;index++)
+		TestL(Client()->iGroup->GroupWin()->CaptureKey(errorKeys[index].keyCode,errorKeys[index].modifier_mask,errorKeys[index].modifiers)==KErrArgument);
+	TestL(Client()->iWs.ResourceCount()==resCount);
+	}
+
+void TCaptureKeyTest::TestComplete()
+	{
+	Request();
+	}
+
+void TCaptureKeyTest::SetMode(TTestMode aMode)
+	{
+	iMode=aMode;
+	}
+
+TTestMode TCaptureKeyTest::Mode()
+	{
+	return(iMode);
+	}
+
+void TCaptureKeyTest::SetUpPriorityKeyTest()
+	{
+	iMode=EModeAbortKeys;
+	iAbortConn->Foreground();
+	}
+
+void TCaptureKeyTest::CaptureUpsAndDownsTest()
+	{
+	iMode=EModeWaitingForFirstDown;
+	}
+
+TestState TCaptureKeyTest::DoTestL()
+	{
+	switch(iState)
+		{
+		case 0:	// Dummy one to let capture key tests run
+			iState++;
+			return(EContinue);
+		case 1:
+			LogSubTest(_L("Capture ups and downs"),1);
+			CaptureUpsAndDownsTest();
+			iState++;
+			return(EContinue);
+		case 2:
+			LogSubTest(_L("Abort key"),1);
+			SetUpPriorityKeyTest();
+			iState++;
+			return(EContinue);
+		case 3:
+			LogSubTest(_L("Errors"),1);
+			BadParamsL();
+			CapKeyPurgingL();
+			LogSubTest(_L("CaptureKey"),1);
+			iState++;
+			return(ENext);
+		default:
+			return(EFinished);
+		}
+//	return(ENext);
+ 	}