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

// Overview:

// Tests and benchmarks the Client/Server architecture of the Symbian platform.

// The client and server run in different threads in the same process. 

// API Information:

// CSession2, CServer2, RSessionBase.

// Details:

// - Create and start a server thread. Verify results are as expected.

// - Open a connection with the server, verify arguments are passed to the server

// and back correctly.

// - Server can read and write messages to/from the client and return verify that 

// the results are as expected.

// - Send dummy messages that the server completes immediately and display how many 

// are completed per second.

// - Stop the server and verify the results are as expected.

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

// 

//

#define __E32TEST_EXTENSION__

#include <e32base.h>

#include <e32base_private.h>

#include <e32test.h>

#include <e32svr.h>

#include <hal.h>

#include <e32math.h>

#include "../mmu/mmudetect.h"

const TInt KHeapSize=0x2000;

const TInt KMajorVersionNumber=1;

const TInt KMinorVersionNumber=0;

const TInt KBuildVersionNumber=1;

_LIT(KServerName,"Display");

_LIT(KReadDesContents, "Testing read");

_LIT(KLengthDesContents, "What-ever");

_LIT(KWriteDesContents, "It worked!");

_LIT(KLocalWriteDesContents, "Local write");

enum TSpeedTest

	{

	ESpeedNull,

	ESpeedUnusedDes,

	ESpeedGetDesLength,

	ESpeedGetMaxDesLength,

	ESpeedReadDes,

	ESpeedWriteDes,

	};

_LIT(KTestNameNull,            "Null");

_LIT(KTestNameUnusedDes,       "UnusedDes");

_LIT(KTestNameGetDesLength,    "GetDesLength");

_LIT(KTestNameGetMaxDesLength, "GetMaxDesLength");

_LIT(KTestNameReadDes,         "ReadDes");

_LIT(KTestNameWriteDes,        "WriteDes");

_LIT(KLitLocal, 			   "Local");

_LIT(KLitRemote, 			   "Remote");

const TDesC* KSpeedTestNames[] =

	{

	&KTestNameNull,

	&KTestNameUnusedDes,

	&KTestNameGetDesLength,

	&KTestNameGetMaxDesLength,

	&KTestNameReadDes,

	&KTestNameWriteDes,

	};

class CMySession : public CSession2

	{

public:

	CMySession();

	~CMySession();

	void DisplayName(const RMessage2& aM);

	virtual void ServiceL(const RMessage2& aMessage);		 	 //pure virtual fns.

private:

	RArray<RMessagePtr2> iAsyncRequests;

	};

class CMyServer : public CServer2

	{

public:

	enum {EDisplay,ERead,EGetDesLength,EGetDesMaxLength,EWrite,ELocalWrite,EDupDes,ENull,ESimpleRead,ESimpleWrite,EStartAsync,ECompleteAsync,EStop};

public:

	CMyServer(TInt aPriority);

	static CMyServer* New(TInt aPriority);

	virtual CSession2* NewSessionL(const TVersion& aVersion, const RMessage2& aMessage) const;//Overloading

	};

class CMyActiveScheduler : public CActiveScheduler

	{

public:

	virtual void Error(TInt anError) const;	 //Overloading pure virtual function

	};

class RDisplay : public RSessionBase

	{

public:

	TInt Open(TInt aMessageSlots=0);

	TInt Display(const TDesC& aMessage);

	TInt Read(TInt aArgIndex);

	TInt Write(TInt aArgIndex);

	TInt LocalWrite(TInt aArgIndex);

	TInt TestDesLength(TInt aArgIndex);

	TInt Stop();

	TInt SpeedTest(TSpeedTest);

	TInt Echo(TInt aWhat, TInt a0, TInt a1, TInt a2, TInt a3);

	void StartAsync(TRequestStatus& aStatus);

	void CompleteAsync(TInt aIndex);

	TInt SendBlind();

	TVersion Version();

private:

	TInt SendMessage(TInt aMessage, TInt aArgIndex, TDesC* aDesArg, TInt8 aOffset = 0);

	TInt SendMessage(TInt aMessage, TInt aArgIndex, TDes* aDesArg, TInt8 aOffset = 0);

	TInt SendMessageDup(TInt aMessage, TInt aArgIndex, TInt aArgIndex2, TDes* aDesArgs);

	};

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 TRequestStatus speedTestStatus;

