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

	}

TInt StartInstructionThread(RThread& aT, const TDesC& aName, TInt aInstruction, TOwnerType aOwnerType, TRequestStatus* aL, TRequestStatus* aR)

	{

	TInt r = aT.Create(aName, &InstructionThread, KDefaultStackSize, KHeapSize, KHeapSize, (TAny*)aInstruction, aOwnerType);

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

	r = StartInstructionThread(thread, _L("Thread"), ENormal, EOwnerProcess, 0, 0);

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

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

	thread.Resume();   

	test.Next(_L("Absorb cancel"));

	User::WaitForRequest(stat);	

	test.Next(_L("Test LogonCancel on dead thread is ok"));

	r=thread.LogonCancel(stat);

	test(r==KErrGeneral);

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

	CLOSE_AND_WAIT(thread);

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

	thread.Close();

	thread.Close();

	thread.Close();

	thread.Close();

	__UHEAP_MARKEND;

	test.End();

	}

LOCAL_D void test2(TOwnerType anOwnerType)

//

// Test 2

//

	{                                  

	__UHEAP_MARK;

	RThread thread;

	TRequestStatus stat;

	TRequestStatus rstat;

	TInt r;

	test.Start(_L("Run thread 10 times"));

	for (TInt xx=0;xx<10;xx++)

		{

		test.Printf(_L("\r%02d"),xx);

		r = StartInstructionThread(thread, _L("Thread1"), ENormal, anOwnerType, &stat, 0);

		test_KErrNone(r);

		thread.Resume();

		User::WaitForRequest(stat);

		CLOSE_AND_WAIT(thread);

		}

	test.Printf(_L("\n"));

	test.Next(_L("Panic within thread"));

	r = StartInstructionThread(thread, _L("Thread2"), EInstrPanic, anOwnerType, &stat, 0);

	test_KErrNone(r);

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

	thread.Resume();

	User::WaitForRequest(stat);

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

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

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

	CLOSE_AND_WAIT(thread);

	test.Next(_L("Panic external to thread"));

	TInt ijk;

	TUint seed[2] = { 0xadf85458, 0 };

	TUint maxcount = 0;

	for (ijk=0; ijk<8192; ++ijk)

		{

		if (!(ijk&255))

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

		r = StartInstructionThread(thread, _L("Thread3"), EWait, anOwnerType, &stat, 0);

		test_KErrNone(r);

		__e32_atomic_store_ord32(&IFLAG, 0);

		thread.Resume();

		thread.SetPriority(EPriorityMore);

		if (maxcount==0)

			{

			while (__e32_atomic_load_acq32(&IFLAG)==0 && --maxcount!=0)

				{

				}

			maxcount = 0u - maxcount;

			test.Printf(_L("maxcount=%u\n"), maxcount);

			}

		else

			{

			TUint random = Random(seed);

			random %= maxcount;

			++random;

			while (__e32_atomic_load_acq32(&IFLAG)==0 && --random!=0)

				{

				}

			}

		thread.Panic(_L("panic"), 123);

		User::WaitForRequest(stat);

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

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

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

		CLOSE_AND_WAIT(thread);

		}

	test.Next(_L("Internal exit"));

	r = StartInstructionThread(thread, _L("Thread4"), ENormal, anOwnerType, &stat, 0);

	test_KErrNone(r);

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

	thread.Resume();

	User::WaitForRequest(stat);

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

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

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

	CLOSE_AND_WAIT(thread);

	test.Next(_L("External terminate"));

	r = StartInstructionThread(thread, _L("Thread5"), EWait, anOwnerType, &stat, &rstat);

	test_KErrNone(r);

	test.Next(_L("Terminate"));

	thread.Terminate(KTerminationReason);

	test.Next(_L("Wait"));

	User::WaitForRequest(stat);

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

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

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

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

	CLOSE_AND_WAIT(thread);

	test.Next(_L("External kill"));

	r = StartInstructionThread(thread, _L("Thread6"), EWait, anOwnerType, &stat, &rstat);

	test_KErrNone(r);

	thread.Suspend();

	thread.Resume();

	thread.Kill(KKillReason);

	User::WaitForRequest(stat);

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

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

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

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

	thread.Kill(KErrNone);

	thread.Kill(KErrNone);

	thread.Kill(KErrNone);

	CLOSE_AND_WAIT(thread);

	test.End();

  	__UHEAP_MARKEND;

	}

LOCAL_D void test3()

//

// Test 3.

