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