// Copyright (c) 1994-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_trap.cpp

// Overview:

// Test TRAP, Leave and Assert

// API Information:

// TRAP, User::Leave, __ASSERT_DEBUG_NO_LEAVE, __ASSERT_ALWAYS_NO_LEAVE

// Details:

// - Test TRAP macro works as expected.

// - Test User::Leave works as expected including leave from

// within nested calls.

// - Verify that a leave without a TRAP causes the thread to panic.

// - Create a thread that asserts and verify the exit type and other

// results are as expected.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

#include <e32panic.h>

const TInt KLeaveVal=1111;

const TInt KUnLeaveVal=2222;

const TInt KRecursiveUnLeaveVal=3333;

const TInt KRecursiveSingleLeaveVal=4444;

const TInt KMaxDepth=20;

//#define __TEST_BREAKPOINT_IN_TRAP__

LOCAL_D RTest test(_L("T_TRAP"));

LOCAL_C TInt UnLeaveFunction(void)

	{

	return(KUnLeaveVal);

	}

LOCAL_C TInt LeaveFunction(void)

	{

	User::Leave(KLeaveVal);

	return(0);

	}

LOCAL_C TInt RecursiveUnLeave(TInt level)

	{

	if (level==0)

		return(KRecursiveUnLeaveVal);

	else

		return(RecursiveUnLeave(--level));

	}

LOCAL_C TInt RecursiveSingleLeave(TInt level)

	{

	if (level==0)

		User::Leave(KRecursiveSingleLeaveVal);

	else

		RecursiveSingleLeave(--level);

	return(0);

	}

LOCAL_C TInt RecursiveMultiLeave1(TInt level)

	{

	TInt ret=0;

	TRAP(ret,{if (level==0)	User::Leave(level);	else ret=RecursiveMultiLeave1(level-1);	test(EFalse);})

	test(ret==level);

	User::Leave(level+1);

	return(0);

	}

LOCAL_C TInt RecursiveMultiLeave2(TInt level)

	{

	if (level==0)

		return(1);

	TInt ret=0;

	TRAP(ret,ret=RecursiveMultiLeave2(level-1))

	test(ret==level);

	User::Leave(level+1);

	return(0);

	}

LOCAL_C TInt doTrap(TInt aVal)

//

// Nest trap function.

//

	{

	if (aVal)

		{

		TInt j=(-1);

		TRAP(j,j=doTrap(aVal-1))

		test(j==aVal);

		}

	return(aVal+1);

	}

#ifdef __TEST_BREAKPOINT_IN_TRAP__

void bkpt()

	{

	__BREAKPOINT();

	}

#endif

LOCAL_C void doLeave(TInt aLevel,TInt aVal)

//

// Nest trap with leave function.

//

	{

	if (aLevel)

		doLeave(aLevel-1,aVal);

	else

		User::Leave(aVal);

	}

LOCAL_C void testTrap()

//

// Test trap functions O.K.

//

	{

	test.Start(_L("Trap level 1"));

//

	TInt i=2;

	TRAP(i,i=1);

	test(i==1);

#ifdef __TEST_BREAKPOINT_IN_TRAP__

	TRAP(i,bkpt());

	TRAP(i,TRAP(i,bkpt()));

#endif

//

	test.Next(_L("Trap level n"));

	for (i=1;i<KMaxDepth;i++)

		test(doTrap(i)==(i+1));

//

	test.End();

	}

LOCAL_C void testLeave()

//

// Test leave functions O.K.

//

	{

	test.Start(_L("Leave level 1"));

//

	TInt i=0;

	TRAP(i,User::Leave(2))

	test(i==2);

//

	test.Next(_L("Leave level 2"));

	i=0;

	TRAP(i,TRAP(i,User::Leave(3)))

	test(i==3);

//

#ifdef __TEST_BREAKPOINT_IN_TRAP__

	TRAP(i,TRAP(i,User::Leave(33)); bkpt())

	test(i==33);

#endif

//

	test.Next(_L("Leave from nested calls"));

	for (i=1;i<KMaxDepth;i++)

		{

		TInt j=(-1);

		TRAP(j,doLeave(i,i))

		test(j==i);

		}

//

	test.End();

	}

