// Copyright (c) 1998-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\thread\t_threadedserver.cpp

// Tests the multi-threaded server/session support in CServer2/CSession2

// Overview:

// Tests the CServer2::SetMaster and CSession2:SetServer functions

// API Information:

// CServer2, CSession2

// Details:

// - Test creating multiple sessions with a single-threaded server

// - Test creating multiple sessions with a multi-threaded server

// - Verify that requests to a multi-threaded server can run in parallel and complete out-of-order

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32panic.h>

#include <e32debug.h>

_LIT(KMyName, "T_THREADEDSERVER");

_LIT(KServerName,"MyServer");

const TInt KHeapSize = 4096;

LOCAL_D RTest test(KMyName);

class CMySession : public CSession2

	{

public:

	enum TMyRequests { EFinish, EDelay5, EPing };

	CMySession(TInt aId);

	virtual void ServiceL(const RMessage2& aMessage);

private:

	const TInt iD;

	};

CMySession::CMySession(TInt aId) :

	iD(aId)

	{

	}

void CMySession::ServiceL(const RMessage2& aMessage)

	{

	TInt err = KErrNotSupported;

	RDebug::Printf("Session %d: received message %d", iD, aMessage.Function());

	switch (aMessage.Function())

		{

		case EFinish:

			CActiveScheduler::Stop();

			err = KErrNone;

			break;

		case EDelay5:

			User::After(5000000);

			err = KErrNone;

			break;

		case EPing:

			User::After(1000000);

			err = KErrNone;

			break;

		default:

			break;

		}

	RDebug::Printf("Session %d: completing message %d, err %d", iD, aMessage.Function(), err);

	if (err == KErrNone)

		aMessage.Complete(err);

	else

		aMessage.Panic(KServerName, err);

	}

class CMyServer : public CServer2

	{

public:

	CMyServer();

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

private:

	mutable TInt iCount;

	};

static CMyServer* TheMaster = NULL;

static CMyServer* TheSlave = NULL;

CMyServer::CMyServer() :

	CServer2(0),

	iCount(0)

	{

	}

CSession2* CMyServer::NewSessionL(const TVersion&, const RMessage2&) const

	{

	RDebug::Printf("Server: creating session, slave is $%x", TheSlave);

	iCount += 1;

	CSession2* mySession = new (ELeave) CMySession(iCount);

	if (iCount > 1 && TheSlave != NULL)

		mySession->SetServer(TheSlave);

	RDebug::Printf("Server: created session %d", iCount);

	return mySession;

	}

TInt RunServerCode(TAny* aFlag)

	{

	TInt mode = (TInt)aFlag;

	TInt r = KErrNoMemory;

	RDebug::Printf("Server: start, mode %d", mode);

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if (cleanup == NULL)

		return r;

	CActiveScheduler* pR = new CActiveScheduler;

	if (pR == NULL)

		return r;

	CActiveScheduler::Install(pR);

	CMyServer* pS = new CMyServer();

	if (pS == NULL)

		return r;

	switch (mode)

		{

		case 0:

			r = pS->Start(KServerName);

			break;

		case 1:

			TheMaster = pS;

			pS->SetMaster(TheMaster);

			r = pS->Start(KServerName);

			break;

		case 2:

			TheSlave = pS;

			pS->SetMaster(TheMaster);

			r = pS->Start(KNullDesC);

			break;

		}

	if (r != KErrNone)

		return r;

	RThread::Rendezvous(KErrNone);

	TRAP(r, CActiveScheduler::Start());

	if (r != KErrNone)

		return r;

	delete pS;

	delete pR;

	delete cleanup;

	RDebug::Printf("Server: exit");

	return KErrNone;

	}

class RSession : public RSessionBase

	{

public:

	TInt Create();

	void Request(TInt aRequest, TRequestStatus& aStatus);

	void Request(TInt aRequest);

	};

TInt RSession::Create()

	{

	return CreateSession(KServerName, TVersion());

	}

void RSession::Request(TInt aRequest, TRequestStatus& aStatus)

	{

	SendReceive(aRequest, TIpcArgs(), aStatus);

	}

void RSession::Request(TInt aRequest)

	{

	SendReceive(aRequest, TIpcArgs());

	}

