1 // Copyright (c) 2001-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 the License "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 // e32test\secure\t_sprocess.cpp

    15 // Overview:

    16 // Test the platform security aspects of the RProcess class

    17 // API Information:

    18 // RProcess

    19 // Details:

    20 // - Test SetJustInTime on the current process, a new un-Resumed process

    21 // and between processes. Verify results are as expected.

    22 // - Test process renaming and verify results are as expected.

    23 // - Test killing, terminating and panicking different processes, verify

    24 // results are as expected.

    25 // - Test resuming a process from a different process, verify results.

    26 // - Test setting process priority in a variety of ways, verify results

    27 // are as expected.

    28 // - Test the RProcess SetType(), SetProtected(), CommandLineLength(), 

    29 // CommandLine(), SetSystem(), SetOwner() and Owner() methods. Verify

    30 // results are as expected.

    31 // Platforms/Drives/Compatibility:

    32 // All.

    33 // Assumptions/Requirement/Pre-requisites:

    34 // Failures and causes:

    35 // Base Port information:

    36 // 

    37 //

    38 

    39 #include <e32test.h>

    40 

    41 LOCAL_D RTest test(_L("T_SPROCESS"));

    42 

    43 _LIT(KSyncMutext,"T_SPROCESS-sync-mutex");

    44 RMutex SyncMutex;

    45 

    46 void Wait()

    47 	{

    48 	RMutex syncMutex;

    49 	if(syncMutex.OpenGlobal(KSyncMutext)!=KErrNone)

    50 		User::Invariant();

    51 	syncMutex.Wait();

    52 	syncMutex.Signal();

    53 	syncMutex.Close();

    54 	}

    55 

    56 enum TTestProcessFunctions

    57 	{

    58 	ETestProcessNull,

    59 	ETestProcessSetJustInTime,

    60 	ETestProcessKill,

    61 	ETestProcessTerminate,

    62 	ETestProcessPanic,

    63 	ETestProcessKillSelf,

    64 	ETestProcessTerminateSelf,

    65 	ETestProcessPanicSelf,

    66 	ETestProcessResume,

    67 	ETestProcessPriority,

    68 	ETestProcessPriorityControlOff,

    69 	ETestProcessPriorityControlOn,

    70 	ETestProcessPriorityControlOnAndLowPriority,

    71 	ETestProcessSetPriority,

    72 	};

    73 

    74 #include "testprocess.h"

    75 

    76 _LIT(KTestPanicCategory,"TEST PANIC");

    77 _LIT(KTestProcessName,"TestName");

    78 _LIT(KTestProcessName2,"TestName2");

    79 

    80 

    81 TInt DoTestProcess(TInt aTestNum,TInt aArg1,TInt aArg2)

    82 	{

    83 	RTestProcess process;

    84 	TInt r;

    85 

    86 	switch(aTestNum)

    87 		{

    88 

    89 	case ETestProcessNull:

    90 		Wait();

    91 		return KErrNone;

    92 

    93 	case ETestProcessSetJustInTime:

    94 		{

    95 		r = process.Open(aArg1);

    96 		if(r==KErrNone)

    97 			process.SetJustInTime(!process.JustInTime()); // Should panic us

    98 		return r;

    99 		}

   100 

   101 	case ETestProcessResume:

   102 		{

   103 		r = process.Open(aArg1);

   104 		if(r==KErrNone)

   105 			process.Resume(); // Should panic us

   106 		return r;

   107 		}

   108 

   109 	case ETestProcessKill:

   110 		{

   111 		r = process.Open(aArg1);

   112 		if(r==KErrNone)

   113 			process.Kill(999);

   114 		return r;

   115 		}

   116 

   117 	case ETestProcessTerminate:

   118 		{

   119 		r = process.Open(aArg1);

   120 		if(r==KErrNone)

   121 			process.Terminate(999);

   122 		return r;

   123 		}

   124 

   125 	case ETestProcessPanic:

   126 		{

   127 		r = process.Open(aArg1);

   128 		if(r==KErrNone)

   129 			process.Panic(KTestPanicCategory,999);

   130 		return r;

   131 		}

   132 

   133 	case ETestProcessKillSelf:

   134 		{

   135 		RProcess().Kill(999);

   136 		return KErrNone;

   137 		}

   138 

   139 	case ETestProcessTerminateSelf:

   140 		{

   141 		RProcess().Terminate(999);

   142 		return KErrNone;

   143 		}

   144 

   145 	case ETestProcessPanicSelf:

   146 		{

   147 		RProcess().Panic(KTestPanicCategory,999);

   148 		return KErrNone;

   149 		}

   150 

   151 	case ETestProcessSetPriority:

   152 		{

   153 		r = process.Open(aArg1);

   154 		if(r==KErrNone)

   155 			process.SetPriority((TProcessPriority)aArg2);

   156 		return r;

   157 		}

   158 

   159 

   160 	case ETestProcessPriority:

   161 		{

   162 		r = process.Open(aArg1);

   163 		if(r!=KErrNone)

   164 			return r;

   165 		TProcessPriority priority;

   166 		priority = process.Priority();

   167 		process.SetPriority(EPriorityLow);

   168 		if(process.Priority()!=priority) // priority shouldn't have changed

   169 			return KErrGeneral;

   170 		process.SetPriority(EPriorityBackground);

   171 		if(process.Priority()!=priority) // priority shouldn't have changed

   172 			return KErrGeneral;

   173 		process.SetPriority(EPriorityForeground);

   174 		if(process.Priority()!=priority) // priority shouldn't have changed

   175 			return KErrGeneral;

   176 		return KErrNone;

   177 		}

   178 

   179 	case ETestProcessPriorityControlOnAndLowPriority:

   180 		RProcess().SetPriority(EPriorityLow);

   181 		// fall through...

   182 	case ETestProcessPriorityControlOn:

   183 		User::SetPriorityControl(ETrue);

   184 		// fall through...

   185 	case ETestProcessPriorityControlOff:

   186 		RProcess::Rendezvous(0);

   187 		Wait();

   188 		return KErrNone;

   189 

   190 	default:

   191 		User::Panic(_L("T_SPROCESS"),1);

   192 		}

   193 

   194 	return KErrNone;

   195 	}

   196 

   197 

   198 

   199 void TestProcessForPlatformSecurityTrap(TTestProcessFunctions aFunction)

   200 	{

   201 	TRequestStatus logonStatus2;

   202 	RTestProcess process;

   203 	process.Create(~0u,aFunction,RProcess().Id(),EPriorityAbsoluteLow);

   204 	process.Logon(logonStatus2);

   205 	process.Resume();

   206 	User::WaitForRequest(logonStatus2);

   207 	test(process.ExitType()==EExitPanic); // Process should have got a Platform Security panic

   208 	test(logonStatus2==EPlatformSecurityTrap);

   209 	}

   210 

   211 

   212 

   213 void TestSetJustInTime()

   214 	{

   215 	RTestProcess process;

   216 	RTestProcess process2;

   217 	TRequestStatus logonStatus;

   218 

   219 	test.Start(_L("Test SetJustInTime on current process"));

   220 	TBool jit = process.JustInTime();

   221 	process.SetJustInTime(!jit);

   222 	test((process.JustInTime()!=EFalse)!=(jit!=EFalse));

   223 	process.SetJustInTime(jit);

   224 	test((process.JustInTime()!=EFalse)==(jit!=EFalse));

   225 

   226 	test.Next(_L("Test SetJustInTime on a new un-Resumed process"));

   227 	process.RProcess::Create(RProcess().FileName(),_L(""));

   228 	jit = process.JustInTime();

   229 	process.SetJustInTime(!jit);

   230 	test((process.JustInTime()!=EFalse)!=(jit!=EFalse));

   231 	process.SetJustInTime(jit);

   232 	test((process.JustInTime()!=EFalse)==(jit!=EFalse));

   233 	process.Kill(0);

   234 	CLOSE_AND_WAIT(process);

   235 

   236 	test.Next(_L("Try other process using SetJustInTime on our created process"));

   237 	process2.Create(0,ETestProcessNull);

   238 	process.Create(~0u,ETestProcessSetJustInTime,process2.Id());

   239 	process.Logon(logonStatus);

   240 	process.Resume();

   241 	User::WaitForRequest(logonStatus);

   242 	test(process.ExitType()==EExitPanic); // Process should have got a Platform Security panic

   243 	test(logonStatus==EPlatformSecurityTrap);

   244 	CLOSE_AND_WAIT(process);

   245 	process2.Kill(0);

   246 	CLOSE_AND_WAIT(process2);

   247 

   248 	test.Next(_L("Try other process to using SetJustInTime on us"));

   249 	process.Create(~0u,ETestProcessSetJustInTime);

   250 	process.Logon(logonStatus);

   251 	process.Resume();

   252 	User::WaitForRequest(logonStatus);

   253 	test(process.ExitType()==EExitPanic); // Process should have got a Platform Security panic

   254 	test(logonStatus==EPlatformSecurityTrap);

   255 	CLOSE_AND_WAIT(process);

   256 

   257 	test.End();

   258 	}

   259 

   260 

   261 

   262 void TestRename()

   263 	{

   264 	TName name;

   265 

   266 	test.Start(_L("Renaming the current process with User::RenameProcess"));

   267 	name = RProcess().Name();

   268 	name.SetLength(KTestProcessName().Length());

   269 	test(name.CompareF(KTestProcessName)!=0);

   270 	User::RenameProcess(KTestProcessName);

   271 	name = RProcess().Name();

   272 	name.SetLength(KTestProcessName().Length());

   273 	test(name.CompareF(KTestProcessName)==0);

   274 

   275 

   276 	test.End();

   277 	}

   278 

   279 

   280 

   281 void TestKill()

   282 	{

   283 	RTestProcess process;

   284 	RTestProcess process2;

   285 	TRequestStatus logonStatus;

   286 	TRequestStatus logonStatus2;

   287 

   288 	process2.Create(0,ETestProcessNull);

   289 	process2.Logon(logonStatus2);

   290 

   291 	// Test RProcess::Kill()

   292 

   293 	test.Start(_L("Test killing an un-resumed process created by us"));

   294 	process.Create(0,ETestProcessNull);

   295 	process.Logon(logonStatus);

   296 	process.Kill(999);

   297 	User::WaitForRequest(logonStatus);

   298 	test(process.ExitType()==EExitKill);

   299 	test(logonStatus==999);

   300 	CLOSE_AND_WAIT(process);

   301 

   302 	test.Next(_L("Try killing un-resumed process not created by self"));

   303 	process.Create(~(1u<<ECapabilityPowerMgmt),ETestProcessKill,process2.Id());

   304 	process.Logon(logonStatus);

   305 	process.Resume();

   306 	User::WaitForRequest(logonStatus);

   307 	test(process.ExitType()==EExitPanic); // Process should have got a Platform Security panic

   308 	test(logonStatus==EPlatformSecurityTrap);

   309 	test(logonStatus2==KRequestPending); // the process should still be alive

   310 	CLOSE_AND_WAIT(process);

   311 

   312 	test.Next(_L("Test a process killing itself"));

   313 	process.Create(0,ETestProcessKillSelf);

   314 	process.Logon(logonStatus);

   315 	process.Resume();

   316 	User::WaitForRequest(logonStatus);

   317 	test(process.ExitType()==EExitKill);

   318 	test(logonStatus==999);

   319 	CLOSE_AND_WAIT(process);

   320 

   321 	test.Next(_L("Try killing running process"));

   322 	process.Create(~(1u<<ECapabilityPowerMgmt),ETestProcessKill,RProcess().Id());

   323 	process.Logon(logonStatus);

   324 	process.Resume();

   325 	User::WaitForRequest(logonStatus);

   326 	test(process.ExitType()==EExitPanic); // Process should have got a Platform Security panic

   327 	test(logonStatus==EPlatformSecurityTrap);

   328 	CLOSE_AND_WAIT(process);

   329 

   330 	// Test RProcess::Teminate()

   331 

   332 	test.Next(_L("Test terminating an un-resumed process created by us"));

   333 	process.Create(0,ETestProcessNull);

   334 	process.Logon(logonStatus);

   335 	process.Terminate(999);

   336 	User::WaitForRequest(logonStatus);

   337 	test(process.ExitType()==EExitTerminate);

   338 	test(logonStatus==999);

   339 	CLOSE_AND_WAIT(process);

   340 

   341 	test.Next(_L("Try terminating un-resumed process not created by self"));

   342 	process.Create(~(1u<<ECapabilityPowerMgmt),ETestProcessTerminate,process2.Id());

   343 	process.Logon(logonStatus);

   344 	process.Resume();

   345 	User::WaitForRequest(logonStatus);

   346 	test(process.ExitType()==EExitPanic); // Process should have got a Platform Security panic

   347 	test(logonStatus==EPlatformSecurityTrap);

   348 	test(logonStatus2==KRequestPending); // the process should still be alive

   349 	CLOSE_AND_WAIT(process);

   350 

   351 	test.Next(_L("Test a process terminating itself"));

   352 	process.Create(0,ETestProcessTerminateSelf);

   353 	process.Logon(logonStatus);

   354 	process.Resume();

   355 	User::WaitForRequest(logonStatus);

   356 	test(process.ExitType()==EExitTerminate);

   357 	test(logonStatus==999);

   358 	CLOSE_AND_WAIT(process);

   359 

   360 	test.Next(_L("Try terminating running process"));

   361 	process.Create(~(1u<<ECapabilityPowerMgmt),ETestProcessTerminate,RProcess().Id());

   362 	process.Logon(logonStatus);

   363 	process.Resume();

   364 	User::WaitForRequest(logonStatus);

   365 	test(process.ExitType()==EExitPanic); // Process should have got a Platform Security panic

   366 	test(logonStatus==EPlatformSecurityTrap);

   367 	CLOSE_AND_WAIT(process);

   368 

   369 	// Test RProcess::Panic()

   370 

   371 	test.Next(_L("Test panicking an un-resumed process created by us"));

   372 	process.Create(0,ETestProcessNull);

   373 	process.Logon(logonStatus);

   374 	process.Panic(KTestPanicCategory,999);

   375 	User::WaitForRequest(logonStatus);

   376 	test(process.ExitType()==EExitPanic);

   377 	test(logonStatus==999);

   378 	CLOSE_AND_WAIT(process);

   379 

   380 	test.Next(_L("Try panicking un-resumed process not created by self"));

   381 	process.Create(~(1u<<ECapabilityPowerMgmt),ETestProcessPanic,process2.Id());

   382 	process.Logon(logonStatus);

   383 	process.Resume();

   384 	User::WaitForRequest(logonStatus);

   385 	test(process.ExitType()==EExitPanic); // Process should have got a Platform Security panic

   386 	test(logonStatus==EPlatformSecurityTrap);

   387 	test(logonStatus2==KRequestPending); // the process should still be alive

   388 	CLOSE_AND_WAIT(process);

   389 

   390 	test.Next(_L("Test a process panicking itself"));

   391 	process.Create(0,ETestProcessPanicSelf);

   392 	process.Logon(logonStatus);

   393 	process.Resume();

   394 	User::WaitForRequest(logonStatus);

   395 	test(process.ExitType()==EExitPanic);

   396 	test(logonStatus==999);

   397 	CLOSE_AND_WAIT(process);

   398 

   399 	test.Next(_L("Try panicking running process"));

   400 	process.Create(~(1u<<ECapabilityPowerMgmt),ETestProcessPanic,RProcess().Id());

   401 	process.Logon(logonStatus);

   402 	process.Resume();

   403 	User::WaitForRequest(logonStatus);

   404 	test(process.ExitType()==EExitPanic); // Process should have got a Platform Security panic

   405 	test(logonStatus==EPlatformSecurityTrap);

   406 	CLOSE_AND_WAIT(process);

   407 

   408 	// 

   409 

   410 	test(logonStatus2==KRequestPending); // the process should still be alive

   411 	process2.Resume();

   412 	User::WaitForRequest(logonStatus2);

   413 	test(logonStatus2==KErrNone);

   414 	CLOSE_AND_WAIT(process2);

   415 

   416 	// Checks with ECapabilityPowerMgmt

   417 

   418 	test.Next(_L("Test kill running process ECapabilityPowerMgmt"));

   419 	process2.Create(0,ETestProcessNull);

   420 	process2.Logon(logonStatus2);

   421 	process.Create((1<<ECapabilityPowerMgmt),ETestProcessKill,process2.Id());

   422 	process.Logon(logonStatus);

   423 	SyncMutex.Wait();

   424 	process2.Resume();

   425 	process.Resume();

   426 	User::WaitForRequest(logonStatus);

   427 	test(process.ExitType()==EExitKill);

   428 	test(logonStatus==0);

   429 	CLOSE_AND_WAIT(process);

   430 	User::WaitForRequest(logonStatus2);

   431 	test(process2.ExitType()==EExitKill);

   432 	test(logonStatus2==999);

   433 	process2.Close();

   434 	SyncMutex.Signal();

   435 

   436 	test.Next(_L("Test terminating running process ECapabilityPowerMgmt"));

   437 	process2.Create(0,ETestProcessNull);

   438 	process2.Logon(logonStatus2);

   439 	process.Create((1<<ECapabilityPowerMgmt),ETestProcessTerminate,process2.Id());

   440 	process.Logon(logonStatus);

   441 	SyncMutex.Wait();

   442 	process2.Resume();

   443 	process.Resume();

   444 	User::WaitForRequest(logonStatus);

   445 	test(process.ExitType()==EExitKill);

   446 	test(logonStatus==0);

   447 	CLOSE_AND_WAIT(process);

   448 	User::WaitForRequest(logonStatus2);

   449 	test(process2.ExitType()==EExitTerminate);

   450 	test(logonStatus2==999);

   451 	CLOSE_AND_WAIT(process2);

   452 	SyncMutex.Signal();

   453 

   454 	test.Next(_L("Test panicking running process ECapabilityPowerMgmt"));

   455 	process2.Create(0,ETestProcessNull);

   456 	process2.Logon(logonStatus2);

   457 	process.Create((1<<ECapabilityPowerMgmt),ETestProcessPanic,process2.Id());

   458 	process.Logon(logonStatus);

   459 	SyncMutex.Wait();

   460 	process2.Resume();

   461 	process.Resume();

   462 	User::WaitForRequest(logonStatus);

   463 	test(process.ExitType()==EExitKill);

   464 	test(logonStatus==0);

   465 	CLOSE_AND_WAIT(process);

   466 	User::WaitForRequest(logonStatus2);

   467 	test(process2.ExitType()==EExitPanic);

   468 	test(logonStatus2==999);

   469 	CLOSE_AND_WAIT(process2);

   470 	SyncMutex.Signal();

   471 

   472 	//

   473 

   474 	test.End();

   475 	}

   476 

   477 

   478 

   479 void TestResume()

   480 	{

   481 	RTestProcess process;

   482 	RTestProcess process2;

   483 	TRequestStatus logonStatus;

   484 	TRequestStatus logonStatus2;

   485 

   486 	test.Start(_L("Try to get another process to resume one we've created"));

   487 	process2.Create(0,ETestProcessNull);

   488 	process2.Logon(logonStatus2);

   489 	process.Create(~0u,ETestProcessResume,process2.Id());

   490 	process.Logon(logonStatus);

   491 	process.Resume();

   492 	User::WaitForRequest(logonStatus);

   493 	test(process.ExitType()==EExitPanic); // Process should have got a Platform Security panic

   494 	test(logonStatus==EPlatformSecurityTrap);

   495 	User::After(1*1000*1000); // Give time for process to run (if it had been resumed)...

   496 	test(logonStatus2==KRequestPending); // It shouldn't have, so logon will be pending

   497 	process2.Kill(0);

   498 	CLOSE_AND_WAIT(process2);

   499 

   500 //	test.Next(_L("Test resuming a process we've created"));

   501 //

   502 //  No code for this, because this whole test program wouldn't work if this wasn't OK

   503 //

   504 

   505 	test.End();

   506 	}

   507 

   508 

   509 

   510 void TestSetPriority()

   511 	{

   512 	RTestProcess process;

   513 	RTestProcess process2;

   514 	TProcessPriority priority;

   515 	TRequestStatus rendezvousStatus;

   516 	TRequestStatus logonStatus;

   517 

   518 	test.Start(_L("Test changing our own process priority"));

   519 	priority = process.Priority();

   520 	process.SetPriority(EPriorityLow);

   521 	test(process.Priority()==EPriorityLow);

   522 	process.SetPriority(EPriorityBackground);

   523 	test(process.Priority()==EPriorityBackground);

   524 	process.SetPriority(EPriorityForeground);

   525 	test(process.Priority()==EPriorityForeground);

   526 	process.SetPriority(priority);

   527 

   528 	test.Next(_L("Test changing unresumed process priority (which we created)"));

   529 	process.Create(0,ETestProcessNull);

   530 	priority = process.Priority();

   531 	process.SetPriority(EPriorityLow);

   532 	test(process.Priority()==EPriorityLow);

   533 	process.SetPriority(EPriorityBackground);

   534 	test(process.Priority()==EPriorityBackground);

   535 	process.SetPriority(EPriorityForeground);

   536 	test(process.Priority()==EPriorityForeground);

   537 	process.SetPriority(priority);

   538 	process.Kill(0);

   539 	CLOSE_AND_WAIT(process);

   540 

   541 	test.Next(_L("Try other process changing the priority of our created process"));

   542 	process2.Create(0,ETestProcessNull);

   543 	process.Create(~0u,ETestProcessPriority,process2.Id());

   544 	process.Logon(logonStatus);

   545 	process.Resume();

   546 	User::WaitForRequest(logonStatus);

   547 	test(logonStatus==KErrNone);

   548 	CLOSE_AND_WAIT(process);

   549 	process2.Kill(0);

   550 	CLOSE_AND_WAIT(process2);

   551 

   552 	test.Next(_L("Try changing other process's priority (no priority-control enabled)"));

   553 	process.Create(~0u,ETestProcessPriorityControlOff);

   554 	process.Rendezvous(rendezvousStatus);

   555 	process.Logon(logonStatus);

   556 	SyncMutex.Wait();

   557 	process.Resume();

   558 	User::WaitForRequest(rendezvousStatus); // Process has started

   559 	priority = process.Priority();

   560 	TInt result = process.SetPriority(EPriorityLow);

   561 	test(result == KErrPermissionDenied);

   562 	test(process.Priority()==priority); // priority shouldn't have changed

   563 	process.SetPriority(EPriorityBackground);

   564 	test(result == KErrPermissionDenied);

   565 	test(process.Priority()==priority); // priority shouldn't have changed

   566 	process.SetPriority(EPriorityForeground);

   567 	test(result == KErrPermissionDenied);

   568 	test(process.Priority()==priority); // priority shouldn't have changed

   569 	test(logonStatus==KRequestPending); // wait for process to end

   570 	SyncMutex.Signal();

   571 	User::WaitForRequest(logonStatus);

   572 	CLOSE_AND_WAIT(process);

   573 

   574 	test.Next(_L("Try changing other process's priority (priority-control enabled)"));

   575 	process.Create(~0u,ETestProcessPriorityControlOn);

   576 	process.Rendezvous(rendezvousStatus);

   577 	process.Logon(logonStatus);

   578 	SyncMutex.Wait();

   579 	process.Resume();

   580 	User::WaitForRequest(rendezvousStatus); // Process has started

   581 	priority = process.Priority();

   582 	result = process.SetPriority(EPriorityForeground);

   583 	test(result == KErrNone);

   584 	test(process.Priority()==EPriorityForeground);

   585 	result = process.SetPriority(EPriorityBackground);

   586 	test(result == KErrNone);

   587 	test(process.Priority()==EPriorityBackground);

   588 	result = process.SetPriority(EPriorityForeground);

   589 	test(result == KErrNone);

   590 	test(process.Priority()==EPriorityForeground);

   591 	result = process.SetPriority(EPriorityLow);

   592 	test(result == KErrPermissionDenied);

   593 	test(process.Priority()==EPriorityForeground); // should still be foreground priority

   594 	result = process.SetPriority(EPriorityHigh);

   595 	test(result == KErrNone);

   596 	test(process.Priority()==EPriorityHigh);

   597 	result = process.SetPriority(priority);

   598 	test(result == KErrNone);

   599 	test(logonStatus==KRequestPending); // wait for process to end

   600 	SyncMutex.Signal();

   601 	User::WaitForRequest(logonStatus);

   602 	CLOSE_AND_WAIT(process);

   603 

   604 	test.Next(_L("Try changing other process's priority (priority-control enabled and low priority)"));

   605 	process.Create(~0u,ETestProcessPriorityControlOnAndLowPriority);

   606 	process.Rendezvous(rendezvousStatus);

   607 	process.Logon(logonStatus);

   608 	SyncMutex.Wait();

   609 	process.Resume();

   610 	User::WaitForRequest(rendezvousStatus); // Process has started

   611 	test(process.Priority()==EPriorityLow);

   612 	result = process.SetPriority(EPriorityForeground);

   613 	test(result == KErrPermissionDenied);

   614 	test(process.Priority()==EPriorityLow);

   615 	result = process.SetPriority(EPriorityBackground);

   616 	test(result == KErrPermissionDenied);

   617 	test(process.Priority()==EPriorityLow);

   618 	result = process.SetPriority(EPriorityForeground);

   619 	test(result == KErrPermissionDenied);

   620 	test(process.Priority()==EPriorityLow);

   621 	result = process.SetPriority(EPriorityLow);

   622 	test(result == KErrPermissionDenied);

   623 	test(process.Priority()==EPriorityLow);

   624 	result = process.SetPriority(EPriorityHigh);

   625 	test(result == KErrPermissionDenied);

   626 	test(process.Priority()==EPriorityLow);

   627 	test(logonStatus==KRequestPending); // wait for process to end

   628 	SyncMutex.Signal();

   629 	User::WaitForRequest(logonStatus);

   630 	CLOSE_AND_WAIT(process);

   631 

   632 	test.End();

   633 	}

   634 

   635 

   636 

   637 GLDEF_C TInt E32Main()

   638     {

   639 	TBuf16<512> cmd;

   640 	User::CommandLine(cmd);

   641 	if(cmd.Length() && TChar(cmd[0]).IsDigit())

   642 		{

   643 		TInt function = -1;

   644 		TInt arg1 = -1;

   645 		TInt arg2 = -1;

   646 		TLex lex(cmd);

   647 

   648 		lex.Val(function);

   649 		lex.SkipSpace();

   650 		lex.Val(arg1);

   651 		lex.SkipSpace();

   652 		lex.Val(arg2);

   653 		return DoTestProcess(function,arg1,arg2);

   654 		}

   655 

   656 	test.Title();

   657 

   658 	if((!PlatSec::ConfigSetting(PlatSec::EPlatSecProcessIsolation))||(!PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement)))

   659 		{

   660 		test.Start(_L("TESTS NOT RUN - PlatSecProcessIsolation is not enforced"));

   661 		test.End();

   662 		return 0;

   663 		}

   664 

   665 	test(SyncMutex.CreateGlobal(KSyncMutext)==KErrNone);

   666 	

   667 	test.Start(_L("Test SetJustInTime"));

   668 	TestSetJustInTime();

   669 

   670 	test.Next(_L("Test Rename"));

   671 	TestRename();

   672 

   673 	test.Next(_L("Test Kill, Panic and Teminate"));

   674 	TestKill();

   675 

   676 	test.Next(_L("Test Resume"));

   677 	TestResume();

   678 

   679 	test.Next(_L("Test SetPriority"));

   680 	TestSetPriority();

   681 

   682 

   683 	SyncMutex.Close();

   684 	test.End();

   685 

   686 	return(0);

   687     }

   688