// 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\prime\t_timer.cpp

// Overview:

// Time and Timer tests.

// API Information:

// RTimer, TTime

// Details:

// - Test relative timers using the RTimer::After() method. Verify 

// results are as expected.

// - Set the date and time using TTime::HomeTime() and verify results

// are as expected.

// - Test absolute timers using RTimer::At() method. Verify results

// are as expected.

// - Test the timer is ok if its thread terminates.

// - Test synchronising time via the RTimer::Lock() method. Verify 

// results are as expected.

// - Test locked timers abort when the system time changes.

// - Test User::ResetInactivityTime() results are as expected.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

// the following was used to help debug emulator implemenation of user mode callbacks

//#define REQUEST_STATUS_POLL_SOAK_TEST  

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32hal.h>

#include <e32panic.h>

#include <hal.h>

#include <e32power.h>

#include <e32math.h>

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

TInt MachineUid;

TInt AfterNegative(TAny*)

	{

	RTimer t;

	TInt r=t.CreateLocal();

	test(r==KErrNone);

	TRequestStatus s;

	t.After(s,-1);

	return KErrNone;

	}

TInt AfterTwice(TAny*)

	{

	RTimer t;

	TInt r=t.CreateLocal();

	test(r==KErrNone);

	TRequestStatus s;

	t.After(s,1000000);

	test(s==KRequestPending);

	t.After(s,1000000);

	return KErrNone;

	}

void PrintTime()

	{

	TTime now;

	now.HomeTime();

	TDateTime dt(now.DateTime());

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

	}

TBool RequestIsComplete(TRequestStatus& s)

	{

	return s != KRequestPending;

	}

LOCAL_C void testRel()

//

// Test relative timers.

//

	{

	test.Start(_L("After 0"));

	RTimer t;

	TInt r=t.CreateLocal();

	test(r==KErrNone);

	TRequestStatus s;

	t.After(s,0);

	test(s==KRequestPending || s==KErrNone);

	User::WaitForRequest(s);

	test(s==KErrNone);

//

	test.Next(_L("After 1 tenth"));

	t.After(s,100000);

#ifdef __WINS__

	// On WINS we can't guarantee thread scheduling so timer may already have

	// completed before we get to test the status. Therefore, allow KErrNone.

	test(s==KRequestPending || s==KErrNone);

	if(s==KErrNone)

		test.Printf(_L("NOTE: completed 'early'"));

#else

	test(s==KRequestPending);

#endif

	User::WaitForRequest(s);

	test(s==KErrNone);

//

	test.Next(_L("After -1 millionth"));

	RThread thread;

	r=thread.Create(_L("After -1"),AfterNegative,KDefaultStackSize,NULL,&thread);

	test(r==KErrNone);

	thread.Logon(s);

	test(s==KRequestPending);

	TBool justInTime=User::JustInTime();

	User::SetJustInTime(EFalse);

	thread.Resume();

	User::WaitForRequest(s);

	test(s==ERTimerAfterTimeNegative);

	test(thread.ExitCategory()==_L("USER"));

	test(thread.ExitReason()==ERTimerAfterTimeNegative);

	test(thread.ExitType()==EExitPanic);

	CLOSE_AND_WAIT(thread);

	User::SetJustInTime(justInTime);

//

	test.Next(_L("After 1 second"));

	t.After(s,1000000);

	test(s==KRequestPending);

	User::WaitForRequest(s);

	test(s==KErrNone);

//

	test.Next(_L("After 1 second polling"));

	t.After(s,1000000);

	test(s==KRequestPending);

	// Have to be careful the compiler doesn't optimise this away

	while(!RequestIsComplete(s))

		; // poll

	test(s==KErrNone);

	User::WaitForRequest(s);

//

	test.Next(_L("Cancel"));

	t.After(s,1000000);

	test(s==KRequestPending);

	t.Cancel();

	User::WaitForRequest(s);

	test(s==KErrCancel);

	t.Close();

//

	test.Next(_L("Request twice"));

	r=thread.Create(_L("After twice"),AfterTwice,KDefaultStackSize,NULL,&thread);

	test(r==KErrNone);

	thread.Logon(s);

	test(s==KRequestPending);

	User::SetJustInTime(EFalse);

	thread.Resume();

	User::WaitForRequest(s);

	test(s==ETimerAlreadyPending);

	test(thread.ExitCategory()==_L("KERN-EXEC"));

	test(thread.ExitReason()==ETimerAlreadyPending);

	test(thread.ExitType()==EExitPanic);

	CLOSE_AND_WAIT(thread);

	User::SetJustInTime(justInTime);

//

	test.End();

	}

#ifdef REQUEST_STATUS_POLL_SOAK_TEST

static volatile TBool PollTestRunning;

