// 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);
	}