// Copyright (c) 1996-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_asyc.cpp

 // Overview:

 // Exercise the priority mechanism of active objects whereby active 

 // objects are run in the priority order.

 // API Information:

 // CAsyncOneShot, CActiveScheduler.

 // Details:

 // - Install active scheduler.

 // - Create active objects of different priorities and verify their RunL 

 // is called in the priority order.

 // - Verify that a very low priority active object will not get the chance

 // to run if a higher priority object keeps rescheduling itself or a 

 // higher priority object stops the active scheduler.

 // Platforms/Drives/Compatibility:

 // All.

 // Assumptions/Requirement/Pre-requisites:

 // Failures and causes:

 // Base Port information:

 // 

 //

 #include <e32test.h>

 enum {ETopPriority=1000,EMiddlePriority=900,ELatePriority=800};

 const TInt KIToldYouSo=666;

 class CMyActiveScheduler : public CActiveScheduler

 	{

 public:

 	virtual void Error(TInt anError) const;

 	};

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

 void CMyActiveScheduler::Error(TInt anError) const

 //

 // Called if any Run() method leaves.

 //

 	{

 	test.Panic(anError,_L("CMyActiveScheduler::Error"));

 	}

 class CMyMultiShot : public CAsyncOneShot

 	{

 public:

 	static CMyMultiShot* NewL(TInt aPriority,const TDesC& aMessage,TInt aCount);

 	void RunL();

 	CMyMultiShot(TInt aPriority,const TDesC& aMessage,TInt aCount);

 private:

 	TInt iCountRemaining;

 	TPtrC iMessage;

 	};

 class CShouldNeverRun : public CAsyncOneShot

 	{

 public:

 	void RunL();

 	static CShouldNeverRun* NewL();

 	CShouldNeverRun();

 	};

 class CStopTheScheduler : public CAsyncOneShot

 	{

 public:

 	CStopTheScheduler(TInt aPriority);

 	static CStopTheScheduler* NewL(TInt aPriority);

 	void RunL();

 	};

 CMyMultiShot* CMyMultiShot::NewL(TInt aPriority,const TDesC& aMessage,TInt aCount)

 	{

 	return new(ELeave)CMyMultiShot(aPriority,aMessage,aCount);

 	}

 CMyMultiShot::CMyMultiShot(TInt aPriority,const TDesC& aMessage,TInt aCount)

 	:CAsyncOneShot(aPriority),iMessage(aMessage)

 	{

 	iCountRemaining=aCount;

 	}

 void CMyMultiShot::RunL()

 	{

 	if (iCountRemaining--)

 		{

 		test.Printf(_L("%S,%d\n\r"),&iMessage,iCountRemaining);

 		Call();

 		}

 	}

 CShouldNeverRun* CShouldNeverRun::NewL()

 	{

 	return new(ELeave)CShouldNeverRun;

 	}

 CShouldNeverRun::CShouldNeverRun()

 	:CAsyncOneShot(KMinTInt)

 	{

 	}

 void CShouldNeverRun::RunL()

 	{

 	User::Panic(_L("CShouldNeverRun"),KIToldYouSo);

 	}

 CStopTheScheduler* CStopTheScheduler::NewL(TInt aPriority)

 	{

 	return new(ELeave)CStopTheScheduler(aPriority);

 	}

 CStopTheScheduler::CStopTheScheduler(TInt aPriority)

 	:CAsyncOneShot(aPriority)

 	{

 	}

 void CStopTheScheduler::RunL()

 	{

 	CActiveScheduler::Stop();

 	}

 GLDEF_C TInt E32Main()

 //

 // Test idle objects.

 //

     {

 	test.Title();

 	test.Start(_L("Testing idle object cancellation"));

 //

 	CMyActiveScheduler* pR=new CMyActiveScheduler;

 	test(pR!=NULL);

 	CActiveScheduler::Install(pR);

 //

 	CShouldNeverRun* pn=CShouldNeverRun::NewL();

 	pn->Call();

 	CStopTheScheduler* ps=CStopTheScheduler::NewL(ELatePriority);

 	ps->Call();

 	CMyMultiShot* multiShot1=CMyMultiShot::NewL(EMiddlePriority,_L("Call Ten times"),10);

 	multiShot1->Call();

 	CMyMultiShot* multiShot2=CMyMultiShot::NewL(ETopPriority,_L("Call five times"),5);

 	multiShot2->Call();

 	CActiveScheduler::Start();	

 //

 	test.End();

 	return(0);

     }