1 // Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32test\thread\t_thread.cpp

    15 // Overview:

    16 // Tests the RThread class

    17 // API Information:

    18 // RThread, RUndertaker

    19 // Details:

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

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

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

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

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

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

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

    27 // heap has not been corrupted.

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

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

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

    31 // the semaphore.

    32 // - Test unclosed but completed threads.

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

    34 // expected.

    35 // - Test thread duplication.

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

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

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

    39 // valid name. Verify results are as expected.

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

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

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

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

    44 // Platforms/Drives/Compatibility:

    45 // All.

    46 // Assumptions/Requirement/Pre-requisites:

    47 // Failures and causes:

    48 // Base Port information:

    49 // 

    50 //

    51 

    52 #define __E32TEST_EXTENSION__

    53 #include <e32test.h>

    54 #include <e32panic.h>

    55 #include <e32svr.h>

    56 #include <u32hal.h>

    57 #include <e32atomics.h>

    58 #include <e32def.h>

    59 #include <e32def_private.h>

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

    61 

    62 const TInt KNumThreads=20;

    63 

    64 const TInt KExitPanicNum=999;

    65 const TInt KHeapSize=0x200;

    66 const TInt KThreadReturnValue=9999;

    67 const TInt KTerminationReason=1234;

    68 const TInt KKillReason=4321;  

    69 enum TInstruction {ENormal,EInstrPanic,EWait};

    70 

    71 const TInt KWaitTime=800000;

    72 

    73 class TReadInfo

    74 	{

    75 public:

    76 	TDesC* tdesc;

    77 	TPtrC* tptrc;

    78 	TDes* tdes;

    79 	TPtr* tptr;

    80 	HBufC* hbufc;

    81 	TBufC<0x20>* tbufc;

    82 	TBuf<0x20>* tbuf;

    83 	TPtr* tptrdes;

    84 	TAny* anAddress;

    85 	};

    86 

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

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

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

    90 

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

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

    93 

    94 LOCAL_C TInt LoopyThread(TAny*)

    95 	{

    96 	

    97 	FOREVER

    98 		User::AfterHighRes(1000);

    99 	}

   100 

   101 LOCAL_D void testUndertaker(TOwnerType anOwnerType)

   102 //

   103 // Test RThreadWatcher

   104 //

   105 	{

   106 

   107 	RThread thread1;

   108 	TInt r;

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

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

   111 //	if (anOwnerType==EOwnerThread)

   112 //		User::SetDebugMask(0x8000867c);

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

   114 	test(r==KErrNone);

   115 	thread1.Resume();

   116 

   117 	TRequestStatus stat1;

   118 	TInt threadHandle1;

   119 	RThread w1;

   120 	RUndertaker u1;

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

   122 	r=u1.Create();

   123 	test(r==KErrNone);

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

   125 	r=u1.Logon(stat1,threadHandle1);

   126 	test(r==KErrNone);

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

   128 	r=u1.Logon(stat1,threadHandle1);

   129 	test(r==KErrInUse);

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

   131 	r=u1.LogonCancel();

   132 	test(r==KErrNone);

   133 	test(stat1==KErrCancel);

   134 

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

   136 	u1.Logon(stat1,threadHandle1);

   137 	

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

   139 	RThread thread2;

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

   141 	test(r==KErrNone);

   142 	thread2.Resume();

   143 

   144 	TRequestStatus stat2;

   145 	TInt threadHandle2;

   146 	RThread w2;

   147 	RUndertaker u2;

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

   149 	r=u2.Create();

   150 	test(r==KErrNone);

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

   152 	r=u2.Logon(stat2,threadHandle2);

   153 	test(r==KErrNone);

   154 

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

   156 	RThread thread3;

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

   158 	test(r==KErrNone);

   159 	thread3.Resume();

   160 

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

   162 	thread1.Kill(0x489);

   163 	thread1.Close();

   164 

   165 	User::WaitForRequest(stat1);

   166 	User::WaitForRequest(stat2);

   167 	test(stat1==KErrDied);

   168 	test(stat2==KErrDied);

   169 

   170 	RThread keep1;

   171 	RThread keep2;

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

   173 	keep1.SetHandle(threadHandle1);

   174 	keep2.SetHandle(threadHandle2);

   175 

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

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

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

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

   180 

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

   182 	r=u1.Logon(stat1,threadHandle1);

   183 	test(r==KErrNone);

   184 	r=u2.Logon(stat2,threadHandle2);

   185 	test(r==KErrNone);

   186 

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

   188 	thread3.Kill(0x999);

   189 	thread3.Close();

   190 

   191 	User::WaitForRequest(stat1);

   192 	User::WaitForRequest(stat2);

   193 	test(stat1==KErrDied);

   194 	test(stat2==KErrDied);

   195 

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

   197 	w1.SetHandle(threadHandle1);

   198 	w2.SetHandle(threadHandle2);

   199 

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

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

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

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

   204 	w1.Close();

   205 	CLOSE_AND_WAIT(w2);

   206 

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

   208 	r=u1.Logon(stat1,threadHandle1);

   209 	test(r==KErrNone);

   210 	r=u2.Logon(stat2,threadHandle2);

   211 	test(r==KErrNone);

   212 

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

   214 	thread2.Kill(0x707);

   215 	thread2.Close();

   216 

   217 	User::WaitForRequest(stat1);

   218 	User::WaitForRequest(stat2);

   219 	test(stat1==KErrDied);

   220 	test(stat2==KErrDied);

   221 

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

   223 	w1.SetHandle(threadHandle1);

   224 	w2.SetHandle(threadHandle2);

   225 

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

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

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

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

   230 

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

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

   233 	RThread t[KNumThreads];

   234 	TInt j;

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

   236 		{

   237 		TBuf<0x10> name;

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

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

   240 		}

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

   242 		{

   243 		t[j].Kill(666);

   244 		CLOSE_AND_WAIT(t[j]);

   245 		}

   246 

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

   248 	u1.Close();

   249 	u2.Close();

   250 	r=u1.Create();

   251 	test(r==KErrNone);

   252 	r=u2.Create();

   253 	test(r==KErrNone);

   254 

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

   256 	__KHEAP_MARK;

   257 

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

   259 	RThread threadx;

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

   261 	test(r==KErrNone);

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

   263 	threadx.Resume();

   264 

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

   266 	TRequestStatus statx;

   267 	TInt threadHandlex;

   268 	RUndertaker ux;

   269 	r=ux.Create();

   270 	test(r==KErrNone);

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

   272 	r=ux.Logon(statx,threadHandlex);

   273 	test(r==KErrNone);

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

   275 	threadx.Kill(0x666);

   276 	threadx.Close();

   277 	User::WaitForRequest(statx);

   278 	test(statx==KErrDied);

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

   280 	RThread wx;

   281 	wx.SetHandle(threadHandlex);

   282 	CLOSE_AND_WAIT(wx);

   283 

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

   285 	ux.Close();

   286 

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

   288 	__KHEAP_MARKEND;

   289 	w1.Close();

   290 	CLOSE_AND_WAIT(w2);

   291 	keep1.Close();

   292 	CLOSE_AND_WAIT(keep2);

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

   294 	CLOSE_AND_WAIT(t[KNumThreads-1]);

   295 

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

   297 	u1.Close();

   298 	u2.Close();

   299 	test.End();

   300 	}

   301 

   302 volatile TInt IFLAG;

   303 

   304 TInt InstructionThread(TAny* anInstruction)

   305 	{

   306 	__e32_atomic_store_ord32(&IFLAG, 1);

   307 	RThread::Rendezvous(KErrNone);

   308 	TInstruction what=(TInstruction)(TInt)anInstruction;

   309 	if (what==EInstrPanic)

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

   311 	if (what==ENormal)

   312 		return(KThreadReturnValue);

   313 	User::After(500000);

   314 	return(KErrNone);

   315 	}

   316 

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

   318 	{

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

   320 	if (r!=KErrNone)

   321 		return r;

   322 	if (aL)

   323 		{

   324 		aT.Logon(*aL);

   325 		TInt s = aL->Int();

   326 		test_Equal(s, KRequestPending);

   327 		}

   328 	if (aR)

   329 		{

   330 		aT.Rendezvous(*aR);

   331 		TInt s = aR->Int();

   332 		test_Equal(s, KRequestPending);

   333 		aT.Resume();

   334 		User::WaitForRequest(*aR);

   335 		s = aR->Int();

   336 		test_KErrNone(s);

   337 		}

   338 	return r;

   339 	}

   340 

   341 

   342 LOCAL_D TInt test4Thread(TAny *aSem)

   343 //

   344 // Wait to be released on the semaphore.

   345 // Then release the semaphore.

   346 //

   347 	{

   348 

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

   350 	sem.Wait();

   351 	sem.Signal();

   352 	return(KErrNone);

   353 	}

   354 

   355 TInt BadPriority(TAny* aThread)

   356 	{

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

   358 	return KErrNone;

   359 	}

   360 

   361 _LIT(KLitRomString,"RomStringRomStringRomStringRomStringRomStringRomStringRomString");

   362 

   363 LOCAL_C TInt BadFullNameThread(TAny* aPar)

   364 	{

   365 	RThread thread;

   366 	

   367 	switch ((TInt)aPar)

   368 		{

   369 		case 0:

   370 			{

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

   372 			test(NULL != hBuf);

   373 			RBuf rBuf(hBuf);

   374 			thread.FullName(rBuf);

   375 			rBuf.Close();

   376 			}

   377 			return(KErrNone);

   378 

   379 		case 1:

   380 			{

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

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

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

   384 			thread.FullName(ptr);

   385 			}

   386 			return(KErrNone);

   387 		}

   388 	return(KErrArgument);

   389 	}

   390 

   391 

   392 LOCAL_D void test1()

   393 //

   394 // Test 1

   395 //

   396 	{

   397 	

   398 	__UHEAP_MARK;

   399 	RThread thread;

   400 	TRequestStatus stat;

   401 	TInt r;

   402 

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

   404 	thread.Close();

   405 	

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

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

   408 	test_KErrNone(r);

   409 

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

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

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

   413 #if defined(__EPOC32__)

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

   415 #endif

   416 	thread.SetPriority(EPriorityMuchMore);

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

   418 //	thread.SetPriority(EPriorityNull);

   419 	RThread badThread;

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

   421 	test(r==KErrNone);

   422 	badThread.Logon(stat);

   423 	test(stat==KRequestPending);

   424 	badThread.Resume();

   425 	User::WaitForRequest(stat);

   426 	test(stat==EBadPriority);

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

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

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

   430 	CLOSE_AND_WAIT(badThread);

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

   432 

   433 #if defined(__EPOC32__)

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

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

   436 	thread.SetProcessPriority(EPriorityHigh);

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

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

   439 	thread.SetProcessPriority(EPriorityForeground);

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

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

   442 #endif

   443 

   444 	TBuf<0x100> name;

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

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

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

   448 	RProcess p;

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

   450 	name=p.Name();

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

   452 	name.Append(thread.Name());

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

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

   455 

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

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

   458 	test(NULL != hBuf);

   459 	TPtr ptr = hBuf->Des();

   460 	thread.FullName(ptr);

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

   462 	RBuf rBuf(hBuf);

   463 	thread.FullName(rBuf);

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

   465 	rBuf.Close();

   466 

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

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

   469 	test(aaa==KErrNone);

   470 	badThread.Logon(stat);

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

   472 	badThread.Resume();

   473 	User::WaitForRequest(stat);

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

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

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

   477 	CLOSE_AND_WAIT(badThread);

   478 

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

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

   481 	test(aaa==KErrNone);

   482 	badThread.Logon(stat);

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

   484 	badThread.Resume();

   485 	User::WaitForRequest(stat);

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

   487 	CLOSE_AND_WAIT(badThread);

   488 

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

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

   491 	name=p.Name();

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

   493 	RThread me;

   494 	name.Append(me.Name());

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

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

   497 

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

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

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

   501 	// no getters for iUserHeap and iFrame

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

   503 

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

   505 	thread.Logon(stat);

   506 	RThread t;

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

   508 	test(stat==KRequestPending);

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

   510 	test(r==KErrNone);

   511 	test(stat==KErrNone);

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

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

   514 

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

   516 	thread.Resume();   

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

   518 	User::WaitForRequest(stat);	

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

   520 	r=thread.LogonCancel(stat);

   521 	test(r==KErrGeneral);

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

   523 	CLOSE_AND_WAIT(thread);

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

   525 	thread.Close();

   526 	thread.Close();

   527 	thread.Close();

   528 	thread.Close();

   529 	__UHEAP_MARKEND;

   530 	test.End();

   531 	}

   532 

   533 

   534 LOCAL_D void test2(TOwnerType anOwnerType)

   535 //

   536 // Test 2

   537 //

   538 	{                                  

   539 

   540 	__UHEAP_MARK;

   541 	RThread thread;

   542 	TRequestStatus stat;

   543 	TRequestStatus rstat;

   544 	TInt r;

   545 

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

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

   548 		{

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

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

   551 		test_KErrNone(r);

   552 		thread.Resume();

   553 		User::WaitForRequest(stat);

   554 		CLOSE_AND_WAIT(thread);

   555 		}

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

   557 

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

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

   560 	test_KErrNone(r);

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

   562 	thread.Resume();

   563 	User::WaitForRequest(stat);

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

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

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

   567 	CLOSE_AND_WAIT(thread);

   568 

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

   570 	TInt ijk;

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

   572 	TUint maxcount = 0;

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

   574 		{

   575 		if (!(ijk&255))

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

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

   578 		test_KErrNone(r);

   579 		__e32_atomic_store_ord32(&IFLAG, 0);

   580 		thread.Resume();

   581 		thread.SetPriority(EPriorityMore);

   582 		if (maxcount==0)

   583 			{

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

   585 				{

   586 				}

   587 			maxcount = 0u - maxcount;

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

   589 			}

   590 		else

   591 			{

   592 			TUint random = Random(seed);

   593 			random %= maxcount;

   594 			++random;

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

   596 				{

   597 				}

   598 			}

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

   600 		User::WaitForRequest(stat);

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

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

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

   604 		CLOSE_AND_WAIT(thread);

   605 		}

   606 	

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

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

   609 	test_KErrNone(r);

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

   611 	thread.Resume();

   612 	User::WaitForRequest(stat);

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

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

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

   616 	CLOSE_AND_WAIT(thread);

   617 

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

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

   620 	test_KErrNone(r);

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

   622 	thread.Terminate(KTerminationReason);

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

   624 	User::WaitForRequest(stat);

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

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

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

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

   629 	CLOSE_AND_WAIT(thread);

   630   

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

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

   633 	test_KErrNone(r);

   634 	thread.Suspend();

   635 	thread.Resume();

   636 	thread.Kill(KKillReason);

   637 	User::WaitForRequest(stat);

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

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

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

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

   642 	thread.Kill(KErrNone);

   643 	thread.Kill(KErrNone);

   644 	thread.Kill(KErrNone);

   645 	CLOSE_AND_WAIT(thread);

   646 	test.End();

   647   	__UHEAP_MARKEND;

   648 	}

   649 

   650 LOCAL_D void test3()

   651 //

   652 // Test 3.

   653 //

   654 	{

   655 

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

   657 	TReadInfo info;

   658 	TPtrC des1=_L("tdesc");

   659 	info.tdesc=(&des1);

   660 	TPtrC ptr1=_L("tptrc");

   661 	info.tptrc=&ptr1;

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

   663 	info.tdes=&tdes;

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

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

   666 	info.tptr=&tptr;

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

   668 	HBufC *pH=hbufc.Alloc();

   669 	test(pH!=NULL);

   670 	info.hbufc=pH;

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

   672 	info.tbufc=&tbufc;

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

   674 	info.tbuf=&tbuf;

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

   676 	TPtr des=tptrdes.Des();

   677 	info.tptrdes=&des;

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

   679 	info.anAddress=(&b);

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

   681 	delete pH;

   682 	test.End();

   683 	}

   684 

   685 LOCAL_D void test4()

   686 //

   687 // Test 4.

   688 //

   689 	{

   690 

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

   692 	RSemaphore sem;

   693 	TInt r=sem.CreateLocal(0);

   694 	test(r==KErrNone);

   695 //

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

   697 	RThread t;

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

   699 	test(r==KErrNone);

   700 	t.Resume();

   701 	t.Close();

   702 //

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

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

   705 	test(r==KErrNone);

   706 	t.Resume();

   707 	t.Close();

   708 //

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

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

   711 	test(r==KErrNone);

   712 	t.Resume();

   713 	t.Close();

   714 //

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

   716 	sem.Signal(3);

   717 //

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

   719 	sem.Wait();

   720 //

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

   722 	sem.Wait();

   723 //

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

   725 	sem.Wait();

   726 	sem.Close();

   727 //

   728 	test.End();

   729 	}

   730 

   731 TInt MinimalThread(TAny*)

   732 //

   733 // Minimal thread, used in test 5

   734 //

   735 	{

   736 	return(KErrNone);

   737 	}

   738 

   739 LOCAL_D void test5()

   740 //

   741 // Test 5 - tests unclosed but completed threads

   742 //

   743 	{

   744 

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

   746 	RThread thread1;

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

   748 	TRequestStatus stat1;

   749 	thread1.Logon(stat1);

   750 	thread1.Resume();

   751 	User::WaitForRequest(stat1);

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

   753 	// 'missing'  thread1.Close();

   754 

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

   756 	RThread thread2;

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

   758 	TRequestStatus stat2;

   759 	thread2.Logon(stat2);

   760 	thread2.Resume();

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

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

   763 	

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

   765 	CLOSE_AND_WAIT(thread2);

   766 	CLOSE_AND_WAIT(thread1);

   767 

   768 	test.End();

   769 	}

   770 

   771 LOCAL_D TInt test6Thread(TAny *anArg)

   772 //

   773 //

   774 //

   775 	{

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

   777 	RThread t;

   778 	RThread dup;

   779 	dup.Duplicate(t);

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

   781 

   782 	return KErrNone;

   783 	}

   784 

   785 void test6()

   786 //

   787 // Test thread duplication

   788 //

   789 	{

   790 

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

   792 	RSemaphore sem;

   793 	TInt r=sem.CreateLocal(0);

   794 	test(r==KErrNone);

   795 

   796 	RThread t;

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

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

   799 	TRequestStatus stat;

   800 	t.Logon(stat);

   801 	t.Resume();

   802 	sem.Signal();

   803 	User::WaitForRequest(stat);

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

   805 	t.Close();

   806 	sem.Close();

   807 	test.End();

   808 	}

   809 

   810 RSemaphore gsem;

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

   812 TThreadProgress progress=EBeforeStart;

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

   814 //

   815 //

   816 //

   817 	{

   818 

   819 	progress=EStarted;

   820 	progress=EWaiting;

   821 	gsem.Wait();

   822 	progress=EDoneWaiting;

   823 	gsem.Wait();

   824 	progress=EFinished;

   825 	return KErrNone;

   826 	}

   827 

   828 void test7()

   829 //

   830 //	Suspend/ Resume tests

   831 //

   832 	{

   833 

   834 	TInt r=gsem.CreateLocal(0);

   835 	test(r==KErrNone);

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

   837 	RThread t;

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

   839 	test(r==KErrNone);

   840 	TRequestStatus stat;

   841 	t.Logon(stat);

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

   843 	t.Resume();

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

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

   846 	test(progress==EWaiting);

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

   848 	t.Suspend();

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

   850 	gsem.Signal();

   851 	User::After(KWaitTime);

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

   853 	test(progress==EWaiting);

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

   855 	t.Resume();

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

   857 	User::After(KWaitTime);

   858 	test(progress==EDoneWaiting);

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

   860 	gsem.Signal();

   861 	User::WaitForRequest(stat);

   862 	test(stat==KErrNone);

   863 	test(progress==EFinished);

   864 	CLOSE_AND_WAIT(t);

   865 

   866 	RThread tt;

   867 	progress=EBeforeStart;

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

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

   870 	test(r==KErrNone);

   871 	tt.Logon(stat);

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

   873 	tt.Suspend();

   874 	tt.Suspend();

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

   876 	tt.Resume();

   877 	tt.Resume();

   878 	User::After(KWaitTime);

   879 	test(progress==EBeforeStart);

   880 	tt.Resume();

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

   882 	User::After(KWaitTime);

   883 	test(progress==EWaiting);

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

   885 	tt.Suspend();

   886 	tt.Suspend();

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

   888 	tt.Resume();

   889 	tt.Resume();

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

   891 	User::After(KWaitTime);

   892 	test(progress==EWaiting);

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

   894 	tt.Suspend();

   895 	tt.Suspend();

   896 	gsem.Signal();

   897 	tt.Suspend();

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

   899 	User::After(KWaitTime);

   900 	test(progress==EWaiting);

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

   902 	tt.Resume();

   903 	User::After(KWaitTime);

   904 	test(progress==EWaiting);

   905 	tt.Resume();

   906 	User::After(KWaitTime);

   907 	test(progress==EWaiting);

   908 	tt.Resume();

   909 	User::After(KWaitTime);

   910 	test(progress==EDoneWaiting);

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

   912 	tt.Resume();

   913 	tt.Resume();

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

   915 //	tt.Suspend();

   916 //	tt.Suspend();

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

   918 	gsem.Signal();

   919 	User::After(KWaitTime);

   920 	test(progress==EFinished);

   921 	User::WaitForRequest(stat);

   922 	CLOSE_AND_WAIT(tt);

   923 

   924 //

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

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

   927 	test(r==KErrNone);

   928 	tt.Logon(stat);

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

   930 	tt.Resume();

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

   932 	User::After(KWaitTime);

   933 	test(progress==EWaiting);

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

   935 	tt.Suspend();

   936 	tt.Suspend();

   937 	tt.Resume();

   938 	User::After(KWaitTime);

   939 	test(progress==EWaiting);

   940 	tt.Resume();

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

   942 	User::After(KWaitTime);

   943 	test(progress==EWaiting);

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

   945 	gsem.Signal();

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

   947 	User::After(KWaitTime);

   948 	test(progress==EDoneWaiting);

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

   950 	tt.Suspend();

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

   952 	gsem.Signal();

   953 	User::After(KWaitTime);

   954 	test(progress==EDoneWaiting);

   955 	tt.Suspend();

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

   957 	tt.Resume();

   958 	User::After(KWaitTime);

   959 	test(progress==EDoneWaiting);

   960 	tt.Resume();

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

   962 	User::After(KWaitTime);

   963 	test(progress==EFinished);

   964 	User::WaitForRequest(stat);

   965 	CLOSE_AND_WAIT(tt);

   966 	test.End();

   967 	}

   968 

   969 #if 0

   970 RSemaphore Sem;

   971 LOCAL_D TInt test8thread(TAny* aPtr)

   972 //

   973 //

   974 //

   975 	{

   976 

   977 	typedef TBuf<0x20> TTestBuf;

   978 	typedef volatile TTestBuf* TTestBufPtr;

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

   980 	if ((TUint)pB != 0xc90fdaa2)

   981 		return KErrGeneral;

   982 	Sem.Wait();

   983 	TDesC* pD=(TDesC*)pB;

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

   985 	delete (TTestBufPtr*)pB;

   986 	__UHEAP_MARKEND;

   987 	return KErrNone;

   988 	}

   989 #endif

   990 

   991 void test8()

   992 //

   993 // Get Heap

   994 //

   995 	{

   996 	// !!! RThread::SetInitialParameter no longer exists

   997 

   998  	/*

   999 	typedef TBuf<0x20> TTestBuf;

  1000 	TTestBuf* buf=(TTestBuf*)0xc90fdaa2;

  1001 

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

  1003 	RThread thread;

  1004 	TInt r=thread.Create(_L("test8thread"),test8thread,KDefaultStackSize,KHeapSize,KHeapSize,NULL);

  1005 	test(r==KErrNone);

  1006 	r=Sem.CreateLocal(0);

  1007 	test(r==KErrNone);

  1008 	test.Next(_L("Set parameter"));

  1009 	r=thread.SetInitialParameter(&buf);

  1010 	test(r==KErrNone);

  1011 	TRequestStatus stat;

  1012 	thread.Logon(stat);

  1013 	thread.SetPriority(EPriorityMore);

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

  1015 	thread.Resume();

  1016 	test.Next(_L("Set initial parameter NULL"));

  1017 	r=thread.SetInitialParameter(NULL);

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

  1019 

  1020 	test.Next(_L("Get heap"));

  1021 	RHeap* heap;

  1022 	heap=thread.Heap();

  1023 	test.Next(_L("Alloc inside heap"));

  1024 	__RHEAP_MARK(heap);

  1025 	buf=(TTestBuf*)heap->Alloc(sizeof(TTestBuf));

  1026 	test(buf!=NULL);

  1027 	new(buf) TTestBuf;

  1028 	*buf=(_L("Everything's just hunky-dory"));

  1029 

  1030 	Sem.Signal();

  1031 	User::WaitForRequest(stat);

  1032 	test(stat==KErrNone);

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

  1034 	test(thread.ExitReason()==KErrNone);

  1035 

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

  1037 	thread.Close();

  1038 	Sem.Close();

  1039 	test.End();

  1040 	*/

  1041 	}

  1042 

  1043 TInt Thread(TAny* /*aAny*/)

  1044 	{

  1045 

  1046 	RTest test(_L("Any old thread"));

  1047 	test.Next(_L("Find remote thread"));

  1048 	// find the main thread

  1049 	TFullName name;

  1050 	name=RProcess().Name();

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

  1052 	TFindThread ft;

  1053 	ft.Find(name);

  1054 	TInt r=ft.Next(name);

  1055 	test(r==KErrNone);

  1056 	RThread t;

  1057 	t.Open(ft);

  1058 

  1059 	t.Close();

  1060 	return KErrNone;

  1061 	}

  1062 

  1063 void test9()

  1064 	{

  1065 

  1066 	test.Start(_L("Test create a NULL TPtr"));

  1067 	TPtr p(NULL, 10, 10);

  1068 	test.Next(_L("Create and run remote thread"));

  1069 	RThread t;

  1070 	TInt r;

  1071 	r=t.Create(_L("Any Old Thread"), Thread, 0x2000, 0x2000, 0x2000, (TAny *)&p);

  1072 	test(KErrNone==r);

  1073 	TRequestStatus stat;

  1074 	t.Logon(stat);

  1075 	t.Resume();

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

  1077 	User::WaitForRequest(stat);

  1078 	test(stat==KErrNone);

  1079 	test(t.ExitCategory()==_L("Kill"));

  1080 	test(t.ExitReason()==KErrNone);

  1081 	test(t.ExitType()==EExitKill);

  1082 	CLOSE_AND_WAIT(t);

  1083 	test.End();

  1084     }

  1085 

  1086 

  1087 

  1088 TInt FoghornLeghorn(TAny* aMutex)

  1089 //

  1090 // Thread function

  1091 //

  1092 	{

  1093 

  1094 	((RSemaphore*)aMutex)->Wait();

  1095 	RThread thread;

  1096 	TInt r=thread.Create(_L("I say * boy"),FoghornLeghorn,KDefaultStackSize,NULL,aMutex);

  1097 	test(r==KErrBadName);

  1098 	return KErrNone;

  1099 	}

  1100 

  1101 void testOpen()

  1102 	{

  1103 	

  1104 	test.Start(_L("Create Foghorn Leghorn"));

  1105 	RSemaphore fogMut;

  1106 	fogMut.CreateLocal(0);

  1107 	RThread foghorn;

  1108 	TInt r=foghorn.Create(_L("Foghorn Leghorn"),FoghornLeghorn,KDefaultStackSize,KHeapSize,KHeapSize,&fogMut);

  1109 	test(r==KErrNone);

  1110 	test.Next(_L("Logon"));

  1111 	TRequestStatus stat;

  1112 	foghorn.Logon(stat);

  1113 	test(stat==KRequestPending);

  1114 	test.Next(_L("Resume Foghorn Leghorn"));

  1115 	foghorn.Resume();

  1116 	test.Next(_L("Get full name"));

  1117 	TFindThread find(_L("*Foghorn Leghorn"));

  1118 	TFullName name;

  1119 	r=find.Next(name);

  1120 	test(r==KErrNone);

  1121 	test.Next(_L("Open another handle using full name"));

  1122 	RThread leghorn;

  1123 	r=leghorn.Open(name);

  1124 	test(r==KErrNone);

  1125 	test.Next(_L("Kill using second handle"));

  1126 	leghorn.Kill(34523);

  1127 	User::WaitForRequest(stat);

  1128 	test(stat==34523);

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

  1130 	foghorn.Close();

  1131 	CLOSE_AND_WAIT(leghorn);

  1132 

  1133 	test.Next(_L("Again! - Create Foghorn Leghorn"));

  1134 	r=foghorn.Create(_L("Foghorn Leghorn"),FoghornLeghorn,KDefaultStackSize,KHeapSize,KHeapSize,&fogMut);