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