// 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>

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

 	test(x==10);

 	p.Terminate(0);

 	User::WaitForRequest(s);

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

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

 	CLOSE_AND_WAIT(p);

 	m.Close();

 	c.Close();

 	}

 TInt SecondaryProcess(RCondVar aCV)

 	{

 	RDebug::Print(_L("SecProc"));

 	RMutex mp;

 	RChunk cp;

 	TInt r = mp.Open(2);

 	if (r!=KErrNone)

 		return r;

 	r = cp.Open(3);

 	if (r!=KErrNone)

 		return r;

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

 	mp.Wait();

 	r = KErrNone;

 	while (r==KErrNone)

 		{

 		r = aCV.Wait(mp);

 		++x;

 		RDebug::Print(_L("SecProc r=%d x=%d"), r, x);

 		}

 	return r;

 	}

 TInt E32Main()

 	{

 	__KHEAP_MARK;

 	__UHEAP_MARK;

 	TInt r;

 	RCondVar cvp;

 	r = cvp.Open(1);

 	if (r==KErrNone)

 		return SecondaryProcess(cvp);

 	test.Title();

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

 	r = CV1.CreateLocal();

 	test(r==KErrNone);

 	r = CV2.CreateLocal();

 	test(r==KErrNone);

 	test.Next(_L("Signal with no-one waiting"));

 	CV1.Signal();

 	test.Next(_L("Broadcast with no-one waiting"));

 	CV1.Broadcast();

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

 	r = M1.CreateLocal();

 	test(r==KErrNone);

 	r = M2.CreateLocal();

 	test(r==KErrNone);

 	RArray<TInt> array;

 	SThreadData d0;

 	d0.iM = M2;

 	d0.iV = CV1;

 	d0.iA = &array;

 	test.Next(_L("Create thread to use mutex 2"));

 	RThread t0;

 	r = t0.Create(KNullDesC, &Thread1, 0x1000, 0x1000, 0x1000, &d0);

 	test(r==KErrNone);

 	t0.SetPriority(EPriorityMore);

 	TRequestStatus s0;

 	t0.Logon(s0);

 	t0.Resume();

 	__TRACE_LINE__;

 	AppendToArray(d0, 1, 4);

 	test(d0.iTotal==4);

 	__TRACE_LINE__;

 	AppendToArray(d0, 2, -3, 17);

 	test(d0.iTotal==18);

 	t0.Terminate(11);

 	User::WaitForRequest(s0);

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

 	test(t0.ExitReason()==11);

 	CLOSE_AND_WAIT(t0);

 	array.Reset();

 	SThreadData d;

 	d.iM = M1;

 	d.iV = CV1;

 	d.iA = &array;

 	test.Next(_L("Create thread to use mutex 1"));

 	RThread t;

 	r = t.Create(KNullDesC, &Thread1, 0x1000, 0x1000, 0x1000, &d);

 	test(r==KErrNone);

 	t.SetPriority(EPriorityMore);

 	TRequestStatus s;

 	t.Logon(s);

 	t.Resume();

 	test.Next(_L("Test wait with mutex unlocked"));

 	r = t0.Create(KNullDesC, &Thread0, 0x1000, 0x1000, 0x1000, NULL);

 	test(r==KErrNone);

 	t0.SetPriority(EPriorityMore);

 	t0.Logon(s0);

 	TBool jit = User::JustInTime();

 	User::SetJustInTime(EFalse);

 	t0.Resume();

 	User::WaitForRequest(s0);

 	User::SetJustInTime(jit);

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

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

 	test(t0.ExitReason()==ECondVarWaitMutexNotLocked);

 	CLOSE_AND_WAIT(t0);

 	test.Next(_L("Test trying to use two mutexes with 1 condition variable"));

 	M2.Wait();

 	r = CV1.Wait(M2);

 	M2.Signal();

 	test(r==KErrInUse);

 	test(d.iTotal==0);

 	__TRACE_LINE__;

 	AppendToArray(d, 1, 3);

 	test(d.iTotal==3);

 	__TRACE_LINE__;

 	AppendToArray(d, 2, 3, 19);

 	test(d.iTotal==25);

 	__TRACE_LINE__;

 	AppendToArray(d, 4, 15, -1, -2, -30);

 	test(d.iTotal==7);

 	test(d.iInnerLoops==3);

 	test(d.iOuterLoops==3);

 	__TRACE_LINE__;

 	t.Suspend();

 	__TRACE_LINE__;

 	t.Resume();

 	test(d.iTotal==7);

 	test(d.iInnerLoops==4);

 	test(d.iOuterLoops==3);

 	__TRACE_LINE__;

 	t.SetPriority(EPriorityLess);

 	test(d.iTotal==7);

 	test(d.iInnerLoops==4);

 	test(d.iOuterLoops==3);

 	__TRACE_LINE__;

 	t.SetPriority(EPriorityMore);

 	test(d.iTotal==7);

 	test(d.iInnerLoops==5);

 	test(d.iOuterLoops==3);

 	__TRACE_LINE__;

 	t.Suspend();

 	__TRACE_LINE__;

 	AppendToArray(d, 1, 4);

 	test(d.iTotal==7);

 	test(d.iInnerLoops==5);

 	test(d.iOuterLoops==3);

 	__TRACE_LINE__;

 	t.Resume();

 	test(d.iTotal==11);

 	test(d.iInnerLoops==6);

 	test(d.iOuterLoops==4);

 	SThreadData d2;

 	d2.iM = M1;

 	d2.iV = CV1;

 	d2.iA = &array;

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

 	RThread t2;

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

 	test(r==KErrNone);

 	t2.SetPriority(EPriorityMuchMore);

 	TRequestStatus s2;

 	t2.Logon(s2);

 	__TRACE_LINE__;

 	t2.Resume();

 	test(d2.iTotal == 11);

 	test(d2.iInnerLoops == 0);

 	test(d2.iOuterLoops == 1);

 	__TRACE_LINE__;

 	AppendToArray(d, 2, 9, 10);

 	test(d2.iTotal == 30);

 	test(d2.iInnerLoops == 1);

 	test(d2.iOuterLoops == 2);

 	test(d.iTotal==11);

 	test(d.iInnerLoops==6);

 	test(d.iOuterLoops==4);

 	__TRACE_LINE__;

 	AppendToArrayB(d, 2, 20, 30);

 	test(d2.iTotal == 80);

 	test(d2.iInnerLoops == 2);

 	test(d2.iOuterLoops == 3);

 	test(d.iTotal == 80);

 	test(d.iInnerLoops == 7);

 	test(d.iOuterLoops == 5);

 	__TRACE_LINE__;

 	AppendToArrayB2(d, 2, -10, -6);

 	test(d2.iTotal == 64);

 	test(d2.iInnerLoops == 3);

 	test(d2.iOuterLoops == 4);

 	test(d.iTotal == 64);

 	test(d.iInnerLoops == 8);

 	test(d.iOuterLoops == 6);

 	__TRACE_LINE__;

 	t2.Suspend();

 	__TRACE_LINE__;

 	AppendToArray(d, 2, -8, -8);

 	test(d2.iTotal == 64);

 	test(d2.iInnerLoops == 3);

 	test(d2.iOuterLoops == 4);

 	test(d.iTotal == 48);

 	test(d.iInnerLoops == 9);

 	test(d.iOuterLoops == 7);

 	__TRACE_LINE__;

 	t2.Resume();

 	test(d2.iTotal == 48);

 	test(d2.iInnerLoops == 4);

 	test(d2.iOuterLoops == 5);

 	test(d.iTotal == 48);

 	test(d.iInnerLoops == 9);

 	test(d.iOuterLoops == 7);

 	// test timeouts

 	d.iTimeoutMs = 1000;

 	__TRACE_LINE__;

 	t.Suspend();

 	__TRACE_LINE__;

 	t.Resume();

 	test(d2.iTotal == 48);

 	test(d2.iInnerLoops == 4);

 	test(d2.iOuterLoops == 5);

 	test(d2.iTimeouts == 0);

 	test(d.iTotal == 48);

 	test(d.iInnerLoops == 10);

 	test(d.iOuterLoops == 7);

 	test(d.iTimeouts == 0);

 	test(array.Append(1)==0);

 	TInt nt = 0;

 	do	{

 		if (d.iTimeouts > nt)

 			{

 			test(d.iTimeouts-nt == 1);

 			nt = d.iTimeouts;

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

 			test(d2.iTotal == 48);

 			test(d2.iInnerLoops == 4);

 			test(d2.iOuterLoops == 5);

 			test(d2.iTimeouts == 0);

 			test(d.iTotal == 48+nt);

 			test(d.iInnerLoops == 10+nt);

 			test(d.iOuterLoops == 7+nt);

 			test(array.Append(1)==0);

 			}

 		} while (nt<10);

 	d.iTimeoutMs = 0;

 	AppendToArrayB(d, 0);

 	test(d2.iTotal == 59);

 	test(d2.iInnerLoops == 5);

 	test(d2.iOuterLoops == 6);

 	test(d2.iTimeouts == 0);

 	test(d.iTotal == 59);

 	test(d.iInnerLoops == 21);

 	test(d.iOuterLoops == 18);

 	test(d.iTimeouts == 10);

 	__TRACE_LINE__;

 	t.SetPriority(EPriorityLess);

 	__TRACE_LINE__;

 	AppendToArrayB(d, 1, 11);

 	test(d2.iTotal == 70);

 	test(d2.iInnerLoops == 6);

 	test(d2.iOuterLoops == 7);

 	test(d2.iTimeouts == 0);

 	test(d.iTotal == 59);

 	test(d.iInnerLoops == 21);

 	test(d.iOuterLoops == 18);

 	test(d.iTimeouts == 10);

 	User::After(50000);

 	test(d2.iTotal == 70);

 	test(d2.iInnerLoops == 6);

 	test(d2.iOuterLoops == 7);

 	test(d2.iTimeouts == 0);

 	test(d.iTotal == 70);

 	test(d.iInnerLoops == 22);

 	test(d.iOuterLoops == 19);

 	test(d.iTimeouts == 10);

 	__TRACE_LINE__;

 	CV1.Close();

 	User::WaitForRequest(s);

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

 	test(t.ExitReason()==KErrGeneral);

 	User::WaitForRequest(s2);

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

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

 	CLOSE_AND_WAIT(t);

 	CLOSE_AND_WAIT(t2);

 	M1.Close();

 	TestGlobal();

 	Thread2Test();

 	TestSecondaryProcess();

 	RunBench();

 	M2.Close();

 	CV2.Close();

 	array.Close();

 	test.End();

 	test.Close();

 	__UHEAP_MARKEND;

 	__KHEAP_MARKEND;

 	return KErrNone;

 	}