// 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\thread\t_thread.cpp

// Overview:

// Tests the RThread class

// API Information:

// RThread, RUndertaker

// Details:

// - Create a thread, verify its priority, change the priority and verify results.

// - Verify naming and renaming threads works as expected.

// - Test logging on, resuming and closing a thread. Verify results are as expected.

// - Test creating threads with a variety of invalid parameters. Verify results.

// - Test the RUndertaker methods: create some threads, logon to the undertaker,

// verify results upon killing a thread and setting the thread handle.

// - Check kernel allocation when creating threads and undertakers. Verify the

// heap has not been corrupted.

// - Run a thread multiple times, panic within the thread, panic external to the

// thread and exit a thread in a variety of ways. Verify results are as expected.

// - Create a semaphore and some threads, verify the threads can wait on and signal

// the semaphore.

// - Test unclosed but completed threads.

// - Suspend and resume some threads in a variety of ways, verify results are as

// expected.

// - Test thread duplication.

// - Test opening a thread using an full name, perform various tests by finding, 

// killing, closing, recreating etc. Verify the results are as expected.

// - Test creating a thread using a duplicate name then reuse the thread with a

// valid name. Verify results are as expected.

// - Verify that a panicked thread releases an existing mutex.

// - Test thread ID: attempt to open a nonexistent thread by ID, verify different

// threads have different IDs, verify open by ID works as expected.

// - Test RThread::StackInfo(), print results and verify results are as expected.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32panic.h>

#include <e32svr.h>

#include <u32hal.h>

#include <e32atomics.h>

#include <e32def.h>

#include <e32def_private.h>

#include "../misc/prbs.h"

const TInt KNumThreads=20;

const TInt KExitPanicNum=999;

const TInt KHeapSize=0x200;

const TInt KThreadReturnValue=9999;

const TInt KTerminationReason=1234;

const TInt KKillReason=4321;  

enum TInstruction {ENormal,EInstrPanic,EWait};

const TInt KWaitTime=800000;

class TReadInfo

	{

public:

	TDesC* tdesc;

	TPtrC* tptrc;

	TDes* tdes;

	TPtr* tptr;

	HBufC* hbufc;

	TBufC<0x20>* tbufc;

	TBuf<0x20>* tbuf;

	TPtr* tptrdes;

	TAny* anAddress;

	};

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

LOCAL_D RTest rtest(_L("Read thread tests"));

LOCAL_D	RTest wtest(_L("Write thread tests"));

#define rtest(x) rtest(x,__LINE__)

#define wtest(x) wtest(x,__LINE__)

LOCAL_C TInt LoopyThread(TAny*)

	{

	FOREVER

		User::AfterHighRes(1000);

	}

LOCAL_D void testUndertaker(TOwnerType anOwnerType)

//

// Test RThreadWatcher

