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

 	}