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

    }