// Copyright (c) 2001-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\secure\t_smessage.cpp

// Overview:

// Test RMessagePtr2 and server message passing

// API Information:

// RMessagePtr2, RMessage2

// Details:

// - Start a test server and open a server session. Perform various IPC tests

// and verify results are as expected.

// - Start a thread and request the server kill, terminate and panic the client

// thread. Verify results are as expected.

// - Perform various tests of setting the process priority via the 

// RMessagePtr2::SetProcessPriority() method. Verify results are as expected.

// - Verify the ability to open a handle on the client thread using the 

// RMessagePtr2::Client() method.

// - Verify message passing via an RMessage2 object. 

// - Verify the RMessagePtr2::Handle and RMessagePtr::Session methods work

// as expected.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

LOCAL_D RTest test(_L("T_SMESSAGE"));

enum TTestProcessFunctions

	{

	ETestProcessServer,

	};

#include "testprocess.h"

TInt StartServer();

TInt DoTestProcess(TInt aTestNum,TInt aArg1,TInt aArg2)

	{

	(void)aArg1;

	(void)aArg2;

	switch(aTestNum)

		{

	case ETestProcessServer:

		return StartServer();

	default:

		User::Panic(_L("T_SMESSAGE"),1);

		}

	return KErrNone;

	}

class RTestThread : public RThread

	{

public:

	void Create(TThreadFunction aFunction,TAny* aArg=0);

	};

void RTestThread::Create(TThreadFunction aFunction,TAny* aArg)

	{

	TInt r=RThread::Create(_L(""),aFunction,KDefaultStackSize,KDefaultStackSize,KDefaultStackSize,aArg);

	test(r==KErrNone);

	}

//

// CTestSession

//

class CTestSession : public CSession2

	{

public:

	enum {EShutdown,ETestIpc,ETestKill,ETestTerminate,ETestPanic,

		ETestSetProcessPriority,ETestClient,ETestRMessage,ETestHandle,ETestSession};

public:

	CTestSession();

	virtual void ServiceL(const RMessage2& aMessage);

public:

	};

CTestSession::CTestSession()

	: CSession2()

	{

	}

const TInt KTestDataMaxLength8 = 20;

const TInt KTestDataMaxLength16 = 40;

_LIT8(KTestData8,"12345678");

_LIT16(KTestData16,"1234567890123456");

_LIT(KTestPanicCategory,"TEST PANIC");

void CTestSession::ServiceL(const RMessage2& aMessage)

	{

	RMessagePtr2 m(aMessage);

	switch (aMessage.Function())

		{

		case CTestSession::ETestIpc:

			{

			TInt r,l,ml;

			// 8 bit descriptors

			TBuf8<KTestDataMaxLength8> buf8;

			buf8.FillZ();

			// GetDesLength

			l = m.GetDesLength(0);

			if(l!=KTestData8().Length()) m.Complete(l<0 ? l : KErrGeneral);

			// Read

			r = m.Read(0,buf8,1);

			if(r!=KErrNone) m.Complete(r);

			if(buf8.Compare(KTestData8().Right(l-1))) m.Complete(KErrGeneral);

			// ReadL

			buf8.Zero();

			buf8.FillZ();

			m.ReadL(0,buf8,1);

			if(buf8.Compare(KTestData8().Right(l-1))) m.Complete(KErrGeneral);

			// GetDesMaxLength

			ml = m.GetDesMaxLength(2);

			if(ml!=KTestDataMaxLength8) m.Complete(ml<0 ? ml : KErrGeneral);

			// Write

			r = m.Write(2,KTestData8(),0);

			if(r!=KErrNone) m.Complete(r);

			// WriteL

			m.WriteL(2,KTestData8(),1);

			// 16 bit descriptors

			TBuf16<KTestDataMaxLength16> buf16;

			buf16.FillZ();

			// GetDesLength

			l = m.GetDesLength(1);

			if(l!=KTestData16().Length()) m.Complete(l<0 ? l : KErrGeneral);

			// Read

			r = m.Read(1,buf16,1);

			if(r!=KErrNone) m.Complete(r);

			if(buf16.Compare(KTestData16().Right(l-1))) m.Complete(KErrGeneral);

			// ReadL

			buf16.Zero();

			buf16.FillZ();

			m.ReadL(1,buf16,1);

			if(buf16.Compare(KTestData16().Right(l-1))) m.Complete(KErrGeneral);

			// GetDesMaxLength

			ml = m.GetDesMaxLength(3);

			if(ml!=KTestDataMaxLength16) m.Complete(ml<0 ? ml : KErrGeneral);

			// Write

			r = m.Write(3,KTestData16(),0);

			if(r!=KErrNone) m.Complete(r);

			// WriteL

			m.WriteL(3,KTestData16(),1);

			// done

			aMessage.Complete(KErrNone);

			}

			break;

		case CTestSession::ETestKill:

			m.Kill(999);

			break;

		case CTestSession::ETestTerminate:

			m.Terminate(999);

			break;

		case CTestSession::ETestPanic:

			m.Panic(KTestPanicCategory,999);

			break;

		case ETestSetProcessPriority:

			m.Complete(m.SetProcessPriority((TProcessPriority)aMessage.Int0()));

			break;

		case ETestClient:

			{

			RThread client;

			m.Client(client);

			m.Complete(client.Id());

			client.Close();

			}

			break;

		case ETestRMessage:

			{

			RMessage2 message2(m);

			if (Mem::Compare((TUint8*)&message2,sizeof(message2),(TUint8*)&aMessage,sizeof(aMessage)))

				m.Complete(KErrGeneral);

			else

				m.Complete(KErrNone);

			}

			break;

		case ETestHandle:

			if (m.Handle()!=aMessage.Handle())

				m.Complete(KErrGeneral);

			else

				m.Complete(KErrNone);

			break;

		case CTestSession::ETestSession:

			if (aMessage.Session()!=this)

				m.Complete(KErrGeneral);

			else

				m.Complete(KErrNone);

			break;

		case CTestSession::EShutdown:

			CActiveScheduler::Stop();

			break;

		default:

			m.Complete(KErrNotSupported);

			break;

		}

	}

