// Copyright (c) 2004-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 <csch_cli.h>

#include "Thelpers.h"

#include <e32base.h>

#include <e32test.h>

#include <f32file.h>

#include <s32file.h>

#include <e32property.h>

#include <schinfointernal.h>

#include "TestUtils.h"

_LIT(KTestName,	"Task Scheduler Condition Scheduling Test");

RTest	TheTest(KTestName);

typedef CArrayFixFlat<TTaskInfo>			CTaskInfoArray;

typedef CArrayFixFlat<TSchedulerItemRef>    CSchItemRefArray;

typedef CArrayFixFlat<TTaskSchedulerCondition>	CSchConditionArray;

static RScheduler	TheScheduler;

static CTrapCleanup*	TheCleanup;

static RFs			TheFsSession;

const TInt KTestKey1 = 1;

const TInt KTestKey2 = 2;

const TInt KTestKey3 = 3;

_LIT(KMinimalTaskHandler, "MinimalTaskHandler");

_LIT(KSeparator, "|"); // Invalid filepath char used to separate filenames

// This function launches the TPropertyDefine process which

//	has WriteDeviceData Capabilities enabling it to create the P&S 

//	variables used by this test.

static void LaunchHelperL(TUid aCategory, TInt aKey, TInt aAttr)

	{

	_LIT(KConditionHelper, "TPropertyDefine");

	TRequestStatus stat;

	RProcess p;

	TBuf<32> args;

	args.AppendNum(aCategory.iUid);

	args.Append(KSeparator);

	args.AppendNum(aKey);

	args.Append(KSeparator);

	args.AppendNum(aAttr);

	User::LeaveIfError(p.Create(KConditionHelper, args,EOwnerProcess));

	// Asynchronous logon: completes when process terminates with process exit code

	p.Logon(stat);

	p.Resume();

	User::WaitForRequest(stat);

	TInt exitReason = p.ExitReason();

	p.Close();

	User::LeaveIfError(exitReason);

	}

static void CreateTestVariables()

	{

	LaunchHelperL(KUidSystemCategory, KTestKey1,RProperty::EInt);

	LaunchHelperL(KUidSystemCategory, KTestKey2,RProperty::EInt);

	LaunchHelperL(KUidSystemCategory, KTestKey3,RProperty::EInt);	

	}	

static void ResetVariablesL(TInt aKey1Val,

							TInt aKey2Val,

							TInt aKey3Val)

	{

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KTestKey1,aKey1Val));

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KTestKey2,aKey2Val));

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KTestKey3,aKey3Val));		

	}

static void GetTaskInfoL(CTaskInfoArray& aTaskInfoArray,

						TInt aScheduleId)

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

	{

	aTaskInfoArray.Reset();

	TTime defaultTime;

	TScheduleState state;

	CSchConditionArray* conditionList 

		= new (ELeave) CSchConditionArray(3);

	CleanupStack::PushL(conditionList);

	TInt res = TheScheduler.GetScheduleL(aScheduleId, 

										state, 

										*conditionList, 

										defaultTime,

										aTaskInfoArray);

	TEST2(res, KErrNone);

	CleanupStack::PopAndDestroy(conditionList);

	}

static TInt CountTasksL(TInt aScheduleId)	

	{

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

	CleanupStack::PushL(tasks);

	GetTaskInfoL(*tasks, aScheduleId);

	TInt ret = tasks->Count();

	CleanupStack::PopAndDestroy(tasks);

	return ret;

	}

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;

	}

static CSchConditionArray* CreateSingleConditionLC(const TUid& aConditionUID,

									TUint aConditionUInt)

	{

	CSchConditionArray* conditionList = new (ELeave) CSchConditionArray(3);

	CleanupStack::PushL(conditionList);

	{

	TTaskSchedulerCondition condition1;

	condition1.iCategory = aConditionUID;

	condition1.iKey		= aConditionUInt;

	condition1.iState	= 10;

	condition1.iType	= TTaskSchedulerCondition::EEquals;

	conditionList->AppendL(condition1);

	}

	return conditionList;

	}

