// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

//

#include <e32base.h>

#include <e32test.h>

#include <csch_cli.h>

#include <f32file.h>

#include "Thelpers.h"

#include "TestUtils.h"

// Globals

RTest					TheTest(_L("TC_TSCH_SCHEDULING1 - UTC"));

static RScheduler		TheScheduler;

static RFs				TheFsSession;

typedef CArrayFixFlat<TScheduleEntryInfo2>	CScheduleEntryInfoArray;

typedef CArrayFixFlat<TTaskInfo>			CTaskInfoArray;

typedef CArrayFixFlat<TSchedulerItemRef>    CSchItemRefArray;

_LIT(KMinimalTaskHandler, "MinimalTaskHandler");

_LIT(KTimeFormatString,						"%-B%:0%J%:1%T%:2%S%.%*C4%:3%+B");

_LIT(KCurrentDateTimeChanged,				"Date & Time changed to: [%S]\n");

//***********************************************************************************

// Sets time to before specified time by aTimeBeforeInSeconds

static void SetTimeBeforeL(RTest& aTest, TTsTime& aTime, TInt aTimeBeforeInSeconds)

	{

	TTimeIntervalSeconds secs(aTimeBeforeInSeconds);

	TTime time = aTime.GetLocalTime()-secs;

	SchSvrHelpers::SetHomeTimeL(time);

	TBuf<30> dateString;

	time.FormatL(dateString, KTimeFormatString);

	aTest.Printf(KCurrentDateTimeChanged, &dateString);

	}

// gets the due time for this schedule

static TTsTime GetDueTimeL(TInt aScheduleId)

	{

	TTsTime nextTimeScheduleIsDue;

	TScheduleState2 state;

	CScheduleEntryInfoArray* entries 

		= new (ELeave) CScheduleEntryInfoArray(3);

	CleanupStack::PushL(entries);

	CTaskInfoArray* tasks = new (ELeave) CTaskInfoArray(3);

	CleanupStack::PushL(tasks);

	TInt res = TheScheduler.GetScheduleL(aScheduleId, state, *entries, *tasks, nextTimeScheduleIsDue);

	TEST2(res, KErrNone);

	CleanupStack::PopAndDestroy(2); // entries, tasks

	return state.DueTime();

	}

// Forces the task to be exectued aCount times.

static void ForceTaskExecutionForSpecifiedIdL(TInt aId, TInt aCount)

	{

	TheTest.Printf(_L("Executing %d times\n"), aCount);

	TTsTime time;

	for (TInt i=0; i<aCount; ++i)

		{

		TheTest.Printf(_L("Execution %d\n"), i+1);

		time = GetDueTimeL(aId);		

		SetTimeBeforeL(TheTest, time, 5 /*seconds*/);		

		// Wait for notification that schedule has executed.

		TEST2(STaskSemaphore::WaitL(KDefaultTimeout), KErrNone);

		CleanupHelpers::KillProcess(KMinimalTaskHandler);

		}

	}

//creates a daily schedule with StartTime of aStartTime

static TInt CreateScheduleL(TSchedulerItemRef& aRef, 

							RScheduler& aScheduler, 

							const TTsTime& aStartTime)

	{

	CScheduleEntryInfoArray* entryList 

		= new (ELeave) CScheduleEntryInfoArray(1);

	CleanupStack::PushL(entryList);

	TScheduleEntryInfo2 entry1 (aStartTime, EDaily, 1, 30);

	entryList->AppendL(entry1);

	TInt res = aScheduler.CreatePersistentSchedule(aRef, *entryList);

	CleanupStack::PopAndDestroy(); // entryList

	return res;

	}

// counts the number of scheduled items based on the supplied filter.

static TInt CountScheduledItemsL(TScheduleFilter aFilter, 

								RScheduler& aScheduler)

	// Extract schedule references from the schedule server based on a filter. If

	{

	CSchItemRefArray* refs = new (ELeave) CSchItemRefArray(3);

	CleanupStack::PushL(refs);

	TInt res = aScheduler.GetScheduleRefsL(*refs, aFilter);

	TEST2(res, KErrNone);

	TInt count = refs->Count();

	CleanupStack::PopAndDestroy(); // refs

	return count;

	}	

