// Copyright (c) 1994-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\system\t_condvar.cpp

// Overview:

// Test the use of the RCondVar & RMutex classes.

// API Information:

// RCondVar, RMutex

// Details:

// - Create some local conditional variables and mutexes and verify results

// are as expected.

// - Create a test thread that waits on conditional variables and mutexes, 

// append some items on an array, signal the conditional variable and mutex,

// the thread then counts the number of items on the array and passes the 

// result back to the main process. Verify results are as expected. Repeat

// with different array data.

// - Verify that a RCondVar::Wait() panics when the thread does not hold the

// specified mutex (mutex not locked).

// - Test using two mutexes with 1 conditional variable, append some items to 

// an array, verify results from the thread are as expected. 

// - Create a second thread with higher priority, perform tests similar to

// above, verify results are as expected.

// - Verify the thread timeout values are as expected.

// - Create global conditional variables and global mutexes, using two threads

// test the RCondVar::Signal() and RMutex::Wait() results are as expected.

// - Test various combinations of creating a thread, suspending and killing it

// and signalling a conditional variable and mutex. Verify results are as

// expected.

// - Create a secondary process along with a global chunk, conditional variable 

// and mutex. Signal the conditional variable and verify the results are as 

// expected.

// - Using two threads, benchmark the number of conditional variable/mutex Signal

// and Wait iterations that can be completed per second.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32std.h>

#include <e32std_private.h>

#include <e32svr.h>

#include <e32test.h>

#include <e32ldr.h>

#include <e32def.h>

#include <e32def_private.h>

#include <u32std.h>

RTest test(_L("T_CONDVAR"));

RMutex M1;

RMutex M2;

RCondVar CV1;

RCondVar CV2;

#define __TRACE_LINE__	test.Printf(_L("Line %d\n"),__LINE__)

struct SThreadData

	{

	SThreadData();

	RMutex iM;

	RCondVar iV;

	RArray<TInt>* iA;

	TInt iTotal;

	TInt iInnerLoops;

	TInt iOuterLoops;

	TInt iTimeoutMs;

	TInt iTimeouts;

	TInt iBadCount;

	};

struct SThreadData2

	{

	SThreadData2();

	const TText* iMutexName;

	const TText* iCondVarName;

	TInt iInnerLoops;

	};

SThreadData::SThreadData()

	{

	memset(this, 0, sizeof(*this));

	}

SThreadData2::SThreadData2()

	{

	memset(this, 0, sizeof(*this));

	}

TInt Thread0(TAny*)

	{

	return CV1.Wait(M1);

	}

TInt Thread1(TAny* a)

	{

	TUint32 t1, t2;

	SThreadData& d = *(SThreadData*)a;

	TInt r = KErrNone;

	TInt i = 0;

	d.iM.Wait();

	FOREVER

		{

		while (d.iA->Count()<=i && r==KErrNone)

			{

			t1 = User::NTickCount();

			if (d.iTimeoutMs)

				r = d.iV.TimedWait(d.iM, d.iTimeoutMs*1000);

			else

				r = d.iV.Wait(d.iM);

			t2 = User::NTickCount();

			++d.iInnerLoops;

			if (r == KErrTimedOut)

				{

				++d.iTimeouts;

				TInt iv = (TInt)(t2-t1);

				if (iv<d.iTimeoutMs)

					++d.iBadCount;

				r = KErrNone;

				}

			}

		if (r != KErrNone)

			break;

		++d.iOuterLoops;

		TInt c = d.iA->Count();

		for (; i<c; ++i)

			d.iTotal += (*d.iA)[i];

		}

	return r;

	}

TInt Thread2(TAny* a)

	{

	TUint32 t1, t2;

	SThreadData& d = *(SThreadData*)a;

	TInt r = KErrNone;

	d.iM.Wait();

	RThread::Rendezvous(KErrNone);

	while (r==KErrNone)

		{

		t1 = User::NTickCount();

		if (d.iTimeoutMs)

			r = d.iV.TimedWait(d.iM, d.iTimeoutMs*1000);

		else

			r = d.iV.Wait(d.iM);

		t2 = User::NTickCount();

		++d.iInnerLoops;

		if (r == KErrTimedOut)

			{

			++d.iTimeouts;

			TInt iv = (TInt)(t2-t1);

			if (iv<d.iTimeoutMs)

				++d.iBadCount;

			r = KErrNone;

			}

		}

	return r;

	}

TInt Thread3(TAny* a)

	{

	SThreadData2& d = *(SThreadData2*)a;

	RMutex m;

	RCondVar cv;

	TInt r = m.OpenGlobal(TPtrC(d.iMutexName), EOwnerThread);

	if (r!=KErrNone)

		return r;

	r = cv.OpenGlobal(TPtrC(d.iCondVarName), EOwnerThread);

	if (r!=KErrNone)

		return r;

	m.Wait();

	while (r==KErrNone)

		{

		r = cv.Wait(m);

		++d.iInnerLoops;

		}

	return r;

	}

