// Copyright (c) 1997-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_killer.cpp

// Derived from T_MESSGE, tests threads killing each other, not cleaning up etc.

// 

//

#include <e32std.h>

#include <e32std_private.h>

#include <e32math.h>

#include <e32test.h>

#include <e32ver.h>

#include <e32panic.h>

const TInt KHeapMinSize=0x1000;

const TInt KHeapMaxSize=0x1000;

class CTestServer : public CServer2

	{

public:

	IMPORT_C CTestServer(TInt aPriority);

	enum TPanicType{

		EInt0Error=1, EInt1Error, EInt2Error, EInt3Error,

		EPtr0Error, EPtr1Error, EPtr2Error, EPtr3Error,

		ECreateNameError, ENewSessionError,

		EClientError, EWatcherError, EKilled

		};

	static void Panic(TPanicType aReason);

protected:

	//override the pure virtual functions:

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

	};

class CTestSession : public CSession2

	{

public:

	enum {EStop,ETestInt,ETestPtr,ETestClient,ETestComplete,ETestPtrComplete,ETestCompletePanic,ETestOtherSession,ETestCompleteAfter};

//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 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& aArgs)

		{

		return (SendReceive(aFunction, aArgs));

		}

	void PublicSendReceive(TInt aFunction, const TIpcArgs& aArgs, TRequestStatus& aStatus)

		{

		SendReceive(aFunction, aArgs, aStatus);

		}

	TInt PublicCreateSession(const TDesC& aServer,TInt aMessageSlots)

		{

		return (CreateSession(aServer,User::Version(),aMessageSlots));

		}

	};

//=========================================================================

// CTestServer functions

//

// Constructor - sets name

//

	: CServer2(aPriority)

	{}

//

// 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, killerThread;

void CTestServer::Panic(TPanicType aReason)	  //static function

	{

	clientThread.Kill(KErrNone);

	User::Panic(_L("CTestServer"),aReason);

	}

// CTestSession funtions

RSession session, otherSession;

RSemaphore sem;

const TInt KTestInt[] = {-3866,30566,0,200};

const TIpcArgs KIpcArgInt(-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};

const TIpcArgs KIpcArgPtr(&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);

	}

TFullName clientName;

TInt clientNumber;

void CTestSession::TestClient(const RMessage2& aMessage)

//

// Tests Client()

//

	{

	// Under WINS, thread names are not prefixed with the process name

	TFullName n=RProcess().Name();

	n+=_L("::");

	n+=clientName;

	RThread client;

	TInt r = aMessage.Client(client);

	if (r != KErrNone || client.FullName().CompareF(n)!=0)

		{

		client.Close();

		clientThread.Kill(0);

		CTestServer::Panic(CTestServer::EClientError);

		}

	client.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;

	if (++count2==5)

		for(count2=4; count2>=0; count2--)

			messagePtrs[count2].Complete(10-count2*2);

	}

//

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

		default:

			r=KErrNotSupported;

		}						  

 	aMessage.Complete(r);

	}

void CMyActiveScheduler::Error(TInt anError) const

//

// Virtual error handler

//

	{

	User::Panic(_L("CMyActiveScheduer::Error"), anError);

	}

LOCAL_D TInt64 TheSeed;

GLDEF_C TInt Random(TInt aRange)

	{

	return (Math::Rand(TheSeed)>>11)%aRange;

	}

TInt KillerThread(TAny*)

//

// Wait a random time and then kill the client thread

//

    {

    RTest test(_L("T_KILLER...Killer"));

    TRequestStatus clientStatus;

    TInt delay=0;

    test.Title();

    test.Start(_L("Logon to client"));

    clientThread.Logon(clientStatus);

    test.Next(_L("Delay...."));

    for (;;)

	{

	User::After(1000);

	delay++;

	if (clientStatus!=KRequestPending)

	    return KErrNone;	// client has already finished

	if (Random(1000)<1)

	    break;		// Time to die!

	}

    test.Printf(_L("Kill client after %d ms\n"), delay);

    clientThread.Kill(CTestServer::EKilled);

    test.Close();	// close console immediately

    // test.End();	// "Press ENTER to exit"

    return KErrNone;

    }

TInt ClientThread(TAny* aPtr)

//

// Passed as the first client thread - signals the server to do several tests

//

    {

    RTest test(_L("T_KILLER...client"));

    TInt repeat = (TInt)aPtr;

    test.Title(); 

    test.Start(_L("Client thread"));

    do 

		{

		test.Next(_L("Client loop"));

		test.Start(_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, KIpcArgInt);

		test(r==KErrNone);

		test.Next(_L("Signal to test Ptr0/1/2/3()"));

		r=session.PublicSendReceive(CTestSession::ETestPtr, KIpcArgPtr);

		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("Try another session"));

		r=otherSession.PublicCreateSession(_L("CTestServer"),5);

		test(r==KErrNone);

		r=otherSession.PublicSendReceive(CTestSession::ETestOtherSession, TIpcArgs());

		test(r==KErrNone);

//	test.Next(_L("Try to disconnect"));

//	r=session.PublicSendReceive(RMessage2::EDisConnect,NULL);//Panics user

//	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.End();

		}

	while (--repeat > 0);

    test.Start(_L("Signal to stop ActiveScheduler"));

    session.PublicSendReceive(CTestSession::EStop, TIpcArgs());			

    test.Close();

    return (KErrNone);

    }

TInt ServerThread(TAny*)

//

// Passed as the server thread in 2 tests - sets up and runs CTestServer

//

	{

	RTest test(_L("T_KILLER...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(_L("CTestServer"));//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_KILLER 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());

	RThread client1;

	test(message1.Client(client1) == KErrNone);

	RThread client2;

	test(message2.Client(client2) == KErrNone);

 	test(client1.Handle()==client2.Handle());

	client2.Close();

	test.Next(_L("Assignment operator"));

	RMessage2 message3(*(RMessage2*) SimpleRMessage);// Pass some rubbish so message3 is definitely != message1

	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());

	RThread client3;

	test(message3.Client(client3) == KErrNone);

 	test(client1.Handle()==client3.Handle());

	client3.Close();

	client1.Close();

	test.End();

	}

GLDEF_C TInt E32Main()

	{

	TInt err;

#ifdef __WINS__

	User::SetDebugMask(0xa04);  // KSERVER+KTHREAD+KLOGON

#endif

	test.Title();

	test.Next(_L("Sending messages between two threads"));

	TRequestStatus clientStat,killerStat,serverStat;

	TInt exitType;

	test.Start(_L("Create and start the server"));

	sem.CreateLocal(0);

	serverThread.Create(_L("Server Thread"),ServerThread,KDefaultStackSize,KHeapMinSize,KHeapMaxSize,NULL);

	serverThread.Logon(serverStat);