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

// Overview:

// Test periodic timers. 

// API Information:

// CPeriodic, CHeartbeat

// Details:	

// - Create some CPeriodic timer active objects with different priorities.

// - Start the periodic timers with varying delay time to start generation 

// of first event and different intervals between events

// - Verify the callback functions associated with each periodic are called 

// in order of the time when the event occurred and considering the priority 

// of the periodics.

// - Create heartbeat timer with different priorities

// - Start one heartbeat synchronized at ETwelveOClock 

// - Start two heartbeats synchronized at ETwelveOClock, ESixOClock

// - Start three heartbeats synchronized at ETwelveOClock, ESixOClock, ETwelveOClock

// - Display start time and beat time for each heartbeat timer

// - Check if the heap has been corrupted by all the tests.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// -	The first part of the test (for CPeriodic) will fail if the timers are not completed in order. 

// The test on emulator is very sensitive on the background activities on PC.

// Base Port information:

// 

//

#include <e32base.h>

#include <e32base_private.h>

#include <e32hal.h>

#include <e32test.h>

#include <hal.h>

#include <u32hal.h>

#include <e32svr.h>

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

class myScheduler: public CActiveScheduler

	{

public:	

	virtual void Error(TInt anError) const;

	};

void myScheduler::Error(TInt anError) const

//

// virtual error handler 

//

	{

	test.Panic(anError,_L("myScheduler::Error"));

	}

TInt Array[11];

TTime Times[11];

TInt counter = 0;

CPeriodic* pPer1;

CPeriodic* pPer2;

CPeriodic* pPer3;

CPeriodic* pPer4;

CPeriodic* pPer5;

CPeriodic* pPer6;

CPeriodic* pPer7;

TInt CallBackFn(TAny* Ptr)

//

// Callback function used for all periodics

// On calling Ptr is actually a TInt - the periodic Id

//

	{

	if (counter < 11)

		{

		Array[counter] = (TInt)Ptr;

		Times[counter].HomeTime();

		counter++;

		}

	return(0);

	}

TInt CallBackPanic(TAny* Ptr)

//

// Periodic should never get called

//

	{

	test.Printf(_L("  PERIODIC %d HAS GONE OFF!\n"),(TInt)Ptr);

	test(EFalse);

	return(KErrGeneral);

	}

class myTimer: public CTimer

	{

public:

	myTimer(TInt aPriority);

	virtual void RunL(); 

	};

myTimer::myTimer(TInt aPriority) : CTimer(aPriority)

//

// Constructor - Creates AND ADDS TO MYSCHEDULER

//	

	{

	ConstructL();

	myScheduler::Add(this);

	}

void myTimer::RunL()

//

// The timer stops the scheduler

//

	{

	myScheduler::Stop();

	test.Printf(_L("   Timer has stopped ActiveScheduler\n"));

	}

//

// CHeartbeat test code

//

class CTick : public CBase, public MBeating

	{

public:

	virtual void Beat();

	virtual void Synchronize();

	void Display();

	TInt iTicks;

	TTime iStartTime;

	TTime iTimes[4];

	};

void CTick::Beat()

	{

	test.Printf(_L("Tick\n"));

	iTimes[iTicks].HomeTime();

	if (++iTicks>=4)

		CActiveScheduler::Stop();

	}

void CTick::Synchronize()

	{

	test.Printf(_L("Sync tick to system clock\n"));

	iStartTime.HomeTime();

	iTicks=0;

	}

void PrintTime(const TDesC& aName, const TTime& aTime)

	{

	TDateTime dt(aTime.DateTime());

	test.Printf(_L("%S = %02d:%02d:%02d:%06d\n"),&aName,dt.Hour(),dt.Minute(),dt.Second(),dt.MicroSecond());

	}

void CTick::Display()

	{

	PrintTime(_L("Start time"),iStartTime);

	TInt i;

	for (i=0; i<4; i++)

		{

		TBuf<16> name;

		name.Format(_L("Beat %d"),i);

		PrintTime(name,iTimes[i]);

		}

	}

class CTock : public CTick

	{

public:

	virtual void Beat();

	virtual void Synchronize();

	};

void CTock::Beat()

	{

	iTimes[iTicks++].HomeTime();

	test.Printf(_L("Tock\n"));

	}

void CTock::Synchronize()

	{

	test.Printf(_L("Sync tock to system clock\n"));

	iStartTime.HomeTime();

	iTicks=0;

	}

class CBigTock : public CTick

	{

public:

	virtual void Beat();

	virtual void Synchronize();

	};

