// Copyright (c) 1995-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\prime\t_semutx2.cpp

// Test RSemaphore and RMutex

// Overview:

// Tests the RSemaphore and RMutex

// API Information:

// RSemaphore, RMutex

// Details:

// - Test and verify that thread priorities work as expected.

// - Test and verify that signalling an RMutex from the wrong

// thread fails as expected.

// - Test and verify that mutex priority inheritance works as

// expected.

// - Perform an exhaustive state transition test using mutexs

// and up to ten threads. Verify priorities, order of execution, 

// mutex signalling, suspend, resume, kill and close. Verify 

// results are as expected.

// - Test semaphore speed by counting how many Wait/Signal 

// operations can be completed in one second.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

RMutex M1;

RMutex M2;

RSemaphore S;

const TInt KBufferSize=4096;

TUint ThreadId[KBufferSize];

TInt PutIx;

TInt GetIx;

TInt Count;

RThread Main;

RTest test(_L("T_SEMUTX2"));

/*****************************************************************************

 * Utility functions / macros

 *****************************************************************************/

#define TRACE_ON	User::SetDebugMask(0xffdfffff);

#define TRACE_OFF	User::SetDebugMask(0x80000000);

//#define MCOUNT(m,c)	test((m).Count() ==(c))

// mutex count value is not visible for user any more

#define MCOUNT(m,c) (void)(1)

#define id0		id[0]

#define id1		id[1]

#define id2		id[2]

#define id3		id[3]

#define id4		id[4]

#define id5		id[5]

#define id6		id[6]

#define id7		id[7]

#define id8		id[8]

#define id9		id[9]

#define id10	id[10]

TBool Exists(const TDesC& aName)

	{

	TFullName n(RProcess().Name());

	n+=_L("::");

	n+=aName;

	TFindThread ft(n);

	TFullName fn;

	return ft.Next(fn)==KErrNone;

	}

TBool Exists(TInt aNum)

	{

	TBuf<4> b;

	b.Num(aNum);

	return Exists(b);

	}

void BusyWait(TInt aMicroseconds)

	{

	TTime begin;

	begin.HomeTime();

	FOREVER

		{

		TTime now;

		now.HomeTime();

		TTimeIntervalMicroSeconds iv=now.MicroSecondsFrom(begin);

		if (iv.Int64()>=TInt64(aMicroseconds))

			return;

		}

	}

void Kick(RThread& t)

	{

	TRequestStatus s;

	TRequestStatus* pS=&s;

	t.RequestComplete(pS,0);

	}

TUint GetNextId()

	{

	if (GetIx<PutIx)

		return ThreadId[GetIx++];

	return 0;

	}

TInt NumIdsPending()

	{

	return PutIx-GetIx;

	}

/*****************************************************************************

 * General tests

 *****************************************************************************/

TInt Test0Thread(TAny* aPtr)

	{

	TInt& count=*(TInt*)aPtr;

	++count;

	Main.SetPriority(EPriorityMuchMore);

	++count;

	Main.SetPriority(EPriorityMuchMore);

	++count;

	RThread().SetPriority(EPriorityNormal);

	++count;

	return 0;

	}

void Test0()

	{

	User::After(100000);	// Test fails intermittently on hardware unless we pause here 

	test.Start(_L("Test thread priorities work"));

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

	RThread t;

	TInt count=0;

	TRequestStatus s;

	TInt r=t.Create(_L("Test0"),Test0Thread,0x1000,NULL,&count);

	t.Logon(s);

	User::After(10000);		// make sure we have a full timeslice

	t.Resume();

	RThread().SetPriority(EPriorityMuchMore);	// shouldn't reschedule (priority unchanged)

	RThread().SetPriority(EPriorityMore);	// shouldn't reschedule (priority decreasing, but not enough)

	RThread().SetPriority(EPriorityMuchMore);	// shouldn't reschedule (priority increasing)

	RThread().SetPriority(EPriorityNormal);	// should reschedule (we go behind t)

	RThread().SetPriority(EPriorityLess);	// should reschedule (priority decreasing to below t)

	t.SetPriority(EPriorityMuchMore);		// shouldn't reschedule (round-robin, timeslice not expired)

	t.SetPriority(EPriorityNormal);			// shouldn't reschedule (t's priority decreasing)

	t.SetPriority(EPriorityNormal);			// shouldn't reschedule (t's priority unchanged)

	BusyWait(100000);		// use up our timeslice

	t.SetPriority(EPriorityMuchMore);		// should reschedule (round-robin, timeslice expired)

	t.SetPriority(EPriorityRealTime);		// should reschedule (t increases above current)

	User::WaitForRequest(s);

	RThread().SetPriority(EPriorityMuchMore);

	t.Close();

	test.End();

	}

