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