TInt Thread4(TAny* a)

	{

	volatile TInt& count = *(volatile TInt*)a;

	TInt r = KErrNone;

	M2.Wait();

	while (r==KErrNone)

		{

		r = CV2.Wait(M2);

		++count;

		}

	return r;

	}

TInt Thread5(TAny*)

	{

	FOREVER

		{

		M2.Wait();

		CV2.Signal();

		M2.Signal();

		}

	}

void RunBench()

	{

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

	RThread t4, t5;

	TInt count = 0;

	TInt r = t4.Create(KNullDesC, &Thread4, 0x1000, 0x1000, 0x1000, &count);

	test(r==KErrNone);

	t4.SetPriority(EPriorityLess);

	r = t5.Create(KNullDesC, &Thread5, 0x1000, 0x1000, 0x1000, NULL);

	test(r==KErrNone);

	t5.SetPriority(EPriorityMuchLess);

	t4.Resume();

	t5.Resume();

	User::After(500000);

	TInt initc = count;

	User::After(5000000);

	TInt finalc = count;

	test.Printf(_L("%d iterations per second\n"), (finalc-initc)/5);

	t4.Kill(0);

	t5.Kill(0);

	CLOSE_AND_WAIT(t4);

	CLOSE_AND_WAIT(t5);

	}

void CreateThread2(RThread& aThread, SThreadData& aData, TThreadPriority aPri)

	{

	TInt r = aThread.Create(KNullDesC, &Thread2, 0x1000, 0x1000, 0x1000, &aData);

	test(r==KErrNone);

	aThread.SetPriority(aPri);

	TRequestStatus s;

	aThread.Rendezvous(s);

	test(s==KRequestPending);

	aThread.Resume();

	User::WaitForRequest(s);

	test(s==KErrNone);

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

	aData.iM.Wait();

	}

void KillThread2(RThread& aThread)

	{

	TRequestStatus s;

	aThread.Logon(s);

	test(s==KRequestPending);

	aThread.Terminate(0);

	User::WaitForRequest(s);

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

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

	test(s==0);

	CLOSE_AND_WAIT(aThread);

	}

void AppendToArray(SThreadData& aD, TInt aCount, ...)

	{

	VA_LIST list;

	VA_START(list,aCount);

	aD.iM.Wait();

	while(--aCount>=0)

		{

		test(aD.iA->Append(VA_ARG(list,TInt))==KErrNone);

		}

	aD.iV.Signal();

	aD.iM.Signal();

	}

void AppendToArrayB(SThreadData& aD, TInt aCount, ...)

	{

	VA_LIST list;

	VA_START(list,aCount);

	aD.iM.Wait();

	while(--aCount>=0)

		{

		test(aD.iA->Append(VA_ARG(list,TInt))==KErrNone);

		}

	aD.iV.Broadcast();

	aD.iM.Signal();

	}

void AppendToArrayB2(SThreadData& aD, TInt aCount, ...)

	{

	VA_LIST list;

	VA_START(list,aCount);

	aD.iM.Wait();

	while(--aCount>=0)

		{

		test(aD.iA->Append(VA_ARG(list,TInt))==KErrNone);

		}

	aD.iM.Signal();

	aD.iV.Broadcast();

	}

void Thread2Test()

	{

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

	RCondVar cv2;

	RMutex m3;

	TInt r = cv2.CreateLocal();

	test(r==KErrNone);

	r = m3.CreateLocal();

	test(r==KErrNone);

	SThreadData d1;

	d1.iM = m3;

	d1.iV = cv2;

	RThread t1;

	CreateThread2(t1, d1, EPriorityLess);

	cv2.Signal();

	m3.Signal();

	User::After(100000);

	test(d1.iInnerLoops == 1);

	KillThread2(t1);

	CreateThread2(t1, d1, EPriorityLess);

	KillThread2(t1);

	m3.Signal();

	test(d1.iInnerLoops == 1);

	CreateThread2(t1, d1, EPriorityLess);

	m3.Signal();

	User::After(10000);

	KillThread2(t1);

	test(d1.iInnerLoops == 1);

	CreateThread2(t1, d1, EPriorityLess);

	cv2.Signal();

	User::After(10000);

	KillThread2(t1);

	m3.Signal();

	test(d1.iInnerLoops == 1);

	CreateThread2(t1, d1, EPriorityLess);

	t1.Suspend();

	KillThread2(t1);

	m3.Signal();

	test(d1.iInnerLoops == 1);

	CreateThread2(t1, d1, EPriorityLess);

	User::After(10000);

	t1.Suspend();

	KillThread2(t1);

	m3.Signal();

	test(d1.iInnerLoops == 1);

	CreateThread2(t1, d1, EPriorityLess);

	cv2.Signal();

	t1.Suspend();

	KillThread2(t1);

	m3.Signal();

	test(d1.iInnerLoops == 1);

	CreateThread2(t1, d1, EPriorityLess);

	cv2.Signal();

	User::After(10000);

	t1.Suspend();

	KillThread2(t1);

	m3.Signal();

	test(d1.iInnerLoops == 1);

	cv2.Close();

	m3.Close();

	}

