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

     }