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

//

// Literal constants

//

_LIT(KTestName,								"TC_TSCH_SCHSVR_OOM");

//

// Type definitions

//

typedef CArrayFixFlat<TScheduleEntryInfo>	CSchEntryInfoArray;

typedef CArrayFixFlat<TTaskInfo>			CTaskInfoArray;

typedef CArrayFixFlat<TSchedulerItemRef>    CSchItemRefArray;

typedef CArrayFixFlat<TTaskSchedulerCondition> CSchConditionArray;

//

// Global data

//

RTest										TheTest(KTestName);

static RScheduler							TheScheduler;

static CTrapCleanup*						TheCleanup;

static RFs									TheFsSession;

const TUid KTestUid = TUid::Uid(0x12345678);

const TInt KTestKey1 = 1;

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

static void GetTaskInfoL(CTaskInfoArray& aTaskInfoArray,

						TInt aScheduleId)

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

	{

	aTaskInfoArray.Reset();

	TTime nextTimeScheduleIsDue;

	TScheduleState state;

	CSchEntryInfoArray* entries 

		= new (ELeave) CSchEntryInfoArray(3);

	CleanupStack::PushL(entries);

	TInt res = TheScheduler.GetScheduleL(aScheduleId, 

										state, 

										*entries, 

										aTaskInfoArray, 

										nextTimeScheduleIsDue);

	TEST2(res, KErrNone);

	CleanupStack::PopAndDestroy(entries);

	}

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

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 CSchEntryInfoArray* CreateScheduleArrayLC()

	{

	CSchEntryInfoArray* entryList = new (ELeave) CSchEntryInfoArray(3);

	CleanupStack::PushL(entryList);

	TScheduleEntryInfo entry1;

	entry1.iStartTime		= SchSvrHelpers::TimeBasedOnOffset(0, 20); // 20m from "now"

	entry1.iInterval		= 1;

	entry1.iIntervalType	= EDaily;

	entry1.iValidityPeriod	= 20;

	entryList->AppendL(entry1);

	return entryList;

	}

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

static CSchConditionArray* CreateConditionArrayLC()

	{

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

	CleanupStack::PushL(conditionList);

	TTaskSchedulerCondition condition1;

	condition1.iCategory = KTestUid;

	condition1.iKey		= KTestKey1;

	condition1.iState	= 10;

	condition1.iType	= TTaskSchedulerCondition::EEquals;

	conditionList->AppendL(condition1);

	return conditionList;

	}

