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 //

    15  

    16 

    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;

    25 

    26 

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

    28 

    29 _LIT(KServerName, "!TaskScheduler");

    30 _LIT(KServerProcess, "SchExe");

    31 

    32 struct TTestInfo

    33 	{

    34 	TInt iFunction;

    35 	TInt iType;

    36 	TInt iArgCount;

    37 	};

    38 

    39 struct TExitDetails

    40 	{

    41 	TExitCategoryName iCategory;

    42 	TExitType iExitType;

    43 	TInt iReason;

    44 	};

    45 

    46 const TInt KAsynchDelay = 500000;

    47 

    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};

    71 

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

    73 

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

    75 

    76 TBool IsFunctionAsynchronous(TInt aFunc)

    77 	{

    78 	TBool asynch = EFalse;

    79 	switch(aFunc)

    80 		{			

    81 			

    82 		default:

    83 			break;

    84 		}

    85 	return asynch;

    86 	}

    87 

    88 class RIpcFuzzTest : public RSessionBase

    89 {

    90 public: // Constructors and destructor

    91 

    92 	/**

    93 		* Constructor for performing 1st stage construction

    94 		*/

    95 	RIpcFuzzTest();

    96 

    97 	/**

    98 		* Destructor.

    99 		*/

   100 	~RIpcFuzzTest();

   101 

   102 	/**

   103 		* Performs test steps

   104 		*/

   105 	

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

   107 				TInt aTestType, TInt aArgCount);

   108 	

   109 private:

   110 	TInt Fuzz(TInt aMsg, TInt aArgCount);

   111 	TInt FuzzL(TInt aMsg, TInt aArgCount);

   112 	TInt Fuzz8L(TInt aMsg, TInt aArgCount);

   113 };

   114 

   115 RIpcFuzzTest::RIpcFuzzTest()

   116 	{

   117 	// No implementation required

   118 	}

   119 

   120 

   121 RIpcFuzzTest::~RIpcFuzzTest()

   122 	{

   123 	Close();	

   124 	}

   125 

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

   127 	{

   128 	TIpcArgs args;

   129 	

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

   131 		{

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

   133 		}	

   134 	

   135 	TInt ret;

   136 	

   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 	}

   148 

   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);

   154 	

   155 	TIpcArgs args;

   156 	

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

   158 		{

   159 		args.Set(i,&ptr);

   160 		}

   161 	

   162 	TInt ret;

   163 	

   164 	if(IsFunctionAsynchronous(aMsg))

   165 		{

   166 		ret = Send(aMsg, args);

   167 		User::After(KAsynchDelay);

   168 		}

   169 	else

   170 		{

   171 		ret = SendReceive(aMsg, args);

   172 		}

   173 

   174 	CleanupStack::PopAndDestroy(buf);

   175 	return ret;

   176 	}

   177 

   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);

   183 

   184 	TIpcArgs args;

   185 	

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

   187 		{

   188 		args.Set(i,&ptr);

   189 		}

   190 	

   191 	TInt ret;

   192 	

   193 	if(IsFunctionAsynchronous(aMsg))

   194 		{

   195 		ret = Send(aMsg, args);

   196 		User::After(KAsynchDelay);

   197 		}

   198 	else

   199 		{

   200 		ret = SendReceive(aMsg, args);

   201 		}

   202 

   203 	CleanupStack::PopAndDestroy(buf);

   204 	return ret;

   205 	}

   206 

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

   208 							TInt aFunc, TInt aTestType, TInt aArgCount)

   209 	{

   210 		TVersion version(0,0,0);

   211 	

   212 		TInt err = CreateSession(aTargetSrvName, version);

   213 		

   214 		User::LeaveIfError(err);

   215 	

   216 		switch(aTestType)

   217 			{

   218 			case 0:

   219 				Fuzz(aFunc,aArgCount);

   220 				break;

   221 				

   222 			case 1:

   223 				Fuzz8L(aFunc,aArgCount);

   224 				break;

   225 				

   226 			case 2:

   227 				FuzzL(aFunc,aArgCount);

   228 				break;			

   229 			}

   230 	}

   231 

   232 TInt KillProcess(const TDesC& aProcessName)

   233 	{

   234 	TFullName name;

   235 

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

   237 

   238 	TBuf<64> pattern(aProcessName);

   239 	TInt length = pattern.Length();

   240 	pattern += _L("*");

   241 	TFindProcess procFinder(pattern);

   242 

   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 	}

   268 

   269 

   270 TInt FuzzServerL(TAny* aTestInfo)

   271 	{

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

   273    	TInt err=KErrNoMemory;

   274    	if (cleanup)

   275    		{

   276    		

   277 		TTestInfo* info = (TTestInfo*)aTestInfo;

   278 		RIpcFuzzTest fuzzer;

   279 		

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

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

   282 		

   283 		fuzzer.Close();

   284 

   285    		delete cleanup;

   286    		}

   287    	return err;

   288 	}

   289 

   290 

   291 void TestServerApi(TInt aFunctionNumber,

   292 			TInt aTestType,TInt aArgCount, TExitDetails& aExitDetails)

   293 	{

   294     

   295     TTestInfo testInfo;

   296 	testInfo.iFunction = aFunctionNumber;

   297 	testInfo.iType = aTestType;

   298 	testInfo.iArgCount = aArgCount;

   299     

   300     RThread thread;	

   301     _LIT(KThreadName,"FuzzerThread" );

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

   303 	

   304 	TRequestStatus threadStat;

   305 	thread.Logon(threadStat);

   306 	

   307 	TBool jit = User::JustInTime();

   308 	User::SetJustInTime(EFalse);

   309 	

   310 	thread.Resume();

   311 	

   312 	User::WaitForRequest(threadStat);

   313 	

   314 	User::SetJustInTime(jit);

   315 

   316 	aExitDetails.iCategory = thread.ExitCategory();

   317 	aExitDetails.iReason = thread.ExitReason();

   318 	aExitDetails.iExitType = thread.ExitType();

   319 	

   320 	thread.Close();

   321 

   322 	}

   323 

   324 

   325 TInt LaunchServer(RProcess& aServer)

   326 	{

   327 	

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

   329 	

   330 	const TUid KServerUid3 = {0x10005399};	

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

   332 	

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

   334 	 

   335 	if(err == KErrNone)

   336 		{   

   337 		aServer.SetPriority(EPriorityForeground);  

   338 		 

   339 		//Start server and wait until it is running

   340 		TRequestStatus serverStat;

   341 		aServer.SetJustInTime(false);   

   342 		aServer.Resume(); 

   343 		    

   344 		aServer.Rendezvous(serverStat);

   345 		User::WaitForRequest(serverStat);

   346 		}

   347 	 

   348 	 return err;

   349 	    

   350 	}

   351 

   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;

   359 			

   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;

   363 			

   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;

   367 			

   368 		}

   369 	

   370 	}

   371 

   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;

   389     

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

   391 

   392     TExitDetails exitDetails;

   393       

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

   395     	{

   396     	

   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);

   404 

   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     			}

   417 	    	

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

   419     		}

   420     	}

   421     }

   422 

   423 

   424 /*

   425  * SERVER API TESTING

   426  */

   427 

   428 typedef void (*TestFunction)();

   429 

   430 class RClientMessageTestSession : public RSessionBase

   431 	{

   432 public:

   433 	TInt Connect();

   434 	

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

   436 	

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

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

   439 	

   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);

   445 	

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

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

   448 	

   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);

   456 		

   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);

   462 

   463 

   464 	};

   465 

   466 static TInt LaunchLogServerL()

   467 	{

   468 

   469 	RProcess process;

   470 

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

   472 	 

   473 	if(err == KErrNone)

   474 		{

   475 		 TRequestStatus serverStat;		

   476 		 

   477 		 process.SetJustInTime(EFalse);

   478 		 process.Resume();

   479 		 process.Rendezvous(serverStat);

   480 		 User::WaitForRequest(serverStat);

   481 		}

   482 	

   483 	return err;

   484 	}

   485 

   486 

   487 TInt RClientMessageTestSession::Connect()

   488 	{

   489 	TInt retry = 2;

   490 	for(;;)

   491 		{

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

   493 		

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

   495 			{

   496 			return r;

   497 			}

   498 		

   499 		if(--retry == 0)

   500 			{

   501 			return r;

   502 			}

   503 		

   504 		r = LaunchLogServerL();

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

   506 			{

   507 			return r;

   508 			}	

   509 		}

   510 	}

   511 

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

   513 	{

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

   515 	}

   516 

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

   518 	{

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

   520 	}

   521 

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

   523 	{

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

   525 	}

   526 

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

   528 	{

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

   530 	}

   531 

   532 TInt RClientMessageTestSession::TestDeleteTask(TInt aArg0)

   533 	{

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

   535 	}

   536 

   537 TInt RClientMessageTestSession::TestDeleteSchedule(TInt aArg0)

   538 	{

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

   540 	}

   541 

   542 TInt RClientMessageTestSession::TestDisableSchedule(TInt aArg0)

   543 	{

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

   545 	}

   546 

   547 TInt RClientMessageTestSession::TestEnableSchedule(TInt aArg0)

   548 	{

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

   550 	}

   551 

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

   553 	{

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

   555 	}

   556 

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

   558 	{

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

   560 	}

   561 

   562 

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

   564 	{

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

   566 	}

   567 

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

   569 	{

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

   571 	}

   572 

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

   574 	{

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

   576 	}

   577 

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

   579 	{

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

   581 	}

   582 

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

   584 	{

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

   586 	}

   587 

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

   589 	{

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

   591 	}

   592 

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

   594 	{

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

   596 	}

   597 

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

   599 	{

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

   601 	}

   602 

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

   604 	{

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

   606 	}

   607 

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

   609 	{

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

   611 	}

   612 

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

   614 	{

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

   616 	}

   617 

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

   619 	{

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

   621 	}

   622 

   623 

   624 

   625 

   626 

   627 TInt TestFunctionLauncherL(TAny* aTestFunction)

   628 	{

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

   630    	TInt r=KErrNoMemory;

   631    	if (cleanup)

   632    		{

   633    		TestFunction function = (TestFunction)aTestFunction;

   634 

   635 __UHEAP_MARK;  		

   636  		TRAP(r,function());

   637 __UHEAP_MARKEND;

   638  		

   639    		delete cleanup;

   640    		}

   641    	return r;

   642 	}

   643 

   644 

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

   646 	{

   647 	RThread thread;	

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

   649 	

   650 	TRequestStatus threadStat;

   651 	thread.Logon(threadStat);

   652 	

   653 	TBool jit = User::JustInTime();

   654 	User::SetJustInTime(EFalse);

   655 	

   656 	thread.Resume();

   657 	User::WaitForRequest(threadStat);

   658 	

   659 	User::SetJustInTime(jit);

   660 	 

   661 	TExitDetails exitDetails;

   662 	exitDetails.iCategory = thread.ExitCategory();

   663 	exitDetails.iReason = thread.ExitReason();

   664 	exitDetails.iExitType = thread.ExitType();

   665 	

   666 	return exitDetails;

   667 	}

   668 

   669 

   670 

   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 	{

   686 	

   687 	RClientMessageTestSession session;

   688 	

   689 	TInt err = session.Connect();

   690 	

   691 	CleanupClosePushL(session);

   692 	

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

   694 	Test(err == KErrNone);

   695 	

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

   697 	Test(err == KErrBadParameter);

   698 	

   699 	TScheduleSettings2 settings;

   700 	TScheduleEntryInfo2 info;

   701 	TInt id;

   702 	

   703 	TPckg<TScheduleSettings2> pSettings(settings);

   704 	TPckg<TScheduleEntryInfo2> pInfo(info);

   705 	TPckg<TInt> pId(id);

   706 	

   707 	settings.iPersists = -1;

   708 	settings.iEntryCount = -1;	

   709 	

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

   711 	Test(err == KErrBadParameter);

   712 	

   713 	settings.iPersists = 0;

   714 	settings.iEntryCount = 1;	

   715 	

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

   717 	Test(err == KErrNone);

   718 	

   719 	TTsTime time;

   720 	TPckg<TTsTime> pTime(time);

   721 	TTaskSchedulerCondition conditions;

   722 	TPckg<TTaskSchedulerCondition> pConditions(conditions);

   723 	

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

   725 	Test(err == KErrNone);

   726 	

   727 	err = session.TestDisableSchedule(id);

   728 	Test(err == KErrNone);

   729 	

   730 	err = session.TestDisableSchedule(249990000);

   731 	Test(err == KErrNotFound);

   732 	

   733 	err = session.TestDisableSchedule(-1);

   734 	Test(err == KErrBadParameter);

   735 	

   736 	err = session.TestDisableSchedule(250000000);

   737 	Test(err == KErrBadParameter);

   738 	

   739 	CleanupStack::PopAndDestroy(&session);

   740 	}

   741 

   742 void TestCreateSchedulesPanic1L()

   743 	{

   744 	RClientMessageTestSession session;

   745 	

   746 	TInt err = session.Connect();

   747 	

   748 	CleanupClosePushL(session);

   749 	

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

   751 	Test(err == KErrNone);

   752 	

   753 	TScheduleSettings2 settings;

   754 	TScheduleEntryInfo2 info;

   755 	TInt id;

   756 	

   757 	TPckg<TScheduleSettings2> pSettings(settings);

   758 	TPckg<TScheduleEntryInfo2> pInfo(info);

   759 	TPckg<TInt> pId(id);

   760 	

   761 	settings.iPersists = 0;

   762 	settings.iEntryCount = 0;	

   763 	

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

   765 	Test(err == KErrNone);

   766 

   767 	CleanupStack::PopAndDestroy(&session);

   768 	}

   769 

   770 void TestCreateSchedulesPanic2L()

   771 	{

   772 	RClientMessageTestSession session;

   773 	

   774 	TInt err = session.Connect();

   775 	

   776 	CleanupClosePushL(session);

   777 	

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

   779 	Test(err == KErrNone);

   780 	

   781 	TScheduleSettings2 settings;

   782 	TTaskSchedulerCondition conditions;

   783 	TTsTime time;

   784 	TInt id;

   785 	

   786 	TPckg<TScheduleSettings2> pSettings(settings);

   787 	TPckg<TTaskSchedulerCondition> pConditions(conditions);

   788 	TPckg<TTsTime> pTime(time);

   789 	TPckg<TInt> pId(id);

   790 	

   791 	settings.iEntryCount = 2;	

   792 	settings.iPersists = 0;

   793 	

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

   795 	Test(err == KErrNone);

   796 	

   797 	CleanupStack::PopAndDestroy(&session);

   798 	}

   799 

   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 	{

   813 	

   814 	RClientMessageTestSession session;

   815 	

   816 	TInt err = session.Connect();

   817 	

   818 	CleanupClosePushL(session);

   819 	

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

   821 	Test(err == KErrNone);

   822 	

   823 	TScheduleSettings2 settings;

   824 	TTaskSchedulerCondition conditions;

   825 	TTsTime time;

   826 	TInt id1;

   827 	TInt id2;

   828 	TScheduleInfo schedInfo;

   829 	

   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);

   836 	

   837 	settings.iEntryCount = 1;	

   838 	settings.iPersists = 0;

   839 	

   840 	TScheduleEntryInfo2 info;

   841 	TPckg<TScheduleEntryInfo2> pInfo(info);

   842 	

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

   844 	Test(err == KErrNone);

   845 	

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

   847 	Test(err == KErrNone);

   848 	

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

   850 	Test(err == KErrBadParameter);

   851 	

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

   853 	Test(err == KErrBadParameter);

   854 	

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

   856 	Test(err == KErrBadParameter);

   857 	

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

   859 	Test(err == KErrBadParameter);

   860 	

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

   862 	Test(err == KErrNone);

   863 	

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

   865 	Test(err == KErrNone);

   866 	

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

   868 	Test(err == KErrBadParameter);

   869 	

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

   871 	Test(err == KErrBadParameter);

   872 	

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

   874 	Test(err == KErrBadParameter);

   875 	

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

   877 	Test(err == KErrBadParameter);

   878 		

   879 	CleanupStack::PopAndDestroy(&session);

   880 

   881 	}

   882 

   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;

   899 		

   900 		TInt err = session.Connect();

   901 		

   902 		CleanupClosePushL(session);

   903 		

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

   905 		Test(err == KErrNone);

   906 		

   907 		TScheduleSettings2 settings;

   908 		TTaskSchedulerCondition conditions;

   909 		TTsTime time;

   910 		TInt id1;

   911 		TInt id2;

   912 		TScheduleInfo schedInfo;

   913 		

   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);

   920 		

   921 		settings.iEntryCount = 1;	

   922 		settings.iPersists = 0;

   923 		

   924 		TScheduleEntryInfo2 info;

   925 		TPckg<TScheduleEntryInfo2> pInfo(info);

   926 		

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

   928 		Test(err == KErrNone);

   929 		

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

   931 		Test(err == KErrNone);

   932 				

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

   934 		Test(err == KErrNone);

   935 		

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

   937 		Test(err == KErrBadParameter);

   938 		

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

   940 		Test(err == KErrBadParameter);

   941 		

   942 		TInt count;

   943 		TPckg<TInt> pCount(count);

   944 		

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

   946 		Test(err == KErrBadParameter);

   947 		

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

   949 		Test(err == KErrNone);

   950 		

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

   952 		Test(err == KErrNone);

   953 		

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

   955 		Test(err == KErrBadParameter);

   956 		

   957 		schedInfo.iEntryCount = 1;

   958 		

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

   960 		Test(err == KErrNone);

   961 		

   962 		schedInfo.iEntryCount = 23;

   963 		

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

   965 		Test(err == KErrArgument);

   966 		

   967 		schedInfo.iEntryCount = 1;

   968 		

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

   970 		Test(err == KErrBadParameter);

   971 		

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

   973 		Test(err == KErrNone);

   974 		

   975 		schedInfo.iEntryCount = 23;

   976 		

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

   978 		Test(err == KErrArgument);

   979 		

   980 		schedInfo.iEntryCount = 1;

   981 		

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

   983 		Test(err == KErrBadParameter);

   984 		

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

   986 		Test(err == KErrBadParameter);			

   987 		

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

   989 		Test(err == KErrNone);

   990 		

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

   992 		TPtr8 pData = data->Des();

   993 		

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

   995 		Test(err == KErrNone);

   996 		

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

   998 		Test(err == KErrNone);

   999 		

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

  1001 		Test(err == KErrArgument);

  1002 		

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

  1004 		Test(err == KErrBadParameter);

  1005 		

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

  1007 		Test(err == KErrBadParameter);

  1008 		

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

  1010 		Test(err == KErrBadParameter);

  1011 		

  1012 		delete data;

  1013 		

  1014 		TInt type;

  1015 		TPckg<TInt> pType(type);

  1016 		

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

  1018 		Test(err == KErrNone);

  1019 		

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

  1021 		Test(err == KErrNone);

  1022 		

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

  1024 		Test(err == KErrBadParameter);

  1025 		

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

  1027 		Test(err == KErrBadParameter);

  1028 		

  1029 		CleanupStack::PopAndDestroy(&session);

  1030 	}

  1031 

  1032 void TestGetScheduleDataPanic1L()

  1033 	{

  1034 	RClientMessageTestSession session;

  1035 		

  1036 	TInt err = session.Connect();

  1037 	

  1038 	CleanupClosePushL(session);

  1039 	

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

  1041 	Test(err == KErrNone);

  1042 	

  1043 	TScheduleSettings2 settings;

  1044 	TTaskSchedulerCondition conditions;

  1045 	TTsTime time;

  1046 	TInt id1;

  1047 	TScheduleInfo schedInfo;

  1048 	

  1049 	TPckg<TScheduleSettings2> pSettings(settings);

  1050 	TPckg<TTsTime> pTime(time);

  1051 	TPckg<TInt> pId1(id1);

  1052 	TPckg<TScheduleInfo> pSchedInfo(schedInfo);

  1053 	

  1054 	settings.iEntryCount = 1;	

  1055 	settings.iPersists = 0;

  1056 	

  1057 	TScheduleEntryInfo2 info;

  1058 	TPckg<TScheduleEntryInfo2> pInfo(info);

  1059 	

  1060 	schedInfo.iEntryCount = 1;

  1061 	

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

  1063 	Test(err == KErrNone);

  1064 	

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

  1066 	Test(err == KErrOverflow);

  1067 

  1068 	CleanupStack::PopAndDestroy(&session);

  1069 	}

  1070 

  1071 void TestGetScheduleDataPanic2L()

  1072 	{

  1073 	RClientMessageTestSession session;

  1074 		

  1075 	TInt err = session.Connect();

  1076 	

  1077 	CleanupClosePushL(session);

  1078 	

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

  1080 	Test(err == KErrNone);

  1081 	

  1082 	TScheduleSettings2 settings;

  1083 	TInt id1;

  1084 	TInt count;

  1085 	

  1086 	TPckg<TScheduleSettings2> pSettings(settings);

  1087 	TPckg<TInt> pId1(id1);

  1088 	TPckg<TInt> pCount(count);

  1089 	

  1090 	settings.iEntryCount = 1;	

  1091 	settings.iPersists = 0;

  1092 	

  1093 	TScheduleEntryInfo2 info;

  1094 	TPckg<TScheduleEntryInfo2> pInfo(info);

  1095 	

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

  1097 	Test(err == KErrNone);

  1098 	

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

  1100 	Test(err == KErrNone);

  1101 		

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

  1103 	Test(err == KErrOverflow);

  1104 	

  1105 	CleanupStack::PopAndDestroy(&session);

  1106 	}

  1107 

  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 	{

  1123 	

  1124 	RClientMessageTestSession session;

  1125 		

  1126 	TInt err = session.Connect();

  1127 	

  1128 	CleanupClosePushL(session);

  1129 	

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

  1131 	Test(err == KErrNone);

  1132 	

  1133 	TScheduleSettings2 settings;

  1134 	TScheduleEntryInfo2 info;

  1135 	TInt id1;