//

	{

	RThread thread1;

	TInt r;

	test.Start(_L("Test the RUndertaker class"));

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

//	if (anOwnerType==EOwnerThread)

//		User::SetDebugMask(0x8000867c);

	r=thread1.Create(_L("Loopy1"),LoopyThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)NULL,anOwnerType);

	test(r==KErrNone);

	thread1.Resume();

	TRequestStatus stat1;

	TInt threadHandle1;

	RThread w1;

	RUndertaker u1;

	test.Next(_L("Create an RUndertaker"));

	r=u1.Create();

	test(r==KErrNone);

	test.Next(_L("Logon to RUndertaker"));

	r=u1.Logon(stat1,threadHandle1);

	test(r==KErrNone);

	test.Next(_L("Logon again & check we're rejected"));

	r=u1.Logon(stat1,threadHandle1);

	test(r==KErrInUse);

	test.Next(_L("Cancel logon to RUndertaker"));

	r=u1.LogonCancel();

	test(r==KErrNone);

	test(stat1==KErrCancel);

	test.Next(_L("Logon to RUndertaker again"));

	u1.Logon(stat1,threadHandle1);

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

	RThread thread2;

	r=thread2.Create(_L("Loopy2"),LoopyThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)NULL,anOwnerType);

	test(r==KErrNone);

	thread2.Resume();

	TRequestStatus stat2;

	TInt threadHandle2;

	RThread w2;

	RUndertaker u2;

	test.Next(_L("Create another RUndertaker"));

	r=u2.Create();

	test(r==KErrNone);

	test.Next(_L("Logon to RUndertaker"));

	r=u2.Logon(stat2,threadHandle2);

	test(r==KErrNone);

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

	RThread thread3;

	r=thread3.Create(_L("Loopy3"),LoopyThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)NULL,anOwnerType);

	test(r==KErrNone);

	thread3.Resume();

	test.Next(_L("Kill the first thread & check the undertakers"));

	thread1.Kill(0x489);

	thread1.Close();

	User::WaitForRequest(stat1);

	User::WaitForRequest(stat2);

	test(stat1==KErrDied);

	test(stat2==KErrDied);

	RThread keep1;

	RThread keep2;

	test.Next(_L("Set the RThread handles"));

	keep1.SetHandle(threadHandle1);

	keep2.SetHandle(threadHandle2);

	test.Next(_L("Test the exit reasons"));

	test(keep1.ExitReason()==0x489);

	test(keep2.ExitReason()==0x489);

//	test.Printf(_L("Thread name %S\n"),&(w1.Name()));

	test.Next(_L("Logon again with both watchers"));

	r=u1.Logon(stat1,threadHandle1);

	test(r==KErrNone);

	r=u2.Logon(stat2,threadHandle2);

	test(r==KErrNone);

	test.Next(_L("Kill the 3rd thread & check the undertakers"));

	thread3.Kill(0x999);

	thread3.Close();

	User::WaitForRequest(stat1);

	User::WaitForRequest(stat2);

	test(stat1==KErrDied);

	test(stat2==KErrDied);

	test.Next(_L("Set the RThread handles"));

	w1.SetHandle(threadHandle1);

	w2.SetHandle(threadHandle2);

	test.Next(_L("Test the exit reasons"));

	test(w1.ExitReason()==0x999);

	test(w2.ExitReason()==0x999);

//	test.Printf(_L("Thread name %S\n"),&(w1.Name()));

	w1.Close();

	CLOSE_AND_WAIT(w2);

	test.Next(_L("Logon again with both undertakers"));

	r=u1.Logon(stat1,threadHandle1);

	test(r==KErrNone);

	r=u2.Logon(stat2,threadHandle2);

	test(r==KErrNone);

	test.Next(_L("Kill the 2nd thread & check the undertakers"));

	thread2.Kill(0x707);

	thread2.Close();

	User::WaitForRequest(stat1);

	User::WaitForRequest(stat2);

	test(stat1==KErrDied);

	test(stat2==KErrDied);

	test.Next(_L("Set the RThread handles"));

	w1.SetHandle(threadHandle1);

	w2.SetHandle(threadHandle2);

	test.Next(_L("Test the exit reasons"));

	test(w1.ExitReason()==0x707);

	test(w2.ExitReason()==0x707);

