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

#include "CSCHCODE.H"

#include "SCHINFO.H"

#include <bsul/bsul.h>

#include <schinfointernal.h>

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)

	{