//

	{

	test.Start(_L("Read across thread"));

	TReadInfo info;

	TPtrC des1=_L("tdesc");

	info.tdesc=(&des1);

	TPtrC ptr1=_L("tptrc");

	info.tptrc=&ptr1;

	TBuf<0x20> tdes(_L("tdes"));

	info.tdes=&tdes;

	TBuf<0x20> tptrbuf(_L("tptr"));

	TPtr tptr((TText*)tptrbuf.Ptr(),tptrbuf.Length(),tptrbuf.MaxLength());

	info.tptr=&tptr;

	TBuf<0x20> hbufc(_L("hbufc"));

	HBufC *pH=hbufc.Alloc();

	test(pH!=NULL);

	info.hbufc=pH;

	TBufC<0x20> tbufc(_L("tbufc"));

	info.tbufc=&tbufc;

	TBuf<0x20> tbuf(_L("tbuf"));

	info.tbuf=&tbuf;

	TBufC<0x20> tptrdes(_L("tptrdes"));

	TPtr des=tptrdes.Des();

	info.tptrdes=&des;

	TBuf<0x10> b(_L("Hello"));

	info.anAddress=(&b);

	info.anAddress= info.anAddress; //prevents warning (var set but never used)

	delete pH;

	test.End();

	}

LOCAL_D void test4()

//

// Test 4.

//

	{

	test.Start(_L("Create sempahore"));

	RSemaphore sem;

	TInt r=sem.CreateLocal(0);

	test(r==KErrNone);

//

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

	RThread t;

	r=t.Create(_L("Thread1"),test4Thread,KDefaultStackSize,KHeapSize,KHeapSize,&sem);

	test(r==KErrNone);

	t.Resume();

	t.Close();

//

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

	r=t.Create(_L("Thread2"),test4Thread,KDefaultStackSize,KHeapSize,KHeapSize,&sem);

	test(r==KErrNone);

	t.Resume();

	t.Close();

//

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

	r=t.Create(_L("Thread3"),test4Thread,KDefaultStackSize,KHeapSize,KHeapSize,&sem);

	test(r==KErrNone);

	t.Resume();

	t.Close();

//

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

	sem.Signal(3);

//

	test.Next(_L("Wait 1"));

	sem.Wait();

//

	test.Next(_L("Wait 2"));

	sem.Wait();

//

	test.Next(_L("Wait 2"));

	sem.Wait();

	sem.Close();

//

	test.End();

	}

TInt MinimalThread(TAny*)

//

// Minimal thread, used in test 5

//

	{

	return(KErrNone);

	}

LOCAL_D void test5()

//

// Test 5 - tests unclosed but completed threads

//

	{

	test.Start(_L("Start thread"));

	RThread thread1;

	test(thread1.Create(_L("Test Thread1"),MinimalThread,KDefaultStackSize,KHeapSize,KHeapSize,NULL)==KErrNone);

	TRequestStatus stat1;

	thread1.Logon(stat1);

	thread1.Resume();

	User::WaitForRequest(stat1);

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

	// 'missing'  thread1.Close();

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

	RThread thread2;

	test(thread2.Create(_L("Test Thread2"),MinimalThread,KDefaultStackSize,KHeapSize,KHeapSize,NULL)==KErrNone);

	TRequestStatus stat2;

	thread2.Logon(stat2);

	thread2.Resume();

	User::WaitForRequest(stat2);  //Goes wrong here in build 48

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

	test.Next(_L("Close both threads"));

	CLOSE_AND_WAIT(thread2);

	CLOSE_AND_WAIT(thread1);

	test.End();

	}

LOCAL_D TInt test6Thread(TAny *anArg)

//

//

//

	{

	((RSemaphore*)anArg)->Wait();

	RThread t;

	RThread dup;

	dup.Duplicate(t);

	dup.Panic(_L("Test"),0);

	return KErrNone;

	}

void test6()

//

// Test thread duplication

//

	{

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

	RSemaphore sem;

	TInt r=sem.CreateLocal(0);

	test(r==KErrNone);

	RThread t;

	t.Create(_L("test6thread"),test6Thread,KDefaultStackSize,KHeapSize,KHeapSize,&sem);

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

	TRequestStatus stat;

	t.Logon(stat);

	t.Resume();

	sem.Signal();

	User::WaitForRequest(stat);

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

	t.Close();

	sem.Close();

	test.End();

	}

RSemaphore gsem;

enum TThreadProgress { EBeforeStart, EStarted, EWaiting, EDoneWaiting, EFinished };

TThreadProgress progress=EBeforeStart;

LOCAL_D TInt test7thread(TAny * /*anArg*/)

//

//

//

	{

	progress=EStarted;

	progress=EWaiting;

	gsem.Wait();

	progress=EDoneWaiting;

	gsem.Wait();

	progress=EFinished;

	return KErrNone;

	}

void test7()

//

//	Suspend/ Resume tests