static CSchConditionArray* CreateMultipleConditionsLC()

	{

	CSchConditionArray* conditionList = new (ELeave) CSchConditionArray(3);

	CleanupStack::PushL(conditionList);

	{

	TTaskSchedulerCondition condition1;

	condition1.iCategory = KUidSystemCategory;

	condition1.iKey		= KTestKey1;

	condition1.iState	= 10;

	condition1.iType	= TTaskSchedulerCondition::EEquals;

	conditionList->AppendL(condition1);

	}

	{

	TTaskSchedulerCondition condition2;

	condition2.iCategory = KUidSystemCategory;

	condition2.iKey		= KTestKey2;

	condition2.iState	= 10;

	condition2.iType	= TTaskSchedulerCondition::ENotEquals;

	conditionList->AppendL(condition2);

	}

	{

	TTaskSchedulerCondition condition3;

	condition3.iCategory = KUidSystemCategory;

	condition3.iKey		= KTestKey3;

	condition3.iState	= 10;

	condition3.iType	= TTaskSchedulerCondition::ELessThan;

	conditionList->AppendL(condition3);

	}

	return conditionList;		

	}

// single condition with default time set to 1 year in the future

// As this is a valid time a CTimer object actually gets set unlike 

// if Time::TTimeMax() is used, hence we need to test for both cases.

static TInt CreateScheduleSingle1L(TSchedulerItemRef& aRef, 

									RScheduler& aScheduler,

									const TUid& aConditionUID,

									TUint aConditionUInt)

	{

	aRef.iName = _L("Schedule created using CreateScheduleSingle");

	CSchConditionArray* conditionList 

		= CreateSingleConditionLC(aConditionUID, aConditionUInt);

	TTime time = SchSvrHelpers::TimeBasedOnOffset(0, 0, 0, 0, 0, 1); //1 year in the future

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

	CleanupStack::PopAndDestroy(); // conditionList

	return res;

	}

// single condition with default time set to Time::MaxTTime()

static TInt CreateScheduleSingle2L(TSchedulerItemRef& aRef, 

									RScheduler& aScheduler,

									const TUid& aConditionUID,

									TUint aConditionUInt)

	{

	aRef.iName = _L("Schedule created using CreateScheduleSingle");

	CSchConditionArray* conditionList 

		= CreateSingleConditionLC(aConditionUID, aConditionUInt);

	TTime time = Time::MaxTTime();

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

	CleanupStack::PopAndDestroy(); // conditionList

	return res;

	}

// An empty schedule list.

static TInt CreateScheduleEmpty3L(TSchedulerItemRef& aRef, 

									RScheduler& aScheduler,

									const TUid&,

									TUint )

	{

	aRef.iName = _L("Empty Schedule list created");

	CSchConditionArray* conditionList = new (ELeave) CSchConditionArray(3);

	CleanupStack::PushL(conditionList);

	TTime time = SchSvrHelpers::TimeBasedOnOffset(0, 0, 0, 0, 0, 1); //1 year in the future

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

	CleanupStack::PopAndDestroy(); // conditionList

	return res;

	}

// A null schedule.

static TInt CreateScheduleSingleNull4L(TSchedulerItemRef& aRef, 

									RScheduler& aScheduler,

									const TUid&,

									TUint )

	{

	aRef.iName = _L("One schedule in the list with a NULL uid");

	CSchConditionArray* conditionList 

		= CreateSingleConditionLC(KNullUid, 0);

	TTime time = SchSvrHelpers::TimeBasedOnOffset(0, 0, 0, 0, 0, 1); //1 year in the future

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

	CleanupStack::PopAndDestroy(); // conditionList

	return res;

	}

static TInt CreateScheduleMultipleL(TSchedulerItemRef& aRef, RScheduler& aScheduler)

	{

	aRef.iName = _L("Schedule created using CreateScheduleMultiple");

	CSchConditionArray* conditionList = CreateMultipleConditionsLC();

	TTime time = SchSvrHelpers::TimeBasedOnOffset(0, 0, 0, 0, 0, 1); //1 year in the future

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

	CleanupStack::PopAndDestroy(); // conditionList

	return res;

	}

static TInt SchedulePersistentTaskL(const TDesC& aName, 

									TInt& aNewId, 

									TInt aScheduleId, 

									RScheduler& aScheduler)

	{

	TTaskInfo taskInfo;

	taskInfo.iTaskId = aNewId;

	taskInfo.iName = aName;

	taskInfo.iPriority = 2;

	taskInfo.iRepeat = 0;

	HBufC* data = _L("the data").AllocLC();

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

	aNewId = taskInfo.iTaskId;

	CleanupStack::PopAndDestroy(); // data

	return res;

	}

