// Copyright (c) 2007-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 Robustness Test");

_LIT(KTaskScheduler, "schexe");

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;

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

	}	

static void ResetVariablesL(TInt aKey1Val)

	{

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

	}

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

static TInt CreateScheduleL(TSchedulerItemRef& aRef, 

									RScheduler& aScheduler,

									const TUid& aConditionUID,

									TUint aConditionUInt)

	{

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

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

	CleanupStack::PushL(conditionList);

	//create a single condition

	TTaskSchedulerCondition condition1;

	condition1.iCategory = aConditionUID;

	condition1.iKey		= aConditionUInt;

	condition1.iState	= 10;

	condition1.iType	= TTaskSchedulerCondition::EEquals;

	conditionList->AppendL(condition1);

	//create a persistent schedule

	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;

	}

//Add a single task to a schedule	

static TInt AddTaskToScheduleL(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;

	}

static TInt ScheduleTaskL()

	{

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

	ResetVariablesL(0);

	//Create a schedule

	TSchedulerItemRef ref1;

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

	TInt res = CreateScheduleL(ref1, TheScheduler, KUidSystemCategory, KTestKey1);

	TEST2(res, KErrNone);

	//Add task to the schedule

	TInt task1 = 0;

	_LIT(KName1, "Test Task");

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

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

	TEST2(res, KErrNone);

	return res;	

	}

static void ExecuteTaskL()

	{

	TheTest.Printf(_L("Execute Task\n"));

	//Set property causing schedule to be run

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

	//Pause to wait for the task to be executed

	SchSvrHelpers::Pause(TheTest, 2);

	}

static TInt ScheduleAndExecuteTaskL()

	{

	TInt res = ScheduleTaskL();

	ExecuteTaskL();

	return res;	

	}

LOCAL_C void AddTaskFunctionL()

	{

	RScheduler	localScheduler;

	// Connect to the server

	TInt res = localScheduler.Connect();

	TEST2(res, KErrNone);

	//Schedule a task and execute it

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

	ResetVariablesL(0);

	//Create a schedule

	TSchedulerItemRef ref1;

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

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

	CleanupStack::PushL(conditionList);

	//create a single condition

	TTaskSchedulerCondition condition1;

	condition1.iCategory = KUidSystemCategory;

	condition1.iKey		= KTestKey1;

	condition1.iState	= 10;

	condition1.iType	= TTaskSchedulerCondition::EEquals;

	conditionList->AppendL(condition1);

	//create a persistent schedule

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

	res = localScheduler.CreatePersistentSchedule(ref1, *conditionList, time);

	CleanupStack::PopAndDestroy(); // conditionList

	//Add task to the schedule

	TInt task1 = 0;

	_LIT(KName1, "Test Task");

	TTaskInfo taskInfo;

	taskInfo.iTaskId = task1;

	taskInfo.iName = KName1;

	taskInfo.iPriority = 2;

	taskInfo.iRepeat = 0;

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

	TInt ret = localScheduler.ScheduleTask(taskInfo, *data, ref1.iHandle);

	TEST2(ret, 0);//EPanicNotRegistered == 0

	task1 = taskInfo.iTaskId;

	CleanupStack::PopAndDestroy(); // data

	//Tidying up so next test will be clear.

	SchSvrHelpers::DeleteAllSchedulesL(localScheduler);

	localScheduler.Close();

	}

// Helper function for DEF124488 

LOCAL_C TInt TestPanicThread(TAny*)

	{

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if(!cleanup)

		return KErrNoMemory;

	TRAPD(err,AddTaskFunctionL())

	TEST2(err,KErrNone);

	delete cleanup;

	return KErrNone;

	}

/**	

@SYMTestCaseID 	SYSLIB-SCHSVR-CT-3369

@SYMTestCaseDesc	Test deletion of temporary files with non existent client

@SYMTestPriority	High

@SYMTestActions 	Schedule a task with a client that does not exist.  

					Ensure that all temporary files are deleted after 

					schedule excecutes

@SYMTestExpectedResults All temporary files should be deleted by task scheduler

@SYMDEF 		 PDEF101876

*/

