// 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_ctimer.cpp
// Overview:
// Test timer functionality.
// API Information:
// CTimer 
// Details:
// - Create some timer active objects, install an active scheduler, and the
// active objects, request event after an interval and verify that:
// - Absolute timer set with time less than current time return KErrUnderflow.
// - Relative timer set with 0 goes off immediately.
// - Absolute timer set to a time of now returns KErrUnderflow.
// - Absolute timer set with time more than the current time returns KErrNone.
// - Repeated timer is cancelled as expected.
// - Call relative timer's After function without adding it to the active scheduler 
// and check for panic.
// - Call absolute timer's At function without adding it to the active scheduler and 
// check for panic.
// - Call 1s inactivity timer
// - Check if heap has been corrupted by the tests.
// Platforms/Drives/Compatibility:
// All.
// Assumptions/Requirement/Pre-requisites:
// Failures and causes:
// Base Port information:
// 
//

#include <e32test.h>
#include <e32panic.h>

enum TDirective {ERelInvalidTime,ERelNotAdded,EAbNotAdded,EHighResNotAdded};

LOCAL_D RTest test(_L("T_CTIMER"));
LOCAL_D const TInt KRepeatID=999; 	
LOCAL_D const TInt ID1=101;
LOCAL_D const TInt ID2=102;
LOCAL_D const TInt ID3=103;
LOCAL_D TInt A[5]; //When a timer expires its identifier is placed in here

class TestCTimer
	{
public:
	void Test1();
	void Test2();
	void Test3();
	};

class myScheduler : public CActiveScheduler
	{
public:
	virtual void Error(TInt anError)const{User::Leave(anError);}
	};

class myTimer : public CTimer
	{
public:
	myTimer(const TInt aPriority, const TInt anId):CTimer(aPriority){iIdentifier=anId; iCount=0;}
	void RunL(void);	
	void Start(void);
	static void SetNum(const TInt aNum) {iNum=aNum; iTotalCount=0;}
private:
	TInt iIdentifier;
	TInt iCount;
	static TInt iNum;
	static TInt iTotalCount;
	};

// for inactivity test
class myInactTimer : public CTimer
	{
public:
	myInactTimer(const TInt aPriority):CTimer(aPriority){;}
	void RunL(void);	
	void Start(void);
	};

TInt myTimer::iTotalCount;
TInt myTimer::iNum;

void myTimer::RunL(void)
//
// Timer has completed
//
	{

	A[iTotalCount++]=iIdentifier;
	if (iIdentifier==KRepeatID)
		{
		if(++iCount>2)
			Cancel();
		else
			After(100000);
		}
	if (iTotalCount>=iNum)
		CActiveScheduler::Stop();
	}

void myTimer::Start(void)
//
// Start a timer going.
//
	{

	ConstructL();
	CActiveScheduler::Add(this);
	}

void myInactTimer::RunL(void)
//
// Timer has completed
//
	{
	CActiveScheduler::Stop();
	}

void myInactTimer::Start(void)
//
// Start a timer going.
//
	{
	ConstructL();
	CActiveScheduler::Add(this);
	}

LOCAL_D TInt ThreadEntry(TAny* aDirective)
//
// Test thread
//
	{

	myTimer* pTimer=new myTimer(0,ID1);
	TTime time;
	switch((TUint)aDirective)
		{
	case ERelInvalidTime: // Setting a relative timer with a negative time panics 
		CActiveScheduler::Install(new myScheduler);
		pTimer->Start();
		pTimer->After(-100000); 
		break;	
	case ERelNotAdded: 	// Requesting an un-added relative timer panics
		pTimer->After(100000);
		break; 	
	case EAbNotAdded: // Requesting an un-added absolute timer panics
		time.HomeTime(); 
		pTimer->At(time); 
		break;
	case EHighResNotAdded: // Requesting an un-added HighRes timer panics
		pTimer->HighRes(100000);
		break;
		}
	return(KErrNone);
	}

void TestCTimer::Test1()
//
// Test timer active objects.
//
	{

	test.Start(_L("Create objects"));
	myTimer* pTimer1=new myTimer(0, ID1);
	myTimer* pTimer2=new myTimer(0, ID2);
	myTimer* pTimer3=new myTimer(0, ID3);
	TTime time;
	pTimer1->Start();
	pTimer2->Start();
	pTimer3->Start();
//
	test.Next(_L("Abs timer with time less than now set KErrUnderflow"));
	myTimer::SetNum(1);
	time.HomeTime();
	pTimer1->At(time+TTimeIntervalSeconds(-1));
	CActiveScheduler::Start();
	test(pTimer1->iStatus==KErrUnderflow);
//
	test.Next(_L("Rel timer with 0 goes off immediately"));
	myTimer::SetNum(2);
	pTimer1->After(0);
	pTimer2->After(1000000);
	CActiveScheduler::Start();
	test(A[0]==ID1 && A[1]==ID2);
//
	test.Next(_L("Abs timer to a time of now sets KErrUnderflow"));
	myTimer::SetNum(1);
	time.UniversalTime();
	pTimer1->AtUTC(time);
	CActiveScheduler::Start();
	test(pTimer1->iStatus==KErrUnderflow);
//
	test.Next(_L("Abs timer set to future"));
	myTimer::SetNum(2);
	pTimer1->After(2000000);
	time.HomeTime();
	pTimer2->At(time+TTimeIntervalSeconds(1));
	CActiveScheduler::Start();
	test(A[0]==ID2 && A[1]==ID1&& pTimer1->iStatus==KErrNone && pTimer2->iStatus==KErrNone);
//  
  	test.Next(_L("Cancel a repeating timer after 3"));
	myTimer::SetNum(4);
	myTimer* pRepeater=new myTimer(0,KRepeatID);
	pRepeater->Start();
	pTimer1->After(1000000);
	pRepeater->After(100000);
	CActiveScheduler::Start();
	test(A[0]==KRepeatID && A[1]==KRepeatID && A[2]==KRepeatID && A[3]==ID1);

//
	test.Next(_L("HighRes timer"));
	myTimer::SetNum(1);
	pTimer1->HighRes(1000000);
	CActiveScheduler::Start();
	test(A[0]==ID1 && pTimer1->iStatus==KErrNone);
//
	test.Next(_L("Inactivity 1s"));
	User::ResetInactivityTime();
	myInactTimer* pInactTimer=new myInactTimer(0);
	pInactTimer->Start();
	test.Printf(_L("inactivity..."));
	pInactTimer->Inactivity(1);
	CActiveScheduler::Start();
	test.Printf(_L("...back"));
	test(pInactTimer->iStatus==KErrNone);
//
	test.Next(_L("Destroy objects"));
	delete pTimer1;
	delete pTimer2;
	delete pTimer3;
	delete pRepeater;
	delete pInactTimer;
//
	test.End();
	}