/**

@SYMTestCaseID          SYSLIB-SCHSVR-CT-1024

@SYMTestCaseDesc	    Single condition based test

@SYMTestPriority 	    High

@SYMTestActions  	    Create a single schedule,check that schedule is of condition type.Wait for the condition to be satisfied

                        Check that persistent schedule has auto-deleted.Repeat the process with another schedule with time set to 

                        Time::MaxTTime().Try auto deleting the last schedule and test for not found error. 

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

static void DoTest1L()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-1024 "));

	// create a simple condition based schedule, and see if it runs.

	TInt res = KErrNone;

	TheTest.Next(_L("single condition based test"));

	__UHEAP_MARK;

	//reset the p&s variables before creating the schedule

	ResetVariablesL(0,0,0);

	TSchedulerItemRef ref1;

	TheTest.Printf(_L("Create a schedule\n"));

	res = CreateScheduleSingle1L(ref1, TheScheduler, KUidSystemCategory, KTestKey1);

	TEST2(res, KErrNone);

	TInt task1 = 0;

	_LIT(KName1, "toothpaste");

	TheTest.Printf(_L("Schedule some tasks\n"));

	res = SchedulePersistentTaskL(KName1, task1, ref1.iHandle, TheScheduler);

	TEST2(res, KErrNone);

	res = TheScheduler.__DbgMarkHeap();

	User::LeaveIfError(res); //#1

	TInt scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 1); 

	// Check that schedule is of condition type

	TScheduleType scheduleType;

	res = TheScheduler.GetScheduleTypeL(ref1.iHandle, scheduleType);

	TEST2(res, KErrNone);

	TEST(scheduleType == EConditionSchedule );	

	res = TheScheduler.__DbgMarkEnd(0);

	User::LeaveIfError(res); //#1

	TheScheduler.Close();

	SchSvrHelpers::Pause(TheTest);

	// wait for condition to be satisfied

	res = RProperty::Set(KUidSystemCategory, KTestKey1,10);

	User::LeaveIfError(res);	

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

	CleanupHelpers::KillProcess(KMinimalTaskHandler);

	res = TheScheduler.Connect();

	TEST2(res, KErrNone);

	// Register a client with the server

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

	res = SchSvrHelpers::RegisterClientL(TheScheduler);

	TEST2(res, KErrNone);

	// can't check scheduler to see if any tasks left because it's been

	// deleted as last task has completed

	//Check that persistent schedule has auto-deleted

	TheTest.Printf(_L("DEF46200 - Check schedule has auto deleted\n"));

	scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 0);

	// Attempt to delete auto-deleted schedule, should fail

	TheTest.Printf(_L("DEF46200 - Attempting to delete schedule with id %d\n"), ref1.iHandle);

	res = TheScheduler.DeleteSchedule(ref1.iHandle);

	TEST2(res, KErrNotFound);

	// now repeat process with singleschedule2

	ResetVariablesL(0,0,0);

	TheTest.Printf(_L("Create another schedule\n"));

	res = CreateScheduleSingle2L(ref1, TheScheduler, KUidSystemCategory, KTestKey1);

	TEST2(res, KErrNone);	

	TheTest.Printf(_L("Create an empty schedule list\n"));

	res = CreateScheduleEmpty3L(ref1, TheScheduler, KUidSystemCategory, KTestKey1);

	TEST2(res, KErrArgument);	

	TheTest.Printf(_L("Create an empty schedule in a list\n"));

	res = CreateScheduleSingleNull4L(ref1, TheScheduler, KUidSystemCategory, KTestKey1);

	TEST2(res, KErrArgument);	

	res = SchedulePersistentTaskL(KName1, task1, ref1.iHandle, TheScheduler);

	TEST2(res, KErrNone);

	SchSvrHelpers::Pause(TheTest);

	// we should have one outstanding task (without the check in

	// schtimer.cpp specifically for Time::MaxTTime() the timer would have

	// gone off immediately in the past.)

	TEST(CountTasksL(ref1.iHandle) == 1);

	scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 1); 

	// wait for condition to be satisfied

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KTestKey1,10));	

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

	CleanupHelpers::KillProcess(KMinimalTaskHandler);

	// can't check scheduler to see if any tasks left because it's been

	// deleted as last task has completed

	TheTest.Printf(_L("DEF46200 - Check schedule has auto deleted\n"));

	scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 0); 

	// Attempt to delete auto-deleted schedule, should fail

	TheTest.Printf(_L("DEF46200 - Attempting to delete schedule with id %d\n"), ref1.iHandle);

	res = TheScheduler.DeleteSchedule(ref1.iHandle);

	TEST2(res, KErrNotFound);

	SchSvrHelpers::Pause(TheTest);

	__UHEAP_MARKEND;

	}

/**

@SYMTestCaseID          SYSLIB-SCHSVR-CT-1025

@SYMTestCaseDesc	    Multiple conditions based tests

@SYMTestPriority 	    High

@SYMTestActions  	    Create a condition based schedule with multiple entries, and see if it runs.

                        Try auto deleting the last schedule and test for not found error. 

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

static void DoTest2L()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-1025 "));

	// create a condition based schedule with multiple entries, and see if it runs.

	TInt res = KErrNone;

	TheTest.Next(_L("multiple condition based test"));

	__UHEAP_MARK;

	//reset the p&s variables before creating the schedule

	ResetVariablesL(0,10,20);

	TSchedulerItemRef ref1;

	TheTest.Printf(_L("Create a schedule\n"));

	res = CreateScheduleMultipleL(ref1, TheScheduler);

	TEST2(res, KErrNone);	

	TInt task1 = 0;

	_LIT(KName1, "web subscription");

	TheTest.Printf(_L("Schedule some tasks\n"));

	res = SchedulePersistentTaskL(KName1, task1, ref1.iHandle, TheScheduler);

	TEST2(res, KErrNone);

	TInt scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 1); 

	// we should have one task scheduled to run

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

	CleanupStack::PushL(tasks);

	GetTaskInfoL(*tasks, ref1.iHandle);

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

	tasks->Reset();

	// wait for conditions to be satisfied

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KTestKey1,10));//"=="

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KTestKey2,1234));//"!="

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KTestKey3,9));//"<"	

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

	CleanupHelpers::KillProcess(KMinimalTaskHandler);

	// Can't check schedule for task info because it's gone

	// we should have no schedule, it has auto-deleted

	scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 0); 

	// Reset variables

	TheTest.Printf(_L("Reseting variables"));

	ResetVariablesL(0,10,20);

	TheTest.Printf(_L("DEF46200 - Attempting to delete schedule with id %d\n"), ref1.iHandle);

	res = TheScheduler.DeleteSchedule(ref1.iHandle);

	TEST2(res, KErrNotFound);

	scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 0); 

	CleanupStack::PopAndDestroy(tasks);

	SchSvrHelpers::Pause(TheTest);

	__UHEAP_MARKEND;

	}

/**

Test 3 does a lot of error checking	

@SYMTestCaseID          SYSLIB-SCHSVR-CT-1026

@SYMTestCaseDesc	    Tests for error conditions checking on task scheduler

@SYMTestPriority 	    High

@SYMTestActions  	    Create invalid P&S variable's and schedule a task,check for no argument error

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/	

static void DoTest3L()	

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-1026 "));

	// create a simple condition based schedule, and see if it runs.

	TInt res = KErrNone;

	TheTest.Next(_L("error checking test"));

	__UHEAP_MARK;

	//reset the p&s variables before creating the schedule

	ResetVariablesL(0,0,0);

	TSchedulerItemRef ref1;

	_LIT(KName1, "toothpaste");

	TheTest.Printf(_L("Create a schedule with a P&S variables that doesnt exist\n"));

	{

	const TUid KNonexistentUid = TUid::Uid(0x01234566);

	res = CreateScheduleSingle1L(ref1, TheScheduler, KNonexistentUid, KTestKey1);

	TEST2(res, KErrNone);

	TheTest.Printf(_L("Schedule some tasks - error should be returned\n"));

	TTaskInfo taskInfo;

	taskInfo.iName = KName1;

	taskInfo.iPriority = 2;

	taskInfo.iRepeat = 0;

	HBufC* data = _L("the data").AllocLC();

	res = TheScheduler.ScheduleTask(taskInfo, *data, ref1.iHandle);

	// since we have created the schedule using a UID which doesn't exist

	//we should get an error

	TEST2(res, KErrArgument);

	CleanupStack::PopAndDestroy(); // data

	TheTest.Printf(_L("Deleting schedule with id %d\n"), ref1.iHandle);

	res = TheScheduler.DeleteSchedule(ref1.iHandle);

	TEST2(res, KErrNone);

	TInt scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 0); 

	}

	TheTest.Printf(_L("Create a schedule\n"));

	res = CreateScheduleSingle1L(ref1, TheScheduler, KUidSystemCategory, KTestKey1);

	TEST2(res, KErrNone);	

	TheTest.Printf(_L("Schedule some tasks\n"));

	{

	TTaskInfo taskInfo;

	taskInfo.iName = KName1;

	taskInfo.iPriority = 2;

	taskInfo.iRepeat = 1;

	HBufC* data = _L("the data").AllocLC();

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

	res = TheScheduler.ScheduleTask(taskInfo, *data, ref1.iHandle);

	// since we have set repeat to something other than 0, we should get an error

	TEST2(res, KErrArgument);

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

	CleanupStack::PopAndDestroy(); // data

	}

	SchSvrHelpers::Pause(TheTest);

	__UHEAP_MARKEND;

	}

/**

@SYMTestCaseID          SYSLIB-SCHSVR-CT-3227

@SYMTestCaseDesc	    Persistent condition based schedule test

@SYMTestPriority 	    High

@SYMTestActions  	    Create a single persistent condition based schedule and then 

						terminate the task scheduler.

						Set the condition and then launch the task scheduler with the 

						condition satisfied.  Check that the schedule is executed.

@SYMTestExpectedResults Schedule must be executed and test must not panic or fail

@SYMREQ                 REQ0000

*/

