diff -r 000000000000 -r bde4ae8d615e os/persistentdata/loggingservices/eventlogger/test/src/t_logservIPC.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/persistentdata/loggingservices/eventlogger/test/src/t_logservIPC.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,1003 @@ +// Copyright (c) 2008-2010 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 "LogCliServShared.h" +#include "logservpanic.h" +#include "logpackage.h" +#include "t_logutil.h" + +RTest TheTest(_L("t_logservipc")); + +_LIT(KServerName, "!LogServ"); +_LIT(KServerProcess, "LogServ"); + +/////////////////////////////////////////////////////////////////////////////////////// +// + +struct TTestInfo + { + TInt iFunction; + TInt iType; + TInt iArgCount; + }; + +struct TExitDetails + { + TExitCategoryName iCategory; + TExitType iExitType; + TInt iReason; + }; + +const TInt KAsynchDelay = 500000; + +const TInt KFunctionNumbers [] = {ELogOperationCancel, + ELogOperationGetResult, + ELogOperationInitiate, + ELogNotify, + ELogNotifyCancel, + ELogViewCreate, + ELogViewDelete, + ELogViewCount, + ELogViewOperationInitiate, + ELogViewChangeNotificationsRequest, + ELogViewChangeNotificationsCancel, + ELogViewFetchChanges, + ELogViewNotifyLockStatusChange, + ELogViewNotifyLockStatusChangeCancel, + ELogNotifyExtended, + ELogNotifyExtendedCancel}; + +const TInt KNumFunctions = sizeof(KFunctionNumbers)/sizeof(KFunctionNumbers[0]); + +//=============================================================================== + +TBool IsFunctionAsynchronous(TInt aFunc) + { + TBool asynch = EFalse; + switch(aFunc) + { + case ELogOperationInitiate: + case ELogNotify: + case ELogViewOperationInitiate: + case ELogViewChangeNotificationsRequest: + case ELogViewNotifyLockStatusChange: + case ELogNotifyExtended: + asynch = ETrue; + break; + + 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); + + LEAVE_IF_ERROR(err); + + switch(aTestType) + { + case 0: + Fuzz(aFunc,aArgCount); + break; + + case 1: + Fuzz8L(aFunc,aArgCount); + break; + + case 2: + FuzzL(aFunc,aArgCount); + break; + } + } + +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" ); + TInt err = thread.Create(KThreadName,&FuzzServerL, KDefaultStackSize, NULL,&testInfo); + TEST2(err, KErrNone); + + 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) + { + + TheTest.Printf(_L("Launching LogServer...\n")); + + const TUid KServerUid3 = {0x0101f401d}; + 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: + TheTest.Printf(_L("\nFuzz Test on function number %d using random Int data. Number of Args = %d"), iFunc, iArgCount); + break; + + case 1: + TheTest.Printf(_L("\nFuzz Test on function number %d using random Des8 data. Number of Args = %d"), iFunc, iArgCount); + break; + + case 2: + TheTest.Printf(_L("\nFuzz Test on function number %d using random Des data. Number of Args = %d"), iFunc, iArgCount); + break; + + } + + } + +/** +Invoke the tests +*/ +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-4002 +@SYMTestCaseDesc Tests LogEng APIs for IPC Robustness +@SYMTestPriority High +@SYMTestActions The function calls each of the Logeng 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 INC114113 +*/ +LOCAL_C void DoFuzzTestsL () + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-4002 ")); + RProcess server; + + LEAVE_IF_ERROR(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(); + TEST2(exitReason, 0); + LEAVE_IF_ERROR(LaunchServer(server)); + } + } + + TheTest.Printf(_L("\nFuzz Test Successful\n")); + } + } + } + + +/* + * SERVER API TESTING + */ + +typedef void (*TestFunction)(); + +class RClientMessageTestSession : public RSessionBase + { +public: + TInt Connect(); + + TInt TestMakeTransient(TInt aArg0); + TInt TestMakeTransient(const TDesC8& aArg0); + + TInt TestCliServDataParam(TInt aFunc, TDes8& aArg0); + TInt TestCliServDataParam(TInt aFunc, TDes8& aArg0, TUint32 aArg1); + TInt TestCliServDataParam(TInt aFunc, TDes8& aArg0, TDes8& aArg1, TInt aArg2); + TInt TestCliServDataParam(TInt aFunc, TDes& aArg0, TDes8& aArg1, TInt aArg2); + + TInt TestLogNotify(TInt aArg0); + TInt TestLogNotifyCancel(); + + TInt TestLogViewCreate(TInt aArg0, TInt aArg1); + + TInt TestLogViewIdParam(TInt aFunc, TInt aArg0); + TInt TestLogViewIdParam(TInt aFunc, TDes8& aArg1); + + TInt TestLogViewFetchChanges(TInt aArg0, TInt aArg1, TDes8& aArg2); + TInt TestLogViewFetchChanges(TInt aArg0, TInt aArg1, const TDesC8& aArg2); + + TInt TestLogNotifyExtended(TDes8& aArg0, TDes8& aArg1, TDes8& aArg2,TDes8& aArg3); + TInt TestLogNotifyExtended(TDes& aArg0, TDes& aArg1, TDes& aArg2,TDes& aArg3); + TInt TestLogNotifyExtended(TDes8& aArg0, TInt aArg1, TInt aArg2,const TDesC8& aArg3); + + TInt TestFunction45(TAny* aData); + + + }; + +static TInt LaunchLogServer() + { + + 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 = LaunchLogServer(); + if((r != KErrNone)&&(r != KErrAlreadyExists)) + { + return r; + } + } + } + +TInt RClientMessageTestSession::TestMakeTransient(TInt aArg0) + { + return SendReceive(ELogMakeTransient,TIpcArgs(aArg0)); + } + +TInt RClientMessageTestSession::TestMakeTransient(const TDesC8& aArg0) + { + return SendReceive(ELogMakeTransient,TIpcArgs(&aArg0)); + } + +TInt RClientMessageTestSession::TestCliServDataParam(TInt aFunc, TDes8& aArg0) + { + return SendReceive(aFunc,TIpcArgs(&aArg0)); + } + +TInt RClientMessageTestSession::TestCliServDataParam(TInt aFunc, TDes8& aArg0, TUint32 aArg1) + { + return SendReceive(aFunc,TIpcArgs(&aArg0, aArg1)); + } + +TInt RClientMessageTestSession::TestCliServDataParam(TInt aFunc, TDes8& aArg0, TDes8& aArg1, TInt aArg2) + { + return SendReceive(aFunc,TIpcArgs(&aArg0, &aArg1, aArg2)); + } + +TInt RClientMessageTestSession::TestLogNotify(TInt aArg0) + { + return Send(ELogNotify,TIpcArgs(aArg0)); + } + +TInt RClientMessageTestSession::TestLogNotifyCancel() + { + return Send(ELogNotifyCancel); + } + +TInt RClientMessageTestSession::TestLogViewCreate(TInt aArg0, TInt aArg1) + { + return SendReceive(ELogViewCreate,TIpcArgs(aArg0,aArg1)); + } + + +TInt RClientMessageTestSession::TestLogViewIdParam(TInt aFunc, TInt aArg0) + { + return SendReceive(aFunc,TIpcArgs(aArg0)); + } + +TInt RClientMessageTestSession::TestLogViewIdParam(TInt aFunc, TDes8& aArg0) + { + return SendReceive(aFunc,TIpcArgs(&aArg0)); + } + +TInt RClientMessageTestSession::TestLogViewFetchChanges(TInt aArg0, TInt aArg1, TDes8& aArg2) + { + return SendReceive(ELogViewFetchChanges,TIpcArgs(aArg0,aArg1, &aArg2)); + } + +TInt RClientMessageTestSession::TestLogViewFetchChanges(TInt aArg0, TInt aArg1, const TDesC8& aArg2) + { + return SendReceive(ELogViewFetchChanges,TIpcArgs(aArg0,aArg1, &aArg2)); + } + +TInt RClientMessageTestSession::TestLogNotifyExtended(TDes8& aArg0, + TDes8& aArg1, TDes8& aArg2,TDes8& aArg3) + { + return Send(ELogNotifyExtended,TIpcArgs(&aArg0,&aArg1,&aArg2,&aArg3)); + } + +TInt RClientMessageTestSession::TestLogNotifyExtended(TDes& aArg0, + TDes& aArg1, TDes& aArg2,TDes& aArg3) + { + return Send(ELogNotifyExtended,TIpcArgs(&aArg0,&aArg1,&aArg2,&aArg3)); + } + +TInt RClientMessageTestSession::TestLogNotifyExtended(TDes8& aArg0, + TInt aArg1, TInt aArg2,const TDesC8& aArg3) + { + return Send(ELogNotifyExtended,TIpcArgs(&aArg0,&aArg1,&aArg2,&aArg3)); + } + +TInt RClientMessageTestSession::TestFunction45(TAny* aData) + { + return SendReceive(45,TIpcArgs(aData)); + } + + +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; + TInt err = thread.Create(aThreadName, &TestFunctionLauncherL, KDefaultStackSize, NULL, (TAny*)aFunction); + TEST2(err, KErrNone); + + 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-LOGENG-CT-4003 +@SYMTestCaseDesc Tests Message schema validation for the ELogMakeTransient message. +@SYMTestPriority High +@SYMTestActions Sends messages to the test server to test the validation of messages + against the message schema. +@SYMTestExpectedResults The server should validate the message and handle bad messages appropriately +@SYMDEF INC114113 +*/ +void TestMakeTransientL() + { + + RClientMessageTestSession session; + + TInt err = session.Connect(); + TEST2(err, KErrNone); + + CleanupClosePushL(session); + + err = session.TestMakeTransient(0); + TEST2(err, KErrNone); + + //anything different from 0 should be considered as ETrue + err = session.TestMakeTransient(1); + TEST2(err, KErrNone); + + err = session.TestMakeTransient(-5); + TEST2(err, KErrNone); + + err = session.TestMakeTransient(3); + TEST2(err, KErrNone); + + err = session.TestMakeTransient( _L8("Des8")); + TEST2(err, KErrNone); + + CleanupStack::PopAndDestroy(&session); + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-4004 +@SYMTestCaseDesc Tests Message schema validation for the messages accepting + TLogClientServerData parameters. +@SYMTestPriority High +@SYMTestActions Sends messages to the test server to test the validation of messages + against the message schema. The messages contain either valid or invalid + parameters. +@SYMTestExpectedResults The server should validate the message and handle bad messages appropriately +@SYMDEF INC114113 +*/ +void TestCliServDataParamL() + { + + RClientMessageTestSession session; + + TInt err = session.Connect(); + TEST2(err, KErrNone); + + CleanupClosePushL(session); + + TLogClientServerData data; + TPckg pData(data); + + TBuf8 buf; + + buf.SetLength(sizeof(TLogClientServerData)); + + buf.Fill(0xFF); + + data.iOperationType = ELogOperationEventAdd; + data.iOperationId = 1; + err = session.TestCliServDataParam(ELogOperationInitiate,pData); + TEST2(err, KErrBadDescriptor); + + data.iOperationType = ELogOperationViewWindowFetch; + data.iOperationId = 5; + err = session.TestCliServDataParam(ELogOperationInitiate,pData); + TEST2(err, KErrArgument); + + data.iOperationType = ELogOperationEventAdd; + data.iOperationId = 0x8FFFFFFF; + err = session.TestCliServDataParam(ELogOperationInitiate,pData); + TEST2(err, KErrBadDescriptor); + + data.iOperationType = ELogOperationEventAdd; + data.iOperationId = 0x8FFFFFFF; + err = session.TestCliServDataParam(ELogOperationInitiate,buf); + TEST2(err, KErrArgument); + + data.iOperationType = ELogOperationEventAdd; + data.iOperationId = 1; + err = session.TestCliServDataParam(ELogOperationCancel,pData); + TEST2(err, KErrCancel); + + data.iOperationType = ELogOperationEventAdd; + data.iOperationId = 1; + err = session.TestCliServDataParam(ELogOperationCancel,buf); + TEST2(err, KErrArgument); + + CLogPackage* package = CLogPackage::NewL(); + TPtr8 ptr(package->Ptr()); + + data.iOperationType = ELogOperationEventAdd; + data.iOperationId = 1; + err = session.TestCliServDataParam(ELogOperationGetResult,buf, ptr, 0); + TEST2(err, KErrArgument); + + data.iOperationType = ELogOperationEventAdd; + data.iOperationId = 1; + err = session.TestCliServDataParam(ELogOperationGetResult,pData, ptr, -1 ); + TEST2(err, KErrNone); + + delete package; + + TBuf8<8> smallBuf; + data.iOperationType = ELogOperationEventAdd; + data.iOperationId = 1; + err = session.TestCliServDataParam(ELogOperationGetResult,buf, smallBuf, 0); + TEST2(err, KErrArgument); + + CleanupStack::PopAndDestroy(&session); + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-LEGACY-T_LOGSERVIPC-0001 +@SYMTestCaseDesc Tests Message schema validation for the messages accepting + TLogClientServerData parameters. +@SYMTestPriority High +@SYMTestActions Sends messages to the test server to test the validation of messages + against the message schema. The messages contain either valid or invalid + parameters. +@SYMTestExpectedResults The server should validate the message and handle bad messages appropriately +@SYMDEF INC114113 +*/ +void TestCliServDataParam2L() + { + RClientMessageTestSession session; + + TInt err = session.Connect(); + TEST2(err, KErrNone); + + CleanupClosePushL(session); + + TBuf8 buf; + + buf.FillZ(); + + //This should panic with Logserv 63 + err = session.TestCliServDataParam(ELogOperationInitiate,buf); + TEST2(err, KErrNone); + + CleanupStack::PopAndDestroy(&session); + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-LEGACY-T_LOGSERVIPC-0002 +@SYMTestCaseDesc Tests Message schema validation for the messages accepting + TLogClientServerData parameters. +@SYMTestPriority High +@SYMTestActions Sends messages to the test server to test the validation of messages + against the message schema. The messages contain either valid or invalid + parameters. +@SYMTestExpectedResults The server should validate the message and handle bad messages appropriately +@SYMDEF INC114113 +*/ +void TestCliServDataParam3L() + { + RClientMessageTestSession session; + + TInt err = session.Connect(); + TEST2(err, KErrNone); + + CleanupClosePushL(session); + + TBuf8 buf; + + buf.FillZ(); + + err = session.TestCliServDataParam(ELogOperationInitiate,buf); + TEST2(err, KErrArgument); + + CleanupStack::PopAndDestroy(&session); + } + + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-4005 +@SYMTestCaseDesc Tests Message schema validation for the ELogNotify message. +@SYMTestPriority High +@SYMTestActions Sends messages to the test server to test the validation of messages + against the message schema. The messages contain either valid or invalid + parameters. +@SYMTestExpectedResults The server should validate the message and handle bad messages appropriately +@SYMDEF INC114113 +*/ +void TestLogNotifyL() + { + + RClientMessageTestSession session; + + TInt err = session.Connect(); + TEST2(err, KErrNone); + + CleanupClosePushL(session); + + err = session.TestLogNotify(0); + TEST2(err, KErrNone); + + //Cancel the pending notification + err = session.TestLogNotifyCancel(); + TEST2(err, KErrNone); + + err = session.TestLogNotify(1000000); + TEST2(err, KErrNone); + + //Cancel the pending notification + err = session.TestLogNotifyCancel(); + TEST2(err, KErrNone); + + err = session.TestLogNotify(-1); + TEST2(err, KErrNone); + + CleanupStack::PopAndDestroy(&session); + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-4006 +@SYMTestCaseDesc Tests Message schema validation for the ELogViewCreate message. +@SYMTestPriority High +@SYMTestActions Sends messages to the test server to test the validation of messages + against the message schema. The messages contain either valid or invalid + parameters. +@SYMTestExpectedResults The server should validate the message and handle bad messages appropriately +@SYMDEF INC114113 +*/ +void TestLogViewCreateL() + { + + RClientMessageTestSession session; + + TInt err = session.Connect(); + TEST2(err, KErrNone); + + CleanupClosePushL(session); + + err = session.TestLogViewCreate(0,ELogViewTypeEvent); + TEST2(err, KErrNone); + + err = session.TestLogViewCreate(100000,ELogViewTypeDuplicate); + TEST2(err, KErrNone); + + err = session.TestLogViewCreate(0,ELogViewTypeDuplicate + 1); + TEST2(err, KErrArgument); + + err = session.TestLogViewCreate(-1,ELogViewTypeRecent); + TEST2(err, KErrNone); + + err = session.TestLogViewCreate(20,-1); + TEST2(err, KErrArgument); + + CleanupStack::PopAndDestroy(&session); + } + + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-4012 +@SYMTestCaseDesc Tests Message schema validation for the ELogNotifyExtended message. +@SYMTestPriority High +@SYMTestActions Sends a message to the test server to test the validation of messages + against the message schema. The message contains an invalid descriptor. +@SYMTestExpectedResults The server should panic the client with KErrBadDescriptor +@SYMDEF INC114113 +*/ +void TestLogNotifyExtended2L() + { + + RClientMessageTestSession session; + + TInt err = session.Connect(); + TEST2(err, KErrNone); + + CleanupClosePushL(session); + + _LIT8(KDes8,"Des8"); + TPckgBuf int0(0); + + err = session.TestLogNotifyExtended(int0, 0, -1, KDes8); + TEST2(err, KErrNone); + + CleanupStack::PopAndDestroy(&session); + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-4013 +@SYMTestCaseDesc Tests Message schema validation for an invalid message +@SYMTestPriority High +@SYMTestActions Sends a message to the test server with a message number not + defined in the schema. +@SYMTestExpectedResults The server should return KErrInvalidFunction +@SYMDEF INC114113 +*/ +void InvalidMessageTestL() + { + + RClientMessageTestSession session; + + TInt err = session.Connect(); + TEST2(err, KErrNone); + + CleanupClosePushL(session); + + //This should cause the server to panic the client + err = session.TestFunction45(0); + + CleanupStack::PopAndDestroy(&session); + } + + + +static void DoAPITestsL() + { + + TExitDetails exitDetails; + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-4004 ")); + exitDetails = LaunchTestThreadL(_L("TestCliServDataParamL"), &TestCliServDataParamL); + TEST2(exitDetails.iExitType, EExitKill); + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-LEGACY-T_LOGSERVIPC-0001 ")); + exitDetails = LaunchTestThreadL(_L("TestCliServDataParam2L"), &TestCliServDataParam2L); + TEST2(exitDetails.iExitType, EExitPanic); + TEST2(exitDetails.iReason, ELogBadDescriptor); + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-LEGACY-T_LOGSERVIPC-0002 ")); + exitDetails = LaunchTestThreadL(_L("TestCliServDataParam3L"), &TestCliServDataParam3L); + TEST2(exitDetails.iExitType, EExitPanic); + TEST2(exitDetails.iReason, ELogBadDescriptor); + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-4005 ")); + exitDetails = LaunchTestThreadL(_L("TestLogNotifyL"), &TestLogNotifyL); + TEST2(exitDetails.iExitType, EExitKill); + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-4006 ")); + exitDetails = LaunchTestThreadL(_L("TestLogViewCreateL"), &TestLogViewCreateL); + TEST2(exitDetails.iExitType, EExitKill); + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-4012 ")); + exitDetails = LaunchTestThreadL(_L("TestLogNotifyExtended2L"), &TestLogNotifyExtended2L); + TEST2(exitDetails.iExitType, EExitKill); + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-4013 ")); + exitDetails = LaunchTestThreadL(_L("InvalidMessageTestL"), &InvalidMessageTestL); + TEST2(exitDetails.iExitType, EExitPanic); + TEST2(exitDetails.iReason, ELogIllegalFunction); + + //test for debug-only API +#ifdef _DEBUG + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-4003 ")); + exitDetails = LaunchTestThreadL(_L("TestMakeTransientL"), &TestMakeTransientL); + TEST2(exitDetails.iExitType, EExitKill); +#endif//_DEBUG + } + + + + +GLDEF_C TInt E32Main () + { + + TheTest.Printf (_L ("\n")); + TheTest.Title (); + TheTest.Start (_L("IPC Fuzz Tests")); + + CTrapCleanup* cleanup=CTrapCleanup::New(); + TEST(cleanup != NULL); + + TInt err=KErrNoMemory; + if (cleanup) + { + + // Construct and install the active scheduler + CActiveScheduler* scheduler = new CActiveScheduler; + TEST(scheduler != NULL); + CActiveScheduler::Install (scheduler); + + KillProcess(KServerProcess); + User::After(1000000); + + TRAP (err, DoFuzzTestsL ()); + TEST2(err, KErrNone); + + TheTest.Next(_L("LogServ API Robustness Tests")); + TRAP (err, DoAPITestsL ()); + TEST2(err, KErrNone); + + TheTest.End (); + TheTest.Close (); + + delete scheduler; + delete cleanup; + + } + return err; + }