// Copyright (c) 1995-2010 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

// - Test replacing the scheduler and also check stack depths

// - Call deprecated dummy functions

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

	void Test5();

	};

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