void CBigTock::Beat()

	{

	iTimes[iTicks++].HomeTime();

	test.Printf(_L("TOCK!\n"));

	}

void CBigTock::Synchronize()

	{

	test.Printf(_L("Sync TOCK to system clock\n"));

	iStartTime.HomeTime();

	iTicks=0;

	}

void testHeartbeat()

//

// Test CHeartBeat

//

	{

	test.Start(_L("Test CHeartbeat timer"));

	CActiveScheduler *scheduler = new CActiveScheduler;

	CActiveScheduler::Install(scheduler);

	test.Next(_L("Create a beating object synchronised at ETwelveOClock"));

	CTick *tick=new CTick;

	CHeartbeat *pH=NULL;

	TRAPD(r, pH=CHeartbeat::NewL(EPriorityNormal));

	test(r==KErrNone);

	test.Next(_L("Run for 4 beats on the second"));

	pH->Start(ETwelveOClock, tick);

	CActiveScheduler::Start();

	pH->Cancel();

	tick->Display();

	User::After(1000000);

	test.Next(_L("Create another heartbeat synchronised at ESixOClock"));

	CHeartbeat *pH6=CHeartbeat::New(EPriorityNormal);

	CTock *tock=new CTock;

	test.Next(_L("Start both"));

	pH->Start(ETwelveOClock, tick);

	pH6->Start(ESixOClock, tock);

	CActiveScheduler::Start();

	tick->Display();

	tock->Display();

	pH->Cancel();

	pH6->Cancel();

	User::After(1000000);

	test.Next(_L("Create another beating object synchronised at ESixOClock with a higher priority"));

	CHeartbeat *pH2=CHeartbeat::New(EPriorityHigh);

	CBigTock *bigtock=new CBigTock;

	test.Next(_L("Start all"));

	pH->Start(ETwelveOClock, tick);

	pH6->Start(ESixOClock, tock);

	pH2->Start(ESixOClock, bigtock);

	CActiveScheduler::Start();

	pH->Cancel();

	pH2->Cancel();

	pH6->Cancel();

	tick->Display();

	tock->Display();

	bigtock->Display();

	delete pH;

	delete pH2;

	delete pH6;

	delete tock;

	delete tick;

	delete bigtock;

	delete scheduler;

	test.End();

	}

void testLockSpec()

//

// test the operators defined for TTimerLockSpec

//

	{

/*

	test.Start(_L("Test pre fix operator ++"));

	TTimerLockSpec i=ETwelveOClock,k=EOneOClock,l;

	TInt j;

	for (j=0; j<30; j++)

		{

		++k=EOneOClock;

		test(k==EOneOClock);

		k=i;

		l=++i;

		switch (k)

			{

		case EOneOClock:

			test(i==ETwoOClock);

			test(l==ETwoOClock);

			break;

		case ETwoOClock:

			test(i==EThreeOClock);

			test(l==EThreeOClock);

			break;

		case EThreeOClock:

			test(i==EFourOClock);

			test(l==EFourOClock);

			break;

		case EFourOClock:

			test(i==EFiveOClock);

			test(l==EFiveOClock);

			break;

		case EFiveOClock:

			test(i==ESixOClock);

			test(l==ESixOClock);

			break;

		case ESixOClock:

			test(i==ESevenOClock);

			test(l==ESevenOClock);

			break;

		case ESevenOClock:

			test(i==EEightOClock);

			test(l==EEightOClock);

			break;

		case EEightOClock:

			test(i==ENineOClock);

			test(l==ENineOClock);

			break;

		case ENineOClock:

			test(i==ETenOClock);

			test(l==ETenOClock);

			break;

		case ETenOClock:

			test(i==EElevenOClock);

			test(l==EElevenOClock);

			break;

		case EElevenOClock:

			test(i==ETwelveOClock);

			test(l==ETwelveOClock);

			break;

		case ETwelveOClock:

			test(i==EOneOClock);

			test(l==EOneOClock);

			break;

			}

		}

	test.Next(_L("Test post fix operator ++"));

	for (j=0; j<30; j++)

		{

		++k=EOneOClock;

		test(k==EOneOClock);

		k=i;

		l=i++;

		switch (k)

			{

		case EOneOClock:

			test(i==ETwoOClock);

			test(l==k);

			break;

		case ETwoOClock:

			test(i==EThreeOClock);

			test(l==k);

			break;

		case EThreeOClock:

			test(i==EFourOClock);

			test(l==k);

			break;

		case EFourOClock:

			test(i==EFiveOClock);

			test(l==k);

			break;

		case EFiveOClock:

			test(i==ESixOClock);

			test(l==k);

			break;

		case ESixOClock:

			test(i==ESevenOClock);

			test(l==k);

			break;

		case ESevenOClock:

			test(i==EEightOClock);

			test(l==k);

			break;

		case EEightOClock:

			test(i==ENineOClock);

			test(l==k);

			break;

		case ENineOClock:

			test(i==ETenOClock);

			test(l==k);

			break;

		case ETenOClock:

			test(i==EElevenOClock);

			test(l==k);

			break;

		case EElevenOClock:

			test(i==ETwelveOClock);

			test(l==k);

			break;

		case ETwelveOClock:

			test(i==EOneOClock);

			test(l==k);

			break;

			}

		}

	test.End();

*/

	}

