1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/genericservices/taskscheduler/Test/Robustness/TC_TSCH_IPC.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1476 @@
1.4 +// Copyright (c) 2008-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 +//
1.18 +
1.19 +
1.20 +#include <e32test.h>
1.21 +#include <e32math.h>
1.22 +#include <e32debug.h>
1.23 +#include "CSCHCODE.H"
1.24 +#include "SCHINFO.H"
1.25 +#include <bsul/bsul.h>
1.26 +#include <schinfointernal.h>
1.27 +using namespace BSUL;
1.28 +
1.29 +
1.30 +LOCAL_D RTest Test (_L("TC_TSCH_IPC"));
1.31 +
1.32 +_LIT(KServerName, "!TaskScheduler");
1.33 +_LIT(KServerProcess, "SchExe");
1.34 +
1.35 +struct TTestInfo
1.36 + {
1.37 + TInt iFunction;
1.38 + TInt iType;
1.39 + TInt iArgCount;
1.40 + };
1.41 +
1.42 +struct TExitDetails
1.43 + {
1.44 + TExitCategoryName iCategory;
1.45 + TExitType iExitType;
1.46 + TInt iReason;
1.47 + };
1.48 +
1.49 +const TInt KAsynchDelay = 500000;
1.50 +
1.51 +const TInt KFunctionNumbers [] = { ERegisterClient,
1.52 + ECreateTimeSchedule,
1.53 + ECreateConditionSchedule,
1.54 + EScheduleTask,
1.55 + ERemoveTask,
1.56 + EDisableSchedule,
1.57 + EEnableSchedule,
1.58 + EDeleteSchedule,
1.59 + EEditTimeSchedule,
1.60 + EEditConditionSchedule,
1.61 + EGetScheduleInfo,
1.62 + EGetTimeScheduleData,
1.63 + EGetConditionScheduleData,
1.64 + EGetTaskData,
1.65 + ECountSchedules,
1.66 + ECountTasks,
1.67 + EGetTaskRefs,
1.68 + EGetTask,
1.69 + EGetTaskDataSize,
1.70 + EGetScheduleRefs,
1.71 + EDeleteTask,
1.72 + EGetSchedulerItemRefAndNextDueTime,
1.73 + EGetScheduleType};
1.74 +
1.75 +const TInt KNumFunctions = sizeof(KFunctionNumbers)/sizeof(KFunctionNumbers[0]);
1.76 +
1.77 +//===============================================================================
1.78 +
1.79 +TBool IsFunctionAsynchronous(TInt aFunc)
1.80 + {
1.81 + TBool asynch = EFalse;
1.82 + switch(aFunc)
1.83 + {
1.84 +
1.85 + default:
1.86 + break;
1.87 + }
1.88 + return asynch;
1.89 + }
1.90 +
1.91 +class RIpcFuzzTest : public RSessionBase
1.92 +{
1.93 +public: // Constructors and destructor
1.94 +
1.95 + /**
1.96 + * Constructor for performing 1st stage construction
1.97 + */
1.98 + RIpcFuzzTest();
1.99 +
1.100 + /**
1.101 + * Destructor.
1.102 + */
1.103 + ~RIpcFuzzTest();
1.104 +
1.105 + /**
1.106 + * Performs test steps
1.107 + */
1.108 +
1.109 + void RunTestL(const TDesC& aTargetSrvName, TInt aFunc,
1.110 + TInt aTestType, TInt aArgCount);
1.111 +
1.112 +private:
1.113 + TInt Fuzz(TInt aMsg, TInt aArgCount);
1.114 + TInt FuzzL(TInt aMsg, TInt aArgCount);
1.115 + TInt Fuzz8L(TInt aMsg, TInt aArgCount);
1.116 +};
1.117 +
1.118 +RIpcFuzzTest::RIpcFuzzTest()
1.119 + {
1.120 + // No implementation required
1.121 + }
1.122 +
1.123 +
1.124 +RIpcFuzzTest::~RIpcFuzzTest()
1.125 + {
1.126 + Close();
1.127 + }
1.128 +
1.129 +TInt RIpcFuzzTest::Fuzz(TInt aMsg, TInt aArgCount)
1.130 + {
1.131 + TIpcArgs args;
1.132 +
1.133 + for(TInt i = 0; i < aArgCount;i++)
1.134 + {
1.135 + args.Set(i,Math::Random());
1.136 + }
1.137 +
1.138 + TInt ret;
1.139 +
1.140 + if(IsFunctionAsynchronous(aMsg))
1.141 + {
1.142 + ret = Send(aMsg, args);
1.143 + User::After(KAsynchDelay);
1.144 + }
1.145 + else
1.146 + {
1.147 + ret = SendReceive(aMsg, args);
1.148 + }
1.149 + return ret;
1.150 + }
1.151 +
1.152 +TInt RIpcFuzzTest::Fuzz8L(TInt aMsg, TInt aArgCount)
1.153 + {
1.154 + HBufC8* buf = HBufC8::NewLC(255);
1.155 + TPtr8 ptr = buf->Des();
1.156 + ptr.Fill(Math::Random(),255);
1.157 +
1.158 + TIpcArgs args;
1.159 +
1.160 + for(TInt i = 0; i < aArgCount;i++)
1.161 + {
1.162 + args.Set(i,&ptr);
1.163 + }
1.164 +
1.165 + TInt ret;
1.166 +
1.167 + if(IsFunctionAsynchronous(aMsg))
1.168 + {
1.169 + ret = Send(aMsg, args);
1.170 + User::After(KAsynchDelay);
1.171 + }
1.172 + else
1.173 + {
1.174 + ret = SendReceive(aMsg, args);
1.175 + }
1.176 +
1.177 + CleanupStack::PopAndDestroy(buf);
1.178 + return ret;
1.179 + }
1.180 +
1.181 +TInt RIpcFuzzTest::FuzzL(TInt aMsg, TInt aArgCount)
1.182 + {
1.183 + HBufC* buf = HBufC::NewLC(255);
1.184 + TPtr ptr = buf->Des();
1.185 + ptr.Fill(Math::Random(),255);
1.186 +
1.187 + TIpcArgs args;
1.188 +
1.189 + for(TInt i = 0; i < aArgCount;i++)
1.190 + {
1.191 + args.Set(i,&ptr);
1.192 + }
1.193 +
1.194 + TInt ret;
1.195 +
1.196 + if(IsFunctionAsynchronous(aMsg))
1.197 + {
1.198 + ret = Send(aMsg, args);
1.199 + User::After(KAsynchDelay);
1.200 + }
1.201 + else
1.202 + {
1.203 + ret = SendReceive(aMsg, args);
1.204 + }
1.205 +
1.206 + CleanupStack::PopAndDestroy(buf);
1.207 + return ret;
1.208 + }
1.209 +
1.210 +void RIpcFuzzTest::RunTestL(const TDesC& aTargetSrvName,
1.211 + TInt aFunc, TInt aTestType, TInt aArgCount)
1.212 + {
1.213 + TVersion version(0,0,0);
1.214 +
1.215 + TInt err = CreateSession(aTargetSrvName, version);
1.216 +
1.217 + User::LeaveIfError(err);
1.218 +
1.219 + switch(aTestType)
1.220 + {
1.221 + case 0:
1.222 + Fuzz(aFunc,aArgCount);
1.223 + break;
1.224 +
1.225 + case 1:
1.226 + Fuzz8L(aFunc,aArgCount);
1.227 + break;
1.228 +
1.229 + case 2:
1.230 + FuzzL(aFunc,aArgCount);
1.231 + break;
1.232 + }
1.233 + }
1.234 +
1.235 +TInt KillProcess(const TDesC& aProcessName)
1.236 + {
1.237 + TFullName name;
1.238 +
1.239 + RDebug::Print(_L("Find and kill \"%S\" process.\n"), &aProcessName);
1.240 +
1.241 + TBuf<64> pattern(aProcessName);
1.242 + TInt length = pattern.Length();
1.243 + pattern += _L("*");
1.244 + TFindProcess procFinder(pattern);
1.245 +
1.246 + while (procFinder.Next(name) == KErrNone)
1.247 + {
1.248 + if (name.Length() > length)
1.249 + {//If found name is a string containing aProcessName string.
1.250 + TChar c(name[length]);
1.251 + if (c.IsAlphaDigit() ||
1.252 + c == TChar('_') ||
1.253 + c == TChar('-'))
1.254 + {
1.255 + // If the found name is other valid application name
1.256 + // starting with aProcessName string.
1.257 + RDebug::Print(_L(":: Process name: \"%S\".\n"), &name);
1.258 + continue;
1.259 + }
1.260 + }
1.261 + RProcess proc;
1.262 + if (proc.Open(name) == KErrNone)
1.263 + {
1.264 + proc.Kill(0);
1.265 + RDebug::Print(_L("\"%S\" process killed.\n"), &name);
1.266 + }
1.267 + proc.Close();
1.268 + }
1.269 + return KErrNone;
1.270 + }
1.271 +
1.272 +
1.273 +TInt FuzzServerL(TAny* aTestInfo)
1.274 + {
1.275 + CTrapCleanup* cleanup=CTrapCleanup::New();
1.276 + TInt err=KErrNoMemory;
1.277 + if (cleanup)
1.278 + {
1.279 +
1.280 + TTestInfo* info = (TTestInfo*)aTestInfo;
1.281 + RIpcFuzzTest fuzzer;
1.282 +
1.283 + TRAP(err,fuzzer.RunTestL(KServerName,info->iFunction
1.284 + ,info->iType, info->iArgCount));
1.285 +
1.286 + fuzzer.Close();
1.287 +
1.288 + delete cleanup;
1.289 + }
1.290 + return err;
1.291 + }
1.292 +
1.293 +
1.294 +void TestServerApi(TInt aFunctionNumber,
1.295 + TInt aTestType,TInt aArgCount, TExitDetails& aExitDetails)
1.296 + {
1.297 +
1.298 + TTestInfo testInfo;
1.299 + testInfo.iFunction = aFunctionNumber;
1.300 + testInfo.iType = aTestType;
1.301 + testInfo.iArgCount = aArgCount;
1.302 +
1.303 + RThread thread;
1.304 + _LIT(KThreadName,"FuzzerThread" );
1.305 + thread.Create(KThreadName,&FuzzServerL, KDefaultStackSize, NULL,&testInfo);
1.306 +
1.307 + TRequestStatus threadStat;
1.308 + thread.Logon(threadStat);
1.309 +
1.310 + TBool jit = User::JustInTime();
1.311 + User::SetJustInTime(EFalse);
1.312 +
1.313 + thread.Resume();
1.314 +
1.315 + User::WaitForRequest(threadStat);
1.316 +
1.317 + User::SetJustInTime(jit);
1.318 +
1.319 + aExitDetails.iCategory = thread.ExitCategory();
1.320 + aExitDetails.iReason = thread.ExitReason();
1.321 + aExitDetails.iExitType = thread.ExitType();
1.322 +
1.323 + thread.Close();
1.324 +
1.325 + }
1.326 +
1.327 +
1.328 +TInt LaunchServer(RProcess& aServer)
1.329 + {
1.330 +
1.331 + Test.Printf(_L("Launching Task Scheduler...\n"));
1.332 +
1.333 + const TUid KServerUid3 = {0x10005399};
1.334 + const TUidType serverUid(KNullUid,KNullUid,KServerUid3);
1.335 +
1.336 + TInt err = aServer.Create(KServerProcess, _L(""),serverUid);
1.337 +
1.338 + if(err == KErrNone)
1.339 + {
1.340 + aServer.SetPriority(EPriorityForeground);
1.341 +
1.342 + //Start server and wait until it is running
1.343 + TRequestStatus serverStat;
1.344 + aServer.SetJustInTime(false);
1.345 + aServer.Resume();
1.346 +
1.347 + aServer.Rendezvous(serverStat);
1.348 + User::WaitForRequest(serverStat);
1.349 + }
1.350 +
1.351 + return err;
1.352 +
1.353 + }
1.354 +
1.355 +void PrintTestMessage(TInt iFunc, TInt iType, TInt iArgCount)
1.356 + {
1.357 + switch(iType)
1.358 + {
1.359 + case 0:
1.360 + Test.Printf(_L("\nFuzz Test on function number %d using random Int data. Number of Args = %d"), iFunc, iArgCount);
1.361 + break;
1.362 +
1.363 + case 1:
1.364 + Test.Printf(_L("\nFuzz Test on function number %d using random Des8 data. Number of Args = %d"), iFunc, iArgCount);
1.365 + break;
1.366 +
1.367 + case 2:
1.368 + Test.Printf(_L("\nFuzz Test on function number %d using random Des data. Number of Args = %d"), iFunc, iArgCount);
1.369 + break;
1.370 +
1.371 + }
1.372 +
1.373 + }
1.374 +
1.375 +/**
1.376 +Invoke the tests
1.377 +*/
1.378 +/**
1.379 +@SYMTestCaseID SYSLIB-SCHSVR-CT-4004
1.380 +@SYMTestCaseDesc Tests SchSvr APIs for IPC Robustness
1.381 +@SYMTestPriority High
1.382 +@SYMTestActions The function calls each of the SchSvr APIs through a custom session object
1.383 + passing random TInt, Des8 and Des16 data .
1.384 +@SYMTestExpectedResults The server should be robust to all malformed messages and should not
1.385 + hang or panic.
1.386 +@SYMDEF PDEF118811
1.387 +*/
1.388 +LOCAL_C void DoFuzzTestsL ()
1.389 + {
1.390 + Test.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4004 "));
1.391 + RProcess server;
1.392 +
1.393 + User::LeaveIfError(LaunchServer(server));
1.394 +
1.395 + TExitDetails exitDetails;
1.396 +
1.397 + for(TInt i = 0;i< KNumFunctions;i++)
1.398 + {
1.399 +
1.400 + //Carry out each type of test
1.401 + for(TInt testType = 0; testType < 3;testType++)
1.402 + {
1.403 + //Carry out each test with number of arguments 1 - 4
1.404 + for(TInt argCount = 1;argCount <= 4;argCount++)
1.405 + {
1.406 + PrintTestMessage(KFunctionNumbers[i], testType, argCount);
1.407 +
1.408 + TestServerApi(KFunctionNumbers[i], testType, argCount, exitDetails);
1.409 + //Kill the server process and verify that it was still running
1.410 + //If the server was already dead it would return the reason it exited
1.411 + if(server.ExitType() != EExitPending)
1.412 + {
1.413 + server.Kill(0);
1.414 + TInt exitReason = server.ExitReason();
1.415 + server.Close();
1.416 + Test(exitReason == 0);
1.417 + User::LeaveIfError(LaunchServer(server));
1.418 + }
1.419 + }
1.420 +
1.421 + Test.Printf(_L("\nFuzz Test Successful\n"));
1.422 + }
1.423 + }
1.424 + }
1.425 +
1.426 +
1.427 +/*
1.428 + * SERVER API TESTING
1.429 + */
1.430 +
1.431 +typedef void (*TestFunction)();
1.432 +
1.433 +class RClientMessageTestSession : public RSessionBase
1.434 + {
1.435 +public:
1.436 + TInt Connect();
1.437 +
1.438 + TInt TestRegisterClient(const TDesC& aData0, TInt aArg1);
1.439 +
1.440 + TInt TestCreateTimeSchedule(TDesC8& aData0,TDesC8& aData1,TDes8& aData2);
1.441 + TInt TestCreateCondSchedule(TDesC8& aData0,TDesC8& aData1,TDesC8& aData2,TDes8& aData3);
1.442 +
1.443 + TInt TestScheduleTask(TDesC8& aData0,TInt aArg1,TDes8& aData2,TDesC& aData3);
1.444 + TInt TestDeleteTask(TInt aArg0);
1.445 + TInt TestDeleteSchedule(TInt aArg0);
1.446 + TInt TestDisableSchedule(TInt aArg0);
1.447 + TInt TestEnableSchedule(TInt aArg0);
1.448 +
1.449 + TInt TestEditTimeSchedule(TInt aArg0, TInt aArg1, TDes8& aData2);
1.450 + TInt TestEditCondSchedule(TInt aArg0, TInt aArg1, TDes8& aData2, TDes8& aData3);
1.451 +
1.452 + TInt TestGetScheduleRefs(TInt aArg0, TInt aArg1, TDes8& aData2);
1.453 + TInt TestCountSchedules(TDes8& aData0, TInt aArg1);
1.454 + TInt TestGetScheduleType(TInt aArg0,TDes8& aData1);
1.455 + TInt TestGetScheduleInfo(TInt aArg0, TDes8& aData1, TDes8& aData2);
1.456 + TInt TestGetTimeScheduleData(TInt aArg0, TDes8& aData1, TDes8& aData2);
1.457 + TInt TestGetCondScheduleData(TInt aArg0, TDes8& aData1, TDes8& aData2, TDes8& aData3);
1.458 + TInt TestGetScheduleItemRef(TInt aArg0, TDes8& aData1, TDes8& aData2);
1.459 +
1.460 + TInt TestGetTaskData(TInt aArg0, TDes8& aData1, TDes8& aData2);
1.461 + TInt TestGetTaskRefs(TInt aArg0, TInt aArg1,TInt aArg2, TDes8& aData3);
1.462 + TInt TestCountTasks(TDes8& aData0, TInt aArg1, TInt aArg2);
1.463 + TInt TestGetTaskInfo(TInt aArg0,TDesC8& aData1,TInt aArg2,TDesC& aData3);
1.464 + TInt TestGetTaskDataSize(TInt aArg0,TDesC8& aData1);
1.465 +
1.466 +
1.467 + };
1.468 +
1.469 +static TInt LaunchLogServerL()
1.470 + {
1.471 +
1.472 + RProcess process;
1.473 +
1.474 + TInt err = process.Create(KServerProcess,_L(""));
1.475 +
1.476 + if(err == KErrNone)
1.477 + {
1.478 + TRequestStatus serverStat;
1.479 +
1.480 + process.SetJustInTime(EFalse);
1.481 + process.Resume();
1.482 + process.Rendezvous(serverStat);
1.483 + User::WaitForRequest(serverStat);
1.484 + }
1.485 +
1.486 + return err;
1.487 + }
1.488 +
1.489 +
1.490 +TInt RClientMessageTestSession::Connect()
1.491 + {
1.492 + TInt retry = 2;
1.493 + for(;;)
1.494 + {
1.495 + TInt r = CreateSession(KServerName,TVersion(1,0,0));
1.496 +
1.497 + if((r != KErrNotFound)&&(r != KErrServerTerminated))
1.498 + {
1.499 + return r;
1.500 + }
1.501 +
1.502 + if(--retry == 0)
1.503 + {
1.504 + return r;
1.505 + }
1.506 +
1.507 + r = LaunchLogServerL();
1.508 + if((r != KErrNone)&&(r != KErrAlreadyExists))
1.509 + {
1.510 + return r;
1.511 + }
1.512 + }
1.513 + }
1.514 +
1.515 +TInt RClientMessageTestSession::TestRegisterClient(const TDesC& aData0, TInt aArg1)
1.516 + {
1.517 + return SendReceive(ERegisterClient,TIpcArgs(&aData0, aArg1));
1.518 + }
1.519 +
1.520 +TInt RClientMessageTestSession::TestCreateTimeSchedule(TDesC8& aData0,TDesC8& aData1,TDes8& aData2)
1.521 + {
1.522 + return SendReceive(ECreateTimeSchedule,TIpcArgs(&aData0, &aData1,& aData2));
1.523 + }
1.524 +
1.525 +TInt RClientMessageTestSession::TestCreateCondSchedule(TDesC8& aData0,TDesC8& aData1,TDesC8& aData2,TDes8& aData3)
1.526 + {
1.527 + return SendReceive(ECreateConditionSchedule,TIpcArgs(&aData0,&aData1, &aData2, &aData3));
1.528 + }
1.529 +
1.530 +TInt RClientMessageTestSession::TestScheduleTask(TDesC8& aData0,TInt aArg1,TDes8& aData2,TDesC& aData3)
1.531 + {
1.532 + return SendReceive(EScheduleTask,TIpcArgs(&aData0, aArg1, &aData2, &aData3));
1.533 + }
1.534 +
1.535 +TInt RClientMessageTestSession::TestDeleteTask(TInt aArg0)
1.536 + {
1.537 + return SendReceive(EDeleteTask,TIpcArgs(aArg0));
1.538 + }
1.539 +
1.540 +TInt RClientMessageTestSession::TestDeleteSchedule(TInt aArg0)
1.541 + {
1.542 + return SendReceive(EDeleteSchedule,TIpcArgs(aArg0));
1.543 + }
1.544 +
1.545 +TInt RClientMessageTestSession::TestDisableSchedule(TInt aArg0)
1.546 + {
1.547 + return SendReceive(EDisableSchedule,TIpcArgs(aArg0));
1.548 + }
1.549 +
1.550 +TInt RClientMessageTestSession::TestEnableSchedule(TInt aArg0)
1.551 + {
1.552 + return SendReceive(EEnableSchedule,TIpcArgs(aArg0));
1.553 + }
1.554 +
1.555 +TInt RClientMessageTestSession::TestEditTimeSchedule(TInt aArg0, TInt aArg1, TDes8& aData2)
1.556 + {
1.557 + return SendReceive(EEditTimeSchedule,TIpcArgs(aArg0, aArg1, &aData2));
1.558 + }
1.559 +
1.560 +TInt RClientMessageTestSession::TestEditCondSchedule(TInt aArg0, TInt aArg1, TDes8& aData2, TDes8& aData3)
1.561 + {
1.562 + return SendReceive(EEditConditionSchedule,TIpcArgs(aArg0, aArg1, &aData2,&aData3));
1.563 + }
1.564 +
1.565 +
1.566 +TInt RClientMessageTestSession::TestGetScheduleRefs(TInt aArg0, TInt aArg1, TDes8& aData2)
1.567 + {
1.568 + return SendReceive(EGetScheduleRefs,TIpcArgs(aArg0, aArg1, &aData2));
1.569 + }
1.570 +
1.571 +TInt RClientMessageTestSession::TestCountSchedules(TDes8& aData0, TInt aArg1)
1.572 + {
1.573 + return SendReceive(ECountSchedules,TIpcArgs(&aData0, aArg1));
1.574 + }
1.575 +
1.576 +TInt RClientMessageTestSession::TestGetScheduleType(TInt aArg0,TDes8& aData1)
1.577 + {
1.578 + return SendReceive(EGetScheduleType,TIpcArgs(aArg0, &aData1));
1.579 + }
1.580 +
1.581 +TInt RClientMessageTestSession::TestGetScheduleInfo(TInt aArg0, TDes8& aData1, TDes8& aData2)
1.582 + {
1.583 + return SendReceive(EGetScheduleInfo,TIpcArgs(aArg0, &aData1, &aData2));
1.584 + }
1.585 +
1.586 +TInt RClientMessageTestSession::TestGetTimeScheduleData(TInt aArg0, TDes8& aData1, TDes8& aData2)
1.587 + {
1.588 + return SendReceive(EGetTimeScheduleData,TIpcArgs(aArg0, &aData1, &aData2));
1.589 + }
1.590 +
1.591 +TInt RClientMessageTestSession::TestGetCondScheduleData(TInt aArg0, TDes8& aData1, TDes8& aData2, TDes8& aData3)
1.592 + {
1.593 + return SendReceive(EGetConditionScheduleData,TIpcArgs(aArg0, &aData1, &aData2, &aData3));
1.594 + }
1.595 +
1.596 +TInt RClientMessageTestSession::TestGetScheduleItemRef(TInt aArg0, TDes8& aData1, TDes8& aData2)
1.597 + {
1.598 + return SendReceive(EGetSchedulerItemRefAndNextDueTime,TIpcArgs(aArg0, &aData1, &aData2));
1.599 + }
1.600 +
1.601 +TInt RClientMessageTestSession::TestGetTaskData(TInt aArg0, TDes8& aData1, TDes8& aData2)
1.602 + {
1.603 + return SendReceive(EGetTaskData,TIpcArgs(aArg0, &aData1, &aData2));
1.604 + }
1.605 +
1.606 +TInt RClientMessageTestSession::TestGetTaskRefs(TInt aArg0, TInt aArg1,TInt aArg2, TDes8& aData3)
1.607 + {
1.608 + return SendReceive(EGetTaskRefs,TIpcArgs(aArg0, aArg1, aArg2, &aData3));
1.609 + }
1.610 +
1.611 +TInt RClientMessageTestSession::TestCountTasks(TDes8& aData0, TInt aArg1, TInt aArg2)
1.612 + {
1.613 + return SendReceive(ECountTasks,TIpcArgs(&aData0, aArg1, aArg2));
1.614 + }
1.615 +
1.616 +TInt RClientMessageTestSession::TestGetTaskInfo(TInt aArg0,TDesC8& aData1,TInt aArg2,TDesC& aData3)
1.617 + {
1.618 + return SendReceive(EGetTask,TIpcArgs(aArg0, &aData1, aArg2, &aData3));
1.619 + }
1.620 +
1.621 +TInt RClientMessageTestSession::TestGetTaskDataSize(TInt aArg0,TDesC8& aData1)
1.622 + {
1.623 + return SendReceive(EGetTaskDataSize,TIpcArgs(aArg0, &aData1));
1.624 + }
1.625 +
1.626 +
1.627 +
1.628 +
1.629 +
1.630 +TInt TestFunctionLauncherL(TAny* aTestFunction)
1.631 + {
1.632 + CTrapCleanup* cleanup=CTrapCleanup::New();
1.633 + TInt r=KErrNoMemory;
1.634 + if (cleanup)
1.635 + {
1.636 + TestFunction function = (TestFunction)aTestFunction;
1.637 +
1.638 +__UHEAP_MARK;
1.639 + TRAP(r,function());
1.640 +__UHEAP_MARKEND;
1.641 +
1.642 + delete cleanup;
1.643 + }
1.644 + return r;
1.645 + }
1.646 +
1.647 +
1.648 +TExitDetails LaunchTestThreadL(const TDesC& aThreadName, TestFunction aFunction)
1.649 + {
1.650 + RThread thread;
1.651 + thread.Create(aThreadName, &TestFunctionLauncherL, KDefaultStackSize, NULL, (TAny*)aFunction);
1.652 +
1.653 + TRequestStatus threadStat;
1.654 + thread.Logon(threadStat);
1.655 +
1.656 + TBool jit = User::JustInTime();
1.657 + User::SetJustInTime(EFalse);
1.658 +
1.659 + thread.Resume();
1.660 + User::WaitForRequest(threadStat);
1.661 +
1.662 + User::SetJustInTime(jit);
1.663 +
1.664 + TExitDetails exitDetails;
1.665 + exitDetails.iCategory = thread.ExitCategory();
1.666 + exitDetails.iReason = thread.ExitReason();
1.667 + exitDetails.iExitType = thread.ExitType();
1.668 +
1.669 + return exitDetails;
1.670 + }
1.671 +
1.672 +
1.673 +
1.674 +/**
1.675 +@SYMTestCaseID SYSLIB-SCHSVR-CT-4005
1.676 +@SYMTestCaseDesc Tests Create Schedule API robustness
1.677 +@SYMTestPriority High
1.678 +@SYMTestActions Calls the Create Schedule APIs passing in varying parameters
1.679 + to test the robustness of the API
1.680 +@SYMTestExpectedResults The server should be robust to badly formed messages and should
1.681 + return KErrBadParameter if messages do not fit the constraints
1.682 + defined in the message schema.
1.683 + The server should panic the client with KErrBadDescriptor if an
1.684 + invalid descriptor argument is passed.
1.685 +@SYMDEF PDEF118811
1.686 +*/
1.687 +void TestCreateSchedulesL()
1.688 + {
1.689 +
1.690 + RClientMessageTestSession session;
1.691 +
1.692 + TInt err = session.Connect();
1.693 +
1.694 + CleanupClosePushL(session);
1.695 +
1.696 + err = session.TestRegisterClient(_L("MyClient"),0);
1.697 + Test(err == KErrNone);
1.698 +
1.699 + err = session.TestRegisterClient(_L("MyClient2"),-1);
1.700 + Test(err == KErrBadParameter);
1.701 +
1.702 + TScheduleSettings2 settings;
1.703 + TScheduleEntryInfo2 info;
1.704 + TInt id;
1.705 +
1.706 + TPckg<TScheduleSettings2> pSettings(settings);
1.707 + TPckg<TScheduleEntryInfo2> pInfo(info);
1.708 + TPckg<TInt> pId(id);
1.709 +
1.710 + settings.iPersists = -1;
1.711 + settings.iEntryCount = -1;
1.712 +
1.713 + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId);
1.714 + Test(err == KErrBadParameter);
1.715 +
1.716 + settings.iPersists = 0;
1.717 + settings.iEntryCount = 1;
1.718 +
1.719 + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId);
1.720 + Test(err == KErrNone);
1.721 +
1.722 + TTsTime time;
1.723 + TPckg<TTsTime> pTime(time);
1.724 + TTaskSchedulerCondition conditions;
1.725 + TPckg<TTaskSchedulerCondition> pConditions(conditions);
1.726 +
1.727 + err = session.TestCreateCondSchedule(pSettings, pConditions, pTime,pId);
1.728 + Test(err == KErrNone);
1.729 +
1.730 + err = session.TestDisableSchedule(id);
1.731 + Test(err == KErrNone);
1.732 +
1.733 + err = session.TestDisableSchedule(249990000);
1.734 + Test(err == KErrNotFound);
1.735 +
1.736 + err = session.TestDisableSchedule(-1);
1.737 + Test(err == KErrBadParameter);
1.738 +
1.739 + err = session.TestDisableSchedule(250000000);
1.740 + Test(err == KErrBadParameter);
1.741 +
1.742 + CleanupStack::PopAndDestroy(&session);
1.743 + }
1.744 +
1.745 +void TestCreateSchedulesPanic1L()
1.746 + {
1.747 + RClientMessageTestSession session;
1.748 +
1.749 + TInt err = session.Connect();
1.750 +
1.751 + CleanupClosePushL(session);
1.752 +
1.753 + err = session.TestRegisterClient(_L("MyClient"),0);
1.754 + Test(err == KErrNone);
1.755 +
1.756 + TScheduleSettings2 settings;
1.757 + TScheduleEntryInfo2 info;
1.758 + TInt id;
1.759 +
1.760 + TPckg<TScheduleSettings2> pSettings(settings);
1.761 + TPckg<TScheduleEntryInfo2> pInfo(info);
1.762 + TPckg<TInt> pId(id);
1.763 +
1.764 + settings.iPersists = 0;
1.765 + settings.iEntryCount = 0;
1.766 +
1.767 + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId);
1.768 + Test(err == KErrNone);
1.769 +
1.770 + CleanupStack::PopAndDestroy(&session);
1.771 + }
1.772 +
1.773 +void TestCreateSchedulesPanic2L()
1.774 + {
1.775 + RClientMessageTestSession session;
1.776 +
1.777 + TInt err = session.Connect();
1.778 +
1.779 + CleanupClosePushL(session);
1.780 +
1.781 + err = session.TestRegisterClient(_L("MyClient"),0);
1.782 + Test(err == KErrNone);
1.783 +
1.784 + TScheduleSettings2 settings;
1.785 + TTaskSchedulerCondition conditions;
1.786 + TTsTime time;
1.787 + TInt id;
1.788 +
1.789 + TPckg<TScheduleSettings2> pSettings(settings);
1.790 + TPckg<TTaskSchedulerCondition> pConditions(conditions);
1.791 + TPckg<TTsTime> pTime(time);
1.792 + TPckg<TInt> pId(id);
1.793 +
1.794 + settings.iEntryCount = 2;
1.795 + settings.iPersists = 0;
1.796 +
1.797 + err = session.TestCreateCondSchedule(pSettings, pConditions, pTime,pId);
1.798 + Test(err == KErrNone);
1.799 +
1.800 + CleanupStack::PopAndDestroy(&session);
1.801 + }
1.802 +
1.803 +/**
1.804 +@SYMTestCaseID SYSLIB-SCHSVR-CT-4006
1.805 +@SYMTestCaseDesc Tests Edit Schedule API robustness
1.806 +@SYMTestPriority High
1.807 +@SYMTestActions Calls the Edit Schedule APIs passing in varying parameters
1.808 + to test the robustness of the API
1.809 +@SYMTestExpectedResults The server should be robust to badly formed messages and should
1.810 + return KErrBadParameter if messages do not fit the constraints
1.811 + defined in the message schema.
1.812 +@SYMDEF PDEF118811
1.813 +*/
1.814 +void TestEditSchedulesL()
1.815 + {
1.816 +
1.817 + RClientMessageTestSession session;
1.818 +
1.819 + TInt err = session.Connect();
1.820 +
1.821 + CleanupClosePushL(session);
1.822 +
1.823 + err = session.TestRegisterClient(_L("MyClient"),0);
1.824 + Test(err == KErrNone);
1.825 +
1.826 + TScheduleSettings2 settings;
1.827 + TTaskSchedulerCondition conditions;
1.828 + TTsTime time;
1.829 + TInt id1;
1.830 + TInt id2;
1.831 + TScheduleInfo schedInfo;
1.832 +
1.833 + TPckg<TScheduleSettings2> pSettings(settings);
1.834 + TPckg<TTaskSchedulerCondition> pConditions(conditions);
1.835 + TPckg<TTsTime> pTime(time);
1.836 + TPckg<TInt> pId1(id1);
1.837 + TPckg<TInt> pId2(id2);
1.838 + TPckg<TScheduleInfo> pSchedInfo(schedInfo);
1.839 +
1.840 + settings.iEntryCount = 1;
1.841 + settings.iPersists = 0;
1.842 +
1.843 + TScheduleEntryInfo2 info;
1.844 + TPckg<TScheduleEntryInfo2> pInfo(info);
1.845 +
1.846 + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1);
1.847 + Test(err == KErrNone);
1.848 +
1.849 + err = session.TestEditTimeSchedule(settings.iEntryCount, id1,pInfo );
1.850 + Test(err == KErrNone);
1.851 +
1.852 + err = session.TestEditTimeSchedule(-1, id1,pInfo );
1.853 + Test(err == KErrBadParameter);
1.854 +
1.855 + err = session.TestEditTimeSchedule(10000, id1,pInfo );
1.856 + Test(err == KErrBadParameter);
1.857 +
1.858 + err = session.TestEditTimeSchedule(settings.iEntryCount, -1,pInfo );
1.859 + Test(err == KErrBadParameter);
1.860 +
1.861 + err = session.TestEditTimeSchedule(settings.iEntryCount,300000000,pInfo );
1.862 + Test(err == KErrBadParameter);
1.863 +
1.864 + err = session.TestCreateCondSchedule(pSettings, pConditions, pTime,pId2);
1.865 + Test(err == KErrNone);
1.866 +
1.867 + err = session.TestEditCondSchedule(settings.iEntryCount, id2,pConditions, pTime );
1.868 + Test(err == KErrNone);
1.869 +
1.870 + err = session.TestEditCondSchedule(-231, id2,pConditions, pTime );
1.871 + Test(err == KErrBadParameter);
1.872 +
1.873 + err = session.TestEditCondSchedule(11000, id2,pConditions, pTime );
1.874 + Test(err == KErrBadParameter);
1.875 +
1.876 + err = session.TestEditCondSchedule(settings.iEntryCount, -1,pConditions, pTime );
1.877 + Test(err == KErrBadParameter);
1.878 +
1.879 + err = session.TestEditCondSchedule(settings.iEntryCount, 250000000,pConditions, pTime );
1.880 + Test(err == KErrBadParameter);
1.881 +
1.882 + CleanupStack::PopAndDestroy(&session);
1.883 +
1.884 + }
1.885 +
1.886 +/**
1.887 +@SYMTestCaseID SYSLIB-SCHSVR-CT-4007
1.888 +@SYMTestCaseDesc Tests Schedule Data API robustness
1.889 +@SYMTestPriority High
1.890 +@SYMTestActions Calls the Get Schedule Data APIs passing in varying parameters
1.891 + to test the robustness of the API
1.892 +@SYMTestExpectedResults The server should be robust to badly formed messages and should
1.893 + return KErrBadParameter if messages do not fit the constraints
1.894 + defined in the message schema.
1.895 + The server should panic the client with KErrBadDescriptor if an
1.896 + invalid descriptor argument is passed.
1.897 +@SYMDEF PDEF118811
1.898 +*/
1.899 +void TestGetScheduleDataL()
1.900 + {
1.901 + RClientMessageTestSession session;
1.902 +
1.903 + TInt err = session.Connect();
1.904 +
1.905 + CleanupClosePushL(session);
1.906 +
1.907 + err = session.TestRegisterClient(_L("MyClient"),0);
1.908 + Test(err == KErrNone);
1.909 +
1.910 + TScheduleSettings2 settings;
1.911 + TTaskSchedulerCondition conditions;
1.912 + TTsTime time;
1.913 + TInt id1;
1.914 + TInt id2;
1.915 + TScheduleInfo schedInfo;
1.916 +
1.917 + TPckg<TScheduleSettings2> pSettings(settings);
1.918 + TPckg<TTaskSchedulerCondition> pConditions(conditions);
1.919 + TPckg<TTsTime> pTime(time);
1.920 + TPckg<TInt> pId1(id1);
1.921 + TPckg<TInt> pId2(id2);
1.922 + TPckg<TScheduleInfo> pSchedInfo(schedInfo);
1.923 +
1.924 + settings.iEntryCount = 1;
1.925 + settings.iPersists = 0;
1.926 +
1.927 + TScheduleEntryInfo2 info;
1.928 + TPckg<TScheduleEntryInfo2> pInfo(info);
1.929 +
1.930 + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1);
1.931 + Test(err == KErrNone);
1.932 +
1.933 + err = session.TestCreateCondSchedule(pSettings, pConditions, pTime,pId2);
1.934 + Test(err == KErrNone);
1.935 +
1.936 + err = session.TestGetScheduleInfo(id1,pSchedInfo, pTime);
1.937 + Test(err == KErrNone);
1.938 +
1.939 + err = session.TestGetScheduleInfo(-1,pSchedInfo, pTime);
1.940 + Test(err == KErrBadParameter);
1.941 +
1.942 + err = session.TestGetScheduleInfo(250000000,pSchedInfo, pTime);
1.943 + Test(err == KErrBadParameter);
1.944 +
1.945 + TInt count;
1.946 + TPckg<TInt> pCount(count);
1.947 +
1.948 + err = session.TestCountSchedules(pCount, -378);
1.949 + Test(err == KErrBadParameter);
1.950 +
1.951 + err = session.TestCountSchedules(pCount, EAllSchedules);
1.952 + Test(err == KErrNone);
1.953 +
1.954 + err = session.TestCountSchedules(pCount, EPendingSchedules);
1.955 + Test(err == KErrNone);
1.956 +
1.957 + err = session.TestCountSchedules(pCount, 3);
1.958 + Test(err == KErrBadParameter);
1.959 +
1.960 + schedInfo.iEntryCount = 1;
1.961 +
1.962 + err = session.TestGetTimeScheduleData(id1,pSchedInfo, pInfo);
1.963 + Test(err == KErrNone);
1.964 +
1.965 + schedInfo.iEntryCount = 23;
1.966 +
1.967 + err = session.TestGetTimeScheduleData(id1,pSchedInfo, pInfo);
1.968 + Test(err == KErrArgument);
1.969 +
1.970 + schedInfo.iEntryCount = 1;
1.971 +
1.972 + err = session.TestGetTimeScheduleData(250000000,pSchedInfo, pInfo);
1.973 + Test(err == KErrBadParameter);
1.974 +
1.975 + err = session.TestGetCondScheduleData(id2,pSchedInfo, pInfo, pTime);
1.976 + Test(err == KErrNone);
1.977 +
1.978 + schedInfo.iEntryCount = 23;
1.979 +
1.980 + err = session.TestGetCondScheduleData(id2,pSchedInfo, pInfo, pTime);
1.981 + Test(err == KErrArgument);
1.982 +
1.983 + schedInfo.iEntryCount = 1;
1.984 +
1.985 + err = session.TestGetCondScheduleData(250000000,pSchedInfo, pInfo, pTime);
1.986 + Test(err == KErrBadParameter);
1.987 +
1.988 + err = session.TestGetCondScheduleData(-3,pSchedInfo, pInfo, pTime);
1.989 + Test(err == KErrBadParameter);
1.990 +
1.991 + err = session.TestCountSchedules(pCount, EAllSchedules);
1.992 + Test(err == KErrNone);
1.993 +
1.994 + HBufC8* data = HBufC8::NewL(sizeof(TSchedulerItemRef)* count);
1.995 + TPtr8 pData = data->Des();
1.996 +
1.997 + err = session.TestGetScheduleRefs(count,EAllSchedules,pData);
1.998 + Test(err == KErrNone);
1.999 +
1.1000 + err = session.TestCountSchedules(pCount, EPendingSchedules);
1.1001 + Test(err == KErrNone);
1.1002 +
1.1003 + err = session.TestGetScheduleRefs(count,EPendingSchedules,pData);
1.1004 + Test(err == KErrArgument);
1.1005 +
1.1006 + err = session.TestGetScheduleRefs(count,3,pData);
1.1007 + Test(err == KErrBadParameter);
1.1008 +
1.1009 + err = session.TestGetScheduleRefs(count,-1,pData);
1.1010 + Test(err == KErrBadParameter);
1.1011 +
1.1012 + err = session.TestGetScheduleRefs(-5,EAllSchedules,pData);
1.1013 + Test(err == KErrBadParameter);
1.1014 +
1.1015 + delete data;
1.1016 +
1.1017 + TInt type;
1.1018 + TPckg<TInt> pType(type);
1.1019 +
1.1020 + err = session.TestGetScheduleType(id1,pType);
1.1021 + Test(err == KErrNone);
1.1022 +
1.1023 + err = session.TestGetScheduleType(id2,pType);
1.1024 + Test(err == KErrNone);
1.1025 +
1.1026 + err = session.TestGetScheduleType(-1,pType);
1.1027 + Test(err == KErrBadParameter);
1.1028 +
1.1029 + err = session.TestGetScheduleType(250000002,pType);
1.1030 + Test(err == KErrBadParameter);
1.1031 +
1.1032 + CleanupStack::PopAndDestroy(&session);
1.1033 + }
1.1034 +
1.1035 +void TestGetScheduleDataPanic1L()
1.1036 + {
1.1037 + RClientMessageTestSession session;
1.1038 +
1.1039 + TInt err = session.Connect();
1.1040 +
1.1041 + CleanupClosePushL(session);
1.1042 +
1.1043 + err = session.TestRegisterClient(_L("MyClient"),0);
1.1044 + Test(err == KErrNone);
1.1045 +
1.1046 + TScheduleSettings2 settings;
1.1047 + TTaskSchedulerCondition conditions;
1.1048 + TTsTime time;
1.1049 + TInt id1;
1.1050 + TScheduleInfo schedInfo;
1.1051 +
1.1052 + TPckg<TScheduleSettings2> pSettings(settings);
1.1053 + TPckg<TTsTime> pTime(time);
1.1054 + TPckg<TInt> pId1(id1);
1.1055 + TPckg<TScheduleInfo> pSchedInfo(schedInfo);
1.1056 +
1.1057 + settings.iEntryCount = 1;
1.1058 + settings.iPersists = 0;
1.1059 +
1.1060 + TScheduleEntryInfo2 info;
1.1061 + TPckg<TScheduleEntryInfo2> pInfo(info);
1.1062 +
1.1063 + schedInfo.iEntryCount = 1;
1.1064 +
1.1065 + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1);
1.1066 + Test(err == KErrNone);
1.1067 +
1.1068 + err = session.TestGetTimeScheduleData(id1,pSchedInfo, pId1);
1.1069 + Test(err == KErrOverflow);
1.1070 +
1.1071 + CleanupStack::PopAndDestroy(&session);
1.1072 + }
1.1073 +
1.1074 +void TestGetScheduleDataPanic2L()
1.1075 + {
1.1076 + RClientMessageTestSession session;
1.1077 +
1.1078 + TInt err = session.Connect();
1.1079 +
1.1080 + CleanupClosePushL(session);
1.1081 +
1.1082 + err = session.TestRegisterClient(_L("MyClient"),0);
1.1083 + Test(err == KErrNone);
1.1084 +
1.1085 + TScheduleSettings2 settings;
1.1086 + TInt id1;
1.1087 + TInt count;
1.1088 +
1.1089 + TPckg<TScheduleSettings2> pSettings(settings);
1.1090 + TPckg<TInt> pId1(id1);
1.1091 + TPckg<TInt> pCount(count);
1.1092 +
1.1093 + settings.iEntryCount = 1;
1.1094 + settings.iPersists = 0;
1.1095 +
1.1096 + TScheduleEntryInfo2 info;
1.1097 + TPckg<TScheduleEntryInfo2> pInfo(info);
1.1098 +
1.1099 + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1);
1.1100 + Test(err == KErrNone);
1.1101 +
1.1102 + err = session.TestCountSchedules(pCount, EAllSchedules);
1.1103 + Test(err == KErrNone);
1.1104 +
1.1105 + err = session.TestGetScheduleRefs(count,EAllSchedules,pInfo);
1.1106 + Test(err == KErrOverflow);
1.1107 +
1.1108 + CleanupStack::PopAndDestroy(&session);
1.1109 + }
1.1110 +
1.1111 +/**
1.1112 +@SYMTestCaseID SYSLIB-SCHSVR-CT-4008
1.1113 +@SYMTestCaseDesc Tests Schedule Task API robustness
1.1114 +@SYMTestPriority High
1.1115 +@SYMTestActions Calls the Schedule Tasks APIs passing in varying parameters
1.1116 + to test the robustness of the API
1.1117 +@SYMTestExpectedResults The server should be robust to badly formed messages and should
1.1118 + return KErrBadParameter if messages do not fit the constraints
1.1119 + defined in the message schema.
1.1120 + The server should panic the client with KErrBadDescriptor if an
1.1121 + invalid descriptor argument is passed.
1.1122 +@SYMDEF PDEF118811
1.1123 +*/
1.1124 +void TestScheduleTasksL()
1.1125 + {
1.1126 +
1.1127 + RClientMessageTestSession session;
1.1128 +
1.1129 + TInt err = session.Connect();
1.1130 +
1.1131 + CleanupClosePushL(session);
1.1132 +
1.1133 + err = session.TestRegisterClient(_L("MyClient"),0);
1.1134 + Test(err == KErrNone);
1.1135 +
1.1136 + TScheduleSettings2 settings;
1.1137 + TScheduleEntryInfo2 info;
1.1138 + TInt id1;
1.1139 + TInt taskId;
1.1140 +
1.1141 + TPckg<TScheduleSettings2> pSettings(settings);
1.1142 + TPckg<TScheduleEntryInfo2> pInfo(info);
1.1143 + TPckg<TInt> pId1(id1);
1.1144 + TPckg<TInt> pTaskId(taskId);
1.1145 +
1.1146 +
1.1147 + settings.iEntryCount = 1;
1.1148 + settings.iPersists = 0;
1.1149 +
1.1150 + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1);
1.1151 + Test(err == KErrNone);
1.1152 +
1.1153 + TTaskInfo taskInfo;
1.1154 + TPckg<TTaskInfo> pTaskInfo(taskInfo);
1.1155 + TBuf<32> taskData;
1.1156 +
1.1157 + err = session.TestScheduleTask(pTaskInfo, -1, pTaskId,taskData);
1.1158 + Test(err == KErrBadParameter);
1.1159 +
1.1160 + err = session.TestScheduleTask(pTaskInfo, 300000000, pTaskId,taskData);
1.1161 + Test(err == KErrBadParameter);
1.1162 +
1.1163 + err = session.TestDeleteTask(0);
1.1164 + Test(err == KErrNotFound);
1.1165 +
1.1166 + err = session.TestDeleteTask(249999999);
1.1167 + Test(err == KErrNotFound);
1.1168 +
1.1169 + err = session.TestDeleteTask(250000000);
1.1170 + Test(err == KErrNotFound);
1.1171 +
1.1172 + err = session.TestDeleteTask(-1);
1.1173 + Test(err == KErrNotFound);
1.1174 +
1.1175 + CleanupStack::PopAndDestroy(&session);
1.1176 + }
1.1177 +
1.1178 +void TestScheduleTasksPanic1L()
1.1179 + {
1.1180 + RClientMessageTestSession session;
1.1181 +
1.1182 + TInt err = session.Connect();
1.1183 +
1.1184 + CleanupClosePushL(session);
1.1185 +
1.1186 + err = session.TestRegisterClient(_L("MyClient"),0);
1.1187 + Test(err == KErrNone);
1.1188 +
1.1189 + TScheduleSettings2 settings;
1.1190 + TScheduleEntryInfo2 info;
1.1191 + TInt id1;
1.1192 + TInt taskId;
1.1193 +
1.1194 + TPckg<TScheduleSettings2> pSettings(settings);
1.1195 + TPckg<TScheduleEntryInfo2> pInfo(info);
1.1196 + TPckg<TInt> pId1(id1);
1.1197 + TPckg<TInt> pTaskId(taskId);
1.1198 +
1.1199 +
1.1200 + settings.iEntryCount = 1;
1.1201 + settings.iPersists = 0;
1.1202 +
1.1203 + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1);
1.1204 + Test(err == KErrNone);
1.1205 +
1.1206 + TTaskInfo taskInfo;
1.1207 + TPckg<TTaskInfo> pTaskInfo(taskInfo);
1.1208 + TBuf<32> taskData;
1.1209 +
1.1210 + //This should cause the server to panic the client as p0 is
1.1211 + //the wrong size
1.1212 + err = session.TestScheduleTask(pInfo, id1, pTaskId,taskData);
1.1213 +
1.1214 + CleanupStack::PopAndDestroy(&session);
1.1215 + }
1.1216 +
1.1217 +void TestScheduleTasksPanic2L()
1.1218 + {
1.1219 + RClientMessageTestSession session;
1.1220 +
1.1221 + TInt err = session.Connect();
1.1222 +
1.1223 + CleanupClosePushL(session);
1.1224 +
1.1225 + err = session.TestRegisterClient(_L("MyClient"),0);
1.1226 + Test(err == KErrNone);
1.1227 +
1.1228 + TScheduleSettings2 settings;
1.1229 + TScheduleEntryInfo2 info;
1.1230 + TInt id1;
1.1231 + TInt taskId;
1.1232 +
1.1233 + TPckg<TScheduleSettings2> pSettings(settings);
1.1234 + TPckg<TScheduleEntryInfo2> pInfo(info);
1.1235 + TPckg<TInt> pId1(id1);
1.1236 + TPckg<TInt> pTaskId(taskId);
1.1237 +
1.1238 +
1.1239 + settings.iEntryCount = 1;
1.1240 + settings.iPersists = 0;
1.1241 +
1.1242 + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1);
1.1243 + Test(err == KErrNone);
1.1244 +
1.1245 + TTaskInfo taskInfo;
1.1246 + TPckg<TTaskInfo> pTaskInfo(taskInfo);
1.1247 + TBuf<32> taskData;
1.1248 +
1.1249 + //This should cause the server to panic the client as p2 is too large
1.1250 + err = session.TestScheduleTask(pTaskInfo, id1, pTaskInfo,taskData);
1.1251 +
1.1252 + CleanupStack::PopAndDestroy(&session);
1.1253 + }
1.1254 +
1.1255 +
1.1256 +/**
1.1257 +@SYMTestCaseID SYSLIB-SCHSVR-CT-4009
1.1258 +@SYMTestCaseDesc Tests Get Task Data API robustness
1.1259 +@SYMTestPriority High
1.1260 +@SYMTestActions Calls the Get Task Data APIs passing in varying parameters
1.1261 + to test the robustness of the API
1.1262 +@SYMTestExpectedResults The server should be robust to badly formed messages and should
1.1263 + return KErrBadParameter if messages do not fit the constraints
1.1264 + defined in the message schema.
1.1265 +@SYMDEF PDEF118811
1.1266 +*/
1.1267 +void TestGetTaskDataL()
1.1268 + {
1.1269 +
1.1270 + RClientMessageTestSession session;
1.1271 +
1.1272 + TInt err = session.Connect();
1.1273 +
1.1274 + CleanupClosePushL(session);
1.1275 +
1.1276 + err = session.TestRegisterClient(_L("MyClient"),0);
1.1277 + Test(err == KErrNone);
1.1278 +
1.1279 + TSchedulerItemRef itemRef;
1.1280 + TScheduleInfo schedInfo;
1.1281 + TTaskInfo taskInfo;
1.1282 + TInt id1;
1.1283 + TInt count;
1.1284 + TInt taskId;
1.1285 +
1.1286 + TPckg<TScheduleInfo> pSchedInfo(schedInfo);
1.1287 + TPckg<TSchedulerItemRef> pItemRef(itemRef);
1.1288 + TPckg<TTaskInfo> pTaskInfo(taskInfo);
1.1289 + TPckg<TInt> pId1(id1);
1.1290 + TPckg<TInt> pCount(count);
1.1291 + TPckg<TInt> pTaskId(taskId);
1.1292 +
1.1293 +
1.1294 + err = session.TestGetTaskData(-1,pSchedInfo,pTaskInfo);
1.1295 + Test(err == KErrBadParameter);
1.1296 +
1.1297 + err = session.TestGetTaskData(340000000,pSchedInfo,pTaskInfo);
1.1298 + Test(err == KErrBadParameter);
1.1299 +
1.1300 + err = session.TestGetTaskRefs(0,0,0,pItemRef);
1.1301 + Test(err == KErrArgument);
1.1302 +
1.1303 + err = session.TestGetTaskRefs(-1,EAllSchedules,EAllTasks,pItemRef);
1.1304 + Test(err == KErrBadParameter);
1.1305 +
1.1306 + err = session.TestGetTaskRefs(340000000, EAllSchedules,EMyTasks,pItemRef);
1.1307 + Test(err == KErrBadParameter);
1.1308 +
1.1309 + err = session.TestGetTaskRefs(1,-1,EAllTasks,pItemRef);
1.1310 + Test(err == KErrBadParameter);
1.1311 +
1.1312 + err = session.TestGetTaskRefs(1,3,EAllTasks,pItemRef);
1.1313 + Test(err == KErrBadParameter);
1.1314 +
1.1315 + err = session.TestGetTaskRefs(1,EPendingSchedules,-1,pItemRef);
1.1316 + Test(err == KErrBadParameter);
1.1317 +
1.1318 + err = session.TestGetTaskRefs(1,EPendingSchedules,2,pItemRef);
1.1319 + Test(err == KErrBadParameter);
1.1320 +
1.1321 + err = session.TestGetTaskRefs(1,EAllSchedules,EMyTasks,pItemRef);
1.1322 + Test(err == KErrArgument);
1.1323 +
1.1324 + err = session.TestCountTasks(pCount,EAllSchedules,EMyTasks);
1.1325 + Test(err == KErrNone);
1.1326 +
1.1327 + err = session.TestCountTasks(pCount,-1,EMyTasks);
1.1328 + Test(err == KErrBadParameter);
1.1329 +
1.1330 + err = session.TestCountTasks(pCount,2,EMyTasks);
1.1331 + Test(err == KErrBadParameter);
1.1332 +
1.1333 + err = session.TestCountTasks(pCount,EAllSchedules,-1);
1.1334 + Test(err == KErrBadParameter);
1.1335 +
1.1336 + err = session.TestCountTasks(pCount,EAllSchedules,2);
1.1337 + Test(err == KErrBadParameter);
1.1338 +
1.1339 + err = session.TestGetTaskDataSize(0,pCount);
1.1340 + Test(err == KErrNotFound);
1.1341 +
1.1342 + err = session.TestGetTaskDataSize(249999999,pCount);
1.1343 + Test(err == KErrNotFound);
1.1344 +
1.1345 + err = session.TestGetTaskDataSize(250000000,pCount);
1.1346 + Test(err == KErrNotFound);
1.1347 +
1.1348 + err = session.TestGetTaskDataSize(-1,pCount);
1.1349 + Test(err == KErrNotFound);
1.1350 +
1.1351 + TBuf<10> data;
1.1352 +
1.1353 + err = session.TestGetTaskInfo(0,pTaskInfo,10,data);
1.1354 + Test(err == KErrNotFound);
1.1355 +
1.1356 + err = session.TestGetTaskInfo(249999999,pTaskInfo,10,data);
1.1357 + Test(err == KErrNotFound);
1.1358 +
1.1359 + err = session.TestGetTaskInfo(250000000,pTaskInfo,10,data);
1.1360 + Test(err == KErrNotFound);
1.1361 +
1.1362 + err = session.TestGetTaskInfo(-1,pTaskInfo,10,data);
1.1363 + Test(err == KErrNotFound);
1.1364 +
1.1365 + TSchedulerItemRef schedItem;
1.1366 + TTsTime time;
1.1367 +
1.1368 + TPckg<TSchedulerItemRef> pSchedItem(schedItem);
1.1369 + TPckg<TTsTime> pTime(time);
1.1370 +
1.1371 + err = session.TestGetScheduleItemRef(0,pSchedItem,pTime);
1.1372 + Test(err == KErrNone);
1.1373 +
1.1374 + err = session.TestGetScheduleItemRef(249999999,pSchedItem,pTime);
1.1375 + Test(err == KErrNotFound);
1.1376 +
1.1377 + err = session.TestGetScheduleItemRef(250000000,pSchedItem,pTime);
1.1378 + Test(err == KErrBadParameter);
1.1379 +
1.1380 + err = session.TestGetScheduleItemRef(-1,pSchedItem,pTime);
1.1381 + Test(err == KErrBadParameter);
1.1382 +
1.1383 + CleanupStack::PopAndDestroy(&session);
1.1384 + }
1.1385 +
1.1386 +
1.1387 +static void DoAPITestsL()
1.1388 + {
1.1389 +
1.1390 + TExitDetails exitDetails;
1.1391 +
1.1392 + Test.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4005 Test Create Schedule APIs "));
1.1393 + exitDetails = LaunchTestThreadL(_L("TestCreateSchedulesL"), &TestCreateSchedulesL);
1.1394 + Test(exitDetails.iExitType == EExitKill);
1.1395 +
1.1396 + exitDetails = LaunchTestThreadL(_L("TestCreateSchedulesPanic1L"), &TestCreateSchedulesPanic1L);
1.1397 + Test(exitDetails.iExitType == EExitPanic);
1.1398 + Test(exitDetails.iReason == KErrBadDescriptor);
1.1399 +
1.1400 + exitDetails = LaunchTestThreadL(_L("TestCreateSchedulesPanic2L"), &TestCreateSchedulesPanic2L);
1.1401 + Test(exitDetails.iExitType == EExitPanic);
1.1402 + Test(exitDetails.iReason == KErrBadDescriptor);
1.1403 +
1.1404 + Test.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4006 Test Edit Schedule APIs "));
1.1405 + exitDetails = LaunchTestThreadL(_L("TestEditSchedulesL"), &TestEditSchedulesL);
1.1406 + Test(exitDetails.iExitType == EExitKill);
1.1407 +
1.1408 + Test.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4007 "));
1.1409 + exitDetails = LaunchTestThreadL(_L("TestGetScheduleDataL"), &TestGetScheduleDataL);
1.1410 + Test(exitDetails.iExitType == EExitKill);
1.1411 +
1.1412 + exitDetails = LaunchTestThreadL(_L("TestGetScheduleDataPanic1L"), &TestGetScheduleDataPanic1L);
1.1413 + Test(exitDetails.iExitType == EExitPanic);
1.1414 + Test(exitDetails.iReason == KErrOverflow);
1.1415 +
1.1416 + Test.Next(_L(" Test Get Schedule Data APIs "));
1.1417 + exitDetails = LaunchTestThreadL(_L("TestGetScheduleDataPanic2L"), &TestGetScheduleDataPanic2L);
1.1418 + Test(exitDetails.iExitType == EExitPanic);
1.1419 + Test(exitDetails.iReason == KErrOverflow);
1.1420 +
1.1421 + Test.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4008 Test Schedule Task APIs "));
1.1422 + exitDetails = LaunchTestThreadL(_L("TestScheduleTasksL"), &TestScheduleTasksL);
1.1423 + Test(exitDetails.iExitType == EExitKill);
1.1424 +
1.1425 + exitDetails = LaunchTestThreadL(_L("TestScheduleTasksPanic1L"), &TestScheduleTasksPanic1L);
1.1426 + Test(exitDetails.iExitType == EExitPanic);
1.1427 + Test(exitDetails.iReason == KErrBadDescriptor);
1.1428 +
1.1429 + exitDetails = LaunchTestThreadL(_L("TestScheduleTasksPanic2L"), &TestScheduleTasksPanic2L);
1.1430 + Test(exitDetails.iExitType == EExitPanic);
1.1431 + Test(exitDetails.iReason == KErrBadDescriptor);
1.1432 +
1.1433 + Test.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4009 Test Get Task Data APIs "));
1.1434 + exitDetails = LaunchTestThreadL(_L("TestGetTaskDataL"), &TestGetTaskDataL);
1.1435 + Test(exitDetails.iExitType == EExitKill);
1.1436 +
1.1437 + }
1.1438 +
1.1439 +
1.1440 +
1.1441 +
1.1442 +
1.1443 +
1.1444 +GLDEF_C TInt E32Main ()
1.1445 + {
1.1446 +
1.1447 + Test.Printf (_L ("\n"));
1.1448 + Test.Title ();
1.1449 + Test.Start (_L("IPC Fuzz Tests"));
1.1450 +
1.1451 + CTrapCleanup* cleanup=CTrapCleanup::New();
1.1452 +
1.1453 + TInt err=KErrNoMemory;
1.1454 + if (cleanup)
1.1455 + {
1.1456 +
1.1457 + // Construct and install the active scheduler
1.1458 + CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;
1.1459 + CActiveScheduler::Install (scheduler);
1.1460 +
1.1461 + KillProcess(KServerProcess);
1.1462 + User::After(1000000);
1.1463 +
1.1464 + TRAP (err, DoFuzzTestsL ());
1.1465 + Test (err == KErrNone);
1.1466 +
1.1467 + Test.Next(_L("Task Scheduler API Robustness Tests"));
1.1468 + TRAP (err, DoAPITestsL ());
1.1469 + Test (err == KErrNone);
1.1470 +
1.1471 + Test.End ();
1.1472 + Test.Close ();
1.1473 +
1.1474 + delete scheduler;
1.1475 + delete cleanup;
1.1476 +
1.1477 + }
1.1478 + return err;
1.1479 + }