LOCAL_D RThread serverThread;

LOCAL_D RProcess serverProcess;

//

// Constructor

// 

CMySession::CMySession()

	{}

//

// Destructor

// 

CMySession::~CMySession()

	{

	// Call User::Exit so server shuts down when client disconnects

	User::Exit(KErrNone);

	}

void CMySession::DisplayName(const RMessage2& aM)

//

// Display the client's name.

//

	{

	RThread t;

	TInt r = aM.Client(t);

	testSvr(r==KErrNone);

	TFullName fn(t.FullName());

	t.Close();

	TBuf<256> text;

	r=aM.Read(0,text);

	testSvr(r==KErrNone);

	testSvr.Printf(_L("Session %S\n%S\n"), &fn, &text);

	}

CMyServer* CMyServer::New(TInt aPriority)

//

// Create a new CMyServer.

//

	{

	return new CMyServer(aPriority);

	}

CMyServer::CMyServer(TInt aPriority)

//

// Constructor.

//

	: CServer2(aPriority)

	{}

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<0x10> b;

	TDes* des = NULL;

	TInt message = f & 0xff;

	TInt arg = (f >> 8) & 0xff;

	TInt8 offset = (TInt8)((f >> 16) & 0xff);

	switch (message)

		{

	case CMyServer::EDisplay:

		DisplayName(aMessage);

		break;

	case CMyServer::ERead:

		r=aMessage.Read(arg,b,offset);

		if (r==KErrNone && b!=KReadDesContents)

			r=KErrGeneral;

		break;

	case CMyServer::EGetDesLength:

		r=aMessage.GetDesLength(arg);

		break;

	case CMyServer::EGetDesMaxLength:

		r=aMessage.GetDesMaxLength(arg);

		break;

	case CMyServer::EWrite:

		r=aMessage.Write(arg,KWriteDesContents,offset);

		// Test descriptor length updated

		if (r == KErrNone && aMessage.GetDesLength(arg) != 10)

			r = KErrGeneral;

		// Test reading descriptor back again

		if (r == KErrNone)

			r = aMessage.Read(arg,b,offset);

		if (r==KErrNone && b!=KWriteDesContents)

			r = KErrGeneral;

		break;

	case CMyServer::ELocalWrite:

		switch(arg)

			{

			case 0:

				des = (TDes*)aMessage.Int0();

				break;

			case 1:

				des = (TDes*)aMessage.Int1();

				break;

			case 2:

				des = (TDes*)aMessage.Int2();

				break;

			case 3:

				des = (TDes*)aMessage.Int3();

				break;

			default:

				r = KErrGeneral;

			}

		if (r==KErrNone)

			{

			*des = KLocalWriteDesContents;

			r = aMessage.GetDesLength(arg) == 11 ? KErrNone : KErrGeneral;

			}

		if (r==KErrNone)

			r=aMessage.Read(arg,b,0);

		if (r==KErrNone && b!=KLocalWriteDesContents)

			r=KErrGeneral;

		break;

	case CMyServer::EDupDes:

		r=aMessage.Write(arg,KWriteDesContents);

		if (r == KErrNone && aMessage.GetDesLength(offset/* used to pass 2nd arg here*/) != 10)

			r = KErrGeneral;

		if (r == KErrNone)

			r = aMessage.Read(offset,b);

		if (r==KErrNone && b!=KWriteDesContents)

			r = KErrGeneral;

		break;

	case CMyServer::ENull:

		break;

	case CMyServer::ESimpleRead:

		r=aMessage.Read(arg,b);

		break;

	case CMyServer::ESimpleWrite:

		r=aMessage.Write(arg,KWriteDesContents);

		break;

	case CMyServer::EStartAsync:

		r=iAsyncRequests.Append(aMessage);

		if (r == KErrNone)

			return;  // don't complete message

		break;

	case CMyServer::ECompleteAsync:

		{

		TInt index = aMessage.Int0();

		if (iAsyncRequests.Count() <= index)

			r = KErrNotFound;

		else

			{

			RMessagePtr2 asyncMessage = iAsyncRequests[index];

			iAsyncRequests.Remove(index);

			asyncMessage.Complete(KErrNone);

			r=KErrNone;

			}

		}

		break;

	case CMyServer::EStop:

		CActiveScheduler::Stop();

		break;

	default:

		r=KErrNotSupported;

		}

	aMessage.Complete(r);

	}