//

	{

	TInt r=gsem.CreateLocal(0);

	test(r==KErrNone);

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

	RThread t;

	r=t.Create(_L("test7thread"), test7thread, KDefaultStackSize,KHeapSize,KHeapSize,NULL);

	test(r==KErrNone);

	TRequestStatus stat;

	t.Logon(stat);

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

	t.Resume();

	User::After(KWaitTime); // wait a bit;

	test.Next(_L("Make thread wait on a semaphore"));

	test(progress==EWaiting);

	test.Next(_L("Suspend waiting thread"));

	t.Suspend();

	test.Next(_L("Signal the semaphore"));

	gsem.Signal();

	User::After(KWaitTime);

	test.Next(_L("Test thread still suspended"));

	test(progress==EWaiting);

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

	t.Resume();

	test.Next(_L("Test the thread no longer waiting on the semaphore"));

	User::After(KWaitTime);

	test(progress==EDoneWaiting);

	test.Next(_L("Wait for thread to finish"));

	gsem.Signal();

	User::WaitForRequest(stat);

	test(stat==KErrNone);

	test(progress==EFinished);

	CLOSE_AND_WAIT(t);

	RThread tt;

	progress=EBeforeStart;

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

	r=tt.Create(_L("test7thread"), test7thread, KDefaultStackSize,KHeapSize,KHeapSize,NULL);

	test(r==KErrNone);

	tt.Logon(stat);

	test.Next(_L("Suspend thread without starting it"));

	tt.Suspend();

	tt.Suspend();

	test.Next(_L("Resume and test suspend/resume balance"));

	tt.Resume();

	tt.Resume();

	User::After(KWaitTime);

	test(progress==EBeforeStart);

	tt.Resume();

	test.Next(_L("test thread is suspended on semaphore"));

	User::After(KWaitTime);

	test(progress==EWaiting);

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

	tt.Suspend();

	tt.Suspend();

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

	tt.Resume();

	tt.Resume();

	test.Next(_L("test thread still suspended on semaphore"));

	User::After(KWaitTime);

	test(progress==EWaiting);

	test.Next(_L("Suspend, Suspend, Signal semaphore, Suspend"));

	tt.Suspend();

	tt.Suspend();

	gsem.Signal();

	tt.Suspend();

	test.Next(_L("test thread still suspended on semaphore"));

	User::After(KWaitTime);

	test(progress==EWaiting);

	test.Next(_L("Resume thread, checking suspend/resume balance"));

	tt.Resume();

	User::After(KWaitTime);

	test(progress==EWaiting);

	tt.Resume();

	User::After(KWaitTime);

	test(progress==EWaiting);

	tt.Resume();

	User::After(KWaitTime);

	test(progress==EDoneWaiting);

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

	tt.Resume();

	tt.Resume();

//	test.Next(_L("Suspend and check balance"));

//	tt.Suspend();

//	tt.Suspend();

	test.Next(_L("Wait for thread to finish"));

	gsem.Signal();

	User::After(KWaitTime);

	test(progress==EFinished);

	User::WaitForRequest(stat);

	CLOSE_AND_WAIT(tt);

//

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

	r=tt.Create(_L("test7thread"), test7thread, KDefaultStackSize,KHeapSize,KHeapSize,NULL);

	test(r==KErrNone);

	tt.Logon(stat);

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

	tt.Resume();

	test.Next(_L("Hang thread on semaphore"));

	User::After(KWaitTime);

	test(progress==EWaiting);

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

	tt.Suspend();

	tt.Suspend();

	tt.Resume();

	User::After(KWaitTime);

	test(progress==EWaiting);

	tt.Resume();

	test.Next(_L("Check still hanging on semaphore"));

	User::After(KWaitTime);

	test(progress==EWaiting);

	test.Next(_L("Signal Semaphore"));

	gsem.Signal();

	test.Next(_L("Test thread executing again"));

	User::After(KWaitTime);

	test(progress==EDoneWaiting);

	test.Next(_L("Hang thread on another semaphore, and suspend"));

	tt.Suspend();

	test.Next(_L("Signal semaphore, and suspend again"));

	gsem.Signal();

	User::After(KWaitTime);

	test(progress==EDoneWaiting);

	tt.Suspend();

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

	tt.Resume();

	User::After(KWaitTime);

	test(progress==EDoneWaiting);

	tt.Resume();

	test.Next(_L("Wait for thread to finish"));

	User::After(KWaitTime);

	test(progress==EFinished);

	User::WaitForRequest(stat);

	CLOSE_AND_WAIT(tt);

	test.End();

	}

#if 0

RSemaphore Sem;

LOCAL_D TInt test8thread(TAny* aPtr)

//

//

//

	{

	typedef TBuf<0x20> TTestBuf;

	typedef volatile TTestBuf* TTestBufPtr;

	volatile TTestBufPtr& pB=*(volatile TTestBufPtr*)aPtr;

	if ((TUint)pB != 0xc90fdaa2)

		return KErrGeneral;

	Sem.Wait();

	TDesC* pD=(TDesC*)pB;

	test(*pD==_L("Everything's just hunky-dory"));

	delete (TTestBufPtr*)pB;

	__UHEAP_MARKEND;

	return KErrNone;

	}

#endif

void test8()

//

// Get Heap

//