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

    }