// 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_thread2.cpp

// More tests the RThread class (T_THREAD was getting too big)

// Overview:

// Tests the RThread class

// API Information:

// RThread

// Details:

// - Test running a thread that suspends itself.  This activity has 

// deadlocked the Emulator in the past.

// - Test a server panicking a thread in another process that's already exited

// 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>

const TInt KHeapSize=0x200;

_LIT(KMyName, "T_THREAD2");

LOCAL_D RTest test(KMyName);

LOCAL_C TInt SuspendThread(TAny*)

	{

	RThread().Suspend();

	return(KErrNone);

	}

LOCAL_D void TestSelfSuspend(TOwnerType anOwnerType)

//

// Test running a thread that suspends itself.  This activity has 

// deadlocked the Emulator in the past

//

	{

	RThread suspendThread;

	TInt r;

	TRequestStatus s;

	TInt jit=User::JustInTime();

	test.Start(_L("Test running a thread which suspends itself"));

	test.Next(_L("Create the thread"));

	r=suspendThread.Create(KNullDesC,SuspendThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)NULL,anOwnerType);

	test(r==KErrNone);

	suspendThread.Logon(s);

	suspendThread.Resume();

	test.Next(_L("Wait a second"));

	User::After(1000000);

	User::SetJustInTime(EFalse);

	suspendThread.Panic(_L("FEDCBA9876543210fedcba"),999);

	User::WaitForRequest(s);

	User::SetJustInTime(jit);

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

	test(suspendThread.ExitReason()==999);

	test(suspendThread.ExitCategory()==_L("FEDCBA9876543210"));

	CLOSE_AND_WAIT(suspendThread);

	test.End();

	}

_LIT(KServerName,"MyServer");

RSemaphore TheSemaphore;

class CMySession : public CSession2

	{

public:

	CMySession();

	virtual void ServiceL(const RMessage2& aMessage);

	};

class CMyServer : public CServer2

	{

public:

	CMyServer();

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

	};

class RSession : public RSessionBase

	{

public:

	TInt Open();

	void Test(TRequestStatus& aStatus);

	};

CMySession::CMySession()

	{

	}

CMyServer::CMyServer() :

	CServer2(0)

	{

	}

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

	{

	RDebug::Printf("Server: create session");

	return new (ELeave) CMySession;

	}

void CMySession::ServiceL(const RMessage2& aMessage)

	{

	RDebug::Printf("Server: receive message");

	TheSemaphore.Wait();

	RDebug::Printf("Server: panic client");

	aMessage.Panic(_L("!!!"), 1);

	CActiveScheduler::Stop();

	}

TInt RSession::Open()

	{

	return CreateSession(KServerName, TVersion());

	}

void RSession::Test(TRequestStatus& aStatus)

	{

	RDebug::Printf("Client: send message");

	SendReceive(0, TIpcArgs(), aStatus);

	RDebug::Printf("Client: send done");

	}

TInt ServerThread(TAny*)

	{

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

	CTrapCleanup* cleanup = CTrapCleanup::New();

	CActiveScheduler* pR = new CActiveScheduler;

	if (pR == NULL)

		return KErrNoMemory;

	CActiveScheduler::Install(pR);

	CMyServer* pS = new CMyServer;

	if (pS == NULL)

		return KErrNoMemory;

	TInt r = pS->Start(KServerName);

	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;

	}

TInt ClientProcess()

	{

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

	RSession session;

	session.Open();

	TRequestStatus status;

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

	session.Test(status);

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

	return KErrNone;

	}

void TestServerPanic()

	{

	TRequestStatus status;

	test_KErrNone(TheSemaphore.CreateLocal(0));

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

	RThread serverThread;

	test_KErrNone(serverThread.Create(_L("server"), ServerThread, 4096, NULL, NULL));

	serverThread.Rendezvous(status);

	serverThread.Resume();

	User::WaitForRequest(status);

	test_KErrNone(status.Int());

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

	RProcess clientProcess;

	test_KErrNone(clientProcess.Create(KMyName, _L("client")));

	clientProcess.Resume();

	clientProcess.Logon(status);

	User::WaitForRequest(status);

	test_KErrNone(clientProcess.ExitReason());

	test_Equal(EExitKill, clientProcess.ExitType());

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

	TheSemaphore.Signal();

	RDebug::Printf("Main: wait for server to exit");

	serverThread.Logon(status);

	User::WaitForRequest(status);

	test_KErrNone(serverThread.ExitReason());

	test_Equal(EExitKill, serverThread.ExitType());

	User::After(1);

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

	}

GLDEF_C TInt E32Main()

//

// Main

//

	{	

	if (User::CommandLineLength())

		return ClientProcess();

	test.Title();

	__UHEAP_MARK;

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

	test.Next(_L("Test a thread suspending itself"));

	TestSelfSuspend(EOwnerProcess);

	TestSelfSuspend(EOwnerThread);

	test.Next(_L("Test a server panicking a thread in another process that's already exited"));

	TestServerPanic();

	test.End();

	__UHEAP_MARKEND;

	return(KErrNone);

	}