void CMyActiveScheduler::Error(TInt anError) const

//

// Called if any Run() method leaves.

//

	{

	testSvr.Panic(anError,_L("CMyActiveScheduler::Error"));

	}

TInt RDisplay::Open(TInt aMessageSlots)

//

// Open the server.

//

	{

	return(CreateSession(KServerName,Version(),aMessageSlots));

	}

TInt RDisplay::Display(const TDesC& aMessage)

//

// Display a message.

//

	{

	TBuf<0x10> b(aMessage);

	return(SendReceive(CMyServer::EDisplay,TIpcArgs(&b)));

	}

TInt RDisplay::SendMessage(TInt aMessage, TInt aArgIndex, TDesC* aDesArg, TInt8 aOffset)

	{

	TInt f = aMessage | (aArgIndex << 8) | ((aOffset << 16) & 0x00ff0000);

	TIpcArgs args;

	args.Set(aArgIndex, aDesArg);

	return SendReceive(f, args);

	}

TInt RDisplay::SendMessage(TInt aMessage, TInt aArgIndex, TDes* aDesArg, TInt8 aOffset)

	{

	TInt f = aMessage | (aArgIndex << 8) | ((aOffset << 16) & 0x00ff0000);

	TIpcArgs args;

	args.Set(aArgIndex, aDesArg);

	return SendReceive(f, args);

	}

TInt RDisplay::SendMessageDup(TInt aMessage, TInt aArgIndex1, TInt aArgIndex2, TDes* aDesArg)

	{

	TInt f = aMessage | (aArgIndex1 << 8) | (aArgIndex2 << 16);

	TIpcArgs args;

	args.Set(aArgIndex1, aDesArg);

	args.Set(aArgIndex2, aDesArg);

	return SendReceive(f, args);

	}

TInt RDisplay::Read(TInt aArgIndex)

//

// Test RMessage2::Read

//

	{

	HBufC* buf = HBufC::New(0x10);

	test_NotNull(buf);

	*buf = KReadDesContents;

	TBufC<0x10> des1(KReadDesContents);

	TBuf<0x10> des2(KReadDesContents);

	TPtrC des3(des1);

	TPtr des4((TUint16*)des2.Ptr(), des2.Length(), des2.MaxLength());

	RBuf des5(buf);

	// test successful read

	test_Equal(KErrNone, SendMessage(CMyServer::ERead, aArgIndex, &des1));

	test_Equal(KErrNone, SendMessage(CMyServer::ERead, aArgIndex, &des2));

	test_Equal(KErrNone, SendMessage(CMyServer::ERead, aArgIndex, &des3));

	test_Equal(KErrNone, SendMessage(CMyServer::ERead, aArgIndex, &des4));

	test_Equal(KErrNone, SendMessage(CMyServer::ERead, aArgIndex, &des5));

	// test negative offset

	test_Equal(KErrArgument, SendMessage(CMyServer::ERead, aArgIndex, &des1, -1));

	// test bad descriptors

	if (HaveVirtMem())

		{

		test_Equal(KErrBadDescriptor, SendMessage(CMyServer::ERead, aArgIndex, (TDesC*)0x30000000));

		RChunk chunk;

		const TInt KChunkSize = 4096;

		test_KErrNone(chunk.CreateLocal(KChunkSize, KChunkSize));

		test_Equal(KChunkSize, chunk.Size());

		TDesC* ptr = (TDesC*)(chunk.Base() + KChunkSize - 8);

		Mem::Copy(ptr, &des3, 8);

		test_Equal(KErrNone, SendMessage(CMyServer::ERead, aArgIndex, ptr));

		ptr = (TDesC*)(chunk.Base() + KChunkSize - 4);

		Mem::Copy(ptr, &des3, 4);

		test_Equal(KErrBadDescriptor, SendMessage(CMyServer::ERead, aArgIndex, ptr));

		ptr = (TDesC*)(chunk.Base() + KChunkSize - 12);

		Mem::Copy(ptr, &des4, 12);

		test_Equal(KErrNone, SendMessage(CMyServer::ERead, aArgIndex, ptr));

		ptr = (TDesC*)(chunk.Base() + KChunkSize - 8);

		Mem::Copy(ptr, &des4, 8);

		test_Equal(KErrBadDescriptor, SendMessage(CMyServer::ERead, aArgIndex, ptr));

		ptr = (TDesC*)(chunk.Base() + KChunkSize - 4);

		Mem::Copy(ptr, &des4, 4);

		test_Equal(KErrBadDescriptor, SendMessage(CMyServer::ERead, aArgIndex, ptr));

		chunk.Close();

		((TUint32*)&des3)[1] = 0x00001000; // make descriptor point to invalid memory

		((TUint32*)&des4)[2] = 0x00001000; // make descriptor point to invalid memory

		test_Equal(KErrBadDescriptor, SendMessage(CMyServer::ERead, aArgIndex, &des3));

		test_Equal(KErrBadDescriptor, SendMessage(CMyServer::ERead, aArgIndex, &des4));

		}

	delete buf;

	return KErrNone;

	}

