// 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_semutx.cpp

 // Tests the RSemaphore, RMutex and RCriticalSection classes

 // Overview:

 // Tests the RSemaphore, RMutex and RCriticalSection classes

 // API Information:

 // RSemaphore, RMutex, RCriticalSection

 // Details:

 // - Test RSemaphore and RMutex with the producer/consumer scenario.

 // Create two threads, use signal and wait to coordinate the

 // threads. Verify results are as expected.

 // - Calculate the time required to create, resume and close a thread.

 // - Test RSemaphore::Wait(timeout) in a variety ways and timeout 

 // values. Verify results are as expected.

 // - Test RMutex via two threads which write to an array. The writing

 // and updating of the index is wrapped within a mutex pair. Verify 

 // results are as expected.

 // - Test RCriticalSection via two threads which write to an array. The 

 // writing and updating of the index is wrapped within a critical section

 // pair. Verify results are as expected.

 // Platforms/Drives/Compatibility:

 // All.

 // Assumptions/Requirement/Pre-requisites:

 // Failures and causes:

 // Base Port information:

 // 

 //

 #include <e32test.h>

 const TInt KMaxBufferSize=10;

 const TInt KMaxArraySize=10;

 const TInt KNumProducerItems=100;

 enum {EThread1ID=1,EThread2ID};

 RTest test(_L("T_SEMUTX"));

 RMutex mutex;

 RCriticalSection criticalSn;	

 TInt thread1Count,thread2Count;

 TInt arrayIndex;

 TInt array[KMaxArraySize];  

 TInt consumerArray[KNumProducerItems];

 RSemaphore slotAvailable,itemAvailable;  

 class CStack

 	{

 public:	   

 	CStack() {iCount=0;};

 	void Push(TInt aItem) {iStack[iCount++]=aItem;};

 	TInt Pop(void) {return(iStack[--iCount]);};

 private:

 	TInt iStack[KMaxBufferSize];

 	TInt iCount;

 	};

 CStack stack;

 TInt Producer(TAny*)

 	{

 	for(TInt ii=0;ii<KNumProducerItems;ii++)

 		{

 		slotAvailable.Wait();

 		mutex.Wait();

 		stack.Push(ii);

 		mutex.Signal();

 		itemAvailable.Signal();

 		}

 	return(KErrNone);

 	}

 TInt Consumer(TAny*)

 	{

 	TInt item;

 	for(TInt ii=0;ii<KNumProducerItems;ii++)

 		{

 		itemAvailable.Wait();

 		mutex.Wait();

 		item=stack.Pop();

 		mutex.Signal();

 		slotAvailable.Signal();

 		consumerArray[item]=item;

 		}

 	return(KErrNone);

 	}

 void BusyWait(TInt aMicroseconds)

 	{

 	TTime begin;

 	begin.HomeTime();

 	FOREVER

 		{

 		TTime now;

 		now.HomeTime();

 		TTimeIntervalMicroSeconds iv=now.MicroSecondsFrom(begin);

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

 			return;

 		}

 	}

 TInt MutexThreadEntryPoint1(TAny*)

 //

 // Mutex test thread 1

 //

 	{	

 	thread1Count=0;

 	TBool running=ETrue;

 	do

 		{

 		mutex.Wait();

 		BusyWait(100000);

 		if (arrayIndex<KMaxArraySize)

 			{

 			array[arrayIndex++]=EThread1ID;

 			thread1Count++;

 			}

 		else

 			running=EFalse;

 		mutex.Signal();

 		} while (running);

 	return(KErrNone);

 	}

 TInt MutexThreadEntryPoint2(TAny*)

 //

 // Mutex test thread 2

 //

 	{

 	thread2Count=0;

 	TBool running=ETrue;

 	do

 		{

 		mutex.Wait();

 		BusyWait(200000);

 		if (arrayIndex<KMaxArraySize)

 			{

 			array[arrayIndex++]=EThread2ID;

 			thread2Count++;

 			}

 		else

 			running=EFalse;

 		mutex.Signal();

 		} while (running);

 	return(KErrNone);

 	}

 TInt CriticalSnThreadEntryPoint1(TAny*)

 //

 // Critical Section test thread 1

 //

 	{	

 	thread1Count=0;

 	TBool running=ETrue;

 	do

 		{

 		criticalSn.Wait();

 		User::After(100000);

 		if (arrayIndex<KMaxArraySize)

 			{

 			array[arrayIndex++]=EThread1ID;

 			thread1Count++;

 			}

 		else

 			running=EFalse;

 		criticalSn.Signal();

 		} while (running);

 	return(KErrNone);

 	}

 TInt CriticalSnThreadEntryPoint2(TAny*)

 //

 // Critical Section test thread 2

 //

 	{

 	thread2Count=0;

 	TBool running=ETrue;

 	do

 		{

 		criticalSn.Wait();

 		User::After(200000);

 		if (arrayIndex<KMaxArraySize)

 			{

 			array[arrayIndex++]=EThread2ID;

 			thread2Count++;

 			}

 		else

 			running=EFalse;

 		criticalSn.Signal();

 		} while (running);

 	return(KErrNone);

 	}

 struct SWaitSem

 	{

 	RSemaphore iSem;

 	TInt iTimeout;

 	};

 TInt WaitSemThread(TAny* a)

 	{

 	SWaitSem& ws = *(SWaitSem*)a;

 	return ws.iSem.Wait(ws.iTimeout);

 	}

 void StartWaitSemThread(RThread& aT, SWaitSem& aW, TThreadPriority aP=EPriorityLess)

 	{

 	TInt r = aT.Create(KNullDesC, &WaitSemThread, 0x1000, 0x1000, 0x1000, &aW);

 	test(r==KErrNone);

 	aT.SetPriority(aP);

 	aT.Resume();

 	}

 void WaitForWaitSemThread(RThread& aT, TInt aResult)

 	{

 	TRequestStatus s;

 	aT.Logon(s);

 	User::WaitForRequest(s);

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

 	test(aT.ExitReason()==aResult);

 	test(s.Int()==aResult);

 	CLOSE_AND_WAIT(aT);

 	}

 TInt DummyThread(TAny*)

 	{

 	return 0;

 	}

 void TestSemaphore2()

 	{

 	test.Start(_L("Test semaphore wait with timeout"));

 	SWaitSem ws;

 	RThread t;

 	TTime initial;

 	TTime final;

 	TInt elapsed=0;

 	TInt r = ws.iSem.CreateLocal(0);

 	test(r==KErrNone);

 	RThread().SetPriority(EPriorityAbsoluteVeryLow);

 	TInt threadcount=0;

 	initial.HomeTime();

 	while (elapsed<1000000)

 		{

 		r = t.Create(KNullDesC, &DummyThread, 0x1000, NULL, NULL);

 		test(r==KErrNone);

 		t.SetPriority(EPriorityMore);

 		t.Resume();

 		t.Close();

 		++threadcount;

 		final.HomeTime();

 		elapsed = I64INT(final.Int64()-initial.Int64());

 		}

 	RThread().SetPriority(EPriorityNormal);

 	test.Printf(_L("%d threads in 1 sec\n"),threadcount);

 	TInt overhead = 1000000/threadcount;

 	test.Printf(_L("overhead = %dus\n"),overhead);

 	ws.iTimeout=1000000;

 	initial.HomeTime();

 	StartWaitSemThread(t, ws);

 	WaitForWaitSemThread(t, KErrTimedOut);

 	final.HomeTime();

 	elapsed = I64INT(final.Int64()-initial.Int64());

 	test.Printf(_L("Time taken = %dus\n"), elapsed);

 	test(elapsed>=900000+overhead && elapsed<1500000+overhead);

 	ws.iTimeout=-1;

 	initial.HomeTime();

 	StartWaitSemThread(t, ws);

 	WaitForWaitSemThread(t, KErrArgument);

 	final.HomeTime();

 	elapsed = I64INT(final.Int64()-initial.Int64());

 	test.Printf(_L("Time taken = %dus\n"), elapsed);

 	ws.iTimeout=2000000;

 	initial.HomeTime();

 	StartWaitSemThread(t, ws);

 	User::After(1000000);

 	ws.iSem.Signal();

 	WaitForWaitSemThread(t, KErrNone);

 	final.HomeTime();

 	elapsed = I64INT(final.Int64()-initial.Int64());

 	test.Printf(_L("Time taken = %dus\n"), elapsed);

 	test(elapsed>=900000+overhead && elapsed<1500000+overhead);

 	ws.iTimeout=100000;

 	StartWaitSemThread(t, ws, EPriorityMore);

 	t.Suspend();

 	ws.iSem.Signal();

 	User::After(200000);

 	t.Resume();

 	WaitForWaitSemThread(t, KErrTimedOut);

 	test(ws.iSem.Wait(1)==KErrNone);

 	ws.iTimeout=100000;

 	StartWaitSemThread(t, ws, EPriorityMore);

 	t.Suspend();

 	ws.iSem.Signal();

 	User::After(50000);

 	t.Resume();

 	WaitForWaitSemThread(t, KErrNone);

 	test(ws.iSem.Wait(1)==KErrTimedOut);

 	RThread t2;

 	ws.iTimeout=100000;

 	StartWaitSemThread(t, ws, EPriorityMuchMore);

 	StartWaitSemThread(t2, ws, EPriorityMore);

 	t.Suspend();

 	ws.iSem.Signal();

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

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

 	t.Resume();

 	WaitForWaitSemThread(t, KErrTimedOut);

 	WaitForWaitSemThread(t2, KErrNone);

 	test(ws.iSem.Wait(1)==KErrTimedOut);

 	ws.iTimeout=1000000;

 	initial.HomeTime();

 	StartWaitSemThread(t2, ws, EPriorityMore);

 	StartWaitSemThread(t, ws, EPriorityMuchMore);

 	ws.iSem.Signal();

 	WaitForWaitSemThread(t, KErrNone);

 	final.HomeTime();

 	elapsed = I64INT(final.Int64()-initial.Int64());

 	test.Printf(_L("Time taken = %dus\n"), elapsed);

 	WaitForWaitSemThread(t2, KErrTimedOut);

 	final.HomeTime();

 	elapsed = I64INT(final.Int64()-initial.Int64());

 	test.Printf(_L("Time taken = %dus\n"), elapsed);

 	test(elapsed>=900000+2*overhead && elapsed<1500000+2*overhead);

 	ws.iTimeout=1000000;

 	initial.HomeTime();

 	StartWaitSemThread(t2, ws, EPriorityMore);

 	StartWaitSemThread(t, ws, EPriorityMuchMore);

 	WaitForWaitSemThread(t, KErrTimedOut);

 	final.HomeTime();

 	elapsed = I64INT(final.Int64()-initial.Int64());

 	test.Printf(_L("Time taken = %dus\n"), elapsed);

 	WaitForWaitSemThread(t2, KErrTimedOut);

 	final.HomeTime();

 	elapsed = I64INT(final.Int64()-initial.Int64());

 	test.Printf(_L("Time taken = %dus\n"), elapsed);

 	test(elapsed>=900000+2*overhead && elapsed<1500000+2*overhead);

 	ws.iTimeout=1000000;

 	initial.HomeTime();

 	StartWaitSemThread(t2, ws, EPriorityMore);

 	StartWaitSemThread(t, ws, EPriorityMuchMore);

 	t.Kill(299792458);

 	WaitForWaitSemThread(t2, KErrTimedOut);

 	WaitForWaitSemThread(t, 299792458);

 	final.HomeTime();

 	elapsed = I64INT(final.Int64()-initial.Int64());

 	test.Printf(_L("Time taken = %dus\n"), elapsed);

 	test(elapsed>=900000+2*overhead && elapsed<1500000+2*overhead);

 	ws.iTimeout=1000000;

 	initial.HomeTime();

 	StartWaitSemThread(t, ws, EPriorityMore);

 	StartWaitSemThread(t2, ws, EPriorityMuchMore);

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

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

 	ws.iSem.Close();

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

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

 	WaitForWaitSemThread(t2, KErrGeneral);

 	WaitForWaitSemThread(t, KErrGeneral);

 	final.HomeTime();

 	elapsed = I64INT(final.Int64()-initial.Int64());

 	test.Printf(_L("Time taken = %dus\n"), elapsed);

 	test(elapsed<=50000+3*overhead);

 	test.End();

 	}

 void TestSemaphore()

 	{

 /*********** TO DO ************/

 // Check it panics if the count <0

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

 	RSemaphore semaphore;

 	RThread thread1, thread2;

 	semaphore.CreateLocal(0); 	// creates a DPlatSemaphore but casts it to a pointer to a DSemaphore

 								// sets semaphore count to the value of the parameter, 

 								// adds object to the K::Semaphores container, sets iHandle

 								// Local sets DSemaphore.iName to NULL & iOwner to Kern::CurrentProcess()

 								// Global sets iName to that passed and iOwner to NULL

 								// Adds a record into CObjectIx containing a pointer to the semaphore object

 /*	test.Next(_L("Find"));

 	fullName=semaphore.FullName();	

 	find.Find(fullName);	// sets iMatch to fullName	(misleadingly named method as it doesn't find anything)

 	test(find.Next(fullName)== KErrNone);	

 */

 	test.Next(_L("Producer/Consumer scenario"));

 	// Test Rsemaphore with the producer/consumer scenario	RThread thread1, thread2;

 	TRequestStatus stat1, stat2;

 	test(mutex.CreateLocal()==KErrNone);

 	test(slotAvailable.CreateLocal(KMaxBufferSize)==KErrNone);

 	test(itemAvailable.CreateLocal(0)==KErrNone);

 	test(thread1.Create(_L("Thread1"),Producer,KDefaultStackSize,0x200,0x200,NULL)==KErrNone);

 	test(thread2.Create(_L("Thread2"),Consumer,KDefaultStackSize,0x200,0x200,NULL)==KErrNone);

 	thread1.Logon(stat1);

 	thread2.Logon(stat2);

 	test(stat1==KRequestPending);

 	test(stat2==KRequestPending);

 	thread1.Resume(); 

 	thread2.Resume();

 	User::WaitForRequest(stat1);

 	User::WaitForRequest(stat2);

 	test(stat1==KErrNone);

 	test(stat2==KErrNone);

 	for(TInt jj=0;jj<KNumProducerItems;jj++)

 		test(consumerArray[jj]==jj);		

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

 	mutex.Close();

 	CLOSE_AND_WAIT(thread1);

 	CLOSE_AND_WAIT(thread2);

 	test.End();

 	}

 void TestMutex2()

 	{

 	RMutex m;

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

 	test(m.CreateLocal()==KErrNone);

 	// Test RMutex::IsHeld()

 	test.Next(_L("IsHeld ?"));

 	test(!m.IsHeld());

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

 	m.Wait();

 	test.Next(_L("IsHeld ?"));

 	test(m.IsHeld());

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

 	m.Signal();

 	test.Next(_L("IsHeld ?"));

 	test(!m.IsHeld());

 	test.End();

 	}

 void TestMutex()

 	{

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

 	test(mutex.CreateLocal()==KErrNone);

 	test.Next(_L("Threads writing to arrays test"));

 //

 // Create two threads which write to two arrays. The arrays and indexs

 // are global and each thread writes an identifier to the arrays. For

 // one array the writing and updating of the index is wrapped in a mutex

 // pair. The other array is a control and is not wrapaped within mutex.

 // Each thread records the number of instances it "thinks" it wrote to

 // each array. For the mutex controlled array the actual instances

 // written to the array should always be the same as the threads think.

 //

 	arrayIndex=0;

 	RThread thread1,thread2;	

 	test(thread1.Create(_L("Thread1"),MutexThreadEntryPoint1,KDefaultStackSize,0x2000,0x2000,NULL)==KErrNone);

 	test(thread2.Create(_L("Thread2"),MutexThreadEntryPoint2,KDefaultStackSize,0x2000,0x2000,NULL)==KErrNone);			 

 	TRequestStatus stat1,stat2;

 	thread1.Logon(stat1);

 	thread2.Logon(stat2);

 	test(stat1==KRequestPending);

 	test(stat2==KRequestPending);

 	thread1.Resume(); 

 	thread2.Resume();

 	User::WaitForRequest(stat1);

 	User::WaitForRequest(stat2);

 	test(stat1==KErrNone);

 	test(stat2==KErrNone); 

 	TInt thread1ActualCount=0; 

 	TInt thread2ActualCount=0;

 	TInt ii=0;

 	while(ii<KMaxArraySize)

 		{

 		if (array[ii]==EThread1ID)

 			thread1ActualCount++;

 		if (array[ii]==EThread2ID)

 			thread2ActualCount++;

 		ii++;

 		}

 	test.Printf(_L("T1 %d T1ACT %d T2 %d T2ACT %d"),thread1Count,thread1ActualCount,thread2Count,thread2ActualCount);

 	test(thread1ActualCount==thread1Count);

 	test(thread2ActualCount==thread2Count);

 	test(thread1Count==thread2Count);

 	test(thread1Count==(KMaxArraySize>>1));

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

 	CLOSE_AND_WAIT(thread1);

 	CLOSE_AND_WAIT(thread2);

 	mutex.Close();

 	test.End();

 	}

 void TestCriticalSection()

 //

 //As TestMutex, but for RCriticalSection

 //

 	{

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

 	test(criticalSn.CreateLocal()==KErrNone);

 /***************** TO DO ***********************

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

 //

 // Test finding the RCriticalSection

 //

 	TFindCriticalSection find;

 	TFullName fullName;

 	fullName=criticalSn.FullName();

 	find.Find(fullName);

 	test(find.Next(fullName)==KErrNone);

 	test(fullName==criticalSn.FullName());

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

 	test.Next(_L("Threads writing to arrays test"));

 //

 // Create two threads which write to two arrays. The arrays and indexs

 // are global and each thread writes an identifier to the arrays. For

 // one array the writing and updating of the index is wrapped in a critical

 // section pair. The other array is a control and is not wrapaped within

 // a critical section. Each thread records the number of instances it

 // "thinks" it wrote to each array. For the mutex controlled array the

 // actual instances written to the array should always be the same as the

 // threads think.

 //

 	arrayIndex=0;

 	RThread thread1,thread2;	

 	test(thread1.Create(_L("Thread1"),CriticalSnThreadEntryPoint1,KDefaultStackSize,0x2000,0x2000,NULL)==KErrNone);

 	test(thread2.Create(_L("Thread2"),CriticalSnThreadEntryPoint2,KDefaultStackSize,0x2000,0x2000,NULL)==KErrNone);			 

 	TRequestStatus stat1,stat2;

 	thread1.Logon(stat1);

 	thread2.Logon(stat2);

 	test(stat1==KRequestPending);

 	test(stat2==KRequestPending);

 	thread1.Resume(); 

 	thread2.Resume();

 	User::WaitForRequest(stat1);

 	User::WaitForRequest(stat2);

 	test(stat1==KErrNone);

 	test(stat2==KErrNone); 

 	TInt thread1ActualCount=0; 

 	TInt thread2ActualCount=0;

 	TInt ii=0;

 	while(ii<KMaxArraySize)

 		{

 		if (array[ii]==EThread1ID)

 			thread1ActualCount++;

 		if (array[ii]==EThread2ID)

 			thread2ActualCount++;

 		ii++;

 		}

 	test(thread1ActualCount==thread1Count);

 	test(thread2ActualCount==thread2Count);

 	test(thread1Count==thread2Count);

 	test(thread1Count==(KMaxArraySize>>1));

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

 	CLOSE_AND_WAIT(thread1);

 	CLOSE_AND_WAIT(thread2);

 	criticalSn.Close();

 	test.End();

 	}

 GLDEF_C TInt E32Main()

 	{	

 	test.Title();

  	__UHEAP_MARK;

 	test.Start(_L("Test RSemaphore"));

 	TestSemaphore();

 	TestSemaphore2();

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

 	TestMutex();

 	TestMutex2();

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

 	TestCriticalSection();

 	test.End();

 	__UHEAP_MARKEND;

 	return(KErrNone);

 	}