/**

@SYMTestCaseID          SYSLIB-SCHSVR-CT-1027

@SYMTestCaseDesc	    Tests out of memory errors for time based API's

@SYMTestPriority 	    High

@SYMTestActions  	    Test for memory errors,while creating,enabling,disabling,editing and other operations on schedule task 

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/		

static void DoTest1L()

// Time based API's

	{     

	TInt err = KErrNone;

	TInt tryCount = 0;

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-1027 ===== Starting OOM test ===== "));

	CSchEntryInfoArray* scheduleArray = CreateScheduleArrayLC();

	TSchedulerItemRef ref1;

	TheTest.Next(_L("===== Testing create persistent schedule ====="));

	for (tryCount = 0; ;++tryCount)

		{

		// These allocations are ignored because they cause corruptness

		// of the persistent store.  Its a bit rubbish.

		if(tryCount < 7 || tryCount >8 )

			{

			TheScheduler.__DbgFailNext(tryCount);

			TheScheduler.__DbgMarkHeap();

			err = TheScheduler.CreatePersistentSchedule(ref1, *scheduleArray);

			if (err==KErrNone)

				{

				TheScheduler.__DbgResetHeap();

				break;

				}

			TEST2(err, KErrNoMemory);		

			// reset server side heap for next iteration.

			TheScheduler.__DbgMarkEnd(0);			

			}

		}

	// Check schedule count

	TInt scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 1); 

	// OK, now we have a persistent schedule

	TheTest.Next(_L("===== Testing disable schedule ====="));

	for (tryCount = 0; ;++tryCount)

		{

		TheScheduler.__DbgFailNext(tryCount);

		TheScheduler.__DbgMarkHeap();

		err = TheScheduler.DisableSchedule(ref1.iHandle);

		if (err==KErrNone)

			{

			TheScheduler.__DbgResetHeap();

			break;

			}

		TEST2(err, KErrNoMemory);		

		// reset server side heap for next iteration.

		TheScheduler.__DbgMarkEnd(0);

		}

	// Check schedule count

	scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 1); 

	TheTest.Next(_L("===== Testing enable schedule ====="));

	for (tryCount = 0; ;++tryCount)

		{

		TheScheduler.__DbgFailNext(tryCount);

		TheScheduler.__DbgMarkHeap();

		err = TheScheduler.EnableSchedule(ref1.iHandle);

		if (err==KErrNone)

			{

			TheScheduler.__DbgResetHeap();

			break;

			}

		TEST2(err, KErrNoMemory);		

		// reset server side heap for next iteration.

		TheScheduler.__DbgMarkEnd(0);

		}

	// Check schedule count

	scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 1); 

	TheTest.Next(_L("===== Testing edit schedule ====="));

	for (tryCount = 0; ;++tryCount)

		{

		TheScheduler.__DbgFailNext(tryCount);

		TheScheduler.__DbgMarkHeap();

		// Even though we use the same array as before, the task scheduler

		// code is not smart enough to just return but actually replaces

		// the existing one, hence we are actually testing this method fully.

		err = TheScheduler.EditSchedule(ref1.iHandle, *scheduleArray);

		if (err==KErrNone)

			{

			TheScheduler.__DbgResetHeap();

			break;

			}

		TEST2(err, KErrNoMemory);		

		// reset server side heap for next iteration.

		TheScheduler.__DbgMarkEnd(0);

		}

	// Check schedule count

	scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 1); 

	TheTest.Next(_L("===== Testing delete schedule ====="));

	for (tryCount = 0; ;++tryCount)

		{

		TheScheduler.__DbgFailNext(tryCount);

		TheScheduler.__DbgMarkHeap();

		err = TheScheduler.DeleteSchedule(ref1.iHandle);

		if (err==KErrNone)

			{

			TheScheduler.__DbgResetHeap();

			break;

			}

		TEST2(err, KErrNoMemory);		

		// reset server side heap for next iteration.

		TheScheduler.__DbgMarkEnd(0);

		}

	// Check schedule count

	scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 0); 

	// delete old files.

	// We need to do this because we have actually corrupted the store, 

	// even though its empty.  Without deleting it we get problems below.

	// This is a bit rubbish having to do this but what else can be done??

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

	SchSvrHelpers::DeleteScheduleFilesL();

	// OK now add back schedule in preparation for adding tasks.

	err = TheScheduler.CreatePersistentSchedule(ref1, *scheduleArray);

	TEST2(err, KErrNone);

	TheTest.Next(_L("===== Testing ScheduleTask ====="));

	_LIT(KTaskName, "TheTaskName");

	TName name = KTaskName();

	TTaskInfo taskInfo(0, name, 2, 0);

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

	// cant test ScheduleTask API using OOM loop as it does dodgy things to 

	// the store which cause allocation problems.  Need to investigate this 

	// later at some stage.

	TEST2(TheScheduler.ScheduleTask(taskInfo, *data, ref1.iHandle), KErrNone);

	// Check schedule and task count

	scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 1); 

	TInt taskCount = CountTasksL(ref1.iHandle);

	TEST(taskCount = 1);	

	TheTest.Next(_L("===== Testing GetScheduleRefsL ====="));

	CSchItemRefArray* refs = new (ELeave) CSchItemRefArray(3);

	CleanupStack::PushL(refs);

	for (tryCount = 0; ;++tryCount)

		{

		TheScheduler.__DbgFailNext(tryCount);

		TheScheduler.__DbgMarkHeap();

		err = TheScheduler.GetScheduleRefsL(*refs, EPendingSchedules);

		if (err==KErrNone)

			{

			TheScheduler.__DbgResetHeap();

			break;

			}

		TEST2(err, KErrNoMemory);		

		// reset server side heap for next iteration.

		TheScheduler.__DbgMarkEnd(0);

		}

	// Check schedule and task count

	scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 1); 

	taskCount = CountTasksL(ref1.iHandle);

	TEST(taskCount = 1);	

	TheTest.Next(_L("===== Testing GetScheduleL ====="));

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

	CleanupStack::PushL(tasks);

	TScheduleState state;

	TTime time;

	CSchEntryInfoArray* entryList = new (ELeave) CSchEntryInfoArray(3);

	CleanupStack::PushL(entryList);

	for (tryCount = 0; ;++tryCount)

		{

		TheScheduler.__DbgFailNext(tryCount);

		TheScheduler.__DbgMarkHeap();

		err = TheScheduler.GetScheduleL(ref1.iHandle,

										state,

										*entryList,

										*tasks, time);

		if (err==KErrNone)

			{

			TheScheduler.__DbgResetHeap();

			break;

			}

		TEST2(err, KErrNoMemory);		

		// reset server side heap for next iteration.

		TheScheduler.__DbgMarkEnd(0);

		}

	// Check schedule and task count

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

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

	scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 1); 

	taskCount = CountTasksL(ref1.iHandle);

	TEST(taskCount = 1);	

	CleanupStack::PopAndDestroy(entryList);

	CleanupStack::PopAndDestroy(tasks);

	TheTest.Next(_L("===== Testing GetTaskRefsL ====="));

	for (tryCount = 0; ;++tryCount)

		{

		TheScheduler.__DbgFailNext(tryCount);

		TheScheduler.__DbgMarkHeap();

		err = TheScheduler.GetTaskRefsL(*refs,

										EAllSchedules,

										EAllTasks);

		if (err==KErrNone)

			{

			TheScheduler.__DbgResetHeap();

			break;

			}

		TEST2(err, KErrNoMemory);		

		// reset server side heap for next iteration.

		TheScheduler.__DbgMarkEnd(0);

		}

	CleanupStack::PopAndDestroy(refs);

	TheTest.Next(_L("===== Testing GetTaskDataSize ====="));

	TInt size;

	for (tryCount = 0; ;++tryCount)

		{

		TheScheduler.__DbgFailNext(tryCount);

		TheScheduler.__DbgMarkHeap();

		err = TheScheduler.GetTaskDataSize(ref1.iHandle,

										size);

		if (err==KErrNone)

			{

			TheScheduler.__DbgResetHeap();

			break;

			}

		TEST2(err, KErrNoMemory);		

		// reset server side heap for next iteration.

		TheScheduler.__DbgMarkEnd(0);

		}

	TheTest.Next(_L("===== Testing GetTaskInfoL ====="));

	HBufC* newData = HBufC::NewLC(size);

	TPtr pTaskData = newData->Des();

	TTaskInfo newTaskInfo;

	for (tryCount = 0; ;++tryCount)

		{

		TheScheduler.__DbgFailNext(tryCount);

		TheScheduler.__DbgMarkHeap();

		err = TheScheduler.GetTaskInfoL(taskInfo.iTaskId,

										newTaskInfo,

										pTaskData,

										ref1,

										time);

		if (err==KErrNone)

			{

			TheScheduler.__DbgResetHeap();

			break;

			}

		TEST2(err, KErrNoMemory);		

		// reset server side heap for next iteration.

		TheScheduler.__DbgMarkEnd(0);

		}

	TEST(newData->MatchF(*data) == 0);

	scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 1); 

	taskCount = CountTasksL(ref1.iHandle);

	TEST(taskCount = 1);	

	CleanupStack::PopAndDestroy(newData);

	CleanupStack::PopAndDestroy(data);

	TheTest.Next(_L("===== Testing GetScheduleTypeL ====="));

	TScheduleType type;

	for (tryCount = 0; ;++tryCount)

		{

		TheScheduler.__DbgFailNext(tryCount);

		TheScheduler.__DbgMarkHeap();

		err = TheScheduler.GetScheduleTypeL(ref1.iHandle, type);

		if (err==KErrNone)

			{

			TheScheduler.__DbgResetHeap();

			break;

			}

		TEST2(err, KErrNoMemory);		

		// reset server side heap for next iteration.

		TheScheduler.__DbgMarkEnd(0);

		}

	TEST(type == ETimeSchedule);

	CleanupStack::PopAndDestroy(scheduleArray);

	TheTest.Next(_L("===== Testing DeleteTask ====="));

	for (tryCount = 0; ;++tryCount)

		{

		TheScheduler.__DbgFailNext(tryCount);

		TheScheduler.__DbgMarkHeap();

		err = TheScheduler.DeleteTask(taskInfo.iTaskId);

		//include test for KErrNotFound here as task is actually deleted and

		// then store is updated (which causes mem failure).  Problems

		// will still occur if you add a new task again and try and access store

		// as store is likely to still be corrupt. Investigate this??

		if (err==KErrNone || err==KErrNotFound) 

			{

			TheScheduler.__DbgResetHeap();

			break;

			}

		TEST2(err, KErrNoMemory);		

		// reset server side heap for next iteration.

		TheScheduler.__DbgMarkEnd(0);

		}

	scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 1); 

	taskCount = CountTasksL(ref1.iHandle);

	TEST(taskCount == 0);

	//Now delete schedule to setup for next test

	TEST2(TheScheduler.DeleteSchedule(ref1.iHandle), KErrNone);

	scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 0); 

	SchSvrHelpers::Pause(TheTest);

	}

/**

@SYMTestCaseID          SYSLIB-SCHSVR-CT-1028

@SYMTestCaseDesc	    Tests out of memory errors for Condition based API's

@SYMTestPriority 	    High

@SYMTestActions  	    Create a persistent schedule,get and delete schedule.

                        Check for memory and no errors.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/		

static void DoTest2L()

// Condition based API's

	{	

	TInt err = KErrNone;

	TInt tryCount = 0;

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-1028 ===== Starting Condition OOM test ===== "));

	// delete old files.

	// We need to do this because we have actually corrupted the store, 

	// with the DeleteTask call.  Without deleting it we get problems below.

	// This is a bit rubbish having to do this but what else can be done??

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

	SchSvrHelpers::DeleteScheduleFilesL();

	//Ensure P&S variables are defined.

	err = RProperty::Define(KTestUid, KTestKey1, RProperty::EInt);

	TEST(err == KErrNone || err == KErrAlreadyExists);

	TEST2(RProperty::Set(KTestUid, KTestKey1,1), KErrNone);

	CSchConditionArray* conditionArray = CreateConditionArrayLC();

	TSchedulerItemRef ref1;

	TheTest.Next(_L("===== Testing create persistent schedule ====="));

	for (tryCount = 0; ;++tryCount)

		{

		TheScheduler.__DbgFailNext(tryCount);

		TheScheduler.__DbgMarkHeap();

		err = TheScheduler.CreatePersistentSchedule(ref1, *conditionArray, Time::MaxTTime());

		if (err==KErrNone)

			{

			TheScheduler.__DbgResetHeap();

			break;

			}

		TEST2(err, KErrNoMemory);		

		// reset server side heap for next iteration.

		TheScheduler.__DbgMarkEnd(0);			

		}

	// Check schedule count

	TInt scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 1); 

// This test code causes problems when EditSchedule fails, it deletes the entries 

// but doenst delete the actual CSchedule object.  We can't do this really as the 

// schedule may have oustanding tasks.  Need to clean up data in a consistent manner.

// Fix this! Same applied for time based EditSchedule

/*	TheTest.Next(_L("===== Testing edit schedule ====="));

	for (tryCount = 0; ;++tryCount)

		{

		TheScheduler.__DbgFailNext(tryCount);

		TheScheduler.__DbgMarkHeap();

		// Even though we use the same array as before, the task scheduler

		// code is not smart enough to just return but actually replaces

		// the existing one, hence we are actually testing this method fully.

		err = TheScheduler.EditSchedule(ref1.iHandle, *conditionArray,

										SchSvrHelpers::TimeBasedOnOffset(0, 20));

		if (err==KErrNone)

			{

			TheScheduler.__DbgResetHeap();

			break;

			}

		TEST2(err, KErrNoMemory);		

		// reset server side heap for next iteration.

		TheScheduler.__DbgMarkEnd(0);

		}

	// Check schedule count

	scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 1); 

*/

	TheTest.Next(_L("===== Testing GetScheduleL ====="));

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

	CleanupStack::PushL(tasks);

	TScheduleState state;

	TTime time;

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

	CleanupStack::PushL(entryList);

	for (tryCount = 0; ;++tryCount)

		{

		TheScheduler.__DbgFailNext(tryCount);

		TheScheduler.__DbgMarkHeap();

		err = TheScheduler.GetScheduleL(ref1.iHandle,

										state,

										*entryList,

										time, *tasks);

		if (err==KErrNone)

			{

			TheScheduler.__DbgResetHeap();

			break;

			}

		TEST2(err, KErrNoMemory);		

		// reset server side heap for next iteration.

		TheScheduler.__DbgMarkEnd(0);

		}

	CleanupStack::PopAndDestroy(entryList);

	CleanupStack::PopAndDestroy(tasks);

	TheTest.Next(_L("===== Testing delete schedule ====="));

	for (tryCount = 0; ;++tryCount)

		{

		TheScheduler.__DbgFailNext(tryCount);

		TheScheduler.__DbgMarkHeap();

		err = TheScheduler.DeleteSchedule(ref1.iHandle);

		if (err==KErrNone)

			{

			TheScheduler.__DbgResetHeap();

			break;

			}

		TEST2(err, KErrNoMemory);		

		// reset server side heap for next iteration.

		TheScheduler.__DbgMarkEnd(0);

		}

	// Check schedule count

	scheduleCount = CountScheduledItemsL(EAllSchedules, TheScheduler);

	TEST(scheduleCount == 0); 

	CleanupStack::PopAndDestroy(conditionArray);

	SchSvrHelpers::Pause(TheTest);

	}

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

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

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

	DoTest1L();

	DoTest2L();

	// Need to add OOM tests for when a task is executed

	// to clarify behaviour.  This will be tricky!!!

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

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

	//close handle to semaphore

	sem.Close();

	return KErrNone;

	}

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

GLDEF_C TInt E32Main()

//	

// TheTest the scheduler

//

    {

	__UHEAP_MARK;

	TheTest.Start(_L("OOM testing"));

	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;

	}