--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lowlevellibsandfws/apputils/tsrc/T_BackupServerIPC.cpp	Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,435 @@
+// 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 "backup_std.h"
+
+LOCAL_D RTest				TheTest (_L("T_BackupServerIPC"));
+LOCAL_D CActiveScheduler*	TheScheduler;
+_LIT(KServerLauncherProcess, "T_BackupServerLauncher");
+_LIT(KServerStartProcess, "baksrvs");
+
+_LIT(KServerName, "!BackupServer");
+
+struct TTestInfo
+	{
+	TInt iFunction;
+	TInt iType;
+	TInt iArgCount;
+	};
+
+struct TExitDetails
+	{
+	TExitCategoryName iCategory;
+	TExitType iExitType;
+	TInt iReason;
+	};
+
+const TInt KAsynchDelay = 500000;
+
+//===============================================================================
+
+TBool IsFunctionAsynchronous(TInt aFunc)
+	{
+	TBool asynch = EFalse;
+	switch(aFunc)
+		{
+		case EBakOpCodeEventReady:
+		case EBakOpCodeCloseAllFiles:
+		case EBakOpCodeCloseServer:
+		case EBakOpCodeBackupOperationEventReady:
+			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);
+
+		User::LeaveIfError(CreateSession(aTargetSrvName, version, 200));
+
+		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)
+	{
+
+	TheTest.Printf(_L("Launching BackupServer...\n"));
+
+	TInt err = aServer.Create(KServerLauncherProcess, _L(""));
+
+	 if(err == KErrNone)
+		 {
+		 //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\n"), iFunc, iArgCount);
+			break;
+
+		case 1:
+			TheTest.Printf(_L("\nFuzz Test on function number %d using random Des8 data. Number of Args = %d\n"), iFunc, iArgCount);
+			break;
+
+		case 2:
+			TheTest.Printf(_L("\nFuzz Test on function number %d using random Des data. Number of Args = %d\n"), iFunc, iArgCount);
+			break;
+
+		}
+
+	}
+
+/**
+Invoke the tests
+*/
+/**
+@SYMTestCaseID          SYSLIB-BAFL-CT-4039
+@SYMTestCaseDesc	    Tests Bafl Backup Server APIs for IPC Robustness
+@SYMTestPriority 	    High
+@SYMTestActions  	    The function calls each of the Bafl Backup Server 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                	INC113760
+*/
+LOCAL_C void DoTestsL ()
+    {
+
+    RProcess server;
+    const TInt KMinFuncNumber = 20;
+    const TInt KMaxFuncNumber = 35;
+
+    TInt err = LaunchServer(server);
+    TheTest(err == 0);
+
+    TExitDetails exitDetails;
+
+    for(TInt i = KMinFuncNumber;i<= KMaxFuncNumber;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(i, testType, argCount);
+
+    			TestServerApi(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();
+	    			TheTest(exitReason == 0);
+	    			User::LeaveIfError(LaunchServer(server));
+	    			}
+    			}
+
+	    	TheTest.Printf(_L("\nFuzz Test Successful\n"));
+    		}
+    	}
+    }
+
+void SetupTestL()
+	{
+	TheScheduler = new (ELeave) CActiveScheduler;
+   	CActiveScheduler::Install (TheScheduler);
+
+	}
+
+
+GLDEF_C TInt E32Main ()
+	{
+
+	TheTest.Printf (_L ("\n"));
+	TheTest.Title ();
+	TheTest.Start (_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-4039 IPC Fuzz Tests "));
+
+   	CTrapCleanup* cleanup=CTrapCleanup::New();
+
+   	TInt err=KErrNoMemory;
+   	if (cleanup)
+   		{
+   		// Construct and install the active scheduler
+   		TRAP(err, SetupTestL());
+
+   		//Kill baksrvs which may have already been launched by another test
+   		KillProcess(KServerStartProcess);
+   		KillProcess(KServerLauncherProcess);
+
+   		TRAP (err, DoTestsL ());
+   		TheTest (err == KErrNone);
+
+   		TheTest.End ();
+   		TheTest.Close ();
+
+   		delete TheScheduler;
+   		delete cleanup;
+
+   		}
+	return err;
+	}