// Copyright (c) 2010 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\active\t_schedrace.cpp

// Overview:

// Test for race conditions in emulator scheduler

// API Information:

// RMessage2, RMessagePtr2, RSessionBase, CSession2, CServer2, CPeriodic

// Details:

// - The client and server shuttle messages back and forth with variable timing

// - The client also has a periodic timer, which fires at a random phase relative to the IPC

// - The client should have higher priority than the server

// - The race may occur when the timer interrupt preempts kernel code and disables interrupts

// - The "preempted" code nonetheless runs and sees the "impossible" disabled interrupts

// - The result is a precondition failure at a random point

// Platforms/Drives/Compatibility:

// Will run on all platforms, but precondition failure is expected only on the UDEB emulator.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

#define	__E32TEST_EXTENSION__

#include <e32std.h>

#include <e32std_private.h>

#include <e32math.h>

#include <e32panic.h>

#include <e32svr.h>

#include <e32test.h>

#include <e32ver.h>

_LIT(KServerName, "CTestServer");

const TVersion version(KE32MajorVersionNumber,

					   KE32MinorVersionNumber,

					   KE32BuildVersionNumber);

// Globals for counting number of times each thread/object runs

TInt nIdleCalls, nTimerCalls, nServerCalls;

//

// Server classes and code ...

//

class CTestServer : public CServer2

	{

public:

	IMPORT_C CTestServer(RTest* aTest) : CServer2(EPriorityIdle), iTest(aTest) {};

protected:

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

public:

	RTest* iTest;

	};

class CTestSession : public CSession2

	{

public:

	IMPORT_C void ServiceL(const RMessage2& aMessage);

	enum Action

		{

		EStop = 0,

		EDelay

		};

public:

	RTest* iTest;

	};

//

// CTestServer functions

//

EXPORT_C CSession2* CTestServer::NewSessionL(const TVersion& aVersion, const RMessage2& /*aMessage*/) const

	{

	if (User::QueryVersionSupported(version, aVersion) == EFalse)

		User::Leave(KErrNotSupported);

	CTestSession* newCTestSession = new CTestSession;

	if (newCTestSession == NULL)

		User::Leave(KErrNoMemory);

	newCTestSession->iTest = iTest;

	return newCTestSession;

	}

//

// CTestSession functions

//

EXPORT_C void CTestSession::ServiceL(const RMessage2& aMessage)

	{

	if ((++nServerCalls & 0x03ff) == 10000)		// never true, to suppress message

		iTest->Printf(_L("S:calls: I=%-7d  S=%-7d  T=%-7d  D=%-7d\n"),

				nIdleCalls, nServerCalls, nTimerCalls, aMessage.Int0());

	TInt r = KErrNone;

	TInt i = 0;

	switch (aMessage.Function())

		{

	case EStop:

		CActiveScheduler::Stop();

		break;

	case EDelay:

		// Spin a bit before replying

		// The compiler can't optimise this away because 'i' is used below ...

		for (i = 0; i < aMessage.Int0(); ++i)

			;

		break;

	default:

		r = KErrNotSupported;

		break;

		}

	if (i != -1)								// always true :)

		aMessage.Complete(r);

	}

//

// Thread to run the server code

//

TInt ServerThread(TAny*)

	{

	RTest test(_L("T_SCHEDRACE server"));

	test.Title();

// UserSvr::FsRegisterThread();

	test.Start(_L("Create and install ActiveScheduler"));

	CActiveScheduler* pScheduler = new CActiveScheduler;

	test_NotNull(pScheduler);

	CActiveScheduler::Install(pScheduler);

	test.Next(_L("Creating and starting Server"));

	CTestServer* pServer = new CTestServer(&test);

	test_NotNull(pServer);

	test_KErrNone(pServer->Start(KServerName));		// Starting a CServer2 also Adds it to the ActiveScheduler

	test.Next(_L("Rendezvous with main thread, then Start ActiveScheduler"));

	RThread self;

	self.Rendezvous(KErrNone);

	test.Printf(_L("        There might be something going on beneath this window\n"));

	CActiveScheduler::Start();

	// This code is not reached until the active scheduler exits.

	test.Next(_L("Destroy Server and ActiveScheduler"));

	delete pServer;

	delete pScheduler;

	test.Close();

	return (KErrNone);

	}

//

// Client classes and code ...

//

class RTestSession : public RSessionBase

	{

	public:

		RTestSession(RTest* aTest, TInt aTicks) : iTest(aTest), iMax(aTicks)

			{

			iDelay = iMax;

			iDelta = -1;

			};

		TInt Connect(const TDesC& aServer, int aSlots)

			{

			return RSessionBase::CreateSession(aServer, version, aSlots);

			};

		TInt SendBlind(TInt aFunction, const TIpcArgs& aArgs) const

			{

			return RSessionBase::Send(aFunction, aArgs);

			};

		TInt SendSync(TInt aFunction, const TIpcArgs& aArgs) const

			{

			return RSessionBase::SendReceive(aFunction, aArgs);

			};

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

			{

			RSessionBase::SendReceive(aFunction, aArgs, aStatus);

			};

	public:

		RTest* iTest;

		TInt iMax;

		TInt iDelay;

		TInt iDelta;

	};

RTestSession* TheSession;

class CIdler : public CIdle

	{

	public:

		CIdler() : CIdle(EPriorityIdle)

			{

			CActiveScheduler::Add(this);

			};

		void Callback();

	};

