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

static RScheduler		TheScheduler;

static RFs				TheFsSession;

typedef CArrayFixFlat<TScheduleEntryInfo>	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");

const TInt KTimeToWait = 4*1000*1000;

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

// Sets time to before specified time by aTimeBeforeInSeconds

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

	{

	TTimeIntervalSeconds secs(aTimeBeforeInSeconds);

	TTime time = aTime-secs;

	SchSvrHelpers::SetHomeTimeL(time);

	TBuf<30> dateString;

	time.FormatL(dateString, KTimeFormatString);

	aTest.Printf(KCurrentDateTimeChanged, &dateString);

	}

// gets the due time for this schedule

static TTime GetDueTimeL(TInt aScheduleId)

	{

	TTime nextTimeScheduleIsDue;

	TScheduleState 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.iDueTime;

	}

// Forces the task to be exectued aCount times.

static void ForceTaskExecutionForSpecifiedIdL(TInt aId, TInt aCount)

	{

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

	TTime 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 TTime& aStartTime)

	{

	CScheduleEntryInfoArray* entryList 

		= new (ELeave) CScheduleEntryInfoArray(1);

	CleanupStack::PushL(entryList);

	TScheduleEntryInfo entry1;

	entry1.iStartTime		= aStartTime;

	entry1.iInterval		= 1; // TTimeIntervalDays

	entry1.iIntervalType	= EDaily;

	entry1.iValidityPeriod	= 30; // minutes

	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();

	TTime nextTimeScheduleIsDue;

	TScheduleState 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");

	// SCEHDULES

	TScheduleEntryInfo entry1;

	entry1.iStartTime = SchSvrHelpers::TimeBasedOnOffset(0, 1); // 1 min in the future

	entry1.iInterval = 1;

	entry1.iIntervalType = EDaily;

	entry1.iValidityPeriod = 20;

	entryList->AppendL(entry1);

	TScheduleEntryInfo entry2;

	entry2.iStartTime = SchSvrHelpers::TimeBasedOnOffset(0, 2); // 2 mins in the future

	entry2.iInterval = 1;

	entry2.iIntervalType = EDaily;

	entry2.iValidityPeriod = 500;

	entryList->AppendL(entry2);

	TScheduleEntryInfo entry3;

	entry3.iStartTime = SchSvrHelpers::TimeBasedOnOffset(0, 3); // 3 mins in the future

	entry3.iInterval = 1;

	entry3.iIntervalType = EDaily;

	entry3.iValidityPeriod = 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;

	}

/*

 * Add Persistent and long term schedules to SchedulessBackup.dat files. this function 

 * is part of the DEF108026 defect testing called by DEF108026() 		

 * It is part of the manual test SYSLIB-SCHSVR-CT-4003

 * should be commented and will run as manual test only.

 * 

 * 

 static void DEF108026_AddPersistentSchedulesL( TBool aImmediate )

	{	

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

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

	_LIT(KTestName,	"Def108026_test");

	TheTest.Next(_L("Def108026_test: Adding schedules"));

	RDebug::Print(_L("DEF108026_AddPersistentSchedulesL"));

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

	TInt res = TheScheduler.Connect();

	TEST2(res, KErrNone);

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

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

	TTime startTimeForSchedule;

	if ( aImmediate )

		{

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

		startTimeForSchedule = TTime( (TDateTime(2007, EJune, 20, 10, 00, 0, 0)) ); 

		RDebug::Print( _L("Added immediate schedule"));

		}

	else

		{

		startTimeForSchedule = TTime( (TDateTime(2037, EJune, 20, 10, 00, 0, 0)) ); // These schedules are due in the future.

		RDebug::Print( _L("Added long-term schedule"));	

		}

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

	CleanupHelpers::KillProcess(KMinimalTaskHandler);

	}

*

** end of DEF108026_AddPersistentSchedulesL() **/