// Extract task references from the schedule server based on a ID

static void GetTaskInfoL(CTaskInfoArray& aTaskInfoArray,

						TInt aScheduleId)

	{

	aTaskInfoArray.Reset();

	TTsTime nextTimeScheduleIsDue;

	TScheduleState2 state;

	CScheduleEntryInfoArray* entries 

		= new (ELeave) CScheduleEntryInfoArray(3);

	CleanupStack::PushL(entries);

	TInt res = TheScheduler.GetScheduleL(aScheduleId, 

										state, 

										*entries, 

										aTaskInfoArray, 

										nextTimeScheduleIsDue);

	TEST2(res, KErrNone);

	CleanupStack::PopAndDestroy(entries);

	}

// schedules a transient task	

static TInt ScheduleTransientTaskL(TInt& aTaskId, 

								TSchedulerItemRef& aRef, 

								TInt aRepeat, 

								RScheduler& aScheduler)

	{

	CScheduleEntryInfoArray* entryList = new(ELeave) CScheduleEntryInfoArray(3);

	CleanupStack::PushL(entryList);

	aRef.iName = _L("transient one");

	// SCHEDULES

	TTime ttime1(SchSvrHelpers::UtcTimeBasedOnOffset(0, 1));

	TTsTime startTime1 (ttime1,ETrue); // 1 min in the future

	TScheduleEntryInfo2 entry1 (startTime1, EDaily, 1, 20);

	entryList->AppendL(entry1);

	TTime ttime2(SchSvrHelpers::UtcTimeBasedOnOffset(0, 2));

	TTsTime startTime2 (ttime2,ETrue); // 2 min in the future

	TScheduleEntryInfo2 entry2 (startTime2, EDaily, 1, 500);

	entryList->AppendL(entry2);

	TTime ttime3(SchSvrHelpers::UtcTimeBasedOnOffset(0, 3));

	TTsTime startTime3 (ttime3,ETrue); // 3 min in the future

	TScheduleEntryInfo2 entry3 (startTime3, EDaily, 1, 5);

	entryList->AppendL(entry3);

	// TASK

	TTaskInfo taskInfo;

	taskInfo.iName = _L("mail");

	taskInfo.iTaskId = aTaskId;

	taskInfo.iRepeat = aRepeat;

	taskInfo.iPriority = 2;

	HBufC* data = _L("the data, some strange new name ").AllocLC();

	// Schedule the item

	TInt res = aScheduler.ScheduleTask(taskInfo, *data, aRef, *entryList);

	CleanupStack::PopAndDestroy(2); // data, entryList

	aTaskId = taskInfo.iTaskId;

	return res;

	}

//***********************************************************************************

/**

@file

@SYMTestCaseID				SYSLIB-SCHSVR-CT-0254

@SYMTestCaseDesc 			Replicated test for for defect (EDNEMHE-4Q69BG) - UTC

@SYMTestPriority 			High

@SYMTestActions  			Create time based schedules and then jump to a time after the due time but within the validity period and check it schedule still fires

@SYMTestExpectedResults		The test must not fail.

@SYMPREQ					PREQ234

*/

