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

#include <e32math.h>

#include "LogCliServShared.h"

#include "logservpanic.h"

#include "logpackage.h"

LOCAL_D RTest				TheTest(_L("T_LogServIPC"));

_LIT(KServerName, "!LogServ");

_LIT(KServerProcess, "LogServ");

//===========================================================================================

static TPtrC FileName(const TText* aFile)

    {

    TPtrC p(aFile);

    TInt ix=p.LocateReverse('\\');

    if (ix<0)

        ix=p.LocateReverse('/');

    if (ix>=0)

        p.Set(p.Mid(1+ix));

    return p;

    }

void LogLeave(TInt aErr, const TText* aFile, TInt aLine)

    {

    TPtrC fname(FileName(aFile));

    RDebug::Print(_L("*** LogEng test leave, err=%d, file: %S-%d\r\n"), aErr, &fname, aLine);

    User::Leave(aErr);

    }

#undef  TEST_STRING

#define TEST_STRING(s) _S(s)

#undef  LEAVE

#undef  LEAVE_IF_ERROR

#define LEAVE(err)           LogLeave(err, TEST_STRING(__FILE__), __LINE__)

#define LEAVE_IF_ERROR(err)  (err < KErrNone ? LogLeave(err, TEST_STRING(__FILE__), __LINE__) : void(0))

//===========================================================================================

///////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////

//Test macross and functions

static void Check(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		TheTest(EFalse, aLine);

		}

	}

static  void Check(TInt aValue, TInt aExpected, TInt aLine)

	{

	if(aValue != aExpected)

		{

		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

		TheTest(EFalse, aLine);

		}

	}

#define TEST(arg) ::Check((arg), __LINE__)

#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

///////////////////////////////////////////////////////////////////////////////////////

//

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

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