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