//	test.Printf(_L("Thread name %S\n"),&(w1.Name()));

	test.Next(_L("Check kernel allocation"));

	test.Next(_L("Please wait while I create & close masses of threads"));

	RThread t[KNumThreads];

	TInt j;

	for (j=0; j<KNumThreads; j++)

		{

		TBuf<0x10> name;

		name.Format(_L("LoopyThread%d"),j);

		test(t[j].Create(name, LoopyThread, KDefaultStackSize, KHeapSize, KHeapSize, (TAny*)NULL,anOwnerType)==KErrNone);

		}

	for (j=0; j<KNumThreads-1; j++)

		{

		t[j].Kill(666);

		CLOSE_AND_WAIT(t[j]);

		}

	test.Next(_L("Please wait while I close & create some undertakers"));

	u1.Close();

	u2.Close();

	r=u1.Create();

	test(r==KErrNone);

	r=u2.Create();

	test(r==KErrNone);

	test.Next(_L("Mark kernel heap"));

	__KHEAP_MARK;

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

	RThread threadx;

	r=threadx.Create(_L("Loopyx"),LoopyThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)NULL,anOwnerType);

	test(r==KErrNone);

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

	threadx.Resume();

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

	TRequestStatus statx;

	TInt threadHandlex;

	RUndertaker ux;

	r=ux.Create();

	test(r==KErrNone);

	test.Next(_L("Logon to undertaker"));

	r=ux.Logon(statx,threadHandlex);

	test(r==KErrNone);

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

	threadx.Kill(0x666);

	threadx.Close();

	User::WaitForRequest(statx);

	test(statx==KErrDied);

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

	RThread wx;

	wx.SetHandle(threadHandlex);

	CLOSE_AND_WAIT(wx);

	test.Next(_L("Close undertaker"));

	ux.Close();

	test.Next(_L("Check kernel heap"));

	__KHEAP_MARKEND;

	w1.Close();

	CLOSE_AND_WAIT(w2);

	keep1.Close();

	CLOSE_AND_WAIT(keep2);

	t[KNumThreads-1].Kill(666);

	CLOSE_AND_WAIT(t[KNumThreads-1]);

	test.Next(_L("Close RUndertakers"));

	u1.Close();

	u2.Close();

	test.End();

	}

volatile TInt IFLAG;

TInt InstructionThread(TAny* anInstruction)

	{

	__e32_atomic_store_ord32(&IFLAG, 1);

	RThread::Rendezvous(KErrNone);

	TInstruction what=(TInstruction)(TInt)anInstruction;

	if (what==EInstrPanic)

		User::Panic(_L("Hello"), KExitPanicNum);

	if (what==ENormal)

		return(KThreadReturnValue);

	User::After(500000);

	return(KErrNone);

	}

	{

	if (r!=KErrNone)

		return r;

	if (aL)

		{

		aT.Logon(*aL);

		TInt s = aL->Int();

		test_Equal(s, KRequestPending);

		}

	if (aR)

		{

		aT.Rendezvous(*aR);

		TInt s = aR->Int();

		test_Equal(s, KRequestPending);

		aT.Resume();

		User::WaitForRequest(*aR);

		s = aR->Int();

		test_KErrNone(s);

		}

	return r;

	}

LOCAL_D TInt test4Thread(TAny *aSem)

//

// Wait to be released on the semaphore.

// Then release the semaphore.

//

	{

	RSemaphore& sem=(*(RSemaphore*)aSem);

	sem.Wait();

	sem.Signal();

	return(KErrNone);

	}

TInt BadPriority(TAny* aThread)

	{

	((RThread*)aThread)->SetPriority(EPriorityNull);

	return KErrNone;

	}

_LIT(KLitRomString,"RomStringRomStringRomStringRomStringRomStringRomStringRomString");

LOCAL_C TInt BadFullNameThread(TAny* aPar)

	{

	RThread thread;

	switch ((TInt)aPar)

		{

		case 0:

			{

			HBufC* hBuf = HBufC::New(5);//Size 5 is not sufficient. thread.FullName should panic.

			test(NULL != hBuf);

			RBuf rBuf(hBuf);

			thread.FullName(rBuf);

			rBuf.Close();

			}

			return(KErrNone);

		case 1:

			{

			TPtr ptr((TText*)(KLitRomString.iBuf), KLitRomString.iTypeLength);

			// Passing descriptor whose data is in ROM. This may behave in different ways

			// on differrent platforms. Here, we just check that Kernel is safe.

			thread.FullName(ptr);

			}

			return(KErrNone);

		}

	return(KErrArgument);

	}

LOCAL_D void test1()

//

// Test 1

