Symaptic: os/ossrv/genericservices/taskscheduler/Test/Robustness/TC_TSCH

     1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    17 #include <e32test.h>

    18 #include <e32math.h>

    19 #include <e32debug.h>

    20 #include "CSCHCODE.H"

    21 #include "SCHINFO.H"

    22 #include <bsul/bsul.h>

    23 #include <schinfointernal.h>

    24 using namespace BSUL;

    27 LOCAL_D RTest				Test (_L("TC_TSCH_IPC"));

    29 _LIT(KServerName, "!TaskScheduler");

    30 _LIT(KServerProcess, "SchExe");

    32 struct TTestInfo

    33 	{

    34 	TInt iFunction;

    35 	TInt iType;

    36 	TInt iArgCount;

    37 	};

    39 struct TExitDetails

    40 	{

    41 	TExitCategoryName iCategory;

    42 	TExitType iExitType;

    43 	TInt iReason;

    44 	};

    46 const TInt KAsynchDelay = 500000;

    48 const TInt KFunctionNumbers [] = {	ERegisterClient,

    49 									ECreateTimeSchedule,

    50 									ECreateConditionSchedule,

    51 									EScheduleTask,

    52 									ERemoveTask,

    53 									EDisableSchedule,

    54 									EEnableSchedule,

    55 									EDeleteSchedule,

    56 									EEditTimeSchedule,

    57 									EEditConditionSchedule,

    58 									EGetScheduleInfo,

    59 									EGetTimeScheduleData,

    60 									EGetConditionScheduleData,

    61 									EGetTaskData,

    62 									ECountSchedules,

    63 									ECountTasks,

    64 									EGetTaskRefs,

    65 									EGetTask,

    66 									EGetTaskDataSize,

    67 									EGetScheduleRefs,

    68 									EDeleteTask,

    69 									EGetSchedulerItemRefAndNextDueTime,

    70 									EGetScheduleType};

    72 const TInt KNumFunctions = sizeof(KFunctionNumbers)/sizeof(KFunctionNumbers[0]);

    74 //===============================================================================

    76 TBool IsFunctionAsynchronous(TInt aFunc)

    77 	{

    78 	TBool asynch = EFalse;

    79 	switch(aFunc)

    80 		{

    82 		default:

    83 			break;

    84 		}

    85 	return asynch;

    86 	}

    88 class RIpcFuzzTest : public RSessionBase

    89 {

    90 public: // Constructors and destructor

    92 	/**

    93 		* Constructor for performing 1st stage construction

    94 		*/

    95 	RIpcFuzzTest();

    97 	/**

    98 		* Destructor.

    99 		*/

   100 	~RIpcFuzzTest();

   102 	/**

   103 		* Performs test steps

   104 		*/

   106 	void RunTestL(const TDesC& aTargetSrvName, TInt aFunc,

   107 				TInt aTestType, TInt aArgCount);

   109 private:

   110 	TInt Fuzz(TInt aMsg, TInt aArgCount);

   111 	TInt FuzzL(TInt aMsg, TInt aArgCount);

   112 	TInt Fuzz8L(TInt aMsg, TInt aArgCount);

   113 };

   115 RIpcFuzzTest::RIpcFuzzTest()

   116 	{

   117 	// No implementation required

   118 	}

   121 RIpcFuzzTest::~RIpcFuzzTest()

   122 	{

   123 	Close();

   124 	}

   126 TInt RIpcFuzzTest::Fuzz(TInt aMsg, TInt aArgCount)

   127 	{

   128 	TIpcArgs args;

   130 	for(TInt i = 0; i < aArgCount;i++)

   131 		{

   132 		args.Set(i,Math::Random());

   133 		}

   135 	TInt ret;

   137 	if(IsFunctionAsynchronous(aMsg))

   138 		{

   139 		ret = Send(aMsg, args);

   140 		User::After(KAsynchDelay);

   141 		}

   142 	else

   143 		{

   144 		ret = SendReceive(aMsg, args);

   145 		}

   146 	return ret;

   147 	}

   149 TInt RIpcFuzzTest::Fuzz8L(TInt aMsg, TInt aArgCount)

   150 	{

   151 	HBufC8* buf = HBufC8::NewLC(255);

   152 	TPtr8 ptr = buf->Des();

   153 	ptr.Fill(Math::Random(),255);

   155 	TIpcArgs args;

   157 	for(TInt i = 0; i < aArgCount;i++)

   158 		{

   159 		args.Set(i,&ptr);

   160 		}

   162 	TInt ret;

   164 	if(IsFunctionAsynchronous(aMsg))

   165 		{

   166 		ret = Send(aMsg, args);

   167 		User::After(KAsynchDelay);

   168 		}

   169 	else

   170 		{

   171 		ret = SendReceive(aMsg, args);

   172 		}

   174 	CleanupStack::PopAndDestroy(buf);

   175 	return ret;

   176 	}

   178 TInt RIpcFuzzTest::FuzzL(TInt aMsg, TInt aArgCount)

   179 	{

   180 	HBufC* buf = HBufC::NewLC(255);

   181 	TPtr ptr = buf->Des();

   182 	ptr.Fill(Math::Random(),255);

   184 	TIpcArgs args;

   186 	for(TInt i = 0; i < aArgCount;i++)

   187 		{

   188 		args.Set(i,&ptr);

   189 		}

   191 	TInt ret;

   193 	if(IsFunctionAsynchronous(aMsg))

   194 		{

   195 		ret = Send(aMsg, args);

   196 		User::After(KAsynchDelay);

   197 		}

   198 	else

   199 		{

   200 		ret = SendReceive(aMsg, args);

   201 		}

   203 	CleanupStack::PopAndDestroy(buf);

   204 	return ret;

   205 	}

   207 void RIpcFuzzTest::RunTestL(const TDesC& aTargetSrvName,

   208 							TInt aFunc, TInt aTestType, TInt aArgCount)

   209 	{

   210 		TVersion version(0,0,0);

   212 		TInt err = CreateSession(aTargetSrvName, version);

   214 		User::LeaveIfError(err);

   216 		switch(aTestType)

   217 			{

   218 			case 0:

   219 				Fuzz(aFunc,aArgCount);

   220 				break;

   222 			case 1:

   223 				Fuzz8L(aFunc,aArgCount);

   224 				break;

   226 			case 2:

   227 				FuzzL(aFunc,aArgCount);

   228 				break;

   229 			}

   230 	}

   232 TInt KillProcess(const TDesC& aProcessName)

   233 	{

   234 	TFullName name;

   236 	RDebug::Print(_L("Find and kill \"%S\" process.\n"), &aProcessName);

   238 	TBuf<64> pattern(aProcessName);

   239 	TInt length = pattern.Length();

   240 	pattern += _L("*");

   241 	TFindProcess procFinder(pattern);

   243 	while (procFinder.Next(name) == KErrNone)

   244 		{

   245 		if (name.Length() > length)

   246 			{//If found name is a string containing aProcessName string.

   247 			TChar c(name[length]);

   248 			if (c.IsAlphaDigit() ||

   249 				c == TChar('_') ||

   250 				c == TChar('-'))

   251 				{

   252 				// If the found name is other valid application name

   253 				// starting with aProcessName string.

   254 				RDebug::Print(_L(":: Process name: \"%S\".\n"), &name);

   255 				continue;

   256 				}

   257 			}

   258 		RProcess proc;

   259 		if (proc.Open(name) == KErrNone)

   260 			{

   261 			proc.Kill(0);

   262 			RDebug::Print(_L("\"%S\" process killed.\n"), &name);

   263 			}

   264 		proc.Close();

   265 		}

   266 	return KErrNone;

   267 	}

   270 TInt FuzzServerL(TAny* aTestInfo)

   271 	{

   272    	CTrapCleanup* cleanup=CTrapCleanup::New();

   273    	TInt err=KErrNoMemory;

   274    	if (cleanup)

   275    		{

   277 		TTestInfo* info = (TTestInfo*)aTestInfo;

   278 		RIpcFuzzTest fuzzer;

   280 		TRAP(err,fuzzer.RunTestL(KServerName,info->iFunction

   281 				,info->iType, info->iArgCount));

   283 		fuzzer.Close();

   285    		delete cleanup;

   286    		}

   287    	return err;

   288 	}

   291 void TestServerApi(TInt aFunctionNumber,

   292 			TInt aTestType,TInt aArgCount, TExitDetails& aExitDetails)

   293 	{

   295     TTestInfo testInfo;

   296 	testInfo.iFunction = aFunctionNumber;

   297 	testInfo.iType = aTestType;

   298 	testInfo.iArgCount = aArgCount;

   300     RThread thread;

   301     _LIT(KThreadName,"FuzzerThread" );

   302 	thread.Create(KThreadName,&FuzzServerL, KDefaultStackSize, NULL,&testInfo);

   304 	TRequestStatus threadStat;

   305 	thread.Logon(threadStat);

   307 	TBool jit = User::JustInTime();

   308 	User::SetJustInTime(EFalse);

   310 	thread.Resume();

   312 	User::WaitForRequest(threadStat);

   314 	User::SetJustInTime(jit);

   316 	aExitDetails.iCategory = thread.ExitCategory();

   317 	aExitDetails.iReason = thread.ExitReason();

   318 	aExitDetails.iExitType = thread.ExitType();

   320 	thread.Close();

   322 	}

   325 TInt LaunchServer(RProcess& aServer)

   326 	{

   328 	Test.Printf(_L("Launching Task Scheduler...\n"));

   330 	const TUid KServerUid3 = {0x10005399};

   331 	const TUidType serverUid(KNullUid,KNullUid,KServerUid3);

   333 	TInt err = aServer.Create(KServerProcess, _L(""),serverUid);

   335 	if(err == KErrNone)

   336 		{

   337 		aServer.SetPriority(EPriorityForeground);

   339 		//Start server and wait until it is running

   340 		TRequestStatus serverStat;

   341 		aServer.SetJustInTime(false);

   342 		aServer.Resume();

   344 		aServer.Rendezvous(serverStat);

   345 		User::WaitForRequest(serverStat);

   346 		}

   348 	 return err;

   350 	}

   352 void PrintTestMessage(TInt iFunc, TInt iType, TInt iArgCount)

   353 	{

   354 	switch(iType)

   355 		{

   356 		case 0:

   357 			Test.Printf(_L("\nFuzz Test on function number %d using random Int data. Number of Args = %d"), iFunc, iArgCount);

   358 			break;

   360 		case 1:

   361 			Test.Printf(_L("\nFuzz Test on function number %d using random Des8 data. Number of Args = %d"), iFunc, iArgCount);

   362 			break;

   364 		case 2:

   365 			Test.Printf(_L("\nFuzz Test on function number %d using random Des data. Number of Args = %d"), iFunc, iArgCount);

   366 			break;

   368 		}

   370 	}

   372 /**

   373 Invoke the tests

   374 */

   375 /**

   376 @SYMTestCaseID          SYSLIB-SCHSVR-CT-4004

   377 @SYMTestCaseDesc	    Tests SchSvr APIs for IPC Robustness

   378 @SYMTestPriority 	    High

   379 @SYMTestActions  	    The function calls each of the SchSvr APIs through a custom session object

   380 						passing random TInt, Des8 and Des16 data .

   381 @SYMTestExpectedResults The server should be robust to all malformed messages and should not

   382 						hang or panic.

   383 @SYMDEF                	PDEF118811

   384 */

   385 LOCAL_C void DoFuzzTestsL ()

   386     {

   387     Test.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4004 "));

   388     RProcess server;

   390     User::LeaveIfError(LaunchServer(server));

   392     TExitDetails exitDetails;

   394     for(TInt i = 0;i< KNumFunctions;i++)

   395     	{

   397     	//Carry out each type of test

   398     	for(TInt testType = 0; testType < 3;testType++)

   399     		{

   400        		//Carry out each test with number of arguments 1 - 4

   401     		for(TInt argCount = 1;argCount <= 4;argCount++)

   402     			{

   403     			PrintTestMessage(KFunctionNumbers[i], testType, argCount);

   405     			TestServerApi(KFunctionNumbers[i], testType, argCount, exitDetails);

   406 		    	//Kill the server process and verify that it was still running

   407 		    	//If the server was already dead it would return the reason it exited

   408 	    		if(server.ExitType() != EExitPending)

   409 	    			{

   410 	    			server.Kill(0);

   411 	    			TInt exitReason = server.ExitReason();

   412 	    			server.Close();

   413 	    			Test(exitReason == 0);

   414 	    			User::LeaveIfError(LaunchServer(server));

   415 	    			}

   416     			}

   418     		Test.Printf(_L("\nFuzz Test Successful\n"));

   419     		}

   420     	}

   421     }

   424 /*

   425  * SERVER API TESTING

   426  */

   428 typedef void (*TestFunction)();

   430 class RClientMessageTestSession : public RSessionBase

   431 	{

   432 public:

   433 	TInt Connect();

   435 	TInt TestRegisterClient(const TDesC& aData0, TInt aArg1);

   437 	TInt TestCreateTimeSchedule(TDesC8& aData0,TDesC8& aData1,TDes8& aData2);

   438 	TInt TestCreateCondSchedule(TDesC8& aData0,TDesC8& aData1,TDesC8& aData2,TDes8& aData3);

   440 	TInt TestScheduleTask(TDesC8& aData0,TInt aArg1,TDes8& aData2,TDesC& aData3);

   441 	TInt TestDeleteTask(TInt aArg0);

   442 	TInt TestDeleteSchedule(TInt aArg0);

   443 	TInt TestDisableSchedule(TInt aArg0);

   444 	TInt TestEnableSchedule(TInt aArg0);

   446 	TInt TestEditTimeSchedule(TInt aArg0, TInt aArg1, TDes8& aData2);

   447 	TInt TestEditCondSchedule(TInt aArg0, TInt aArg1, TDes8& aData2, TDes8& aData3);

   449 	TInt TestGetScheduleRefs(TInt aArg0, TInt aArg1, TDes8& aData2);

   450 	TInt TestCountSchedules(TDes8& aData0, TInt aArg1);

   451 	TInt TestGetScheduleType(TInt aArg0,TDes8& aData1);

   452 	TInt TestGetScheduleInfo(TInt aArg0, TDes8& aData1, TDes8& aData2);

   453 	TInt TestGetTimeScheduleData(TInt aArg0, TDes8& aData1, TDes8& aData2);

   454 	TInt TestGetCondScheduleData(TInt aArg0, TDes8& aData1, TDes8& aData2, TDes8& aData3);

   455 	TInt TestGetScheduleItemRef(TInt aArg0, TDes8& aData1, TDes8& aData2);

   457 	TInt TestGetTaskData(TInt aArg0, TDes8& aData1, TDes8& aData2);

   458 	TInt TestGetTaskRefs(TInt aArg0, TInt aArg1,TInt aArg2, TDes8& aData3);

   459 	TInt TestCountTasks(TDes8& aData0, TInt aArg1, TInt aArg2);

   460 	TInt TestGetTaskInfo(TInt aArg0,TDesC8& aData1,TInt aArg2,TDesC& aData3);

   461 	TInt TestGetTaskDataSize(TInt aArg0,TDesC8& aData1);

   464 	};

   466 static TInt LaunchLogServerL()

   467 	{

   469 	RProcess process;

   471 	TInt err = process.Create(KServerProcess,_L(""));

   473 	if(err == KErrNone)

   474 		{

   475 		 TRequestStatus serverStat;

   477 		 process.SetJustInTime(EFalse);

   478 		 process.Resume();

   479 		 process.Rendezvous(serverStat);

   480 		 User::WaitForRequest(serverStat);

   481 		}

   483 	return err;

   484 	}

   487 TInt RClientMessageTestSession::Connect()

   488 	{

   489 	TInt retry = 2;

   490 	for(;;)

   491 		{

   492 		TInt r = CreateSession(KServerName,TVersion(1,0,0));

   494 		if((r != KErrNotFound)&&(r != KErrServerTerminated))

   495 			{

   496 			return r;

   497 			}

   499 		if(--retry == 0)

   500 			{

   501 			return r;

   502 			}

   504 		r = LaunchLogServerL();

   505 		if((r != KErrNone)&&(r != KErrAlreadyExists))

   506 			{

   507 			return r;

   508 			}

   509 		}

   510 	}

   512 TInt RClientMessageTestSession::TestRegisterClient(const TDesC& aData0, TInt aArg1)

   513 	{

   514 	return SendReceive(ERegisterClient,TIpcArgs(&aData0, aArg1));

   515 	}

   517 TInt RClientMessageTestSession::TestCreateTimeSchedule(TDesC8& aData0,TDesC8& aData1,TDes8& aData2)

   518 	{

   519 	return SendReceive(ECreateTimeSchedule,TIpcArgs(&aData0, &aData1,& aData2));

   520 	}

   522 TInt RClientMessageTestSession::TestCreateCondSchedule(TDesC8& aData0,TDesC8& aData1,TDesC8& aData2,TDes8& aData3)

   523 	{

   524 	return SendReceive(ECreateConditionSchedule,TIpcArgs(&aData0,&aData1, &aData2, &aData3));

   525 	}

   527 TInt RClientMessageTestSession::TestScheduleTask(TDesC8& aData0,TInt aArg1,TDes8& aData2,TDesC& aData3)

   528 	{

   529 	return SendReceive(EScheduleTask,TIpcArgs(&aData0, aArg1, &aData2, &aData3));

   530 	}

   532 TInt RClientMessageTestSession::TestDeleteTask(TInt aArg0)

   533 	{

   534 	return SendReceive(EDeleteTask,TIpcArgs(aArg0));

   535 	}

   537 TInt RClientMessageTestSession::TestDeleteSchedule(TInt aArg0)

   538 	{

   539 	return SendReceive(EDeleteSchedule,TIpcArgs(aArg0));

   540 	}

   542 TInt RClientMessageTestSession::TestDisableSchedule(TInt aArg0)

   543 	{

   544 	return SendReceive(EDisableSchedule,TIpcArgs(aArg0));

   545 	}

   547 TInt RClientMessageTestSession::TestEnableSchedule(TInt aArg0)

   548 	{

   549 	return SendReceive(EEnableSchedule,TIpcArgs(aArg0));

   550 	}

   552 TInt RClientMessageTestSession::TestEditTimeSchedule(TInt aArg0, TInt aArg1, TDes8& aData2)

   553 	{

   554 	return SendReceive(EEditTimeSchedule,TIpcArgs(aArg0, aArg1, &aData2));

   555 	}

   557 TInt RClientMessageTestSession::TestEditCondSchedule(TInt aArg0, TInt aArg1, TDes8& aData2, TDes8& aData3)

   558 	{

   559 	return SendReceive(EEditConditionSchedule,TIpcArgs(aArg0, aArg1, &aData2,&aData3));

   560 	}

   563 TInt RClientMessageTestSession::TestGetScheduleRefs(TInt aArg0, TInt aArg1, TDes8& aData2)

   564 	{

   565 	return SendReceive(EGetScheduleRefs,TIpcArgs(aArg0, aArg1, &aData2));

   566 	}

   568 TInt RClientMessageTestSession::TestCountSchedules(TDes8& aData0, TInt aArg1)

   569 	{

   570 	return SendReceive(ECountSchedules,TIpcArgs(&aData0, aArg1));

   571 	}

   573 TInt RClientMessageTestSession::TestGetScheduleType(TInt aArg0,TDes8& aData1)

   574 	{

   575 	return SendReceive(EGetScheduleType,TIpcArgs(aArg0, &aData1));

   576 	}

   578 TInt RClientMessageTestSession::TestGetScheduleInfo(TInt aArg0, TDes8& aData1, TDes8& aData2)

   579 	{

   580 	return SendReceive(EGetScheduleInfo,TIpcArgs(aArg0, &aData1, &aData2));

   581 	}

   583 TInt RClientMessageTestSession::TestGetTimeScheduleData(TInt aArg0, TDes8& aData1, TDes8& aData2)

   584 	{

   585 	return SendReceive(EGetTimeScheduleData,TIpcArgs(aArg0, &aData1, &aData2));

   586 	}

   588 TInt RClientMessageTestSession::TestGetCondScheduleData(TInt aArg0, TDes8& aData1, TDes8& aData2, TDes8& aData3)

   589 	{

   590 	return SendReceive(EGetConditionScheduleData,TIpcArgs(aArg0, &aData1, &aData2, &aData3));

   591 	}

   593 TInt RClientMessageTestSession::TestGetScheduleItemRef(TInt aArg0, TDes8& aData1, TDes8& aData2)

   594 	{

   595 	return SendReceive(EGetSchedulerItemRefAndNextDueTime,TIpcArgs(aArg0, &aData1, &aData2));

   596 	}

   598 TInt RClientMessageTestSession::TestGetTaskData(TInt aArg0, TDes8& aData1, TDes8& aData2)

   599 	{

   600 	return SendReceive(EGetTaskData,TIpcArgs(aArg0, &aData1, &aData2));

   601 	}

   603 TInt RClientMessageTestSession::TestGetTaskRefs(TInt aArg0, TInt aArg1,TInt aArg2, TDes8& aData3)

   604 	{

   605 	return SendReceive(EGetTaskRefs,TIpcArgs(aArg0, aArg1, aArg2, &aData3));

   606 	}

   608 TInt RClientMessageTestSession::TestCountTasks(TDes8& aData0, TInt aArg1, TInt aArg2)

   609 	{

   610 	return SendReceive(ECountTasks,TIpcArgs(&aData0, aArg1, aArg2));

   611 	}

   613 TInt RClientMessageTestSession::TestGetTaskInfo(TInt aArg0,TDesC8& aData1,TInt aArg2,TDesC& aData3)

   614 	{

   615 	return SendReceive(EGetTask,TIpcArgs(aArg0, &aData1, aArg2, &aData3));

   616 	}

   618 TInt RClientMessageTestSession::TestGetTaskDataSize(TInt aArg0,TDesC8& aData1)

   619 	{

   620 	return SendReceive(EGetTaskDataSize,TIpcArgs(aArg0, &aData1));

   621 	}

   627 TInt TestFunctionLauncherL(TAny* aTestFunction)

   628 	{

   629    	CTrapCleanup* cleanup=CTrapCleanup::New();

   630    	TInt r=KErrNoMemory;

   631    	if (cleanup)

   632    		{

   633    		TestFunction function = (TestFunction)aTestFunction;

   635 __UHEAP_MARK;

   636  		TRAP(r,function());

   637 __UHEAP_MARKEND;

   639    		delete cleanup;

   640    		}

   641    	return r;

   642 	}

   645 TExitDetails LaunchTestThreadL(const TDesC& aThreadName, TestFunction aFunction)

   646 	{

   647 	RThread thread;

   648 	thread.Create(aThreadName, &TestFunctionLauncherL, KDefaultStackSize, NULL, (TAny*)aFunction);

   650 	TRequestStatus threadStat;

   651 	thread.Logon(threadStat);

   653 	TBool jit = User::JustInTime();

   654 	User::SetJustInTime(EFalse);

   656 	thread.Resume();

   657 	User::WaitForRequest(threadStat);

   659 	User::SetJustInTime(jit);

   661 	TExitDetails exitDetails;

   662 	exitDetails.iCategory = thread.ExitCategory();

   663 	exitDetails.iReason = thread.ExitReason();

   664 	exitDetails.iExitType = thread.ExitType();

   666 	return exitDetails;

   667 	}

   671 /**

   672 @SYMTestCaseID          SYSLIB-SCHSVR-CT-4005

   673 @SYMTestCaseDesc	    Tests Create Schedule API robustness

   674 @SYMTestPriority 	    High

   675 @SYMTestActions  	    Calls the Create Schedule APIs passing in varying parameters

   676 						to test the robustness of the API

   677 @SYMTestExpectedResults The server should be robust to badly formed messages and should

   678 						return KErrBadParameter if messages do not fit the constraints

   679 						defined in the message schema.

   680 						The server should panic the client with KErrBadDescriptor if an

   681 						invalid descriptor argument is passed.

   682 @SYMDEF                	PDEF118811

   683 */

   684 void TestCreateSchedulesL()

   685 	{

   687 	RClientMessageTestSession session;

   689 	TInt err = session.Connect();

   691 	CleanupClosePushL(session);

   693 	err = session.TestRegisterClient(_L("MyClient"),0);

   694 	Test(err == KErrNone);

   696 	err = session.TestRegisterClient(_L("MyClient2"),-1);

   697 	Test(err == KErrBadParameter);

   699 	TScheduleSettings2 settings;

   700 	TScheduleEntryInfo2 info;

   701 	TInt id;

   703 	TPckg<TScheduleSettings2> pSettings(settings);

   704 	TPckg<TScheduleEntryInfo2> pInfo(info);

   705 	TPckg<TInt> pId(id);

   707 	settings.iPersists = -1;

   708 	settings.iEntryCount = -1;

   710 	err = session.TestCreateTimeSchedule(pSettings, pInfo, pId);

   711 	Test(err == KErrBadParameter);

   713 	settings.iPersists = 0;

   714 	settings.iEntryCount = 1;

   716 	err = session.TestCreateTimeSchedule(pSettings, pInfo, pId);

   717 	Test(err == KErrNone);

   719 	TTsTime time;

   720 	TPckg<TTsTime> pTime(time);

   721 	TTaskSchedulerCondition conditions;

   722 	TPckg<TTaskSchedulerCondition> pConditions(conditions);

   724 	err = session.TestCreateCondSchedule(pSettings, pConditions, pTime,pId);

   725 	Test(err == KErrNone);

   727 	err = session.TestDisableSchedule(id);

   728 	Test(err == KErrNone);

   730 	err = session.TestDisableSchedule(249990000);

   731 	Test(err == KErrNotFound);

   733 	err = session.TestDisableSchedule(-1);

   734 	Test(err == KErrBadParameter);

   736 	err = session.TestDisableSchedule(250000000);

   737 	Test(err == KErrBadParameter);

   739 	CleanupStack::PopAndDestroy(&session);

   740 	}

   742 void TestCreateSchedulesPanic1L()

   743 	{

   744 	RClientMessageTestSession session;

   746 	TInt err = session.Connect();

   748 	CleanupClosePushL(session);

   750 	err = session.TestRegisterClient(_L("MyClient"),0);

   751 	Test(err == KErrNone);

   753 	TScheduleSettings2 settings;

   754 	TScheduleEntryInfo2 info;

   755 	TInt id;

   757 	TPckg<TScheduleSettings2> pSettings(settings);

   758 	TPckg<TScheduleEntryInfo2> pInfo(info);

   759 	TPckg<TInt> pId(id);

   761 	settings.iPersists = 0;

   762 	settings.iEntryCount = 0;

   764 	err = session.TestCreateTimeSchedule(pSettings, pInfo, pId);

   765 	Test(err == KErrNone);

   767 	CleanupStack::PopAndDestroy(&session);

   768 	}

   770 void TestCreateSchedulesPanic2L()

   771 	{

   772 	RClientMessageTestSession session;

   774 	TInt err = session.Connect();

   776 	CleanupClosePushL(session);

   778 	err = session.TestRegisterClient(_L("MyClient"),0);

   779 	Test(err == KErrNone);

   781 	TScheduleSettings2 settings;

   782 	TTaskSchedulerCondition conditions;

   783 	TTsTime time;

   784 	TInt id;

   786 	TPckg<TScheduleSettings2> pSettings(settings);

   787 	TPckg<TTaskSchedulerCondition> pConditions(conditions);

   788 	TPckg<TTsTime> pTime(time);

   789 	TPckg<TInt> pId(id);

   791 	settings.iEntryCount = 2;

   792 	settings.iPersists = 0;

   794 	err = session.TestCreateCondSchedule(pSettings, pConditions, pTime,pId);

   795 	Test(err == KErrNone);

   797 	CleanupStack::PopAndDestroy(&session);

   798 	}

   800 /**

   801 @SYMTestCaseID          SYSLIB-SCHSVR-CT-4006

   802 @SYMTestCaseDesc	    Tests Edit Schedule API robustness

   803 @SYMTestPriority 	    High

   804 @SYMTestActions  	    Calls the Edit Schedule APIs passing in varying parameters

   805 						to test the robustness of the API

   806 @SYMTestExpectedResults The server should be robust to badly formed messages and should

   807 						return KErrBadParameter if messages do not fit the constraints

   808 						defined in the message schema.

   809 @SYMDEF                	PDEF118811

   810 */

   811 void TestEditSchedulesL()

   812 	{

   814 	RClientMessageTestSession session;

   816 	TInt err = session.Connect();

   818 	CleanupClosePushL(session);

   820 	err = session.TestRegisterClient(_L("MyClient"),0);

   821 	Test(err == KErrNone);

   823 	TScheduleSettings2 settings;

   824 	TTaskSchedulerCondition conditions;

   825 	TTsTime time;

   826 	TInt id1;

   827 	TInt id2;

   828 	TScheduleInfo schedInfo;

   830 	TPckg<TScheduleSettings2> pSettings(settings);

   831 	TPckg<TTaskSchedulerCondition> pConditions(conditions);

   832 	TPckg<TTsTime> pTime(time);

   833 	TPckg<TInt> pId1(id1);

   834 	TPckg<TInt> pId2(id2);

   835 	TPckg<TScheduleInfo> pSchedInfo(schedInfo);

   837 	settings.iEntryCount = 1;

   838 	settings.iPersists = 0;

   840 	TScheduleEntryInfo2 info;

   841 	TPckg<TScheduleEntryInfo2> pInfo(info);

   843 	err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1);

   844 	Test(err == KErrNone);

   846 	err = session.TestEditTimeSchedule(settings.iEntryCount, id1,pInfo );

   847 	Test(err == KErrNone);

   849 	err = session.TestEditTimeSchedule(-1, id1,pInfo );

   850 	Test(err == KErrBadParameter);

   852 	err = session.TestEditTimeSchedule(10000, id1,pInfo );

   853 	Test(err == KErrBadParameter);

   855 	err = session.TestEditTimeSchedule(settings.iEntryCount, -1,pInfo );

   856 	Test(err == KErrBadParameter);

   858 	err = session.TestEditTimeSchedule(settings.iEntryCount,300000000,pInfo );

   859 	Test(err == KErrBadParameter);

   861 	err = session.TestCreateCondSchedule(pSettings, pConditions, pTime,pId2);

   862 	Test(err == KErrNone);

   864 	err = session.TestEditCondSchedule(settings.iEntryCount, id2,pConditions, pTime );

   865 	Test(err == KErrNone);

   867 	err = session.TestEditCondSchedule(-231, id2,pConditions, pTime );

   868 	Test(err == KErrBadParameter);

   870 	err = session.TestEditCondSchedule(11000, id2,pConditions, pTime );

   871 	Test(err == KErrBadParameter);

   873 	err = session.TestEditCondSchedule(settings.iEntryCount, -1,pConditions, pTime );

   874 	Test(err == KErrBadParameter);

   876 	err = session.TestEditCondSchedule(settings.iEntryCount, 250000000,pConditions, pTime );

   877 	Test(err == KErrBadParameter);

   879 	CleanupStack::PopAndDestroy(&session);

   881 	}

   883 /**

   884 @SYMTestCaseID          SYSLIB-SCHSVR-CT-4007

   885 @SYMTestCaseDesc	    Tests  Schedule Data API robustness

   886 @SYMTestPriority 	    High

   887 @SYMTestActions  	    Calls the Get Schedule Data APIs passing in varying parameters

   888 						to test the robustness of the API

   889 @SYMTestExpectedResults The server should be robust to badly formed messages and should

   890 						return KErrBadParameter if messages do not fit the constraints

   891 						defined in the message schema.

   892 						The server should panic the client with KErrBadDescriptor if an

   893 						invalid descriptor argument is passed.

   894 @SYMDEF                	PDEF118811

   895 */

   896 void TestGetScheduleDataL()

   897 	{

   898 	RClientMessageTestSession session;

   900 		TInt err = session.Connect();

   902 		CleanupClosePushL(session);

   904 		err = session.TestRegisterClient(_L("MyClient"),0);

   905 		Test(err == KErrNone);

   907 		TScheduleSettings2 settings;

   908 		TTaskSchedulerCondition conditions;

   909 		TTsTime time;

   910 		TInt id1;

   911 		TInt id2;

   912 		TScheduleInfo schedInfo;

   914 		TPckg<TScheduleSettings2> pSettings(settings);

   915 		TPckg<TTaskSchedulerCondition> pConditions(conditions);

   916 		TPckg<TTsTime> pTime(time);

   917 		TPckg<TInt> pId1(id1);

   918 		TPckg<TInt> pId2(id2);

   919 		TPckg<TScheduleInfo> pSchedInfo(schedInfo);

   921 		settings.iEntryCount = 1;

   922 		settings.iPersists = 0;

   924 		TScheduleEntryInfo2 info;

   925 		TPckg<TScheduleEntryInfo2> pInfo(info);

   927 		err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1);

   928 		Test(err == KErrNone);

   930 		err = session.TestCreateCondSchedule(pSettings, pConditions, pTime,pId2);

   931 		Test(err == KErrNone);

   933 		err = session.TestGetScheduleInfo(id1,pSchedInfo, pTime);

   934 		Test(err == KErrNone);

   936 		err = session.TestGetScheduleInfo(-1,pSchedInfo, pTime);

   937 		Test(err == KErrBadParameter);

   939 		err = session.TestGetScheduleInfo(250000000,pSchedInfo, pTime);

   940 		Test(err == KErrBadParameter);

   942 		TInt count;

   943 		TPckg<TInt> pCount(count);

   945 		err = session.TestCountSchedules(pCount, -378);

   946 		Test(err == KErrBadParameter);

   948 		err = session.TestCountSchedules(pCount, EAllSchedules);

   949 		Test(err == KErrNone);

   951 		err = session.TestCountSchedules(pCount, EPendingSchedules);

   952 		Test(err == KErrNone);

   954 		err = session.TestCountSchedules(pCount, 3);

   955 		Test(err == KErrBadParameter);

   957 		schedInfo.iEntryCount = 1;

   959 		err = session.TestGetTimeScheduleData(id1,pSchedInfo, pInfo);

   960 		Test(err == KErrNone);

   962 		schedInfo.iEntryCount = 23;

   964 		err = session.TestGetTimeScheduleData(id1,pSchedInfo, pInfo);

   965 		Test(err == KErrArgument);

   967 		schedInfo.iEntryCount = 1;

   969 		err = session.TestGetTimeScheduleData(250000000,pSchedInfo, pInfo);

   970 		Test(err == KErrBadParameter);

   972 		err = session.TestGetCondScheduleData(id2,pSchedInfo, pInfo, pTime);

   973 		Test(err == KErrNone);

   975 		schedInfo.iEntryCount = 23;

   977 		err = session.TestGetCondScheduleData(id2,pSchedInfo, pInfo, pTime);

   978 		Test(err == KErrArgument);

   980 		schedInfo.iEntryCount = 1;

   982 		err = session.TestGetCondScheduleData(250000000,pSchedInfo, pInfo, pTime);

   983 		Test(err == KErrBadParameter);

   985 		err = session.TestGetCondScheduleData(-3,pSchedInfo, pInfo, pTime);

   986 		Test(err == KErrBadParameter);

   988 		err = session.TestCountSchedules(pCount, EAllSchedules);

   989 		Test(err == KErrNone);

   991 		HBufC8* data = HBufC8::NewL(sizeof(TSchedulerItemRef)* count);

   992 		TPtr8 pData = data->Des();

   994 		err = session.TestGetScheduleRefs(count,EAllSchedules,pData);

   995 		Test(err == KErrNone);

   997 		err = session.TestCountSchedules(pCount, EPendingSchedules);

   998 		Test(err == KErrNone);

  1000 		err = session.TestGetScheduleRefs(count,EPendingSchedules,pData);

  1001 		Test(err == KErrArgument);

  1003 		err = session.TestGetScheduleRefs(count,3,pData);

  1004 		Test(err == KErrBadParameter);

  1006 		err = session.TestGetScheduleRefs(count,-1,pData);

  1007 		Test(err == KErrBadParameter);

  1009 		err = session.TestGetScheduleRefs(-5,EAllSchedules,pData);

  1010 		Test(err == KErrBadParameter);

  1012 		delete data;

  1014 		TInt type;

  1015 		TPckg<TInt> pType(type);

  1017 		err = session.TestGetScheduleType(id1,pType);

  1018 		Test(err == KErrNone);

  1020 		err = session.TestGetScheduleType(id2,pType);

  1021 		Test(err == KErrNone);

  1023 		err = session.TestGetScheduleType(-1,pType);

  1024 		Test(err == KErrBadParameter);

  1026 		err = session.TestGetScheduleType(250000002,pType);

  1027 		Test(err == KErrBadParameter);

  1029 		CleanupStack::PopAndDestroy(&session);

  1030 	}

  1032 void TestGetScheduleDataPanic1L()

  1033 	{

  1034 	RClientMessageTestSession session;

  1036 	TInt err = session.Connect();

  1038 	CleanupClosePushL(session);

  1040 	err = session.TestRegisterClient(_L("MyClient"),0);

  1041 	Test(err == KErrNone);

  1043 	TScheduleSettings2 settings;

  1044 	TTaskSchedulerCondition conditions;

  1045 	TTsTime time;

  1046 	TInt id1;

  1047 	TScheduleInfo schedInfo;

  1049 	TPckg<TScheduleSettings2> pSettings(settings);

  1050 	TPckg<TTsTime> pTime(time);

  1051 	TPckg<TInt> pId1(id1);

  1052 	TPckg<TScheduleInfo> pSchedInfo(schedInfo);

  1054 	settings.iEntryCount = 1;

  1055 	settings.iPersists = 0;

  1057 	TScheduleEntryInfo2 info;

  1058 	TPckg<TScheduleEntryInfo2> pInfo(info);

  1060 	schedInfo.iEntryCount = 1;

  1062 	err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1);

  1063 	Test(err == KErrNone);

  1065 	err = session.TestGetTimeScheduleData(id1,pSchedInfo, pId1);

  1066 	Test(err == KErrOverflow);

  1068 	CleanupStack::PopAndDestroy(&session);

  1069 	}

  1071 void TestGetScheduleDataPanic2L()

  1072 	{

  1073 	RClientMessageTestSession session;

  1075 	TInt err = session.Connect();

  1077 	CleanupClosePushL(session);

  1079 	err = session.TestRegisterClient(_L("MyClient"),0);

  1080 	Test(err == KErrNone);

  1082 	TScheduleSettings2 settings;

  1083 	TInt id1;

  1084 	TInt count;

  1086 	TPckg<TScheduleSettings2> pSettings(settings);

  1087 	TPckg<TInt> pId1(id1);

  1088 	TPckg<TInt> pCount(count);

  1090 	settings.iEntryCount = 1;

  1091 	settings.iPersists = 0;

  1093 	TScheduleEntryInfo2 info;

  1094 	TPckg<TScheduleEntryInfo2> pInfo(info);

  1096 	err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1);

  1097 	Test(err == KErrNone);

  1099 	err = session.TestCountSchedules(pCount, EAllSchedules);

  1100 	Test(err == KErrNone);

  1102 	err = session.TestGetScheduleRefs(count,EAllSchedules,pInfo);

  1103 	Test(err == KErrOverflow);

  1105 	CleanupStack::PopAndDestroy(&session);

  1106 	}

  1108 /**

  1109 @SYMTestCaseID          SYSLIB-SCHSVR-CT-4008

  1110 @SYMTestCaseDesc	    Tests  Schedule Task API robustness

  1111 @SYMTestPriority 	    High

  1112 @SYMTestActions  	    Calls the Schedule Tasks APIs passing in varying parameters

  1113 						to test the robustness of the API

  1114 @SYMTestExpectedResults The server should be robust to badly formed messages and should

  1115 						return KErrBadParameter if messages do not fit the constraints

  1116 						defined in the message schema.

  1117 						The server should panic the client with KErrBadDescriptor if an

  1118 						invalid descriptor argument is passed.

  1119 @SYMDEF                	PDEF118811

  1120 */

  1121 void TestScheduleTasksL()

  1122 	{

  1124 	RClientMessageTestSession session;

  1126 	TInt err = session.Connect();

  1128 	CleanupClosePushL(session);

  1130 	err = session.TestRegisterClient(_L("MyClient"),0);

  1131 	Test(err == KErrNone);

  1133 	TScheduleSettings2 settings;

  1134 	TScheduleEntryInfo2 info;

  1135 	TInt id1;

  1136 	TInt taskId;

  1138 	TPckg<TScheduleSettings2> pSettings(settings);

  1139 	TPckg<TScheduleEntryInfo2> pInfo(info);

  1140 	TPckg<TInt> pId1(id1);

  1141 	TPckg<TInt> pTaskId(taskId);

  1144 	settings.iEntryCount = 1;

  1145 	settings.iPersists = 0;

  1147 	err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1);

  1148 	Test(err == KErrNone);

  1150 	TTaskInfo taskInfo;

  1151 	TPckg<TTaskInfo> pTaskInfo(taskInfo);

  1152 	TBuf<32> taskData;

  1154 	err = session.TestScheduleTask(pTaskInfo, -1, pTaskId,taskData);

  1155 	Test(err == KErrBadParameter);

  1157 	err = session.TestScheduleTask(pTaskInfo, 300000000, pTaskId,taskData);

  1158 	Test(err == KErrBadParameter);

  1160 	err = session.TestDeleteTask(0);

  1161 	Test(err == KErrNotFound);

  1163 	err = session.TestDeleteTask(249999999);

  1164 	Test(err == KErrNotFound);

  1166 	err = session.TestDeleteTask(250000000);

  1167 	Test(err == KErrNotFound);

  1169 	err = session.TestDeleteTask(-1);

  1170 	Test(err == KErrNotFound);

  1172 	CleanupStack::PopAndDestroy(&session);

  1173 	}

  1175 void TestScheduleTasksPanic1L()

  1176 	{

  1177 	RClientMessageTestSession session;

  1179 	TInt err = session.Connect();

  1181 	CleanupClosePushL(session);

  1183 	err = session.TestRegisterClient(_L("MyClient"),0);

  1184 	Test(err == KErrNone);

  1186 	TScheduleSettings2 settings;

  1187 	TScheduleEntryInfo2 info;

  1188 	TInt id1;

  1189 	TInt taskId;

  1191 	TPckg<TScheduleSettings2> pSettings(settings);

  1192 	TPckg<TScheduleEntryInfo2> pInfo(info);

  1193 	TPckg<TInt> pId1(id1);

  1194 	TPckg<TInt> pTaskId(taskId);

  1197 	settings.iEntryCount = 1;

  1198 	settings.iPersists = 0;

  1200 	err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1);

  1201 	Test(err == KErrNone);

  1203 	TTaskInfo taskInfo;

  1204 	TPckg<TTaskInfo> pTaskInfo(taskInfo);

  1205 	TBuf<32> taskData;

  1207 	//This should cause the server to panic the client as p0 is

  1208 	//the wrong size

  1209 	err = session.TestScheduleTask(pInfo, id1, pTaskId,taskData);

  1211 	CleanupStack::PopAndDestroy(&session);

  1212 	}

  1214 void TestScheduleTasksPanic2L()

  1215 	{

  1216 	RClientMessageTestSession session;

  1218 	TInt err = session.Connect();

  1220 	CleanupClosePushL(session);

  1222 	err = session.TestRegisterClient(_L("MyClient"),0);

  1223 	Test(err == KErrNone);

  1225 	TScheduleSettings2 settings;

  1226 	TScheduleEntryInfo2 info;

  1227 	TInt id1;

  1228 	TInt taskId;

  1230 	TPckg<TScheduleSettings2> pSettings(settings);

  1231 	TPckg<TScheduleEntryInfo2> pInfo(info);

  1232 	TPckg<TInt> pId1(id1);

  1233 	TPckg<TInt> pTaskId(taskId);

  1236 	settings.iEntryCount = 1;

  1237 	settings.iPersists = 0;

  1239 	err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1);

  1240 	Test(err == KErrNone);

  1242 	TTaskInfo taskInfo;

  1243 	TPckg<TTaskInfo> pTaskInfo(taskInfo);

  1244 	TBuf<32> taskData;

  1246 	//This should cause the server to panic the client as p2 is too large

  1247 	err = session.TestScheduleTask(pTaskInfo, id1, pTaskInfo,taskData);

  1249 	CleanupStack::PopAndDestroy(&session);

  1250 	}

  1253 /**

  1254 @SYMTestCaseID          SYSLIB-SCHSVR-CT-4009

  1255 @SYMTestCaseDesc	    Tests  Get Task Data API robustness

  1256 @SYMTestPriority 	    High

  1257 @SYMTestActions  	    Calls the Get Task Data APIs passing in varying parameters

  1258 						to test the robustness of the API

  1259 @SYMTestExpectedResults The server should be robust to badly formed messages and should

  1260 						return KErrBadParameter if messages do not fit the constraints

  1261 						defined in the message schema.

  1262 @SYMDEF                	PDEF118811

  1263 */

  1264 void TestGetTaskDataL()

  1265 	{

  1267 	RClientMessageTestSession session;

  1269 	TInt err = session.Connect();

  1271 	CleanupClosePushL(session);

  1273 	err = session.TestRegisterClient(_L("MyClient"),0);

  1274 	Test(err == KErrNone);

  1276 	TSchedulerItemRef itemRef;

  1277 	TScheduleInfo schedInfo;

  1278 	TTaskInfo taskInfo;

  1279 	TInt id1;

  1280 	TInt count;

  1281 	TInt taskId;

  1283 	TPckg<TScheduleInfo> pSchedInfo(schedInfo);

  1284 	TPckg<TSchedulerItemRef> pItemRef(itemRef);

  1285 	TPckg<TTaskInfo> pTaskInfo(taskInfo);

  1286 	TPckg<TInt> pId1(id1);

  1287 	TPckg<TInt> pCount(count);

  1288 	TPckg<TInt> pTaskId(taskId);

  1291 	err = session.TestGetTaskData(-1,pSchedInfo,pTaskInfo);

  1292 	Test(err == KErrBadParameter);

  1294 	err = session.TestGetTaskData(340000000,pSchedInfo,pTaskInfo);

  1295 	Test(err == KErrBadParameter);

  1297 	err = session.TestGetTaskRefs(0,0,0,pItemRef);

  1298 	Test(err == KErrArgument);

  1300 	err = session.TestGetTaskRefs(-1,EAllSchedules,EAllTasks,pItemRef);

  1301 	Test(err == KErrBadParameter);

  1303 	err = session.TestGetTaskRefs(340000000, EAllSchedules,EMyTasks,pItemRef);

  1304 	Test(err == KErrBadParameter);

  1306 	err = session.TestGetTaskRefs(1,-1,EAllTasks,pItemRef);

  1307 	Test(err == KErrBadParameter);

  1309 	err = session.TestGetTaskRefs(1,3,EAllTasks,pItemRef);

  1310 	Test(err == KErrBadParameter);

  1312 	err = session.TestGetTaskRefs(1,EPendingSchedules,-1,pItemRef);

  1313 	Test(err == KErrBadParameter);

  1315 	err = session.TestGetTaskRefs(1,EPendingSchedules,2,pItemRef);

  1316 	Test(err == KErrBadParameter);

  1318 	err = session.TestGetTaskRefs(1,EAllSchedules,EMyTasks,pItemRef);

  1319 	Test(err == KErrArgument);

  1321 	err = session.TestCountTasks(pCount,EAllSchedules,EMyTasks);

  1322 	Test(err == KErrNone);

  1324 	err = session.TestCountTasks(pCount,-1,EMyTasks);

  1325 	Test(err == KErrBadParameter);

  1327 	err = session.TestCountTasks(pCount,2,EMyTasks);

  1328 	Test(err == KErrBadParameter);

  1330 	err = session.TestCountTasks(pCount,EAllSchedules,-1);

  1331 	Test(err == KErrBadParameter);

  1333 	err = session.TestCountTasks(pCount,EAllSchedules,2);

  1334 	Test(err == KErrBadParameter);

  1336 	err = session.TestGetTaskDataSize(0,pCount);

  1337 	Test(err == KErrNotFound);

  1339 	err = session.TestGetTaskDataSize(249999999,pCount);

  1340 	Test(err == KErrNotFound);

  1342 	err = session.TestGetTaskDataSize(250000000,pCount);

  1343 	Test(err == KErrNotFound);

  1345 	err = session.TestGetTaskDataSize(-1,pCount);

  1346 	Test(err == KErrNotFound);

  1348 	TBuf<10> data;

  1350 	err = session.TestGetTaskInfo(0,pTaskInfo,10,data);

  1351 	Test(err == KErrNotFound);

  1353 	err = session.TestGetTaskInfo(249999999,pTaskInfo,10,data);

  1354 	Test(err == KErrNotFound);

  1356 	err = session.TestGetTaskInfo(250000000,pTaskInfo,10,data);

  1357 	Test(err == KErrNotFound);

  1359 	err = session.TestGetTaskInfo(-1,pTaskInfo,10,data);

  1360 	Test(err == KErrNotFound);

  1362 	TSchedulerItemRef schedItem;

  1363 	TTsTime time;

  1365 	TPckg<TSchedulerItemRef> pSchedItem(schedItem);

  1366 	TPckg<TTsTime> pTime(time);

  1368 	err = session.TestGetScheduleItemRef(0,pSchedItem,pTime);

  1369 	Test(err == KErrNone);

  1371 	err = session.TestGetScheduleItemRef(249999999,pSchedItem,pTime);

  1372 	Test(err == KErrNotFound);

  1374 	err = session.TestGetScheduleItemRef(250000000,pSchedItem,pTime);

  1375 	Test(err == KErrBadParameter);

  1377 	err = session.TestGetScheduleItemRef(-1,pSchedItem,pTime);

  1378 	Test(err == KErrBadParameter);

  1380 	CleanupStack::PopAndDestroy(&session);

  1381 	}

  1384 static void DoAPITestsL()

  1385 	{

  1387 	TExitDetails exitDetails;

  1389 	Test.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4005 Test Create Schedule APIs "));

  1390 	exitDetails = LaunchTestThreadL(_L("TestCreateSchedulesL"), &TestCreateSchedulesL);

  1391 	Test(exitDetails.iExitType == EExitKill);

  1393 	exitDetails = LaunchTestThreadL(_L("TestCreateSchedulesPanic1L"), &TestCreateSchedulesPanic1L);

  1394 	Test(exitDetails.iExitType == EExitPanic);

  1395 	Test(exitDetails.iReason == KErrBadDescriptor);

  1397 	exitDetails = LaunchTestThreadL(_L("TestCreateSchedulesPanic2L"), &TestCreateSchedulesPanic2L);

  1398 	Test(exitDetails.iExitType == EExitPanic);

  1399 	Test(exitDetails.iReason == KErrBadDescriptor);

  1401 	Test.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4006 Test Edit Schedule APIs "));

  1402 	exitDetails = LaunchTestThreadL(_L("TestEditSchedulesL"), &TestEditSchedulesL);

  1403 	Test(exitDetails.iExitType == EExitKill);

  1405 	Test.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4007 "));

  1406 	exitDetails = LaunchTestThreadL(_L("TestGetScheduleDataL"), &TestGetScheduleDataL);

  1407 	Test(exitDetails.iExitType == EExitKill);

  1409 	exitDetails = LaunchTestThreadL(_L("TestGetScheduleDataPanic1L"), &TestGetScheduleDataPanic1L);

  1410 	Test(exitDetails.iExitType == EExitPanic);

  1411 	Test(exitDetails.iReason == KErrOverflow);

  1413 	Test.Next(_L("  Test Get Schedule Data APIs "));

  1414 	exitDetails = LaunchTestThreadL(_L("TestGetScheduleDataPanic2L"), &TestGetScheduleDataPanic2L);

  1415 	Test(exitDetails.iExitType == EExitPanic);

  1416 	Test(exitDetails.iReason == KErrOverflow);

  1418 	Test.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4008 Test Schedule Task APIs "));

  1419 	exitDetails = LaunchTestThreadL(_L("TestScheduleTasksL"), &TestScheduleTasksL);

  1420 	Test(exitDetails.iExitType == EExitKill);

  1422 	exitDetails = LaunchTestThreadL(_L("TestScheduleTasksPanic1L"), &TestScheduleTasksPanic1L);

  1423 	Test(exitDetails.iExitType == EExitPanic);

  1424 	Test(exitDetails.iReason == KErrBadDescriptor);

  1426 	exitDetails = LaunchTestThreadL(_L("TestScheduleTasksPanic2L"), &TestScheduleTasksPanic2L);

  1427 	Test(exitDetails.iExitType == EExitPanic);

  1428 	Test(exitDetails.iReason == KErrBadDescriptor);

  1430 	Test.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4009 Test Get Task Data APIs "));

  1431 	exitDetails = LaunchTestThreadL(_L("TestGetTaskDataL"), &TestGetTaskDataL);

  1432 	Test(exitDetails.iExitType == EExitKill);

  1434 	}

  1441 GLDEF_C TInt E32Main ()

  1442 	{

  1444 	Test.Printf (_L ("\n"));

  1445 	Test.Title ();

  1446 	Test.Start (_L("IPC Fuzz Tests"));

  1448    	CTrapCleanup* cleanup=CTrapCleanup::New();

  1450    	TInt err=KErrNoMemory;

  1451    	if (cleanup)

  1452    		{

  1454    		// Construct and install the active scheduler

  1455    		CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

  1456    		CActiveScheduler::Install (scheduler);

  1458    		KillProcess(KServerProcess);

  1459    		User::After(1000000);

  1461    		TRAP (err, DoFuzzTestsL ());

  1462    		Test (err == KErrNone);

  1464    		Test.Next(_L("Task Scheduler API Robustness Tests"));

  1465    		TRAP (err, DoAPITestsL ());

  1466    		Test (err == KErrNone);

  1468    		Test.End ();

  1469    		Test.Close ();

  1471    		delete scheduler;

  1472    		delete cleanup;

  1474    		}

  1475 	return err;

  1476 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200 (2014-06-10)
changeset 1	260cb5ec6c19
permissions	-rw-r--r--