// 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_cact.cpp

 // Overview:

 // Test the CActiveScheduler class, including scheduling priority, thread 

 // panics and cancelling objects attached to the scheduler. 

 // API Information:

 // CActiveScheduler 

 // Details:

 // - Verify the thread is panicked when one of the following programming errors occurs:

 // - start an uninstalled scheduler

 // - install a scheduler twice

 // - stop the scheduler twice 

 // - stop an uninstalled scheduler

 // - set active an active object twice

 // - add an active object to an uninstalled scheduler

 // - add a NULL pointer to the scheduler

 // - add an active object twice

 // - thread gets a stray signal

 // - make request on an un-added active object

 // - Create timers with different priorities

 // - Check the timers are scheduled according to expiration time

 // - Check the timers are scheduled in order of their priority when they expire at the

 // same time

 // - Check the timers are scheduled in order of the addition to the scheduler when

 // they expire at the same time and they have the same priority

 // - Verify that a leave in RunL method not handled by the active object calls the active 

 // scheduler's Error method

 // - Test a cancelled timer will not be scheduled 

 // - Create a thread with its own heap and test that timers are scheduled in the order of

 // their expiration time, priority and order of addition to the scheduler

 // - Check the heap is not corrupted by all the tests

 // Platforms/Drives/Compatibility:

 // All

 // Assumptions/Requirement/Pre-requisites:

 // Failures and causes:

 // Base Port information:

 // 

 //

 #include <e32test.h>

 #include <e32panic.h>

 const TInt KmyErrorNum=999;

 const TInt KLeaveCode=1234;  

 const TInt KgTimerID=4321;

 const TInt KCancelCode=1111;

 const TInt KTestArraySize=10;

 const TInt KPanicThreadRet=2222;

 const TInt KHeapSize=0x2000;

 enum TActivePriority {eLowest=-100,eLow=-1,eNone=0,eHigh=1,eHighest=100};

 enum TDirective {EStartUninstalled,EInstallTwice,EStopTwice,EStopUninstalled,ESetActiveTwice,

 				 EAddToUninstalled,EAddNull,EAddTwice,ECreateStray,ERequestUnadded,EStraySignalNoKRequestPending,EStraySignalNoSetActive,ENormal};

 class TSecdulerTester

 	{

 public:

 	void Test1();

 	void Test2();

 	void Test3();

 	void Test4();

 	};

 class MyManager : public CActiveScheduler

 	{

 public:

 	virtual void Error(TInt anError) const {CActiveScheduler::Halt(anError);}

 	};

 class myTimer : public CTimer

 	{

 public:

 	myTimer(const TInt aPriority, const TInt anIdentifier):CTimer(aPriority){iIdentifier=anIdentifier;}

 	virtual void RunL();

 	void Start();		  

 	void Setactive() {SetActive();}

 	static void SetNum(const TInt aNum) {iNum=aNum; iCount=0;}

 private:   

 	TInt iIdentifier;

 	static TInt iCount;

 	static TInt iNum;

 	};

 class myThreadTimer : public CTimer

 	{

 public:

 	myThreadTimer(const TInt aPriority, const TInt anIdentifier):CTimer(aPriority){iIdentifier=anIdentifier;}

 	virtual void RunL();

 	static void SetNum(const TInt aNum) {iNum=aNum; iCount=0;}

 	void Start();

 private:

 	TInt iIdentifier;

 	static TInt iCount;

 	static TInt iNum;

 	};

 class CreateStray : public CActive

 	{

 public:

 	CreateStray(TInt aPriority);

 	void DoCancel() {}

 	void RunL() {}

 private:

 	RTimer iTimer;

 	};

 class myStray : public CActive

 	{

 public:

 	myStray(TInt aPriority) : CActive(aPriority) {};

 	void DoCancel() {}

 	void RunL() { CActiveScheduler::Stop(); }

 	void Start1();

 	void Start2();

 	};

 void myStray::Start1()

 	{

 	TRequestStatus* s=&iStatus;

 	SetActive();

 	RThread().RequestComplete(s,KErrNone);

 	}

 void myStray::Start2()

 	{

 	TRequestStatus* s=&iStatus;

 	iStatus=KRequestPending;

 	User::RequestComplete(s,KErrNone);

 	}

 TInt myTimer::iCount;

 TInt myTimer::iNum;

 TInt myThreadTimer::iCount;

 TInt myThreadTimer::iNum;

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

 LOCAL_D myTimer* gTimer; // This is cancelled from within the run method 

 LOCAL_D RSemaphore threadSemaphore;

 LOCAL_D myTimer* pLowest=NULL;

 LOCAL_D myTimer* pLow=NULL;

 LOCAL_D myTimer* pNone=NULL;

 LOCAL_D myTimer* pHigh=NULL;

 LOCAL_D myTimer* pHigh2=NULL;

 LOCAL_D myTimer* pHigh3=NULL;

 LOCAL_D myTimer* pHighest=NULL;

 LOCAL_D TInt order[KTestArraySize]; // When a timer expires its identifier is placed in here

 LOCAL_D TInt threadArray[KTestArraySize];

 LOCAL_C TInt myThreadEntryPoint(TAny*)

 //

 // myThread tests 

 //

 	{

 	__UHEAP_MARK;

 	RTest test(_L("Separate thread tests"));

 	test.Title();

 	test.Start(_L("Create semaphore"));

 	RTimer t;

 	TInt ret=t.CreateLocal();

 	test(ret==KErrNone);

 //

 	test.Next(_L("Install scheduler"));

 	MyManager* pManager=new MyManager;

 	CActiveScheduler::Install(pManager);

 //

 	test.Next(_L("Create active objects"));

 	myThreadTimer* pLowest=new myThreadTimer(eLowest, eLowest);

 	test(pLowest!=NULL);

 	myThreadTimer* pLow=new myThreadTimer(eLow, eLow);

 	test(pLow!=NULL);

 	myThreadTimer* pNone=new myThreadTimer(eNone, eNone);

 	test(pNone!=NULL);

 	myThreadTimer* pHigh=new myThreadTimer(eHigh, eHigh);

 	test(pHigh!=NULL);

 	myThreadTimer* pHigh2=new myThreadTimer(eHigh, eHigh+2);

 	test(pHigh2!=NULL);

 	myThreadTimer* pHigh3=new myThreadTimer(eHigh, eHigh+3);

 	test(pHigh3!=NULL);

 	myThreadTimer* pHighest=new myThreadTimer(eHighest, eHighest);

 	test(pHighest!=NULL);

 //

 	test.Next(_L("Test low is scheduled before lowest"));

 	myThreadTimer::SetNum(2);

 	pLowest->Start();

 	pLowest->After(0);

 	pLow->Start();

 	pLow->After(0);

 	TRequestStatus s;

 	t.After(s,100000);

 	test(s==KRequestPending);

 	User::WaitForRequest(s);

 	CActiveScheduler::Start();

 	test(threadArray[0]==eLow && threadArray[1]==eLowest);

 //

 	test.Next(_L("Test none is scheduled before low"));

 	myThreadTimer::SetNum(2);

 	pLow->After(0);

 	pNone->Start();

 	pNone->After(0);

 	t.After(s,100000);

 	test(s==KRequestPending);

 	User::WaitForRequest(s);

 	CActiveScheduler::Start();

 	test(threadArray[0]==eNone && threadArray[1]==eLow);

 //

 	test.Next(_L("Test high is scheduled before none"));

 	myThreadTimer::SetNum(2);

 	pHigh->Start();

 	pHigh->After(0);

 	pNone->After(0);

 	t.After(s, 100000);

 	test(s==KRequestPending);

 	User::WaitForRequest(s);

 	CActiveScheduler::Start();

 	test(threadArray[0]==eHigh && threadArray[1]==eNone);

 //

 	test.Next(_L("Test highest is scheduled before high"));

 	myThreadTimer::SetNum(2);

 	pHighest->Start();

 	pHighest->After(0);

 	pHigh->After(0);

 	t.After(s, 100000);

 	test(s==KRequestPending);

 	User::WaitForRequest(s);

 	CActiveScheduler::Start();

 	test(threadArray[0]==eHighest && threadArray[1]==eHigh);

 //

 	test.Next(_L("Test objects are scheduled according to priority"));

 	myThreadTimer::SetNum(5);

 	pLowest->After(0);

 	pLow->After(0);

 	pNone->After(0);

 	pHigh->After(0);

 	pHighest->After(0);

 	t.After(s, 100000);

 	test(s==KRequestPending);

 	User::WaitForRequest(s);

 	CActiveScheduler::Start();

 	test(threadArray[0]==eHighest && threadArray[1]==eHigh && threadArray[2]==eNone && 

 		 threadArray[3]==eLow && threadArray[4]==eLowest);

 //

 	test.Next(_L("Test objects are scheduled according to timer expiry"));

 	myThreadTimer::SetNum(5);

 	pLowest->After(0);

 	pLow->After(500000);

 	pNone->After(1000000);

 	pHigh->After(1500000);

 	pHighest->After(2000000);

 	CActiveScheduler::Start();

 	test(threadArray[4]==eHighest && threadArray[3]==eHigh && threadArray[2]==eNone && 

 		 threadArray[1]==eLow && threadArray[0]==eLowest);

 //

 	test.Next(_L("Test with some objects having the same priority"));

 	myThreadTimer::SetNum(7);

 	pLowest->After(0);

 	pLow->After(0);

 	pNone->After(0);

 	pHigh->After(0);

 	pHigh2->Start();

 	pHigh2->After(0);

 	pHigh3->Start();

 	pHigh3->After(0);

 	pHighest->After(0);

 	t.After(s, 100000);

 	test(s==KRequestPending);

 	User::WaitForRequest(s);

 	CActiveScheduler::Start();

 	test(threadArray[0]==eHighest && threadArray[1]==eHigh && threadArray[2]==eHigh+2 && 

 		 threadArray[3]==eHigh+3 && threadArray[4]==eNone && threadArray[5]==eLow && threadArray[6]==eLowest);

 //

 	test.Next(_L("Tidying up"));

 	delete pManager;

 	delete pLowest;

 	delete pLow;

 	delete pNone;

 	delete pHigh;

 	delete pHigh2;

 	delete pHigh3;

 	delete pHighest;

 	test.Close();

 	__UHEAP_MARKEND;

 	threadSemaphore.Signal();

 	return(KErrNone);

 	}

 LOCAL_D TInt panicThread(TAny* aDirective)

 //

 // Test thread which panics

 //

 	{

 	// cause panics in various ways depending upon aDirective

 	MyManager* pManager=new MyManager;

 	switch((TInt)aDirective)

 		{

 	case EStartUninstalled:

 		CActiveScheduler::Start(); // Start an uninstalled active schedler

 		break;

 	case EInstallTwice:

 		CActiveScheduler::Install(pManager); // Install the scheduler twice

 		CActiveScheduler::Install(pManager);

 		break;

 	case EStopTwice:

 		CActiveScheduler::Install(pManager); // Stop a scheduler twice

 		CActiveScheduler::Stop();

 		CActiveScheduler::Stop();

 		break;

 	case EStopUninstalled:

 		CActiveScheduler::Stop(); // Stop an uninstalled active scheduler

 		break;

 	case ESetActiveTwice:

 		{

 //

 // Set an active object to active twice

 //

 		myTimer* pTimer=new myTimer(eNone,eNone);

 		CActiveScheduler::Install(pManager);

 		CActiveScheduler::Add(pTimer);

 		pTimer->Setactive();

 		pTimer->Setactive();

 		}

 		break;

 	case EAddToUninstalled:

 		{

 //

 // Add an active object to an uninstalled scheduler

 //

 		myTimer* pTimer=new myTimer(eNone,eNone);

 		CActiveScheduler::Add(pTimer); 

 		}

 		break;

 	case EAddNull:

 //

 // Add Null to the scheduling queue

 //

 		CActiveScheduler::Install(pManager);  

 		CActiveScheduler::Add(NULL);

 		break;

 	case EAddTwice:

 		{

 //

 // Add the same object twice to the scheduling queue

 //

 		myTimer* pTimer=new myTimer(eNone,eNone);

 		CActiveScheduler::Install(pManager);  

 		CActiveScheduler::Add(pTimer);

 		CActiveScheduler::Add(pTimer);

 		}

 		break;

 	case ECreateStray:

 		{

 //

 // Create a stray signal

 //

 		CActiveScheduler::Install(pManager); 

 		new CreateStray(1);

 		CActiveScheduler::Start();

 		}

 		break;

 	case ERequestUnadded:

 		{

 //

 // Make a request of an active object not added to the scheduling queue

 //

 		CActiveScheduler::Install(pManager);

 		myTimer* pTimer=new myTimer(eNone,eNone);

 		pTimer->Setactive();

 		}

 		break;

 	case EStraySignalNoKRequestPending:

 		{

 		CActiveScheduler::Install(pManager);

 		myStray* pStray = new myStray(eNone);

 		CActiveScheduler::Add(pStray);

 		pStray->Start1();

 		CActiveScheduler::Start();

 		}

 		break;

 	case EStraySignalNoSetActive:

 		{

 		CActiveScheduler::Install(pManager);

 		myStray* pStray = new myStray(eNone);

 		CActiveScheduler::Add(pStray);

 		pStray->Start2();

 		CActiveScheduler::Start();

 		}

 		break;

 	case ENormal:

 	default:

 		break;

 		}

 	delete pManager;

 	return(KPanicThreadRet);

 	}

 void myTimer::RunL()

 //

 // Handle the timer completion

 //

 	{

 	if (iIdentifier==KLeaveCode)	// Used to test that the request manager error() method is called

 		User::Leave(KmyErrorNum);

 	if (iIdentifier==KCancelCode) // Used to test cancelling an object

 		gTimer->Cancel();

 	order[iCount++]=iIdentifier;

 	if (iCount>=iNum)

 		CActiveScheduler::Stop();

 	}

 void myTimer::Start()

 //

 // Start a timer

 //

 	{

 	ConstructL();

 	CActiveScheduler::Add(this);

 	}

 void myThreadTimer::RunL()

 //

 // Handle timer completion

 //

 	{

 	threadArray[iCount++]=iIdentifier;

 	if(iCount>=iNum)

 		CActiveScheduler::Stop();

 	}

 void myThreadTimer::Start()

 //

 // Start a timer

 //

 	{

 	ConstructL();

 	CActiveScheduler::Add(this);

 	}

 CreateStray::CreateStray(TInt aPriority)

 //

 // Constructor

 //

 	: CActive(aPriority)

 	{

 	iTimer.CreateLocal();

 	CActiveScheduler::Add(this);

 	iTimer.After(iStatus, 1000000);

 	}

 void TSecdulerTester::Test1()

 //

 // Test 1

 //

 	{

 //

 // Test the panics

 //

 	RThread thread;

 	TRequestStatus stat;

 //

 	test.Start(_L("First test normal thread termination"));

 	TInt r=thread.Create(_L("myThread"),panicThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ENormal);

 	test(r==KErrNone);

 	thread.Logon(stat);

 	thread.Resume();

 	User::WaitForRequest(stat);

 	test(thread.ExitCategory().Compare(_L("Kill"))==0);

 	test(thread.ExitReason()==KPanicThreadRet);	  

 	test(thread.ExitType()==EExitKill);

 	CLOSE_AND_WAIT(thread);

 //

 	test.Next(_L("Starting an uninstalled scheduler panics"));

 	r=thread.Create(_L("myThread"),panicThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)EStartUninstalled);

 	test(r==KErrNone);

 	thread.Logon(stat);

 	thread.Resume();

 	User::WaitForRequest(stat);

 	test(thread.ExitReason()==EReqManagerDoesNotExist);

 	test(thread.ExitType()==EExitPanic);

 	CLOSE_AND_WAIT(thread);

 //

 	test.Next(_L("Installing the scheduler twice panics"));

 	r=thread.Create(_L("myThread"),panicThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)EInstallTwice);

 	test(r==KErrNone);

 	thread.Logon(stat);

 	thread.Resume();

 	User::WaitForRequest(stat);

 	test(thread.ExitReason()==EReqManagerAlreadyExists);

 	test(thread.ExitType()==EExitPanic);

 	CLOSE_AND_WAIT(thread);

 //

 	test.Next(_L("Stopping the scheduler twice panics"));

 	r=thread.Create(_L("myThread"),panicThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)EStopTwice);

 	test(r==KErrNone);

 	thread.Logon(stat);

 	thread.Resume();

 	User::WaitForRequest(stat);

 	test(thread.ExitReason()==EReqTooManyStops);

 	test(thread.ExitType()==EExitPanic);

 	CLOSE_AND_WAIT(thread);

 //

 	test.Next(_L("Stopping an uninstalled scheduler panics"));

 	r=thread.Create(_L("myThread"),panicThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)EStopUninstalled);

 	test(r==KErrNone);

 	thread.Logon(stat);

 	thread.Resume();

 	User::WaitForRequest(stat);

 	test(thread.ExitReason()==EReqManagerDoesNotExist);

 	test(thread.ExitType()==EExitPanic);

 	CLOSE_AND_WAIT(thread);

 //

 	test.Next(_L("Setting an active object to active twice panics"));

 	r=thread.Create(_L("myThread"),panicThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ESetActiveTwice);

 	test(r==KErrNone);

 	thread.Logon(stat);

 	thread.Resume();

 	User::WaitForRequest(stat);

 	test(thread.ExitReason()==EReqAlreadyActive);

 	test(thread.ExitType()==EExitPanic);

 	CLOSE_AND_WAIT(thread);

 //

 	test.Next(_L("Adding an active object to an uninstalled scheduler panics"));

 	r=thread.Create(_L("myThread"),panicThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)EAddToUninstalled);

 	test(r==KErrNone);

 	thread.Logon(stat);

 	thread.Resume();

 	User::WaitForRequest(stat);

 	test(thread.ExitReason()==EReqManagerDoesNotExist);

 	test(thread.ExitType()==EExitPanic);

 	CLOSE_AND_WAIT(thread);

 //

 	test.Next(_L("Adding NULL panics"));

 	r=thread.Create(_L("myThread"),panicThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)EAddNull);

 	test(r==KErrNone);

 	thread.Logon(stat);

 	thread.Resume();

 	User::WaitForRequest(stat);

 	test(thread.ExitReason()==EReqNull);

 	test(thread.ExitType()==EExitPanic);

 	CLOSE_AND_WAIT(thread);

 //

 	test.Next(_L("Adding an active object twice panics"));

 	r=thread.Create(_L("myThread"),panicThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)EAddTwice);

 	test(r==KErrNone);

 	thread.Logon(stat);

 	thread.Resume();

 	User::WaitForRequest(stat);

 	test(thread.ExitReason()==EReqAlreadyAdded);

 	test(thread.ExitType()==EExitPanic);

 	CLOSE_AND_WAIT(thread);

 //

 	test.Next(_L("A stray signal causes a panic"));

 	r=thread.Create(_L("myThread"),panicThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ECreateStray);

 	test(r==KErrNone);

 	thread.Logon(stat);

 	thread.Resume();

 	User::WaitForRequest(stat);

 	test(thread.ExitReason()==EReqStrayEvent);

 	test(thread.ExitType()==EExitPanic);

 	CLOSE_AND_WAIT(thread);

 //

 	test.Next(_L("Making a request on an unadded active object panics"));

 	r=thread.Create(_L("myThread"),panicThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ERequestUnadded);

 	test(r==KErrNone);

 	thread.Logon(stat);

 	thread.Resume();

 	User::WaitForRequest(stat);

 	test(thread.ExitReason()==EActiveNotAdded);

 	test(thread.ExitType()==EExitPanic);

 	CLOSE_AND_WAIT(thread);

 //

 	test.Next(_L("The service provider does not set the status to KRequestPending"));

 	r=thread.Create(_L("myThread"),panicThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)EStraySignalNoKRequestPending);

 	test(r==KErrNone);

 	thread.Logon(stat);

 	thread.Resume();

 	User::WaitForRequest(stat);

 #ifdef _DEBUG

 	//this might fail if we're using a UREL euser

 	test(thread.ExitReason()==EReqStrayEvent);

 	test(thread.ExitType()==EExitPanic);

 #else

 	test(thread.ExitCategory().Compare(_L("Kill"))==0);

 	test(thread.ExitReason()==KPanicThreadRet);	  

 	test(thread.ExitType()==EExitKill);

 #endif 

 	CLOSE_AND_WAIT(thread);

 //

 #ifdef _DEBUG

 	//this might fail if we're using a UREL euser

 	test.Next(_L("The active object does not call SetActive"));

 	r=thread.Create(_L("myThread"),panicThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)EStraySignalNoSetActive);

 	test(r==KErrNone);

 	thread.Logon(stat);

 	thread.Resume();

 	User::WaitForRequest(stat);

 	test(thread.ExitReason()==EReqStrayEvent);

 	test(thread.ExitType()==EExitPanic);

 	CLOSE_AND_WAIT(thread);

 #endif

 //

 	test.End();

 	}

 void TSecdulerTester::Test2()

 //

 // Test 2

 //

 	{

 	test.Start(_L("Create timer"));

 	RTimer t;

 	TInt ret=t.CreateLocal();

 	test(ret==KErrNone);

 	TRequestStatus s;

 //

 	test.Next(_L("Test low is scheduled before lowest when timing equal"));

 	myTimer::SetNum(2);

 	pLowest->After(0);

 	pLow->After(0);

 	t.After(s, 100000);

 	test(s==KRequestPending);

 	User::WaitForRequest(s);

 	CActiveScheduler::Start();

 	test(order[0]==eLow && order[1]==eLowest);

 //

 	test.Next(_L("Test low is not before lowest when it expires later"));

 	myTimer::SetNum(2);

 	pLowest->After(0);

 	pLow->After(1000000);

 	CActiveScheduler::Start();

 	test(order[0]==eLowest && order[1]==eLow);

 //

 	test.Next(_L("Test none is scheduled before low"));

 	myTimer::SetNum(2);

 	pLow->After(0);

 	pNone->After(0);

 	t.After(s, 100000);

 	test(s==KRequestPending);

 	User::WaitForRequest(s);

 	CActiveScheduler::Start();

 	test(order[0]==eNone && order[1]==eLow);

 //

 	test.Next(_L("Test none is not before low when it expires later"));

 	myTimer::SetNum(2);

 	pLow->After(0);

 	pNone->After(1000000);

 	CActiveScheduler::Start();

 	test(order[0]==eLow && order[1]==eNone);

 //

 	test.Next(_L("Test high is scheduled before none"));

 	myTimer::SetNum(2);

 	pHigh->After(0);

 	pNone->After(0);

 	t.After(s, 100000);

 	test(s==KRequestPending);

 	User::WaitForRequest(s);

 	CActiveScheduler::Start();

 	test(order[0]==eHigh && order[1]==eNone);

 //

 	test.Next(_L("Test high is not before none when it expires later"));

 	myTimer::SetNum(2);

 	pHigh->After(1000000);

 	pNone->After(0);

 	CActiveScheduler::Start();

 	test(order[0]==eNone && order[1]==eHigh);

 //

 	test.Next(_L("Test highest is scheduled before high"));

 	myTimer::SetNum(2);

 	pHighest->After(0);

 	pHigh->After(0);

 	t.After(s, 100000);

 	test(s==KRequestPending);

 	User::WaitForRequest(s);

 	CActiveScheduler::Start();

 	test(order[0]==eHighest && order[1]==eHigh);

 //

 	test.Next(_L("Test highest is not before high when it expires later"));

 	myTimer::SetNum(2);

 	pHighest->After(1000000);

 	pHigh->After(0);

 	CActiveScheduler::Start();

 	test(order[0]==eHigh && order[1]==eHighest);

 //			  

 	test.Next(_L("Test all objects are scheduled in priority order"));

 	myTimer::SetNum(5);

 	pLowest->After(0);

 	pLow->After(0);

 	pNone->After(0);

 	pHigh->After(0);

 	pHighest->After(0);

 	t.After(s, 100000);

 	test(s==KRequestPending);

 	User::WaitForRequest(s);

 	CActiveScheduler::Start();

 	test(order[0]==eHighest && order[1]==eHigh && order[2]==eNone && order[3]==eLow && order[4]==eLowest);

 //

 	test.Next(_L("Test objects are scheduled according to expiry of timers"));

 	myTimer::SetNum(5);

 	pLowest->After(0);

 	pLow->After(500000);

 	pNone->After(1000000);

 	pHigh->After(1500000);

 	pHighest->After(2000000);

 	CActiveScheduler::Start();

 	test(order[4]==eHighest && order[3]==eHigh && order[2]==eNone && order[1]==eLow && order[0]==eLowest);

 //

 	test.Next(_L("Test with some objects having the same priority"));

 	myTimer::SetNum(7);

 	pLowest->After(0);

 	pLow->After(0);

 	pNone->After(0);

 	pHigh->After(0);

 	pHigh2->After(0);

 	pHigh3->After(0);

 	pHighest->After(0);	  

 	t.After(s, 100000);

 	test(s==KRequestPending);

 	User::WaitForRequest(s);

 	CActiveScheduler::Start();

 	test(order[0]==eHighest && order[1]==eHigh && order[2]==eHigh+2 && order[3]==eHigh+3 && order[4]==eNone && order[5]==eLow && order[6]==eLowest);

 //

 	test.End();

 	}

 void TSecdulerTester::Test3()

 //

 // Test 3

 //

 	{

 //

 // Test that a leave in a Run method calls the requestmanager error() method

 //

 	myTimer* pTimer=new myTimer(0, KLeaveCode);

 	pTimer->Start();

 	pTimer->After(100000);

 	TRAPD(ret,CActiveScheduler::Start());

 	test(ret==KmyErrorNum);		

 //

 // Test cancelling an object

 // Without the cancel the schedule order should be: pTimer1, gTimer, pTimer3

 // gTimer is cancelled so should not be scheduled 

 //

 	myTimer::SetNum(2);

 	myTimer* pTimer2=new myTimer(eHighest,KCancelCode);

 	myTimer* pTimer3=new myTimer(eLowest,eLowest);

 	pTimer2->Start();

 	pTimer2->After(100000);

 	gTimer->Start();

 	gTimer->After(1000000);

 	pTimer3->Start();

 	pTimer3->After(2000000);

 	CActiveScheduler::Start();

 	test(order[0]==KCancelCode && order[1]==eLowest);

 	delete pTimer;

 	delete pTimer2;

 	delete pTimer3;

 	}

 void TSecdulerTester::Test4()

 //

 // Create a thread with its own scheduler

 //

 	{	  

 	threadSemaphore.CreateLocal(0);

 	RThread myThread;

 	test(myThread.Create(_L("myThread"),myThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,NULL)==KErrNone);

 	myThread.Resume();

 	myThread.Close();

 	Test2();

 	threadSemaphore.Wait();

 	User::After(100000);

 	}

 GLDEF_C TInt E32Main()

     {

 	// don't want just in time debugging as we trap panics

 	TBool justInTime=User::JustInTime(); 

 	User::SetJustInTime(EFalse); 

 	test.Title();

 	__UHEAP_MARK;

 //

 	test.Start(_L("Test1"));

 	TSecdulerTester sched;

 	sched.Test1();

 	MyManager* pManager=new MyManager;

 	test(pManager!=NULL);

 	CActiveScheduler::Install(pManager);

 	test(CActiveScheduler::Current()==pManager);

 	MyManager* pManager2=new MyManager;

 	test(pManager2!=NULL);

 	delete pManager2;

 	test(CActiveScheduler::Current()==pManager);

 	pLowest=new myTimer(eLowest,eLowest);

 	test(pLowest!=NULL);

 	pLow=new myTimer(eLow,eLow);

 	test(pLow!=NULL);

 	pNone=new myTimer(eNone,eNone);

 	test(pNone!=NULL);

 	pHigh=new myTimer(eHigh,eHigh);

 	test(pHigh!=NULL);

 	pHigh2=new myTimer(eHigh,eHigh+2);

 	test(pHigh2!=NULL);

 	pHigh3=new myTimer(eHigh,eHigh+3);

 	test(pHigh3!=NULL);

 	pHighest=new myTimer(eHighest,eHighest);

 	test(pHighest!=NULL);

 	pLowest->Start();

 	pLow->Start();

 	pNone->Start();

 	pHigh->Start();

 	pHigh2->Start();

 	pHigh3->Start();

 	pHighest->Start();

 //

 	test.Next(_L("Test2"));

 	sched.Test2();	

 	User::Check();

 //

 	test.Next(_L("Test3"));

 	gTimer=new myTimer(eNone, KgTimerID);

 	sched.Test3();

 //

 	test.Next(_L("Test4"));

 	sched.Test4();

 	delete gTimer;

 	User::Check();

 	delete pManager;

 	delete pLowest;

 	delete pLow;

 	delete pNone;

 	delete pHigh;

 	delete pHigh2;

 	delete pHigh3;

 	delete pHighest;

 //

 	test.End();

 	__UHEAP_MARKEND;

 	User::SetJustInTime(justInTime);

 	return(KErrNone);

     }