--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/active/t_asyc.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,163 @@
+// 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);
+    }
+