// 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\active\t_messge.cpp

 // Overview:

 // Test the RMessage2 and RMessagePtr2 classes. 

 // API Information:

 // RMessage2, RMessagePtr2, RSessionBase, CSession2, CServer2

 // Details:

 // - Verify copy constructor and assignment operator of Rmessage2 is implemented correctly.

 // - Verify default constructor, copy constructor and assignment operator of RMessagePtr2 

 // is implemented correctly, construct RMessagePtr2 from pointer to RMessage2 and verify

 // that it is constructed successfully.

 // - Create client and server threads, open a session with specified number of message slots

 // - Send integer message arguments from client and test that the server receives the

 // same integers.

 // - Send pointers as message arguments from client and test that the server receives the

 // same pointers. 

 // - Test Client() method of RMessage2 and verify it opened a handle to the client thread

 // - Complete several messages using RMessage2::Complete and verify the client gets the

 // error codes back correctly.

 // - Complete several messages using RMessagePtr2::Complete and verify the client gets the

 // error codes back correctly.

 // - Check RMessage construction from RMessagePtr2 is successful.

 // - Check creation of other sessions to the same server is successful.

 // - Check the server return KErrServerBusy when client has more outstanding requests than

 // available message slots.

 // - Send stop signal and check that the server has stopped as expected.

 // - Check the client and server have exited as expected.

 // - Create client and server threads, open a connection to the server and verify that

 // - Server is panicked when completing a message twice.

 // Platforms/Drives/Compatibility:

 // All.

 // Assumptions/Requirement/Pre-requisites:

 // Failures and causes:

 // Base Port information:

 // 

 //

 #include <e32std.h>

 #include <e32std_private.h>

 #include <e32test.h>

 #include <e32ver.h>

 #include <e32panic.h>

 const TInt KHeapMinSize=0x1000;

 const TInt KHeapMaxSize=0x1000;

 _LIT(KServerName,"CTestServer");

 class CTestServer : public CServer2

 	{

 public:

 	IMPORT_C CTestServer(TInt aPriority);

 	enum TPanicType{

 		EInt0Error=1, EInt1Error, EInt2Error, EInt3Error,

 		EPtr0Error, EPtr1Error, EPtr2Error, EPtr3Error,

 		ECreateNameError, ENewSessionError,

 		EClientError

 		};

 	static void Panic(TPanicType aReason);

 protected:

 	//override the pure virtual functions:

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

 	};

 class CTestSession : public CSession2

 	{

 public:

 	enum {EStop,ETestInt,ETestPtr,ETestClient,ETestComplete,ETestPtrComplete,ETestCompletePanic,ETestOtherSession,ETestCompleteAfter,ETestMessageConstruction, ETestRMessagePtr2LeavingInterface};

 //Override pure virtual

 	IMPORT_C virtual void ServiceL(const RMessage2& aMessage);

 private:

 	void TestInt(const RMessage2& aMessage);

 	void TestPtr(const RMessage2& aMessage);

 	void TestClient(const RMessage2& aMessage);

 	void TestComplete(const RMessage2& aMessage);

 	void TestPtrComplete(const RMessage2& aMessage);

 	void TestCompletePanic();

 	TInt TestMessageConstruction(const RMessage2& aMessage);

 	TInt TestRMessagePtr2LeavingInterface(const RMessage2& aMessage);

 	//	

 	TInt count1;//initially ==0

 	RMessage2 messages[5];//Used in TestComplete()

 //

 	TInt count2;//initially ==0

 	RMessagePtr2 messagePtrs[5];//User in TestPtrComplete()

 	};

 class CMyActiveScheduler : public CActiveScheduler

 	{

 public:

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

 	};

 class RSession : public RSessionBase

 	{

 public:

 	TInt PublicSendReceive(TInt aFunction, const TIpcArgs &aPtr)

 		{

 		return (SendReceive(aFunction, aPtr));

 		}

 	void PublicSendReceive(TInt aFunction, const TIpcArgs &aPtr, TRequestStatus& aStatus)

 		{

 		SendReceive(aFunction, aPtr, aStatus);

 		}

 	TInt PublicCreateSession(const TDesC& aServer,TInt aMessageSlots)

 		{

 		return (CreateSession(aServer,User::Version(),aMessageSlots));

 		}

 	};

 // CTestServer functions

 CTestServer::CTestServer(TInt aPriority) 

 //

 // Constructor - sets name

 //

 	: CServer2(aPriority)

 	{}

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

 //

 // Virtual fn - checks version supported and creates a CTestSession

 //

 	{

 	TVersion version(KE32MajorVersionNumber,KE32MinorVersionNumber,KE32BuildVersionNumber);

 	if (User::QueryVersionSupported(version,aVersion)==EFalse)

 		User::Leave(KErrNotSupported);

 	CTestSession* newCTestSession = new CTestSession;

 	if (newCTestSession==NULL)

 		Panic(ENewSessionError);

 	return(newCTestSession);

 	}

 RThread clientThread, serverThread;

 void CTestServer::Panic(TPanicType aReason)	  //static function

 	{

 	clientThread.Kill(KErrNone);

 	User::Panic(_L("CTestServer"),aReason);

 	}

 RSession session, otherSession;

 RSemaphore sem;

 const TInt KTestInt[] = {-3866,30566,0,200};

 void CTestSession::TestInt(const RMessage2& aMessage)

 //

 // Tests to see that the correct Int0/1/2/3 have been received

 //

 	{

 	if (aMessage.Int0()!=KTestInt[0])

 		CTestServer::Panic(CTestServer::EInt0Error);

 	if (aMessage.Int1()!=KTestInt[1])

 		CTestServer::Panic(CTestServer::EInt1Error);

 	if (aMessage.Int2()!=KTestInt[2])

 		CTestServer::Panic(CTestServer::EInt2Error);

 	if (aMessage.Int3()!=KTestInt[3])

 		CTestServer::Panic(CTestServer::EInt3Error);

 	}

 const TAny* KTestPtr[]={&clientThread, &serverThread, &session, &sem};

 void CTestSession::TestPtr(const RMessage2& aMessage)

 //

 // Tests to see that the correct Ptr0/1/2/3 have been received

 //

 	{

 	if (aMessage.Ptr0()!=KTestPtr[0])

 		CTestServer::Panic(CTestServer::EPtr0Error);

 	if (aMessage.Ptr1()!=KTestPtr[1])

 		CTestServer::Panic(CTestServer::EPtr1Error);

 	if (aMessage.Ptr2()!=KTestPtr[2])

 		CTestServer::Panic(CTestServer::EPtr2Error);

 	if (aMessage.Ptr3()!=KTestPtr[3])

 		CTestServer::Panic(CTestServer::EPtr3Error);

 	}

 void CTestSession::TestClient(const RMessage2& aMessage)

 //

 // Tests Client()

 //

 	{

 	TFullName n=RProcess().Name();

 	n+=_L("::Client Thread");

 	RThread t;

 	TInt r=aMessage.Client(t);

 	if (r!=KErrNone)

 		User::Invariant();

 	if (t.FullName().CompareF(n)!=0)

 		{

 		clientThread.Kill(0);

 		CTestServer::Panic(CTestServer::EClientError);

 		}

 	t.Close();

 	}

 void CTestSession::TestComplete(const RMessage2& aMessage)

 //

 // Stores messages up then Completes in reverse order 

 //

 	{

 	messages[count1] = aMessage;

 	if (++count1==5)

 		for(count1=4; count1>=0; count1--)

 			messages[count1].Complete(5-count1);  //Complete with different 'error messages'

 	}

 void CTestSession::TestPtrComplete(const RMessage2& aMessage)

 //

 // Stores messages up as RMessagePtrs then Completes in reverse order

 // Also tests RMessage2::MessagePtr()

 //

 	{

 	messagePtrs[count2] = aMessage;

 	__ASSERT_ALWAYS(!messagePtrs[count2].IsNull(), User::Invariant());

 	if (++count2==5)

 		for(count2=4; count2>=0; count2--)

 			{

 			messagePtrs[count2].Complete(10-count2*2);

 			__ASSERT_ALWAYS(messagePtrs[count2].IsNull(), User::Invariant());

 			}

 	}

 TInt CTestSession::TestMessageConstruction(const RMessage2& aMessage)

 	{

 	RMessage2 m2((RMessagePtr2&)aMessage);

 	if(m2!=aMessage)

 		return KErrGeneral;

 	return KErrNone;

 	}

 TInt CTestSession::TestRMessagePtr2LeavingInterface(const RMessage2& aMessage)

 	{

 	RThread thread1, thread2;

 	TProcessPriority priority = EPriorityForeground;

 	//Check that both Client and ClientL methods return the same thread and error code.

 	if (aMessage.Client(thread1)) 

 		return KErrGeneral;

 	TRAPD(r1, aMessage.ClientL(thread2))

 	if (KErrNone != r1)	

 		{

 		thread1.Close();

 		return r1;

 		}

 	if (thread1.Id() != thread2.Id()) 

 		{

 		thread1.Close();

 		thread2.Close();

 		return KErrBadHandle;

 		}

 	//Check that both SetPriority & SetPriorityL methods return the same error code 

 	r1 = aMessage.SetProcessPriority(priority);

 	TRAPD(r2, aMessage.SetProcessPriorityL(priority))

 	thread1.Close();

 	thread2.Close();

 	if (r1 != r2)

 		return KErrGeneral;

 	return KErrNone;

 	}

 void CTestSession::ServiceL(const RMessage2& aMessage)

 //

 // Virtual message-handler

 //

 	{

 	TInt r=KErrNone;

 	switch (aMessage.Function())

 		{

 		case EStop:

 			CActiveScheduler::Stop();

 			break;		

 		case ETestInt:

 			TestInt(aMessage);

 			break;

 		case ETestPtr:

 			TestPtr(aMessage);

 			break;

 		case ETestClient:

 			TestClient(aMessage);

 			break;

 		case ETestComplete:

 			TestComplete(aMessage);

 			return;

 		case ETestPtrComplete:

 			TestPtrComplete(aMessage);

 			return;

 		case ETestCompletePanic:

 			aMessage.Complete(KErrNone);

 			break;

 		case ETestOtherSession:

 			break;

 		case ETestCompleteAfter:

 			User::After(7000000);

 			break;

 		case ETestMessageConstruction:

 			r=TestMessageConstruction(aMessage);

 			break;

 		case ETestRMessagePtr2LeavingInterface:

 			r=TestRMessagePtr2LeavingInterface(aMessage);

 			break;

 		default:

 			r=KErrNotSupported;

 		}						  

  	aMessage.Complete(r);

 	}

 // CTestSession funtions

 void CMyActiveScheduler::Error(TInt anError) const

 //

 // Virtual error handler

 //

 	{

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

 	}

 #include <e32svr.h>

 TInt ClientThread(TAny*)

 //

 // Passed as the first client thread - signals the server to do several tests

 //

 	{

 	RTest test(_L("T_MESSGE...client"));

 	test.Title(); 

 	test.Start(_L("Wait for server to start"));

 	sem.Wait();

 	test.Next(_L("Create Session"));

 	TInt r=session.PublicCreateSession(_L("CTestServer"),5);

 	if (r!=KErrNone)

 		User::Panic(_L("CreateSessn failure"),r);

 	test.Next(_L("Signal to test Int0/1/2/3()"));

 	r=session.PublicSendReceive(CTestSession::ETestInt,TIpcArgs(-3866,30566,0,200) );

 	test(r==KErrNone);

 	test.Next(_L("Signal to test Ptr0/1/2/3()"));

 	r=session.PublicSendReceive(CTestSession::ETestPtr, TIpcArgs(&clientThread, &serverThread, &session, &sem));

 	test(r==KErrNone);

 	test.Next(_L("Signal to test Client()"));

 	r=session.PublicSendReceive(CTestSession::ETestClient, TIpcArgs());

 	test(r==KErrNone);

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

 	TRequestStatus stat[7];

 	for (r=0;r<4;r++)

 		{

 		session.PublicSendReceive(CTestSession::ETestComplete, TIpcArgs(), stat[r]);

 		test(stat[r]==KRequestPending);

 		}

 	session.PublicSendReceive(CTestSession::ETestComplete, TIpcArgs(), stat[4]);

 	User::WaitForRequest(stat[0]);

 	for (r=0;r<5;r++)

 		test(stat[r]==5-r);	 //Test the 'error messages' set by Complete()

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

 	for (r=0;r<4;r++)

 		{

 		session.PublicSendReceive(CTestSession::ETestPtrComplete, TIpcArgs(), stat[r]);

 		test(stat[r]==KRequestPending);

 		}

 	session.PublicSendReceive(CTestSession::ETestPtrComplete, TIpcArgs(), stat[4]);

 	User::WaitForRequest(stat[0]);

 	for (r=0;r<5;r++)

 		test(stat[r]==10-r*2);

 	test.Next(_L("Test RMessage contruction from Ptr"));

 	if(UserSvr::IpcV1Available())

 		{

 		r=session.PublicSendReceive(CTestSession::ETestMessageConstruction, TIpcArgs(111,222,333,444));

 		test(r==KErrNone);

 		}

 	else

 		{

 		test.Printf(_L("NOT TESTED - IPC V1 is not supported by system"));

 		}

 	test.Next(_L("Test RMessagePtr leaving interface"));

 	r=session.PublicSendReceive(CTestSession::ETestRMessagePtr2LeavingInterface, TIpcArgs());

 	test(r==KErrNone);

 	test.Next(_L("Try another session"));

 	r=otherSession.PublicCreateSession(_L("CTestServer"),5);

 	test(r==KErrNone);

 	r=otherSession.PublicSendReceive(CTestSession::ETestOtherSession, TIpcArgs());

 	test(r==KErrNone);

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

 	for(r=0;r<7;r++)

 		{

 		test.Printf(_L("Send %d\r"),r);

 		session.PublicSendReceive(CTestSession::ETestCompleteAfter,TIpcArgs(),stat[r]);			

 		if (r<5)

 			test(stat[r]==KRequestPending);

 		else

 			test(stat[r]==KErrServerBusy);

 		}

  	test.Printf(_L("\n"));

 	for(r=0;r<5;r++)

 		{

 		test.Printf(_L("Wait %d\r"),r);

 		User::WaitForRequest(stat[r]);

 		test(stat[r]==KErrNone);

 		}

  	test.Printf(_L("\n"));

 	test.Next(_L("Signal to stop ActiveScheduler"));

 	session.PublicSendReceive(CTestSession::EStop, TIpcArgs());	

 	session.Close();

 	otherSession.PublicSendReceive(CTestSession::EStop, TIpcArgs());

 	otherSession.Close();

 	test.Close();

 	return (KErrNone);

 	}

 TInt ServerThread(TAny*)

 //

 // Passed as the server thread in 2 tests - sets up and runs CTestServer

 //

 	{

 	RTest test(_L("T_MESSGE...server"));

 	test.Title();

 	test.Start(_L("Create and install ActiveScheduler"));

 	CMyActiveScheduler* pScheduler = new CMyActiveScheduler;

 	if (pScheduler==NULL)

 		{

 		clientThread.Kill(0);

 		User::Panic(_L("CreateSched failure"),KErrNoMemory);

 		}

 	CActiveScheduler::Install(pScheduler);

 	test.Next(_L("Creating and starting Server"));

 	CTestServer* pServer = new CTestServer(0);

 	if (pServer==NULL)

 		{

 		clientThread.Kill(0);

 		User::Panic(_L("CreateServr failure"),KErrNoMemory);

 		}

 	TInt r=pServer->Start(KServerName);//Starting a CServer2 also Adds it to the ActiveScheduler

 	if (r!=KErrNone)

 		{

 		clientThread.Kill(0);

 		User::Panic(_L("StartServr failure"),r);

 		}

 	test.Next(_L("Start ActiveScheduler and signal to client"));

 	test.Printf(_L("        There might be something going on beneath this window"));

 	sem.Signal();

 	CActiveScheduler::Start();

 	test.Next(_L("Destroy ActiveScheduler"));

 	delete pScheduler;

 	delete pServer;

 	test.Close();

 	return (KErrNone);

 	}

 const TInt KTestPanic = 14849;

 TInt PanicTestThread (TAny*)

 //

 // Passed as a thread entry - just calls RMessage2::Panic()

 //

 	{

 	RMessage2 message;

 	message.Panic(_L("Testing Panic"),KTestPanic);

 	return(KErrNone);

 	}

 RTest test(_L("Main T_MESSGE test"));

 TInt CompletePanicClientThread (TAny*)

 //

 // Passed as the second client thread entry - signals to server to call Complete() twice

 //

 	{

 	sem.Wait();

 	TInt r=session.PublicCreateSession(_L("CTestServer"),1);

 	test(r==KErrNone);

 	r=session.PublicSendReceive(CTestSession::ETestCompletePanic, TIpcArgs());

 	test(r==KErrNone);

 	session.PublicSendReceive(CTestSession::EStop, TIpcArgs());//panic should occur before this is serviced 

 	return(KErrNone);

 	}

 void SimpleRMessage()

 //

 // Simple RMessage2 Tests - constructors and assignment

 //

 	{

 	test.Start(_L("Default constructor"));

 	RMessage2 message1;

 	test.Next(_L("Copy constructor"));

 	RMessage2 message2(message1);

 	test(message1.Function()==message2.Function());

 	test(message1.Int0()==message2.Int0());

 	test(message1.Int1()==message2.Int1());

 	test(message1.Int2()==message2.Int2());

 	test(message1.Int3()==message2.Int3());

 	test.Next(_L("Assignment operator"));

 	RMessage2 message3;

 	Mem::Fill(&message3,sizeof(message3),0xb9);	// first fill message 3 with rubbish

 	message3=message1;

  	test(message1.Function()==message3.Function());

 	test(message1.Int0()==message3.Int0());

 	test(message1.Int1()==message3.Int1());

 	test(message1.Int2()==message3.Int2());

 	test(message1.Int3()==message3.Int3());

 	test.End();

 	}

 void SimpleRMessagePtr()

 //

 // Simple RMessagePtr2 tests - constructors and assignment

 //

 	{

 	test.Start(_L("Default constructor"));

 	RMessagePtr2 messagePtr1;

 	test(messagePtr1.IsNull());

 	test.Next(_L("Copy constructor"));

 	RMessagePtr2 messagePtr2(messagePtr1);

 	test(messagePtr2.IsNull());

 	test.Next(_L("Constructor from pointer to RMessage2"));

 	RMessage2 message;

     messagePtr1= message;

 	test.Next(_L("Assignment operator"));

 	messagePtr1=messagePtr2;

 	test.End();

 	}

 GLDEF_C TInt E32Main()

 	{

 	test.Title();

 	test.Start(_L("Simple RMessage2 tests"));

 	SimpleRMessage();

 	test.Next(_L("Simple RMessagePtr2 tests"));

 	SimpleRMessagePtr();

 	test.Next(_L("Sending messages between two threads"));

 	test.Start(_L("Create client and server threads"));

 	clientThread.Create(_L("Client Thread"),ClientThread,KDefaultStackSize,KHeapMinSize,KHeapMaxSize,NULL);

 	serverThread.Create(_L("Server Thread"),ServerThread,KDefaultStackSize,KHeapMinSize,KHeapMaxSize,NULL);

 	test.Next(_L("Logon to the threads"));

 	TRequestStatus clientStat,serverStat;	

 	clientThread.Logon(clientStat);

 	serverThread.Logon(serverStat);

 	test.Next(_L("Start the threads"));

 	sem.CreateLocal(0);

 	clientThread.Resume();

 	serverThread.Resume();

 	test.Next(_L("Wait for the threads to stop"));

 	if(clientStat==KRequestPending)

 		User::WaitForRequest(clientStat);

 	if(serverStat==KRequestPending)

 		User::WaitForRequest(serverStat);

 	switch (clientThread.ExitType())

 		{

 		case EExitKill:

 			test.Printf(_L("  Client thread killed\n")); 

 			break;

 		case EExitTerminate:

 			test.Printf(_L("!!Client thread terminated:"));

 			test.Panic(clientThread.ExitCategory(), clientThread.ExitReason());

 		case EExitPanic:

 			test.Panic(_L("!!Client thread panicked:"));

 			test.Panic(clientThread.ExitCategory(), clientThread.ExitReason());

 		default:

 			test.Panic(_L("!!Client thread did something bizarre"), clientThread.ExitReason());

 		}

 	switch (serverThread.ExitType())

 		{

 		case EExitKill:

 			test.Printf(_L("  Server thread killed\n")); 

 			break;

 		case EExitTerminate:

 			test.Printf(_L("!!Server thread terminated:"));

 			test.Panic(serverThread.ExitCategory(), serverThread.ExitReason());

 		case EExitPanic:

 			test.Printf(_L("!!Server thread panicked:"));

 			test.Panic(serverThread.ExitCategory(), serverThread.ExitReason());

 			//

 			// To catch a panic put a breakpoint in User::Panic() (in UCDT\UC_UNC.CPP).

 			//

 		default:

 			test.Panic(_L("!!Server thread did something bizarre"), serverThread.ExitReason());

 		}

 	test.Next(_L("Close the threads"));

 	CLOSE_AND_WAIT(serverThread);

 	CLOSE_AND_WAIT(clientThread);

 	test.End();

 	TBool justInTime=User::JustInTime();

  	test.Next(_L("Check it Panics if you try to Complete a message twice"));

 	test.Start(_L("Create client and server threads"));

 	clientThread.Create(_L("Client Thread1"),CompletePanicClientThread,KDefaultStackSize,KHeapMinSize,KHeapMaxSize,NULL);

 	serverThread.Create(_L("Server Thread"),ServerThread,KDefaultStackSize,KHeapMinSize,KHeapMaxSize,NULL);

 	test.Next(_L("Logon to the threads"));

 	clientThread.Logon(clientStat);

 	serverThread.Logon(serverStat);

 	test.Next(_L("Start the threads"));

 	sem.CreateLocal(0);

 	User::SetJustInTime(EFalse); 

 	clientThread.Resume();

 	serverThread.Resume();

 	test.Next(_L("Wait for the threads to stop"));

 	User::WaitForRequest(clientStat); //

 	User::WaitForRequest(serverStat);

 	User::SetJustInTime(justInTime); 

 	test.Next(_L("Check the exit categories"));

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

 	test(clientThread.ExitCategory().Compare(_L("Kill"))==0);

 	test(clientThread.ExitReason()==KErrNone);

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

 	test(serverThread.ExitCategory().Compare(_L("USER"))==0);

 	test(serverThread.ExitReason()==ETMesCompletion);

 	test.Next(_L("Close the threads"));

 	CLOSE_AND_WAIT(serverThread);

 	CLOSE_AND_WAIT(clientThread);

 	test.End();	  

 	test.End();

 	return (KErrNone);

 	}