//

// CTestServer

//

class CTestServer : public CServer2

	{

public:

	CTestServer(TInt aPriority);

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

	};

CTestServer::CTestServer(TInt aPriority)

	: CServer2(aPriority)

	{

	}

CSession2* CTestServer::NewSessionL(const TVersion& /*aVersion*/,const RMessage2& /*aMessage*/) const

	{

	return new (ELeave) CTestSession();

	}

//

// CTestActiveScheduler

//

class CTestActiveScheduler : public CActiveScheduler

	{

public:

	virtual void Error(TInt anError) const;

	};

void CTestActiveScheduler::Error(TInt anError) const

	{

	User::Panic(_L("TestServer Error"),anError);

	}

//

// Server thread

//

_LIT(KServerName,"T_SMESSAGE-server");

const TInt KServerRendezvous = KRequestPending+1;

void DoStartServer()

	{

	CTestActiveScheduler* activeScheduler = new (ELeave) CTestActiveScheduler;

	CActiveScheduler::Install(activeScheduler);

	CleanupStack::PushL(activeScheduler);

	CTestServer* server = new (ELeave) CTestServer(0);

	CleanupStack::PushL(server);

	User::LeaveIfError(server->Start(KServerName));

	RProcess::Rendezvous(KServerRendezvous);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(2);

	}

TInt StartServer()

	{

	CTrapCleanup* cleanupStack = CTrapCleanup::New();

	if(!cleanupStack)

		return KErrNoMemory;

	TRAPD(leaveError,DoStartServer())

	delete cleanupStack;

	return leaveError;

	}

//

// RTestSession

//

class RTestSession : public RSessionBase

	{

public:

	inline TInt Connect()

		{ return CreateSession(KServerName,TVersion());}

	inline TInt Send(TInt aFunction)

		{ return RSessionBase::SendReceive(aFunction); }

	inline TInt Send(TInt aFunction,const TIpcArgs& aArgs)

		{ return RSessionBase::SendReceive(aFunction,aArgs); }

	inline void Send(TInt aFunction,TRequestStatus& aStatus)

		{ RSessionBase::SendReceive(aFunction,aStatus); }

	inline void Send(TInt aFunction,const TIpcArgs& aArgs,TRequestStatus& aStatus)

		{ RSessionBase::SendReceive(aFunction,aArgs,aStatus); }

	};

TInt TestThreadServerKill(TAny* aArg)

	{

	RTestSession Session;

	TInt r = Session.Connect();

	if(r!=KErrNone)

		return KErrGeneral;

	User::SetJustInTime(EFalse);

	r = Session.Send((TInt)aArg);

	Session.Close();

	return KErrGeneral;

	}

RTestSession Session;

void TestIPC()

	{

	TBuf8<KTestDataMaxLength8> buf8;

	TBuf16<KTestDataMaxLength16> buf16;

	TInt r = Session.Send(CTestSession::ETestIpc,TIpcArgs(&KTestData8,&KTestData16,&buf8,&buf16));

	test(r==KErrNone);

	TInt l = KTestData8().Length();

	test(buf8.Length()==l+1);

	test(KTestData8().Compare(buf8.Right(l))==0);

	l = KTestData16().Length();

	test(buf16.Length()==l+1);

	test(KTestData16().Compare(buf16.Right(l))==0);

	}