static void Test1L()

	{

	_LIT(KTaskData1, "This is some really exciting task data (number 1)");

	_LIT(KTaskData2, "This is some really exciting task data (number 2)");

	_LIT(KTestName,	"SmsTest");

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-0254 TheTest3: SMS:Sending to multiple recipients "));

	TheTest.Next(_L("Connect to Scheduler"));

	TInt res = TheScheduler.Connect();

	TEST2(res, KErrNone);

	TheTest.Next(_L("Registering Client"));

	TEST2(SchSvrHelpers::RegisterClientL(TheScheduler), KErrNone);

	// Set the time to a known value, since this makes testing much easier (and more

	// repeatable).	

	SchSvrHelpers::SetHomeTimeL(TTime(TDateTime(2000, EJanuary, 1, 9, 55, 0, 0))); // 9:55 am

	// This is the time when we want the schedule to fire

	TDateTime datetime(2000, EJanuary, 1, 10, 0, 0, 0);

	TTsTime startTimeForSchedule(datetime, ETrue); // 10:00 am

	// Prepare a schedule describing when we want the tasks to run (10:00 am)

	TSchedulerItemRef ref;

	User::LeaveIfError(CreateScheduleL(ref, TheScheduler, startTimeForSchedule));

	// Disable the schedule whilst we set it up

	User::LeaveIfError(TheScheduler.DisableSchedule(ref.iHandle));

	// Associate a task with the schedule

	TTaskInfo taskInfo1;

	taskInfo1.iRepeat = 0;

	taskInfo1.iName = KTestName;

	taskInfo1.iPriority = 2;

	// Create some data associated with this task

	HBufC* taskData1 = KTaskData1().AllocLC();

	User::LeaveIfError(TheScheduler.ScheduleTask(taskInfo1, *taskData1, ref.iHandle));

	CleanupStack::PopAndDestroy(); // taskData1

	// Associate a task (2) with the schedule

	TTaskInfo taskInfo2;

	taskInfo2.iRepeat = 0;

	taskInfo2.iName = KTestName;

	taskInfo2.iPriority = 2;

	// Create some data associated with this task

	HBufC* taskData2 = KTaskData2().AllocLC();

	User::LeaveIfError(TheScheduler.ScheduleTask(taskInfo2, *taskData2, ref.iHandle));

	CleanupStack::PopAndDestroy(); // taskData2

	// We should now have two tasks scheduled at exactly the same time...

	User::LeaveIfError(TheScheduler.EnableSchedule(ref.iHandle));

	// Set the time to 5 minutes *AFTER* the schedule was due to run (10:05am). In this instance,

	// based on the new fixed Schedule Server, the schedule should still execute since 

	// it falls within the validity period (30 mins), however, in the old scheme of things,

	// the schedule would not be valid again until tomorrow (2/1/2000) at 10:00am and hence

	// would not execute until then.	

	SchSvrHelpers::SetHomeTimeL(TTime(TDateTime(2000, EJanuary, 1, 10, 5, 0, 0))); // 10:05 am

	// Now wait for something to happen...

	TEST2(STaskSemaphore::WaitL(KDefaultTimeout), KErrNone);

	CleanupHelpers::KillProcess(KMinimalTaskHandler);

	}

//***********************************************************************************

/**

@file

@SYMTestCaseID				SYSLIB-SCHSVR-CT-0255

@SYMTestCaseDesc 			Replicated test for for defect (EDNEMHE-4Q69BG) - UTC

@SYMTestPriority 			High

@SYMTestActions  			Create time based schedules and then jump to a time after the due time but within the validity period and check it schedule still fires

@SYMTestExpectedResults		The test must not fail.

@SYMPREQ					PREQ234

*/

static void Test2L()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-0255 Testing creation of transient schedule with task repeating 5 times "));	

	TInt tTask = 0;

	TSchedulerItemRef ref;

	// schedule has 3 entries - +1min, +2min and +3min

	TInt res = ScheduleTransientTaskL(tTask, ref, 5, TheScheduler);//5 repeats

	TEST2(res, KErrNone);

	TheTest.Printf(_L("Get Task count and repeat count\n"));

	CTaskInfoArray* tasks = new (ELeave) CTaskInfoArray(3);

	CleanupStack::PushL(tasks);

	GetTaskInfoL(*tasks, ref.iHandle);

	TEST(tasks->Count() == 1);

	TTaskInfo info = tasks->At(0);

	TEST(info.iRepeat == 5);

	ForceTaskExecutionForSpecifiedIdL(ref.iHandle, 3);

	GetTaskInfoL(*tasks, ref.iHandle);

	TEST(tasks->Count() == 1);

	info = tasks->At(0);

	TEST(info.iRepeat == 2); // still 2 repeats to go.

	ForceTaskExecutionForSpecifiedIdL(ref.iHandle, 2);

	CleanupStack::PopAndDestroy(tasks);

	TInt scheduleCount = CountScheduledItemsL(EPendingSchedules, TheScheduler);

	// There should be no schedules as its a transient one and last schedule

	// should have deleted itself.

	TEST(scheduleCount == 0); 

	SchSvrHelpers::Pause(TheTest);

	}

