diff -r 000000000000 -r a41df078684a kerneltest/e32test/bench/t_svr5.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/bench/t_svr5.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,1191 @@
+// 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\bench\t_svr5.cpp
+// Overview:
+// Test client server shareable sessions and benchmark their performance.
+// API information:
+// CSession2, CServer2, RSessionBase, RMessage2, DServer, DSession 
+// Details:
+// - Start the test server
+// - Open a connection with the server specifying 0 message slots should be 
+// available for the session and verify the server returns KErrServerBusy 
+// when it tries to pass a message to it.
+// - Open a connection using a fixed pool of messages and test that the server 
+// handles the messages correctly.
+// - Open a connection using the kernel's global pool of messages and test the 
+// servers handles the messages correctly.
+// - Open a shareable session with the server and verify that:
+// - all arguments are passed to the server and back correctly
+// - server can read and write to/from the client and return the appropriate 
+// errors when bad descriptors are passed in.
+// - another thread can share the session to send messages to the server.
+// - a message sent by one thread can be saved and completed later in 
+// response to a message sent by a different thread.
+// - another thread can close the session.
+// - a different thread can attach to a session by handle.
+// - Establish a global shareable session to the server and test it fails, as 
+// the server doesn't support global shareable sessions.
+// - Open an unshareable session with the server and verify that:
+// - all arguments are passed to the server and back correctly.
+// - server can reads and write to/from the client and return the 
+// appropriate errors when bad descriptors are passed in.
+// - the session handle is local (thread owned)
+// - Open an automatically shared session using ShareAuto and test it can be 
+// shared by threads in the same process.
+// - Send dummy messages that the server completes immediately and display how 
+// many are completed per second.
+// - Verify that stopping the server completes existing pending requests with 
+// KErrServerTerminated.
+// - Verify that the kernel does not crash by completing a message with an invalid 
+// handle and verify the client is panicked with EBadMessageHandle.
+// Platforms/Drives/Compatibility:
+// All.
+// Assumptions/Requirement/Pre-requisites:
+// Failures and causes:
+// Base Port information:
+// This test does not help to validate an EKA2 port.
+// 
+//
+
+#include <e32base.h>
+#include <e32base_private.h>
+#define __E32TEST_EXTENSION__
+#include <e32test.h>
+#include <e32svr.h>
+
+#include "../mmu/mmudetect.h"
+
+const TInt KHeapSize=0x2000;
+const TInt KMajorVersionNumber=1;
+const TInt KMinorVersionNumber=0;
+const TInt KBuildVersionNumber=1;
+
+_LIT(KServerName,"Display");
+
+TInt SessionCreateLResult=0;
+TInt SessionCostructCount=0;
+TInt SessionDestructCount=0;
+
+class CMySession : public CSession2
+	{
+public:
+	CMySession();
+	~CMySession();
+	void DisplayName(const RMessage2& aM);
+	virtual void ServiceL(const RMessage2& aMessage);
+	virtual void CreateL();
+	TInt Hold(const RMessage2& aM);
+	TInt Release(const RMessage2& aM);
+public:
+	RPointerArray<TInt> iAsyncMsgArray;	// 'pointers' are actually message handles
+	TInt iCompleteIndex;
+	};
+
+TInt AsyncMsgOrder(const TInt& aL, const TInt& aR)
+	{
+	TInt lh = (TInt)&aL;
+	TInt rh = (TInt)&aR;
+	RMessage2 l(*(const RMessagePtr2*)&lh);
+	RMessage2 r(*(const RMessagePtr2*)&rh);
+	return l.Int0() - r.Int0();
+	}
+
+TInt GetClientName(const RMessagePtr2& aM, TFullName& aN)
+	{
+	RThread t;
+	TInt r = aM.Client(t);
+	if (r==KErrNone)
+		{
+		aN = t.FullName();
+		t.Close();
+		}
+	return r;
+	}
+
+class CMyServer : public CServer2
+	{
+public:
+	enum {EDisplay,ERead,EWrite,ETest,EStop,EHold,ERelease,EGetCompleteIndex};
+public:
+	CMyServer(TInt aPriority);
+	static CMyServer* New(TInt aPriority);
+	virtual CSession2* NewSessionL(const TVersion& aVersion,const RMessage2& aMessage) const;
+	};
+
+class CMyActiveScheduler : public CActiveScheduler
+	{
+public:
+	virtual void Error(TInt anError) const;	 //Overloading pure virtual function
+	};
+
+class RDisplay : public RSessionBase
+	{
+public:
+	TInt Open();
+	TInt OpenNoAsync();
+	TInt OpenDynamic();
+	TInt OpenUS();
+	TInt OpenS();
+	TInt OpenGS();
+	TInt Display(const TDesC& aMessage);
+	TInt Read();
+	TInt Write();
+	TInt Stop();
+	TInt Test();
+	TInt Echo(TInt aWhat, TInt a0, TInt a1, TInt a2, TInt a3);
+	TVersion Version();
+	TInt Hold(TInt aOrder=0, TInt aArg=0);
+	void Hold(TRequestStatus& aStatus, TInt aOrder=0, TInt aArg=0);
+	TInt Release(TInt aCount=KMaxTInt);
+	TInt CompleteIndex();
+	};
+
+LOCAL_D RTest test(_L("T_SVR"));
+LOCAL_D RTest testSvr(_L("T_SVR Server"));
+LOCAL_D RTest testSpeedy(_L("T_SVR Speedy"));
+LOCAL_D RSemaphore client;
+LOCAL_D TInt speedCount;
+
+CMySession::CMySession()
+//
+// Constructor
+//
+	{
+	++SessionCostructCount;
+	}
+
+CMySession::~CMySession()
+	{
+	iAsyncMsgArray.Close();
+	++SessionDestructCount;
+	}
+
+void CMySession::CreateL()
+	{
+	User::LeaveIfError(SessionCreateLResult);
+	}
+
+void CMySession::DisplayName(const RMessage2& aM)
+//
+// Display the client's name.
+//
+	{
+
+	TFullName fn;
+	TInt r = GetClientName(aM, fn);
+	testSvr(r==KErrNone);
+	TBuf<256> text;
+	r=aM.Read(0,text);
+	testSvr(r==KErrNone);
+	testSvr.Printf(_L("Session %08x %S\n%S\n"), this, &fn, &text);
+	}
+
+CMyServer* CMyServer::New(TInt aPriority)
+//
+// Create a new CMyServer.
+//
+	{
+	
+	return new CMyServer(aPriority);
+	}
+
+CMyServer::CMyServer(TInt aPriority)
+//
+// Constructor.
+//
+	: CServer2(aPriority, ESharableSessions)
+	{}
+
+CSession2* CMyServer::NewSessionL(const TVersion& aVersion, const RMessage2&) const
+//
+// Create a new client for this server.
+//
+	{
+
+	TVersion v(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);
+	if (!User::QueryVersionSupported(v,aVersion))
+		User::Leave(KErrNotSupported);
+	return new(ELeave) CMySession;
+	}
+
+void CMySession::ServiceL(const RMessage2& aMessage)
+//
+// Handle messages for this server.
+//
+	{
+
+	TInt f = aMessage.Function();
+	if (f & 0x40000000)
+		{
+		TInt what = f & 0x3fffffff;
+		TInt a0 = aMessage.Int0();
+		TInt a1 = aMessage.Int1();
+		TInt a2 = aMessage.Int2();
+		TInt a3 = aMessage.Int3();
+		switch (what)
+			{
+			case 0:
+				aMessage.Complete(a0);
+				return;
+			case 1:
+				aMessage.Complete(a1);
+				return;
+			case 2:
+				aMessage.Complete(a2);
+				return;
+			case 3:
+				aMessage.Complete(a3);
+				return;
+			case 4:
+				aMessage.Complete(a0+a1+a2+a3);
+				return;
+			case 5:
+				aMessage.Complete(a0*a0+a1*a1+a2*a2+a3*a3);
+				return;
+			default:
+				break;
+			}
+		}
+
+	TInt r=KErrNone;
+	TBuf<0x100> b;
+	switch (f)
+		{
+	case CMyServer::EDisplay:
+		DisplayName(aMessage);
+		break;
+	case CMyServer::ERead:
+		testSvr.Printf(_L("read message received\n"));
+		r=aMessage.Read(0,b);
+		if (r==KErrNone && b!=_L("Testing read"))
+			r=KErrGeneral;
+		if (r==KErrNone)
+			{
+            r=aMessage.Read(0,b,-1);
+			if (r==KErrNone)
+				r=KErrGeneral;
+			if (r==KErrArgument)
+				r=KErrNone;
+			}
+		if (r==KErrNone && HaveVirtMem())
+			{
+			r=aMessage.Read(1,b);
+			if (r==KErrNone)
+				r=KErrGeneral;
+			if (r==KErrBadDescriptor)
+				r=KErrNone;
+			}
+		break;
+	case CMyServer::EWrite:
+		testSvr.Printf(_L("write message received\n"));
+		r=aMessage.Write(0,_L("It worked!"));
+		RDebug::Print(_L("Write returns %d"),r);
+		if (r==KErrNone)
+			{
+			r=aMessage.Write(0,b,-1);
+			if (r==KErrNone)
+				r=KErrGeneral;
+			if (r==KErrArgument)
+				r=KErrNone;
+			}
+		if (r==KErrNone)
+			{
+			r=aMessage.Write(1,b);
+			if (r==KErrNone)
+				r=KErrGeneral;
+			if (r==KErrBadDescriptor)
+				r=KErrNone;
+			}
+		if (r==KErrNone && HaveVirtMem())
+			{
+			r=aMessage.Write(2,b);
+			if (r==KErrNone)
+				r=KErrGeneral;
+			if (r==KErrBadDescriptor)
+				r=KErrNone;
+			}
+		break;
+	case CMyServer::ETest:
+		break;
+	case CMyServer::EStop:
+		testSvr.Printf(_L("stop message received\n"));
+		CActiveScheduler::Stop();
+		break;
+	case CMyServer::EHold:
+		{
+		r = Hold(aMessage);
+		if (r==KErrNone)
+			return;
+		break;
+		}
+	case CMyServer::ERelease:
+		{
+		r = Release(aMessage);
+		break;
+		}
+	case CMyServer::EGetCompleteIndex:
+		{
+		r = iCompleteIndex;
+		break;
+		}
+	default:
+		r=KErrNotSupported;
+		}
+	aMessage.Complete(r);
+	}
+
+TInt CMySession::Hold(const RMessage2& a)
+	{
+	TInt ord = a.Int0();
+	TInt arg = a.Int1();
+	TFullName fn;
+	TInt r = GetClientName(a, fn);
+	testSvr(r==KErrNone);
+    testSvr.Printf(_L("Hold message from %S ord %08x arg %08x\n"), &fn, ord, arg);
+	r = iAsyncMsgArray.InsertInOrder((const TInt*)a.Handle(), &AsyncMsgOrder);
+	return r;
+	}
+
+TInt CMySession::Release(const RMessage2& a)
+	{
+	TInt req_count = a.Int0();
+	TInt avail = iAsyncMsgArray.Count();
+	TInt count = Min(req_count, avail);
+	TFullName fn;
+	TInt r = GetClientName(a, fn);
+	testSvr(r==KErrNone);
+	testSvr.Printf(_L("Release message from %S req_count=%d count=%d\n"), &fn, req_count, count);
+	while (count--)
+		{
+		TInt mp = (TInt)iAsyncMsgArray[0];
+		iAsyncMsgArray.Remove(0);
+		RMessage2 m(*(const RMessagePtr2*)&mp);
+		TInt arg = m.Int1();
+		TInt code = arg ? arg ^ iCompleteIndex : 0;
+		r = GetClientName(m, fn);
+		testSvr(r==KErrNone);
+		testSvr.Printf(_L("Releasing %S arg=%08x index=%08x code=%08x\n"), &fn, arg, iCompleteIndex, code);
+		++iCompleteIndex;
+		m.Complete(code);
+		}
+	return KErrNone;
+	}
+
+void CMyActiveScheduler::Error(TInt anError) const
+//
+// Called if any Run() method leaves.
+//
+	{
+
+	testSvr.Panic(anError,_L("CMyActiveScheduler::Error"));
+	}
+
+TInt RDisplay::Open()
+	{
+	TInt r=CreateSession(KServerName,Version(),8);	// use fixed pool of 8 slots
+	if (r==KErrNone)
+		r=ShareAuto();
+	return r;
+	}
+
+TInt RDisplay::OpenUS()
+	{
+	return CreateSession(KServerName,Version(),8,EIpcSession_Unsharable);	// use fixed pool of 8 slots
+	}
+
+TInt RDisplay::OpenS()
+	{
+	return CreateSession(KServerName,Version(),8,EIpcSession_Sharable);	// use fixed pool of 8 slots
+	}
+
+TInt RDisplay::OpenGS()
+	{
+	return CreateSession(KServerName,Version(),8,EIpcSession_GlobalSharable);	// use fixed pool of 8 slots
+	}
+
+TInt RDisplay::OpenNoAsync()
+	{
+
+	TInt r=CreateSession(KServerName,Version(),0);	// no asynchronous messages allowed
+	if (r==KErrNone)
+		r=ShareAuto();
+	return r;
+	}
+
+TInt RDisplay::OpenDynamic()
+	{
+	TInt r=CreateSession(KServerName,Version(),-1);	// use global dynamic message pool
+	if (r==KErrNone)
+		r=ShareAuto();
+	return r;
+	}
+
+TInt RDisplay::Display(const TDesC& aMessage)
+//
+// Display a message.
+//
+	{
+
+	TBuf<0x100> b(aMessage);
+	return SendReceive(CMyServer::EDisplay, TIpcArgs(&b));
+	}
+
+TInt RDisplay::Read()
+//
+// Get session to test CSession2::ReadL.
+//
+	{
+
+	TBuf<0x10> b(_L("Testing read"));
+	TBuf<0x10>* bad = (TBuf<0x10> *)(0x30000000);
+
+	return SendReceive(CMyServer::ERead, TIpcArgs(&b, bad));
+	}
+
+TInt RDisplay::Write()
+//
+// Get session to test CSession2::WriteL.
+//
+	{
+
+	TBuf<0x10> b;
+    TBufC<0x10> c; // Bad descriptor - read only
+	TBuf<0x10>* bad = (TBuf<0x10> *)(0x30000000);
+	TInt r=SendReceive(CMyServer::EWrite, TIpcArgs(&b, &c, bad));
+	if (r==KErrNone && b!=_L("It worked!"))
+		r=KErrGeneral;
+	return r;
+	}
+
+TInt RDisplay::Test()
+//
+// Send a message and wait for completion.
+//
+	{
+
+	return SendReceive(CMyServer::ETest, TIpcArgs());
+	}
+
+TInt RDisplay::Stop()
+//
+// Stop the server.
+//
+	{
+
+	return SendReceive(CMyServer::EStop, TIpcArgs());
+	}
+
+TVersion RDisplay::Version()
+//
+// Return the current version.
+//
+	{
+
+	TVersion v(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);
+	return v;
+	}
+
+TInt RDisplay::Echo(TInt aWhat, TInt a0, TInt a1, TInt a2, TInt a3)
+	{
+	return SendReceive(0x40000000|aWhat, TIpcArgs(a0,a1,a2,a3));
+	}
+
+TInt RDisplay::Hold(TInt aOrder, TInt aArg)
+	{
+
+	return Send(CMyServer::EHold, TIpcArgs(aOrder, aArg));
+	}
+
+void RDisplay::Hold(TRequestStatus& aStatus, TInt aOrder, TInt aArg)
+	{
+
+	SendReceive(CMyServer::EHold, TIpcArgs(aOrder, aArg), aStatus);
+	}
+
+TInt RDisplay::Release(TInt aCount)
+	{
+
+	return SendReceive(CMyServer::ERelease, TIpcArgs(aCount));
+	}
+
+TInt RDisplay::CompleteIndex()
+	{
+	return SendReceive(CMyServer::EGetCompleteIndex, TIpcArgs());
+	}
+
+TInt serverThreadEntryPoint(TAny*)
+//
+// The entry point for the producer thread.
+//
+	{
+
+	testSvr.Title();
+	testSvr.Start(_L("Create CActiveScheduler"));
+	CMyActiveScheduler* pR=new CMyActiveScheduler;
+	testSvr(pR!=NULL);
+	CActiveScheduler::Install(pR);
+//
+	testSvr.Next(_L("Create CMyServer"));
+	CMyServer* pS=CMyServer::New(0);
+	testSvr(pS!=NULL);
+//
+	testSvr.Next(_L("Start CMyServer"));
+	TInt r=pS->Start(KServerName);
+	testSvr(r==KErrNone);
+//
+	testSvr.Next(_L("Signal to client that we have started"));
+	client.Signal();
+//
+	testSvr.Next(_L("Start CActiveScheduler"));
+	CActiveScheduler::Start();
+//
+	testSvr.Next(_L("Exit server"));
+	delete pS;
+	testSvr.Close();
+	return(KErrNone);
+	}
+
+TInt speedyThreadEntryPoint(TAny* aDisplay)
+//
+// The entry point for the speed test thread.
+//
+	{
+
+	RDisplay& t=*(RDisplay*)aDisplay;
+	TInt r=t.Test();
+	testSpeedy(r==KErrNone);
+	speedCount=0;
+	client.Signal();
+	while ((r=t.Test())==KErrNone)
+		speedCount++;
+	testSpeedy(r==KErrServerTerminated);
+	return(KErrNone);
+	}
+
+TInt RunPanicThread(RThread& aThread)
+	{
+	TRequestStatus s;
+	aThread.Logon(s);
+	TBool jit = User::JustInTime();
+	User::SetJustInTime(EFalse);
+	aThread.Resume();
+	User::WaitForRequest(s);
+	User::SetJustInTime(jit);
+	return s.Int();
+	}
+
+TInt RogueThread1(TAny*)
+	{
+	// try to kill the kernel
+	RMutex mutex;
+	TPtrC* p=(TPtrC*)0x30000000;
+	mutex.CreateGlobal(*p,EOwnerProcess);	// this should panic the thread
+	return KErrNone;
+	}
+
+class RMessageT : public RMessage2
+	{
+public:
+	RMessageT(TLinAddr anAddr) { iFunction=0; iHandle=(TInt)anAddr; }
+	};
+
+TInt RogueThread2(TAny*)
+	{
+	// try to kill the kernel
+	RMessageT m(0x30000000);
+	m.Complete(KErrNone);					// this should panic the thread
+	return KErrNone;
+	}
+
+TInt RogueThread3(TAny*)
+	{
+	// try to kill the kernel
+	RMessageT m(0x80000000);
+	m.Complete(KErrNone);					// this should panic the thread
+	return KErrNone;
+	}
+
+TInt RogueThread4(TAny*)
+	{
+	// try to kill the kernel
+	RMessageT m(0x800fff00);				// this should be off the end of the kernel heap
+	m.Complete(KErrNone);					// this should panic the thread
+	return KErrNone;
+	}
+
+void DisplayThreadExitInfo(const RThread& aThread)
+	{
+	TFullName fn=aThread.FullName();
+	TExitType exitType=aThread.ExitType();
+	TInt exitReason=aThread.ExitReason();
+	TBuf<32> exitCat=aThread.ExitCategory();
+	test.Printf(_L("Thread %S exited %d,%d,%S\n"),&fn,exitType,exitReason,&exitCat);
+	}
+
+void RogueThreadTest()
+	{
+	RThread thread;
+	TInt r;
+	if (HaveVirtMem())
+		{
+		test.Next(_L("Rogue thread test 1"));
+		r=thread.Create(_L("Rogue1"),RogueThread1,KDefaultStackSize,KHeapSize,KHeapSize,NULL);
+		test_KErrNone(r);
+		RunPanicThread(thread);	// wait for rogue thread to die
+		DisplayThreadExitInfo(thread);
+		test(thread.ExitType()==EExitPanic);
+		test(thread.ExitReason()==ECausedException);
+		thread.Close();
+		}
+
+	test.Next(_L("Rogue thread test 2"));
+	r=thread.Create(_L("Rogue2"),RogueThread2,KDefaultStackSize,KHeapSize,KHeapSize,NULL);
+	test_KErrNone(r);
+	RunPanicThread(thread);	// wait for rogue thread to die
+	DisplayThreadExitInfo(thread);
+	test(thread.ExitType()==EExitPanic);
+	test(thread.ExitReason()==EBadMessageHandle);
+	thread.Close();
+
+	test.Next(_L("Rogue thread test 3"));
+	r=thread.Create(_L("Rogue3"),RogueThread3,KDefaultStackSize,KHeapSize,KHeapSize,NULL);
+	test_KErrNone(r);
+	RunPanicThread(thread);	// wait for rogue thread to die
+	DisplayThreadExitInfo(thread);
+	test(thread.ExitType()==EExitPanic);
+	test(thread.ExitReason()==EBadMessageHandle);
+	thread.Close();
+
+	test.Next(_L("Rogue thread test 4"));
+	r=thread.Create(_L("Rogue4"),RogueThread4,KDefaultStackSize,KHeapSize,KHeapSize,NULL);
+	test_KErrNone(r);
+	RunPanicThread(thread);	// wait for rogue thread to die
+	DisplayThreadExitInfo(thread);
+	test(thread.ExitType()==EExitPanic);
+	test(thread.ExitReason()==EBadMessageHandle);
+	thread.Close();
+	}
+
+TInt SecondClient(TAny* aSession)
+	{
+	RDisplay d;
+	d.SetHandle(TInt(aSession));
+	TInt r=d.Display(_L("Second client"));
+	if (r!=KErrNone)
+		return r;
+	r = d.Echo(0,19,31,83,487);
+	if (r!=19)
+		return -999990;
+	r = d.Echo(1,19,31,83,487);
+	if (r!=31)
+		return -999991;
+	r = d.Echo(2,19,31,83,487);
+	if (r!=83)
+		return -999992;
+	r = d.Echo(3,19,31,83,487);
+	if (r!=487)
+		return -999993;
+	r = d.Echo(4,19,31,83,487);
+	if (r!=620)
+		return -999994;
+	r = d.Echo(5,19,31,83,487);
+	if (r!=245380)
+		return -999995;
+	r=d.Read();
+	if (r!=KErrNone)
+		return r;
+	r=d.Write();
+	if (r!=KErrNone)
+		return r;
+	d.Release();
+	return KErrNone;
+	}
+
+TInt ThirdClient(TAny* aSession)
+	{
+	RDisplay d;
+	d.SetHandle(TInt(aSession));
+	TInt r=d.Display(_L("Third client"));
+	if (r!=KErrNone)
+		return r;
+	r=d.Hold();
+	if (r!=KErrNone)
+		return r;
+	r=d.Read();
+	if (r!=KErrNone)
+		return r;
+	r=d.Write();
+	if (r!=KErrNone)
+		return r;
+	return KErrNone;
+	}
+
+void TestSecondClient(RSessionBase& aSession)
+	{
+	RThread t;
+	TInt r=t.Create(_L("SecondClient"),SecondClient,0x1000,NULL,(TAny*)aSession.Handle());
+	test_KErrNone(r);
+	TRequestStatus s;
+	t.Logon(s);
+	t.Resume();
+	User::WaitForRequest(s);
+	test_KErrNone(s.Int());
+	t.Close();
+	}
+
+void TestThirdClient(RSessionBase& aSession)
+	{
+	RThread t;
+	TInt r=t.Create(_L("ThirdClient"),ThirdClient,0x1000,NULL,(TAny*)aSession.Handle());
+	test_KErrNone(r);
+	TRequestStatus s;
+	t.Logon(s);
+	t.Resume();
+	User::WaitForRequest(s);
+	test_KErrNone(s.Int());
+	t.Close();
+	}
+
+TInt FourthClient(TAny* aSession)
+	{
+	RDisplay d;
+	d.SetHandle(TInt(aSession));
+	TInt r=d.Display(_L("Fourth client"));
+	if (r!=KErrNone)
+		return r;
+	d.Close();
+	return KErrNone;
+	}
+
+void TestSessionClose()
+	{
+	RDisplay d;
+	TInt r=d.Open();
+	test_KErrNone(r);
+	TRequestStatus msgStat;
+	d.Hold(msgStat);
+	test(msgStat==KRequestPending);
+	RThread t;
+	r=t.Create(_L("FourthClient"),FourthClient,0x1000,NULL,(TAny*)d.Handle());
+	test_KErrNone(r);
+	TRequestStatus s;
+	t.Logon(s);
+	t.Resume();
+	User::WaitForRequest(s);
+	test_KErrNone(s.Int());
+	t.Close();
+	User::After(1000000);
+	test(msgStat==KRequestPending);
+	}
+
+TInt FifthClient(TAny* aDisplay)
+	{
+	RDisplay& d=*(RDisplay*)aDisplay;
+	TInt r=d.Open();
+	if (r!=KErrNone)
+		return r;
+	r=d.Display(_L("Fifth client"));
+	if (r!=KErrNone)
+		return r;
+	return KErrNone;
+	}
+
+void TestZeroShares()
+	{
+	RDisplay d;
+	d.SetHandle(0);
+	RThread t;
+	TInt r=t.Create(_L("FifthClient"),FifthClient,0x1000,NULL,&d);
+	test_KErrNone(r);
+	TRequestStatus s;
+	t.Logon(s);
+	t.Resume();
+	User::WaitForRequest(s);
+	test_KErrNone(s.Int());
+	test(d.Handle()!=0);
+	t.Close();
+	r=d.Display(_L("Access after last share closed"));
+	test_KErrNone(r);
+	d.Close();
+	}
+
+TInt AttachClient1(TAny* aSession)
+	{
+	RDisplay d;
+	d.SetHandle(TInt(aSession));
+	__KHEAP_MARK;
+	TInt r=d.Display(_L("Attach client 1"));
+	__KHEAP_MARKEND;	// shouldn't need to allocate memory
+	return r;
+	}
+
+TInt AttachClient2(TAny* aSession)
+	{
+	RDisplay d;
+	d.SetHandle(TInt(aSession));
+	TInt r=d.Display(_L("Attach client 2"));
+	if (r!=KErrNone)
+		return r;
+	__KHEAP_MARK;
+	r=d.Display(_L("Attach client 2"));
+	__KHEAP_MARKEND;	// check no memory was allocated by message send
+	return r;
+	}
+
+void TestAttach(RSessionBase& aSession)
+	{
+	test.Next(_L("Test Attach"));
+	RThread t;
+	TInt r=t.Create(_L("AttachClient1"),AttachClient1,0x1000,NULL,(TAny*)aSession.Handle());
+	test_KErrNone(r);
+	r=RunPanicThread(t);	// wait for thread to die
+	test_KErrNone(r);
+	test(t.ExitType()==EExitKill);
+	test_KErrNone(t.ExitReason());
+	t.Close();
+
+	r=t.Create(_L("AttachClient2"),AttachClient2,0x1000,NULL,(TAny*)aSession.Handle());
+	test_KErrNone(r);
+	TRequestStatus s;
+	t.Logon(s);
+	t.Resume();
+	User::WaitForRequest(s);
+	test_KErrNone(s.Int());
+	test(t.ExitType()==EExitKill);
+	test_KErrNone(t.ExitReason());
+	t.Close();
+	}
+
+TInt SixthClient(TAny* aDisplay)
+	{
+	RDisplay& d=*(RDisplay*)aDisplay;
+	TInt r=d.Display(_L("Sixth client"));
+	if (r!=KErrNone)
+		return r;
+	TRequestStatus s;
+	User::WaitForRequest(s);
+	return KErrNone;
+	}
+
+TInt SeventhClient(TAny* aDisplay)
+	{
+	RDisplay& d=*(RDisplay*)aDisplay;
+	TInt r=d.Display(_L("Seventh client"));
+	if (r!=KErrNone)
+		return r;
+	TRequestStatus s;
+	User::WaitForRequest(s);
+	return KErrNone;
+	}
+
+TInt EighthClient(TAny* aDisplay)
+	{
+	RDisplay& d=*(RDisplay*)aDisplay;
+	TInt r=d.Display(_L("Eighth client"));
+	if (r!=KErrNone)
+		return r;
+	TRequestStatus s;
+	User::WaitForRequest(s);
+	return KErrNone;
+	}
+
+TInt NinthClient(TAny* aDisplay)
+	{
+	RDisplay& d=*(RDisplay*)aDisplay;
+	TInt r=d.Display(_L("Ninth client"));
+	if (r!=KErrNone)
+		return r;
+	TRequestStatus s;
+	User::WaitForRequest(s);
+	return KErrNone;
+	}
+
+void TestAsync(RDisplay& aD)
+	{
+	TInt ci = aD.CompleteIndex();
+	TRequestStatus s[128];
+	TInt i;
+	TInt r;
+	for (i=0; i<128; ++i)
+		{
+		TInt ord = i ^ 0x55;
+		TInt arg = i + 1;
+		aD.Hold(s[i], ord, arg);
+		if (s[i]==KErrServerBusy)
+			{
+			User::WaitForRequest(s[i]);
+			break;
+			}
+		test(s[i]==KRequestPending);
+		}
+	r = aD.Release();
+	test_KErrNone(r);
+	TInt j;
+	for (j=0; j<128; ++j)
+		{
+		if ( (j^0x55) >= i )
+			continue;
+		TInt code = s[j^0x55].Int();
+		TInt expected = ci ^ ((j^0x55)+1);
+		if (code != expected)
+			{
+			test.Printf(_L("j=%02x i=%02x expected=%08x got=%08x\n"),j,j^0x55,expected,code);
+			test(0);
+			}
+		User::WaitForRequest(s[j^0x55]);
+		++ci;
+		}
+	}
+
+void TestSession(RDisplay& aSess)
+	{
+//
+	TInt r;
+	test.Next(_L("Test all args passed"));
+	test(aSess.Echo(0,3,5,7,11)==3);
+	test(aSess.Echo(1,3,5,7,11)==5);
+	test(aSess.Echo(2,3,5,7,11)==7);
+	test(aSess.Echo(3,3,5,7,11)==11);
+	test(aSess.Echo(4,3,5,7,11)==26);
+	test(aSess.Echo(5,3,5,7,11)==204);
+//
+	test.Next(_L("Send to server"));
+	r=aSess.Display(_L("First message"));
+	test_KErrNone(r);
+//
+	test.Next(_L("Read"));
+	r=aSess.Read();
+	test_KErrNone(r);
+//
+	test.Next(_L("Write"));
+	r=aSess.Write();
+	test_KErrNone(r);
+//
+	TestThirdClient(aSess);
+	User::After(1000000);
+	TestSecondClient(aSess);
+	User::After(1000000);
+	TestSessionClose();
+	User::After(1000000);
+	TestZeroShares();
+	User::After(1000000);
+	TestAttach(aSess);
+	User::After(1000000);
+	}
+
+void TestUnsharableSession(RDisplay& aSess)
+	{
+//
+	TInt r;
+	test.Next(_L("Test all args passed"));
+	test(aSess.Echo(0,3,5,7,11)==3);
+	test(aSess.Echo(1,3,5,7,11)==5);
+	test(aSess.Echo(2,3,5,7,11)==7);
+	test(aSess.Echo(3,3,5,7,11)==11);
+	test(aSess.Echo(4,3,5,7,11)==26);
+	test(aSess.Echo(5,3,5,7,11)==204);
+//
+	test.Next(_L("Send to server"));
+	r=aSess.Display(_L("First message"));
+	test_KErrNone(r);
+//
+	test.Next(_L("Read"));
+	r=aSess.Read();
+	test_KErrNone(r);
+//
+	test.Next(_L("Write"));
+	r=aSess.Write();
+	test_KErrNone(r);
+//
+	TInt h = aSess.Handle();
+	test.Printf(_L("HANDLE %08x\n"), h);
+	test((h & KHandleFlagLocal)!=0);
+	}
+
+void TestSessionCreateLLeaving()
+	{
+	SessionCreateLResult=KErrGeneral;
+
+	TInt c=SessionCostructCount;
+	TInt d=SessionDestructCount;
+
+	RDisplay t;
+	TInt r = t.Open();
+	test(r==SessionCreateLResult);
+
+	test(SessionCostructCount==c+1);
+	test(SessionDestructCount==d+1);
+
+	SessionCreateLResult=KErrNone;
+	}
+
+GLDEF_C TInt E32Main()
+//
+// Test timers.
+//
+    {
+
+	test.Title();
+	test.Start(_L("Creating client semaphore"));
+	TInt r=client.CreateLocal(0);
+	test_KErrNone(r);
+//
+	test.Next(_L("Creating server thread"));
+	RThread server;
+	r=server.Create(_L("Server"),serverThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,NULL);
+	test_KErrNone(r);
+	server.SetPriority(EPriorityMore);
+//
+	test.Next(_L("Resume server thread"));
+	server.Resume();
+	test(ETrue);
+//
+	test.Next(_L("Wait for server to start"));
+	client.Wait();
+//
+	test.Next(_L("Connect to server"));
+	RDisplay t;
+	r = t.OpenNoAsync();
+	test_KErrNone(r);
+	test.Next(_L("Send to server"));
+	r=t.Display(_L("AsyncMsg"));
+	test_KErrNone(r);
+	TRequestStatus s0;
+	t.Hold(s0);
+	test(s0==KErrServerBusy);
+	t.Close();
+//
+	test.Next(_L("Test Session::CreateL leaving"));
+	TestSessionCreateLLeaving();
+//
+	test.Next(_L("Async fixed pool"));
+	r = t.Open();
+	test_KErrNone(r);
+	TestAsync(t);
+	TestAsync(t);
+	t.Close();
+	test.Next(_L("Async global pool"));
+	r = t.OpenDynamic();
+	test_KErrNone(r);
+	TestAsync(t);
+	TestAsync(t);
+	t.Close();
+//
+	r=t.Open();
+	test_KErrNone(r);
+//
+	TestSession(t);
+//
+	RDisplay tt;
+	r = tt.OpenS();
+	test.Printf(_L("OpenS -> %d\n"),r);
+	test_KErrNone(r);
+	TestSession(tt);
+	tt.Close();
+//
+	r = tt.OpenGS();
+	test.Printf(_L("OpenGS -> %d\n"),r);
+	test(r==KErrPermissionDenied);
+	tt.Close();
+//
+	r = tt.OpenUS();
+	test.Printf(_L("OpenUS -> %d\n"),r);
+	test_KErrNone(r);
+	TestUnsharableSession(tt);
+	tt.Close();
+//
+	test.Next(_L("Starting speedy client"));
+	RThread speedy;
+	TRequestStatus speedyStat;
+	r=speedy.Create(_L("Speedy"),speedyThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,&t);
+	test_KErrNone(r);
+	speedy.Logon(speedyStat);
+	RThread t1;
+	RThread t2;
+	RThread t3;
+	RThread t4;
+	TRequestStatus s1;
+	TRequestStatus s2;
+	TRequestStatus s3;
+	TRequestStatus s4;
+	r=t1.Create(_L("SixthClient"),SixthClient,0x1000,NULL,&t);
+	test_KErrNone(r);
+	t1.Logon(s1);
+	r=t2.Create(_L("SeventhClient"),SeventhClient,0x1000,NULL,&t);
+	test_KErrNone(r);
+	t2.Logon(s2);
+	r=t3.Create(_L("EighthClient"),EighthClient,0x1000,NULL,&t);
+	test_KErrNone(r);
+	t3.Logon(s3);
+	r=t4.Create(_L("NinthClient"),NinthClient,0x1000,NULL,&t);
+	test_KErrNone(r);
+	t4.Logon(s4);
+	t1.Resume();
+	t2.Resume();
+	t3.Resume();
+	t4.Resume();
+	User::After(1000000);
+//
+	test.Next(_L("Wait for speedy to start"));
+    speedy.SetPriority(EPriorityNormal);
+	RThread().SetPriority(EPriorityMuchMore);
+	speedy.Resume();
+	client.Wait();
+//
+	test.Printf(_L("Starting speed test...\n"));
+    User::After(300000);
+    TInt b=speedCount;
+    User::After(3000000);
+    TInt n=speedCount;
+    test.Printf(_L("Count = %d in 1 second\n"),(n-b)/3);
+//
+	test.Next(_L("Stop server"));
+	r=t.Stop();
+	test_KErrNone(r);
+	User::After(0); // Allow the speed client to die
+//
+	test.Next(_L("Close extra threads"));
+	t1.Kill(0);
+	User::WaitForRequest(s1);
+	test(t1.ExitType()==EExitKill && s1==KErrNone);
+	t2.Kill(0);
+	User::WaitForRequest(s2);
+	test(t2.ExitType()==EExitKill && s2==KErrNone);
+	t3.Kill(0);
+	User::WaitForRequest(s3);
+	test(t3.ExitType()==EExitKill && s3==KErrNone);
+	t4.Kill(0);
+	User::WaitForRequest(s4);
+	test(t4.ExitType()==EExitKill && s4==KErrNone);
+	User::WaitForRequest(speedyStat);
+	test(speedy.ExitType()==EExitKill && speedyStat==KErrNone);
+//
+	test.Next(_L("Close all"));
+	t1.Close();
+	t2.Close();
+	t3.Close();
+	t4.Close();
+	speedy.Close();
+	server.Close();
+	client.Close();
+//
+	test.Next(_L("Close connection"));
+	t.Close();
+//
+	RogueThreadTest();
+//
+	test.End();
+	return(0);
+    }
+