void CIdler::Callback()

	{

	if ((++nIdleCalls & 0x03ff) == 10000)		// never true, to suppress message

		TheSession->iTest->Printf(_L("I:calls: I=%-7d  S=%-7d  T=%-7d  D=%-7d\n"),

						nIdleCalls, nServerCalls, nTimerCalls, TheSession->iDelay);

	// TInt delay = Math::Random() & 0xffff;					// up to ~64ms

	TheSession->SendBlind(CTestSession::EDelay, TIpcArgs(TheSession->iDelay));

	TheSession->SendAsync(CTestSession::EDelay, TIpcArgs(0), iStatus);

	SetActive();

	}

//

// CIdler callback wrapper

//

TInt IdleCallback(TAny* aPtr)

	{

	((CIdler*)aPtr)->Callback();

	return EFalse;

	}

//

// CPeriodic callback

//

TInt TimerCallback(TAny*)

	{

	if ((++nTimerCalls & 0x003f) == 1)			// true in one out of 64 cycles

		TheSession->iTest->Printf(_L("T:calls: I=%-7d  S=%-7d  T=%-7d  D=%-7d\n"),

						nIdleCalls, nServerCalls, nTimerCalls, TheSession->iDelay);

	if (TheSession->iDelay >= TheSession->iMax)

		TheSession->iDelta = -1;

//	if (TheSession->iDelay < 1)

//		TheSession->iDelta = 1;

	TheSession->iDelay += TheSession->iDelta;

	if (TheSession->iDelay < 0)

		CActiveScheduler::Stop();

	return ETrue;

	}

//

// Thread to run the client code

//

TInt ClientThread(TAny*)

	{

	RTest test(_L("T_SCHEDRACE client"));

	test.Title();

// UserSvr::FsRegisterThread();

	test.Start(_L("Create Session"));

	TheSession = new RTestSession(&test, 5*60*64);	// will run for 5 minutes

	test_NotNull(TheSession);

	test_KErrNone(TheSession->Connect(KServerName, 2));

	test.Start(_L("Create and install ActiveScheduler"));

	CActiveScheduler* pScheduler = new CActiveScheduler;

	test_NotNull(pScheduler);

	CActiveScheduler::Install(pScheduler);

	test.Next(_L("Create timer and idle task"));

	CPeriodic* pTimer = CPeriodic::New(CActive::EPriorityStandard);

	test_NotNull(pTimer);

	CIdler* pIdler = new CIdler();

	test_NotNull(pIdler);

	test.Next(_L("Rendezvous with main thread"));

	RThread self;

	self.Rendezvous(KErrNone);

	test.Next(_L("Start idle task, timer, and active scheduler"));

	pIdler->Start(TCallBack(IdleCallback, pIdler));

	pTimer->Start(1000000, 1000, TCallBack(TimerCallback, pTimer));

	test.Printf(_L("        There might be something going on beneath this window\n"));

	CActiveScheduler::Start();

	// This code is not reached until the active scheduler exits.

	TheSession->SendSync(CTestSession::EStop, TIpcArgs());

	TheSession->Close();

	test.Next(_L("Destroy Idle task, Timer, and ActiveScheduler"));

	delete pIdler;

	delete pTimer;

	delete pScheduler;

	test.Close();

	return (KErrNone);

	}

//

// Main program ...

//

GLDEF_C TInt E32Main()

	{

	RTest test(_L("Main T_SCHEDRACE test"));

	test.Title();

	test.Start(_L("Create server and client threads"));

	const TInt KHeapMinSize = 0x1000;

	const TInt KHeapMaxSize = 0x1000;

	RThread serverThread, clientThread;

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

	test_KErrNone(clientThread.Create(_L("Client Thread"), ClientThread, KDefaultStackSize, KHeapMinSize, KHeapMaxSize, NULL));

	TRequestStatus serverStat, clientStat;

	serverThread.Rendezvous(serverStat);

	clientThread.Rendezvous(clientStat);

	serverThread.SetPriority(EPriorityMuchLess);

	clientThread.SetPriority(EPriorityMore);

	test.Next(_L("Start the threads"));

	serverThread.Resume();

	User::WaitForRequest(serverStat);

	test_KErrNone(serverStat.Int());

	clientThread.Resume();

	User::WaitForRequest(clientStat);

	test_KErrNone(clientStat.Int());

	test.Next(_L("Wait for the threads to stop"));

	serverThread.Logon(serverStat);

	clientThread.Logon(clientStat);

	User::WaitForRequest(clientStat);

	User::WaitForRequest(serverStat);

	switch (clientThread.ExitType())

		{

	case EExitKill:

		test.Printf(_L("  Client thread killed\n"));

		break;

	case EExitTerminate:

		test.Printf(_L("!!Client thread terminated:"));

		test.Panic(clientThread.ExitCategory(), clientThread.ExitReason());

		break;

	case EExitPanic:

		test.Panic(_L("!!Client thread panicked:"));

		test.Panic(clientThread.ExitCategory(), clientThread.ExitReason());

		break;

	default:

		test.Panic(_L("!!Client thread did something bizarre"), clientThread.ExitReason());

		break;

		}

	switch (serverThread.ExitType())

		{

	case EExitKill:

		test.Printf(_L("  Server thread killed\n"));

		break;

	case EExitTerminate:

		test.Printf(_L("!!Server thread terminated:"));

		test.Panic(serverThread.ExitCategory(), serverThread.ExitReason());

		break;

	case EExitPanic:

		//

		// To catch a panic put a breakpoint in User::Panic() (in UCDT\UC_UNC.CPP).

		//

		test.Printf(_L("!!Server thread panicked:"));

		test.Panic(serverThread.ExitCategory(), serverThread.ExitReason());

		break;

	default:

		test.Panic(_L("!!Server thread did something bizarre"), serverThread.ExitReason());

		break;

		}

	test.Next(_L("Close the threads"));

	CLOSE_AND_WAIT(serverThread);

	CLOSE_AND_WAIT(clientThread);

	test.End();

	return (KErrNone);

	}