LOCAL_C void testMH(void)

	{

	TInt ret=0;

	TRAP(ret,ret=UnLeaveFunction())

	test(ret==KUnLeaveVal);

	TRAP(ret,LeaveFunction())

	test(ret==KLeaveVal);

	TInt i=0;

	for(;i<=KMaxDepth;i++)

		{

		TRAP(ret,ret=RecursiveUnLeave(i))

		test(ret==KRecursiveUnLeaveVal);

		}

	for(i=0;i<=KMaxDepth;i++)

		{

		TRAP(ret,ret=RecursiveSingleLeave(i))

		test(ret==KRecursiveSingleLeaveVal);

		}

	for(i=0;i<=KMaxDepth;i++)

		{

		TRAP(ret,ret=RecursiveMultiLeave1(i))

		test(ret==i+1);

		}

	for(i=0;i<=KMaxDepth;i++)

		{

		TRAP(ret,ret=RecursiveMultiLeave2(i))

		test(ret==i+1);

		}

	}

TInt LeaveNoTrapThread(TAny*)

	{

	User::Leave(KErrGeneral);

	return KErrNone;

	}

void TestLeaveNoTrap()

	{

	RThread thread;

	TInt r=thread.Create(_L("Leave without Trap thread"),LeaveNoTrapThread,0x1000,&User::Allocator(),NULL);

	test(r==KErrNone);

	TRequestStatus stat;

	thread.Logon(stat);

	test(stat==KRequestPending);

	TBool justInTime=User::JustInTime();

	User::SetJustInTime(EFalse);

	thread.Resume();

	User::WaitForRequest(stat);

	User::SetJustInTime(justInTime);

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

	test(thread.ExitReason()==EUserLeaveWithoutTrap);

	test(thread.ExitCategory()==_L("USER"));

	CLOSE_AND_WAIT(thread);

	}

enum TAssertTest

	{

	EAssertTest_Debug = 1,

	EAssertTest_Leave = 2,

	EAssertTest_Ret = 4,

	};

TInt AssertThread(TAny* a)

	{

	TInt f = (TInt)a;

	TInt r = f | EAssertTest_Ret;

	if (f & EAssertTest_Leave)

		{

		if (f & EAssertTest_Debug)

			{

			__ASSERT_DEBUG_NO_LEAVE(User::Leave(r));

			}

		else

			{

			__ASSERT_ALWAYS_NO_LEAVE(User::Leave(r));

			}

		}

	else

		{

		if (f & EAssertTest_Debug)

			{

			__ASSERT_DEBUG_NO_LEAVE(RThread().Terminate(r));

			}

		else

			{

			__ASSERT_ALWAYS_NO_LEAVE(RThread().Terminate(r));

			}

		}

	return r;

	}

TInt _AssertThread(TAny* a)

	{

	TInt s=0;

	TRAP_IGNORE(s=AssertThread(a));

	return s;

	}

void TestAssert(TInt aTest)

	{

	test.Printf(_L("Assert %d\n"), aTest);

	RThread t;

	TInt r = t.Create(_L("assert"), &_AssertThread, 0x1000, NULL, (TAny*)aTest);

	test(r==KErrNone);

	TRequestStatus s;

	t.Logon(s);

	test(s==KRequestPending);

	TBool jit = User::JustInTime();

	User::SetJustInTime(EFalse);

	t.Resume();

	User::WaitForRequest(s);

	User::SetJustInTime(jit);

	TInt exitType = t.ExitType();

	TInt exitReason = t.ExitReason();

	const TDesC& exitCat = t.ExitCategory();

	CLOSE_AND_WAIT(t);

	test.Printf(_L("Exit %d,%d,%S\n"), exitType, exitReason, &exitCat);

	if (aTest & EAssertTest_Leave)

		{

		if (aTest & EAssertTest_Debug)

			{

#ifdef _DEBUG

			test(exitType == EExitPanic);

			test(exitReason == EUnexpectedLeave);

#else

			test(exitType == EExitKill);

			test(exitReason == KErrNone);

#endif

			}

		else

			{

			test(exitType == EExitPanic);

			test(exitReason == EUnexpectedLeave);

			}

		}

	else

		{

		test(exitType == EExitTerminate);

		test(exitReason == (aTest | EAssertTest_Ret));

		}

	}

/*============== server for testing exceptions in TRAP implementation ====================*/

#include <e32base.h>

#include <e32base_private.h>

#include "../mmu/mmudetect.h"

const TInt KHeapSize=0x2000;