TInt Test1Thread(TAny*)

	{

	M1.Signal();

	return 0;

	}

void Test1()

	{

	test.Start(_L("Test signalling from wrong thread"));

	TInt r=M1.CreateLocal();

	M1.Wait();

	RThread t;

	r=t.Create(_L("Test1"),Test1Thread,0x1000,NULL,NULL);

	TRequestStatus s;

	t.Logon(s);

	t.Resume();

	TBool jit = User::JustInTime();

	User::SetJustInTime(EFalse);

	User::WaitForRequest(s);

	User::SetJustInTime(jit);

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

	t.Close();

	M1.Close();

	test.End();

	}

/*****************************************************************************

 * Mutex priority inheritance

 *****************************************************************************/

const TInt KTestDelay = 1000000;

TInt LowThread(TAny* aPtr)

	{

	TInt& count=*(TInt*)aPtr;

	FOREVER

		{

		M1.Wait();

		++count;

		BusyWait(KTestDelay);

		M1.Signal();

		User::WaitForAnyRequest();

		}

	}

TInt MedThread(TAny* aPtr)

	{

	TInt& count=*(TInt*)aPtr;

	FOREVER

		{

		++count;

		User::WaitForAnyRequest();

		}

	}

TInt HighThread(TAny* aPtr)

	{

	TInt& count=*(TInt*)aPtr;

	FOREVER

		{

		M2.Wait();

		++count;

		M1.Wait();

		++count;

		BusyWait(KTestDelay);

		M1.Signal();

		M2.Signal();

		User::WaitForAnyRequest();

		}

	}

void TestMutex1()

	{

	test.Start(_L("Test mutex priority inheritance"));

	test.Next(_L("Create mutex"));

	TInt r=M1.CreateLocal();

	test.Next(_L("Create low priority thread"));

	TInt lowcount=0;

	RThread low;

	r=low.Create(_L("low"),LowThread,0x1000,NULL,&lowcount);

	low.SetPriority(EPriorityMuchLess);

	test(Exists(_L("low")));

	test.Next(_L("Create medium priority thread"));

	TInt medcount=0;

	RThread med;

	r=med.Create(_L("med"),MedThread,0x1000,NULL,&medcount);

	med.SetPriority(EPriorityNormal);

	test(Exists(_L("med")));

	test.Next(_L("Start low priority thread"));

	low.Resume();

	User::AfterHighRes(KTestDelay/10);

//	MCOUNT(M1,0);

	test.Next(_L("Start medium priority thread"));

	med.Resume();

	User::AfterHighRes(KTestDelay/10);

	Kick(med);

	User::AfterHighRes(KTestDelay/10);

	Kick(med);

	M1.Wait();

	test.Next(_L("Wait, check medium runs"));

	User::AfterHighRes(KTestDelay/10);

	M1.Signal();

	test.Next(_L("Create mutex 2"));

	r=M2.CreateLocal();

	test.Next(_L("Create high priority thread"));

	TInt highcount=0;

	RThread high;

	r=high.Create(_L("high"),HighThread,0x1000,NULL,&highcount);

	high.SetPriority(EPriorityMore);

	test(Exists(_L("high")));

	Kick(low);

	User::AfterHighRes(KTestDelay/10);

//	MCOUNT(M1,0);

	Kick(med);

//	MCOUNT(M2,1);

	high.Resume();

	User::AfterHighRes(KTestDelay/10);

//	MCOUNT(M2,0);

//	MCOUNT(M1,-1);

	M2.Wait();

	test.Next(_L("Wait, check medium runs"));

	User::AfterHighRes(KTestDelay/10);

	M2.Signal();

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

	low.Kill(0);

	med.Kill(0);

	high.Kill(0);

	low.Close();

	med.Close();

	high.Close();

	test(!Exists(_L("low")));

	test(!Exists(_L("med")));

	test(!Exists(_L("high")));

	M1.Close();

	test.End();

	}

/*****************************************************************************

 * Utilities for mutex exhaustive state transition test

 *****************************************************************************/

