// 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_cactw.cpp
// Overview:
// Test the CActiveSchedulerWait class. 
// API Information:
// CActiveSchedulerWait
// Details:
// - Verify the thread is panicked when one of the following programming errors occurs:
// - the scheduler is started twice. 
// - the scheduler is stopped without starting scheduler.
// - the scheduler is started and then stopped twice.
// - the CanStopNow method of scheduler is called without starting scheduler.
// - Run different combinations of wait, start, async stop, async stop with a callback,
// canstopnow and nested calls to start and async stop operations and verify they run
// correctly
// - 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 KPanicThreadRet = 222;
const TInt KHeapSize = 0x1000;
const TInt KMaxActions = 32;
const TInt KNumWaits = 2;

enum TDirective {ENormal,EStartTwice,EStopUnstarted,EStopTwice,ECanStopNotStarted};
enum TActionType {EStartWait, EStopWait, EStopWaitCallBack, EIsWaitStarted, ECanStopWait, EStart, EStop};

struct TAction
	{
	TActionType iType;
	TInt iId;
	};

class TSchedulerTester
	{
public:
	void Test1();
	void Test2();
private:
	void SubTest2(TAction* aActions, TInt aCount, const TDesC& aResult);
	};

class CActionRunner : public CActive
	{
public:
	CActionRunner();
	~CActionRunner();
	void SetActions(TAction* aActions, TInt aCount);
	void Start();
	const TDesC& Trace() const;
private:
	void DoCancel();
	void RunL();
	static TInt CallBack(TAny* aThis);
private:
	TInt iStep;
	TInt iNumActions;
	TAction iActions[KMaxActions];
	CActiveSchedulerWait iWait[KNumWaits];
	TBuf<256> iTrace;
	};


LOCAL_D RTest test(_L("T_CACTW"));
LOCAL_D RSemaphore threadSemaphore;


CActionRunner::CActionRunner() : CActive(EPriorityStandard)
	{
	CActiveScheduler::Add(this);
	}

CActionRunner::~CActionRunner()
	{
	Cancel();
	}

void CActionRunner::SetActions(TAction* aActions, TInt aCount)
	{
	iNumActions = aCount;
	for (TInt ii=0; ii<aCount && ii<KMaxActions; ii++)
		iActions[ii] = aActions[ii];
	}

void CActionRunner::Start()
	{
	TRequestStatus* s = &iStatus;
	SetActive();
	User::RequestComplete(s, KErrNone);
	}

void CActionRunner::DoCancel()
	{
	}

void CActionRunner::RunL()
	{
	Start();
	if (iStep < iNumActions)
		{
		TAction& action = iActions[iStep];
		CActiveSchedulerWait& wait = iWait[action.iId];
		iTrace.AppendFormat(_L("%d%dS"), action.iId, action.iType);
		iStep++;
		switch (action.iType)
			{
			case EStartWait:
				wait.Start();
				break;
			case EStopWait:
				wait.AsyncStop();
				break;
			case EStopWaitCallBack:
				wait.AsyncStop(TCallBack(CallBack, this));
				break;
			case EIsWaitStarted:
				iTrace.AppendFormat(_L("%d"), wait.IsStarted()!=0);
				break;
			case ECanStopWait:
				iTrace.AppendFormat(_L("%d"), wait.CanStopNow()!=0);
				break;
			case EStart:
				CActiveScheduler::Start();
				break;
			case EStop:
				CActiveScheduler::Stop();
				break;
			default:
				break;
			}
		iTrace.AppendFormat(_L("%d%dE"), action.iId, action.iType);
		}
	}

const TDesC& CActionRunner::Trace() const
	{
	return iTrace;
	}

TInt CActionRunner::CallBack(TAny* aThis)
	{
	CActionRunner* self = (CActionRunner*) aThis;
	self->iTrace.Append(_L("C"));
	return 0;
	}


LOCAL_D TInt panicThread(TAny* aDirective)
//
// Test thread which panics
//
	{
	// cause panics in various ways depending upon aDirective
	CActiveScheduler* pManager=new CActiveScheduler;
	CActiveScheduler::Install(pManager);

	CActionRunner* r = new(ELeave)CActionRunner;
	
	switch((TInt)aDirective)
		{
		case ENormal:
			{
			TAction actions[] = {{EStop, 0}};
			r->SetActions(actions, sizeof(actions)/sizeof(*actions));
			break;
			}
		case EStartTwice:
			{
			TAction actions[] = {{EStartWait, 0}, {EStartWait, 0}, {EStop, 0}};
			r->SetActions(actions, sizeof(actions)/sizeof(*actions));
			break;
			}
		case EStopUnstarted:
			{
			TAction actions[] = {{EStopWait, 0}, {EStop, 0}};
			r->SetActions(actions, sizeof(actions)/sizeof(*actions));
			break;
			}
		case EStopTwice:
			{
			TAction actions[] = {{EStartWait, 0}, {EStopWait, 0}, {EStopWait, 0}, {EStop, 0}};
			r->SetActions(actions, sizeof(actions)/sizeof(*actions));
			break;
			}
		case ECanStopNotStarted:
			{
			TAction actions[] = {{ECanStopWait, 0}, {EStop, 0}};
			r->SetActions(actions, sizeof(actions)/sizeof(*actions));
			break;
			}
		default:
			break;
		}

	r->Start();
	CActiveScheduler::Start();
	delete r;
	delete pManager;
	return(KPanicThreadRet);
	}