const TText* KMutex1Name = _S("mtx1");

const TText* KMutex2Name = _S("mtx2");

const TText* KCondVar1Name = _S("cv1");

const TText* KCondVar2Name = _S("cv2");

void TestGlobal()

	{

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

	RMutex mg1, mg2;

	RCondVar cvg1, cvg2;

	TInt r = mg1.CreateGlobal(TPtrC(KMutex1Name));

	test(r==KErrNone);

	r = mg2.CreateGlobal(TPtrC(KMutex2Name));

	test(r==KErrNone);

	r = cvg1.CreateGlobal(TPtrC(KCondVar1Name));

	test(r==KErrNone);

	r = cvg2.CreateGlobal(TPtrC(KCondVar2Name));

	test(r==KErrNone);

	SThreadData2 d1, d2;

	d1.iMutexName = KMutex1Name;

	d1.iCondVarName = KCondVar1Name;

	d2.iMutexName = KMutex2Name;

	d2.iCondVarName = KCondVar2Name;

	RThread t1, t2;

	r = t1.Create(KNullDesC, &Thread3, 0x1000, 0x1000, 0x1000, &d1);

	test(r==KErrNone);

	t1.SetPriority(EPriorityMore);

	TRequestStatus s1;

	t1.Logon(s1);

	t1.Resume();

	r = t2.Create(KNullDesC, &Thread3, 0x1000, 0x1000, 0x1000, &d2);

	test(r==KErrNone);

	t2.SetPriority(EPriorityMore);

	TRequestStatus s2;

	t2.Logon(s2);

	t2.Resume();

	test(s1==KRequestPending);

	test(s2==KRequestPending);

	test(d1.iInnerLoops == 0);

	test(d2.iInnerLoops == 0);

	cvg1.Signal();

	test(d1.iInnerLoops == 1);

	test(d2.iInnerLoops == 0);

	cvg2.Signal();

	test(d1.iInnerLoops == 1);

	test(d2.iInnerLoops == 1);

	cvg1.Close();

	cvg2.Close();

	test(s1==KRequestPending);

	test(s2==KRequestPending);

	test(d1.iInnerLoops == 1);

	test(d2.iInnerLoops == 1);

	t1.Kill(0);

	t2.Kill(0);

	User::WaitForRequest(s1);

	User::WaitForRequest(s2);

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

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

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

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

	CLOSE_AND_WAIT(t1);

	CLOSE_AND_WAIT(t2);

	r = cvg1.OpenGlobal(TPtrC(KCondVar1Name));

	test(r==KErrNotFound);

	test(cvg1.Handle()==0);

	mg1.Close();

	mg2.Close();

	}

void TestSecondaryProcess()

	{

	test.Next(_L("Test Secondary Process"));

	RProcess p;

	RChunk c;

	RMutex m;

	RCondVar cv;

	//cancel lazy dll unloading

	RLoader loader;

	TInt r = loader.Connect();

	test(r==KErrNone);

	r = loader.CancelLazyDllUnload();

	test(r==KErrNone);

	loader.Close();

	r = c.CreateGlobal(KNullDesC, 0x1000, 0x1000);

	test(r==KErrNone);

	volatile TInt& x = *(volatile TInt*)c.Base();

	x = 0;

	r = m.CreateGlobal(KNullDesC);

	test(r==KErrNone);

	r = cv.CreateGlobal(KNullDesC);

	test(r==KErrNone);

	r = p.Create(RProcess().FileName(), KNullDesC);

	test(r==KErrNone);

	p.SetPriority(EPriorityHigh);

	r = p.SetParameter(1, cv);

	test(r==KErrNone);

	r = p.SetParameter(2, m);

	test(r==KErrNone);

	r = p.SetParameter(3, c);

	test(r==KErrNone);

	TRequestStatus s;

	p.Logon(s);

	p.Resume();

	test(s==KRequestPending);

	test(x==0);

	TInt i;

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

		{

		cv.Signal();

		test(x == i+1);

		}

	cv.Close();

	test(s==KRequestPending);