LOCAL_C TInt PollThread(TAny* aArg)

	{

	const TInt KMaxTimers = 1000;

	TInt threadIndex = (TInt)aArg;

	TInt64 seed = 5511498647534504549 + RThread().Id();

	RTimer timers[KMaxTimers];

	TRequestStatus statuses[KMaxTimers];

	TInt i;

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

		{

		test_KErrNone(timers[i].CreateLocal());

		statuses[i] = 1;

		}

	TInt totalComplete = 0;

	TInt totalWaiting = 0;

	while(PollTestRunning)

		{

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

			{

			switch(statuses[i].Int())

				{

				case KRequestPending:

					// do nothing

					++totalWaiting;

					break;

				case KErrNone:

					User::WaitForRequest(statuses[i]);

					++totalComplete;

					// fall through

				case 1:

					{

					TInt after = ((TUint)Math::Rand(seed) >> 28) + 1;

					timers[i].HighRes(statuses[i], after);

					}

					break;

				default:

					return statuses[i].Int();

				}

			}

		}

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

		{

		User::WaitForRequest(statuses[i]);

		if (statuses[i].Int() != KErrNone)

			return statuses[i].Int();

		timers[i].Close();

		}

	RDebug::Printf("%d: %d %d\n", threadIndex, totalComplete, totalWaiting);

	return KErrNone;

	}

LOCAL_C void testPoll()

	{

	const TInt KMaxThreads = 10;

	const TInt KSecondsToTest = 60;

	RThread threads[KMaxThreads];

	TRequestStatus statuses[KMaxThreads];

	test.Start(_L("Test polling"));

	PollTestRunning = ETrue;

	TInt i;

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

		{

		test_KErrNone(threads[i].Create(KNullDesC, PollThread, 0x1000, NULL, (TAny*)i));

		threads[i].Logon(statuses[i]);

		threads[i].Resume();

		}

	User::After(KSecondsToTest * 1000 * 1000);

	PollTestRunning = EFalse;

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

		{

		User::WaitForRequest(statuses[i]);

		test_KErrNone(statuses[i].Int());

		test_Equal(EExitKill, threads[i].ExitType());

		threads[i].Close();

		}

	test.End();

	}

#endif

LOCAL_C void testHomeTime()

//

// Test HomeTime.

//

	{

    TTime t1, t2;

    t1.HomeTime();

    for (TInt x=0;x<100;x++)

        {

        do

            {

            t2.HomeTime();

            }

        while (t2==t1);

#if defined(_DEBUG)

		TDateTime dt=t2.DateTime();

		test.Printf(_L("%d:%d\r\n"),dt.Second(),dt.MicroSecond());

#endif

        test(t2>t1);

        t1=t2;

        }

#if defined(_DEBUG)

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

#endif

    }

TInt AtTwice(TAny*)

	{

	RTimer t;

	TInt r=t.CreateLocal();

	test(r==KErrNone);

	TRequestStatus s;

	TTime time;

	time.UniversalTime();

	t.AtUTC(s,time+TTimeIntervalSeconds(1));

	test(s==KRequestPending);

	t.AtUTC(s,time+TTimeIntervalSeconds(2));

	return KErrNone;

	}

TInt AtAfter(TAny*)

	{

	RTimer t;

	TInt r=t.CreateLocal();

	test(r==KErrNone);

	TRequestStatus s;

	TTime time;

	time.UniversalTime();

	t.AtUTC(s,time+TTimeIntervalSeconds(1));

	test(s==KRequestPending);

	t.After(s,1000000);

	return KErrNone;

	}

TInt AfterAt(TAny*)

	{

	RTimer t;

	TInt r=t.CreateLocal();

	test(r==KErrNone);

	TRequestStatus s;

	TTime time;

	time.UniversalTime();

	t.After(s,1000000);

	test(s==KRequestPending);

	t.AtUTC(s,time+TTimeIntervalSeconds(2));

	return KErrNone;

	}

LOCAL_C void testAbs()

//

// Test absolute timers.

