1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/graphics/windowing/windowserver/test/tcapability/TCapTest.CPP Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,745 @@
1.4 +// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +// Automatically test the window server capabilities.
1.18 +//
1.19 +//
1.20 +
1.21 +#include <e32std.h>
1.22 +#include "W32STD.H"
1.23 +#include "../../SERVER/w32cmd.h"
1.24 +#include <e32svr.h>
1.25 +#include <bacline.h>
1.26 +#include <hal.h>
1.27 +
1.28 +typedef TInt (*TPanicFunction)(TInt aInt,TDes& capability,TInt aExternalGroupId);
1.29 +LOCAL_D const TUint KPanicThreadHeapSize=0x2000;
1.30 +#define EWindowGroupHandle 1234
1.31 +#define EWindowGroupHandle2 4567
1.32 +_LIT(KCAPABILITY_ALL,"CAPABILITY_ALL");
1.33 +_LIT(KCAPABILITY_NONE,"CAPABILITY_NONE");
1.34 +_LIT(KWRITEDATA_SWEVENT,"WRITEDATA+SWEVENT");
1.35 +_LIT(KWRITEDATA_POWERMGMT,"WRITEDATA+POWERMGMT");
1.36 +_LIT(KPOWERMGMT_SWEVENT,"POWERMGMT+SWEVENT");
1.37 +_LIT(KSetOrdinalPositionPri,"EWsWinOpSetOrdinalPositionPri Capability Check");
1.38 +_LIT(KSetOrdinalPositionErr,"EWsWinOpSetOrdinalPositionErr Capability Check");
1.39 +TLogMessageText LogMessageText;
1.40 +
1.41 +//Enum for indicating which capability is checked.
1.42 +enum TTestCapability
1.43 + {
1.44 + EWriteDeviceData,
1.45 + ESwEvent,
1.46 + EPowerMgmt,
1.47 + EDoNotTest,
1.48 + ENoCapReq,
1.49 + EEikSrvSID,
1.50 + ESwEventPri,
1.51 + ENoSwEventPri,
1.52 + ENoSwEventPriSmallOrdinal,
1.53 + ESwEventErr,
1.54 + ENoSwEventErr,
1.55 + ENoSwEventErrSmallOrdinal,
1.56 + };
1.57 +
1.58 +//Enum for test exit reasons
1.59 +enum TTestState
1.60 + {
1.61 + EWsExitReasonBad,
1.62 + EWsTestNext,
1.63 + EWsTestFinished,
1.64 + };
1.65 +
1.66 +
1.67 +TTestCapability gTheTestCapability;
1.68 +TInt gTestState=KErrNone;
1.69 +
1.70 +
1.71 +//Panics if EWsExitReasonBad
1.72 +enum TAutoPanics
1.73 + {
1.74 + EAutoPanicPanicFailed,
1.75 + };
1.76 +
1.77 +//Thread function structure
1.78 +struct SPanicParams
1.79 + {
1.80 + TInt num;
1.81 + TPanicFunction func;
1.82 + TBuf<256> capability;
1.83 + TInt externalGroupId;
1.84 + };
1.85 +
1.86 +class CTestBase
1.87 + {
1.88 +public:
1.89 + CTestBase();
1.90 + ~CTestBase();
1.91 + void ConstructL(const TDes* aCapabilityTest);
1.92 + TInt TestWsPanicL(TPanicFunction aFunction, TInt aInt, const TDes& aCommandLine);
1.93 + void UpdateLogsL();
1.94 +private :
1.95 + TInt TestPanicL(SPanicParams* aPtr);
1.96 + TInt LaunchPanicThread(RThread& aThread, SPanicParams* aPtr);
1.97 + void Test(TInt aCondition);
1.98 +private :
1.99 + TInt iThreadNumber;
1.100 + RWsSession iWs;
1.101 + TBuf<256> iCapabilityTest;
1.102 + TInt iTestCount;
1.103 + TInt iTestPass;
1.104 + };
1.105 +
1.106 +//RWsSession derived class to test the EWservMessShutdown message
1.107 +class RShellWsSession : public RWsSession
1.108 + {
1.109 +public:
1.110 + void ShutDown();
1.111 + };
1.112 +
1.113 +void RShellWsSession::ShutDown()
1.114 + {
1.115 + SendReceive(EWservMessShutdown,TIpcArgs(EWservShutdownCheck));
1.116 + }
1.117 +
1.118 +LOCAL_C TInt PanicThreadFunc(TAny* aPtr)
1.119 + {
1.120 + CTrapCleanup* CleanUpStack=CTrapCleanup::New();
1.121 + SPanicParams* ptr=(SPanicParams*)aPtr;
1.122 + TInt ret;
1.123 + TRAP(ret,ret=(*ptr->func)(ptr->num,ptr->capability,ptr->externalGroupId));
1.124 + delete CleanUpStack;
1.125 + if (ret==EWsExitReasonBad)
1.126 + {
1.127 + User::Panic(_L("Auto"),EAutoPanicPanicFailed);
1.128 + }
1.129 + return(ret);
1.130 + }
1.131 +
1.132 +CTestBase::CTestBase()
1.133 + {
1.134 + }
1.135 +
1.136 +CTestBase::~CTestBase()
1.137 + {
1.138 + iWs.Close();
1.139 + }
1.140 +
1.141 +void CTestBase::ConstructL(const TDes* aCapabilityTest)
1.142 + {
1.143 + iTestCount=iTestPass=0;
1.144 + iWs.Connect();
1.145 + TLex lex(*aCapabilityTest);
1.146 + TPtrC capability = lex.NextToken();
1.147 + iCapabilityTest.Append(capability);
1.148 + }
1.149 +
1.150 +TInt CTestBase::LaunchPanicThread(RThread& aThread, SPanicParams* aPtr)
1.151 + {
1.152 + TBuf<32> threadName;
1.153 + _LIT(KPanicThread, "AutoPanicThread%d");
1.154 + threadName.AppendFormat(KPanicThread,iThreadNumber++);
1.155 + return(aThread.Create(threadName,PanicThreadFunc,KDefaultStackSize,KPanicThreadHeapSize,KPanicThreadHeapSize,aPtr,EOwnerThread));
1.156 + }
1.157 +
1.158 +TInt CTestBase::TestPanicL(SPanicParams* aPtr)
1.159 + {
1.160 + RThread thread;
1.161 + TRequestStatus stat;
1.162 + TInt err=LaunchPanicThread(thread, aPtr);
1.163 + if (err==KErrAlreadyExists)
1.164 + {
1.165 + // wait for kernel to clear up old threads
1.166 + // and have several attempts at starting the thread
1.167 + // if unsuccessful the first time
1.168 + for (TInt i=0;i<3;i++)
1.169 + {
1.170 + User::After(TTimeIntervalMicroSeconds32(100000)); //0.1 secs
1.171 + err=LaunchPanicThread(thread, aPtr);
1.172 + if (err!=KErrAlreadyExists)
1.173 + {
1.174 + break;
1.175 + }
1.176 + }
1.177 + }
1.178 + User::LeaveIfError(err);
1.179 + thread.Logon(stat);
1.180 + User::SetJustInTime(EFalse);
1.181 + thread.Resume();
1.182 + User::WaitForRequest(stat);
1.183 + User::SetJustInTime(ETrue);
1.184 + TInt threadExit=thread.ExitReason();
1.185 + if (threadExit!=EWsTestFinished)
1.186 + {
1.187 + if (gTheTestCapability==ENoCapReq)
1.188 + {
1.189 + Test(threadExit==KErrNone);
1.190 + }
1.191 + else if(gTheTestCapability==EEikSrvSID)
1.192 + {
1.193 + Test(threadExit==KErrPermissionDenied);
1.194 + }
1.195 + else if(!iCapabilityTest.Compare(KCAPABILITY_ALL))
1.196 + {
1.197 + if(gTheTestCapability!=EDoNotTest)
1.198 + {
1.199 + iTestCount++;
1.200 + if(gTheTestCapability==ESwEventPri)
1.201 + {
1.202 + Test(threadExit==KPasswordWindowGroupPriority);
1.203 + }
1.204 + else
1.205 + {
1.206 + Test(threadExit==KErrNone);
1.207 + }
1.208 + }
1.209 + }
1.210 + else if(!iCapabilityTest.Compare(KCAPABILITY_NONE))
1.211 + {
1.212 + if(gTheTestCapability!=EDoNotTest)
1.213 + {
1.214 + iTestCount++;
1.215 + if((gTheTestCapability==ENoSwEventPriSmallOrdinal)||(gTheTestCapability==ENoSwEventPri))
1.216 + {
1.217 + Test(threadExit==KPasswordWindowGroupPriority-1);
1.218 + }
1.219 + else if(gTheTestCapability==ENoSwEventErrSmallOrdinal)
1.220 + {
1.221 + Test(threadExit==KErrNone);
1.222 + }
1.223 + else if(gTheTestCapability==ENoSwEventErr)
1.224 + {
1.225 + Test(threadExit==KErrPermissionDenied);
1.226 + }
1.227 + else
1.228 + {
1.229 + Test((threadExit==EWservPanicPermissionDenied)||(threadExit==KErrPermissionDenied));
1.230 + }
1.231 + }
1.232 + }
1.233 + else if(!iCapabilityTest.Compare(KWRITEDATA_SWEVENT))
1.234 + {
1.235 + if(gTheTestCapability==EWriteDeviceData || gTheTestCapability==ESwEvent)
1.236 + {
1.237 + iTestCount++;
1.238 + Test(threadExit==KErrNone);
1.239 + }
1.240 + if(gTheTestCapability==EPowerMgmt)
1.241 + {
1.242 + iTestCount++;
1.243 + Test((threadExit==EWservPanicPermissionDenied)||(threadExit==KErrPermissionDenied));
1.244 + }
1.245 + }
1.246 + else if(!iCapabilityTest.Compare(KWRITEDATA_POWERMGMT))
1.247 + {
1.248 + if(gTheTestCapability==EWriteDeviceData || gTheTestCapability==EPowerMgmt)
1.249 + {
1.250 + iTestCount++;
1.251 + Test(threadExit==KErrNone);
1.252 + }
1.253 + if(gTheTestCapability==ESwEvent)
1.254 + {
1.255 + iTestCount++;
1.256 + Test((threadExit==EWservPanicPermissionDenied)||(threadExit==KErrPermissionDenied));
1.257 + }
1.258 + }
1.259 + else if(!iCapabilityTest.Compare(KPOWERMGMT_SWEVENT))
1.260 + {
1.261 + if(gTheTestCapability==EPowerMgmt || gTheTestCapability==ESwEvent)
1.262 + {
1.263 + iTestCount++;
1.264 + Test(threadExit==KErrNone);
1.265 + }
1.266 + if(gTheTestCapability==EWriteDeviceData)
1.267 + {
1.268 + iTestCount++;
1.269 + Test((threadExit==EWservPanicPermissionDenied)||(threadExit==KErrPermissionDenied));
1.270 + }
1.271 + }
1.272 + }
1.273 + thread.Close();
1.274 + return(threadExit);
1.275 + }
1.276 +
1.277 +TInt CTestBase::TestWsPanicL(TPanicFunction aFunction,TInt aTestNo, const TDes& aCommandLine)
1.278 + {
1.279 + TLex lex(aCommandLine);
1.280 + TPtrC capability = lex.NextToken();
1.281 + TPtrC idstr = lex.NextToken();
1.282 + lex = idstr;
1.283 + TInt id = 0;
1.284 + lex.Val(id);
1.285 +
1.286 + SPanicParams params;
1.287 + params.num=aTestNo;
1.288 + params.func=aFunction;
1.289 + params.capability.Copy(capability);
1.290 + params.externalGroupId = id;
1.291 + return TestPanicL(¶ms);
1.292 + }
1.293 +
1.294 +void CTestBase::Test(TInt aCondition)
1.295 + {
1.296 + if(!aCondition)
1.297 + {
1.298 + TLogMessageText buf;
1.299 + _LIT(Fail,"AUTO Failed in Capability Test : ");
1.300 + buf.Append(Fail);
1.301 + buf.Append(iCapabilityTest);
1.302 + iWs.LogMessage(buf);
1.303 + iWs.Flush();
1.304 + }
1.305 + else
1.306 + {
1.307 + iTestPass++;
1.308 + }
1.309 + }
1.310 +
1.311 +void CTestBase::UpdateLogsL()
1.312 + {
1.313 + TBuf<256> testResult;
1.314 + RFs fileSession;
1.315 + RFile resultFile;
1.316 + User::LeaveIfError(fileSession.Connect());
1.317 + CleanupClosePushL(fileSession);
1.318 + resultFile.Replace(fileSession,_L("C:\\DATA\\TestResult.Dat"),EFileWrite);
1.319 + CleanupClosePushL(resultFile);
1.320 + TFileText fileText;
1.321 + fileText.Set(resultFile);
1.322 + testResult.Num(iTestCount);
1.323 + fileText.Write(testResult);
1.324 + testResult.Num(iTestPass);
1.325 + fileText.Write(testResult);
1.326 + resultFile.Close();
1.327 + fileSession.Close();
1.328 + CleanupStack::PopAndDestroy(&resultFile);
1.329 + CleanupStack::PopAndDestroy(&fileSession);
1.330 + }
1.331 +
1.332 +TInt TestCapability(TInt aTest, TDes& aCapability, TInt aExternalGroupId)
1.333 + {
1.334 + _LIT(KDllName,"CLICK");
1.335 + RWsSession ws;
1.336 + ws.Connect();
1.337 + CleanupClosePushL(ws);
1.338 + RWindowGroup gr1(ws);
1.339 + RWindowGroup gr2(ws);
1.340 + gr1.Construct(EWindowGroupHandle,EFalse);
1.341 + gr2.Construct(EWindowGroupHandle2,EFalse);
1.342 + CleanupClosePushL(gr1);
1.343 + CleanupClosePushL(gr2);
1.344 + TWsEvent event;
1.345 + RSoundPlugIn click1(ws);
1.346 + CWsScreenDevice *screenDevice;
1.347 + TRawEvent rawEvent;
1.348 + CPalette* defPalette=CPalette::NewDefaultL(EColor256);
1.349 + TInt ret=KErrNone;
1.350 + switch(aTest)
1.351 + {
1.352 + case 0:
1.353 + // ws.LogMessage(_L("EWsClOpSetKeyboardRepeatRate Capability Check"));
1.354 + gTheTestCapability=EWriteDeviceData;
1.355 + ret=ws.SetKeyboardRepeatRate(TTimeIntervalMicroSeconds32(1000000), TTimeIntervalMicroSeconds32(500000));
1.356 + ws.Flush();
1.357 + break;
1.358 + case 1:
1.359 + // ws.LogMessage(_L("EWsClOpSetDoubleClick Capability Check"));
1.360 + gTheTestCapability=EWriteDeviceData;
1.361 + ret=ws.SetDoubleClick(TTimeIntervalMicroSeconds32(900000),10);
1.362 + ws.Flush();
1.363 + break;
1.364 + case 2:
1.365 + // ws.LogMessage(_L("EWsClOpSendEventToWindowGroup (external group) Capability Check"));
1.366 + gTheTestCapability=ESwEvent;
1.367 + event.SetType(EEventModifiersChanged);
1.368 + ret=ws.SendEventToWindowGroup(aExternalGroupId,event);
1.369 + break;
1.370 + case 3:
1.371 + // ws.LogMessage(_L("EWsClOpSendEventToAllWindowGroup Capability Check"));
1.372 + gTheTestCapability=ESwEvent;
1.373 + event.SetType(EEventModifiersChanged);
1.374 + ret=ws.SendEventToAllWindowGroups(event);
1.375 + break;
1.376 + case 4:
1.377 + // ws.LogMessage(_L("EWsClOpSendEventToAllWindowGroupPriority Capability Check"));
1.378 + gTheTestCapability=ESwEvent;
1.379 + event.SetType(EEventModifiersChanged);
1.380 + gr1.SetOrdinalPosition(0,1);
1.381 + ret=ws.SendEventToAllWindowGroups(gr1.OrdinalPriority(),event);
1.382 + break;
1.383 + case 5:
1.384 + // ws.LogMessage(_L("EWsClOpSendEventToOneWindowGroupPerClient Capability Check"));
1.385 + gTheTestCapability=ESwEvent;
1.386 + event.SetType(EEventModifiersChanged);
1.387 + ret=ws.SendEventToOneWindowGroupsPerClient(event);
1.388 + break;
1.389 + case 6:
1.390 + // ws.LogMessage(_L("EWsClOpSendMessageToWindowGroup (external group) Capability Check"));
1.391 + gTheTestCapability=ESwEvent;
1.392 + ret=ws.SendMessageToWindowGroup(aExternalGroupId,TUid::Uid(123),_L8("SomeParams"));
1.393 + break;
1.394 + case 7:
1.395 + // ws.LogMessage(_L("EWsClOpClaimSystemPointerCursorList Capability Check"));
1.396 + gTheTestCapability=EWriteDeviceData;
1.397 + ret=ws.ClaimSystemPointerCursorList();
1.398 + //This may return KErrInUse if succeeds.
1.399 + if(ret==KErrInUse)
1.400 + {
1.401 + ret=KErrNone;
1.402 + }
1.403 + break;
1.404 + case 8:
1.405 + // ws.LogMessage(_L("EWsClOpSetClientCursorMode Capability Check"));
1.406 + gTheTestCapability=EWriteDeviceData;
1.407 + ret=ws.SetClientCursorMode(EPointerCursorNone);
1.408 + ws.Flush();
1.409 + break;
1.410 + case 9:
1.411 + //Check only if capability is not defined,since the windowgroup is not focused.
1.412 + if(aCapability.Compare(KCAPABILITY_ALL)&&aCapability.Compare(KWRITEDATA_POWERMGMT)&&aCapability.Compare(KWRITEDATA_SWEVENT))
1.413 + {
1.414 + // ws.LogMessage(_L("EWsClOpSetPointerCursorPosition Capability Check"));
1.415 + gTheTestCapability=EWriteDeviceData;
1.416 + ret=ws.SetPointerCursorPosition(TPoint(60,20));
1.417 + ws.Flush();
1.418 + }
1.419 + else
1.420 + {
1.421 + gTheTestCapability=EDoNotTest;
1.422 + }
1.423 + break;
1.424 + case 10:
1.425 + // ws.LogMessage(_L("EWsClOpSetModifierState Capability Check"));
1.426 + gTheTestCapability=EWriteDeviceData;
1.427 + ret=ws.SetModifierState(EModifierCapsLock,ETurnOnModifier);
1.428 + ret=ws.SetModifierState(EModifierCapsLock,ETurnOffModifier);
1.429 + ws.Flush();
1.430 + break;
1.431 + case 11:
1.432 + {
1.433 + // ws.LogMessage(_L("EWsClOpRawEvent Capability Check"));
1.434 + gTheTestCapability=ESwEvent;
1.435 + rawEvent.Set(TRawEvent::EActive);
1.436 + ws.SimulateRawEvent(rawEvent);
1.437 + ws.Flush();
1.438 + }
1.439 + break;
1.440 + case 12:
1.441 + {
1.442 + // ws.LogMessage(_L("EWsClOpKeyEvent Capability Check"));
1.443 + gTheTestCapability=ESwEvent;
1.444 + TKeyEvent keyEvent;
1.445 + keyEvent.iCode='J';
1.446 + keyEvent.iScanCode=0;
1.447 + keyEvent.iModifiers=EModifierAutorepeatable;
1.448 + keyEvent.iRepeats=0;
1.449 + ws.SimulateKeyEvent(keyEvent);
1.450 + ws.Flush();
1.451 + }
1.452 + break;
1.453 + case 13:
1.454 + // ws.LogMessage(_L("EWsClOpSendOffEventsToShell Capability Check"));
1.455 + gTheTestCapability=EPowerMgmt;
1.456 + ret=ws.RequestOffEvents(EFalse);
1.457 + break;
1.458 + case 14:
1.459 + // ws.LogMessage(_L("EWsClOpSetFaded Capability Check"));
1.460 + gTheTestCapability=EWriteDeviceData;
1.461 + ret=ws.SetSystemFaded(EFalse);
1.462 + break;
1.463 + case 15:
1.464 + //Since there is some problem in running the EWsClOpNoFlickerFree
1.465 + //code this test is not run if WriteDeviceData capability is defined.
1.466 + // ws.LogMessage(_L("EWsClOpNoFlickerFree Capability Check"));
1.467 + if(aCapability.Compare(KCAPABILITY_ALL)&&aCapability.Compare(KWRITEDATA_POWERMGMT)&&aCapability.Compare(KWRITEDATA_SWEVENT))
1.468 + {
1.469 + CWsScreenDevice* screen = new (ELeave) CWsScreenDevice(ws);
1.470 + gTheTestCapability=EWriteDeviceData;
1.471 + TInt err;
1.472 + if ((err=screen->Construct(0))!=KErrNone)
1.473 + {
1.474 + delete screen;
1.475 + User::Leave(err);
1.476 + }
1.477 + ws.TestWrite(ws.WsHandle(), EWsClOpNoFlickerFree, NULL, 0);
1.478 + ws.Flush();
1.479 + delete screen;
1.480 + }
1.481 + else
1.482 + {
1.483 + gTheTestCapability=EDoNotTest;
1.484 + }
1.485 + break;
1.486 + case 16:
1.487 + // ws.LogMessage(_L("EWsClOpSetFocusScreen Capability Check"));
1.488 + gTheTestCapability=EWriteDeviceData;
1.489 + ret=ws.SetFocusScreen(0);
1.490 + break;
1.491 + case 17:
1.492 + {
1.493 + //Check only if capability is not defined. Otherwise it will shut down the shell.
1.494 + if(aCapability.Compare(KCAPABILITY_ALL)&&aCapability.Compare(KWRITEDATA_POWERMGMT)&&aCapability.Compare(KPOWERMGMT_SWEVENT))
1.495 + {
1.496 + // ws.LogMessage(_L("EWservMessShutdown Capability Check"));
1.497 + gTheTestCapability=EPowerMgmt;
1.498 + RShellWsSession wsShell;
1.499 + wsShell.Connect();
1.500 + wsShell.ShutDown();
1.501 + }
1.502 + else
1.503 + {
1.504 + gTheTestCapability=EDoNotTest;
1.505 + }
1.506 + break;
1.507 + }
1.508 + case 18:
1.509 + // ws.LogMessage(_L("EWsWinOpCaptureKey Capability Check"));
1.510 + gTheTestCapability=ESwEvent;
1.511 + ret=gr2.CaptureKey('a',EModifierFunc,EModifierFunc);
1.512 + //If the function succeeds capability check,the ret value is handle identifying the capture key.
1.513 + if(ret>0)
1.514 + {
1.515 + ret=KErrNone;
1.516 + }
1.517 + break;
1.518 + case 19:
1.519 + // ws.LogMessage(_L("EWsWinOpCaptureKeyUpsAndDowns Capability Check"));
1.520 + gTheTestCapability=ESwEvent;
1.521 + ret=gr2.CaptureKeyUpAndDowns('a',0,0);
1.522 + //If the function succeeds capability check,the ret value is handle identifying the capture key.
1.523 + if(ret>0)
1.524 + {
1.525 + ret=KErrNone;
1.526 + }
1.527 + break;
1.528 + case 20:
1.529 + // ws.LogMessage(_L("EWsWinOpCaptureLongKey Capability Check"));
1.530 + gTheTestCapability=ESwEvent;
1.531 + ret=gr2.CaptureLongKey(EKeyEscape,'e',0,0,2,ELongCaptureNormal|ELongCaptureRepeatEvents);
1.532 + //If the function succeeds capability check,the ret value is handle identifying the capture key.
1.533 + if(ret>0)
1.534 + {
1.535 + ret=KErrNone;
1.536 + }
1.537 + break;
1.538 + case 21:
1.539 + // ws.LogMessage(_L("EWsClickOpLoad Capability Check"));
1.540 + gTheTestCapability=EWriteDeviceData;
1.541 + click1.Construct();
1.542 + CleanupClosePushL(click1);
1.543 + ret=click1.Load(KDllName);
1.544 + CleanupStack::PopAndDestroy(&click1);
1.545 + break;
1.546 + case 22:
1.547 + // ws.LogMessage(_L("EWsClickOpUnLoad Capability Check"));
1.548 + gTheTestCapability=EWriteDeviceData;
1.549 + click1.Construct();
1.550 + ret=click1.Unload();
1.551 + break;
1.552 + case 23:
1.553 + // ws.LogMessage(_L("EWsSdOpSetScreenMode Capability Check"));
1.554 + gTheTestCapability=EWriteDeviceData;
1.555 + screenDevice=new(ELeave) CWsScreenDevice(ws);
1.556 + CleanupStack::PushL(screenDevice);
1.557 + screenDevice->Construct(0);
1.558 + screenDevice->SetScreenMode(0);
1.559 + CleanupStack::PopAndDestroy(screenDevice);
1.560 + break;
1.561 + case 24:
1.562 + // ws.LogMessage(_L("EWsSdOpSetScreenModeEnforcement Capability Check"));
1.563 + gTheTestCapability=EWriteDeviceData;
1.564 + screenDevice=new(ELeave) CWsScreenDevice(ws);
1.565 + CleanupStack::PushL(screenDevice);
1.566 + screenDevice->Construct(0);
1.567 + screenDevice->SetScreenModeEnforcement(ESizeEnforcementNone);
1.568 + ws.Flush();
1.569 + CleanupStack::PopAndDestroy(screenDevice);
1.570 + break;
1.571 + case 25:
1.572 + {
1.573 + // ws.LogMessage(_L("EWsSdOpSetPalette Capability Check"));
1.574 + gTheTestCapability=EWriteDeviceData;
1.575 + screenDevice=new(ELeave) CWsScreenDevice(ws);
1.576 + CleanupStack::PushL(screenDevice);
1.577 + screenDevice->Construct(0);
1.578 + ret=screenDevice->SetCustomPalette(defPalette);
1.579 + //Returns KErrNotSupported if succeeds capability check.
1.580 + if(ret==KErrNotSupported)
1.581 + {
1.582 + ret=KErrNone;
1.583 + }
1.584 + CleanupStack::PopAndDestroy(screenDevice);
1.585 + }
1.586 + break;
1.587 + case 26:
1.588 + {
1.589 + //Checking the capability for SetHotKeys
1.590 + // ws.LogMessage(_L("EWsClOpSetHotKey Capability Check"));
1.591 + gTheTestCapability=ESwEvent;
1.592 + ret=ws.SetHotKey(EHotKeyEnableLogging,'e',EModifierFunc|EModifierCtrl|EModifierShift,0);
1.593 + ws.Flush();
1.594 + }
1.595 + break;
1.596 + case 27:
1.597 + {
1.598 + //Checking the capability for ClearHotKeys
1.599 + // ws.LogMessage(_L("EWsClOpClearHotKeys Capability Check"));
1.600 + gTheTestCapability=ESwEvent;
1.601 + ret=ws.ClearHotKeys(EHotKeyEnableLogging);
1.602 + ws.Flush();
1.603 + }
1.604 + break;
1.605 + case 28:
1.606 + // ws.LogMessage(_L("EWsClOpSendEventToWindowGroup (own group) Capability Check"));
1.607 + gTheTestCapability=ENoCapReq;
1.608 + event.SetType(EEventModifiersChanged);
1.609 + ret=ws.SendEventToWindowGroup(gr1.Identifier(),event);
1.610 + break;
1.611 + case 29:
1.612 + // ws.LogMessage(_L("EWsClOpSendMessageToWindowGroup (own group) Capability Check"));
1.613 + gTheTestCapability=ENoCapReq;
1.614 + ret=ws.SendMessageToWindowGroup(gr1.Identifier(),TUid::Uid(123),_L8("SomeParams"));
1.615 + break;
1.616 + case 30:
1.617 + // ws.LogMessage(_L("EWsClOpSetBackLight Capability Check"));
1.618 + gTheTestCapability=EEikSrvSID;
1.619 + screenDevice=new(ELeave) CWsScreenDevice(ws);
1.620 + CleanupStack::PushL(screenDevice);
1.621 + screenDevice->Construct(0);
1.622 + ret=screenDevice->SetBackLight(ETrue); //Always returns KErrPermissionDenied.
1.623 + CleanupStack::PopAndDestroy(screenDevice);
1.624 + break;
1.625 + case 31:
1.626 + {
1.627 + TBool test=EFalse;
1.628 + if(!aCapability.Compare(KCAPABILITY_ALL))
1.629 + {
1.630 + gTheTestCapability=ESwEventPri;
1.631 + test=ETrue;
1.632 + }
1.633 + else if(!aCapability.Compare(KCAPABILITY_NONE))
1.634 + {
1.635 + gTheTestCapability=ENoSwEventPri;
1.636 + test=ETrue;
1.637 + }
1.638 + else
1.639 + {
1.640 + gTheTestCapability=EDoNotTest;
1.641 + }
1.642 + if(test)
1.643 + {
1.644 + LogMessageText.Format(KSetOrdinalPositionPri);
1.645 + ws.LogMessage(LogMessageText);
1.646 + gr1.SetOrdinalPosition(0,KPasswordWindowGroupPriority);
1.647 + ret=ws.GetWindowGroupOrdinalPriority(gr1.Identifier());
1.648 + }
1.649 + }
1.650 + break;
1.651 + case 32:
1.652 + if(!aCapability.Compare(KCAPABILITY_NONE))
1.653 + {
1.654 + LogMessageText.Format(KSetOrdinalPositionPri);
1.655 + ws.LogMessage(LogMessageText);
1.656 + gTheTestCapability=ENoSwEventPriSmallOrdinal;
1.657 + gr1.SetOrdinalPosition(0,KPasswordWindowGroupPriority-1);
1.658 + ret=ws.GetWindowGroupOrdinalPriority(gr1.Identifier());
1.659 + }
1.660 + else
1.661 + {
1.662 + gTheTestCapability=EDoNotTest;
1.663 + }
1.664 + break;
1.665 + case 33:
1.666 + {
1.667 + TBool test=EFalse;
1.668 + if(!aCapability.Compare(KCAPABILITY_ALL))
1.669 + {
1.670 + gTheTestCapability=ESwEventErr;
1.671 + test=ETrue;
1.672 + }
1.673 + else if(!aCapability.Compare(KCAPABILITY_NONE))
1.674 + {
1.675 + gTheTestCapability=ENoSwEventErr;
1.676 + test=ETrue;
1.677 + }
1.678 + else
1.679 + {
1.680 + gTheTestCapability=EDoNotTest;
1.681 + }
1.682 + if(test)
1.683 + {
1.684 + LogMessageText.Format(KSetOrdinalPositionErr);
1.685 + ws.LogMessage(LogMessageText);
1.686 + ret=gr1.SetOrdinalPositionErr(0,KPasswordWindowGroupPriority);
1.687 + }
1.688 + }
1.689 + break;
1.690 + case 34:
1.691 + if(!aCapability.Compare(KCAPABILITY_NONE))
1.692 + {
1.693 + LogMessageText.Format(KSetOrdinalPositionErr);
1.694 + ws.LogMessage(LogMessageText);
1.695 + gTheTestCapability=ENoSwEventErrSmallOrdinal;
1.696 + ret=gr1.SetOrdinalPositionErr(0,KPasswordWindowGroupPriority-1);
1.697 + }
1.698 + else
1.699 + {
1.700 + gTheTestCapability=EDoNotTest;
1.701 + }
1.702 + break;
1.703 + case 35:
1.704 + // EWsClOpSetCloseProximityThresholds Capability Check
1.705 + gTheTestCapability=EWriteDeviceData;
1.706 + ret=ws.SetCloseProximityThresholds(-20, -50);
1.707 + ws.SetCloseProximityThresholds(KMaxTInt, KMinTInt);
1.708 + break;
1.709 + case 36:
1.710 + // EWsClOpSetHighPressureThresholds Capability Check
1.711 + gTheTestCapability=EWriteDeviceData;
1.712 + ret=ws.SetHighPressureThresholds(4000, 2000);
1.713 + ws.SetHighPressureThresholds(KMaxTInt, KMinTInt);
1.714 + break;
1.715 + default:
1.716 + ret=gTestState=EWsTestFinished;
1.717 + }
1.718 + CleanupStack::PopAndDestroy(&gr2);
1.719 + CleanupStack::PopAndDestroy(&gr1);
1.720 + CleanupStack::PopAndDestroy(&ws);
1.721 + return ret;
1.722 + }
1.723 +
1.724 +void MainL()
1.725 + {
1.726 + TBuf<256> commandLine;
1.727 + User::CommandLine(commandLine);
1.728 + CTestBase testBase;
1.729 + testBase.ConstructL(&commandLine);
1.730 + TInt ii=0;
1.731 + while(gTestState!=EWsTestFinished)
1.732 + testBase.TestWsPanicL(&TestCapability,ii++,commandLine) ;
1.733 +// testBase.UpdateLogsL();
1.734 + }
1.735 +
1.736 +GLDEF_C TInt E32Main()
1.737 + {
1.738 + __UHEAP_MARK;
1.739 + CTrapCleanup* cleanUpStack=CTrapCleanup::New();
1.740 + if(cleanUpStack==NULL)
1.741 + {
1.742 + return KErrNoMemory;
1.743 + }
1.744 + TRAP_IGNORE(MainL())
1.745 + delete cleanUpStack;
1.746 + __UHEAP_MARKEND;
1.747 + return(KErrNone);
1.748 + }