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

 // All rights reserved.

 // This component and the accompanying materials are made available

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

 // which accompanies this distribution, and is available

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

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // e32test\secure\t_sthread.cpp

 // Overview:

 // Test the platform security aspects of the RThread class

 // API Information:

 // RThread

 // Details:

 // - Test renaming the current thread and renaming a thread from 

 // another thread. Verify results are as expected.

 // - Test resuming a thread from a different process and from the

 // process that created the thread. Verify results are as expected.

 // - Verify that other processes can not suspend a thread and that the

 // creating process can.

 // - Perform a variety of tests on killing, terminating and panicking

 // a thread. Verify results are as expected.

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

 // are as expected. Includes ensuring real-time priorities are

 // unavailable to processes without capability ProtServ.

 // - Test RequestComplete and RequestSignal on a thread in a variety 

 // of ways, verify results are as expected.

 // - Test SetProcessPriority on a thread in a variety of ways, verify 

 // results are as expected.

 // - Test the Heap, ExceptionHandler, SetExceptionHandler, 

 // ModifyExceptionMask, RaiseException, IsExceptionHandled, 

 // SetProtected and SetSystem methods. Verify results as expected.

 // Platforms/Drives/Compatibility:

 // All.

 // Assumptions/Requirement/Pre-requisites:

 // Failures and causes:

 // Base Port information:

 // 

 //

 #include <e32test.h>

 LOCAL_D RTest test(_L("T_STHREAD"));

 _LIT(KSyncMutex,"T_STHREAD-sync-mutex");

 RMutex SyncMutex;

 void Wait()

 	{

 	RMutex syncMutex;

 	if(syncMutex.OpenGlobal(KSyncMutex)!=KErrNone)

 		User::Invariant();

 	syncMutex.Wait();

 	syncMutex.Signal();

 	syncMutex.Close();

 	}

 enum TTestProcessFunctions

 	{

 	ETestProcessResume,

 	ETestProcessSuspend,

 	ETestProcessKill,

 	ETestProcessTerminate,

 	ETestProcessPanic,

 	ETestProcessRequestComplete,

 	ETestProcessRequestSignal,

 	ETestProcessPriorityControlOff,

 	ETestProcessPriorityControlOn,

 	ETestProcessSetPriority,

 	ETestProcessSetPrioritiesWithoutProtServ,

 	ETestProcessSetPrioritiesWithProtServ

 	};

 #include "testprocess.h"

 _LIT(KTestPanicCategory,"TEST PANIC");

 _LIT(KTestThreadName,"TestName");

 class RTestThread : public RThread

 	{

 public:

 	void Create(TThreadFunction aFunction,TAny* aArg=0);

 	};

 volatile TInt TestThreadCount = 0;

 TInt TestThreadNull(TAny*)

 	{

 	++TestThreadCount;

 	Wait();

 	return KErrNone;

 	}

 void RTestThread::Create(TThreadFunction aFunction,TAny* aArg)

 	{

 	TInt r=RThread::Create(_L("TestThread"),aFunction,KDefaultStackSize,KDefaultStackSize,KDefaultStackSize,aArg);

 	test(r==KErrNone);

 	}

 // these priorities are available to any process

 void TestSetNormalApplicationPriorities(RThread& aThread)

 	{

 	TThreadPriority priority = aThread.Priority(); // save priority to restore before return

 	aThread.SetPriority(EPriorityAbsoluteVeryLow);

 	test(aThread.Priority()==EPriorityAbsoluteVeryLow);

 	aThread.SetPriority(EPriorityAbsoluteLowNormal);

 	test(aThread.Priority()==EPriorityAbsoluteLowNormal);

 	aThread.SetPriority(EPriorityAbsoluteLow);

 	test(aThread.Priority()==EPriorityAbsoluteLow);

 	aThread.SetPriority(EPriorityAbsoluteBackgroundNormal);

 	test(aThread.Priority()==EPriorityAbsoluteBackgroundNormal);

 	aThread.SetPriority(EPriorityAbsoluteBackground);

 	test(aThread.Priority()==EPriorityAbsoluteBackground);

 	aThread.SetPriority(EPriorityAbsoluteForegroundNormal);

 	test(aThread.Priority()==EPriorityAbsoluteForegroundNormal);

 	aThread.SetPriority(EPriorityAbsoluteForeground);

 	test(aThread.Priority()==EPriorityAbsoluteForeground);

 	aThread.SetPriority(EPriorityAbsoluteHighNormal);

 	test(aThread.Priority()==EPriorityAbsoluteHighNormal);

 	aThread.SetPriority(EPriorityAbsoluteHigh);

 	test(aThread.Priority()==EPriorityAbsoluteHigh);

 	aThread.SetPriority(priority);

 	}

 TInt TestThreadSetPriority(TAny* aArg)

 	{

 	RThread thisThread;

 	thisThread.SetPriority((TThreadPriority)(reinterpret_cast<TInt>(aArg)));

 	return KErrNone;

 	}

 void TestSetPriorityPanic(TThreadPriority aPriority)

 	{

 	RTestThread thread;

 	TRequestStatus status;

 	thread.Create(TestThreadSetPriority, reinterpret_cast<TAny*>(aPriority));

 	thread.Logon(status);

 	thread.Resume();

 	User::WaitForRequest(status);

 	test(thread.ExitType()==EExitPanic);

 	test(thread.ExitCategory()==_L("KERN-EXEC"));

 	test(thread.ExitReason()==46);

 	CLOSE_AND_WAIT(thread);

 	}

 void TestSetPrioritySuccess(TThreadPriority aPriority)

 	{

 	RTestThread thread;

 	TRequestStatus status;

 	thread.Create(TestThreadSetPriority, reinterpret_cast<TAny*>(aPriority));

 	thread.Logon(status);

 	thread.Resume();

 	User::WaitForRequest(status);

 	test(thread.Priority()==aPriority);

 	test(thread.ExitCategory()==_L("Kill"));

 	test(thread.ExitReason()==0);

 	CLOSE_AND_WAIT(thread);

 	}

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

 	{

 	RThread thread;

 	TInt r;

 	switch(aTestNum)

 		{

 	case ETestProcessResume:

 		{

 		r = thread.Open(aArg1);

 		if(r==KErrNone)

 			thread.Resume(); // Should panic us

 		return r;

 		}

 	case ETestProcessSuspend:

 		{

 		r = thread.Open(aArg1);

 		if(r==KErrNone)

 			thread.Suspend(); // Should panic us

 		return r;

 		}

 	case ETestProcessKill:

 		{

 		r = thread.Open(aArg1);

 		if(r==KErrNone)

 			thread.Kill(999); // Should panic us

 		return r;

 		}

 	case ETestProcessTerminate:

 		{

 		r = thread.Open(aArg1);

 		if(r==KErrNone)

 			thread.Terminate(999); // Should panic us

 		return r;

 		}

 	case ETestProcessPanic:

 		{

 		r = thread.Open(aArg1);

 		if(r==KErrNone)

 			thread.Panic(KTestPanicCategory,999); // Should panic us

 		return r;

 		}

 	case ETestProcessSetPriority:

 		{

 		r = thread.Open(aArg1);

 		if(r==KErrNone)

 			thread.SetPriority((TThreadPriority)aArg2);

 		return r;

 		}

 	case ETestProcessRequestComplete:

 		{

 		r = thread.Open(aArg1);

 		if(r==KErrNone)

 			{

 			// use a local request status because Thread::RequestComplete is

 			// implemented to write to it in our context

 			TRequestStatus myStatus;

 			TRequestStatus* status = &myStatus;

 			thread.RequestComplete(status,KErrNone);

 			}

 		return r;

 		}

 	case ETestProcessRequestSignal:

 		{

 		r = thread.Open(aArg1);

 		if(r==KErrNone)

 			thread.RequestSignal();

 		return r;

 		}

 	case ETestProcessPriorityControlOn:

 		User::SetPriorityControl(ETrue);

 		// fall through...

 	case ETestProcessPriorityControlOff:

 		RProcess::Rendezvous(RThread().Id());

 		Wait();

 		return KErrNone;

 	case ETestProcessSetPrioritiesWithoutProtServ:

 		{

 		RThread thread;

 		TestSetNormalApplicationPriorities(thread);

 		TestSetPriorityPanic(EPriorityAbsoluteRealTime1);

 		TestSetPriorityPanic(EPriorityAbsoluteRealTime2);

 		TestSetPriorityPanic(EPriorityAbsoluteRealTime3);

 		TestSetPriorityPanic(EPriorityAbsoluteRealTime4);

 		TestSetPriorityPanic(EPriorityAbsoluteRealTime5);

 		TestSetPriorityPanic(EPriorityAbsoluteRealTime6);

 		TestSetPriorityPanic(EPriorityAbsoluteRealTime7);

 		TestSetPriorityPanic(EPriorityAbsoluteRealTime8);	

 		return KErrNone;

 		}

 	case ETestProcessSetPrioritiesWithProtServ:

 		{

 		RThread thread;

 		TestSetNormalApplicationPriorities(thread);

 		TestSetPrioritySuccess(EPriorityAbsoluteRealTime1);

 		TestSetPrioritySuccess(EPriorityAbsoluteRealTime2);

 		TestSetPrioritySuccess(EPriorityAbsoluteRealTime3);

 		TestSetPrioritySuccess(EPriorityAbsoluteRealTime4);

 		TestSetPrioritySuccess(EPriorityAbsoluteRealTime5);

 		TestSetPrioritySuccess(EPriorityAbsoluteRealTime6);

 		TestSetPrioritySuccess(EPriorityAbsoluteRealTime7);

 		TestSetPrioritySuccess(EPriorityAbsoluteRealTime8);	

 		return KErrNone;

 		}

 	default:

 		User::Panic(_L("T_STHREAD"),1);

 		}

 	return KErrNone;

 	}

 void TestThreadForPlatformSecurityTrap(TThreadFunction aFunction)

 	{

 	TBool jit = User::JustInTime();

 	TRequestStatus logonStatus;

 	RTestThread thread;

 	thread.Create(aFunction,(TAny*)(TUint)RThread().Id());

 	thread.Logon(logonStatus);

 	User::SetJustInTime(EFalse);

 	thread.Resume();

 	User::WaitForRequest(logonStatus);

 	User::SetJustInTime(jit);

 	test(thread.ExitType()==EExitPanic);

 	test(logonStatus==EPlatformSecurityTrap);

 	CLOSE_AND_WAIT(thread);

 	}

 void TestProcessForPlatformSecurityTrap(TTestProcessFunctions aFunction)

 	{

 	TRequestStatus logonStatus2;

 	RTestProcess process;

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

 	process.Logon(logonStatus2);

 	process.Resume();

 	User::WaitForRequest(logonStatus2);

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

 	test(logonStatus2==EPlatformSecurityTrap);

 	CLOSE_AND_WAIT(process);

 	}

 void TestRename()

 	{

 	TName name;

 	test.Start(_L("Renaming the current thread"));

 	name = RThread().Name();

 	name.SetLength(KTestThreadName().Length());

 	test(name.CompareF(KTestThreadName)!=0);

 	User::RenameThread(KTestThreadName);

 	name = RThread().Name();

 	name.SetLength(KTestThreadName().Length());

 	test(name.CompareF(KTestThreadName)==0);

 	test.End();

 	}

 void TestResume()

 	{

 	RTestProcess process;

 	RTestThread thread;

 	TRequestStatus logonStatus;

 	TInt testCount = TestThreadCount;

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

 	thread.Create(TestThreadNull);

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

 	process.Logon(logonStatus);

 	process.Resume();

 	User::WaitForRequest(logonStatus);

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

 	test(logonStatus==EPlatformSecurityTrap);

 	User::After(1000000); // Give time for thread to run (if it had been resumed)...

 	test(TestThreadCount==testCount); // it shouldn't have, so count will be unchanged.

 	test.Next(_L("Test resuming a thread we've created"));

 	thread.Logon(logonStatus);

 	test(logonStatus==KRequestPending);

 	thread.Resume();

 	User::WaitForRequest(logonStatus);

 	test(logonStatus==KErrNone);

 	test(TestThreadCount==testCount+1); // Thread should have run and incremented the count

 	CLOSE_AND_WAIT(thread);

 	CLOSE_AND_WAIT(process);

 	test.End();

 	}

 TInt TestThreadCounting(TAny*)

 	{

 	RThread().SetPriority(EPriorityAbsoluteVeryLow);

 	for(;;)

 		++TestThreadCount;

 	}

 TBool IsTestThreadRunning()

 	{

 	 // Thread should have been busy incrementing the count if it is running

 	TInt testCount = TestThreadCount;

 	User::After(100000);

 	if(testCount!=TestThreadCount)

 		return ETrue;

 	User::After(1000000);

 	return testCount!=TestThreadCount;

 	}

 void TestSuspend()

 	{

 	RTestProcess process;

 	RTestThread thread;

 	TRequestStatus logonStatus;

 	test.Start(_L("Creating a never ending thread..."));

 	thread.Create(TestThreadCounting);

 	thread.Resume();

 	test(IsTestThreadRunning());  // Thread should still be running

 	test.Next(_L("Checking other process can't supspend it"));

 	process.Create(~0u,ETestProcessSuspend,thread.Id());

 	process.Logon(logonStatus);

 	process.Resume();

 	User::WaitForRequest(logonStatus);

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

 	test(logonStatus==EPlatformSecurityTrap);

 	test(IsTestThreadRunning());  // Thread should still be running

 	test.Next(_L("Test suspending a thread in same process"));

 	thread.Logon(logonStatus);

 	thread.Suspend();

 	test(!IsTestThreadRunning()); // Thread should have stopped...

 	test(logonStatus==KRequestPending); // but not have died

 	thread.LogonCancel(logonStatus);

 	User::WaitForRequest(logonStatus);

 	test.Next(_L("Kill thread"));

 	thread.Kill(0);

 	CLOSE_AND_WAIT(thread);

 	CLOSE_AND_WAIT(process);

 	test.End();

 	}

 TInt TestThreadKillSelf(TAny* )

 	{

 	RThread().Kill(999);

 	return KErrGeneral;

 	}

 TInt TestThreadTerminateSelf(TAny*)

 	{

 	RThread().Terminate(999);

 	return KErrGeneral;

 	}

 TInt TestThreadPanicSelf(TAny*)

 	{

 	RThread().Panic(KTestPanicCategory,999);

 	return KErrGeneral;

 	}

 void TestKill()

 	{

 	RTestProcess process;

 	RTestThread thread;

 	TRequestStatus logonStatus;

 	TRequestStatus logonStatus2;

 	TBool jit = User::JustInTime();

 	// Test RProcess::Kill()

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

 	thread.Create(TestThreadNull);

 	thread.Logon(logonStatus);

 	thread.Kill(999);

 	User::WaitForRequest(logonStatus);

 	test(thread.ExitType()==EExitKill);

 	test(logonStatus==999);

 	CLOSE_AND_WAIT(thread);

 	test.Next(_L("Test killing a resumed thread created by us"));

 	thread.Create(TestThreadNull);

 	thread.Logon(logonStatus);

 	SyncMutex.Wait();

 	thread.Resume();

 	thread.Kill(999);

 	SyncMutex.Signal();

 	User::WaitForRequest(logonStatus);

 	test(thread.ExitType()==EExitKill);

 	test(logonStatus==999);

 	CLOSE_AND_WAIT(thread);

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

 	thread.Create(TestThreadNull);

 	process.Create(~0u,ETestProcessKill,thread.Id());

 	thread.Logon(logonStatus2);

 	process.Logon(logonStatus);

 	process.Resume();

 	User::WaitForRequest(logonStatus);

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

 	test(logonStatus==EPlatformSecurityTrap);

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

 	thread.Resume();

 	User::WaitForRequest(logonStatus2);

 	test(logonStatus2==KErrNone);

 	CLOSE_AND_WAIT(thread);

 	CLOSE_AND_WAIT(process);

 	test.Next(_L("Try killing resumed thread not created by self"));

 	thread.Create(TestThreadNull);

 	process.Create(~0u,ETestProcessKill,thread.Id());

 	thread.Logon(logonStatus2);

 	process.Logon(logonStatus);

 	SyncMutex.Wait();

 	thread.Resume();

 	process.Resume();

 	User::WaitForRequest(logonStatus);

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

 	test(logonStatus==EPlatformSecurityTrap);

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

 	SyncMutex.Signal();

 	User::WaitForRequest(logonStatus2);

 	test(logonStatus2==KErrNone);

 	CLOSE_AND_WAIT(thread);

 	CLOSE_AND_WAIT(process);

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

 	thread.Create(TestThreadKillSelf);

 	thread.Logon(logonStatus);

 	thread.Resume();

 	User::WaitForRequest(logonStatus);

 	test(thread.ExitType()==EExitKill);

 	test(logonStatus==999);

 	CLOSE_AND_WAIT(thread);

 	// Test RProcess::Teminate()

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

 	thread.Create(TestThreadNull);

 	thread.Logon(logonStatus);

 	thread.Terminate(999);

 	User::WaitForRequest(logonStatus);

 	test(thread.ExitType()==EExitTerminate);

 	test(logonStatus==999);

 	CLOSE_AND_WAIT(thread);

 	test.Next(_L("Test terminating a resumed thread created by us"));

 	thread.Create(TestThreadNull);

 	thread.Logon(logonStatus);

 	SyncMutex.Wait();

 	thread.Resume();

 	thread.Terminate(999);

 	SyncMutex.Signal();

 	User::WaitForRequest(logonStatus);

 	test(thread.ExitType()==EExitTerminate);

 	test(logonStatus==999);

 	CLOSE_AND_WAIT(thread);

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

 	thread.Create(TestThreadNull);

 	process.Create(~0u,ETestProcessTerminate,thread.Id());

 	thread.Logon(logonStatus2);

 	process.Logon(logonStatus);

 	process.Resume();

 	User::WaitForRequest(logonStatus);

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

 	test(logonStatus==EPlatformSecurityTrap);

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

 	thread.Resume();

 	User::WaitForRequest(logonStatus2);

 	test(logonStatus2==KErrNone);

 	CLOSE_AND_WAIT(thread);

 	CLOSE_AND_WAIT(process);

 	test.Next(_L("Try terminating resumed thread not created by self"));

 	thread.Create(TestThreadNull);

 	process.Create(~0u,ETestProcessTerminate,thread.Id());

 	thread.Logon(logonStatus2);

 	process.Logon(logonStatus);

 	SyncMutex.Wait();

 	thread.Resume();

 	process.Resume();

 	User::WaitForRequest(logonStatus);

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

 	test(logonStatus==EPlatformSecurityTrap);

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

 	SyncMutex.Signal();

 	User::WaitForRequest(logonStatus2);

 	test(logonStatus2==KErrNone);

 	CLOSE_AND_WAIT(thread);

 	CLOSE_AND_WAIT(process);

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

 	thread.Create(TestThreadTerminateSelf);

 	thread.Logon(logonStatus);

 	thread.Resume();

 	User::WaitForRequest(logonStatus);

 	test(thread.ExitType()==EExitTerminate);

 	test(logonStatus==999);

 	CLOSE_AND_WAIT(thread);

 	// Test RProcess::Panic()

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

 	thread.Create(TestThreadNull);

 	thread.Logon(logonStatus);

 	User::SetJustInTime(EFalse);

 	thread.Panic(KTestPanicCategory,999);

 	User::WaitForRequest(logonStatus);

 	User::SetJustInTime(jit);

 	test(thread.ExitType()==EExitPanic);

 	test(logonStatus==999);

 	CLOSE_AND_WAIT(thread);

 	test.Next(_L("Test panicking a resumed thread created by us"));

 	thread.Create(TestThreadNull);

 	thread.Logon(logonStatus);

 	SyncMutex.Wait();

 	thread.Resume();

 	User::SetJustInTime(EFalse);

 	thread.Panic(KTestPanicCategory,999);

 	SyncMutex.Signal();

 	User::WaitForRequest(logonStatus);

 	User::SetJustInTime(jit);

 	test(thread.ExitType()==EExitPanic);

 	test(logonStatus==999);

 	CLOSE_AND_WAIT(thread);

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

 	thread.Create(TestThreadNull);

 	process.Create(~0u,ETestProcessPanic,thread.Id());

 	thread.Logon(logonStatus2);

 	process.Logon(logonStatus);

 	process.Resume();

 	User::WaitForRequest(logonStatus);

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

 	test(logonStatus==EPlatformSecurityTrap);

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

 	thread.Resume();

 	User::WaitForRequest(logonStatus2);

 	test(logonStatus2==KErrNone);

 	CLOSE_AND_WAIT(thread);

 	CLOSE_AND_WAIT(process);

 	test.Next(_L("Try panicking resumed thread not created by self"));

 	thread.Create(TestThreadNull);

 	process.Create(~0u,ETestProcessPanic,thread.Id());

 	thread.Logon(logonStatus2);

 	process.Logon(logonStatus);

 	SyncMutex.Wait();

 	thread.Resume();

 	process.Resume();

 	User::WaitForRequest(logonStatus);

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

 	test(logonStatus==EPlatformSecurityTrap);

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

 	SyncMutex.Signal();

 	User::WaitForRequest(logonStatus2);

 	test(logonStatus2==KErrNone);

 	CLOSE_AND_WAIT(thread);

 	CLOSE_AND_WAIT(process);

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

 	thread.Create(TestThreadPanicSelf);

 	thread.Logon(logonStatus);

 	User::SetJustInTime(EFalse);

 	thread.Resume();

 	User::WaitForRequest(logonStatus);

 	User::SetJustInTime(jit);

 	test(thread.ExitType()==EExitPanic);

 	test(logonStatus==999);

 	CLOSE_AND_WAIT(thread);

 	// 

 	test.End();

 	}

 //---------------------------------------------

 //! @SYMTestCaseID KBASE-T_STHREAD-0120

 //! @SYMTestCaseDesc Set thread priority

 //! @SYMTestType UT

 //! @SYMREQ historical, enhanced under PREQ955

 //! @SYMTestActions Test setting all thread priority values to threads in this process,

 //!     and in another process, resumed and not.

 //! @SYMTestExpectedResults Confirm can set and get "normal application" thread priorities

 //!     for threads in this process, whether resumed or not. Confirm thread is panicked

 //!     if attempts to set priority of thread in another process. Confirm can set and get

 //!     "real-time" thread priorities if this process has ProtServ capability, and that

 //!     calling thread is panicked if not.

 //! @SYMTestPriority Critical

 //! @SYMTestStatus Implemented

 //---------------------------------------------

 void TestSetPriority()

 	{

 	RTestThread thread;

 	RTestProcess process;

 	TRequestStatus logonStatus;

 	TRequestStatus logonStatus2;

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

 	TestSetNormalApplicationPriorities(thread);

 	test.Next(_L("Test changing priority of un-resumed thread in our process"));

 	thread.Create(TestThreadNull);

 	thread.Logon(logonStatus);

 	TestSetNormalApplicationPriorities(thread);

 	test.Next(_L("Test changing priority of resumed thread in our process"));

 	SyncMutex.Wait();

 	thread.Resume();

 	TestSetNormalApplicationPriorities(thread);

 	SyncMutex.Signal();

 	User::WaitForRequest(logonStatus);

 	test(logonStatus==KErrNone);

 	CLOSE_AND_WAIT(thread);

 	test.Next(_L("Try changing priority of an un-resumed thread in other process"));

 	thread.Create(TestThreadNull);

 	thread.Logon(logonStatus);

 	thread.SetPriority(EPriorityAbsoluteHigh);

 	process.Create(~0u,ETestProcessSetPriority,thread.Id(),EPriorityAbsoluteLow);

 	process.Logon(logonStatus2);

 	process.Resume();

 	User::WaitForRequest(logonStatus2);

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

 	test(logonStatus2==EPlatformSecurityTrap);

 	test(thread.Priority()==EPriorityAbsoluteHigh); // Priority should be unaltered

 	test.Next(_L("Try changing priority of a resumed thread in other process"));

 	process.Create(~0u,ETestProcessSetPriority,thread.Id(),EPriorityAbsoluteLow);

 	process.Logon(logonStatus2);

 	SyncMutex.Wait();

 	thread.Resume();

 	process.Resume();

 	User::WaitForRequest(logonStatus2);

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

 	test(logonStatus2==EPlatformSecurityTrap);

 	test(thread.Priority()==EPriorityAbsoluteHigh); // Priority should be unaltered

 	SyncMutex.Signal();

 	User::WaitForRequest(logonStatus);

 	test(logonStatus==KErrNone);

 	CLOSE_AND_WAIT(thread);

 	test.Next(_L("Test setting thread priorities without ECapabilityProtServ"));

 	process.Create(~(1u<<ECapabilityProtServ), ETestProcessSetPrioritiesWithoutProtServ);

 	process.Run();

 	test.Next(_L("Test setting thread priorities with ECapabilityProtServ"));

 	process.Create(1<<ECapabilityProtServ, ETestProcessSetPrioritiesWithProtServ);

 	process.Run();

 	test.End();

 	}

 TRequestStatus TestRequest;

 TInt TestThreadRequestComplete(TAny* aArg)

 	{

 	RThread thread;

 	TInt r = thread.Open((TInt)aArg);

 	if(r==KErrNone)

 		{

 		TRequestStatus* status = &TestRequest;

 		thread.RequestComplete(status,KErrNone);

 		}

 	return r;

 	}

 void TestRequestComplete()

 	{

 	RTestThread thread;

 	RTestProcess process;

 	TRequestStatus logonStatus;

 	test.Start(_L("Test RequestComplete on thread in current process"));

 	TestRequest = KRequestPending;

 	thread.Create(TestThreadRequestComplete,(TAny*)(TUint)RThread().Id());

 	thread.Logon(logonStatus);

 	thread.Resume();

 	User::WaitForRequest(TestRequest);

 	test(TestRequest==KErrNone);

 	User::WaitForRequest(logonStatus);

 	test(logonStatus==KErrNone);

 	CLOSE_AND_WAIT(thread);

 	test.Next(_L("Test RequestComplete on with NULL request pointer"));

 	test(RThread().RequestCount()==0); // No signals

 	TRequestStatus* nullReq = 0;

 	RThread().RequestComplete(nullReq,0);

 	test(RThread().RequestCount()==0); // No signals

 	test.Next(_L("Test RequestComplete on thread in different process"));

 	TestRequest = KRequestPending;

 	process.Create(~0u,ETestProcessRequestComplete,RThread().Id(),(TInt)&TestRequest);

 	process.Logon(logonStatus);

 	process.Resume();

 	User::WaitForRequest(logonStatus);

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

 	test(logonStatus==EPlatformSecurityTrap);

 	test(TestRequest==KRequestPending);

 	CLOSE_AND_WAIT(process);

 	test.End();

 	}

 TInt TestThreadRequestSignal(TAny* aArg)

 	{

 	RThread thread;

 	TInt r = thread.Open((TInt)aArg);

 	if(r==KErrNone)

 		thread.RequestSignal();

 	return r;

 	}

 void TestRequestSignal()

 	{

 	RTestThread thread;

 	RTestProcess process;

 	TRequestStatus logonStatus;

 	TInt count;

 	test.Start(_L("Test RequestSignal on thread in current process"));

 	thread.Create(TestThreadRequestSignal,(TAny*)(TUint)RThread().Id());

 	thread.Logon(logonStatus);

 	count = RThread().RequestCount();

 	test(count==0); // No signals yet

 	thread.Resume();

 	User::WaitForRequest(logonStatus);

 	test(logonStatus==KErrNone);

 	count = RThread().RequestCount();

 	test(count==1); // We should have been signalled

 	User::WaitForAnyRequest();	// eat signal

 	CLOSE_AND_WAIT(thread);

 	test.Next(_L("Test RequestSignal on thread in different process"));

 	process.Create(~0u,ETestProcessRequestSignal,RThread().Id(),0);

 	process.Logon(logonStatus);

 	process.Resume();

 	User::WaitForRequest(logonStatus);

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

 	test(logonStatus==EPlatformSecurityTrap);

 	count = RThread().RequestCount();

 	test(count==0); // We shouldn't have been signalled

 	CLOSE_AND_WAIT(process);

 	test.End();

 	}

 void TestSetProcessPriority()

 	{

 	RTestThread thread;

 	RTestProcess process;

 	TProcessPriority priority;

 	TRequestStatus rendezvousStatus;

 	TRequestStatus logonStatus;

 	TInt r;

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

 	priority = process.Priority();

 	thread.SetProcessPriority(EPriorityLow);

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

 	thread.SetProcessPriority(EPriorityBackground);

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

 	thread.SetProcessPriority(EPriorityForeground);

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

 	thread.SetProcessPriority(priority);

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

 	process.Create(~0u,ETestProcessPriorityControlOff);

 	process.Rendezvous(rendezvousStatus);

 	process.Logon(logonStatus);

 	SyncMutex.Wait();

 	process.Resume();

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

 	r = thread.Open(rendezvousStatus.Int()); // Process returned Id of main thread as status value

 	test(r==KErrNone);

 	priority = process.Priority();

 	thread.SetProcessPriority(EPriorityLow);

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

 	thread.SetProcessPriority(EPriorityBackground);

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

 	thread.SetProcessPriority(EPriorityForeground);

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

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

 	SyncMutex.Signal();

 	User::WaitForRequest(logonStatus);

 	CLOSE_AND_WAIT(thread);

 	CLOSE_AND_WAIT(process);

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

 	process.Create(~0u,ETestProcessPriorityControlOn);

 	process.Rendezvous(rendezvousStatus);

 	process.Logon(logonStatus);

 	SyncMutex.Wait();

 	process.Resume();

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

 	r = thread.Open(rendezvousStatus.Int()); // Process returned Id of main thread as status value

 	test(r==KErrNone);

 	priority = process.Priority();

 	thread.SetProcessPriority(EPriorityForeground);

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

 	thread.SetProcessPriority(EPriorityBackground);

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

 	thread.SetProcessPriority(EPriorityForeground);

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

 	thread.SetProcessPriority(EPriorityLow);

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

 	thread.SetProcessPriority(priority);

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

 	SyncMutex.Signal();

 	User::WaitForRequest(logonStatus);

 	CLOSE_AND_WAIT(thread);

 	CLOSE_AND_WAIT(process);

 	test.End();

 	}

 GLDEF_C TInt E32Main()

     {

 	TBuf16<512> cmd;

 	User::CommandLine(cmd);

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

 		{

 		TInt function = -1;

 		TInt arg1 = -1;

 		TInt arg2 = -1;

 		TLex lex(cmd);

 		lex.Val(function);

 		lex.SkipSpace();

 		lex.Val(arg1);

 		lex.SkipSpace();

 		lex.Val(arg2);

 		return DoTestProcess(function,arg1,arg2);

 		}

 	test.Title();

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

 		{

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

 		test.End();

 		return 0;

 		}

 	test(SyncMutex.CreateGlobal(KSyncMutex)==KErrNone);

 	test.Start(_L("Test Rename"));

 	TestRename();

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

 	TestResume();

 	test.Next(_L("Test Suspend"));

 	TestSuspend();

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

 	TestKill();

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

 	TestSetPriority();

 	test.Next(_L("Test RequestComplete"));

 	TestRequestComplete();

 	test.Next(_L("Test RequestSignal"));

 	TestRequestSignal();

 	test.Next(_L("Test SetProcessPriority"));

 	TestSetProcessPriority();

 	SyncMutex.Close();

 	test.End();

 	return(0);

     }