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