// Copyright (c) 2003-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\debug\t_eventtracker.cpp

// User-side harness for a LDD-based debug agent which keeps 

// track of various events (e.g. thread creation) and tests 

// them for consistency (e.g. a thread deletion event should be 

// preceded with a thread creation one).

// USAGE:

// 1.	start t_eventtracker usehook

// to hook event tracker to the stop-mode debugger breakpoint, or

// start t_eventtracker

// to add it to the kernel event handler queue

// 2.	<< do something e.g. run some tests >>

// 3.	t_eventtracker stop

// KNOWN ISSUES:

// * The debug agent allocates memory on the kernel heap.

// Consequently, it will perturbate any test using 

// __KHEAP_FAILNEXT() (e.g. t_kheap).

// * There is a window of opportunity when tracking is started

// or stopped during which some events may be lost, leading

// to incorrect results.  Therefore t_eventtracker should

// be called only when the system is idle.

// 

//

#include <e32test.h>

#include "reventtracker.h"

RTest test(_L("T_EVENTTRACKER"));

_LIT(KTrackerServerName, "EventTrackerServer");

//////////////////////////////////////////////////////////////////////////////

/** Wrapper around LDD session with debug agent */

class CTracker : public CBase

	{

public:

	~CTracker();

	void Start(TBool aUseHook);

	TInt Stop();

private:

	REventTracker iEventTracker;

	};

CTracker::~CTracker()

	{

	iEventTracker.Close();

	}

void CTracker::Start(TBool aUseHook)

	{

	TInt r = User::LoadLogicalDevice(_L("D_EVENTTRACKER.LDD"));

	test(r == KErrNone || r == KErrAlreadyExists);

	test(iEventTracker.Open(aUseHook) == KErrNone);

	test(iEventTracker.Start() == KErrNone);

	}

TInt CTracker::Stop()

	{

	TInt r=iEventTracker.Stop();

	iEventTracker.Close();

	return r;

	}

//////////////////////////////////////////////////////////////////////////////

/** Server used to interact with the debug agent */

class CTrackerServer : public CServer2

	{

public:

	static CTrackerServer* NewLC(TBool aUseHook);

	~CTrackerServer();

	// from CServer2

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

private:

	CTrackerServer();

public:

	CTracker* iTracker;

	};

/** Session used to stop event tracking */

class CTrackerSession : public CSession2

	{

private:

	// from CSession2

	void ServiceL(const RMessage2& aMessage);

	};

void CTrackerSession::ServiceL(const RMessage2& aMessage)

	{

	TInt r = ((CTrackerServer*)Server())->iTracker->Stop();

	CActiveScheduler::Stop();

	aMessage.Complete(r);

	}

CTrackerServer* CTrackerServer::NewLC(TBool aUseHook)

	{

	CTrackerServer* server = new(ELeave) CTrackerServer;

	CleanupStack::PushL(server);

	server->iTracker = new(ELeave) CTracker;

	server->StartL(KTrackerServerName);

	server->iTracker->Start(aUseHook);

	return server;

	}

CTrackerServer::CTrackerServer()

	: CServer2(EPriorityStandard)

	{

	}

CTrackerServer::~CTrackerServer()

	{

	delete iTracker;

	}

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

	{

	return new(ELeave) CTrackerSession;

	}

//////////////////////////////////////////////////////////////////////////////

/** Handle to client/server session */

class RTracker : public RSessionBase

	{

public:

	TInt Open() { return CreateSession(KTrackerServerName, TVersion(), 0); }

	TInt Stop() { return SendReceive(0); }

	};

//////////////////////////////////////////////////////////////////////////////

void MainL()

	{

	_LIT(KStop,"stop");

	_LIT(KUseHook,"usehook");

	TBuf<64> c;

	User::CommandLine(c);

	if (c.FindF(KStop) >= 0)

		{

		// Stop event tracking

		RTracker t;

		test(t.Open() == KErrNone);

		test(t.Stop() == KErrNone);

		t.Close();

		}

	else

		{

		// Create server and start event tracking

		test(User::RenameThread(KTrackerServerName) == KErrNone);

		TBool useHook = EFalse;

		if (c.FindF(KUseHook) >= 0)

			{

			useHook = ETrue;

			}

		CTrackerServer* server = CTrackerServer::NewLC(useHook);

		CActiveScheduler::Start();

		CleanupStack::PopAndDestroy(server);

		}

	}

TInt E32Main()

	{

	test.Title();

	__UHEAP_MARK;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	test(cleanup != NULL);

	CActiveScheduler* scheduler = new CActiveScheduler;

	test(scheduler != NULL);

	CActiveScheduler::Install(scheduler);

	TRAPD(r, MainL());

	if (r != KErrNone)

		{

		test.Printf(_L("Unexpected leave: %d\n"), r);

		test(EFalse);

		}

	delete scheduler;

	delete cleanup;

	__UHEAP_MARKEND;

	return 0;

	}