static void DoTest4L()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-3227 "));

	// create a persistent condition based schedule

	TInt res = KErrNone;

	TheTest.Next(_L("single condition based test"));

	__UHEAP_MARK;

	//reset the p&s variables before creating the schedule

	ResetVariablesL(0,0,0);

	TSchedulerItemRef ref1;

	TheTest.Printf(_L("Create a test schedule\n"));

	res = CreateScheduleSingle1L(ref1, TheScheduler, KUidSystemCategory, KTestKey1);

	TEST2(res, KErrNone);

	TInt task1 = 0;

	_LIT(KName1, "shutdown task 1");

	TheTest.Printf(_L("Schedule a persistant task\n"));

	res = SchedulePersistentTaskL(KName1, task1, ref1.iHandle, TheScheduler);

	TEST2(res, KErrNone);

	//Fault the server to force it to shut down

 	TheScheduler.__FaultServer();

	//close the Scheduler handle

	TheScheduler.Close();

	SchSvrHelpers::Pause(TheTest);

	// set condition

	res = RProperty::Set(KUidSystemCategory, KTestKey1,10);

	TEST2(res, KErrNone);

	//Restart the scheduler with the condition for this persistant task

	//satisfied

	res = TheScheduler.Connect();

	TEST2(res, KErrNone);	

	//wait for task to be executed

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

	CleanupHelpers::KillProcess(KMinimalTaskHandler);

	SchSvrHelpers::Pause(TheTest);

	__UHEAP_MARKEND;

	}

