// 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 <e32test.h>

#include <e32math.h>

#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));

	}