// Copyright (c) 1995-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\active\t_act.cpp
// Overview:
// Test CTimer based timers and error handling in active objects and 
// active scheduler
// API Information:
// CTimer, CActiveScheduler
// Details:
// - Create and install the active scheduler
// - Create a timer, add it to the active scheduler and start the timer
// - Verify RunL is run when the timer fires off and test dequeuing itself from 
// the active scheduler
// - Test that when a leave in RunL occurs, the active object gets the chance to 
// handle it before the active scheduler
// - Test that leaves in RunL can be handled successfully in the active object
// - Test the active object can propagate the leave to the active scheduler
// - Test that leaves in RunL can be handled successfully in the active scheduler
// Platforms/Drives/Compatibility:
// All.
// Assumptions/Requirement/Pre-requisites:
// Failures and causes:
// Base Port information:
// 
//

#include <e32test.h>
#include <e32panic.h>

class CMyRequestManager : public CActiveScheduler
	{
public:
	enum TMode
		{
		EExpectError,
		EGenerateException,
		EPanic
	} iMode;
public:
	virtual void Error(TInt anError) const;
	void SetMode(TMode aExpect);

private:
	TBool iExpectError;
	};

class CMyTimer : public CTimer
	{
public:
	static CMyTimer* New();
	void Start();
	virtual void RunL();
	void StartLeave(TBool aHandleLocally, TBool aLeaveInOOM, CMyRequestManager::TMode aMode);
	virtual TInt RunError(TInt aError);
	void StopLeave();
	void StartImbalance();
	virtual ~CMyTimer();
protected:
	CMyTimer(TInt aPriority);
private:
	enum {EMaxCount=10,ETimeReq=100000};
	CBase* iDummy;
	TInt iCount;
	TBool iConstructed;
	TBool iLeave;
	TBool iHandleLocally;
	TBool iLeaveInOOM;
	TBool iImbalance;
	TBool iStopping;
	};

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

void CMyRequestManager::Error(TInt anError) const
//
// Called if any Run() method leaves.
//
	{
	switch (iMode)
		{
		case EExpectError:
			{
			_LIT(KExpectError,"CMyRequestManager::Error handling error %d\n");
			test.Printf(KExpectError,anError);
			Stop();
			return;
			}
		case EGenerateException:
			{

			_LIT(KExpectError,"CMyRequestManager::Error about to generate exception...\n");
			test.Printf(KExpectError,anError);

			__UHEAP_FAILNEXT(1);
			TRAPD(ret,User::Leave(KErrArgument));
			__UHEAP_RESET;
	   		if (ret != KErrArgument) 
	   			{
				_LIT(KDoNotExpectError,"CMyRequestManager::Error unexpected");
				test.Panic(anError,KDoNotExpectError);
	   			}
			Stop();
			return;	
			}
		case EPanic:
		default:
			{
			_LIT(KDoNotExpectError,"CMyRequestManager::Error unexpected");
			test.Panic(anError,KDoNotExpectError);
			}
		}
	}


void CMyRequestManager::SetMode(TMode aMode)
	{
	iMode = aMode;
	}

CMyTimer* CMyTimer::New()
//
// Create a new CMyTimer.
//
	{

	return(new CMyTimer(0));
	}

CMyTimer::CMyTimer(TInt aPriority)
//
// Constructor
//
	: CTimer(aPriority),iCount(0), iImbalance(EFalse), iStopping(EFalse)
	{}

CMyTimer::~CMyTimer()
	{
	delete iDummy;
	}

void CMyTimer::Start()
//
// Start the timer
//
	{
	if (!iConstructed)
		{
		TRAPD(r, ConstructL());
		test(r==KErrNone);
		iConstructed = ETrue;
		iDummy = new(ELeave)CBase();
		}
	CActiveScheduler::Add(this); // Previously caused panic in UREL after Deque()
	SetPriority(1);
	After(ETimeReq);
	}

void CMyTimer::StartLeave(TBool aHandleLocally, TBool aLeaveInOOM, CMyRequestManager::TMode aMode)
//
// Start the timer
//
	{
	CActiveScheduler::Add(this); 
	SetPriority(1);
	After(ETimeReq);
	iLeave = ETrue;
	iHandleLocally = aHandleLocally;
	iLeaveInOOM = aLeaveInOOM;
	//	STATIC_CAST(CMyRequestManager*,CActiveScheduler::Current())->ExpectError(!aHandleLocally);
	STATIC_CAST(CMyRequestManager*,CActiveScheduler::Current())->SetMode(aMode);
	}

void CMyTimer::StopLeave()
	{
	iLeave=EFalse;
	}

void CMyTimer::StartImbalance()
	{
	iImbalance=ETrue;
	}

