// Copyright (c) 2002-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_emul.cpp

// Overview:

// Test the mechanism to escape threads from the emulator in order

// to block on Windows objects

// Test launching processes doesn't leak windows TLS indices

// API Information:

// Emulator

// Details:

// - Test the mechanism to escape threads from the emulator in order

// to block on Windows objects:

// - test escape and re-enter mechanism.

// - block on Windows in EPOC thread and escaped EPOC thread.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#define __E32TEST_EXTENSION__

#include <f32file.h>

#include <e32atomics.h>

#include <e32std.h>

#include <e32std_private.h>

#include <e32ldr.h>

#include <e32ldr_private.h>

#include "e32test.h"

#include "emulator.h"

#include "t_emul.h"

#define WIN32_LEAN_AND_MEAN

#pragma warning( disable : 4201 ) // nonstandard extension used : nameless struct/union

#include <windows.h>

#pragma warning( default : 4201 ) // nonstandard extension used : nameless struct/union

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

static TInt ELock;

static HANDLE ESemaphore;

static TInt EResult;

TInt EscapeTimeoutThread(TAny*)

	{

	User::After(1000000);

	if (__e32_atomic_add_ord32(&ELock, 1) == 0)

		{

		EResult=KErrTimedOut;

		ReleaseSemaphore(ESemaphore,1,NULL);

		}

	return KErrNone;

	}

TInt EscapeSignalThread(TAny*)

	{

	if (__e32_atomic_add_ord32(&ELock, 1) == 0)

		{

		EResult=KErrNone;

		ReleaseSemaphore(ESemaphore,1,NULL);

		}

	return KErrNone;

	}

TInt DoTestEscape(TBool aDoEscape)

//

// Test the mechanism to escape threads from the emulator in order to block on Windows objects

//

	{

	ELock = 0;

	EResult = KRequestPending;

	ESemaphore = CreateSemaphoreA(NULL,0,1,NULL);

	test (ESemaphore != NULL);

	RThread t1,t2;

	TRequestStatus s1,s2;

	TInt r = t1.Create(KNullDesC,&EscapeSignalThread,0x1000,NULL,NULL);

	test (r == KErrNone);

	t1.SetPriority(EPriorityLess);

	t1.Logon(s1);

	t1.Resume();

	r = t2.Create(KNullDesC,&EscapeTimeoutThread,0x1000,NULL,NULL);

	test (r == KErrNone);

	t2.SetPriority(EPriorityMore);

	t2.Logon(s2);

	t2.Resume();

//

	if (aDoEscape)

		Emulator::Escape();

	r = WaitForSingleObject(ESemaphore,INFINITE);

	if (aDoEscape)

		Emulator::Reenter();

	test (r==WAIT_OBJECT_0);

//

	r = EResult;

	t1.Kill(0);

	t2.Kill(0);

	t1.Close();

	t2.Close();

	User::WaitForRequest(s1);

	User::WaitForRequest(s2);

//

	CloseHandle(ESemaphore);

	return r;

	}

void TestEscape()

//

// Test the mechanism to escape threads from the emulator in order to block on Windows objects

//

	{

	test.Start(_L("Test escape and reenter mechanism"));

	for (TInt i = 0;i<10000;++i)

		{

		Emulator::Escape();

		if (i%100 == 0)

			Sleep(10);

		Emulator::Reenter();

		}

	test.Next(_L("Block on Windows in EPOC thread"));

	TInt r = DoTestEscape(EFalse);

	test (r == KErrTimedOut);

	test.Next(_L("Block on Windows in escaped EPOC thread"));

	r = DoTestEscape(ETrue);

	test (r == KErrNone);

	test.End();

	}

TInt CountRemainingTlsIndicies()

	{

	const TInt KMax = 2000;

	TBool allocated[KMax];

	memclr(allocated, sizeof(TBool) * KMax);

	TInt i;

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

		{

		TInt index = TlsAlloc();

		if (index == TLS_OUT_OF_INDEXES)

			break;

		test(index >= 0 && index < KMax);

		allocated[index] = ETrue;

		}

	for (TInt j = 0 ; j < KMax ; ++j)

		{

		if (allocated[j])

			test(TlsFree(j));

		}

	return i;

	}

void RunSlave(TSlaveAction aAction)

	{

	RProcess p;

	TBuf<8> arg;

	arg.Format(_L("%d"), aAction);

	test_KErrNone(p.Create(KTEmulSlaveName, arg));

	p.Resume();

	TRequestStatus status;

	p.Logon(status);

	User::WaitForRequest(status);

	test_KErrNone(status.Int());

	test_Equal(EExitKill, p.ExitType());

	p.Close();

	}

