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