_LIT(KServerName,"Display");

class CMySession : public CSession2

	{

public:

	CMySession();

	virtual void ServiceL(const RMessage2& aMessage);

	};

class CMyServer : public CServer2

	{

public:

	enum {ERead,EStop};

public:

	CMyServer(TInt aPriority);

	static CMyServer* New(TInt aPriority);

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

	};

class RDisplay : public RSessionBase

	{

public:

	TInt Open();

	void Read(TRequestStatus& aStatus);

	TInt Stop();

	};

LOCAL_D RTest testSvr(_L("T_TRAP Server"));

LOCAL_D RSemaphore client;

LOCAL_D RSemaphore server;

LOCAL_D RDisplay display;

LOCAL_D const RMessage2* message;

// Constructor

//

// 

CMySession::CMySession()

	{}

CMyServer* CMyServer::New(TInt aPriority)

//

// Create a new CMyServer.

//

	{

	return new CMyServer(aPriority);

	}

CMyServer::CMyServer(TInt aPriority)

//

// Constructor.

//

	: CServer2(aPriority)

	{}

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

//

// Create a new client for this server.

//

	{

	return(new(ELeave) CMySession());

	}

void CMySession::ServiceL(const RMessage2& aMessage)

//

// Handle messages for this server.

//

	{

	TInt r=KErrNone;

	switch (aMessage.Function())

		{

	case CMyServer::ERead:

		testSvr.Printf(_L("read message received\n"));

		if (HaveVirtMem())

			{

			message = &aMessage;

			}

		client.Signal();

		server.Wait();

		break;

	case CMyServer::EStop:

		testSvr.Printf(_L("stop message received\n"));

		CActiveScheduler::Stop();

		break;

	default:

		r=KErrNotSupported;

		}

	aMessage.Complete(r);

	}

TInt RDisplay::Open()

//

// Open the server.

//

	{

	return(CreateSession(KServerName,TVersion(),1));

	}

void RDisplay::Read(TRequestStatus& aStatus)

//

// Get session to test CSession2::ReadL.

//

	{

	TBuf<0x10>* bad = (TBuf<0x10> *)(0x30000000);

	SendReceive(CMyServer::ERead, TIpcArgs(bad), aStatus);

	}

TInt RDisplay::Stop()

//

// Stop the server.

//

	{

	return SendReceive(CMyServer::EStop, TIpcArgs());

	}

LOCAL_C TInt serverThreadEntryPoint(TAny*)

//

// The entry point for the server thread.

//

	{

	testSvr.Title();

	testSvr.Start(_L("Create CActiveScheduler"));

	CActiveScheduler* pR=new CActiveScheduler;

	testSvr(pR!=NULL);

	CActiveScheduler::Install(pR);

//

	testSvr.Next(_L("Create CMyServer"));

	CMyServer* pS=CMyServer::New(0);

	testSvr(pS!=NULL);

//

	testSvr.Next(_L("Start CMyServer"));

	TInt r=pS->Start(KServerName);

	testSvr(r==KErrNone);

//

	testSvr.Next(_L("Signal to client that we have started"));

	client.Signal();

//

	testSvr.Next(_L("Start CActiveScheduler"));

	CActiveScheduler::Start();

//

	testSvr.Next(_L("Exit server"));

	delete pS;

	testSvr.Close();

	return(KErrNone);

	}

void CreateServer()

	{

	test.Next(_L("Creating client semaphore"));

	TInt r=client.CreateLocal(0);

	test(r==KErrNone);

//

	test.Next(_L("Creating server semaphore"));

	r=server.CreateLocal(0);

	test(r==KErrNone);

//

	test.Next(_L("Creating server thread"));

	RThread server;

	r=server.Create(_L("Server"),serverThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,NULL);

	test(r==KErrNone);

	server.SetPriority(EPriorityMore);

//

	test.Next(_L("Resume server thread"));

	server.Resume();

	test(ETrue);

//

	test.Next(_L("Wait for server to start"));

	client.Wait();

//

	test.Next(_L("Connect to server"));

	r=display.Open();

	test(r==KErrNone);

	}

void StopServer()

	{

	test.Next(_L("Stop server"));

	TInt r=display.Stop();

	test(r==KErrNone);

//

	test.Next(_L("Close connection"));

	display.Close();

//

	test.Next(_L("Close all"));

	server.Close();

	client.Close();