TInt RunClientCode(TAny* aFlag)

	{

	TInt mode = (TInt)aFlag;

	RDebug::Printf("Client: open sessions");

	RSession session1, session2;

	session1.Create();

	session2.Create();

	TBool ooc = EFalse;

	TRequestStatus status1 (KRequestPending), status2 (KRequestPending);

	RDebug::Printf("Client: send request 1");

	session1.Request(CMySession::EDelay5, status1);

	User::After(1000000);

	RDebug::Printf("Client: send request 2");

	session2.Request(CMySession::EPing, status2);

	User::WaitForRequest(status1, status2);

	if (status1 == KRequestPending)

		{

		// request2 finished first ...

		ooc = ETrue;

		RDebug::Printf("Client: request 2 completed %d", status2.Int());

		User::WaitForRequest(status1);

		}

	else

		{

		RDebug::Printf("Client: request 1 completed %d", status1.Int());

		User::WaitForRequest(status2);

		}

	RDebug::Printf("Client: status1 %d status2 %d OOC %d", status1.Int(), status2.Int(), ooc);

	test_KErrNone(status1.Int());

	test_KErrNone(status2.Int());

	test_Equal(ooc, mode > 0);

	if (mode)

		session2.Request(CMySession::EFinish);

	session1.Request(CMySession::EFinish);

	RDebug::Printf("Client: exit");

	return KErrNone;

	}

void TestSequential()

	{

	TRequestStatus status;

	RDebug::Printf("Main: start server");

	RThread serverThread;

	test_KErrNone(serverThread.Create(_L("server"), RunServerCode, KHeapSize, NULL, (TAny*)0));

	serverThread.Rendezvous(status);

	serverThread.Resume();

	User::WaitForRequest(status);

	test_KErrNone(status.Int());

	RDebug::Printf("Main: start client");

	RThread clientThread;

	test_KErrNone(clientThread.Create(_L("client"), RunClientCode, KHeapSize, NULL, (TAny*)0));

	clientThread.Logon(status);

	clientThread.Resume();

	User::WaitForRequest(status);

	test_KErrNone(clientThread.ExitReason());

	test_Equal(EExitKill, clientThread.ExitType());

	serverThread.Logon(status);

	User::WaitForRequest(status);

	test_KErrNone(serverThread.ExitReason());

	test_Equal(EExitKill, serverThread.ExitType());

	User::After(1000);

	RDebug::Printf("Main: exit");

	}

void TestParallel()

	{

	TRequestStatus status;

	RDebug::Printf("Main: start master server");

	RThread masterThread;

	test_KErrNone(masterThread.Create(_L("master"), RunServerCode, KHeapSize, NULL, (TAny*)1));

	masterThread.Rendezvous(status);

	masterThread.Resume();

	User::WaitForRequest(status);

	test_KErrNone(status.Int());

	RDebug::Printf("Main: start slave server");

	RThread slaveThread;

	test_KErrNone(slaveThread.Create(_L("slave"), RunServerCode, KHeapSize, NULL, (TAny*)2));

	slaveThread.Rendezvous(status);

	slaveThread.Resume();

	User::WaitForRequest(status);

	test_KErrNone(status.Int());

	RDebug::Printf("Main: start client");

	RThread clientThread;

	test_KErrNone(clientThread.Create(_L("client2"), RunClientCode, KHeapSize, NULL, (TAny*)3));

	clientThread.Logon(status);

	clientThread.Resume();

	User::WaitForRequest(status);

	test_KErrNone(clientThread.ExitReason());

	test_Equal(EExitKill, clientThread.ExitType());

	slaveThread.Logon(status);

	User::WaitForRequest(status);

	test_KErrNone(slaveThread.ExitReason());

	test_Equal(EExitKill, slaveThread.ExitType());

	masterThread.Logon(status);

	User::WaitForRequest(status);

	test_KErrNone(masterThread.ExitReason());

	test_Equal(EExitKill, masterThread.ExitType());

	User::After(1000);

	RDebug::Printf("Main: exit");

	}

GLDEF_C TInt E32Main()

//

// Main

//

	{	

	test.Title();

	__UHEAP_MARK;

	test.Start(_L("Test threaded server support"));

	test.Next(_L("Test two sessions to the same server (single-threaded)"));

	TestSequential();

	test.Next(_L("Test two sessions to the same server (multi-threaded)"));

	TestParallel();

	test.End();

	__UHEAP_MARKEND;

	return(KErrNone);

	}