static TInt RunTestsL()

	{

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

	SchSvrHelpers::DeleteScheduleFilesL();

	TheTest.Next(_L("Create Task notification semaphore"));

	//initialise task notification semaphore

	STaskSemaphore sem;

	sem.CreateL();

	// Connect to the server

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

	TInt res = TheScheduler.Connect();

	TEST2(res, KErrNone);

	// Register a client with the server

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

	res = SchSvrHelpers::RegisterClientL(TheScheduler);

	TEST2(res, KErrNone);

	// Launch helper process to create P&S variables

	CreateTestVariables();

	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();

	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install(scheduler);

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

 	DoTest1L();

	DoTest2L();

	DoTest3L();

	DoTest4L();

	TheTest.Next(_L("Tidying up"));

	CleanupStack::PopAndDestroy(scheduler);

	//close handle to semaphore

	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.Start(_L("TC_TSCH_CONDITION"));

	TheTest.Title();

	TheCleanup = CTrapCleanup::New();

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

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

	TEST2(error, KErrNone);

	TheTest(TheFsSession.Connect() == KErrNone);;

	TRAP(error, RunTestsL());

	TEST2(error, KErrNone);	

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

	TEST2(error, KErrNone);

	delete TheCleanup;	

	TheFsSession.Close();

	TheTest.End();

	TheTest.Close();

	__UHEAP_MARKEND;

	return KErrNone;

	}