TInt RDisplay::TestDesLength(TInt aArgIndex)

//

// Test RMessage2::GetDesLength and RMessage2::GetDesMaxLength

//

	{

	HBufC* buf = HBufC::New(0x10);

	test_NotNull(buf);

	*buf = KLengthDesContents;

	TBufC<0x10> des1(KLengthDesContents);

	TBuf<0x10> des2(KLengthDesContents);

	TPtrC des3(des1);

	TPtr des4((TUint16*)des2.Ptr(), des2.Length(), des2.MaxLength());

	RBuf des5(buf);

	// test GetDesLength

	test_Equal(9, SendMessage(CMyServer::EGetDesLength, aArgIndex, &des1));

	test_Equal(9, SendMessage(CMyServer::EGetDesLength, aArgIndex, &des2));

	test_Equal(9, SendMessage(CMyServer::EGetDesLength, aArgIndex, &des3));

	test_Equal(9, SendMessage(CMyServer::EGetDesLength, aArgIndex, &des4));

	test_Equal(9, SendMessage(CMyServer::EGetDesLength, aArgIndex, &des5));

	// test GetDesMaxLength

	test_Equal(KErrBadDescriptor, SendMessage(CMyServer::EGetDesMaxLength, aArgIndex, &des1));

	test_Equal(0x10, SendMessage(CMyServer::EGetDesMaxLength, aArgIndex, &des2));

	test_Equal(KErrBadDescriptor, SendMessage(CMyServer::EGetDesMaxLength, aArgIndex, &des3));

	test_Equal(0x10, SendMessage(CMyServer::EGetDesMaxLength, aArgIndex, &des4));

	test_Equal(0x10, SendMessage(CMyServer::EGetDesMaxLength, aArgIndex, &des5));

	// test bad descriptors

	if (HaveVirtMem())

		{

		test_Equal(KErrBadDescriptor, SendMessage(CMyServer::EGetDesLength, aArgIndex, (TDesC*)0x30000000));

		RChunk chunk;

		const TInt KChunkSize = 4096;

		test_KErrNone(chunk.CreateLocal(KChunkSize, KChunkSize));

		test_Equal(KChunkSize, chunk.Size());

		TDesC* ptr = (TDesC*)(chunk.Base() + KChunkSize - 8);

		Mem::Copy(ptr, &des3, 8);

		test_Equal(9, SendMessage(CMyServer::EGetDesLength, aArgIndex, ptr));

		ptr = (TDesC*)(chunk.Base() + KChunkSize - 4);

		Mem::Copy(ptr, &des3, 4);

		test_Equal(KErrBadDescriptor, SendMessage(CMyServer::EGetDesLength, aArgIndex, ptr));

		ptr = (TDesC*)(chunk.Base() + KChunkSize - 12);

		Mem::Copy(ptr, &des4, 12);

		test_Equal(9, SendMessage(CMyServer::EGetDesLength, aArgIndex, ptr));

		test_Equal(0x10, SendMessage(CMyServer::EGetDesMaxLength, aArgIndex, ptr));

		ptr = (TDesC*)(chunk.Base() + KChunkSize - 8);

		Mem::Copy(ptr, &des4, 8);