static void DoTest1L()

	{	

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-3369 Test handling of non existent client "));	

	// Connect to the server

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

	TInt res = TheScheduler.Connect();

	TEST2(res, KErrNone);

	// Register a client with the server - this client does not exist

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

	res = SchSvrHelpers::RegisterNonExistentClient(TheScheduler);

	TEST2(res, KErrNone);

	//Schedule a task and execute it

	ScheduleAndExecuteTaskL();

	// Check for left task files after scheduled tasks completed

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

	TheTest.Next(_L("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);

	TheTest.Next(_L("All files deleted as expected..."));

	//Tidying up so next test will be clear.

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

	SchSvrHelpers::DeleteAllSchedulesL(TheScheduler);

	TheScheduler.Close();

	}

/**

@SYMTestCaseID 	SYSLIB-SCHSVR-CT-3370

@SYMTestCaseDesc	Test deletion of temporary files with faulty client

@SYMTestPriority	High

@SYMTestActions 	Schedule a task with a client that panics and does not 

					release the temporary file handle. 

					Ensure that all temporary files are deleted after schedule excecutes

@SYMTestExpectedResults All temporary files should be deleted by task scheduler

@SYMDEF 		 PDEF101876

*/	

static void DoTest2L()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-3370 Test handling of panicing client "));

	// Connect to the server

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

	TInt res = TheScheduler.Connect();

	TEST2(res, KErrNone);

	// Register a client with the server - this client panics

	//after calling RFile::AdoptFromClient

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

	res = SchSvrHelpers::RegisterPanicingClient(TheScheduler);

	TEST2(res, KErrNone);

	//Schedule a task and execute it - we expect the client to panic

	ScheduleAndExecuteTaskL();

	// Check for left task files after scheduled tasks completed

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

	TheTest.Next(_L("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);	

	TheTest.Next(_L("All files deleted as expected..."));

	//Tidying up so next test will be clear.

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

	SchSvrHelpers::DeleteAllSchedulesL(TheScheduler);

	TheScheduler.Close();

	}

/**

@SYMTestCaseID 	SYSLIB-SCHSVR-CT-3371

@SYMTestCaseDesc	Test deletion of temporary files on task scheduler startup

@SYMTestPriority	High

@SYMTestActions 	Create temporary files in the task schedulers private data cage.

					Start the task scheduler and verify that these files are deleted.

@SYMTestExpectedResults All temporary files should be deleted by task scheduler on startup

@SYMDEF 		 PDEF101876

*/	

static void DoTest3L()

	{	

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-3371 Test deletion of temporary files on startup "));

	//Connect to the scheduler

	TInt res = TheScheduler.Connect();

	TEST2(res, KErrNone);

 	// Kill the server to ensure we restart it when we connect

	res = CleanupHelpers::KillProcess(KTaskScheduler);

	TEST2(res, KErrNone);

 	TheScheduler.Close();

	// Create task files to test cleanup

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

	TheTest.Next(_L("Creating dummy task files"));

	res = SchSvrHelpers::CreateTaskFilesL();

	//Restart the scheduler which should clean up temp files on startup

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

	res = TheScheduler.Connect();

	TEST2(res, KErrNone);

	//wait for the server to start up

	SchSvrHelpers::Pause(TheTest, 2);

	TheScheduler.Close();

	// Check for left task files after scheduled tasks completed

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

	TheTest.Next(_L("Now checking no files left after task scheduler starts"));

	res = SchSvrHelpers::CheckTaskFilesL();

	TEST2(res, KErrNone);

	TheTest.Next(_L("All files deleted as expected..."));

	}

/**

@SYMTestCaseID 		SYSLIB-SCHSVR-CT-3402

@SYMTestCaseDesc	Test memory cleanup on Task Scheduler exit

@SYMTestPriority	High

@SYMTestActions 	Start the scheduler and register a client.

					Execute a schedule and then terminate the scheduler.

					When the scheduler is restarted it should exit as there are no

					pending schedules. On exit all allocated memory should be freed	

@SYMTestExpectedResults All allocated memory should be freed when the scheduler exits

@SYMDEF 		 DEF102414

*/	

static void DoTest4L()

	{	

	__UHEAP_MARK;

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-3402 Test memory cleanup on Task Scheduler exit "));

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

	//Schedule a task and execute it

	ScheduleAndExecuteTaskL();

 	// Kill the server

	res = CleanupHelpers::KillProcess(KTaskScheduler);

	TEST2(res, KErrNone);

 	TheScheduler.Close();

	//Restarting with a registered client and no schedule should

	//cause the server to exit.  Ther server should free all allocated

	//memory.  If all memory is not freed, heap check macros within

	// the task scheduler code will cause a panic 

	SchSvrHelpers::LaunchTaskSchedulerL();

	//wait for the server to exit

	SchSvrHelpers::Pause(TheTest, 2);

	//Verify that the server has already exited - there are two valid 

	//error codes depending on how quickly the process is cleaned up

	//KErrDied - Process is dead but hasn't been cleaned up yet by the kernel

	//KErrNotFound - Process has been cleaned up

	res = CleanupHelpers::KillProcess(KTaskScheduler);

	TEST((res == KErrDied)||(res == KErrNotFound));

	__UHEAP_MARKEND;

	TheTest.Next(_L("All memory freed..."));

	}

/**

@SYMTestCaseID 		SYSLIB-SCHSVR-CT-3412

@SYMTestCaseDesc	Test Task Scheduler startup with pending schedule

@SYMTestPriority	High

@SYMTestActions 	Start the scheduler and register a client.

					Create a scheduled task and then terminate the scheduler without executing the task.

					When the scheduler is restarted it should not exit as there is a 

					pending schedule. Verify that the scheduler is still active by executing

					the schedule

@SYMTestExpectedResults	The task scheduler should not exit and the schedule should execute

@SYMDEF 		 DEF102414

*/	

static void DoTest5L()

	{

	__UHEAP_MARK;

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-3412 Test Task Scheduler startup with pending schedule "));

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

	//Schedule a task

	ScheduleTaskL();

 	// Kill the server

	res = CleanupHelpers::KillProcess(KTaskScheduler);

	TEST2(res, KErrNone);

 	TheScheduler.Close();

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

	//initialise task notification semaphore

	STaskSemaphore sem;

	sem.CreateL();

	//Restart the scheduler - task scheduler should not exit as there is a 

	//pending schedule

	res = SchSvrHelpers::LaunchTaskSchedulerL();

	TEST2(res, KErrNone);

	//Execute task and wait for it to run - this would not succeed

	//if task scheduler had exited above

	ExecuteTaskL();

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

	//Kill the process and verify that the scheduler was active

	//If the task scheduler isnt active when we try to kill it

	//KillProcess would return KErrDied

	res = CleanupHelpers::KillProcess(KTaskScheduler);

	TEST2(res, KErrNone);

	//close handle to semaphore

	sem.Close();

	__UHEAP_MARKEND;	

	}

/**	

@SYMTestCaseID 	SYSLIB-SCHSVR-CT-4010

@SYMTestCaseDesc	Test that adding a task using an unregistered client panics the client and does not crash the server.

@SYMTestPriority	High

@SYMTestActions 	Schedule a task with a client that has not been registered.  

@SYMTestExpectedResults Client should be panicked.

@SYMDEF 		DEF124488 

*/

static void DoTest6L()

	{	

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4010 Test handling of unregistered client Should Panic Client thread "));	

	RThread testThread;

	_LIT(KThreadName, "PanicClientThread");

	testThread.Create(KThreadName, TestPanicThread, KDefaultStackSize, 0x1000, 0x100000, NULL);

	TRequestStatus requestStatus;

	// Request notification when the thread terminates

	testThread.Logon(requestStatus);

	TBool justInTime=User::JustInTime(); 

	User::SetJustInTime(EFalse); 

	// Let the thread execute

	testThread.Resume();

	// Wait for termination

	User::WaitForRequest(requestStatus);

	User::SetJustInTime(justInTime); 

	TEST2(testThread.ExitReason(), 0);

	testThread.Close();

	}

static TInt RunTestsL()

	{

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

	SchSvrHelpers::DeleteScheduleFilesL();

	//create P&S variables for the test

	CreateTestVariables();

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

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

	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install(scheduler);

	DoTest1L();

	DoTest2L();

	DoTest3L();

	DoTest4L();

	DoTest5L();	

	DoTest6L();

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

	CleanupStack::PopAndDestroy(scheduler);

	return KErrNone;

	}

GLDEF_C TInt E32Main()

    {

	__UHEAP_MARK;

	TheTest.Start(_L("TC_TSCH_ROBUSTNESS"));

	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;

	}