void MutexWait()

	{

	M1.Wait();

	++Count;

	ThreadId[PutIx++]=(TUint)RThread().Id();

	}

void MutexSignal()

	{

	M1.Signal();

	}

typedef void (*PFV)(void);

TInt ThreadFunction(TAny* aPtr)

	{

	PFV& f=*(PFV*)aPtr;

	FOREVER

		{

		MutexWait();

		if (f)

			f();

		MutexSignal();

		User::WaitForAnyRequest();

		}

	}

void Exit()

	{

	User::Exit(0);

	}

TUint CreateThread(RThread& t, TInt n, TAny* aPtr)

	{

	TBuf<4> b;

	b.Num(n);

	TInt r=t.Create(b,ThreadFunction,0x1000,NULL,aPtr);

	t.Resume();

	TUint id=t.Id();

	test.Printf(_L("id=%d\n"),id);

	return id;

	}

/*

Possible thread relationships with mutex:

	Holding

	Waiting

	Waiting + suspended

	Hold Pending

Need to verify correct behaviour when the following actions occur for each of these states:

	Suspend thread

	Resume thread

	Change thread priority

	Thread exits

	Thread is killed

	Mutex deleted

*/

PFV HoldExtra;

void KickMain()

	{

	RThread me;

	Kick(Main);

	User::WaitForAnyRequest();

	me.SetPriority(EPriorityMuchMore);

	MutexSignal();						// this should wake up t8

	MutexWait();

	MutexSignal();						// this should wake up t9

	MutexWait();

	Kick(Main);

	User::WaitForAnyRequest();

	if (HoldExtra)

		HoldExtra();

	}

void RackEmUp(RThread* t, PFV* f, TUint* id)

	{

	// set up t4 holding

	// t1, t2, t5, t10 waiting

	// t3, t6, t7 waiting+suspended

	// t8, t9 pending

	MCOUNT(M1,1);			// check mutex free

	Kick(t[4]);

	f[4]=&KickMain;

	User::WaitForAnyRequest();

	MCOUNT(M1,0);			// check mutex now held

	TInt i;

	for (i=1; i<=10; ++i)

		if (i!=4)

			Kick(t[i]);		// wake up threads

	User::After(50000);		// let threads wait

	MCOUNT(M1,-9);			// check 9 threads waiting

	Kick(t[4]);

	User::WaitForAnyRequest();

	MCOUNT(M1,-7);			// check 7 threads waiting

	NUMCHECK(3);

	IDCHECK(id4);			// from the initial wait

	IDCHECK(id4);			// now have t8, t9 pending, t4 holding, rest waiting

	IDCHECK(id4);			// now have t8, t9 pending, t4 holding, rest waiting

	t[4].SetPriority(EPriorityNormal);

	t[7].Resume();			// test resume when not suspended

	MCOUNT(M1,-7);			// check 7 threads waiting

	t[3].Suspend();

	t[6].Suspend();

	t[7].Suspend();			// now have required state

	t[3].Suspend();			// suspend and resume t3 again for good measure

	t[3].Resume();

	MCOUNT(M1,-7);			// check 7 threads waiting

	HoldExtra=NULL;

	}

void SimpleCheck(TInt n, const TUint* id, ...)

	{

	VA_LIST list;

	VA_START(list,id);

	User::After(50000);		// let stuff happen

	NUMCHECK(n);

	TInt i;

	for (i=0; i<n; ++i)

		{

		TInt tn=VA_ARG(list,TInt);

		IDCHECK(id[tn]);

		}

	}

void Resurrect(TInt n, TThreadPriority aPriority, RThread* t, PFV* f, TUint* id)

	{

	f[n]=NULL;

	id[n]=CreateThread(t[n],n,f+n);

	t[n].SetPriority(EPriorityRealTime);

	t[n].SetPriority(aPriority);

	NUMCHECK(1);

	IDCHECK(id[n]);

	}

/*****************************************************************************

 * Mutex exhaustive state transition test

 *****************************************************************************/

void TestMutex2()

	{

	test.Start(_L("Test mutex state transitions"));

	RThread t[11];

	TUint id[11];

	PFV f[11]={NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};

	id[0]=(TUint)RThread().Id();

	PutIx=0;

	GetIx=0;

	Count=0;

	test.Next(_L("Create mutex"));

	TInt r=M1.CreateLocal();