// Copyright (c) 2006-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\emul\t_emulex.cpp
// Test various things to do with exceptions on the emulator
// 
//

#include <e32test.h>

#define WIN32_LEAN_AND_MEAN
#define _WIN32_WINNT 0x0400
#include <windows.h>
#include <winnt.h>

#define TestSuccess(r) { TInt _r = (r); if (_r != KErrNone) { test.Printf(_L("Error code: %d"), _r); test(EFalse); } }

// LONG CALLBACK VectoredHandler(PEXCEPTION_POINTERS ExceptionInfo);
// PVOID AddVectoredExceptionHandler(ULONG FirstHandler, PVECTORED_EXCEPTION_HANDLER VectoredHandler);
// ULONG RemoveVectoredExceptionHandler(PVOID Handler);

typedef TInt (WINAPI TVectoredHandler)(PEXCEPTION_POINTERS aExceptionInfo);
typedef TAny* (WINAPI TAddVectoredHandlerFunc)(TBool aFirstHandler, TVectoredHandler aHandler);
typedef TUint (WINAPI TRemoveVectoredHandlerFunc)(TAny* aHandler);

RTest test(_L("T_EMULEX"));

const TInt KSpinIterations = 5000;

TInt TestIterations = 500;
volatile TInt ExceptionCount;
volatile TInt SpinCount;
TAddVectoredHandlerFunc* AddVEHFunc;
TRemoveVectoredHandlerFunc* RemoveVEHFunc;

TBool LookupVEHFunctions()
//
// Look up VEH functions, return EFalse if not supported
//
	{
	HMODULE hLibrary = GetModuleHandleA("kernel32.dll");
	test(hLibrary != NULL);

	AddVEHFunc = (TAddVectoredHandlerFunc*)GetProcAddress(hLibrary, "AddVectoredExceptionHandler");
	RemoveVEHFunc = (TRemoveVectoredHandlerFunc*)GetProcAddress(hLibrary, "RemoveVectoredExceptionHandler");

	return AddVEHFunc && RemoveVEHFunc;
	}

TInt WINAPI VectoredHandler(PEXCEPTION_POINTERS /*ExceptionInfo*/)
	{
	for (TInt i = 0 ; i < KSpinIterations ; ++i)
		++SpinCount; // spin 
	return EXCEPTION_CONTINUE_SEARCH;
	}

TInt CppExceptionThreadFunction(TAny* /*aParam*/)
	{
	for (;;)
		{
		for (TInt i = 0 ; i < KSpinIterations ; ++i)
			++SpinCount; // spin
		try
			{
			throw 23;
			}
		catch(TInt /*x*/)
			{
			++ExceptionCount;
			}
		}
	}

TInt CppExceptionThreadFunction2(TAny* /*aParam*/)
	{
	for (;;)
		{
		for (TInt i = 0 ; i < KSpinIterations ; ++i)
			++SpinCount; // spin
		try
			{
			throw 23;
			}
		catch(TInt /*x*/)
			{
			User::Heap();
			++ExceptionCount;
			}
		}
	}

void HwExceptionHandler(TExcType /*aType*/)
	{
	++ExceptionCount;
	}

TInt HwExceptionThreadFunction(TAny* /*aParam*/)
	{
	User::SetExceptionHandler(HwExceptionHandler, KExceptionInteger);

	volatile int zero = 0, out;
	for (;;)
		{
		for (TInt i = 0 ; i < KSpinIterations ; ++i)
			++SpinCount; // spin
		out = 1 / zero;
		}
	}

void CreateTestThread(RThread& aThread, TThreadFunction aFunc)
	{
	TInt r = aThread.Create(_L("exceptionThread"),
							aFunc,
							KDefaultStackSize,
							NULL,
							NULL);
	test(r == KErrNone);
	}

void Test1(TThreadFunction aFunc)
	{
	for (TInt i = 0 ; i < TestIterations ; ++i)
		{
		RThread thread;
		CreateTestThread(thread, aFunc);
		ExceptionCount = 0;
		thread.SetPriority(EPriorityLess);
		thread.Resume();
		while (ExceptionCount == 0)
			User::AfterHighRes(1);

		test.Printf(_L("Iteration %d: ExceptionCount == %d\n"), i, ExceptionCount);

		TRequestStatus status;
		thread.Logon(status);
		thread.Kill(KErrGeneral);
		User::WaitForRequest(status);
		CLOSE_AND_WAIT(thread);
		}
	}

void Test2(TThreadFunction aFunc)
	{
	TAny* handle = (*AddVEHFunc)(ETrue, VectoredHandler);

	RThread thread;
	CreateTestThread(thread, aFunc);
	ExceptionCount = 0;
	SpinCount = 0;
	thread.Resume();

	for (TInt i = 0 ; i < TestIterations ; ++i)
		{
		ExceptionCount = 0;
		thread.SetPriority(EPriorityNormal);
		while (ExceptionCount == 0)
			;
		thread.SetPriority(EPriorityLess);
		
		test.Printf(_L("Iteration %d: ExceptionCount == %d\n"), i, ExceptionCount);

		// test exception handling doesn't deadlock
		try { throw 13; } catch (TInt /*x*/) { }
		}

	TRequestStatus status;
	thread.Logon(status);
	thread.Kill(KErrGeneral);
	User::WaitForRequest(status);
	CLOSE_AND_WAIT(thread);

	(*RemoveVEHFunc)(handle);
	}

void ParseCommandLine()
	{
	TBuf<128> buf;
	User::CommandLine(buf);
	if (buf != KNullDesC)
		{
		TLex lex(buf);
		lex.Val(TestIterations);
		}
	}

TInt E32Main()
	{
	test.Title();
	test.Start(_L("T_EMULEX"));

	ParseCommandLine();

	test.Next(_L("Test killing a thread while it's taking a hardware exception"));
	Test1(HwExceptionThreadFunction);

	test.Next(_L("Test killing a thread while it's taking a C++ exception"));
	Test1(CppExceptionThreadFunction);

	test.Next(_L("Test killing a thread while it's taking a C++ exception, and subsequently calling into the kernel"));
	Test1(CppExceptionThreadFunction2);
	
	TBool vehSupported = LookupVEHFunctions();
	if (vehSupported)
		{
		test.Next(_L("Test thread preemption while taking a hardware exception"));
		Test2(HwExceptionThreadFunction);

		test.Next(_L("Test thread preemption while taking a C++ exception"));
		Test2(CppExceptionThreadFunction);
		}
		
	test.End();
	test.Close();
	return(0);
	}