//***********************************************************************************

/**

@file

@SYMTestCaseID				SYSLIB-SCHSVR-CT-0256

@SYMTestCaseDesc 			Replicated test for for defect (DEF055586L) - UTC

@SYMTestPriority 			High

@SYMTestActions  			Create a time-based schedule check that there are 0 entries in the scehule after it fires

@SYMTestExpectedResults		The test must not fail.

@SYMPREQ					PREQ234

*/

static void DEF055586L()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-0256 DEF055586 - Last element in array missed by loop "));

	TheTest.Next(_L("Connect to Scheduler"));

	TInt res = TheScheduler.Connect();

	TEST2(res, KErrNone);

	TheTest.Next(_L("Registering Client"));

	TEST2(SchSvrHelpers::RegisterClientL(TheScheduler), KErrNone);

	// Set the time to a known value, since this makes testing much easier (and more

	// repeatable).	

	SchSvrHelpers::SetHomeTimeL(TTime(TDateTime(2000, EJanuary, 1, 9, 55, 0, 0))); // 9:55 am

	// This is the time when we want the schedule to fire

	TDateTime datetime(2000, EJanuary, 1, 10, 0, 0, 0);

	TTsTime startTimeForSchedule(datetime, ETrue); // 10:00 am

	// Prepare a schedule describing when we want the tasks to run (10:00 am)

	TSchedulerItemRef ref;

	CScheduleEntryInfoArray* entryList = new (ELeave) CScheduleEntryInfoArray(1);

	CleanupStack::PushL(entryList);

	TScheduleEntryInfo2 entry1 (startTimeForSchedule, EDaily, 0, 30); // TTimeIntervalDays: set to 0 to induce an error

	entryList->AppendL(entry1);

	TInt err = TheScheduler.CreatePersistentSchedule(ref, *entryList);

	TEST2(err, KErrArgument);

	TheTest.Next(_L("DEF055586 - Now checking 0 entries in schedule"));

	entryList->Reset();

	err = TheScheduler.CreatePersistentSchedule(ref, *entryList);

	TEST2(err, KErrArgument);

	CleanupStack::PopAndDestroy(); // entryList

	}

//DEF061595  Schedule timers incorrectly expire when system time is changed 	

//The test will create and submit one schedule which execution time is one year later.

//Then the test will change the system time to be current time + 1 day.

//Although the schedule time is set to be current time + 1 year, the schedule task(s) will

//be executed immediately because the schedule timer expires when the system time changes.

