diff -r e20de85af2ee -r ce057bb09d0b genericservices/taskscheduler/Test/PlatSec/tschsvrclient.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/genericservices/taskscheduler/Test/PlatSec/tschsvrclient.cpp Fri Jun 04 16:20:51 2010 +0100 @@ -0,0 +1,294 @@ +// 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: +// tschsvrsclient1.cpp +// +// + +#include +#include + +#include +#include +#include "Thelpers.h" +#include "TestUtils.h" + +_LIT(KTestName, "Client with different UID test"); +RTest TheTest(KTestName); +static RScheduler TheScheduler; + + +typedef CArrayFixFlat CSchEntryInfoArray; +typedef CArrayFixFlat CTaskInfoArray; +typedef CArrayFixFlat CSchItemRefArray; +typedef CArrayFixFlat CSchConditionArray; + + +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* CreateSingleConditionLC() + { + CSchConditionArray* conditionList = new (ELeave) CSchConditionArray(3); + CleanupStack::PushL(conditionList); + + const TUid KTestUid = TUid::Uid(0x12345678); + + TTaskSchedulerCondition condition1; + condition1.iCategory = KTestUid; + condition1.iKey = 1; + condition1.iState = 10; + condition1.iType = TTaskSchedulerCondition::EEquals; + conditionList->AppendL(condition1); + + return conditionList; + } +/** +@SYMTestCaseID SYSLIB-SCHSVR-CT-1343 +@SYMTestCaseDesc Client with different UID test +@SYMTestPriority High +@SYMTestActions Connect to Scheduler, + Tests RScheduler::EditSchedule(),RScheduler::DisableSchedule(),RScheduler::EnableSchedule() + RScheduler::ScheduleTask(),RScheduler::GetScheduleRefsL(),RScheduler::GetScheduleL(), + RScheduler::GetTaskRefsL(),RScheduler::GetTaskDataSize(),RScheduler::GetTaskInfoL(), + RScheduler::GetScheduleTypeL(),RScheduler::DeleteTask(),RScheduler::DeleteSchedule() functions +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +void DoExecuteL(TInt aScheduleHandle, + TInt aTaskHandle, + TInt aExpectedError, + TInt aExpectedScheduleCount, + TInt aExpectedTaskCount) + { + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-1343 Connect to Scheduler ")); + TInt res = TheScheduler.Connect(); + TEST2(res, KErrNone); + TheTest.Next(_L("Registering Client")); + TEST2(SchSvrHelpers::RegisterClientL(TheScheduler), KErrNone); + + //Edit Schedule + TheTest.Next(_L("Testing EditSchedule")); + CSchEntryInfoArray* scheduleArray = CreateScheduleArrayLC(); + res = TheScheduler.EditSchedule(aScheduleHandle, *scheduleArray); + CleanupStack::PopAndDestroy(); //scheduleArray + TEST2(res, aExpectedError); + //condition API - only check if we are expecting an error + if(aExpectedError != KErrNone) + { + CSchConditionArray* conditionList = CreateSingleConditionLC(); + TTime time = SchSvrHelpers::TimeBasedOnOffset(0, 0, 0, 0, 0, 1); //1 year in the future + res = TheScheduler.EditSchedule(aScheduleHandle, *conditionList, time); + CleanupStack::PopAndDestroy(); // conditionList + TEST2(res, aExpectedError); + } + //Disable/Enable Schedule + TheTest.Next(_L("Testing DisableSchedule and EnableSchedule")); + res = TheScheduler.DisableSchedule(aScheduleHandle); + TEST2(res, aExpectedError); + res = TheScheduler.EnableSchedule(aScheduleHandle); + TEST2(res, aExpectedError); + + //ScheduleTask + TheTest.Next(_L("Testing ScheduleTask")); + TTaskInfo taskInfo; + taskInfo.iName = _L("MyTask"); + taskInfo.iPriority = 2; + taskInfo.iTaskId = 0; + taskInfo.iRepeat = 1; + HBufC* data = _L("Task Data I cant schedule").AllocLC(); + res = TheScheduler.ScheduleTask(taskInfo, *data, aScheduleHandle); + TEST2(res, aExpectedError); + CleanupStack::PopAndDestroy(); // data + + if(res == KErrNone) + { + res = TheScheduler.DeleteTask(taskInfo.iTaskId); + TEST2(res, KErrNone); + } + + //GetScheduleRefs + TheTest.Next(_L("Testing GetScheduleRefsL")); + CSchItemRefArray* refs = new (ELeave) CSchItemRefArray(3); + CleanupStack::PushL(refs); + res = TheScheduler.GetScheduleRefsL(*refs, EAllSchedules); + TEST2(res, KErrNone); + TInt count = refs->Count(); + TEST2(count, aExpectedScheduleCount); + + //GetSchedule + TheTest.Next(_L("Testing GetScheduleL")); + CSchEntryInfoArray* entries = new (ELeave) CSchEntryInfoArray(3); + CleanupStack::PushL(entries); + CTaskInfoArray* tasks = new (ELeave) CTaskInfoArray(3); + CleanupStack::PushL(tasks); + + TTime nextTimeScheduleIsDue; + TScheduleState state; + res = TheScheduler.GetScheduleL(aScheduleHandle, + state, + *entries, + *tasks, + nextTimeScheduleIsDue); + TEST2(res, aExpectedError); + //condition API - only check if we are expecting an error + if(aExpectedError != KErrNone) + { + CSchConditionArray* conditions = new (ELeave) CSchConditionArray(3); + CleanupStack::PushL(conditions); + res = TheScheduler.GetScheduleL(aScheduleHandle, + state, + *conditions, + nextTimeScheduleIsDue, + *tasks); + CleanupStack::PopAndDestroy(conditions); + TEST2(res, aExpectedError); + } + + //GetTaskRefs + TheTest.Next(_L("Testing GetScheduleL")); + res = TheScheduler.GetTaskRefsL(*refs, EAllSchedules, EAllTasks); + TEST2(res, KErrNone); + count = refs->Count(); + TEST2(count, aExpectedTaskCount); + + // TaskDataSize + TheTest.Next(_L("Testing GetTaskDataSize")); + TInt taskSize = 0; + res = TheScheduler.GetTaskDataSize(aTaskHandle, taskSize); + TEST2(res, aExpectedError); + + // GetTaskInfo + TheTest.Next(_L("Testing GetTaskInfoL")); + if(aExpectedError != KErrNone) + //use dummy size for task as we actually didnt get it from above + // if we were expected as error + taskSize = 10; + HBufC* taskData = HBufC::NewLC(taskSize); + TPtr pTaskData = taskData->Des(); + + TTime scheduleNextDueTime; + TTaskInfo taskFromServer; + TSchedulerItemRef scheduleReference; + + res = TheScheduler.GetTaskInfoL(aTaskHandle, + taskFromServer, + pTaskData, + scheduleReference, + scheduleNextDueTime); + CleanupStack::PopAndDestroy(taskData); + TEST2(res, aExpectedError); + + TScheduleType scheduleType; + res = TheScheduler.GetScheduleTypeL(aScheduleHandle, scheduleType); + TEST2(res, aExpectedError); + + //DeleteTask + TheTest.Next(_L("Testing TaskSchedule")); + res = TheScheduler.DeleteTask(aTaskHandle); + TEST2(res, aExpectedError); + + //Delete Schedule + TheTest.Next(_L("Testing DeleteSchedule")); + res = TheScheduler.DeleteSchedule(aScheduleHandle); + TEST2(res, aExpectedError); + + CleanupStack::PopAndDestroy(tasks); + CleanupStack::PopAndDestroy(entries); + CleanupStack::PopAndDestroy(refs); + + TheScheduler.Close(); + + } + +LOCAL_D TInt Execute(TInt aScheduleHandle, + TInt aTaskHandle, + TInt aExpectedError, + TInt aExpectedScheduleCount, + TInt aExpectedTaskCount) + { + TInt err = KErrNoMemory; + CTrapCleanup* cleanup=CTrapCleanup::New(); //can fail + if (cleanup) + { + + TheTest.Start(_L("TSchSvrClient")); + TheTest.Title(); + err = KErrNone; + TRAP(err, DoExecuteL(aScheduleHandle, + aTaskHandle, + aExpectedError, + aExpectedScheduleCount, + aExpectedTaskCount)) + delete cleanup; + + TheTest.End(); + TheTest.Close(); + + } + return err; + } + + +//*********************************************************************************** +static TInt Str2Int(const TDesC& aStr) + { + TLex16 lex(aStr); + TInt val = 0; + lex.Val(val); + return val; + } + +static TBuf<20> ExtractInt(const TDesC& aBuf, TInt& aExtractedInt) + { + TBuf<20> buf = aBuf.Right(aBuf.Length() - aBuf.Locate(':')-1); + TBuf<5> handle; + handle.FillZ(); + handle = buf.Left(buf.Locate(':')); + aExtractedInt = Str2Int(handle); + return buf; + } + +GLDEF_C TInt E32Main() + { + TBuf<30> cmd; + User::CommandLine(cmd); + // schedule Handle is first + TInt scheduleHandle=0, taskHandle=0, errCode=0, schCount=0, taskCount=0; + cmd = ExtractInt(cmd, scheduleHandle); + // task Handle is second + cmd = ExtractInt(cmd, taskHandle); + // expected error code is third + cmd = ExtractInt(cmd, errCode); + // expected schedule count (based on this exe UID/Capability is fourth + cmd = ExtractInt(cmd, schCount); + // expected task count (based on this exe UID/Capability is fourth + cmd = ExtractInt(cmd, taskCount); + + return Execute(scheduleHandle, taskHandle, errCode, schCount, taskCount); + } + +