void TSchedulerTester::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("Two starts panics"));
	r=thread.Create(_L("myThread"),panicThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)EStartTwice);
	test(r==KErrNone);
	thread.Logon(stat);
	thread.Resume();
	User::WaitForRequest(stat);
	test(thread.ExitReason()==EActiveSchedulerWaitAlreadyStarted);
	test(thread.ExitType()==EExitPanic);
	CLOSE_AND_WAIT(thread);
//
	test.Next(_L("Stop without start panics"));
	r=thread.Create(_L("myThread"),panicThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)EStopUnstarted);
	test(r==KErrNone);
	thread.Logon(stat);
	thread.Resume();
	User::WaitForRequest(stat);
	test(thread.ExitReason()==EActiveSchedulerWaitNotStarted);
	test(thread.ExitType()==EExitPanic);
	CLOSE_AND_WAIT(thread);
//
	test.Next(_L("Start then two stops 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()==EActiveSchedulerWaitNotStarted);
	test(thread.ExitType()==EExitPanic);
	CLOSE_AND_WAIT(thread);
//
	test.Next(_L("Can stop now, without start panics"));
	r=thread.Create(_L("myThread"),panicThread,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ECanStopNotStarted);
	test(r==KErrNone);
	thread.Logon(stat);
	thread.Resume();
	User::WaitForRequest(stat);
	test(thread.ExitReason()==EActiveSchedulerWaitNotStarted);
	test(thread.ExitType()==EExitPanic);
	CLOSE_AND_WAIT(thread);

	test.End();
	}

void TSchedulerTester::Test2()
//
// Test 2
//
	{
//
// Test sequencing
	test.Start(_L("Scheduler wait sequencing"));
		{
		test.Next(_L("First a simple stop"));
		TAction a[] = {{EStop, 0}};
		SubTest2(a, sizeof(a)/sizeof(*a), _L("06S06E"));
		}
		{
		test.Next(_L("Simple wait stop"));
		TAction a[] = { {EIsWaitStarted, 0}, {EStartWait, 0}, {EIsWaitStarted, 0}, 
						{ECanStopWait, 0}, {EStopWait, 0}, {EIsWaitStarted, 0}, 
						{EStop, 0}};
		SubTest2(a, sizeof(a)/sizeof(*a), _L("03S003E00S03S103E04S104E01S01E00E03S003E06S06E"));
		}
		{
		test.Next(_L("Properly nested wait"));
		TAction a[] = { {EStartWait, 0}, {EStartWait, 1}, 
						{EStopWait, 1}, {EStopWait, 0}, {EStop, 0}};
		SubTest2(a, sizeof(a)/sizeof(*a), _L("00S10S11S11E10E01S01E00E06S06E"));
		}
		{
		test.Next(_L("Properly nested scheduler"));
		TAction a[] = { {EStart, 0}, {EStart, 1}, 
						{EStop, 1}, {EStop, 0}, {EStop, 0}};
		SubTest2(a, sizeof(a)/sizeof(*a), _L("05S15S16S16E15E06S06E05E06S06E"));
		}
		{
		test.Next(_L("Badly nested wait"));
		TAction a[] = { {EStartWait, 0}, {EStartWait, 1}, 
						{EStopWait, 0}, {EStopWait, 1}, {EStop, 0}};
		SubTest2(a, sizeof(a)/sizeof(*a), _L("00S10S01S01E11S11E10E00E06S06E"));
		}
		{
		test.Next(_L("Badly nested scheduler"));
		TAction a[] = { {EStart, 0}, {EStart, 1}, 
						{EStop, 0}, {EStop, 1}, {EStop, 0}};
		SubTest2(a, sizeof(a)/sizeof(*a), _L("05S15S06S06E15E16S16E05E06S06E"));
		}
		{
		test.Next(_L("Bad mixed nesting 1"));
		TAction a[] = { {EStartWait, 0}, {EStart, 1}, 
						{EStopWait, 0}, {EStop, 1}, {EStop, 0}};
		SubTest2(a, sizeof(a)/sizeof(*a), _L("00S15S01S01E16S16E15E00E06S06E"));
		}
		{
		test.Next(_L("Bad mixed nesting 2"));
		TAction a[] = { {EStart, 0}, {EStartWait, 1}, 
						{EStop, 0}, {EStopWait, 1}, {EStop, 0}};
		SubTest2(a, sizeof(a)/sizeof(*a), _L("05S10S06S06E11S11E10E05E06S06E"));
		}
		{
		test.Next(_L("Properly nested wait callback 1"));
		TAction a[] = { {EStartWait, 0}, {EStartWait, 1}, 
						{EStopWaitCallBack, 1}, {EStopWait, 0}, {EStop, 0}};
		SubTest2(a, sizeof(a)/sizeof(*a), _L("00S10S12S12EC10E01S01E00E06S06E"));
		}
		{
		test.Next(_L("Properly nested wait callback 2"));
		TAction a[] = { {EStartWait, 0}, {EStartWait, 1}, 
						{EStopWait, 1}, {EStopWaitCallBack, 0}, {EStop, 0}};
		SubTest2(a, sizeof(a)/sizeof(*a), _L("00S10S11S11E10E02S02EC00E06S06E"));
		}
		{
		test.Next(_L("Badly nested wait callback 1"));
		TAction a[] = { {EStartWait, 0}, {EStartWait, 1}, 
						{EStopWaitCallBack, 0}, {EStopWait, 1}, {EStop, 0}};
		SubTest2(a, sizeof(a)/sizeof(*a), _L("00S10S02S02E11S11E10EC00E06S06E"));
		}
		{
		test.Next(_L("Badly nested wait callback 2"));
		TAction a[] = { {EStartWait, 0}, {EStartWait, 1}, 
						{EStopWait, 0}, {EStopWaitCallBack, 1}, {EStop, 0}};
		SubTest2(a, sizeof(a)/sizeof(*a), _L("00S10S01S01E12S12EC10E00E06S06E"));
		}
		{
		test.Next(_L("Properly nested wait can stop now"));
		TAction a[] = { {EStartWait, 0}, {EStartWait, 1}, {ECanStopWait, 0}, {ECanStopWait, 1}, 
						{EStopWait, 1}, {ECanStopWait, 0}, {EStopWait, 0}, {EStop, 0}};
		SubTest2(a, sizeof(a)/sizeof(*a), _L("00S10S04S004E14S114E11S11E10E04S104E01S01E00E06S06E"));
		}
		{
		test.Next(_L("Badly nested wait can stop now"));
		TAction a[] = { {EStartWait, 0}, {EStartWait, 1}, {ECanStopWait, 0}, {ECanStopWait, 1}, 
						{EStopWait, 0}, {ECanStopWait, 1}, {EStopWait, 1}, {EStop, 0}};
		SubTest2(a, sizeof(a)/sizeof(*a), _L("00S10S04S004E14S114E01S01E14S114E11S11E10E00E06S06E"));
		}
		{
		test.Next(_L("Properly nested wait is started"));
		TAction a[] = { {EStartWait, 0}, {EStartWait, 1}, {EIsWaitStarted, 0}, {EIsWaitStarted, 1}, 
						{EStopWait, 1}, {EIsWaitStarted, 0}, {EIsWaitStarted, 1}, {EStopWait, 0}, {EStop, 0}};
		SubTest2(a, sizeof(a)/sizeof(*a), _L("00S10S03S103E13S113E11S11E10E03S103E13S013E01S01E00E06S06E"));
		}
		{
		test.Next(_L("Badly nested wait is started"));
		TAction a[] = { {EStartWait, 0}, {EStartWait, 1}, {EIsWaitStarted, 0}, {EIsWaitStarted, 1}, 
						{EStopWait, 0}, {EIsWaitStarted, 0}, {EIsWaitStarted, 1}, {EStopWait, 1}, {EStop, 0}};
		SubTest2(a, sizeof(a)/sizeof(*a), _L("00S10S03S103E13S113E01S01E03S003E13S113E11S11E10E00E06S06E"));
		}
		{
		test.Next(_L("Interleaved badly nested wait with callback"));
		TAction a[] = { {EStartWait, 0}, {EStartWait, 1}, {EStopWaitCallBack, 0}, 
						{EStartWait, 0}, {EStopWaitCallBack, 1}, {EStopWaitCallBack, 0}, 
						{EStop, 0}};
		SubTest2(a, sizeof(a)/sizeof(*a), _L("00S10S02S02E00S12S12E02S02EC00EC10EC00E06S06E"));
		}
	test.End();
	}

void TSchedulerTester::SubTest2(TAction* aActions, TInt aCount, const TDesC& aResult)
	{
	CActiveScheduler* pManager=new CActiveScheduler;
	CActiveScheduler::Install(pManager);

	CActionRunner* r = new(ELeave)CActionRunner;
	r->SetActions(aActions, aCount);
	r->Start();
	CActiveScheduler::Start();
	test(r->Trace() == aResult);

	delete r;
	delete pManager;
	}

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"));
	TSchedulerTester sched;
	sched.Test1();
//
	test.Next(_L("Test2"));
	sched.Test2();
//
	test.End();
	__UHEAP_MARKEND;

	User::SetJustInTime(justInTime);
	return(KErrNone);
    }