//

	{

	test.Start(_L("Now -1"));

	RTimer t;

	TInt r=t.CreateLocal();

	test(r==KErrNone);

	TRequestStatus s;

	TTime time;

	time.UniversalTime();

	t.AtUTC(s,time+TTimeIntervalSeconds(-2));

	test(s==KErrUnderflow);  // =KRequestPending

	User::WaitForRequest(s);

	test(s==KErrUnderflow);

//

	TTime time2;

	test.Next(_L("Synchronise to clock"));

	time.UniversalTime();

    TDateTime dateTime=time.DateTime();

	dateTime.SetMicroSecond(0);

    time=dateTime;

 	time+=TTimeIntervalSeconds(2);

	t.AtUTC(s,time);

	User::WaitForRequest(s);

	test.Next(_L("Now +1"));

	time += TTimeIntervalSeconds(1);

	t.AtUTC(s,time);

	test(s==KRequestPending);

	User::WaitForRequest(s);

	time2.UniversalTime();

	test(s==KErrNone);

	TTimeIntervalMicroSeconds delay=time2.MicroSecondsFrom(time);

	// Test we are in the same second as the requested time...

	test(delay>=TTimeIntervalMicroSeconds(0));

	test(delay<TTimeIntervalMicroSeconds(1000000));

	test.Next(_L("Now +3"));

	time += TTimeIntervalSeconds(3);

	t.AtUTC(s,time);

	test(s==KRequestPending);

	User::WaitForRequest(s);

	time2.UniversalTime();

	test(s==KErrNone);

	delay=time2.MicroSecondsFrom(time);

	// Test we are in the same second as the requested time...

	test(delay>=TTimeIntervalMicroSeconds(0));

	test(delay<TTimeIntervalMicroSeconds(1000000));

//

	test.Next(_L("UTC vs local"));

	TTimeIntervalSeconds savedOffset = User::UTCOffset();

	User::SetUTCOffset(3600);

	time.HomeTime();

	time += TTimeIntervalSeconds(1);

	t.At(s,time);

	test(s==KRequestPending);

	User::WaitForRequest(s);

	time2.HomeTime();

	test(s==KErrNone);

	delay=time2.MicroSecondsFrom(time);

	// Test we are in the same second as the requested time...

	test(delay>=TTimeIntervalMicroSeconds(0));

	test(delay<TTimeIntervalMicroSeconds(1000000));

	time.UniversalTime();

	time += TTimeIntervalSeconds(1);

	t.AtUTC(s,time);

	test(s==KRequestPending);

	User::WaitForRequest(s);

	time2.UniversalTime();

	test(s==KErrNone);

	delay=time2.MicroSecondsFrom(time);

	// Test we are in the same second as the requested time...

	test(delay>=TTimeIntervalMicroSeconds(0));

	test(delay<TTimeIntervalMicroSeconds(1000000));

	User::SetUTCOffset(savedOffset);	

//

	test.Next(_L("Cancel"));

	time.UniversalTime();

	t.AtUTC(s,time+TTimeIntervalSeconds(10));

	test(s==KRequestPending);

	t.Cancel();

	User::WaitForRequest(s);

	test(s==KErrCancel);

	t.Close();						

//

	test.Next(_L("Request twice"));

	RThread thread;

	r=thread.Create(_L("At twice"),AtTwice,KDefaultStackSize,NULL,&thread);

	test(r==KErrNone);

	thread.Logon(s);

	test(s==KRequestPending);

	TBool justInTime=User::JustInTime();

	User::SetJustInTime(EFalse);

	thread.Resume();

	User::WaitForRequest(s);

	User::SetJustInTime(justInTime);

	test(s==ETimerAlreadyPending);

	test(thread.ExitCategory()==_L("KERN-EXEC"));

	test(thread.ExitReason()==ETimerAlreadyPending);

	test(thread.ExitType()==EExitPanic);

	CLOSE_AND_WAIT(thread);

//

	r=thread.Create(_L("At After"),AtAfter,KDefaultStackSize,NULL,&thread);

	test(r==KErrNone);

	thread.Logon(s);

	test(s==KRequestPending);

	User::SetJustInTime(EFalse);

	thread.Resume();

	User::WaitForRequest(s);

	User::SetJustInTime(justInTime);

	test(s==ETimerAlreadyPending);

	test(thread.ExitCategory()==_L("KERN-EXEC"));

	test(thread.ExitReason()==ETimerAlreadyPending);

	test(thread.ExitType()==EExitPanic);

	CLOSE_AND_WAIT(thread);

//

	r=thread.Create(_L("After At"),AfterAt,KDefaultStackSize,NULL,&thread);

	test(r==KErrNone);

	thread.Logon(s);

	test(s==KRequestPending);

	User::SetJustInTime(EFalse);

	thread.Resume();

	User::WaitForRequest(s);

	User::SetJustInTime(justInTime);

	test(s==ETimerAlreadyPending);

	test(thread.ExitCategory()==_L("KERN-EXEC"));

	test(thread.ExitReason()==ETimerAlreadyPending);

	test(thread.ExitType()==EExitPanic);

	CLOSE_AND_WAIT(thread);

//

	test.End();

	}

TInt LockTwice(TAny*)

	{

	RTimer t;

	test(t.CreateLocal()==KErrNone);

	TRequestStatus stat;

	t.Lock(stat, ETwelveOClock);

	User::WaitForRequest(stat);

	test(stat==KErrGeneral);

	t.Lock(stat, ETwelveOClock);

	t.Lock(stat, ETwelveOClock);

	return KErrNone;

	}

LOCAL_C void testLock()

//

// Test locked timers

//

	{

	test.Start(_L("Test synchronise to ETwelveOClock"));

	RTimer t;

	TTime time,time2;

	test(t.CreateLocal()==KErrNone);

	TRequestStatus stat;

	t.Lock(stat, ETwelveOClock);

	User::WaitForRequest(stat);

	test(stat==KErrGeneral);

	time.UniversalTime();

	t.Lock(stat, ETwelveOClock);

	User::WaitForRequest(stat);

	test(stat==KErrNone);

	time2.UniversalTime();

	test(time<time2);

	User::After(500000);

	test.Next(_L("Test sync to EOneOClock for 4 seconds"));

	t.Lock(stat, EOneOClock);

	User::WaitForRequest(stat);

	test(stat==KErrGeneral);

	time.UniversalTime();

	TInt i;

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

		{

		t.Lock(stat, EOneOClock);