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

 	}