void TestCTimer::Test2()
//
// Test the panics
//
	{

	RThread thread;
	TRequestStatus stat;
//
// Calling At or After or HighRes of an object not added to the queue panics
//
	test.Start(_L("Queue rel when not added"));
	test(thread.Create(_L("myThread"),ThreadEntry,KDefaultStackSize,0x2000,0x2000,(TAny*)ERelNotAdded)==KErrNone);
	thread.Logon(stat);
	thread.Resume();
	User::WaitForRequest(stat);
	test(thread.ExitCategory().Compare(_L("E32USER-CBase"))==0);
	test(thread.ExitReason()==ETimNotAdded);				
	test(thread.ExitType()==EExitPanic);				   
	CLOSE_AND_WAIT(thread);
//
	test.Next(_L("Queue abs when not added"));
	test(thread.Create(_L("myThread"),ThreadEntry,KDefaultStackSize,0x2000,0x2000,(TAny*)EAbNotAdded)==KErrNone);
	thread.Logon(stat);
	thread.Resume();
	User::WaitForRequest(stat);
	test(thread.ExitCategory().Compare(_L("E32USER-CBase"))==0);
	test(thread.ExitReason()==ETimNotAdded);				
	test(thread.ExitType()==EExitPanic);				   	
	CLOSE_AND_WAIT(thread);
//
	test.Next(_L("Queue HighRes when not added"));
	test(thread.Create(_L("myThread"),ThreadEntry,KDefaultStackSize,0x2000,0x2000,(TAny*)EHighResNotAdded)==KErrNone);
	thread.Logon(stat);
	thread.Resume();
	User::WaitForRequest(stat);
	test(thread.ExitCategory().Compare(_L("E32USER-CBase"))==0);
	test(thread.ExitReason()==ETimNotAdded);				
	test(thread.ExitType()==EExitPanic);				   	
	CLOSE_AND_WAIT(thread);
//
	test.End();
	}

LOCAL_D TInt Test3ThreadEntry(TAny* aArg)
//
// Test thread for RTimer::HighRes
//
	{
	TRequestStatus status;
	RTimer timer;
	TInt r = timer.CreateLocal();
	if (r != KErrNone)
		return r;
	timer.HighRes(status, (TInt) aArg);
	timer.Cancel();
	User::WaitForRequest(status);
	timer.Close();
	if (status != KErrNone && status != KErrCancel)
		return status.Int();	
	return KErrNone;
	}

void TestRTimerHighRes(TInt aInterval, TExitType aExpectedExitType)
	{
	RThread thread;
	TRequestStatus stat;
	test(thread.Create(_L("myThread"),Test3ThreadEntry,KDefaultStackSize,0x2000,0x2000,(TAny*)aInterval)==KErrNone);
	thread.Logon(stat);
	thread.Resume();
	User::WaitForRequest(stat);
	test(thread.ExitType()==aExpectedExitType);
	if (thread.ExitType()==EExitKill)
		test(thread.ExitReason()==KErrNone);
	CLOSE_AND_WAIT(thread);
	}

void TestCTimer::Test3()
//
// Test RTimer::HighRes argument checking
//
	{
	test.Start(_L("Test RTimer::HighRes argument checking"));
	TestRTimerHighRes(0, EExitKill);
	TestRTimerHighRes(0x7FFFEC79, EExitKill);
	TestRTimerHighRes(0x7FFFFFFF, EExitKill);
	TestRTimerHighRes(0x80000000, EExitPanic);
	test.End();
	}

GLDEF_C TInt E32Main()
//
// Test the CTimer class
//
    {
	// don't want just in time debugging as we trap panics
	TBool justInTime=User::JustInTime(); 
	User::SetJustInTime(EFalse); 

	test.Title();
	__UHEAP_MARK;
	TestCTimer T;
	myScheduler* pScheduler=new myScheduler;
	CActiveScheduler::Install(pScheduler);
	test.Start(_L("Test1"));
	T.Test1();
	test.Next(_L("Test2"));
	T.Test2();
	CActiveScheduler::Install(NULL);
	delete pScheduler;
	T.Test3();
	test.End();
	__UHEAP_MARKEND;

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