//

	{

	__UHEAP_MARK;

	RThread thread;

	TRequestStatus stat;

	TInt r;

	test.Start(_L("Close without create"));

	thread.Close();

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

	test_KErrNone(r);

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

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

	thread.SetPriority(EPriorityRealTime);	// WINS will commute this to EPriorityMuchMore

#if defined(__EPOC32__)

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

#endif

	thread.SetPriority(EPriorityMuchMore);

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

//	thread.SetPriority(EPriorityNull);

	RThread badThread;

	r = badThread.Create(_L("Bad Priority"),BadPriority,KDefaultStackSize,KHeapSize,KHeapSize,&thread);

	test(r==KErrNone);

	badThread.Logon(stat);

	test(stat==KRequestPending);

	badThread.Resume();

	User::WaitForRequest(stat);

	test(stat==EBadPriority);

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

	test(badThread.ExitReason()==EBadPriority);

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

	CLOSE_AND_WAIT(badThread);

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

#if defined(__EPOC32__)

	test.Next(_L("Test setting process priority from thread"));

	test(thread.ProcessPriority()==EPriorityForeground);

	thread.SetProcessPriority(EPriorityHigh);

	test(thread.ProcessPriority()==EPriorityHigh);

	test(RProcess().Priority()==EPriorityHigh);

	thread.SetProcessPriority(EPriorityForeground);

	test(thread.ProcessPriority()==EPriorityForeground);

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

#endif

	TBuf<0x100> name;

	test.Next(_L("Test thread name"));

	test(thread.Name()==_L("Thread"));

	test.Next(_L("Get owning process name"));

	RProcess p;

	test(thread.Process(p)==KErrNone);

	name=p.Name();

	name.Append(_L("::"));

	name.Append(thread.Name());

	test.Next(_L("Test fullname - via TFullName RHandleBase::FullName"));

	test(thread.FullName().CompareF(name)==0);

	test.Next(_L("Test fullname - via void RHandleBase::FullName(TDes& aName)"));

	HBufC* hBuf = HBufC::New(100);

	test(NULL != hBuf);

	TPtr ptr = hBuf->Des();

	thread.FullName(ptr);

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

	RBuf rBuf(hBuf);

	thread.FullName(rBuf);

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

	rBuf.Close();

	test.Next(_L("Test void RHandleBase::FullName(TDes& aName) when aName is too short"));

	TInt aaa=badThread.Create(_L("BadFullNameThread1"),BadFullNameThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)0);

	test(aaa==KErrNone);

	badThread.Logon(stat);

	test(badThread.ExitType()==EExitPending);

	badThread.Resume();

	User::WaitForRequest(stat);

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

	test(badThread.ExitReason()==EKUDesSetLengthOverflow);

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

	CLOSE_AND_WAIT(badThread);

	test.Next(_L("Test void RHandleBase::FullName(TDes& aName) where aName has data in ROM "));

	aaa=badThread.Create(_L("BadFullNameThread2"),BadFullNameThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)1);

	test(aaa==KErrNone);

	badThread.Logon(stat);

	test(badThread.ExitType()==EExitPending);

	badThread.Resume();

	User::WaitForRequest(stat);

	test.Printf(_L("BadFullNameThread2 exited with ExitReason=%d and ExitType=%d\n"),badThread.ExitReason(),badThread.ExitType());

	CLOSE_AND_WAIT(badThread);

	test.Next(_L("Rename current thread"));

	test(User::RenameThread(_L("renamed"))==KErrNone);

	name=p.Name();

	name.Append(_L("::"));

	RThread me;

	name.Append(me.Name());

	test(me.Name()==_L("renamed"));

	test(me.FullName().CompareF(name)==0);

	test.Next(_L("Test running exit types"));

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

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

	// no getters for iUserHeap and iFrame

	test(thread.ExitCategory()==KNullDesC);

	test.Next(_L("Test logging on"));

	thread.Logon(stat);

	RThread t;

	test(t.RequestCount()==0);

	test(stat==KRequestPending);

	r=thread.LogonCancel(stat); // this generates a signal 

	test(r==KErrNone);

	test(stat==KErrNone);

	test(t.RequestCount()==1); // the request count is 1 due to the signal generated by LogonCancel

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