GLDEF_C TInt E32Main()

	{

	test.Title();

	__UHEAP_MARK;

	test.Start(_L("Create some CPeriodics"));

	myScheduler* pScheduler = new myScheduler;

	myScheduler::Install(pScheduler);

	pPer1 = CPeriodic::New(0);

	pPer2 = CPeriodic::NewL(0);

	pPer3 = CPeriodic::NewL(10);

	pPer4 = CPeriodic::NewL(100);

	pPer5 = CPeriodic::NewL(100);

	pPer6 = CPeriodic::NewL(100);

	pPer7 = CPeriodic::NewL(100);

	myTimer* pTimer = new myTimer(50);

	test.Next(_L("Start them"));

	TCallBack callBack1(CallBackFn,(TAny*)1);

	TCallBack callBack2(CallBackFn,(TAny*)2);

	TCallBack callBack3(CallBackFn,(TAny*)3);

	TCallBack callBack4(CallBackPanic,(TAny*)4);

	TCallBack callBack5(CallBackPanic,(TAny*)5);

	TCallBack callBack6(CallBackPanic,(TAny*)6);

	TCallBack callBack7(CallBackPanic,(TAny*)7);

	TInt p=0;

	HAL::Get(HAL::ESystemTickPeriod, p);

	User::After(p); // ensure tick does not occur while starting all these timers

	pPer1->Start(2*p+1,7*p+1,callBack1);	//After 3 ticks, complete every 8th tick

	pPer2->Start(1,    2*p+1,callBack2);	//After 1 tick , complete every 3rd tick

	pPer3->Start(7*p+1,  p+1,callBack3);	//After 8 ticks, complete every 2nd tick

	pPer4->Start(KMaxTInt,KMaxTInt,callBack4);

	pPer5->Start(60000000,60000000,callBack5);

	pPer6->Start(KMaxTInt/91,KMaxTInt/91,callBack6);

	pPer7->Start(KMaxTInt/91+1,KMaxTInt/91+1,callBack7);

	pTimer->After(20*p-1); // ensure there's enough time for them to fill up the array.

	/*

		Time	per1   per2	  per3

		  1				-

		  2

		  3		 -

		  4				-

		  5

		  6

		  7				-

		  8					   -

		  9

		 10				-	   -

		 11		 -			   

		 12					   -

		 13				-	   

		 14					   -

	*/

	myScheduler::Start();

	TInt i;

	for (i=0; i<counter; ++i)

		{

		test.Printf(_L("   Time: %7d Periodic: %d\n"),static_cast<TUint32>(Times[i].Int64()-Times[0].Int64()),Array[i]);

		}

	test(Array[0]==2);

	test(Array[1]==1);

	test(Array[2]==2);

	test(Array[3]==2);

	test(Array[4]==3);

	TBool normal56 = (Array[5]==3 && Array[6]==2);

	TBool reverse56 = (Array[5]==2 && Array[6]==3);

	if (UserSvr::HalFunction(EHalGroupKernel, EKernelHalNumLogicalCpus, 0, 0) > 1)

		{

		// If there are multiple processors the order of 'simultaneous' timers is undefined since

		// the test may get to run as soon as the first timer is completed, instead of only after

		// the timer thread blocks, which would be after both timers completed.

		test(normal56 || reverse56);

		}

	else

		test(normal56);

	test(Array[7]==1);

	test(Array[8]==3);

	test(Array[9]==2);

	test(Array[10]==3);

	test.Next(_L("Destroy them"));

	delete pPer1;

	delete pPer2;

	delete pPer3;

	delete pPer4;

	delete pPer5;

	delete pPer6;

	delete pPer7;

	delete pTimer;

	delete pScheduler;

	test.Next(_L("Test CHeartbeat"));

	testHeartbeat();

	test.Next(_L("Test TTimerLockSpec"));

	testLockSpec();

	__UHEAP_MARKEND;

	test.End();

	return(KErrNone);

	}