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

 	}