void CMyTimer::RunL()
//
// The timer has completed.
//
	{
	if (iLeave) 
		{
		Deque(); // Test removal from scheduler
		if (iLeaveInOOM)
			{
			__UHEAP_FAILNEXT(1);
			}
		User::Leave(KErrGeneral);
		}
	
	// This switch is used when testing for imbalance in the cleanupstack
	if(iImbalance)
		{
		if(iStopping)
			{
			
			iStopping=EFalse;
			//CleanupStack::PopAndDestroy(iDummy);
			CActiveScheduler::Stop();
			return;
			}
		else 
			{
			// Push something onto the stack, but dont take it off 
			//- deal in CActiveScheduler::DoRunL
			CleanupStack::PushL(iDummy);
			iStopping=ETrue; //Stop the scheduler the next time
			iCount=EMaxCount; 
//			CActiveScheduler::Stop();
			After(ETimeReq);
			return;
			}
		}

	iCount++;
	SetPriority(iCount);
	test.Printf(_L("\r%03d"),iCount);

	if (iCount<EMaxCount)
		After(ETimeReq);
	else
		{
		test.Printf(_L("\n"));
		CActiveScheduler::Stop();
		Deque(); // Test removal from scheduler
		iCount = 0;
		}
	}

TInt CMyTimer::RunError(TInt aError)
//
// Handle leave from RunL
//
	{
	if (iHandleLocally)
		{
		_LIT(KExpectError,"CMyTimer::RunError handling error %d\n");
		test.Printf(KExpectError,aError);
		CActiveScheduler::Stop();
		return KErrNone;
		}
	else 
		return aError; // Let the scheduler handle this error
	}


TInt DoImbalanceTest(TAny* /*aAny*/)
// This function is the first executing fuction of the cleanupstack imbalace
// testing thread - RunLCleanupImbalance
// see ImbalanceTest()
	{
	// Set up cleanup stack & scheduler
	RTest test(_L("Thread:RunLCleanupImbalance - DoImbalanceTest()"));
	test.Start(_L("DoImbalanceTest()"));

	//Create a cleanup stack and scheduler
	CTrapCleanup::New();
	CActiveScheduler* cas = new(ELeave) CActiveScheduler();
	CActiveScheduler::Install(cas);

	// Create a new AO.
	CMyTimer* myTimer = CMyTimer::New();
	myTimer->StopLeave();
	myTimer->StartImbalance(); 
	// Start the AO
	test.Next(_L("Start Imblance Test"));
	myTimer->Start();
	
	test.Next(_L("Start Scheduler"));
	// The following is expected to panic (with EUSER-CBase 90 EClnCheckFailed)
	cas->Start(); 
	
	delete myTimer;
	delete cas;
	test.End();
	return 0;
	}

#ifdef _DEBUG
LOCAL_C void ImbalanceTest()
// this test will test whether the cleanup stack is imbalanced after
// a runL of an Active object.
	{
	TBool imbalanced = ETrue;
	User::SetJustInTime(EFalse);
	RThread t;
	TRequestStatus s;
	test.Next(_L("Create a thread (RunLCleanupImbalance)"));
	TInt r=t.Create(_L("RunLCleanupImbalance"),DoImbalanceTest,KDefaultStackSize,KDefaultStackSize,KDefaultStackSize,&imbalanced);
	test(r==KErrNone);
	t.Logon(s);
	test.Next(_L("Resume and wait for panic (E32USER-CBase 90 EClnCheckFailed) due to imbalance"));
	t.Resume();
	User::WaitForRequest(s);
	
	test.Printf(_L("Exit Type %d\r\n"),(TInt)t.ExitType());
	test.Printf(_L("Exit Reason %d\r\n"),(TInt)t.ExitReason());
	
	test(t.ExitReason()==EClnCheckFailed);
	
	CLOSE_AND_WAIT(t);

	}
#endif

GLDEF_C TInt E32Main()
//
// Test timers.
//
    {
 	test.Title();
	test.Start(_L("Creating CActiveScheduler"));
	CMyRequestManager* pR=new CMyRequestManager;
	test(pR!=NULL);
	CActiveScheduler::Install(pR);
//
	test.Next(_L("Testing relative timers"));
	CMyTimer* pT=CMyTimer::New();
	test(pT!=NULL);
//
	test.Next(_L("Start timer"));
	pT->Start();
//
	test.Next(_L("Start CMyRequestManager"));
	CActiveScheduler::Start();
//
	test.Next(_L("Start timer again"));
	pT->Start();
//
	test.Next(_L("Start CMyRequestManager"));
	CActiveScheduler::Start();
//
	test.Next(_L("Start timer, leave in RunL, handle in scheduler"));
	pT->StartLeave(EFalse, EFalse, CMyRequestManager::EExpectError );
//
	test.Next(_L("Start CMyRequestManager"));
	CActiveScheduler::Start();
#ifdef _DEBUG
//
	test.Next(_L("Start timer, leave in RunL, generate nested exception under OOM condition"));
	pT->StartLeave(EFalse, ETrue, CMyRequestManager::EGenerateException);
//
	test.Next(_L("Start CMyRequestManager"));
	CActiveScheduler::Start();
	__UHEAP_RESET;
#endif
	//
	test.Next(_L("Start timer, leave in RunL, handle in object"));
	pT->StartLeave(ETrue, EFalse, CMyRequestManager::EPanic);
//
	test.Next(_L("Start CMyRequestManager"));
	CActiveScheduler::Start();
//
#ifdef _DEBUG
// Test the cleanupstack imbalances
	test.Next(_L("Test : Check Cleanupstack imbalance in RunL, handle(panic) in scheduler"));
	ImbalanceTest();
#endif
//
	test.End();
	return(0); 
    }