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

 #include <e32test.h>

 #include <bautils.h>

 #include <hal.h>

 #include <e32std.h>

 #include <bsul/bsul.h>

 #include "t_clientmessagetestserver.h"

 using namespace BSUL;

 LOCAL_D RTest				Test (_L("T_ClientMessage"));

 LOCAL_D RFs					TheFs;

 _LIT(KServerName,"ClientMessageTestServer");

 _LIT(KServer2Name,"SecondTestServer");

 _LIT(KServerFileName,"T_ClientMessageTestServer.exe");

 struct TExitDetails

 	{

 	TExitCategoryName iCategory;

 	TExitType iExitType;

 	TInt iReason;

 	};

 typedef void (*TestFunction)();

 /*RClientMessageTestSession client side interface to

  * CClientMessageTestServer server.  This is used to pass

  * messages to the server to testthe Client Message Framework.

  */

 class RClientMessageTestSession : public RSessionBase

 	{

 public:

 	TInt Connect();

 	TInt TestFunction0(TInt aArg0);

 	TInt TestFunction0(TInt aArg0, TInt aArg1);

 	TInt TestFunction0(TInt aArg0, TInt aArg1, TInt aArg2);

 	TInt TestFunction0(const TDesC8& aData0, const TDesC& aData1);

 	TInt TestFunction1(TInt aArg0, TInt aArg1);

 	TInt TestFunction2(TInt aArg0, TInt aArg1);

 	TInt TestFunction3(TInt aArg0, TInt aArg1);

 	TInt TestFunction4(const TDesC8& aData0, const TDesC& aData1);

 	TInt TestFunction4(const TDesC& aData0, const TDesC8& aData1);

 	TInt TestFunction4(const TDesC8& aData0);

 	TInt TestFunction5(const TDesC8& aData0, const TDesC& aData1);

 	TInt TestFunction6(const TDesC8& aData0, const TDesC& aData1);

 	TInt TestFunction7(const TDesC8& aData0, const TDesC& aData1);

 	TInt TestFunction8(const TDesC8& aData0, const TDesC& aData1);

 	TInt TestFunction9(TDes8& aData0,TInt aOffset0, TDes& aData1,TInt aOffset1);

 	TInt TestFunction9(TDes& aData0,TInt aOffset0, TDes8& aData1,TInt aOffset1);

 	TInt TestFunction10(TDes8& aData0,TInt aOffset0, TDes& aData1,TInt aOffset1);

 	TInt TestFunction11(TDes8& aData0,TInt aOffset0, TDes& aData1,TInt aOffset1);

 	TInt TestFunction12(TDes8& aData0,TInt aOffset0, TDes& aData1,TInt aOffset1);

 	TInt TestFunction13(TDes8& aData0,TInt aOffset0, TDes& aData1,TInt aOffset1);

 	TInt TestFunction14(const TDesC8& aData0,TInt aOffset0, TDes8& aData1);

 	TInt TestFunction15(const TDesC& aData0,TInt aOffset0, TDes& aData1);

 	TInt TestFunction16(TAny* aData);

 	TInt TestFunction17(TAny* aData);

 	TInt TestFunction18(TDes8& aData);

 	TInt TestFunction18(TDes16& aData);

 	TInt TestFunction19(TDes8& aData);

 	TInt TestFunction20(TInt aArg0, TInt aArg1);

 	TInt TestFunction21(TInt aArg0, TInt aArg1);

 	TInt TestFunction22(TInt aArg0, TInt aArg1);

 	TInt TestFunction23(TInt aArg0, TInt aArg1);

 	TInt TestFunction24(TInt aArg0, TInt aArg1);

 	TInt TestFunction25();

 	TInt TestFunction26();

 	TInt TestFunction27();

 	TInt TestFunction28(TInt aArg0);

 	TInt TestFunction29(TDes& aData);

 	TInt TestFunction30(TDes8& aData);

 	TInt TestFunction31(TInt aArg0);

 	TInt TestFunction32(TDes8& aData);

 	TInt TestInvalidFunction(TInt aFn);

 	};

 /*RClientMessageTestSession2 client side interface to

  * CClientMessageTestServer2 server.  This is used to pass

  * messages to the server to testthe Client Message Framework.

  */

 class RClientMessageTestSession2 : public RSessionBase

 	{

 public:

 	TInt Connect();

 	TInt TestFunction0(TInt aArg0, TInt aArg1);

 	TInt TestFunction1(const TDesC& aData0);

 	};

 //Global process that is accessible in test code to determine the

 //exit reason and category on termination

 RProcess serverProcess;

 //Launch the server process

 static TInt LaunchServer()

 	{

 	TInt err = serverProcess.Create(KServerFileName,_L(""));

 	if(err == KErrNone)

 		{

 		 TRequestStatus serverStat;

 		 serverProcess.SetJustInTime(EFalse);

 		 serverProcess.Rendezvous(serverStat);

 		 serverProcess.Resume();

 		 User::WaitForRequest(serverStat);

 		}

 	return err;

 	}

 /* Connect to the CClientMessageTestServer, launching

  * the sevrer process if necessary

  */

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

 		if((r != KErrNone)&&(r != KErrAlreadyExists))

 			{

 			return r;

 			}

 		}

 	}

 /* These functions are used to send IPC messages to the server.

  * The messages are sent with different parameters to test the

  * ClientMessage framework handling of bad messages

  */

 TInt RClientMessageTestSession::TestFunction0(TInt aArg0, TInt aArg1)

 	{

 	return SendReceive(ETestMessage0,TIpcArgs(aArg0,aArg1));

 	}

 TInt RClientMessageTestSession::TestFunction0(TInt aArg0)

 	{

 	return SendReceive(ETestMessage0,TIpcArgs(aArg0));

 	}

 TInt RClientMessageTestSession::TestFunction0(TInt aArg0, TInt aArg1, TInt aArg2)

 	{

 	return SendReceive(ETestMessage0,TIpcArgs(aArg0,aArg1,aArg2));

 	}

 TInt RClientMessageTestSession::TestFunction0(const TDesC8& aData0, const TDesC& aData1)

 	{

 	//Call the function passing invalid arguments

 	return SendReceive(ETestMessage0,TIpcArgs(&aData0,&aData1));

 	}

 TInt RClientMessageTestSession::TestFunction1(TInt aArg0, TInt aArg1)

 	{

 	return SendReceive(ETestMessage1,TIpcArgs(aArg0,aArg1));

 	}

 TInt RClientMessageTestSession::TestFunction2(TInt aArg0, TInt aArg1)

 	{

 	return SendReceive(ETestMessage2,TIpcArgs(aArg0,aArg1));

 	}

 TInt RClientMessageTestSession::TestFunction3(TInt aArg0, TInt aArg1)

 	{

 	return SendReceive(ETestMessage3,TIpcArgs(aArg0,aArg1));

 	}

 TInt RClientMessageTestSession::TestFunction4(const TDesC8& aData0, const TDesC& aData1)

 	{

 	return SendReceive(ETestMessage4,TIpcArgs(&aData0,&aData1));

 	}

 TInt RClientMessageTestSession::TestFunction4(const TDesC& aData0, const TDesC8& aData1)

 	{

 	return SendReceive(ETestMessage4,TIpcArgs(&aData0,&aData1));

 	}

 TInt RClientMessageTestSession::TestFunction4(const TDesC8& aData0)

 	{

 	return SendReceive(ETestMessage4,TIpcArgs(&aData0));

 	}

 TInt RClientMessageTestSession::TestFunction5(const TDesC8& aData0, const TDesC& aData1)

 	{

 	return SendReceive(ETestMessage5,TIpcArgs(&aData0,&aData1));

 	}

 TInt RClientMessageTestSession::TestFunction6(const TDesC8& aData0, const TDesC& aData1)

 	{

 	return SendReceive(ETestMessage6,TIpcArgs(&aData0,&aData1));

 	}

 TInt RClientMessageTestSession::TestFunction7(const TDesC8& aData0, const TDesC& aData1)

 	{

 	return SendReceive(ETestMessage7,TIpcArgs(&aData0,&aData1));

 	}

 TInt RClientMessageTestSession::TestFunction8(const TDesC8& aData0, const TDesC& aData1)

 	{

 	return SendReceive(ETestMessage8,TIpcArgs(&aData0,&aData1));

 	}

 TInt RClientMessageTestSession::TestFunction9(TDes& aData0,TInt aOffset0, TDes8& aData1,TInt aOffset1)

 	{

 	return SendReceive(ETestMessage9,TIpcArgs(&aData0,aOffset0,&aData1,aOffset1));

 	}

 TInt RClientMessageTestSession::TestFunction9(TDes8& aData0,TInt aOffset0, TDes& aData1,TInt aOffset1)

 	{

 	return SendReceive(ETestMessage9,TIpcArgs(&aData0,aOffset0,&aData1,aOffset1));

 	}

 TInt RClientMessageTestSession::TestFunction10(TDes8& aData0,TInt aOffset0, TDes& aData1,TInt aOffset1)

 	{

 	return SendReceive(ETestMessage10,TIpcArgs(&aData0,aOffset0,&aData1,aOffset1));

 	}

 TInt RClientMessageTestSession::TestFunction11(TDes8& aData0,TInt aOffset0, TDes& aData1,TInt aOffset1)

 	{

 	return SendReceive(ETestMessage11,TIpcArgs(&aData0,aOffset0,&aData1,aOffset1));

 	}

 TInt RClientMessageTestSession::TestFunction12(TDes8& aData0,TInt aOffset0, TDes& aData1,TInt aOffset1)

 	{

 	return SendReceive(ETestMessage12,TIpcArgs(&aData0,aOffset0,&aData1,aOffset1));

 	}

 TInt RClientMessageTestSession::TestFunction13(TDes8& aData0,TInt aOffset0, TDes& aData1,TInt aOffset1)

 	{

 	return SendReceive(ETestMessage13,TIpcArgs(&aData0,aOffset0,&aData1,aOffset1));

 	}

 TInt RClientMessageTestSession::TestFunction14(const TDesC8& aData0,TInt aOffset0, TDes8& aData1)

 	{

 	return SendReceive(ETestMessage14,TIpcArgs(&aData0,aOffset0,&aData1));

 	}

 TInt RClientMessageTestSession::TestFunction15(const TDesC& aData0,TInt aOffset0, TDes& aData1)

 	{

 	return SendReceive(ETestMessage15,TIpcArgs(&aData0,aOffset0,&aData1));

 	}

 TInt RClientMessageTestSession::TestFunction16(TAny* aData)

 	{

 	return SendReceive(ETestMessage16,TIpcArgs(aData));

 	}

 TInt RClientMessageTestSession::TestFunction17(TAny* aData)

 	{

 	return SendReceive(ETestMessage17,TIpcArgs(aData));

 	}

 TInt RClientMessageTestSession::TestFunction18(TDes8& aData)

 	{

 	return SendReceive(ETestMessage18,TIpcArgs(&aData));

 	}

 TInt RClientMessageTestSession::TestFunction18(TDes& aData)

 	{

 	return SendReceive(ETestMessage18,TIpcArgs(&aData));

 	}

 TInt RClientMessageTestSession::TestFunction19(TDes8& aData)

 	{

 	return SendReceive(ETestMessage19,TIpcArgs(&aData));

 	}

 TInt RClientMessageTestSession::TestFunction20(TInt aArg0, TInt aArg1)

 	{

 	return SendReceive(ETestMessage20,TIpcArgs(aArg0,aArg1));

 	}

 TInt RClientMessageTestSession::TestFunction21(TInt aArg0, TInt aArg1)

 	{

 	return SendReceive(ETestMessage21,TIpcArgs(aArg0,aArg1));

 	}

 TInt RClientMessageTestSession::TestFunction22(TInt aArg0, TInt aArg1)

 	{

 	return SendReceive(ETestMessage22,TIpcArgs(aArg0,aArg1));

 	}

 TInt RClientMessageTestSession::TestFunction23(TInt aArg0, TInt aArg1)

 	{

 	return SendReceive(ETestMessage23,TIpcArgs(aArg0,aArg1));

 	}

 TInt RClientMessageTestSession::TestFunction24(TInt aArg0, TInt aArg1)

 	{

 	return SendReceive(ETestMessage24,TIpcArgs(aArg0,aArg1));

 	}

 TInt RClientMessageTestSession::TestFunction25()

 	{

 	return SendReceive(ETestMessage25,TIpcArgs());

 	}

 TInt RClientMessageTestSession::TestFunction26()

 	{

 	return SendReceive(ETestMessage26,TIpcArgs());

 	}

 TInt RClientMessageTestSession::TestFunction27()

 	{

 	return SendReceive(ETestMessage27,TIpcArgs());

 	}

 TInt RClientMessageTestSession::TestFunction28(TInt aArg0)

 	{

 	return SendReceive(ETestMessage28,TIpcArgs(aArg0));

 	}

 TInt RClientMessageTestSession::TestFunction29(TDes& aData)

 	{

 	return SendReceive(ETestMessage29,TIpcArgs(&aData));

 	}

 TInt RClientMessageTestSession::TestFunction30(TDes8& aData)

 	{

 	return SendReceive(ETestMessage30,TIpcArgs(&aData));

 	}

 TInt RClientMessageTestSession::TestFunction31(TInt aArg0)

 	{

 	return SendReceive(ETestMessage31,TIpcArgs(aArg0));

 	}

 TInt RClientMessageTestSession::TestFunction32(TDes8& aData)

 	{

 	return SendReceive(ETestMessage32,TIpcArgs(&aData));

 	}

 TInt RClientMessageTestSession::TestInvalidFunction(TInt aFn)

 	{

 	return SendReceive(aFn,TIpcArgs());

 	}

 /* This function is the entry point for a new thread.  It calls the

  * function passed to it as a TAny*.

  */

 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;

 	}

 /* This function creates a new thread and passes through the test function

  * to be called.  It also monitors and returns the exit reason for the launched

  * thread.

  */

 TExitDetails LaunchTestThreadL(const TDesC& aThreadName, TestFunction aFunction)

 	{

 	RThread thread;

 	TInt err = thread.Create(aThreadName, &TestFunctionLauncherL, KDefaultStackSize, NULL, (TAny*)aFunction);

 	if(err != KErrAlreadyExists)

 		{

 		User::LeaveIfError(err);

 		}

 	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;

 	}

 /*

  This test function accepts 2 integer parameters as defined below

 {EParamInt,-10,100},{EParamInt,0,200}

 Any calls to this function with parameters outside the ranges

 defined above should fail with KErrBadParameter

 */

 void TestFunction0AL()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	err = session.TestFunction0( 0, 100);

 	Test(err == KErrNone);

 	err = session.TestFunction0( 100, 0);

 	Test(err == KErrNone);

 	err = session.TestFunction0( -5, 10);

 	Test(err == KErrNone);

 	err = session.TestFunction0( -5, -10);

 	Test(err == KErrBadParameter);

 	err = session.TestFunction0( -15, 10);

 	Test(err == KErrBadParameter);

 	err = session.TestFunction0( -10, 200);

 	Test(err == KErrNone);

 	err = session.TestFunction0( 101, 102);

 	Test(err == KErrBadParameter);

 	err = session.TestFunction0(11, 56, 43);

 	Test(err == KErrNone);

 	err = session.TestFunction0( _L8("Des8"), _L("Des"));

 	Test(err == KErrBadParameter);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

  This test function accepts 2 integer parameters as defined below

 {EParamInt,-10,100},{EParamInt,0,200}

 In the server, this function tries to access a ptr type from

 an int argument. This is a programming error and should result

 in the server panicking with ECMPanicWrongParameterType in UDEB

 or returning KErrWrongParameterType in UREL

 */

 void TestFunction1L()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	err = session.TestFunction1(10,100);

 #ifdef _DEBUG

 	Test(err == KErrServerTerminated);

 	TInt type = serverProcess.ExitType();

 	Test(type == EExitPanic);

 	TInt reason = serverProcess.ExitReason();

 	Test(reason == ECMPanicWrongParameterType);

 #else

 	Test(err == KErrWrongParameterType);

 #endif

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

  This test function accepts 1 integer parameter as defined below

 {EParamInt,100,10}

 As can be seen above, the schema is incorrectly defined as iMin is

 greater than iMax. This is a programming error and should result

 in the server panicking with ECMPanicBadMessageSchema in UDEB

 or returning KErrBadParameter in UREL

 */

 void TestFunction2L()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	//this function is incorrectly defined in the

 	//message schema. This should result in the

 	//server panicking

 	err = session.TestFunction2(10,100);

 	//In debug builds the server should panic.

 	//In release builds KErrBadParameter should be returned

 #ifdef _DEBUG

 	Test(err == KErrServerTerminated);

 	TInt type = serverProcess.ExitType();

 	Test(type == EExitPanic);

 	TInt reason = serverProcess.ExitReason();

 	Test(reason == ECMPanicBadMessageSchema);

 #else

 	Test(err == KErrBadParameter);

 #endif

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

  This test function accepts 1 integer parameter as defined below

 {EParamInt,-10,-20}

 As can be seen above, the schema is incorrectly defined as iMin is

 greater than iMax. This is a programming error and should result

 in the server panicking with ECMPanicBadMessageSchema in UDEB

 or returning KErrBadParameter in UREL

 */

 void TestFunction3L()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	//this function is incorrectly defined in the

 	//message schema. This should result in the

 	//server panicking

 	err = session.TestFunction3(10,100);

 	//In debug builds the server should panic.

 	//In release builds KErrBadParameter should be returned

 #ifdef _DEBUG

 	Test(err == KErrServerTerminated);

 	TInt type = serverProcess.ExitType();

 	Test(type == EExitPanic);

 	TInt reason = serverProcess.ExitReason();

 	Test(reason == ECMPanicBadMessageSchema);

 #else

 	Test(err == KErrBadParameter);

 #endif

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

  This test function accepts 2 descriptor parameters as defined below

 {EParamDes8Read,2,16},{EParamDes16Read,0,32}

 Any calls to this function with parameters outside the constraints

 defined above should result in the client being panicked with

 KErrBadDescriptor

 */

 void TestFunction4AL()

 	{

 	RClientMessageTestSession session;

 	_LIT8(KDes8, "Des8");

 	_LIT8(KShortDes8, "De");

 	_LIT(KDes16, "Des16");

 	_LIT(KLongDes16, "Des16 - A longer version");

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	err = session.TestFunction4(KDes8,KDes16);

 	Test(err == KErrNone);

 	err = session.TestFunction4(KShortDes8,KLongDes16);

 	Test(err == KErrNone);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

  This test function accepts 2 descriptor parameters as defined below

 {EParamDes8Read,2,16},{EParamDes16Read,0,32}

 Any calls to this function with parameters outside the constraints

 defined above should result in the client being panicked with

 KErrBadDescriptor

 */

 void TestFunction4BL()

 	{

 	RClientMessageTestSession session;

 	_LIT8(KDes8, "Des8");

 	_LIT(KDes16, "Des16");

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	//This should result in the server panicking the client

 	err = session.TestFunction4(KDes16,KDes8);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

  This test function accepts 2 descriptor parameters as defined below

 {EParamDes8Read,2,16},{EParamDes16Read,0,32}

 Any calls to this function with parameters outside the constraints

 defined above should result in the client being panicked with

 KErrBadDescriptor

 */

 void TestFunction4CL()

 	{

 	RClientMessageTestSession session;

 	_LIT(KDes16, "Des16");

 	_LIT8(KLongDes8, "This is a long Des8");

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	//This should result in the server panicing the client

 	err = session.TestFunction4(KLongDes8,KDes16);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts 2 descriptor parameters as defined below

 {EParamDes8Read,2,16},{EParamDes16Read,0,32}

 Any calls to this function with parameters outside the constraints

 defined above should result in the client being panicked with

 KErrBadDescriptor

 */

 void TestFunction4DL()

 	{

 	RClientMessageTestSession session;

 	_LIT8(KDes8, "Des8");

 	_LIT(KLongDes16, "This is a long Des16 that should cause an issue");

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	//This should result in the server panicing the client

 	err = session.TestFunction4(KDes8,KLongDes16);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts 2 descriptor parameters as defined below

 {EParamDes8Read,2,16},{EParamDes16Read,0,32}

 Any calls to this function with parameters outside the constraints

 defined above should result in the client being panicked with

 KErrBadDescriptor

 */

 void TestFunction4EL()

 	{

 	RClientMessageTestSession session;

 	_LIT(KDes16, "Des16");

 	_LIT8(KEmptyDes8, "");

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	//This should result in the server panicing the client

 	//as the function expects a descriptor of minimum length 2

 	err = session.TestFunction4(KEmptyDes8,KDes16);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts 2 descriptor parameters as defined below

 {EParamDes8Read,2,16},{EParamDes16Read,0,32}

 Any calls to this function with parameters outside the constraints

 defined above should result in the client being panicked with

 KErrBadDescriptor

 */

 void TestFunction4FL()

 	{

 	RClientMessageTestSession session;

 	_LIT8(KDes8, "Des8");

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	//This should result in the server panicing the client

 	//as the function expects 2 descriptor arguments

 	err = session.TestFunction4(KDes8);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts 2 descriptor parameters as defined below

 {EParamDes8Read,2,16},{EParamDes16Read,0,32}

 The server attempts to read from the first descriptor but passes

 in a buffer that is too small.  This is a programming error and

 should result in the server panicking with ECMPanicBadDescriptor in UDEB

 and returning KErrNone in UREL

 KErrBadDescriptor

 */

 void TestFunction5L()

 	{

 	RClientMessageTestSession session;

 	_LIT8(KDes8, "Des8");

 	_LIT(KDes16, "Des16");

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	err = session.TestFunction5(KDes8,KDes16);

 #ifdef _DEBUG

 	Test(err == KErrServerTerminated);

 	TInt type = serverProcess.ExitType();

 	Test(type == EExitPanic);

 	TInt reason = serverProcess.ExitReason();

 	Test(reason == ECMPanicBadDescriptor);

 #else

 	Test(err == KErrNone);

 #endif

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts 2 descriptor parameters as defined below

 {EParamDes8Read,2,16},{EParamDes16Read,0,32}

 Any calls to this function with parameters outside the constraints

 defined above should result in the client being panicked with

 KErrBadDescriptor

 */

 void TestFunction6L()

 	{

 	RClientMessageTestSession session;

 	_LIT8(KDes8, "Des8");

 	_LIT(KDes16, "Des16");

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	err = session.TestFunction6(KDes8,KDes16);

 	Test(err == KErrArgument);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts 2 descriptor parameters as defined below

 {EParamDes8Read,2,16},{EParamDes16Read,0,32}

 Any calls to this function with parameters outside the constraints

 defined above should result in the client being panicked with

 KErrBadDescriptor

 */

 void TestFunction7L()

 	{

 	RClientMessageTestSession session;

 	_LIT8(KDes8, "Descriptor8");

 	_LIT(KDes16, "Descriptor16");

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	err = session.TestFunction7(KDes8,KDes16);

 	Test(err == KErrNone);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts 1 descriptor parameter as defined below

 {EParamDes8Read,0,-16}

 As can be seen above, the schema is incorrectly defined as iMax is

 negative. This is a programming error and should result

 in the server panicking with ECMPanicBadMessageSchema in UDEB

 or the client being panicked with KErrBadDescriptor in UREL

 */

 void TestFunction8L()

 	{

 	RClientMessageTestSession session;

 	_LIT8(KDes8, "Descriptor8");

 	_LIT(KDes16, "Descriptor16");

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	//this function is incorrectly defined in the

 	//message schema. This should result in the

 	//server panicking

 	err = session.TestFunction8(KDes8,KDes16);

 	//In debug builds the server should panic.

 	//In release builds the client will be panicked

 #ifdef _DEBUG

 	Test(err == KErrServerTerminated);

 	TInt type = serverProcess.ExitType();

 	Test(type == EExitPanic);

 	TInt reason = serverProcess.ExitReason();

 	Test(reason == ECMPanicBadMessageSchema);

 #endif

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts 2 descriptor parameters and 2 TInt

 parameters as defined below

 {EParamDes8,64,64},{EParamInt,0,64},{EParamDes16,128,128},{EParamInt,0,128}

 Any calls to this function with descriptor parameters outside the constraints

 defined above should result in the client being paniced with

 KErrBadDescriptor or KErrOverflow

 */

 void TestFunction9AL()

 	{

 	TBuf8<64> buf8;

 	TBuf<128> buf;

 	TBuf8<64> buf82;

 	TBuf<128> buf2;

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	err = session.TestFunction9(buf8,0,buf,0);

 	Test(err == KErrNone);

 	Test(buf8.Find(_L8("CClientMessageTest")) == 0);

 	Test(buf.Find(_L("CClientMessageTest")) == 0);

 	err = session.TestFunction9(buf82,7,buf2,73);

 	Test(err == KErrNone);

 	Test(buf82.Find(_L8("CClientMessageTest")) == 7);

 	Test(buf2.Find(_L("CClientMessageTest")) == 73);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts 2 descriptor parameters and 2 TInt

 parameters as defined below

 {EParamDes8,64,64},{EParamInt,0,64},{EParamDes16,128,128},{EParamInt,0,128}

 Any calls to this function with descriptor parameters outside the constraints

 defined above should result in the client being paniced with

 KErrBadDescriptor

 */

 void TestFunction9BL()

 	{

 	TBuf8<32> smallBuf8;

 	TBuf<32> smallBuf;

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	//this should result in a  client panic with KErrBadDescriptor

 	err = session.TestFunction9(smallBuf8,0,smallBuf,0);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts 2 descriptor parameters and 2 TInt

 parameters as defined below

 {EParamDes8,64,64},{EParamInt,0,64},{EParamDes16,128,128},{EParamInt,0,128}

 The server function attempts to write to the supplied descriptors at the

 offsets specified by the two TInt values.  In this test the server will

 attempt to write to the first buffer with an offset of 60 which should

 result in the client being panicked with KErrOverflow

 */

 void TestFunction9CL()

 	{

 	TBuf8<64> buf8;

 	TBuf<128> buf;

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	//this will attempt to write a descriptor with an offset of 60

 	//which should tresult in a client panic KErrOverflow

 	err = session.TestFunction9(buf8,60,buf,10);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts 2 descriptor parameters and 2 TInt

 parameters as defined below

 {EParamDes8,64,64},{EParamInt,0,64},{EParamDes16,128,128},{EParamInt,0,128}

 The test function below calls this function but passed the 8 and 16 bit

 descriptors in the wrong order which should result in the client being

 panicked with KErrBadDescriptor

 */

 void TestFunction9DL()

 	{

 	TBuf8<64> buf8;

 	TBuf<128> buf;

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	//this should result in a client panic as the descriptors

 	//are passed in in the wrong order

 	err = session.TestFunction9(buf,0,buf8,10);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts 2 descriptor parameters and 2 TInt

 parameters as defined below

 {EParamDes8,64,64},{EParamInt,0,64},{EParamDes16,128,128},{EParamInt,0,128}

 The server function attempts to write a descriptor that is larger than the

 buffer supplied by the client which should result in the client being

 panicked with KErrOverflow

 */

 void TestFunction10L()

 	{

 	TBuf8<64> buf8;

 	TBuf<128> buf;

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	//This function tries to write a descriptor

 	//that is larger than the declared buffer

 	//this should result in a panic

 	err = session.TestFunction10(buf8,0,buf,0);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts 2 descriptor parameters and 2 TInt

 parameters as defined below

 {EParamDes8,64,64},{EParamInt,0,64},{EParamDes16,128,128},{EParamInt,0,128}

 The server function attempts to read from a descriptor that is smaller

 than the specified minimum length.  This is a programming error and

 should result in the server panicking with ECMPanicBadDescriptor in UDEB

 and returning KErrNone in UREL

 */

 void TestFunction11L()

 	{

 	_LIT8(KLongDes8,"This descriptor is longer than 32 characters");

 	TBuf8<64> buf8(KLongDes8);

 	TBuf<128> buf;

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	//This function tries to read from a descriptor

 	//into a buffer that is smaller than the allowed min length

 	//this should result in a server panic

 	err = session.TestFunction11(buf8,0,buf,0);

 #ifdef _DEBUG

 	Test(err == KErrServerTerminated);

 	TInt type = serverProcess.ExitType();

 	Test(type == EExitPanic);

 	TInt reason = serverProcess.ExitReason();

 	Test(reason == ECMPanicBadDescriptor);

 #else

 	Test(err == KErrNone);

 #endif

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts 1 descriptor parameter as defined below

 {EParamDes8,-64,64}

 As can be seen above, the schema is incorrectly defined as iMin is

 negative. This is a programming error and should result

 in the server panicking with ECMPanicBadMessageSchema in UDEB

 or returning KErrNone in UREL

 */

 void TestFunction12L()

 	{

 	TBuf8<64> buf8;

 	TBuf<128> buf;

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	//this function is incorrectly defined in the

 	//message schema. This should result in the

 	//server panicking in debug builds

 	//In release builds KErrNone should be returned

 	err = session.TestFunction12(buf8,0,buf,0);

 #ifdef _DEBUG

 	Test(err == KErrServerTerminated);

 	TInt type = serverProcess.ExitType();

 	Test(type == EExitPanic);

 	TInt reason = serverProcess.ExitReason();

 	Test(reason == ECMPanicBadMessageSchema);

 #else

 	Test(err == KErrNone);

 #endif

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts 1 descriptor parameter as defined below

 {EParamDes8,64,-64}

 As can be seen above, the schema is incorrectly defined as iMax is

 negative. This is a programming error and should result

 in the server panicking with ECMPanicBadMessageSchema in UDEB

 or panicking the client with KErrBadDescriptor in UREL

 */

 void TestFunction13L()

 	{

 	TBuf8<64> buf8;

 	TBuf<128> buf;

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	//this function is incorrectly defined in the

 	//message schema. This should result in the

 	//server panicking in debug builds

 	err = session.TestFunction13(buf8,0,buf,0);

 #ifdef _DEBUG

 	Test(err == KErrServerTerminated);

 	TInt type = serverProcess.ExitType();

 	Test(type == EExitPanic);

 	TInt reason = serverProcess.ExitReason();

 	Test(reason == ECMPanicBadMessageSchema);

 #endif

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts 2 8bit descriptor parameters and 1 TInt

 parameter as defined below

 {EParamDes8Read,0,16},{EParamInt,0,16},{EParamDes8,16,16}

 The server function attempts reads from the first descriptor and

 then writes into the second descriptor at the offset supplied by

 the TInt value.  The test function below checks that the reading

 and writing with offset occurs as expected by checking the strings

 written by the server.

 */

 void TestFunction14L()

 	{

 	_LIT8(KDes8, "Descriptor8");

 	TBuf8<16> buf;

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	err = session.TestFunction14(KDes8,0,buf);

 	Test(err == KErrNone);

 	Test(buf.Find(_L8("Descriptor8")) == 0);

 	err = session.TestFunction14(KDes8,3,buf);

 	Test(err == KErrNone);

 	Test(buf.Find(_L8("criptor8")) == 0);

 	err = session.TestFunction14(KDes8,8,buf);

 	Test(err == KErrNone);

 	Test(buf.Find(_L8("or8")) == 0);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts 2 16bit descriptor parameters and 1 TInt

 parameter as defined below

 {EParamDes16Read,0,64},{EParamInt,0,64},{EParamDes16,64,64}

 The server function attempts reads from the first descriptor and

 then writes into the second descriptor at the offset supplied by

 the TInt value.  The test function below checks that the reading

 and writing with offset occurs as expected by checking the strings

 written by the server.

 */

 void TestFunction15L()

 	{

 	_LIT(KDes, "Descriptor");

 	TBuf<64> buf;

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	err = session.TestFunction15(KDes,0,buf);

 	Test(err == KErrNone);

 	Test(buf.Find(_L("Descriptor")) == 0);

 	err = session.TestFunction15(KDes,3,buf);

 	Test(err == KErrNone);

 	Test(buf.Find(_L("criptor")) == 0);

 	err = session.TestFunction15(KDes,8,buf);

 	Test(err == KErrNone);

 	Test(buf.Find(_L("or")) == 0);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts a single TAny* parameter as below

 {EParamPtr,0,0}

 The server function reads the pointer value.

 */

 void TestFunction16L()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	err = session.TestFunction16(0);

 	Test(err == KErrNone);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts a single TAny* parameter as below

 {EParamPtr,0,0}

 The server function attempts to call CMessageParameterBase::WriteL

 which is not defined for a Ptr type. This is a programming error and

 should result in the server panicking with ECMPanicWrongParameterType

 in UDEB or returning KErrWrongParameterType in UREL

 */

 void TestFunction17L()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	//This should result in the server panicking with ECMPanicWrongParameterType

 	//in UDEB or returning KErrWrongParameterType in UREL

 	err = session.TestFunction17(0);

 #ifdef _DEBUG

 	Test(err == KErrServerTerminated);

 	TInt type = serverProcess.ExitType();

 	Test(type == EExitPanic);

 	TInt reason = serverProcess.ExitReason();

 	Test(reason == ECMPanicWrongParameterType);

 #else

 	Test(err == KErrWrongParameterType);

 #endif

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts a single custom TPckg parameter as below

 {EParamCustom1,sizeof(CMTestStruct2),sizeof(CMTestStruct2)}.

 CMTestStruct2 is defined as follows:

 struct CMTestStruct1

 	{

 	TInt iInt;

 	TBuf<32> iDes;

 	};

 struct CMTestStruct2

 	{

 	TInt iCount;

 	CMTestStruct1* iStruct;

 	TCMTestEnum iEnum;

 	TBuf<32> iDes;

 	};

 The EParamCustom1 parameter type is validated using a custom validation

 function defined in the testclientmessageschema.cpp.  The validation

 function checks that iEnum is in the valid range for TCMTestEnum,

 that iCount >= 0 and that iDes.Length() > 0.  If any of these checks

 fail the server should return KErrBadParameter.

 */

 void TestFunction18AL()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	CMTestStruct1 struct1;

 	struct1.iInt = 7;

 	struct1.iDes = _L("Test Struct");

 	CMTestStruct2 struct2;

 	struct2.iCount = 1;

 	struct2.iStruct = &struct1;

 	struct2.iEnum = ETestVal1;

 	struct2.iDes = _L("Test Struct 2");

 	TPckg<CMTestStruct2> pData(struct2);

 	err = session.TestFunction18(pData);

 	Test(err == KErrNone);

 	Test(struct2.iCount == 0);

 	CMTestStruct1 struct3;

 	struct3.iInt = -1;

 	struct3.iDes = _L("");

 	CMTestStruct2 struct4;

 	struct4.iCount = 1;

 	struct4.iStruct = &struct3;

 	struct4.iEnum = -1;

 	struct4.iDes = _L("Test Struct 2");

 	TPckg<CMTestStruct2> pData2(struct4);

 	//As iEnum is not in the valid range this validation should fail

 	err = session.TestFunction18(pData2);

 	Test(err == KErrBadParameter);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts a single custom TPckg parameter as below

 {EParamCustom1,sizeof(CMTestStruct2),sizeof(CMTestStruct2)}.

 CMTestStruct2 is defined above.

 The test function below passes in a TPckg<CMTestStruct1> which is an

 incorrect type.  The server should return KErrBadDescriptor

 */

 void TestFunction18BL()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	CMTestStruct1 struct1;

 	struct1.iInt = 0;

 	struct1.iDes = _L("Test Struct");

 	TPckg<CMTestStruct1> pData(struct1);

 	//This should result in a panic

 	err = session.TestFunction18(pData);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts a single custom TPckg parameter as below

 {EParamCustom1,sizeof(CMTestStruct2),sizeof(CMTestStruct2)}.

 CMTestStruct2 is defined above.

 The test function below passes in an Empty TBuf the same size as a

 CMTestStruct2. As this wont contain any valid data, the server should

 panic the client with KErrBadParameter.

 */

 void TestFunction18CL()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	TBuf<sizeof(CMTestStruct2)> buf;

 	buf.SetLength(sizeof(CMTestStruct2));

 	//This should result in a panic

 	err = session.TestFunction18(buf);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts a single custom TPckg parameter as below

 {EParamCustom2,sizeof(CMTestStruct1),sizeof(CMTestStruct1)}.

 CMTestStruct1 is defined as follows:

 struct CMTestStruct1

 	{

 	TInt iInt;

 	TBuf<32> iDes;

 	};

 The EParamCustom1 parameter type is validated using a custom validation

 function defined in the testclientmessageschema.cpp.  The validation

 function checks that iInt is > 0.  If this check fails the server

 should return KErrBadParameter.

 The test function below passes the data to the server in a TPckgBuf

 */

 void TestFunction19L()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	CMTestStruct1 struct1;

 	struct1.iInt = 4;

 	struct1.iDes = _L("Test Struct");

 	TPckgBuf<CMTestStruct1> pData(struct1);

 	err = session.TestFunction19(pData);

 	Test(err == KErrNone);

 	struct1.iInt = -4;

 	TPckgBuf<CMTestStruct1> pData2(struct1);

 	err = session.TestFunction19(pData2);

 	Test(err == KErrBadParameter);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function does not expect any parameters.

 The schema defines a single placeholder parameter

 {EParamNull,0,0}

 but the number of parameters is set to 0

 */

 void TestFunction25L()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	err = session.TestFunction25();

 	Test(err == KErrNone);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function does not expect any parameters.

 The schema defines a single placeholder parameter

 {EParamNull,0,0}

 The schema is incorrectly defined as the number of parameters is

 listed as 1 instead of 0.  This is a programming error and should result

 in the server panicking with ECMPanicBadMessageSchema in UDEB

 or the client being panicked with KErrBadDescriptor in UREL

 */

 void TestFunction26L()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	err = session.TestFunction26();

 	//In debug builds the server should panic.

 	//In release builds KErrBadParameter should be returned

 #ifdef _DEBUG

 	Test(err == KErrServerTerminated);

 	TInt type = serverProcess.ExitType();

 	Test(type == EExitPanic);

 	TInt reason = serverProcess.ExitReason();

 	Test(reason == ECMPanicBadMessageSchema);

 #else

 	Test(err == KErrBadMessageSchema);

 #endif

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function does not expect any parameters.

 The schema defines a single placeholder parameter

 {453,0,0}

 The schema is incorrectly defined as it contains an invalid

 parameter type. This is a programming error and should result

 in the server panicking with ECMPanicBadMessageSchema in UDEB

 or returning KErrBadParameter in UREL

 */

 void TestFunction27L()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	err = session.TestFunction27();

 	//In debug builds the server should panic.

 	//In release builds KErrBadMessageSchema should be returned

 #ifdef _DEBUG

 	Test(err == KErrServerTerminated);

 	TInt type = serverProcess.ExitType();

 	Test(type == EExitPanic);

 	TInt reason = serverProcess.ExitReason();

 	Test(reason == ECMPanicBadMessageSchema);

 #else

 	Test(err == KErrBadMessageSchema);

 #endif

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts a single integer parameter with a

 custom validation function.

 {EParamCustom3,0,0}

 The validation functions checks that the value passed in is a

 multiple of 4.

 Any calls to this function with a parameter that is not divisible

 by 4 should fail with KErrBadParameter

 */

 void TestFunction28L()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	err = session.TestFunction28(4);

 	Test(err == KErrNone);

 	err = session.TestFunction28(128);

 	Test(err == KErrNone);

 	err = session.TestFunction28(73);

 	Test(err == KErrBadParameter);

 	err = session.TestFunction28(-1);

 	Test(err == KErrBadParameter);

 	err = session.TestFunction28(44444444);

 	Test(err == KErrNone);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts a single descriptor parameter with a

 custom validation function.

 {EParamCustom4,0,0}

 The validation functions checks that the descriptor passed in

 contains the string 'Expected Data'

 Any calls to this function with a descriptor that is not 'Expected Data'

 should fail with KErrBadParameter

 */

 void TestFunction29L()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	TBuf<32> data = _L("Expected Data");

 	err = session.TestFunction29(data);

 	Test(err == KErrNone);

 	data.SetLength(5);

 	err = session.TestFunction29(data);

 	Test(err == KErrBadParameter);

 	data = _L("expected data");

 	err = session.TestFunction29(data);

 	Test(err == KErrBadParameter);

 	data.Zero();

 	err = session.TestFunction29(data);

 	Test(err == KErrBadParameter);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts a single custom TPckg parameter as below

 {EParamPckg,sizeof(CMTestStruct1),sizeof(CMTestStruct1)}.

 CMTestStruct1 is defined as follows:

 struct CMTestStruct1

 	{

 	TInt iInt;

 	TBuf<32> iDes;

 	};

 The EParamCustom1 parameter type is validated using the default validation

 function.  This checks that the size of the TPckg passed in is

 exactly that defined in the schema. If this check fails the server

 should panic the client with KErrBadDescriptor.

 */

 void TestFunction30L()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	CMTestStruct1 struct1;

 	struct1.iInt = 4;

 	struct1.iDes = _L("Test Struct");

 	TPckg<CMTestStruct1> pData(struct1);

 	err = session.TestFunction30(pData);

 	Test(err == KErrNone);

 	TBuf8<16> data;

 	//This should cause a panic

 	err = session.TestFunction30(data);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /*

 This test function accepts an Intergeer parameter and a TAny* parameter

 {EParamInt,EGetIntL,EWrite16L},{EParamPtr,0,0}

 The server function checks the value passed in the TInt parameter and calls

 an appropriate CMessageParameterBase function on the second parameter.

 As none of the functions called are defined for a pointer parameter, the

 call defaults to the CMessageParameterBase implementation which panics the

 client with ECMPanicWrongParameterType in UDEB or returns

 KErrWrongParameterType in UREL

 */

 void DoTest31L(TInt aType)

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	err = session.TestFunction31(aType);

 #ifdef _DEBUG

 	Test(err == KErrServerTerminated);

 	TInt type = serverProcess.ExitType();

 	Test(type == EExitPanic);

 	TInt reason = serverProcess.ExitReason();

 	Test(reason == ECMPanicWrongParameterType);

 #else

 	Test(err == KErrWrongParameterType);

 #endif

 	CleanupStack::PopAndDestroy(&session);

 	}

 void TestFunction31AL()

 	{

 	DoTest31L(EGetIntL);

 	}

 void TestFunction31BL()

 	{

 	DoTest31L(EGetDes8L);

 	}

 void TestFunction31CL()

 	{

 	DoTest31L(EGetDes16L);

 	}

 void TestFunction31DL()

 	{

 	DoTest31L(EGetDesLengthL);

 	}

 void TestFunction31EL()

 	{

 	DoTest31L(EGetDesMaxLengthL);

 	}

 void TestFunction31FL()

 	{

 	DoTest31L(ERead8L);

 	}

 void TestFunction31GL()

 	{

 	DoTest31L(ERead16L);

 	}

 void TestFunction31HL()

 	{

 	DoTest31L(EWrite8L);

 	}

 void TestFunction31IL()

 	{

 	DoTest31L(EWrite16L);

 	}

 /*

 This test function accepts a single custom parameter as below

 {EParamCustom5,sizeof(CMTestStruct1),sizeof(CMTestStruct1)}

 CMTestStruct1 is defined as follows:

 struct CMTestStruct1

 	{

 	TInt iInt;

 	TBuf<32> iDes;

 	};

 The EParamCustom5 parameter type enum value is  defined as

 (0x90000 | EParamPckg).  The upper 16 bits are the index of

 the validation function in the array supplied by the server.

 The array only contains 5 values so the above definition is

 incorrect.  Calling this messge should result in the server

 panicking with ECMPanicBadMessageSchema in UDEB or returning

 KErrBadMessageSchema in UREL

 */

 void TestFunction32L()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	CMTestStruct1 struct1;

 	TPckg<CMTestStruct1> pData(struct1);

 	err = session.TestFunction32(pData);

 #ifdef _DEBUG

 	Test(err == KErrServerTerminated);

 	TInt type = serverProcess.ExitType();

 	Test(type == EExitPanic);

 	TInt reason = serverProcess.ExitReason();

 	Test(reason == ECMPanicBadMessageSchema);

 #else

 	Test(err == KErrBadMessageSchema);

 #endif

 	CleanupStack::PopAndDestroy(&session);

 	}

 /* Connect to the CClientMessageTestServer, launching

  * the server process if necessary

  */

 TInt RClientMessageTestSession2::Connect()

 	{

 	TInt retry = 2;

 	for(;;)

 		{

 		TInt r = CreateSession(KServer2Name,TVersion(1,0,0));

 		if((r != KErrNotFound)&&(r != KErrServerTerminated))

 			{

 			return r;

 			}

 		if(--retry == 0)

 			{

 			return r;

 			}

 		r = LaunchServer();

 		if((r != KErrNone)&&(r != KErrAlreadyExists))

 			{

 			return r;

 			}

 		}

 	}

 /* These functions are used to send IPC messages to the server.

  * The messages are sent with different parameters to test the

  * ClientMessage framework handling of bad messages

  */

 TInt RClientMessageTestSession2::TestFunction0(TInt aArg0, TInt aArg1)

 	{

 	return SendReceive(ETestMessage0,TIpcArgs(aArg0,aArg1));

 	}

 TInt RClientMessageTestSession2::TestFunction1(const TDesC& aData0)

 	{

 	return SendReceive(ETestMessage1,TIpcArgs(&aData0));

 	}

 /**

 @SYMTestCaseID SYSLIB-BAFL-CT-4040

 @SYMTestCaseDesc Tests CClientMessage handling of EParamInt type parameters

 @SYMTestPriority High

 @SYMTestActions Call a series of test functions expecting integer parameters.

 				Various argument values and types are passed to these functions.

 				The Server should only accept messages containing integer

 				values that fall within the bounds defined in the message schema.

 @SYMTestExpectedResults The Server should return KErrNone if the message is

 				accepted or KErrBadParameter if the int parameters are outside

 				the bounds defined in the schema.  If the message is incorrectly

 				defined in the mssage schema or the server code incorrectly uses

 				the parameter type the server should panic.

 @SYMDEF         INC117370

 */

 void DoIntParameterTestsL()

 	{

 	TExitDetails exitDetails;

 	exitDetails = LaunchTestThreadL(_L("TestFunction0"), &TestFunction0AL);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction1"), &TestFunction1L);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction2"), &TestFunction2L);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction3"), &TestFunction3L);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction28"), &TestFunction28L);

 	Test(exitDetails.iExitType == EExitKill);

 	}

 /**

 @SYMTestCaseID SYSLIB-BAFL-CT-4041

 @SYMTestCaseDesc Tests CClientMessage handling of EParamDes8Read and

 				EParamDes16Read type parameters

 @SYMTestPriority High

 @SYMTestActions Call a series of test functions expecting Des*Read parameters.

 				Various argument values and types are passed to these functions.

 				The Server should only accept messages containing Des*Read

 				values that fall within the bounds defined in the message schema.

 @SYMTestExpectedResults The Server should return KErrNone if the message is

 				accepted or panic the client with KErrBadDescriptor if the

 				descriptor parameters are outside the bounds defined in the schema.

 				If the message is incorrectly defined in the mssage schema or the

 				server code incorrectly uses the parameter type the server should panic.

 @SYMDEF         INC117370

 */

 void DoDesReadParameterTestsL()

 	{

 	TExitDetails exitDetails;

 	exitDetails = LaunchTestThreadL(_L("TestFunction4A"), &TestFunction4AL);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction4B"), &TestFunction4BL);

 	Test(exitDetails.iExitType == EExitPanic);

 	Test(exitDetails.iReason == KErrBadDescriptor);

 	exitDetails = LaunchTestThreadL(_L("TestFunction4C"), &TestFunction4CL);

 	Test(exitDetails.iExitType == EExitPanic);

 	Test(exitDetails.iReason == KErrBadDescriptor);

 	exitDetails = LaunchTestThreadL(_L("TestFunction4D"), &TestFunction4DL);

 	Test(exitDetails.iExitType == EExitPanic);

 	Test(exitDetails.iReason == KErrBadDescriptor);

 	exitDetails = LaunchTestThreadL(_L("TestFunction4E"), &TestFunction4EL);

 	Test(exitDetails.iExitType == EExitPanic);

 	Test(exitDetails.iReason == KErrBadDescriptor);

 	exitDetails = LaunchTestThreadL(_L("TestFunction4F"), &TestFunction4FL);

 	Test(exitDetails.iExitType == EExitPanic);

 	Test(exitDetails.iReason == KErrBadDescriptor);

 	exitDetails = LaunchTestThreadL(_L("TestFunction5"), &TestFunction5L);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction6"), &TestFunction6L);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction7"), &TestFunction7L);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction8"), &TestFunction8L);

 #ifdef _DEBUG

 	Test(exitDetails.iExitType == EExitKill);

 #else

 	Test(exitDetails.iExitType == EExitPanic);

 	Test(exitDetails.iReason == KErrBadDescriptor);

 #endif

 	exitDetails = LaunchTestThreadL(_L("TestFunction29"), &TestFunction29L);

 	Test(exitDetails.iExitType == EExitKill);

 	}

 /**

 @SYMTestCaseID SYSLIB-BAFL-CT-4042

 @SYMTestCaseDesc Tests CClientMessage handling of EParamDes8 and

 				EParamDes16 type parameters

 @SYMTestPriority High

 @SYMTestActions Call a series of test functions expecting Des* parameters.

 				Various argument values and types are passed to these functions.

 				The Server should only accept messages containing Des*

 				values that fall within the bounds defined in the message schema.

 @SYMTestExpectedResults The Server should return KErrNone if the message is

 				accepted or panic the client with KErrBadDescriptor or KErrOverflow if the

 				descriptor parameters are outside the bounds defined in the schema.

 				If the message is incorrectly defined in the mssage schema or the

 				server code incorrectly uses the parameter type the server should panic.

 @SYMDEF         INC117370

 */

 void DoDesParameterTestsL()

 	{

 	TExitDetails exitDetails;

 	exitDetails = LaunchTestThreadL(_L("TestFunction9A"), &TestFunction9AL);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction9B"), &TestFunction9BL);

 	Test(exitDetails.iExitType == EExitPanic);

 	Test(exitDetails.iReason == KErrBadDescriptor);

 	exitDetails = LaunchTestThreadL(_L("TestFunction9C"), &TestFunction9CL);

 	Test(exitDetails.iExitType == EExitPanic);

 	Test(exitDetails.iReason == KErrOverflow);

 	exitDetails = LaunchTestThreadL(_L("TestFunction9D"), &TestFunction9DL);

 	Test(exitDetails.iExitType == EExitPanic);

 	Test(exitDetails.iReason == KErrBadDescriptor);

 	exitDetails = LaunchTestThreadL(_L("TestFunction10"), &TestFunction10L);

 	Test(exitDetails.iExitType == EExitPanic);

 	Test(exitDetails.iReason == KErrOverflow);

 	exitDetails = LaunchTestThreadL(_L("TestFunction11"), &TestFunction11L);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction12"), &TestFunction12L);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction13"), &TestFunction13L);

 #ifdef _DEBUG

 	Test(exitDetails.iExitType == EExitKill);

 #else

 	Test(exitDetails.iExitType == EExitPanic);

 	Test(exitDetails.iReason == KErrBadDescriptor);

 #endif

 	exitDetails = LaunchTestThreadL(_L("TestFunction14"), &TestFunction14L);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction15"), &TestFunction15L);

 	Test(exitDetails.iExitType == EExitKill);

 	}

 /**

 @SYMTestCaseID SYSLIB-BAFL-CT-4043

 @SYMTestCaseDesc Tests CClientMessage handling of EParamPtr type parameters

 @SYMTestPriority High

 @SYMTestActions Call test functions accepting ptr parameter types

 @SYMTestExpectedResults The Server should return KErrNone if the message is

 				accepted. If the message is incorrectly defined in the message

 				schema or the server code incorrectly uses the parameter type

 				the server should panic

 				expected

 @SYMDEF         INC117370

 */

 void DoPtrParameterTestsL()

 	{

 	TExitDetails exitDetails;

 	exitDetails = LaunchTestThreadL(_L("TestFunction16"), &TestFunction16L);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction17"), &TestFunction17L);

 	Test(exitDetails.iExitType == EExitKill);

 	}

 /**

 @SYMTestCaseID SYSLIB-BAFL-CT-4044

 @SYMTestCaseDesc Tests CClientMessage handling of EParamPckg type parameters

 @SYMTestPriority High

 @SYMTestActions Call a series of test functions expecting Pckg parameters.

 				Various argument values and types are passed to these functions.

 				The Server should only accept messages containing Pckg

 				values that fall within the bounds defined in the message schema.

 @SYMTestExpectedResults The Server should return KErrNone if the message is

 				accepted, return KErrBadParameter if the packaged parameter is

 				outside the bounds described in the schema or panic the client with

 				KErrBadDescriptor if the descriptor parameter is outside the bounds

 				defined in the schema.

 @SYMDEF         INC117370

 */

 void DoPckgParameterTestsL()

 	{

 	TExitDetails exitDetails;

 	exitDetails = LaunchTestThreadL(_L("TestFunction18A"), &TestFunction18AL);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction18B"), &TestFunction18BL);

 	Test(exitDetails.iExitType == EExitPanic);

 	Test(exitDetails.iReason == KErrBadDescriptor);

 	exitDetails = LaunchTestThreadL(_L("TestFunction18C"), &TestFunction18CL);

 	Test(exitDetails.iExitType == EExitPanic);

 	Test(exitDetails.iReason == KErrBadDescriptor);

 	exitDetails = LaunchTestThreadL(_L("TestFunction19"), &TestFunction19L);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction30"), &TestFunction30L);

 	Test(exitDetails.iExitType == EExitPanic);

 	Test(exitDetails.iReason == KErrBadDescriptor);

 	exitDetails = LaunchTestThreadL(_L("TestFunction32"), &TestFunction32L);

 	Test(exitDetails.iExitType == EExitKill);

 	}

 /**

 @SYMTestCaseID SYSLIB-BAFL-CT-4045

 @SYMTestCaseDesc Tests CClientMessage handling of EParamNull type parameters

 @SYMTestPriority High

 @SYMTestActions Call a series of test functions expecting no parameters.

 @SYMTestExpectedResults The Server should return KErrNone if the message is

 				accepted. If the message is incorrectly defined in the message

 				schema or the server code incorrectly uses the parameter type

 				the server should panic.

 @SYMDEF         INC117370

 */

 void DoNullParameterTestsL()

 	{

 	TExitDetails exitDetails;

 	exitDetails = LaunchTestThreadL(_L("TestFunction25"), &TestFunction25L);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction26"), &TestFunction26L);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction27"), &TestFunction27L);

 	Test(exitDetails.iExitType == EExitKill);

 	}

 /**

 @SYMTestCaseID SYSLIB-BAFL-CT-4046

 @SYMTestCaseDesc Tests CClientMessage handling of Security policies

 @SYMTestPriority High

 @SYMTestActions Call several test functions with varying security policies and

 				verify that the ClientMessage framework handles each case as

 				expected

 @SYMTestExpectedResults The server should return KErrNone if the client has

 				the required security policy, otherwise return KErrPermissionDenied

 @SYMDEF         INC117370

 */

 void DoSecurityPolicyTestsL()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	CleanupClosePushL(session);

 	//This function is incorrectly defined in the message table

 	//for this server and so the CClientMessage Object creation will fail

 	//This should reult in the server panicking

 	RDebug::Print(_L("Testing Always Fail Policy..."));

 	err = session.TestFunction20(0,0);

 	Test(err == KErrPermissionDenied);

 	RDebug::Print(_L("Testing Valid SID Policy..."));

 	err = session.TestFunction21(0,0);

 	Test(err == KErrNone);

 	RDebug::Print(_L("Testing Invalid SID Policy..."));

 	err = session.TestFunction22(0,0);

 	Test(err == KErrPermissionDenied);

 	RDebug::Print(_L("Testing Valid Capability Policy..."));

 	err = session.TestFunction23(0,0);

 	Test(err == KErrNone);

 	RDebug::Print(_L("Testing Invalid Capability Policy..."));

 	err = session.TestFunction24(0,0);

 	Test(err == KErrPermissionDenied);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /**

 @SYMTestCaseID SYSLIB-BAFL-CT-4047

 @SYMTestCaseDesc Tests CClientMessage handling of undefined messagess

 @SYMTestPriority High

 @SYMTestActions Call a test function which sends an unknown message request to the

 				server.

 @SYMTestExpectedResults The ClientMessage framework should return KErrInvalidFunction

 @SYMDEF         INC117370

 */

 void DoInvalidMessageTestsL()

 	{

 	RClientMessageTestSession session;

 	TInt err = session.Connect();

 	CleanupClosePushL(session);

 	//This function is not defined in the message table

 	//for this server and so the CClientMessage Object creation will fail

 	//This should result in the server panicking

 	err = session.TestInvalidFunction(45);

 	Test(err == KErrInvalidFunction);

 	err = session.TestInvalidFunction(5);

 	Test(err == KErrInvalidFunction);

 	CleanupStack::PopAndDestroy(&session);

 	}

 /**

 @SYMTestCaseID SYSLIB-BAFL-CT-4050

 @SYMTestCaseDesc Tests CMessageParameterBase default implementation of message access functions

 @SYMTestPriority High

 @SYMTestActions Calls test functions which signal the server to call one

 				of the Message access methods on a EParamPtr parameter type.

 				As none of these methods are explicitly defined for a EParamPtr

 				type the call will be delegated to the base class implementation

 				which will panic the client in UDEB and return an error in UREL

 @SYMTestExpectedResults The server should panic the client with ECMPanicWrongParameterType

 				in UDEB and return KErrWrongParameterType in UREL

 @SYMDEF         INC117370

 */

 void DoCMessageParameterBaseTestL()

 	{

 	TExitDetails exitDetails;

 	exitDetails = LaunchTestThreadL(_L("TestFunction31A"), &TestFunction31AL);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction31B"), &TestFunction31BL);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction31C"), &TestFunction31CL);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction31D"), &TestFunction31DL);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction31E"), &TestFunction31EL);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction31F"), &TestFunction31FL);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction31G"), &TestFunction31GL);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction31H"), &TestFunction31HL);

 	Test(exitDetails.iExitType == EExitKill);

 	exitDetails = LaunchTestThreadL(_L("TestFunction31I"), &TestFunction31IL);

 	Test(exitDetails.iExitType == EExitKill);

 	}

 /**

 @SYMTestCaseID SYSLIB-BAFL-CT-4048

 @SYMTestCaseDesc Tests CClientMessage handling of multiple servers

 @SYMTestPriority High

 @SYMTestActions Calls test functions which pass the same message to two different

  				servers.  The servers have different message schemas and data is

  				passed to the server to check that the correct schema is used

  				for the given server.

 @SYMTestExpectedResults The ClientMessage framework should validate the message

 						against the correct schema for the given server

 @SYMDEF         INC117370

 */

 void DoMultipleServerTestsL()

 	{

 	RClientMessageTestSession session1;

 	RClientMessageTestSession2 session2;

 	TInt err = session1.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session1);

 	err = session2.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session2);

 	err = session1.TestFunction0( 0, 150);

 	Test(err == KErrNone);

 	err = session2.TestFunction0( 0, 150);

 	Test(err == KErrBadParameter);

 	err = session1.TestFunction0( 0, -50);

 	Test(err == KErrBadParameter);

 	err = session2.TestFunction0( 0, -50);

 	Test(err == KErrNone);

 	CleanupStack::PopAndDestroy(2,&session1);

 	}

 /**

 @SYMTestCaseID SYSLIB-BAFL-CT-4051

 @SYMTestCaseDesc Tests CClientMessage allowing disabling of Panic.

 @SYMTestPriority Medium

 @SYMTestActions Calls test functions which pass a message to a server for which the 

 				ESrvFlagDoNotPanicClientOnBadMessageErrors flag is set.Then invokes the client	API with 

 				incorrect arguments to create an error scenario of KErrBadDescriptor.

 @SYMTestExpectedResults The ClientMessage framework should check for the above flag, and in case 

 			its not set simply return an error instead of panicing the client.

 @SYMDEF         DEF125501

 */

 void DoDisablePanicTestsL()

 	{

 	RClientMessageTestSession2 session;

 	_LIT(KDes16, "Descriptor");

 	TInt err = session.Connect();

 	Test(err == KErrNone);

 	CleanupClosePushL(session);

 	/* According to schema defined, this function accepts TDesC8 only.

 	Validation failure occurs.Server should check if flag ESrvFlagDoNotPanicClientOnBadMessageErrors

 	is set, and either return with KErrBadDescriptor or Panic the client.

 	In this case the above flag is set for CClientMessageTestServer2.

 	*/

 	err = session.TestFunction1(KDes16);

 #ifdef _DEBUG

 	Test(err == KErrBadDescriptor);

 	// Server is not terminated, still alive

 	TInt type = serverProcess.ExitType();

 	Test(type == EExitPending);

 #else

 	Test(err == KErrBadDescriptor);

 #endif

 	CleanupStack::PopAndDestroy(&session);

 	}

 static void DoTestsL()

 	{

 	TExitDetails exitDetails;

 	Test.Title ();

 	Test.Start (_L("ClientMessage Tests"));

 	Test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-4040 Testing Message with Int Parameters "));

 	DoIntParameterTestsL();

 	Test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-4041 Testing Message with Read Only Des Parameters "));

 	DoDesReadParameterTestsL();

 	Test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-4042 Testing Message with Read/Write Des Parameters "));

 	DoDesParameterTestsL();

 	Test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-4043 Testing Message with Ptr Parameters "));

 	DoPtrParameterTestsL();

 	Test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-4044 Testing Message with Pckg Parameters "));

 	DoPckgParameterTestsL();

 	Test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-4045 Testing Message with Null Parameters "));

 	DoNullParameterTestsL();

 	Test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-4046 Testing Security Policy Checking "));

 	exitDetails = LaunchTestThreadL(_L("SecurityPolicyTestL"), &DoSecurityPolicyTestsL);

 	Test(exitDetails.iExitType == EExitKill);

 	Test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-4047 Testing Invalid Message "));

 	exitDetails = LaunchTestThreadL(_L("InvalidMessageTestL"), &DoInvalidMessageTestsL);

 	Test(exitDetails.iExitType == EExitKill);

 	Test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-4050 Testing CMessageParameterBase Default Implementations "));

 	exitDetails = LaunchTestThreadL(_L("CMessageParameterBaseTestL"), &DoCMessageParameterBaseTestL);

 	Test(exitDetails.iExitType == EExitKill);

 	Test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-4048 Testing Multiple Servers "));

 	exitDetails = LaunchTestThreadL(_L("MultipleServerTestingL"), &DoMultipleServerTestsL);

 	Test(exitDetails.iExitType == EExitKill);

 	Test.Next(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-4051 Testing Disable Client Panic"));

 	exitDetails = LaunchTestThreadL(_L("DisablePanicTesting"), &DoDisablePanicTestsL);

 	Test(exitDetails.iExitType == EExitKill);

 	Test.Printf(_L("Tests Completed O.K."));

 	Test.End();

 	Test.Close();

 	}

 TInt E32Main()

    //

    // Server process entry-point

    //

    	{

    	//

    	CTrapCleanup* cleanup=CTrapCleanup::New();

    	TInt r=KErrNoMemory;

    	if (cleanup)

    		{

  		TRAP(r,DoTestsL());

    		delete cleanup;

    		}

    	//

    	return r;

    	}