// Copyright (c) 2006-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_sprioritycap.cpp

 // Overview:

 // Test the platform security aspects of the RThread class as affected by the process priority

 // specified in the MMP file, mainly capping of higher thread priorities without ProtServ.

 // API Information:

 // Process priorities windowserver, fileserver, supervisor and realtimeserver set with

 //

 // # 'epocprocesspriority' keyword in MMP files

 // # 'priority' keyword in OBEY (OBY/IBY) files

 // Details:

 // - Tests that the desired thread prioritisation results are obtained for process priorities

 // SystemServer and RealTimeServer (established by separate MMP files):

 // # without ECapabilityProtServ - priorities capped to SystemServer/More.

 // # with ECapabilityProtServ - higher, "real-time" priorities obtainable.

 // - Tests effect of reduction of SystemServer/More from nanothread priority 24 to 23,

 // i.e. same priority as AbsoluteHigh

 // Platforms/Drives/Compatibility:

 // All.

 // Assumptions/Requirement/Pre-requisites:

 // Failures and causes:

 // Base Port information:

 //

 #include <e32test.h>

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

 RMutex SyncMutex;

 TInt threadMutexAcquireOrder; // where 132 = thread 1 acquires mutex, then thread 3 then thread 2

 _LIT(KTestPanicCategory,"TEST PANIC");

 class RTestThread : public RThread

 	{

 public:

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

 	};

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

 	{

 	TInt threadNumber = reinterpret_cast<TInt>(aThreadNumber);

 	ASSERT((threadNumber > 0) && (threadNumber < 10));

 	TBuf<20> threadName = _L("TestThread_");

 	threadName.AppendNum(threadNumber);

 	TInt r=RThread::Create(threadName,aFunction,KDefaultStackSize,KDefaultStackSize,KDefaultStackSize,aThreadNumber);

 	test(r==KErrNone);

 	}

 TInt TestThreadWaitMutex(TAny* aThreadNumber)

 	{

 	TInt threadNumber = reinterpret_cast<TInt>(aThreadNumber);

 	ASSERT((threadNumber > 0) && (threadNumber < 10));

 	RThread thisThread;

 	thisThread.Rendezvous(KErrNone);

 	SyncMutex.Wait();

 	threadMutexAcquireOrder = threadMutexAcquireOrder*10 + threadNumber;

 	SyncMutex.Signal();

 	return KErrNone;

 	}

 // Create three threads with priority 1, 2 and 1, each waiting on a mutex that is already held by the

 // main thread. Signal the mutex from the main thread and return the order the threads acquire it

 // as an integer where 132 = thread 1 acquires mutex, then thread 3 then thread 2.

 //

 // In order to work this test requires the three threads to wait on the mutex in the order listed.

 // This cannot be guaranteed, but the following points make it a near-certainty:

 // (1) This main thread runs at lowest priority

 // (2) The three threads initially resume at higher, decreasing priorities.

 // (3) We Rendezvous() with the thread just before it waits on the mutex

 // (4) Wait some time before creating next thread

 // (5) Actual priorities are set after all test threads are waiting

 TInt TestThreadMutexAcquireOrder(TThreadPriority aPriorityThread1, TThreadPriority aPriorityThread2)

 	{

 	RTestThread thread1;

 	RTestThread thread2;

 	RTestThread thread3;

 	TRequestStatus logonStatus1;

 	TRequestStatus logonStatus2;

 	TRequestStatus logonStatus3;

 	TRequestStatus rendezvousStatus;

 	threadMutexAcquireOrder = 0; // global variable to hold order in which threads obtain mutex

 	RThread thisThread;

 	thisThread.SetPriority(EPriorityAbsoluteVeryLow);

 	// create the SyncMutex global variable and hold it initially

 	if(SyncMutex.CreateLocal()!=KErrNone)

 		User::Invariant();

 	SyncMutex.Wait();

 	thread1.Create(TestThreadWaitMutex, reinterpret_cast<TAny*>(1));

 	thread1.Logon(logonStatus1);

 	thread1.SetPriority(EPriorityAbsoluteHigh);

 	thread1.Rendezvous(rendezvousStatus);

 	thread1.Resume();

 	User::WaitForRequest(rendezvousStatus);

 	User::After(500000);

 	thread2.Create(TestThreadWaitMutex, reinterpret_cast<TAny*>(2));

 	thread2.Logon(logonStatus2);

 	thread2.SetPriority(EPriorityAbsoluteForeground);

 	thread2.Rendezvous(rendezvousStatus);

 	thread2.Resume();

 	User::WaitForRequest(rendezvousStatus);

 	User::After(500000);

 	thread3.Create(TestThreadWaitMutex, reinterpret_cast<TAny*>(3));

 	thread3.Logon(logonStatus3);

 	thread3.SetPriority(EPriorityAbsoluteBackground);

 	thread3.Rendezvous(rendezvousStatus);

 	thread3.Resume();

 	User::WaitForRequest(rendezvousStatus);

 	User::After(500000);

 	thread1.SetPriority(aPriorityThread1);

 	thread2.SetPriority(aPriorityThread2);

 	thread3.SetPriority(aPriorityThread1);

 	SyncMutex.Signal();

 	User::WaitForRequest(logonStatus1);

 	User::WaitForRequest(logonStatus2);

 	User::WaitForRequest(logonStatus3);

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

 	test(logonStatus1==KErrNone);

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

 	test(logonStatus2==KErrNone);

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

 	test(logonStatus3==KErrNone);

 	thread1.Close();

 	thread2.Close();

 	thread3.Close();

 	SyncMutex.Close();

 	return threadMutexAcquireOrder;

 	}

 enum TTestProcessFunctions

 	{

 	ETestProcessThreadPrioritiesEqual,

 	ETestProcessThreadPrioritiesHighLow

 	};

 #include "testprocess.h"

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

 	{

 	RThread thread;

 	switch(aTestNum)

 		{

 	case ETestProcessThreadPrioritiesEqual:

 		{

 		TInt acquireOrder = TestThreadMutexAcquireOrder((TThreadPriority)aArg1, (TThreadPriority)aArg2);

 		if (acquireOrder != 123)

 			{

 			thread.Panic(KTestPanicCategory,999);

 			}

 		break;

 		}

 	case ETestProcessThreadPrioritiesHighLow:

 		{

 		TInt acquireOrder = TestThreadMutexAcquireOrder((TThreadPriority)aArg1, (TThreadPriority)aArg2);

 		if (acquireOrder != 132)

 			{

 			thread.Panic(KTestPanicCategory,999);

 			}

 		break;

 		}

 	default:

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

 		}

 	return KErrNone;

 	}

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

 //! @SYMTestCaseID KBASE-T_SPRIORITYCAP-0121

 //! @SYMTestCaseDesc Check prioritisation of threads with ProtServ capability

 //! @SYMTestType UT

 //! @SYMREQ PREQ955

 //! @SYMTestActions Create sets of three threads with various priorities and have them wait on

 //!     a mutex. Signal the mutex to see whether the threads obtain it in priority or wait order.

 //!     Note: 2 MMP files build test exe with RealTimeServer and WindowServer process priorities.

 //!     Test creates copy of this executable with/without required capabilities.

 //! @SYMTestExpectedResults All thread priorities are obtainable to processes with ProtServ, so

 //!     confirm they are correctly mapped to absolute priorities, that MuchMore > More etc. and

 //!     that SystemServer/More is correctly mapped for SYMBIAN_CURB_SYSTEMSERVER_PRIORITIES macro.

 //! @SYMTestPriority Critical

 //! @SYMTestStatus Implemented

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

 void TestPriorityMappingWithProtServ()

 	{

 	const TUint32 capability = 1u<<ECapabilityProtServ; // only ProtServ capability

 	RTestProcess process;

 	TProcessPriority processPriority = process.Priority();

 	// only call with the following process priorities

 	ASSERT((processPriority == EPriorityWindowServer) || (processPriority == EPriorityFileServer)

 		|| (processPriority == EPrioritySupervisor) || (processPriority == EPriorityRealTimeServer));

 	test.Start(_L("Test EPriorityRealTime is greater than EPriorityMuchMore"));

 	process.Create(capability,ETestProcessThreadPrioritiesHighLow,EPriorityRealTime,EPriorityMuchMore);

 	process.Run();

 	test.Next(_L("Test EPriorityMuchMore is greater than EPriorityMore"));

 	process.Create(capability,ETestProcessThreadPrioritiesHighLow,EPriorityMuchMore,EPriorityMore);

 	process.Run();

 	test.Next(_L("Test EPriorityMore is greater than EPriorityNormal"));

 	process.Create(capability,ETestProcessThreadPrioritiesHighLow,EPriorityMore,EPriorityNormal);

 	process.Run();

 	test.Next(_L("Test EPriorityNormal is greater than EPriorityLess"));

 	process.Create(capability,ETestProcessThreadPrioritiesHighLow,EPriorityNormal,EPriorityLess);

 	process.Run();

 	test.Next(_L("Test EPriorityLess is greater than EPriorityMuchLess"));

 	process.Create(capability,ETestProcessThreadPrioritiesHighLow,EPriorityLess,EPriorityMuchLess);

 	process.Run();

 	test.Next(_L("Test EPriorityMore versus independent capping priority"));

 	process.Create(capability,

 		(processPriority == EPriorityRealTimeServer) ? ETestProcessThreadPrioritiesHighLow : ETestProcessThreadPrioritiesEqual,

 		EPriorityMore,

 #ifdef SYMBIAN_CURB_SYSTEMSERVER_PRIORITIES

 		EPriorityAbsoluteHigh

 #else

 		EPriorityAbsoluteRealTime1

 #endif	

 		);

 	process.Run();

 	test.End();

 	}

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

 //! @SYMTestCaseID KBASE-T_SPRIORITYCAP-0122

 //! @SYMTestCaseDesc Check prioritisation of threads without ProtServ capability

 //! @SYMTestType UT

 //! @SYMREQ PREQ955

 //! @SYMTestActions Create sets of three threads with various priorities and have them wait on

 //!     a mutex. Signal the mutex to see whether the threads obtain it in priority or wait order.

 //!     Note: 2 MMP files build test exe with RealTimeServer and WindowServer process priorities.

 //!     Test creates copy of this executable with/without required capabilities.

 //! @SYMTestExpectedResults Confirm thread priorities are capped at SystemServer/More without ProtServ,

 //!     so many priority enumerations will map to the same absolute priority. Confirm that

 //!     SystemServer/More is correctly mapped for SYMBIAN_CURB_SYSTEMSERVER_PRIORITIES macro.

 //! @SYMTestPriority Critical

 //! @SYMTestStatus Implemented

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

 void TestPriorityMappingWithoutProtServ()

 	{

 	const TUint32 capability = ~(1u<<ECapabilityProtServ); // all capabilities except ProtServ

 	RTestProcess process;

 	TProcessPriority processPriority = process.Priority();

 	// only call with the following process priorities

 	ASSERT((processPriority == EPriorityWindowServer) || (processPriority == EPriorityFileServer)

 		|| (processPriority == EPrioritySupervisor) || (processPriority == EPriorityRealTimeServer));

 	test.Start(_L("Test EPriorityRealTime and EPriorityMuchMore are capped and equal"));

 	process.Create(capability,ETestProcessThreadPrioritiesEqual,EPriorityRealTime,EPriorityMuchMore);

 	process.Run();

 	test.Next(_L("Test EPriorityMuchMore and EPriorityMore are capped and equal"));

 	process.Create(capability,ETestProcessThreadPrioritiesEqual,EPriorityMuchMore,EPriorityMore);

 	process.Run();

 	if (processPriority == EPriorityRealTimeServer)

 		{

 		test.Next(_L("Test EPriorityMore and EPriorityMuchLess are capped and equal"));

 		process.Create(capability,ETestProcessThreadPrioritiesEqual,EPriorityMore,EPriorityMuchLess);

 		process.Run();

 		test.Next(_L("Test EPriorityNormal and EPriorityMuchLess are capped and equal"));

 		process.Create(capability,ETestProcessThreadPrioritiesEqual,EPriorityNormal,EPriorityMuchLess);

 		process.Run();

 		test.Next(_L("Test EPriorityLess and EPriorityMuchLess are capped and equal"));

 		process.Create(capability,ETestProcessThreadPrioritiesEqual,EPriorityLess,EPriorityMuchLess);

 		process.Run();

 		}

 	test.Next(_L("Test EPriorityMore versus EPriorityAbsoluteHigh"));

 	process.Create(capability,

 #ifdef SYMBIAN_CURB_SYSTEMSERVER_PRIORITIES

 		ETestProcessThreadPrioritiesEqual,

 #else

 		ETestProcessThreadPrioritiesHighLow,

 #endif	

 		EPriorityMore,EPriorityAbsoluteHigh);

 	process.Run();

 	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::EPlatSecEnforcement))

 		{

 		test.Start(_L("TESTS NOT RUN - EPlatSecEnforcement is OFF"));

 		test.End();

 		return 0;

 		}

 	test.Next(_L("Test thread priority mappings for processes with ECapabilityProtServ"));

 	TestPriorityMappingWithProtServ();

 	test.Start(_L("Test thread priority mappings for processes without ECapabilityProtServ"));

 	TestPriorityMappingWithoutProtServ();

 	test.End();

 	return(0);

     }