--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/genericservices/taskscheduler/Test/Scheduling/TC_TSCH_SCHEDULING1.cpp Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,773 @@
+// 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"));
+static RScheduler TheScheduler;
+static RFs TheFsSession;
+
+typedef CArrayFixFlat<TScheduleEntryInfo> 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");
+
+const TInt KTimeToWait = 4*1000*1000;
+
+
+//***********************************************************************************
+
+// Sets time to before specified time by aTimeBeforeInSeconds
+static void SetTimeBeforeL(RTest& aTest, TTime& aTime, TInt aTimeBeforeInSeconds)
+ {
+ TTimeIntervalSeconds secs(aTimeBeforeInSeconds);
+ TTime time = aTime-secs;
+ SchSvrHelpers::SetHomeTimeL(time);
+ TBuf<30> dateString;
+ time.FormatL(dateString, KTimeFormatString);
+ aTest.Printf(KCurrentDateTimeChanged, &dateString);
+ }
+
+// gets the due time for this schedule
+static TTime GetDueTimeL(TInt aScheduleId)
+ {
+ TTime nextTimeScheduleIsDue;
+ TScheduleState 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.iDueTime;
+ }
+
+// Forces the task to be exectued aCount times.
+static void ForceTaskExecutionForSpecifiedIdL(TInt aId, TInt aCount)
+ {
+ TheTest.Printf(_L("Executing %d times\n"), aCount);
+ TTime 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 TTime& aStartTime)
+ {
+ CScheduleEntryInfoArray* entryList
+ = new (ELeave) CScheduleEntryInfoArray(1);
+ CleanupStack::PushL(entryList);
+
+ TScheduleEntryInfo entry1;
+ entry1.iStartTime = aStartTime;
+ entry1.iInterval = 1; // TTimeIntervalDays
+ entry1.iIntervalType = EDaily;
+ entry1.iValidityPeriod = 30; // minutes
+ 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();
+ TTime nextTimeScheduleIsDue;
+ TScheduleState 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");
+
+ // SCEHDULES
+ TScheduleEntryInfo entry1;
+ entry1.iStartTime = SchSvrHelpers::TimeBasedOnOffset(0, 1); // 1 min in the future
+ entry1.iInterval = 1;
+ entry1.iIntervalType = EDaily;
+ entry1.iValidityPeriod = 20;
+ entryList->AppendL(entry1);
+
+ TScheduleEntryInfo entry2;
+ entry2.iStartTime = SchSvrHelpers::TimeBasedOnOffset(0, 2); // 2 mins in the future
+ entry2.iInterval = 1;
+ entry2.iIntervalType = EDaily;
+ entry2.iValidityPeriod = 500;
+ entryList->AppendL(entry2);
+
+ TScheduleEntryInfo entry3;
+ entry3.iStartTime = SchSvrHelpers::TimeBasedOnOffset(0, 3); // 3 mins in the future
+ entry3.iInterval = 1;
+ entry3.iIntervalType = EDaily;
+ entry3.iValidityPeriod = 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;
+ }
+
+/*
+ * Add Persistent and long term schedules to SchedulessBackup.dat files. this function
+ * is part of the DEF108026 defect testing called by DEF108026()
+ * It is part of the manual test SYSLIB-SCHSVR-CT-4003
+ * should be commented and will run as manual test only.
+ *
+ *
+
+ static void DEF108026_AddPersistentSchedulesL( TBool aImmediate )
+ {
+
+ _LIT(KTaskData1, "This is some really exciting task data (number 1)");
+ _LIT(KTaskData2, "This is some really exciting task data (number 2)");
+ _LIT(KTestName, "Def108026_test");
+
+ TheTest.Next(_L("Def108026_test: Adding schedules"));
+
+ RDebug::Print(_L("DEF108026_AddPersistentSchedulesL"));
+
+ TheTest.Next(_L("Connect to Scheduler"));
+ TInt res = TheScheduler.Connect();
+ TEST2(res, KErrNone);
+
+ TheTest.Next(_L("Registering Client"));
+ TEST2(SchSvrHelpers::RegisterClientL(TheScheduler), KErrNone);
+
+
+
+ TTime startTimeForSchedule;
+ if ( aImmediate )
+ {
+ // This is the time when we want the schedule to fire
+ startTimeForSchedule = TTime( (TDateTime(2007, EJune, 20, 10, 00, 0, 0)) );
+ RDebug::Print( _L("Added immediate schedule"));
+ }
+ else
+ {
+ startTimeForSchedule = TTime( (TDateTime(2037, EJune, 20, 10, 00, 0, 0)) ); // These schedules are due in the future.
+ RDebug::Print( _L("Added long-term schedule"));
+ }
+
+
+ // 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));
+
+ CleanupHelpers::KillProcess(KMinimalTaskHandler);
+ }
+
+*
+** end of DEF108026_AddPersistentSchedulesL() **/
+
+
+/**
+@SYMTestCaseID SYSLIB-SCHSVR-CT-1031
+@SYMTestCaseDesc Test code for defect "Sending SMS to multiple recipients
+ sends message to only one recipient" (EDNEMHE-4Q69BG)
+@SYMTestPriority High
+@SYMTestActions Schedule two tasks to run at same time
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ0000
+*/
+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-1031 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
+ TTime startTimeForSchedule(TDateTime(2000, EJanuary, 1, 10, 0, 0, 0)); // 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);
+ }
+
+/**
+@SYMTestCaseID SYSLIB-SCHSVR-CT-1032
+@SYMTestCaseDesc Tests for creation of transient schedule with task repeating 5 times
+@SYMTestPriority High
+@SYMTestActions There should be no schedules as its a transient one and last schedule
+ should have deleted by itself.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ0000
+*/
+static void Test2L()
+ {
+ TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-1032 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);
+ }
+
+/**
+@SYMTestCaseID SYSLIB-SCHSVR-CT-1341
+@SYMTestCaseDesc Tests for defect number DEF055586L
+@SYMTestPriority High
+@SYMTestActions Check to ensure that last element in schedule entries
+ array not skipped by schedule checking functions
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ0000
+*/
+static void DEF055586L()
+ {
+ TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-1041 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
+ TTime startTimeForSchedule(TDateTime(2000, EJanuary, 1, 10, 0, 0, 0)); // 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);
+
+ TScheduleEntryInfo entry1;
+ entry1.iStartTime = startTimeForSchedule;
+ entry1.iInterval = 0; // TTimeIntervalDays: set to 0 to induce an error
+ entry1.iIntervalType = EDaily;
+ entry1.iValidityPeriod = 30; // minutes
+ 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
+ }
+
+/**
+@SYMTestCaseID SYSLIB-SCHSVR-CT-3159
+@SYMTestCaseDesc Tests for defect number DEF094149
+@SYMTestPriority Normal
+@SYMTestActions Create one Schedule and two task in it, then delete one task
+ check whether Task Scheduler execute disabled Schedule
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ0000
+*/
+void DEF094149L()
+ {
+ // Create scheduling entries
+ TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-3159 DEF094149: RF Task Scheduler execute deleted tasks (in stress conditions) "));
+ TTime time;
+ time.HomeTime();
+ time += TTimeIntervalSeconds(2); // Scheduler will run task in 2 seconds
+
+ TScheduleEntryInfo entry;
+ entry.iIntervalType = EHourly;
+ entry.iStartTime = time;
+ entry.iInterval = 1;
+ entry.iValidityPeriod = 20;
+
+ CArrayFixFlat<TScheduleEntryInfo>* entries = new(ELeave) CArrayFixFlat<TScheduleEntryInfo>(10);
+ CleanupStack::PushL(entries);
+
+ entries->AppendL(entry);
+ TSchedulerItemRef ref;
+ // Create the schedule for the task... and disable it
+ TheScheduler.Connect();
+ TheScheduler.CreatePersistentSchedule(ref, *entries);
+ TheScheduler.DisableSchedule(ref.iHandle);
+
+// CreateNewTask
+ TTaskInfo task;
+ task.iRepeat = 1; // repeat once
+ task.iName = _L("Test Task For Defect Verification");
+ task.iPriority = 100;
+
+
+ TBuf<255>fileName = _L("Some task");
+ TheScheduler.Register( fileName, 1 );
+ HBufC* taskData = HBufC::NewLC(1);
+
+ //first task
+ TheScheduler.ScheduleTask(task, *taskData,ref.iHandle);
+ TInt taskid1;
+ taskid1 = task.iTaskId;
+
+ //Second task
+ TheScheduler.ScheduleTask(task, *taskData,ref.iHandle);
+ TInt taskid2;
+ taskid2 = task.iTaskId;
+
+ TInt err = TheScheduler.DeleteTask(taskid1);
+
+ User::After(KTimeToWait);
+ err = TheScheduler.DeleteTask(taskid2);
+
+ //check whether Task Scheduler execute the second task after deleting first tasks
+ //If the Schedule executed then err == KErrNotFound
+ TEST2(err, KErrNone);
+ CleanupStack::PopAndDestroy(taskData);
+ CleanupStack::PopAndDestroy(entries);
+
+ }
+
+/**
+@SYMTestCaseID SYSLIB-SCHSVR-CT-3358
+@SYMTestCaseDesc Tests for defect number INC098909
+@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
+@SYMDEF INC098909: Process !TaskScheluder leaks memory in mail polls.
+*/
+static void INC098909()
+ {
+ const TInt KTimeToWait = 5*1000*1000;
+ //SchSvrHelpers::DeleteScheduleFilesL();
+
+ TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-3358 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<TScheduleEntryInfo>* entryList = new(ELeave) CArrayFixFlat<TScheduleEntryInfo>(1);
+ CleanupStack::PushL(entryList);
+ TSchedulerItemRef ref;
+
+ TTime time;
+ time.HomeTime();
+ time += TTimeIntervalSeconds(0); // Scheduler will run task in 5 sec
+
+ TScheduleEntryInfo entry1;
+ entry1.iIntervalType = EHourly;
+ entry1.iStartTime = time;
+ entry1.iInterval = 1;
+ entry1.iValidityPeriod = 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));
+
+ SchSvrHelpers::DeleteAllSchedulesL(TheScheduler);
+
+ // really clean out the scheduler (get rid of all the files and process)
+ TheScheduler.Close();
+ SchSvrHelpers::DeleteScheduleFilesL();
+ CleanupHelpers::KillProcess(KMinimalTaskHandler);
+ // Now wait for something to happen...
+ TEST2(STaskSemaphore::WaitL(KDefaultTimeout), KErrNone);
+ }
+
+
+
+/**
+@SYMTestCaseID SYSLIB-SCHSVR-CT-4003
+@SYMTestCaseDesc Test for DEF108026:
+ The aim of this test is to create enough persistent schedules. This reproduce the defect, when
+ SysStart startup. task scheduler will see that these schedules are due. It will then add them
+ immediately to the timer during SSA phase. As this operation consumes a long time and CSchStartupStateMgr::RunL()
+ is blocking, the domain manager fails to be ackowleged about the state transition, therefore certain processes like
+ Esock workers does not complete. These schedules are due immediately (at the time we run this test), we need then to
+ set the time of the device at the time where the schedules are due. We set the home time of the device in CSchServer::ConstructL().
+ I add in comment the modified CSchServer::ConstructL().
+ ssch_svr.dll must be rebuilt.
+ I could reproduces this defect only on Uiq. I could not reproduce it on techview!
+@SYMTestPriority Normal
+@SYMTestActions Create persistent and long-term schedules.
+@SYMTestExpectedResults Test must create a
+@SYMDEF DEF108026:SCHSVR performs SSA-driven actions before acknowledging transition.
+*/
+/*********************** constructL() modified.Needed to explain the manual test DEF108026() ********************************
+**
+**
+void CSchServer::ConstructL()
+ {
+#ifdef __SCHLOGGING__
+ iTheLog = CSheduleServerLog::NewL(_L("SchSvr"));
+ Dll::SetTls(iTheLog);
+#endif
+
+ // Create server storage path
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+
+#ifdef __SECURE_DATA__
+ TInt err = fs.CreatePrivatePath(EDriveC);
+#else
+ _LIT(KDirPath, "C:\\System\\Schedules\\");
+ TInt err = fs.MkDirAll(KDirPath);
+#endif
+
+ if(err != KErrNone && err != KErrAlreadyExists)
+ User::Leave(err);
+
+ fs.Close();
+
+
+
+
+ // The process that we need to add to set the time of the device.
+ // We need to set it to the same time that the schedules added are due.
+TTime newTime ( (TDateTime(2007, EJune, 20, 10, 00, 00, 00)) ); // 10:00 am
+ {
+
+ _LIT(KSetHomeTime, "TSetHomeTime");
+ _LIT(KTimeFormat, "%F%Y%M%D:%H%T%S.%*C6");
+
+ RProcess p;
+ TRequestStatus stat;
+ TBuf<128> bufLocalTime;
+
+ newTime.FormatL(bufLocalTime, KTimeFormat);
+
+ User::LeaveIfError(p.Create(KSetHomeTime, bufLocalTime));
+
+ // Asynchronous logon: completes when process terminates with process exit code
+ p.Logon(stat);
+ p.Resume();
+
+ User::WaitForRequest(stat);
+ TInt exitReason = p.ExitReason();
+ p.Close();
+ //return (exitReason);
+ }
+
+
+
+
+ iTaskScheduler = CTaskScheduler::NewL();
+
+ iSSAMgr = new(ELeave) CSchStartupStateMgr(KDmHierarchyIdStartup, KBaseServicesDomain3);
+ iSSAMgr->RegisterObserverL(iTaskScheduler);
+ iSSAMgr->InitialiseL();
+
+ StartL(KSchSvrName);
+ }
+**
+** end of the changes we need to do in ssch_svr.cpp **/
+
+/*
+ * This should be called by DoTheTestsL () . It is part of the manual test SYSLIB-SCHSVR-CT-4003
+ * should be commented and will run as manual test only.
+ *
+ *
+static void DEF108026()
+ {
+ TheTest.Next(_L("DEF108026: Creating enough persistent and long-term schedules to make task scheduler slower while adding them to the timer"));
+
+ for ( TInt i = 0; i < 500; i++ )
+ {
+ DEF108026_AddPersistentSchedulesL( ETrue );
+ HBufC* debugTxt = HBufC::NewLC( 256 );
+ debugTxt->Des().Append( _L( "Added Test... " ) );
+ debugTxt->Des().AppendNum( i++ );
+ RDebug::Print( *debugTxt );
+ CleanupStack::PopAndDestroy( debugTxt );
+ }
+
+
+ for ( TInt i = 0; i < 1000; i++ )
+ {
+ DEF108026_AddPersistentSchedulesL( EFalse );
+ HBufC* debugTxt = HBufC::NewLC( 256 );
+ debugTxt->Des().Append( _L( "Added Test... " ) );
+ debugTxt->Des().AppendNum( i++ );
+ RDebug::Print( *debugTxt );
+ CleanupStack::PopAndDestroy( debugTxt );
+ }
+
+ }
+** end of DEF108026 () **/
+
+GLDEF_C TInt DoTheTestsL()
+ {
+
+ //Delete old files.
+ SchSvrHelpers::DeleteScheduleFilesL();
+
+ STaskSemaphore sem;
+ sem.CreateL();
+
+ TheTest.Next(_L("Start tests"));
+ // Add tests here:-
+
+ //DEF108026(); //This is a manual test. This test runs only under certain condition,
+ //Read the condition required to run this test in the implementation of the DEF108026() comments.
+
+ INC098909(); // Should be commented while running def108026
+ DEF094149L(); // Should be commented while running def108026
+ Test1L(); //Should be commented while running def108026
+ Test2L(); //Should be commented while running def108026
+ DEF055586L(); //Should be commented while running def108026
+
+ sem.Close();
+
+ //Tidying up so next test will be clear.
+ TheTest.Next(_L("Delete all schedules"));
+ SchSvrHelpers::DeleteAllSchedulesL(TheScheduler); // While running def108026() manual test, this should be commented. We
+ // want keep the persistent schedules.
+ SchSvrHelpers::Pause(TheTest, 2);
+ TheTest.Next(_L("Delete old files\n"));
+ SchSvrHelpers::DeleteScheduleFilesL(); // While running def108026() manual test, this should be commented. We
+ // want keep the persistent schedules.
+ TheScheduler.Close();
+
+ return KErrNone;
+ }
+
+
+//***********************************************************************************
+GLDEF_C TInt E32Main()
+ {
+ __UHEAP_MARK;
+ TheTest.Title();
+ TheTest.Start(_L("TC_TSCH_SCHEDULING1"));
+
+ 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);
+
+ TEST2(TheFsSession.Connect(), KErrNone);
+ TheTest.Next(_L("Do the tests"));
+ TRAP(error, DoTheTestsL());
+ TEST2(error,KErrNone); // While running DEF108026 this line should be commented. If not, error = -4 (no memory) and this leaves.
+ //The reason is that our generated schedules take a lot of space. But this is the aim of this manual test:
+ // The SchedulesBackup.dat must be bigger as possible to reproduce the defect
+ TheFsSession.Close();
+ TRAP(error,CleanupHelpers::TestCleanupL());
+ TEST2(error, KErrNone);
+ delete cleanup;
+
+ TheTest.End();
+ TheTest.Close();
+ __UHEAP_MARKEND;
+ return KErrNone;
+ }