void DEF061595L()

	{

	TheTest.Next(_L("DEF061595  Schedule timers incorrectly expire when system time is changed"));

	//Get current time in currTime variable

	TTime currTime;		

	currTime.HomeTime();

	//Prepare the task time (in taskTime variable) to be currTime + 1 year.

	TTime taskTime(currTime + TTimeIntervalYears(1));		

	TInt taskYear = taskTime.DateTime().Year();

	//Connect to the Task Scheduler Server	

	RScheduler	scheduler;

	CleanupClosePushL(scheduler);

	TInt res = scheduler.Connect();

	TEST2(res, KErrNone);

	TEST2(SchSvrHelpers::RegisterClientL(scheduler), KErrNone);

	//Create new schedule. The new schedule task will run 1 year later.

	TTsTime taskTsTime(taskTime, EFalse);

	TSchedulerItemRef ref;

	TEST2(::CreateScheduleL(ref, scheduler, taskTsTime), KErrNone);

	// Disable the schedule whilst we set it up

	TEST2(scheduler.DisableSchedule(ref.iHandle), KErrNone);

	// Associate a task with the schedule

	_LIT(KTaskInfo, "DEF061595");

	TTaskInfo taskInfo;

	taskInfo.iRepeat = 0;

	taskInfo.iName = KTaskInfo;

	taskInfo.iPriority = 2;

	const TInt KTaskDataLen = 1;

	HBufC* taskData = HBufC::NewLC(KTaskDataLen);

	TEST2(scheduler.ScheduleTask(taskInfo, *taskData, ref.iHandle), KErrNone);

	//We should now have one tasks scheduled to be executed after 1 year.

	//Enable schedule.

	TEST2(scheduler.EnableSchedule(ref.iHandle), KErrNone);

	//Get the scheduled task info. The task year should be the same as it was set in the schedule.

	TTime nextTime;	

	TPtr pTaskData = taskData->Des();

	TEST2(scheduler.GetTaskInfoL(taskInfo.iTaskId, taskInfo, pTaskData, ref, nextTime), KErrNone);

	TInt nextTaskYear = nextTime.DateTime().Year();	

	TEST(nextTaskYear == taskYear);

	//Change the system time to be current time + 1 day	

	TEST2(SchSvrHelpers::SetUTCTimeL(currTime + TTimeIntervalDays(1)), KErrNone);

	//Get the scheduled task info again. If the defect is not fixed, the call will fail

	//with KErrNotFound (because SchSvrHelpers::SetUTCTimeL() call will make the schedule timer to expire)

	TInt err = scheduler.GetTaskInfoL(taskInfo.iTaskId, taskInfo, pTaskData, ref, nextTime);

//TODO	TEST2(err, KErrNone);

//TODO	nextTaskYear = nextTime.DateTime().Year();

//TODO	TEST(nextTaskYear == taskYear);

	CleanupStack::PopAndDestroy(taskData);

	CleanupStack::PopAndDestroy(&scheduler);

	CleanupHelpers::KillProcess(KMinimalTaskHandler);

	}

/**

@SYMTestCaseID          SYSLIB-SCHSVR-CT-1655

@SYMTestCaseDesc	    Tests for defect number DEF079983

@SYMTestPriority 	    High

@SYMTestActions  	    Check to ensure all task files have been cleaned up

						after scheduled tasks completed

@SYMTestExpectedResults Test must not fail

@SYMDEF 				DEF079983

*/		

static void DEF079983L()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-1655 DEF079983: Private directory of schsvr flooded with files "));

	// A dummy scheduled task:

	// Create some transient schedule task and repeat 5 times

	TheTest.Printf(_L("DEF079983: Create a dummy scheduled task"));

	TInt tTask = 0;

	TSchedulerItemRef ref;

	// 5 repeats

	TInt res = ScheduleTransientTaskL(tTask, ref, 5, TheScheduler);

	TEST2(res, KErrNone);

	ForceTaskExecutionForSpecifiedIdL(ref.iHandle, 5);

	// Check for left task files after scheduled tasks completed

	// To access private data cage, uses SchSvrHelplers::CheckTaskFilesL()

	TheTest.Next(_L("DEF079983: Now checking no files left when tasks completed"));

	TInt err = SchSvrHelpers::CheckTaskFilesL();

	// If there's any task files left, test fails with error code KErrGeneral

	TEST(err == KErrNone);

	}		

/**

@SYMTestCaseID          SYSLIB-SCHSVR-CT-3362

@SYMTestCaseDesc	    Replicated test for for defect (INC098909) - UTC   

@SYMTestPriority 	    High

@SYMTestActions  	    Mark heap of Scheduler then create a schedule & task wait for its 

						execution then check heap again for memory leaks

@SYMTestExpectedResults Test must not fail (i.e. No memory leaks)

@SYMDEF                INC098909: Process !TaskScheluder leaks memory in mail polls.

*/