void TestRuntimeCleanup()

	{

	test.Start(_L("Test Codewarrior runtime library is correctly cleaned up"));

	TInt initIndicies = CountRemainingTlsIndicies();

	test.Next(_L("Test creating a process doesn't leak windows TLS indicies"));

	RunSlave(ESlaveDoNothing);

	test_Equal(initIndicies, CountRemainingTlsIndicies());

	test.Next(_L("Test leaving in an exe doesn't leak windows TLS indicies"));

	RunSlave(ESlaveTrapExceptionInExe);

	test_Equal(initIndicies, CountRemainingTlsIndicies());

	test.Next(_L("Test leaving in a linked DLL doesn't leak windows TLS indicies"));

	RunSlave(ESlaveTrapExceptionInLinkedDll);

	test_Equal(initIndicies, CountRemainingTlsIndicies());

	test.Next(_L("Test leaving in a loaded DLL doesn't leak windows TLS indicies"));

	RunSlave(ESlaveTrapExceptionInLoadedDll);

	test_Equal(initIndicies, CountRemainingTlsIndicies());

	test.Next(_L("Test cleanup doesn't happen while DLL still loaded"));

	RLibrary l;

	test_KErrNone(l.Load(KTEmulDll2Name));

	RunSlave(ESlaveTrapExceptionInLoadedDll);

	TInt midCount = CountRemainingTlsIndicies();

	test(initIndicies > midCount);

	test.Next(_L("Test previous detach doesn't cause runtime to be re-initalised"));

	TTrapExceptionInDllFunc func =

		(TTrapExceptionInDllFunc)l.Lookup(KTrapExceptionInDllOrdinal);

	test_NotNull(func);

	func();

	test_Equal(midCount, CountRemainingTlsIndicies());	

	l.Close();

	test_Equal(initIndicies, CountRemainingTlsIndicies());

	test.End();

	}

void DoSomething2L()

	{

	test.Printf(_L("@\n"));

	}

void DoSomething1L()

	{

	TInt i = -1, j = 1;

	for ( ; ; )

		{

		i++;

		//DoSomething2L() must only be called once , else we know that trap mechanism didn't work 

		test( i<2);

		if (i == j)  

			{

			User::Leave(KErrNotFound);

			}

		TRAP_IGNORE(DoSomething2L());

		TRAPD(errr, DoSomething2L());

		TInt r;

		TRAP(r, DoSomething2L());

		}

	}

void LeaveIfArgIsTwo(TInt aCall);

class CFred : public CBase

{

	public:

static CFred* NewLC();

	CFred();

	~CFred();

};

void DoSomething3L()

	{

	// Push something on the cleanup stack so we can see whyen it gets cleaned up.

	CFred *fred = CFred::NewLC();

	TInt beforeFunc=0;

	TInt betweenFuncAndTRAPD=0;

	TInt afterTRAPD=0;

	for(TInt loop=1; loop<=2; ++loop)

		{

		++beforeFunc;

		test.Printf(_L("Before LeaveIfArgIsTwo()\n"));

		// The first time around the loop, this function call works.

		// The second time, it leaves KErrGeneral

		// Then when TRAP mechanism isn't working properly the emulator (correctly) 

		// would delete fred, and (incorrectly) jump to the line

		// just after the TRAPD call a few lines further down the file!

		LeaveIfArgIsTwo(loop);

		++betweenFuncAndTRAPD;

		test.Printf(_L("Between LeaveIfArgIsTwo() and TRAPD\n"));

		TRAPD(err, test.Printf(_L("Inside TRAPD\n") ) );

		// It should only be possible to reach this section of code by executing all the lines

		// between LeaveIfArgIsTwo and here.

		++afterTRAPD;

		}

	// Should NEVER get here because LeaveIfArgIsTwo did a leave the second time around the loop

	test.Printf(_L("After loop (should NEVER get here) -\n\

					beforeFunc %d\n\

					betweenFuncAndTRAPD %d\n\

					afterTRAPD %d\n"),

					beforeFunc, betweenFuncAndTRAPD, afterTRAPD);

	test.Printf(_L("It should be impossible for afterTRAPD to be larger than betweenFuncAndTRAPD\n"));

	test(afterTRAPD <= betweenFuncAndTRAPD);

	// Cleanup our cleanup stack. 

	CleanupStack::PopAndDestroy(&fred);

	}

void LeaveIfArgIsTwo(TInt aCall)

	{

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

	if(aCall == 2)

		{

		User::Leave(KErrGeneral);

		}

	}

CFred *CFred::NewLC()

	{

	CFred *self = new(ELeave) CFred;

	CleanupStack::PushL(self);

	return self;

	}

CFred::CFred()

	{

	test.Printf(_L("CFred %x\n"), this);

	}

CFred::~CFred()

	{

	test.Printf(_L("~CFred %x\n"), this);

	}

GLDEF_C TInt E32Main()

//

//

//

	{

	test.Title();

	test.Start(_L("Starting tests ..."));

	// Turn off evil lazy dll unloading

	RLoader l;

	test(l.Connect()==KErrNone);

	test(l.CancelLazyDllUnload()==KErrNone);

	l.Close();

	TestEscape();

#ifdef __CW32__

	TestRuntimeCleanup();

#endif

	// The following tests were added to test that the TRAP mechanism works correctly in case of

	// nested TRAP's. A compiler bug (winscw) caused the following tests to fail, since the wrong 

	// trap handler would be invoked, when User::Leave() was called.

	test.Next(_L("Check User::Leave is handled by the correct TRAP handler when nested TRAPs are present - Simple scenario\n")); 

 	TRAPD(err, DoSomething1L());

	test(err == KErrNotFound);

	test.Next(_L("Check User::Leave is handled by the correct TRAP handler when nested TRAPs are present - Cleanup stack scenario\n")); 		

	__UHEAP_MARK;

	CTrapCleanup* tc = CTrapCleanup::New();

	if (tc == 0) return KErrNoMemory;

	TRAPD(err2, DoSomething3L());

	test(err2==KErrGeneral);	

	delete tc;

	__UHEAP_MARKEND;

	test.End();

	test.Close();

	return KErrNone;

	}