/**

@SYMTestCaseID          SYSLIB-SCHSVR-CT-1031

@SYMTestCaseDesc	    Test code for defect "Sending SMS to multiple recipients

						sends message to only one recipient" (EDNEMHE-4Q69BG)

@SYMTestPriority 	    High

@SYMTestActions  	    Schedule two tasks to run at same time

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/		

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-1031 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

	TTime startTimeForSchedule(TDateTime(2000, EJanuary, 1, 10, 0, 0, 0)); // 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);

	}

/**

@SYMTestCaseID          SYSLIB-SCHSVR-CT-1032

@SYMTestCaseDesc	    Tests for creation of transient schedule with task repeating 5 times

@SYMTestPriority 	    High

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

						should have deleted by itself.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/		

static void Test2L()

	{	

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-1032 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);

	}

/**

@SYMTestCaseID          SYSLIB-SCHSVR-CT-1341

@SYMTestCaseDesc	    Tests for defect number DEF055586L

@SYMTestPriority 	    High

@SYMTestActions  	    Check to ensure that last element in schedule entries

                        array not skipped by schedule checking functions

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/		

static void DEF055586L()

	{	

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-1041 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

	TTime startTimeForSchedule(TDateTime(2000, EJanuary, 1, 10, 0, 0, 0)); // 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);

	TScheduleEntryInfo entry1;

	entry1.iStartTime		= startTimeForSchedule;

	entry1.iInterval		= 0; // TTimeIntervalDays: set to 0 to induce an error

	entry1.iIntervalType	= EDaily;

	entry1.iValidityPeriod	= 30; // minutes

	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

	}

/**

@SYMTestCaseID          SYSLIB-SCHSVR-CT-3159

@SYMTestCaseDesc	    Tests for defect number DEF094149

@SYMTestPriority 	    Normal

@SYMTestActions  	    Create one Schedule and two task in it, then delete one task

						check whether Task Scheduler execute disabled Schedule 

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/		

void DEF094149L()

	{	

	// Create  scheduling entries

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-3159 DEF094149: RF Task Scheduler execute deleted tasks (in stress conditions) "));

	TTime time;

	time.HomeTime();

	time += TTimeIntervalSeconds(2); // Scheduler will run task in 2 seconds

	TScheduleEntryInfo entry;

	entry.iIntervalType	= EHourly;

	entry.iStartTime		= time;

	entry.iInterval		= 1;

	entry.iValidityPeriod	= 20;

	CArrayFixFlat<TScheduleEntryInfo>* entries = new(ELeave) CArrayFixFlat<TScheduleEntryInfo>(10);

	CleanupStack::PushL(entries);

	entries->AppendL(entry);

	TSchedulerItemRef ref;

	// Create the schedule for the task... and disable it

	TheScheduler.Connect();

	TheScheduler.CreatePersistentSchedule(ref, *entries);

	TheScheduler.DisableSchedule(ref.iHandle);

// CreateNewTask

	TTaskInfo task;

	task.iRepeat	= 1; // repeat once

	task.iName		= _L("Test Task For Defect Verification");

	task.iPriority	= 100;

	TBuf<255>fileName = _L("Some task");

	TheScheduler.Register( fileName, 1 );

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

	//first task

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

	TInt taskid1;

	taskid1 = task.iTaskId;

	//Second task

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

	TInt taskid2;

	taskid2 = task.iTaskId;

	TInt err = TheScheduler.DeleteTask(taskid1);

	User::After(KTimeToWait);

	err = TheScheduler.DeleteTask(taskid2);

	//check whether Task Scheduler execute the second task after deleting first tasks 

	//If the Schedule executed then err == KErrNotFound

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(taskData);	

	CleanupStack::PopAndDestroy(entries);	

	}

/**

@SYMTestCaseID          SYSLIB-SCHSVR-CT-3358

@SYMTestCaseDesc	    Tests for defect number  INC098909 

@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

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

*/

static void INC098909()

	{

	const TInt KTimeToWait = 5*1000*1000; 

	//SchSvrHelpers::DeleteScheduleFilesL();