diff -r 000000000000 -r bde4ae8d615e os/ossrv/genericservices/taskscheduler/Test/Robustness/TC_TSCH_IPC.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/genericservices/taskscheduler/Test/Robustness/TC_TSCH_IPC.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,1476 @@ +// Copyright (c) 2008-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 +#include +#include +#include "CSCHCODE.H" +#include "SCHINFO.H" +#include +#include +using namespace BSUL; + + +LOCAL_D RTest Test (_L("TC_TSCH_IPC")); + +_LIT(KServerName, "!TaskScheduler"); +_LIT(KServerProcess, "SchExe"); + +struct TTestInfo + { + TInt iFunction; + TInt iType; + TInt iArgCount; + }; + +struct TExitDetails + { + TExitCategoryName iCategory; + TExitType iExitType; + TInt iReason; + }; + +const TInt KAsynchDelay = 500000; + +const TInt KFunctionNumbers [] = { ERegisterClient, + ECreateTimeSchedule, + ECreateConditionSchedule, + EScheduleTask, + ERemoveTask, + EDisableSchedule, + EEnableSchedule, + EDeleteSchedule, + EEditTimeSchedule, + EEditConditionSchedule, + EGetScheduleInfo, + EGetTimeScheduleData, + EGetConditionScheduleData, + EGetTaskData, + ECountSchedules, + ECountTasks, + EGetTaskRefs, + EGetTask, + EGetTaskDataSize, + EGetScheduleRefs, + EDeleteTask, + EGetSchedulerItemRefAndNextDueTime, + EGetScheduleType}; + +const TInt KNumFunctions = sizeof(KFunctionNumbers)/sizeof(KFunctionNumbers[0]); + +//=============================================================================== + +TBool IsFunctionAsynchronous(TInt aFunc) + { + TBool asynch = EFalse; + switch(aFunc) + { + + default: + break; + } + return asynch; + } + +class RIpcFuzzTest : public RSessionBase +{ +public: // Constructors and destructor + + /** + * Constructor for performing 1st stage construction + */ + RIpcFuzzTest(); + + /** + * Destructor. + */ + ~RIpcFuzzTest(); + + /** + * Performs test steps + */ + + void RunTestL(const TDesC& aTargetSrvName, TInt aFunc, + TInt aTestType, TInt aArgCount); + +private: + TInt Fuzz(TInt aMsg, TInt aArgCount); + TInt FuzzL(TInt aMsg, TInt aArgCount); + TInt Fuzz8L(TInt aMsg, TInt aArgCount); +}; + +RIpcFuzzTest::RIpcFuzzTest() + { + // No implementation required + } + + +RIpcFuzzTest::~RIpcFuzzTest() + { + Close(); + } + +TInt RIpcFuzzTest::Fuzz(TInt aMsg, TInt aArgCount) + { + TIpcArgs args; + + for(TInt i = 0; i < aArgCount;i++) + { + args.Set(i,Math::Random()); + } + + TInt ret; + + if(IsFunctionAsynchronous(aMsg)) + { + ret = Send(aMsg, args); + User::After(KAsynchDelay); + } + else + { + ret = SendReceive(aMsg, args); + } + return ret; + } + +TInt RIpcFuzzTest::Fuzz8L(TInt aMsg, TInt aArgCount) + { + HBufC8* buf = HBufC8::NewLC(255); + TPtr8 ptr = buf->Des(); + ptr.Fill(Math::Random(),255); + + TIpcArgs args; + + for(TInt i = 0; i < aArgCount;i++) + { + args.Set(i,&ptr); + } + + TInt ret; + + if(IsFunctionAsynchronous(aMsg)) + { + ret = Send(aMsg, args); + User::After(KAsynchDelay); + } + else + { + ret = SendReceive(aMsg, args); + } + + CleanupStack::PopAndDestroy(buf); + return ret; + } + +TInt RIpcFuzzTest::FuzzL(TInt aMsg, TInt aArgCount) + { + HBufC* buf = HBufC::NewLC(255); + TPtr ptr = buf->Des(); + ptr.Fill(Math::Random(),255); + + TIpcArgs args; + + for(TInt i = 0; i < aArgCount;i++) + { + args.Set(i,&ptr); + } + + TInt ret; + + if(IsFunctionAsynchronous(aMsg)) + { + ret = Send(aMsg, args); + User::After(KAsynchDelay); + } + else + { + ret = SendReceive(aMsg, args); + } + + CleanupStack::PopAndDestroy(buf); + return ret; + } + +void RIpcFuzzTest::RunTestL(const TDesC& aTargetSrvName, + TInt aFunc, TInt aTestType, TInt aArgCount) + { + TVersion version(0,0,0); + + TInt err = CreateSession(aTargetSrvName, version); + + User::LeaveIfError(err); + + switch(aTestType) + { + case 0: + Fuzz(aFunc,aArgCount); + break; + + case 1: + Fuzz8L(aFunc,aArgCount); + break; + + case 2: + FuzzL(aFunc,aArgCount); + break; + } + } + +TInt KillProcess(const TDesC& aProcessName) + { + TFullName name; + + RDebug::Print(_L("Find and kill \"%S\" process.\n"), &aProcessName); + + TBuf<64> pattern(aProcessName); + TInt length = pattern.Length(); + pattern += _L("*"); + TFindProcess procFinder(pattern); + + while (procFinder.Next(name) == KErrNone) + { + if (name.Length() > length) + {//If found name is a string containing aProcessName string. + TChar c(name[length]); + if (c.IsAlphaDigit() || + c == TChar('_') || + c == TChar('-')) + { + // If the found name is other valid application name + // starting with aProcessName string. + RDebug::Print(_L(":: Process name: \"%S\".\n"), &name); + continue; + } + } + RProcess proc; + if (proc.Open(name) == KErrNone) + { + proc.Kill(0); + RDebug::Print(_L("\"%S\" process killed.\n"), &name); + } + proc.Close(); + } + return KErrNone; + } + + +TInt FuzzServerL(TAny* aTestInfo) + { + CTrapCleanup* cleanup=CTrapCleanup::New(); + TInt err=KErrNoMemory; + if (cleanup) + { + + TTestInfo* info = (TTestInfo*)aTestInfo; + RIpcFuzzTest fuzzer; + + TRAP(err,fuzzer.RunTestL(KServerName,info->iFunction + ,info->iType, info->iArgCount)); + + fuzzer.Close(); + + delete cleanup; + } + return err; + } + + +void TestServerApi(TInt aFunctionNumber, + TInt aTestType,TInt aArgCount, TExitDetails& aExitDetails) + { + + TTestInfo testInfo; + testInfo.iFunction = aFunctionNumber; + testInfo.iType = aTestType; + testInfo.iArgCount = aArgCount; + + RThread thread; + _LIT(KThreadName,"FuzzerThread" ); + thread.Create(KThreadName,&FuzzServerL, KDefaultStackSize, NULL,&testInfo); + + TRequestStatus threadStat; + thread.Logon(threadStat); + + TBool jit = User::JustInTime(); + User::SetJustInTime(EFalse); + + thread.Resume(); + + User::WaitForRequest(threadStat); + + User::SetJustInTime(jit); + + aExitDetails.iCategory = thread.ExitCategory(); + aExitDetails.iReason = thread.ExitReason(); + aExitDetails.iExitType = thread.ExitType(); + + thread.Close(); + + } + + +TInt LaunchServer(RProcess& aServer) + { + + Test.Printf(_L("Launching Task Scheduler...\n")); + + const TUid KServerUid3 = {0x10005399}; + const TUidType serverUid(KNullUid,KNullUid,KServerUid3); + + TInt err = aServer.Create(KServerProcess, _L(""),serverUid); + + if(err == KErrNone) + { + aServer.SetPriority(EPriorityForeground); + + //Start server and wait until it is running + TRequestStatus serverStat; + aServer.SetJustInTime(false); + aServer.Resume(); + + aServer.Rendezvous(serverStat); + User::WaitForRequest(serverStat); + } + + return err; + + } + +void PrintTestMessage(TInt iFunc, TInt iType, TInt iArgCount) + { + switch(iType) + { + case 0: + Test.Printf(_L("\nFuzz Test on function number %d using random Int data. Number of Args = %d"), iFunc, iArgCount); + break; + + case 1: + Test.Printf(_L("\nFuzz Test on function number %d using random Des8 data. Number of Args = %d"), iFunc, iArgCount); + break; + + case 2: + Test.Printf(_L("\nFuzz Test on function number %d using random Des data. Number of Args = %d"), iFunc, iArgCount); + break; + + } + + } + +/** +Invoke the tests +*/ +/** +@SYMTestCaseID SYSLIB-SCHSVR-CT-4004 +@SYMTestCaseDesc Tests SchSvr APIs for IPC Robustness +@SYMTestPriority High +@SYMTestActions The function calls each of the SchSvr APIs through a custom session object + passing random TInt, Des8 and Des16 data . +@SYMTestExpectedResults The server should be robust to all malformed messages and should not + hang or panic. +@SYMDEF PDEF118811 +*/ +LOCAL_C void DoFuzzTestsL () + { + Test.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4004 ")); + RProcess server; + + User::LeaveIfError(LaunchServer(server)); + + TExitDetails exitDetails; + + for(TInt i = 0;i< KNumFunctions;i++) + { + + //Carry out each type of test + for(TInt testType = 0; testType < 3;testType++) + { + //Carry out each test with number of arguments 1 - 4 + for(TInt argCount = 1;argCount <= 4;argCount++) + { + PrintTestMessage(KFunctionNumbers[i], testType, argCount); + + TestServerApi(KFunctionNumbers[i], testType, argCount, exitDetails); + //Kill the server process and verify that it was still running + //If the server was already dead it would return the reason it exited + if(server.ExitType() != EExitPending) + { + server.Kill(0); + TInt exitReason = server.ExitReason(); + server.Close(); + Test(exitReason == 0); + User::LeaveIfError(LaunchServer(server)); + } + } + + Test.Printf(_L("\nFuzz Test Successful\n")); + } + } + } + + +/* + * SERVER API TESTING + */ + +typedef void (*TestFunction)(); + +class RClientMessageTestSession : public RSessionBase + { +public: + TInt Connect(); + + TInt TestRegisterClient(const TDesC& aData0, TInt aArg1); + + TInt TestCreateTimeSchedule(TDesC8& aData0,TDesC8& aData1,TDes8& aData2); + TInt TestCreateCondSchedule(TDesC8& aData0,TDesC8& aData1,TDesC8& aData2,TDes8& aData3); + + TInt TestScheduleTask(TDesC8& aData0,TInt aArg1,TDes8& aData2,TDesC& aData3); + TInt TestDeleteTask(TInt aArg0); + TInt TestDeleteSchedule(TInt aArg0); + TInt TestDisableSchedule(TInt aArg0); + TInt TestEnableSchedule(TInt aArg0); + + TInt TestEditTimeSchedule(TInt aArg0, TInt aArg1, TDes8& aData2); + TInt TestEditCondSchedule(TInt aArg0, TInt aArg1, TDes8& aData2, TDes8& aData3); + + TInt TestGetScheduleRefs(TInt aArg0, TInt aArg1, TDes8& aData2); + TInt TestCountSchedules(TDes8& aData0, TInt aArg1); + TInt TestGetScheduleType(TInt aArg0,TDes8& aData1); + TInt TestGetScheduleInfo(TInt aArg0, TDes8& aData1, TDes8& aData2); + TInt TestGetTimeScheduleData(TInt aArg0, TDes8& aData1, TDes8& aData2); + TInt TestGetCondScheduleData(TInt aArg0, TDes8& aData1, TDes8& aData2, TDes8& aData3); + TInt TestGetScheduleItemRef(TInt aArg0, TDes8& aData1, TDes8& aData2); + + TInt TestGetTaskData(TInt aArg0, TDes8& aData1, TDes8& aData2); + TInt TestGetTaskRefs(TInt aArg0, TInt aArg1,TInt aArg2, TDes8& aData3); + TInt TestCountTasks(TDes8& aData0, TInt aArg1, TInt aArg2); + TInt TestGetTaskInfo(TInt aArg0,TDesC8& aData1,TInt aArg2,TDesC& aData3); + TInt TestGetTaskDataSize(TInt aArg0,TDesC8& aData1); + + + }; + +static TInt LaunchLogServerL() + { + + RProcess process; + + TInt err = process.Create(KServerProcess,_L("")); + + if(err == KErrNone) + { + TRequestStatus serverStat; + + process.SetJustInTime(EFalse); + process.Resume(); + process.Rendezvous(serverStat); + User::WaitForRequest(serverStat); + } + + return err; + } + + +TInt RClientMessageTestSession::Connect() + { + TInt retry = 2; + for(;;) + { + TInt r = CreateSession(KServerName,TVersion(1,0,0)); + + if((r != KErrNotFound)&&(r != KErrServerTerminated)) + { + return r; + } + + if(--retry == 0) + { + return r; + } + + r = LaunchLogServerL(); + if((r != KErrNone)&&(r != KErrAlreadyExists)) + { + return r; + } + } + } + +TInt RClientMessageTestSession::TestRegisterClient(const TDesC& aData0, TInt aArg1) + { + return SendReceive(ERegisterClient,TIpcArgs(&aData0, aArg1)); + } + +TInt RClientMessageTestSession::TestCreateTimeSchedule(TDesC8& aData0,TDesC8& aData1,TDes8& aData2) + { + return SendReceive(ECreateTimeSchedule,TIpcArgs(&aData0, &aData1,& aData2)); + } + +TInt RClientMessageTestSession::TestCreateCondSchedule(TDesC8& aData0,TDesC8& aData1,TDesC8& aData2,TDes8& aData3) + { + return SendReceive(ECreateConditionSchedule,TIpcArgs(&aData0,&aData1, &aData2, &aData3)); + } + +TInt RClientMessageTestSession::TestScheduleTask(TDesC8& aData0,TInt aArg1,TDes8& aData2,TDesC& aData3) + { + return SendReceive(EScheduleTask,TIpcArgs(&aData0, aArg1, &aData2, &aData3)); + } + +TInt RClientMessageTestSession::TestDeleteTask(TInt aArg0) + { + return SendReceive(EDeleteTask,TIpcArgs(aArg0)); + } + +TInt RClientMessageTestSession::TestDeleteSchedule(TInt aArg0) + { + return SendReceive(EDeleteSchedule,TIpcArgs(aArg0)); + } + +TInt RClientMessageTestSession::TestDisableSchedule(TInt aArg0) + { + return SendReceive(EDisableSchedule,TIpcArgs(aArg0)); + } + +TInt RClientMessageTestSession::TestEnableSchedule(TInt aArg0) + { + return SendReceive(EEnableSchedule,TIpcArgs(aArg0)); + } + +TInt RClientMessageTestSession::TestEditTimeSchedule(TInt aArg0, TInt aArg1, TDes8& aData2) + { + return SendReceive(EEditTimeSchedule,TIpcArgs(aArg0, aArg1, &aData2)); + } + +TInt RClientMessageTestSession::TestEditCondSchedule(TInt aArg0, TInt aArg1, TDes8& aData2, TDes8& aData3) + { + return SendReceive(EEditConditionSchedule,TIpcArgs(aArg0, aArg1, &aData2,&aData3)); + } + + +TInt RClientMessageTestSession::TestGetScheduleRefs(TInt aArg0, TInt aArg1, TDes8& aData2) + { + return SendReceive(EGetScheduleRefs,TIpcArgs(aArg0, aArg1, &aData2)); + } + +TInt RClientMessageTestSession::TestCountSchedules(TDes8& aData0, TInt aArg1) + { + return SendReceive(ECountSchedules,TIpcArgs(&aData0, aArg1)); + } + +TInt RClientMessageTestSession::TestGetScheduleType(TInt aArg0,TDes8& aData1) + { + return SendReceive(EGetScheduleType,TIpcArgs(aArg0, &aData1)); + } + +TInt RClientMessageTestSession::TestGetScheduleInfo(TInt aArg0, TDes8& aData1, TDes8& aData2) + { + return SendReceive(EGetScheduleInfo,TIpcArgs(aArg0, &aData1, &aData2)); + } + +TInt RClientMessageTestSession::TestGetTimeScheduleData(TInt aArg0, TDes8& aData1, TDes8& aData2) + { + return SendReceive(EGetTimeScheduleData,TIpcArgs(aArg0, &aData1, &aData2)); + } + +TInt RClientMessageTestSession::TestGetCondScheduleData(TInt aArg0, TDes8& aData1, TDes8& aData2, TDes8& aData3) + { + return SendReceive(EGetConditionScheduleData,TIpcArgs(aArg0, &aData1, &aData2, &aData3)); + } + +TInt RClientMessageTestSession::TestGetScheduleItemRef(TInt aArg0, TDes8& aData1, TDes8& aData2) + { + return SendReceive(EGetSchedulerItemRefAndNextDueTime,TIpcArgs(aArg0, &aData1, &aData2)); + } + +TInt RClientMessageTestSession::TestGetTaskData(TInt aArg0, TDes8& aData1, TDes8& aData2) + { + return SendReceive(EGetTaskData,TIpcArgs(aArg0, &aData1, &aData2)); + } + +TInt RClientMessageTestSession::TestGetTaskRefs(TInt aArg0, TInt aArg1,TInt aArg2, TDes8& aData3) + { + return SendReceive(EGetTaskRefs,TIpcArgs(aArg0, aArg1, aArg2, &aData3)); + } + +TInt RClientMessageTestSession::TestCountTasks(TDes8& aData0, TInt aArg1, TInt aArg2) + { + return SendReceive(ECountTasks,TIpcArgs(&aData0, aArg1, aArg2)); + } + +TInt RClientMessageTestSession::TestGetTaskInfo(TInt aArg0,TDesC8& aData1,TInt aArg2,TDesC& aData3) + { + return SendReceive(EGetTask,TIpcArgs(aArg0, &aData1, aArg2, &aData3)); + } + +TInt RClientMessageTestSession::TestGetTaskDataSize(TInt aArg0,TDesC8& aData1) + { + return SendReceive(EGetTaskDataSize,TIpcArgs(aArg0, &aData1)); + } + + + + + +TInt TestFunctionLauncherL(TAny* aTestFunction) + { + CTrapCleanup* cleanup=CTrapCleanup::New(); + TInt r=KErrNoMemory; + if (cleanup) + { + TestFunction function = (TestFunction)aTestFunction; + +__UHEAP_MARK; + TRAP(r,function()); +__UHEAP_MARKEND; + + delete cleanup; + } + return r; + } + + +TExitDetails LaunchTestThreadL(const TDesC& aThreadName, TestFunction aFunction) + { + RThread thread; + thread.Create(aThreadName, &TestFunctionLauncherL, KDefaultStackSize, NULL, (TAny*)aFunction); + + TRequestStatus threadStat; + thread.Logon(threadStat); + + TBool jit = User::JustInTime(); + User::SetJustInTime(EFalse); + + thread.Resume(); + User::WaitForRequest(threadStat); + + User::SetJustInTime(jit); + + TExitDetails exitDetails; + exitDetails.iCategory = thread.ExitCategory(); + exitDetails.iReason = thread.ExitReason(); + exitDetails.iExitType = thread.ExitType(); + + return exitDetails; + } + + + +/** +@SYMTestCaseID SYSLIB-SCHSVR-CT-4005 +@SYMTestCaseDesc Tests Create Schedule API robustness +@SYMTestPriority High +@SYMTestActions Calls the Create Schedule APIs passing in varying parameters + to test the robustness of the API +@SYMTestExpectedResults The server should be robust to badly formed messages and should + return KErrBadParameter if messages do not fit the constraints + defined in the message schema. + The server should panic the client with KErrBadDescriptor if an + invalid descriptor argument is passed. +@SYMDEF PDEF118811 +*/ +void TestCreateSchedulesL() + { + + RClientMessageTestSession session; + + TInt err = session.Connect(); + + CleanupClosePushL(session); + + err = session.TestRegisterClient(_L("MyClient"),0); + Test(err == KErrNone); + + err = session.TestRegisterClient(_L("MyClient2"),-1); + Test(err == KErrBadParameter); + + TScheduleSettings2 settings; + TScheduleEntryInfo2 info; + TInt id; + + TPckg pSettings(settings); + TPckg pInfo(info); + TPckg pId(id); + + settings.iPersists = -1; + settings.iEntryCount = -1; + + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId); + Test(err == KErrBadParameter); + + settings.iPersists = 0; + settings.iEntryCount = 1; + + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId); + Test(err == KErrNone); + + TTsTime time; + TPckg pTime(time); + TTaskSchedulerCondition conditions; + TPckg pConditions(conditions); + + err = session.TestCreateCondSchedule(pSettings, pConditions, pTime,pId); + Test(err == KErrNone); + + err = session.TestDisableSchedule(id); + Test(err == KErrNone); + + err = session.TestDisableSchedule(249990000); + Test(err == KErrNotFound); + + err = session.TestDisableSchedule(-1); + Test(err == KErrBadParameter); + + err = session.TestDisableSchedule(250000000); + Test(err == KErrBadParameter); + + CleanupStack::PopAndDestroy(&session); + } + +void TestCreateSchedulesPanic1L() + { + RClientMessageTestSession session; + + TInt err = session.Connect(); + + CleanupClosePushL(session); + + err = session.TestRegisterClient(_L("MyClient"),0); + Test(err == KErrNone); + + TScheduleSettings2 settings; + TScheduleEntryInfo2 info; + TInt id; + + TPckg pSettings(settings); + TPckg pInfo(info); + TPckg pId(id); + + settings.iPersists = 0; + settings.iEntryCount = 0; + + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId); + Test(err == KErrNone); + + CleanupStack::PopAndDestroy(&session); + } + +void TestCreateSchedulesPanic2L() + { + RClientMessageTestSession session; + + TInt err = session.Connect(); + + CleanupClosePushL(session); + + err = session.TestRegisterClient(_L("MyClient"),0); + Test(err == KErrNone); + + TScheduleSettings2 settings; + TTaskSchedulerCondition conditions; + TTsTime time; + TInt id; + + TPckg pSettings(settings); + TPckg pConditions(conditions); + TPckg pTime(time); + TPckg pId(id); + + settings.iEntryCount = 2; + settings.iPersists = 0; + + err = session.TestCreateCondSchedule(pSettings, pConditions, pTime,pId); + Test(err == KErrNone); + + CleanupStack::PopAndDestroy(&session); + } + +/** +@SYMTestCaseID SYSLIB-SCHSVR-CT-4006 +@SYMTestCaseDesc Tests Edit Schedule API robustness +@SYMTestPriority High +@SYMTestActions Calls the Edit Schedule APIs passing in varying parameters + to test the robustness of the API +@SYMTestExpectedResults The server should be robust to badly formed messages and should + return KErrBadParameter if messages do not fit the constraints + defined in the message schema. +@SYMDEF PDEF118811 +*/ +void TestEditSchedulesL() + { + + RClientMessageTestSession session; + + TInt err = session.Connect(); + + CleanupClosePushL(session); + + err = session.TestRegisterClient(_L("MyClient"),0); + Test(err == KErrNone); + + TScheduleSettings2 settings; + TTaskSchedulerCondition conditions; + TTsTime time; + TInt id1; + TInt id2; + TScheduleInfo schedInfo; + + TPckg pSettings(settings); + TPckg pConditions(conditions); + TPckg pTime(time); + TPckg pId1(id1); + TPckg pId2(id2); + TPckg pSchedInfo(schedInfo); + + settings.iEntryCount = 1; + settings.iPersists = 0; + + TScheduleEntryInfo2 info; + TPckg pInfo(info); + + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1); + Test(err == KErrNone); + + err = session.TestEditTimeSchedule(settings.iEntryCount, id1,pInfo ); + Test(err == KErrNone); + + err = session.TestEditTimeSchedule(-1, id1,pInfo ); + Test(err == KErrBadParameter); + + err = session.TestEditTimeSchedule(10000, id1,pInfo ); + Test(err == KErrBadParameter); + + err = session.TestEditTimeSchedule(settings.iEntryCount, -1,pInfo ); + Test(err == KErrBadParameter); + + err = session.TestEditTimeSchedule(settings.iEntryCount,300000000,pInfo ); + Test(err == KErrBadParameter); + + err = session.TestCreateCondSchedule(pSettings, pConditions, pTime,pId2); + Test(err == KErrNone); + + err = session.TestEditCondSchedule(settings.iEntryCount, id2,pConditions, pTime ); + Test(err == KErrNone); + + err = session.TestEditCondSchedule(-231, id2,pConditions, pTime ); + Test(err == KErrBadParameter); + + err = session.TestEditCondSchedule(11000, id2,pConditions, pTime ); + Test(err == KErrBadParameter); + + err = session.TestEditCondSchedule(settings.iEntryCount, -1,pConditions, pTime ); + Test(err == KErrBadParameter); + + err = session.TestEditCondSchedule(settings.iEntryCount, 250000000,pConditions, pTime ); + Test(err == KErrBadParameter); + + CleanupStack::PopAndDestroy(&session); + + } + +/** +@SYMTestCaseID SYSLIB-SCHSVR-CT-4007 +@SYMTestCaseDesc Tests Schedule Data API robustness +@SYMTestPriority High +@SYMTestActions Calls the Get Schedule Data APIs passing in varying parameters + to test the robustness of the API +@SYMTestExpectedResults The server should be robust to badly formed messages and should + return KErrBadParameter if messages do not fit the constraints + defined in the message schema. + The server should panic the client with KErrBadDescriptor if an + invalid descriptor argument is passed. +@SYMDEF PDEF118811 +*/ +void TestGetScheduleDataL() + { + RClientMessageTestSession session; + + TInt err = session.Connect(); + + CleanupClosePushL(session); + + err = session.TestRegisterClient(_L("MyClient"),0); + Test(err == KErrNone); + + TScheduleSettings2 settings; + TTaskSchedulerCondition conditions; + TTsTime time; + TInt id1; + TInt id2; + TScheduleInfo schedInfo; + + TPckg pSettings(settings); + TPckg pConditions(conditions); + TPckg pTime(time); + TPckg pId1(id1); + TPckg pId2(id2); + TPckg pSchedInfo(schedInfo); + + settings.iEntryCount = 1; + settings.iPersists = 0; + + TScheduleEntryInfo2 info; + TPckg pInfo(info); + + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1); + Test(err == KErrNone); + + err = session.TestCreateCondSchedule(pSettings, pConditions, pTime,pId2); + Test(err == KErrNone); + + err = session.TestGetScheduleInfo(id1,pSchedInfo, pTime); + Test(err == KErrNone); + + err = session.TestGetScheduleInfo(-1,pSchedInfo, pTime); + Test(err == KErrBadParameter); + + err = session.TestGetScheduleInfo(250000000,pSchedInfo, pTime); + Test(err == KErrBadParameter); + + TInt count; + TPckg pCount(count); + + err = session.TestCountSchedules(pCount, -378); + Test(err == KErrBadParameter); + + err = session.TestCountSchedules(pCount, EAllSchedules); + Test(err == KErrNone); + + err = session.TestCountSchedules(pCount, EPendingSchedules); + Test(err == KErrNone); + + err = session.TestCountSchedules(pCount, 3); + Test(err == KErrBadParameter); + + schedInfo.iEntryCount = 1; + + err = session.TestGetTimeScheduleData(id1,pSchedInfo, pInfo); + Test(err == KErrNone); + + schedInfo.iEntryCount = 23; + + err = session.TestGetTimeScheduleData(id1,pSchedInfo, pInfo); + Test(err == KErrArgument); + + schedInfo.iEntryCount = 1; + + err = session.TestGetTimeScheduleData(250000000,pSchedInfo, pInfo); + Test(err == KErrBadParameter); + + err = session.TestGetCondScheduleData(id2,pSchedInfo, pInfo, pTime); + Test(err == KErrNone); + + schedInfo.iEntryCount = 23; + + err = session.TestGetCondScheduleData(id2,pSchedInfo, pInfo, pTime); + Test(err == KErrArgument); + + schedInfo.iEntryCount = 1; + + err = session.TestGetCondScheduleData(250000000,pSchedInfo, pInfo, pTime); + Test(err == KErrBadParameter); + + err = session.TestGetCondScheduleData(-3,pSchedInfo, pInfo, pTime); + Test(err == KErrBadParameter); + + err = session.TestCountSchedules(pCount, EAllSchedules); + Test(err == KErrNone); + + HBufC8* data = HBufC8::NewL(sizeof(TSchedulerItemRef)* count); + TPtr8 pData = data->Des(); + + err = session.TestGetScheduleRefs(count,EAllSchedules,pData); + Test(err == KErrNone); + + err = session.TestCountSchedules(pCount, EPendingSchedules); + Test(err == KErrNone); + + err = session.TestGetScheduleRefs(count,EPendingSchedules,pData); + Test(err == KErrArgument); + + err = session.TestGetScheduleRefs(count,3,pData); + Test(err == KErrBadParameter); + + err = session.TestGetScheduleRefs(count,-1,pData); + Test(err == KErrBadParameter); + + err = session.TestGetScheduleRefs(-5,EAllSchedules,pData); + Test(err == KErrBadParameter); + + delete data; + + TInt type; + TPckg pType(type); + + err = session.TestGetScheduleType(id1,pType); + Test(err == KErrNone); + + err = session.TestGetScheduleType(id2,pType); + Test(err == KErrNone); + + err = session.TestGetScheduleType(-1,pType); + Test(err == KErrBadParameter); + + err = session.TestGetScheduleType(250000002,pType); + Test(err == KErrBadParameter); + + CleanupStack::PopAndDestroy(&session); + } + +void TestGetScheduleDataPanic1L() + { + RClientMessageTestSession session; + + TInt err = session.Connect(); + + CleanupClosePushL(session); + + err = session.TestRegisterClient(_L("MyClient"),0); + Test(err == KErrNone); + + TScheduleSettings2 settings; + TTaskSchedulerCondition conditions; + TTsTime time; + TInt id1; + TScheduleInfo schedInfo; + + TPckg pSettings(settings); + TPckg pTime(time); + TPckg pId1(id1); + TPckg pSchedInfo(schedInfo); + + settings.iEntryCount = 1; + settings.iPersists = 0; + + TScheduleEntryInfo2 info; + TPckg pInfo(info); + + schedInfo.iEntryCount = 1; + + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1); + Test(err == KErrNone); + + err = session.TestGetTimeScheduleData(id1,pSchedInfo, pId1); + Test(err == KErrOverflow); + + CleanupStack::PopAndDestroy(&session); + } + +void TestGetScheduleDataPanic2L() + { + RClientMessageTestSession session; + + TInt err = session.Connect(); + + CleanupClosePushL(session); + + err = session.TestRegisterClient(_L("MyClient"),0); + Test(err == KErrNone); + + TScheduleSettings2 settings; + TInt id1; + TInt count; + + TPckg pSettings(settings); + TPckg pId1(id1); + TPckg pCount(count); + + settings.iEntryCount = 1; + settings.iPersists = 0; + + TScheduleEntryInfo2 info; + TPckg pInfo(info); + + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1); + Test(err == KErrNone); + + err = session.TestCountSchedules(pCount, EAllSchedules); + Test(err == KErrNone); + + err = session.TestGetScheduleRefs(count,EAllSchedules,pInfo); + Test(err == KErrOverflow); + + CleanupStack::PopAndDestroy(&session); + } + +/** +@SYMTestCaseID SYSLIB-SCHSVR-CT-4008 +@SYMTestCaseDesc Tests Schedule Task API robustness +@SYMTestPriority High +@SYMTestActions Calls the Schedule Tasks APIs passing in varying parameters + to test the robustness of the API +@SYMTestExpectedResults The server should be robust to badly formed messages and should + return KErrBadParameter if messages do not fit the constraints + defined in the message schema. + The server should panic the client with KErrBadDescriptor if an + invalid descriptor argument is passed. +@SYMDEF PDEF118811 +*/ +void TestScheduleTasksL() + { + + RClientMessageTestSession session; + + TInt err = session.Connect(); + + CleanupClosePushL(session); + + err = session.TestRegisterClient(_L("MyClient"),0); + Test(err == KErrNone); + + TScheduleSettings2 settings; + TScheduleEntryInfo2 info; + TInt id1; + TInt taskId; + + TPckg pSettings(settings); + TPckg pInfo(info); + TPckg pId1(id1); + TPckg pTaskId(taskId); + + + settings.iEntryCount = 1; + settings.iPersists = 0; + + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1); + Test(err == KErrNone); + + TTaskInfo taskInfo; + TPckg pTaskInfo(taskInfo); + TBuf<32> taskData; + + err = session.TestScheduleTask(pTaskInfo, -1, pTaskId,taskData); + Test(err == KErrBadParameter); + + err = session.TestScheduleTask(pTaskInfo, 300000000, pTaskId,taskData); + Test(err == KErrBadParameter); + + err = session.TestDeleteTask(0); + Test(err == KErrNotFound); + + err = session.TestDeleteTask(249999999); + Test(err == KErrNotFound); + + err = session.TestDeleteTask(250000000); + Test(err == KErrNotFound); + + err = session.TestDeleteTask(-1); + Test(err == KErrNotFound); + + CleanupStack::PopAndDestroy(&session); + } + +void TestScheduleTasksPanic1L() + { + RClientMessageTestSession session; + + TInt err = session.Connect(); + + CleanupClosePushL(session); + + err = session.TestRegisterClient(_L("MyClient"),0); + Test(err == KErrNone); + + TScheduleSettings2 settings; + TScheduleEntryInfo2 info; + TInt id1; + TInt taskId; + + TPckg pSettings(settings); + TPckg pInfo(info); + TPckg pId1(id1); + TPckg pTaskId(taskId); + + + settings.iEntryCount = 1; + settings.iPersists = 0; + + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1); + Test(err == KErrNone); + + TTaskInfo taskInfo; + TPckg pTaskInfo(taskInfo); + TBuf<32> taskData; + + //This should cause the server to panic the client as p0 is + //the wrong size + err = session.TestScheduleTask(pInfo, id1, pTaskId,taskData); + + CleanupStack::PopAndDestroy(&session); + } + +void TestScheduleTasksPanic2L() + { + RClientMessageTestSession session; + + TInt err = session.Connect(); + + CleanupClosePushL(session); + + err = session.TestRegisterClient(_L("MyClient"),0); + Test(err == KErrNone); + + TScheduleSettings2 settings; + TScheduleEntryInfo2 info; + TInt id1; + TInt taskId; + + TPckg pSettings(settings); + TPckg pInfo(info); + TPckg pId1(id1); + TPckg pTaskId(taskId); + + + settings.iEntryCount = 1; + settings.iPersists = 0; + + err = session.TestCreateTimeSchedule(pSettings, pInfo, pId1); + Test(err == KErrNone); + + TTaskInfo taskInfo; + TPckg pTaskInfo(taskInfo); + TBuf<32> taskData; + + //This should cause the server to panic the client as p2 is too large + err = session.TestScheduleTask(pTaskInfo, id1, pTaskInfo,taskData); + + CleanupStack::PopAndDestroy(&session); + } + + +/** +@SYMTestCaseID SYSLIB-SCHSVR-CT-4009 +@SYMTestCaseDesc Tests Get Task Data API robustness +@SYMTestPriority High +@SYMTestActions Calls the Get Task Data APIs passing in varying parameters + to test the robustness of the API +@SYMTestExpectedResults The server should be robust to badly formed messages and should + return KErrBadParameter if messages do not fit the constraints + defined in the message schema. +@SYMDEF PDEF118811 +*/ +void TestGetTaskDataL() + { + + RClientMessageTestSession session; + + TInt err = session.Connect(); + + CleanupClosePushL(session); + + err = session.TestRegisterClient(_L("MyClient"),0); + Test(err == KErrNone); + + TSchedulerItemRef itemRef; + TScheduleInfo schedInfo; + TTaskInfo taskInfo; + TInt id1; + TInt count; + TInt taskId; + + TPckg pSchedInfo(schedInfo); + TPckg pItemRef(itemRef); + TPckg pTaskInfo(taskInfo); + TPckg pId1(id1); + TPckg pCount(count); + TPckg pTaskId(taskId); + + + err = session.TestGetTaskData(-1,pSchedInfo,pTaskInfo); + Test(err == KErrBadParameter); + + err = session.TestGetTaskData(340000000,pSchedInfo,pTaskInfo); + Test(err == KErrBadParameter); + + err = session.TestGetTaskRefs(0,0,0,pItemRef); + Test(err == KErrArgument); + + err = session.TestGetTaskRefs(-1,EAllSchedules,EAllTasks,pItemRef); + Test(err == KErrBadParameter); + + err = session.TestGetTaskRefs(340000000, EAllSchedules,EMyTasks,pItemRef); + Test(err == KErrBadParameter); + + err = session.TestGetTaskRefs(1,-1,EAllTasks,pItemRef); + Test(err == KErrBadParameter); + + err = session.TestGetTaskRefs(1,3,EAllTasks,pItemRef); + Test(err == KErrBadParameter); + + err = session.TestGetTaskRefs(1,EPendingSchedules,-1,pItemRef); + Test(err == KErrBadParameter); + + err = session.TestGetTaskRefs(1,EPendingSchedules,2,pItemRef); + Test(err == KErrBadParameter); + + err = session.TestGetTaskRefs(1,EAllSchedules,EMyTasks,pItemRef); + Test(err == KErrArgument); + + err = session.TestCountTasks(pCount,EAllSchedules,EMyTasks); + Test(err == KErrNone); + + err = session.TestCountTasks(pCount,-1,EMyTasks); + Test(err == KErrBadParameter); + + err = session.TestCountTasks(pCount,2,EMyTasks); + Test(err == KErrBadParameter); + + err = session.TestCountTasks(pCount,EAllSchedules,-1); + Test(err == KErrBadParameter); + + err = session.TestCountTasks(pCount,EAllSchedules,2); + Test(err == KErrBadParameter); + + err = session.TestGetTaskDataSize(0,pCount); + Test(err == KErrNotFound); + + err = session.TestGetTaskDataSize(249999999,pCount); + Test(err == KErrNotFound); + + err = session.TestGetTaskDataSize(250000000,pCount); + Test(err == KErrNotFound); + + err = session.TestGetTaskDataSize(-1,pCount); + Test(err == KErrNotFound); + + TBuf<10> data; + + err = session.TestGetTaskInfo(0,pTaskInfo,10,data); + Test(err == KErrNotFound); + + err = session.TestGetTaskInfo(249999999,pTaskInfo,10,data); + Test(err == KErrNotFound); + + err = session.TestGetTaskInfo(250000000,pTaskInfo,10,data); + Test(err == KErrNotFound); + + err = session.TestGetTaskInfo(-1,pTaskInfo,10,data); + Test(err == KErrNotFound); + + TSchedulerItemRef schedItem; + TTsTime time; + + TPckg pSchedItem(schedItem); + TPckg pTime(time); + + err = session.TestGetScheduleItemRef(0,pSchedItem,pTime); + Test(err == KErrNone); + + err = session.TestGetScheduleItemRef(249999999,pSchedItem,pTime); + Test(err == KErrNotFound); + + err = session.TestGetScheduleItemRef(250000000,pSchedItem,pTime); + Test(err == KErrBadParameter); + + err = session.TestGetScheduleItemRef(-1,pSchedItem,pTime); + Test(err == KErrBadParameter); + + CleanupStack::PopAndDestroy(&session); + } + + +static void DoAPITestsL() + { + + TExitDetails exitDetails; + + Test.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4005 Test Create Schedule APIs ")); + exitDetails = LaunchTestThreadL(_L("TestCreateSchedulesL"), &TestCreateSchedulesL); + Test(exitDetails.iExitType == EExitKill); + + exitDetails = LaunchTestThreadL(_L("TestCreateSchedulesPanic1L"), &TestCreateSchedulesPanic1L); + Test(exitDetails.iExitType == EExitPanic); + Test(exitDetails.iReason == KErrBadDescriptor); + + exitDetails = LaunchTestThreadL(_L("TestCreateSchedulesPanic2L"), &TestCreateSchedulesPanic2L); + Test(exitDetails.iExitType == EExitPanic); + Test(exitDetails.iReason == KErrBadDescriptor); + + Test.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4006 Test Edit Schedule APIs ")); + exitDetails = LaunchTestThreadL(_L("TestEditSchedulesL"), &TestEditSchedulesL); + Test(exitDetails.iExitType == EExitKill); + + Test.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4007 ")); + exitDetails = LaunchTestThreadL(_L("TestGetScheduleDataL"), &TestGetScheduleDataL); + Test(exitDetails.iExitType == EExitKill); + + exitDetails = LaunchTestThreadL(_L("TestGetScheduleDataPanic1L"), &TestGetScheduleDataPanic1L); + Test(exitDetails.iExitType == EExitPanic); + Test(exitDetails.iReason == KErrOverflow); + + Test.Next(_L(" Test Get Schedule Data APIs ")); + exitDetails = LaunchTestThreadL(_L("TestGetScheduleDataPanic2L"), &TestGetScheduleDataPanic2L); + Test(exitDetails.iExitType == EExitPanic); + Test(exitDetails.iReason == KErrOverflow); + + Test.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4008 Test Schedule Task APIs ")); + exitDetails = LaunchTestThreadL(_L("TestScheduleTasksL"), &TestScheduleTasksL); + Test(exitDetails.iExitType == EExitKill); + + exitDetails = LaunchTestThreadL(_L("TestScheduleTasksPanic1L"), &TestScheduleTasksPanic1L); + Test(exitDetails.iExitType == EExitPanic); + Test(exitDetails.iReason == KErrBadDescriptor); + + exitDetails = LaunchTestThreadL(_L("TestScheduleTasksPanic2L"), &TestScheduleTasksPanic2L); + Test(exitDetails.iExitType == EExitPanic); + Test(exitDetails.iReason == KErrBadDescriptor); + + Test.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-4009 Test Get Task Data APIs ")); + exitDetails = LaunchTestThreadL(_L("TestGetTaskDataL"), &TestGetTaskDataL); + Test(exitDetails.iExitType == EExitKill); + + } + + + + + + +GLDEF_C TInt E32Main () + { + + Test.Printf (_L ("\n")); + Test.Title (); + Test.Start (_L("IPC Fuzz Tests")); + + CTrapCleanup* cleanup=CTrapCleanup::New(); + + TInt err=KErrNoMemory; + if (cleanup) + { + + // Construct and install the active scheduler + CActiveScheduler* scheduler = new (ELeave) CActiveScheduler; + CActiveScheduler::Install (scheduler); + + KillProcess(KServerProcess); + User::After(1000000); + + TRAP (err, DoFuzzTestsL ()); + Test (err == KErrNone); + + Test.Next(_L("Task Scheduler API Robustness Tests")); + TRAP (err, DoAPITestsL ()); + Test (err == KErrNone); + + Test.End (); + Test.Close (); + + delete scheduler; + delete cleanup; + + } + return err; + }