void TestKill()

	{

	RTestThread thread;

	TRequestStatus logonStatus;

	test.Start(_L("Test Kill"));

	thread.Create(TestThreadServerKill,(TAny*)CTestSession::ETestKill);

	thread.Logon(logonStatus);

	thread.Resume();

	User::WaitForRequest(logonStatus);

	User::SetJustInTime(ETrue);

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

	test(logonStatus==999);

	CLOSE_AND_WAIT(thread);

	test.Next(_L("Test Terminate"));

	thread.Create(TestThreadServerKill,(TAny*)CTestSession::ETestTerminate);

	thread.Logon(logonStatus);

	thread.Resume();

	User::WaitForRequest(logonStatus);

	User::SetJustInTime(ETrue);

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

	test(logonStatus==999);

	CLOSE_AND_WAIT(thread);

	test.Next(_L("Test Panic"));

	thread.Create(TestThreadServerKill,(TAny*)CTestSession::ETestPanic);

	thread.Logon(logonStatus);

	thread.Resume();

	User::WaitForRequest(logonStatus);

	User::SetJustInTime(ETrue);

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

	test(logonStatus==999);

	CLOSE_AND_WAIT(thread);

	test.End();

	}

void TestSetProcessPriority()

	{

	RProcess process;

	TProcessPriority priority(process.Priority());

	TInt r;

	test.Start(_L("Try changing priority when Priority Control disabled"));

	r = Session.Send(CTestSession::ETestSetProcessPriority,TIpcArgs(EPriorityBackground));

	test(r==KErrPermissionDenied);

	test(process.Priority()==priority);

	r = Session.Send(CTestSession::ETestSetProcessPriority,TIpcArgs(EPriorityForeground));

	test(r==KErrPermissionDenied);

	test(process.Priority()==priority);

	r = Session.Send(CTestSession::ETestSetProcessPriority,TIpcArgs(EPriorityLow));

	test(r==KErrPermissionDenied);

	test(process.Priority()==priority);

	r = Session.Send(CTestSession::ETestSetProcessPriority,TIpcArgs(EPriorityHigh));

	test(r==KErrPermissionDenied);

	test(process.Priority()==priority);

	test.Next(_L("Test changing priority when Priority Control enabled"));

	User::SetPriorityControl(ETrue);

	r = Session.Send(CTestSession::ETestSetProcessPriority,TIpcArgs(EPriorityBackground));

	test(r==KErrNone);

	test(process.Priority()==EPriorityBackground);

	r = Session.Send(CTestSession::ETestSetProcessPriority,TIpcArgs(EPriorityForeground));

	test(r==KErrNone);

	test(process.Priority()==EPriorityForeground);

	r = Session.Send(CTestSession::ETestSetProcessPriority,TIpcArgs(EPriorityLow));

	test(r==KErrPermissionDenied);

	test(process.Priority()==EPriorityForeground);

	r = Session.Send(CTestSession::ETestSetProcessPriority,TIpcArgs(EPriorityHigh));

	test(r==KErrPermissionDenied);

	test(process.Priority()==EPriorityForeground);

	User::SetPriorityControl(EFalse);

	process.SetPriority(priority);

	test.End();

	}

GLDEF_C TInt E32Main()

    {

	TBuf16<512> cmd;

	User::CommandLine(cmd);

	if(cmd.Length() && TChar(cmd[0]).IsDigit())

		{

		TInt function = -1;

		TInt arg1 = -1;

		TInt arg2 = -1;

		TLex lex(cmd);

		lex.Val(function);

		lex.SkipSpace();

		lex.Val(arg1);

		lex.SkipSpace();

		lex.Val(arg2);

		return DoTestProcess(function,arg1,arg2);

		}

	test.Title();

	test.Start(_L("Starting test server"));

	RTestProcess server;

	TRequestStatus rendezvous;

	TRequestStatus svrstat;

	server.Create(ETestProcessServer);

	server.NotifyDestruction(svrstat);

	server.Rendezvous(rendezvous);

	server.Resume();

	User::WaitForRequest(rendezvous);

	test(rendezvous==KServerRendezvous);

	server.Close();

	test.Next(_L("Openning server session"));

	TInt r = Session.Connect();

	test(r==KErrNone);

	test.Next(_L("Test IPC data transfer"));

	TestIPC();

	test.Next(_L("Test RMessagePtr2::Kill, Panic and Teminate"));

	TestKill();

	test.Next(_L("Test RMessagePtr2::SetProcessPriority"));

	TestSetProcessPriority();

	test.Next(_L("Test RMessagePtr2::Client"));

	test(Session.Send(CTestSession::ETestClient)==(TInt)RThread().Id());

	test.Next(_L("Test RMessagePtr2::RMessage2"));

	test(Session.Send(CTestSession::ETestRMessage,TIpcArgs(111111,222222,333333,444444))==KErrNone);

	test.Next(_L("Test RMessagePtr2::Handle"));

	test(Session.Send(CTestSession::ETestHandle,TIpcArgs())==KErrNone);

	test.Next(_L("Test RMessagePtr2::Session"));

	test(Session.Send(CTestSession::ETestSession,TIpcArgs())==KErrNone);

	test.Next(_L("Stopping test server"));

	Session.Send(CTestSession::EShutdown);

	Session.Close();

	User::WaitForRequest(svrstat);

	test(svrstat == KErrNone);

	test.End();

	return(0);

    }