diff -r 000000000000 -r a41df078684a kerneltest/e32test/system/t_svr_connect.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/system/t_svr_connect.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,915 @@
+// Copyright (c) 2005-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\system\t_svr_connect.cpp
+// Overview:
+// Tests correct operation of server when interleaving connect/disconnect/
+// other messages and creating the user-side session object (setting the
+// session cookie) in interesting manners.
+// Tests that clients/servers are panicked when performing illegal operations
+// w.r.t. server connection, i.e. a client thread may not send more than one
+// connect message simultaneously, nor may it send another connect message
+// once a connect message has been successfully completed. Similarly, a server
+// may not set the cookie twice nor may it set the cookie to be NULL. Also, a
+// server may only set the cookie from a connect message and from no other.
+// API Information:
+// RServer2
+// Details:
+// - Test asynchronous server connect in various ways. Verify results
+// are as expected.
+// - Test illegal client/server behaviour. Verify threads are panicked,
+// as expected.
+// Platforms/Drives/Compatibility:
+// All.
+// Assumptions/Requirement/Pre-requisites:
+// None.
+// Failures and causes:
+// Failure of this test would be caused by an incorrect modification of
+// the internal client/server mechanism in the kernel.
+// Base Port information:
+// This is a unit test of the client/server mechanism within the kernel.
+// It should be invariant to base ports. If the kernel proper has not been
+// modified, this test should not fail with any new base port.
+// 
+//
+
+#include <e32test.h>
+#include "../misc/int_svr_calls.h"
+#include <e32kpan.h>
+
+_LIT(KTestName, "t_svr_connect");
+LOCAL_D RTest test(KTestName);
+LOCAL_D RTest test_client(KTestName);
+LOCAL_D RTest test_server(KTestName);
+
+_LIT(KServerName, "t_svr_connect");
+_LIT8(KServerName8, "t_svr_connect");
+_LIT(KMainThread, "main thread");
+_LIT(KServerThread, "server thread");
+_LIT(KClientThread, "client thread");
+_LIT(KClientThread2, "client thread2");
+_LIT(KClientThread3, "client thread3");
+
+class RTestServer : public RSessionBase
+	{
+public:
+	inline static TInt CreateSession(TInt aMsgSlots) { return SessionCreate(KServerName8,aMsgSlots,NULL,EIpcSession_Sharable); }
+	};
+
+// Messages to send:
+//
+//		connect,				1
+//		a.n.other,				2
+//		disconnect				3
+//
+// Things to do in the server:
+//
+//		recieve connect			4
+//		set cookie				5
+//		complete connect		6
+//		receive a.n.other		7
+//		complete a.n.other		8
+//		receive disconnect		9
+//		complete disconnect		10
+//		
+
+enum TMsgType
+	{
+	EConnect = -1,
+	EDisConnect = -2,
+	EANOther = 1,
+	EANOther2 = 2,
+	EMsgCount = 4
+	};
+
+enum TServerControl
+	{
+	EReceiveMsg = 0,
+	EReceiveBlocked = 1,
+	EWaitForReceive = 2,
+	ESetCookie = 3,
+	ESetNullCookie = 4,
+	ECompleteMsg = 5,
+	EServerDie = 6
+	};
+
+enum TClientControl
+	{
+	ESendMsg = 0,
+	EWaitMsg = 1,
+	ECreateSession = 2,
+	EClientDie = 3,
+	ESetCritical = 4
+	};
+
+static TMsgType TheMsgType;
+static TServerControl TheServerControl;
+static TClientControl TheClientControl;
+static RSemaphore ServerSemaphore;
+static RSemaphore ClientSemaphore;
+static RSemaphore TaskCompletionSemaphore;
+static RMessage2 Msgs[EMsgCount];
+static RServer2 Server;
+static RThread ServerThread;
+static RThread ClientThread;
+static RTestServer ServerHandle;
+static TRequestStatus ConnectStatus;
+static TRequestStatus ANOtherStatus;
+static TRequestStatus ANOther2Status;
+static TRequestStatus ServerReceiveStatus;
+static TInt TheNumberOfMsgSlots;
+static TInt ErrorExpected;
+static User::TCritical CriticalLevel;
+
+
+static const TAny* const KSessionCookie = (const TAny*)0x12345;
+static TRequestStatus* volatile KNullReference = 0;
+
+void DoServerAction();
+void DoClientAction();
+TInt Index();
+
+TInt TestThreadServer(TAny*)
+	{
+	test_server(Server.CreateGlobal(KServerName) == KErrNone);
+	RThread::Rendezvous(KErrNone);
+
+	for (;;)
+		{
+		ServerSemaphore.Wait();
+		DoServerAction();
+		TaskCompletionSemaphore.Signal();
+		}
+	}
+
+TInt Index()
+	{
+	switch (TheMsgType)
+		{
+	case EConnect:
+		return 0;
+	case EDisConnect:
+		return 3;
+	case EANOther:
+		return 1;
+	case EANOther2:
+		return 2;
+	default:
+		return -1;
+		};
+	}
+
+TRequestStatus& RequestStatus()
+	{
+	switch (TheMsgType)
+		{
+	case EConnect:
+		return ConnectStatus;
+	case EANOther:
+		return ANOtherStatus;
+	case EANOther2:
+		return ANOther2Status;
+	default:
+		User::Invariant();
+		};
+	return *(TRequestStatus*)KNullReference;
+	}
+
+void DoServerAction()
+	{
+	switch (TheServerControl)
+		{
+	case EReceiveMsg:
+		{
+		RMessage2& msg = Msgs[Index()];
+		Server.Receive(msg);
+		test_server(msg.Function() == TheMsgType);
+		}
+		break;
+	case EReceiveBlocked:
+		{
+		RMessage2& msg = Msgs[Index()];
+		Server.Receive(msg, ServerReceiveStatus);
+		test_server(ServerReceiveStatus.Int() == KRequestPending);
+		}
+		break;
+	case EWaitForReceive:
+		{
+		User::WaitForRequest(ServerReceiveStatus);
+		test_server(ServerReceiveStatus.Int() == KErrNone);
+		test_server(Msgs[Index()].Function() == TheMsgType);
+		}
+		break;
+	case ESetCookie:
+		{
+		SetSessionPtr(Msgs[Index()].Handle(), KSessionCookie);
+		}
+		break;
+	case ESetNullCookie:
+		{
+		SetSessionPtr(Msgs[Index()].Handle(), NULL);
+		}
+		break;
+	case ECompleteMsg:
+		{
+		Msgs[Index()].Complete(KErrNone);
+		}
+		break;
+	case EServerDie:
+		{
+		User::Exit(0);
+		}
+		break;
+	default:
+		{
+		}
+		break;
+		};
+	}
+
+void StartServer()
+	{
+	ServerThread.Create(KServerThread, TestThreadServer, KDefaultStackSize, 4096, 4096, NULL);
+
+	TRequestStatus started;
+	ServerThread.Rendezvous(started);
+
+	ServerThread.Resume();
+	User::WaitForRequest(started);
+
+	test(started.Int() == KErrNone);
+	}
+
+void StopServer()
+	{
+	TRequestStatus logon;
+	ServerThread.Logon(logon);
+
+	TheServerControl = EServerDie;
+	ServerSemaphore.Signal();
+
+	User::WaitForRequest(logon);
+	test(logon.Int() == KErrNone);
+
+	CLOSE_AND_WAIT(ServerThread);
+	}
+
+TInt TestThreadClient(TAny*)
+	{
+	RThread::Rendezvous(KErrNone);
+
+	for (;;)
+		{
+		ClientSemaphore.Wait();
+		DoClientAction();
+		TaskCompletionSemaphore.Signal();
+		}
+	}
+
+void DoClientAction()
+	{
+	switch (TheClientControl)
+		{
+	case ESendMsg:
+		{
+		if (TheMsgType == EDisConnect)
+			ServerHandle.Close();
+		else
+			SessionSend(ServerHandle.Handle(), TheMsgType, NULL, &RequestStatus());
+		}
+		break;
+	case EWaitMsg:
+		{
+		User::WaitForRequest(RequestStatus());
+		}
+		break;
+	case ECreateSession:
+		{
+		TInt err = ServerHandle.SetReturnedHandle(RTestServer::CreateSession(TheNumberOfMsgSlots));
+		
+		if (err != ErrorExpected)
+			{
+			test_client.Printf(_L("Error returned = %d\n"),err);
+			test_client(EFalse,__LINE__);
+			}
+		}
+		break;
+	case EClientDie:
+		{
+		User::SetCritical(User::ENotCritical);
+		User::Exit(0);
+		}
+		break;
+	case ESetCritical:
+		{
+		User::SetCritical(CriticalLevel);
+		break;
+		}
+	default:
+		{
+		}
+		break;
+		};
+	}
+
+// I'm lazy and I haven't completed all the IPC the client thread does,
+// so even when the client thread panics, the DObject is still kept alive
+// until the server goes away. Therefore if I want another client I rename.
+void StartClient(const TDesC& aName)
+	{
+	ClientThread.Create(aName, TestThreadClient, KDefaultStackSize, 4096, 4096, NULL);
+
+	TRequestStatus started;
+	ClientThread.Rendezvous(started);
+
+	ClientThread.Resume();
+	User::WaitForRequest(started);
+
+	test(started.Int() == KErrNone);
+	}
+
+void StartClient()
+	{
+	StartClient(KClientThread);
+	}
+
+void StopClient()
+	{
+	TRequestStatus logon;
+	ClientThread.Logon(logon);
+
+	TheClientControl = EClientDie;
+	ClientSemaphore.Signal();
+
+	User::WaitForRequest(logon);
+	test(logon.Int() == KErrNone);
+
+	CLOSE_AND_WAIT(ClientThread);
+	}
+
+void CreateSemaphores()
+	{
+	TInt err = ServerSemaphore.CreateLocal(0);
+	test(err == KErrNone);
+	err = ClientSemaphore.CreateLocal(0);
+	test(err == KErrNone);
+	err = TaskCompletionSemaphore.CreateLocal(0);
+	test(err == KErrNone);
+	}
+
+void CloseSemaphores()
+	{
+	ServerSemaphore.Close();
+	ClientSemaphore.Close();
+	TaskCompletionSemaphore.Close();
+	}
+
+void CreateSession(TInt aErrorExpected=KErrNone, TInt aMsgSlots=-1)
+	{
+	TheClientControl = ECreateSession;
+	TheNumberOfMsgSlots = aMsgSlots;
+	ErrorExpected=aErrorExpected;
+	ClientSemaphore.Signal();
+	TaskCompletionSemaphore.Wait();
+	}
+
+void SendMsg(TMsgType aType)
+	{
+	TheClientControl = ESendMsg;
+	TheMsgType = aType;
+	ClientSemaphore.Signal();
+	TaskCompletionSemaphore.Wait();
+	}
+
+void SendMsg_NoWait(TMsgType aType)
+	{
+	TheClientControl = ESendMsg;
+	TheMsgType = aType;
+	ClientSemaphore.Signal();
+	}
+
+void WaitMsg(TMsgType aType)
+	{
+	TheClientControl = EWaitMsg;
+	TheMsgType = aType;
+	ClientSemaphore.Signal();
+	TaskCompletionSemaphore.Wait();
+	}
+
+void ReceiveBlocked(TMsgType aType)
+	{
+	TheServerControl = EReceiveBlocked;
+	TheMsgType = aType;
+	ServerSemaphore.Signal();
+	TaskCompletionSemaphore.Wait();
+	}
+
+void WaitForReceive(TMsgType aType)
+	{
+	TheServerControl = EWaitForReceive;
+	TheMsgType = aType;
+	ServerSemaphore.Signal();
+	TaskCompletionSemaphore.Wait();
+	}
+
+void ReceiveMsg(TMsgType aType)
+	{
+	TheServerControl = EReceiveMsg;
+	TheMsgType = aType;
+	ServerSemaphore.Signal();
+	TaskCompletionSemaphore.Wait();
+	}
+
+void CompleteMsg(TMsgType aType)
+	{
+	TheServerControl = ECompleteMsg;
+	TheMsgType = aType;
+	ServerSemaphore.Signal();
+	TaskCompletionSemaphore.Wait();
+	}
+
+void SetCookie()
+	{
+	TheServerControl = ESetCookie;
+	TheMsgType = EConnect;
+	ServerSemaphore.Signal();
+	TaskCompletionSemaphore.Wait();
+	}
+
+void SetCookie_NoWait()
+	{
+	TheServerControl = ESetCookie;
+	TheMsgType = EConnect;
+	ServerSemaphore.Signal();
+	}
+
+void SetNullCookie()
+	{
+	TheServerControl = ESetNullCookie;
+	TheMsgType = EConnect;
+	ServerSemaphore.Signal();
+	}
+
+void SetBadCookie(TMsgType aType)
+	{
+	TheServerControl = ESetCookie;
+	test(aType != EConnect);
+	TheMsgType = aType;
+	ServerSemaphore.Signal();
+	}
+void SetClientCritical(User::TCritical aCritical)
+	{	
+	TheClientControl = ESetCritical;
+	CriticalLevel=aCritical;
+	ClientSemaphore.Signal();
+	TaskCompletionSemaphore.Wait();
+	}
+	
+void Test1()
+	{
+	test.Next(_L("Create session with test server"));
+	CreateSession();
+	test.Next(_L("Send connect message"));
+	SendMsg(EConnect);
+	test.Next(_L("Send A.N.Other message"));
+	SendMsg(EANOther);
+	test.Next(_L("Sending disconnect message"));
+	SendMsg(EDisConnect);
+	test.Next(_L("Receive A.N.Other message"));
+	ReceiveMsg(EANOther);
+	test(Msgs[Index()].Session() == NULL);
+	test.Next(_L("Receive disconnect message"));
+	ReceiveMsg(EDisConnect);
+	test.Next(_L("Check the session has gone"));
+	test(Msgs[Index()].Session() == NULL);
+	test.Next(_L("Set up receive for next test"));
+	ReceiveBlocked(EConnect);
+	}
+
+void Test2()
+	{
+	test.Next(_L("Create session with test server"));
+	CreateSession();
+	test.Next(_L("Send connect message"));
+	SendMsg(EConnect);
+	test.Next(_L("Send A.N.Other message"));
+	SendMsg(EANOther);
+	test.Next(_L("Receive connect message"));
+	WaitForReceive(EConnect);
+	test(Msgs[Index()].Session() == NULL);
+	test.Next(_L("Receive A.N.Other message"));
+	ReceiveMsg(EANOther);
+	test(Msgs[Index()].Session() == NULL);
+	test.Next(_L("Sending disconnect message"));
+	SendMsg(EDisConnect);
+	test.Next(_L("Await disconnect message"));
+	ReceiveBlocked(EDisConnect);
+	test.Next(_L("Set cookie"));
+	SetCookie();
+	test.Next(_L("Check disconnect message received"));
+	WaitForReceive(EDisConnect);
+	test(Msgs[Index()].Session() == KSessionCookie);
+	test.Next(_L("Complete connect message"));
+	CompleteMsg(EConnect);
+	}
+
+void Test2a()
+	{
+	CreateSession();
+	SendMsg(EConnect);
+	SendMsg(EANOther);
+	ReceiveMsg(EConnect);
+	test(Msgs[Index()].Session() == NULL);
+	ReceiveMsg(EANOther);
+	test(Msgs[Index()].Session() == NULL);
+	SendMsg(EDisConnect);
+	ReceiveBlocked(EDisConnect);
+	CompleteMsg(EConnect);
+	WaitForReceive(EDisConnect);
+	test(Msgs[Index()].Session() == NULL);
+	}
+
+void Test2b()
+	{
+	CreateSession();
+	SendMsg(EConnect);
+	SendMsg(EANOther);
+	ReceiveMsg(EConnect);
+	test(Msgs[Index()].Session() == NULL);
+	SetCookie();
+	ReceiveMsg(EANOther);
+	test(Msgs[Index()].Session() == KSessionCookie);
+	SendMsg(EDisConnect);
+	ReceiveMsg(EDisConnect);
+	test(Msgs[Index()].Session() == KSessionCookie);
+	}
+
+void Test3()
+	{
+	CreateSession();
+	SendMsg(EConnect);
+	ReceiveMsg(EConnect);
+	test(Msgs[Index()].Session() == NULL);
+	SendMsg(EANOther);
+	ReceiveMsg(EANOther);
+	test(Msgs[Index()].Session() == NULL);
+	SendMsg(EDisConnect);
+	ReceiveBlocked(EDisConnect);
+	SetCookie();
+	WaitForReceive(EDisConnect);
+	test(Msgs[Index()].Session() == KSessionCookie);
+	CompleteMsg(EConnect);
+	}
+
+void Test3a()
+	{
+	CreateSession();
+	SendMsg(EConnect);
+	ReceiveMsg(EConnect);
+	test(Msgs[Index()].Session() == NULL);
+	SendMsg(EANOther);
+	ReceiveMsg(EANOther);
+	test(Msgs[Index()].Session() == NULL);
+	SendMsg(EDisConnect);
+	ReceiveBlocked(EDisConnect);
+	CompleteMsg(EConnect);
+	WaitForReceive(EDisConnect);
+	test(Msgs[Index()].Session() == NULL);
+	}
+
+void Test3b()
+	{
+	CreateSession();
+	SendMsg(EConnect);
+	ReceiveMsg(EConnect);
+	test(Msgs[Index()].Session() == NULL);
+	SetCookie();
+	SendMsg(EANOther);
+	ReceiveMsg(EANOther);
+	test(Msgs[Index()].Session() == KSessionCookie);
+	SendMsg(EDisConnect);
+	ReceiveMsg(EDisConnect);
+	test(Msgs[Index()].Session() == KSessionCookie);
+	}
+
+void Test4()
+	{
+	CreateSession();
+	SendMsg(EANOther);
+	SendMsg(EConnect);
+	SendMsg(EANOther2);
+	SendMsg(EDisConnect);
+	ReceiveMsg(EANOther);
+	test(Msgs[Index()].Session() == NULL);
+	ReceiveMsg(EANOther2);
+	test(Msgs[Index()].Session() == NULL);
+	ReceiveMsg(EDisConnect);
+	test(Msgs[Index()].Session() == NULL);
+	}
+
+void Test5()
+	{
+	CreateSession();
+	SendMsg(EANOther);
+	SendMsg(EConnect);
+	SendMsg(EANOther2);
+	ReceiveMsg(EANOther);
+	test(Msgs[Index()].Session() == NULL);
+	SendMsg(EDisConnect);
+	ReceiveMsg(EANOther2);
+	test(Msgs[Index()].Session() == NULL);
+	ReceiveMsg(EDisConnect);
+	test(Msgs[Index()].Session() == NULL);
+	ReceiveBlocked(EANOther);
+	}
+
+void Test6()
+	{
+	CreateSession();
+	SendMsg(EANOther);
+	SendMsg(EConnect);
+	SendMsg(EANOther2);
+	WaitForReceive(EANOther);
+	test(Msgs[Index()].Session() == NULL);
+	ReceiveMsg(EConnect);
+	test(Msgs[Index()].Session() == NULL);
+	ReceiveMsg(EANOther2);
+	test(Msgs[Index()].Session() == NULL);
+	SendMsg(EDisConnect);
+	ReceiveBlocked(EDisConnect);
+	SetCookie();
+	WaitForReceive(EDisConnect);
+	test(Msgs[Index()].Session() == KSessionCookie);
+	CompleteMsg(EConnect);
+	}
+
+void Test6a()
+	{
+	CreateSession();
+	SendMsg(EANOther);
+	SendMsg(EConnect);
+	SendMsg(EANOther2);
+	ReceiveMsg(EANOther);
+	test(Msgs[Index()].Session() == NULL);
+	ReceiveMsg(EConnect);
+	test(Msgs[Index()].Session() == NULL);
+	ReceiveMsg(EANOther2);
+	test(Msgs[Index()].Session() == NULL);
+	SendMsg(EDisConnect);
+	ReceiveBlocked(EDisConnect);
+	CompleteMsg(EConnect);
+	WaitForReceive(EDisConnect);
+	test(Msgs[Index()].Session() == NULL);
+	}
+
+void Test6b()
+	{
+	CreateSession();
+	SendMsg(EANOther);
+	SendMsg(EConnect);
+	SendMsg(EANOther2);
+	ReceiveMsg(EANOther);
+	test(Msgs[Index()].Session() == NULL);
+	ReceiveMsg(EConnect);
+	test(Msgs[Index()].Session() == NULL);
+	SetCookie();
+	ReceiveMsg(EANOther2);
+	test(Msgs[Index()].Session() == KSessionCookie);
+	SendMsg(EDisConnect);
+	ReceiveMsg(EDisConnect);
+	test(Msgs[Index()].Session() == KSessionCookie);
+	}
+
+void Test7()
+	{
+	CreateSession();
+	SendMsg(EANOther);
+	SendMsg(EConnect);
+	ReceiveMsg(EANOther);
+	test(Msgs[Index()].Session() == NULL);
+	SendMsg(EANOther2);
+	ReceiveMsg(EConnect);
+	test(Msgs[Index()].Session() == NULL);
+	SetCookie();
+	ReceiveMsg(EANOther2);
+	test(Msgs[Index()].Session() == KSessionCookie);
+	SendMsg(EDisConnect);
+	ReceiveMsg(EDisConnect);
+	test(Msgs[Index()].Session() == KSessionCookie);
+	}
+
+void Test8()
+	{
+	CreateSession();
+	SendMsg(EANOther);
+	SendMsg(EConnect);
+	ReceiveMsg(EANOther);
+	test(Msgs[Index()].Session() == NULL);
+	ReceiveMsg(EConnect);
+	test(Msgs[Index()].Session() == NULL);
+	SetCookie();
+	SendMsg(EANOther2);
+	ReceiveMsg(EANOther2);
+	test(Msgs[Index()].Session() == KSessionCookie);
+	SendMsg(EDisConnect);
+	ReceiveMsg(EDisConnect);
+	test(Msgs[Index()].Session() == KSessionCookie);
+	}
+
+void Test9()
+	{
+	CreateSession();
+	SendMsg(EANOther);
+	ReceiveMsg(EANOther);
+	test(Msgs[Index()].Session() == NULL);
+	SendMsg(EConnect);
+	ReceiveMsg(EConnect);
+	test(Msgs[Index()].Session() == NULL);
+	SetCookie();
+	SendMsg(EANOther2);
+	ReceiveMsg(EANOther2);
+	test(Msgs[Index()].Session() == KSessionCookie);
+	SendMsg(EDisConnect);
+	ReceiveMsg(EDisConnect);
+	test(Msgs[Index()].Session() == KSessionCookie);
+	}
+
+void Test10()
+	{
+	// Try connecting with too many message slots
+	// (Check for DEF091903 regression)
+	CreateSession(KErrArgument, 1000);
+	}
+
+_LIT(KKernExec, "KERN-EXEC");
+
+void CheckClientDeath(TInt aReason)
+	{
+	TRequestStatus logon;
+
+	ClientThread.Logon(logon);
+	User::WaitForRequest(logon);
+
+	test(ClientThread.ExitType() == EExitPanic);
+	test(ClientThread.ExitCategory() == KKernExec);
+	test(ClientThread.ExitReason() == aReason);
+
+	ClientThread.Close();
+	ClientThread.SetHandle(KNullHandle);
+	}
+
+void CheckServerDeath(TInt aReason)
+	{
+	TRequestStatus logon;
+
+	ServerThread.Logon(logon);
+	User::WaitForRequest(logon);
+
+	test(ServerThread.ExitType() == EExitPanic);
+	test(ServerThread.ExitCategory() == KKernExec);
+	test(ServerThread.ExitReason() == aReason);
+
+	CLOSE_AND_WAIT(ServerThread);
+	ServerThread.SetHandle(KNullHandle);
+	}
+
+void TestNaughty()
+	{
+	TBool jit = User::JustInTime();
+	User::SetJustInTime(EFalse);
+
+	SetClientCritical(User::ENotCritical);
+	test.Next(_L("Two connect msgs at once is naughty"));
+	CreateSession();
+	SendMsg(EConnect);
+	ReceiveMsg(EConnect);
+	SetCookie();
+	SendMsg_NoWait(EConnect);
+	CheckClientDeath(ERequestAlreadyPending);
+	StartClient(KClientThread2);
+	test.Next(_L("Another connect message after a sucessful connect msg is naughty"));
+	CreateSession();
+	SendMsg(EConnect);
+	ReceiveMsg(EConnect);
+	SetCookie();
+	CompleteMsg(EConnect);
+	SendMsg_NoWait(EConnect);
+	CheckClientDeath(ESessionAlreadyConnected);
+	StartClient(KClientThread3);
+
+	test.Next(_L("A null session cookie is naughty"));
+	CreateSession();
+	SendMsg(EConnect);
+	ReceiveMsg(EConnect);
+	SetNullCookie();
+	CheckServerDeath(ESessionNullCookie);
+	StartServer();
+
+	test.Next(_L("Setting the session cookie twice is naughty"));
+	CreateSession();
+	SendMsg(EConnect);
+	ReceiveMsg(EConnect);
+	SetCookie();
+	SetCookie_NoWait();
+	CheckServerDeath(ESessionCookieAlreadySet);
+	StartServer();
+
+	test.Next(_L("Trying to set the session cookie from a non-connect message is naughty"));
+	CreateSession();
+	SendMsg(EConnect);
+	ReceiveMsg(EConnect);
+	SendMsg(EANOther);
+	ReceiveMsg(EANOther);
+	SetBadCookie(EANOther);
+	CheckServerDeath(ESessionInvalidCookieMsg);
+	StartServer();
+
+	User::SetJustInTime(jit);
+	}
+
+TInt E32Main()
+    {
+	User::RenameThread(KMainThread);
+
+	__UHEAP_MARK;
+
+	test.Title();
+
+	test.Start(_L("Creating semaphores"));
+	CreateSemaphores();
+
+	test.Next(_L("Starting test server"));
+	StartServer();
+
+	test.Next(_L("Starting test client"));
+	StartClient();
+	SetClientCritical(User::EProcessCritical);
+	// test combinations of receiving messages with messages sent by the client in the
+	// correct order (w.r.t to each other, but not necessarily to when messages are received)
+	test.Next(_L("Sending in order"));
+	test.Next(_L("1"));
+	Test1();
+	test.Next(_L("2"));
+	Test2();
+	test.Next(_L("2a"));
+	Test2a();
+	test.Next(_L("2b"));
+	Test2b();
+	test.Next(_L("3"));
+	Test3();
+	test.Next(_L("3a"));
+	Test3a();
+	test.Next(_L("3b"));
+	Test3b();
+
+	// test combinations of receiving messages with messages sent by the client in the
+	// wrong order (w.r.t to each other, but not necessarily to when messages are received)
+	test.Next(_L("Sending out of order"));
+	test.Next(_L("4"));
+	Test4();
+	test.Next(_L("5"));
+	Test5();
+	test.Next(_L("6"));
+	Test6();
+	test.Next(_L("6a"));
+	Test6a();
+	test.Next(_L("6b"));
+	Test6b();
+	test.Next(_L("7"));
+	Test7();
+	test.Next(_L("8"));
+	Test8();
+	test.Next(_L("9"));
+	Test9();
+	test.Next(_L("10"));
+	Test10();
+
+	test.Next(_L("Test other naughty behaviour is trapped"));
+	TestNaughty();
+
+	test.Next(_L("Stopping test client"));
+	StopClient();
+
+	test.Next(_L("Stopping test server"));
+	StopServer();
+
+	test.Next(_L("Closing semaphores"));
+	CloseSemaphores();
+
+	test.End();
+	test.Close();
+
+	__UHEAP_MARKEND;
+
+	return KErrNone;
+    }