static void INC098909()

	{

	const TInt KTimeToWait = 10*1000*1000; 

	SchSvrHelpers::DeleteScheduleFilesL();

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-3362 INC098909: Process !TaskScheluder leaks memory in mail polls "));

	TheTest.Next(_L("Connect to Scheduler"));

	TEST2(TheScheduler.Connect(),KErrNone);

	TheTest.Next(_L("Registering Client"));

	TEST2(SchSvrHelpers::RegisterClientL(TheScheduler), KErrNone);

	User::LeaveIfError(TheScheduler.__DbgMarkHeap());

	//Create Schedule

	CArrayFixFlat<TScheduleEntryInfo2>* entryList = new(ELeave) CArrayFixFlat<TScheduleEntryInfo2>(1);

	CleanupStack::PushL(entryList);

	TSchedulerItemRef ref;

	TTsTime startTime1(SchSvrHelpers::UtcTimeBasedOnOffset(0, 0), ETrue); // 0m:0s from "now"

	TScheduleEntryInfo2 entry1 (startTime1, EDaily, 1, 20);

	entryList->AppendL(entry1);

	// Create the schedule for the task...

	TEST2(TheScheduler.CreatePersistentSchedule(ref, *entryList),KErrNone);

	//Create Task

	TTaskInfo task;

	task.iRepeat	= 1; // repeat once

	task.iName		= _L("Test ");

	task.iPriority	= 100;

	HBufC* taskData = HBufC::NewLC(1);

	TEST2(TheScheduler.ScheduleTask(task, *taskData,ref.iHandle), KErrNone);

	CleanupStack::PopAndDestroy(taskData);

	CleanupStack::PopAndDestroy(entryList);	

	//Wait schedule to complete

	User::After(KTimeToWait);

	User::LeaveIfError(TheScheduler.__DbgMarkEnd(0));

	TheScheduler.Close();

	// really clean out the scheduler (get rid of all the files and process)

	SchSvrHelpers::DeleteScheduleFilesL();

	CleanupHelpers::KillProcess(KMinimalTaskHandler);

	// Now wait for something to happen...

	TEST2(STaskSemaphore::WaitL(KDefaultTimeout), KErrNone);	

	}

GLDEF_C TInt DoTheTestsL()

	{

	//Delete old files.

	SchSvrHelpers::DeleteScheduleFilesL();

	STaskSemaphore sem;

	sem.CreateL();

	TheTest.Next(_L("Start tests"));

	// Add tests here:-

	Test1L();

	Test2L();

	INC098909();

	DEF055586L();

	DEF061595L();

	DEF079983L();	// task file check test

	sem.Close();

	//Tidying up so next test will be clear.

	TheTest.Next(_L("Delete all schedules"));

	SchSvrHelpers::DeleteAllSchedulesL(TheScheduler);

	SchSvrHelpers::Pause(TheTest, 2);

	TheTest.Next(_L("Delete old files\n"));

	SchSvrHelpers::DeleteScheduleFilesL();

	TheScheduler.Close();

	return KErrNone;

	}

//***********************************************************************************

GLDEF_C TInt E32Main()

    {

	__UHEAP_MARK;

	TheTest.Title();

	TheTest.Start(_L("TC_TSCH_SCHEDULING1 - UTC"));

	TInt error = KErrNone;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if	(!cleanup)

		return KErrNoMemory;

	//If the previous test fails, SCHSVR.exe may stay in memory.

	TRAP(error,CleanupHelpers::TestCleanupL());

	TEST2(error, KErrNone);

	TTime now;

	now.HomeTime();

	// Used to Set the system UTC time and UTC offset

	// so that correct UTC Time values are returned while using time based APIs.

	SchSvrHelpers::SetHomeTimeL(now);

	TEST2(TheFsSession.Connect(), KErrNone);

	TheTest.Next(_L("Do the tests"));

	TRAP(error, DoTheTestsL());

	TEST2(error,KErrNone);

	TheFsSession.Close();

	TRAP(error,CleanupHelpers::TestCleanupL());

	TEST2(error, KErrNone);

	delete cleanup;	

	TheTest.End();

	TheTest.Close();

	__UHEAP_MARKEND;

	return KErrNone;

	}