--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/active/t_messge.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,686 @@
+// 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 <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);
+ }
+
+