// 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;