// 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 "t_clientmessagetestserver.h"

_LIT(KServerName,"ClientMessageTestServer");

_LIT(KServer2Name,"SecondTestServer");

extern const BSUL::TClientMessageServerData KServerData;

extern const BSUL::TClientMessageServerData KServer2Data;

/* CClientMessageTestServer is a lightweight Server that is used to test

 * the CClientMessage framework.  Clientside code sends messages to the 

 * server which are processed and the client chceks the expected behaviour.

 * The server code does no testing itself.

 */

CServer2* CClientMessageTestServer::NewLC()

	{

	CClientMessageTestServer* self = new(ELeave) CClientMessageTestServer(CActive::EPriorityStandard);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CClientMessageTestServer::ConstructL()

	{

	BSUL::CClientMessage::InitialiseFrameworkL(KServerData);

	StartL(KServerName);

	}

TInt CClientMessageTestServer::RunError(TInt aError)

	{

	Message().Complete(aError);

	ReStart();

	return KErrNone;

	}

CClientMessageTestServer::CClientMessageTestServer(TInt aPriority):

		CServer2(aPriority)

	{	

	}

CSession2* CClientMessageTestServer::NewSessionL(const TVersion& /*aVersion*/, const RMessage2& /*aMessage*/) const

	{

	return new(ELeave)CClientMessageTestSession;

	}

/* CClientMessageTestSession is a lightweight Session class processes

 * messages from the client using the CClientMessage framework 

 */

CClientMessageTestSession::~CClientMessageTestSession()

	{

	delete iClientMessage;

	}

void CClientMessageTestSession::CreateL(const CServer2& /*aServer*/)

	{

	}

void CClientMessageTestSession::ServiceL(const RMessage2& aMessage)

	{

	iClientMessage = BSUL::CClientMessage::NewL(aMessage);

	TRAPD(err, iClientMessage->ValidateL());

	if(err == KErrNone)

		{

		TRAP(err, DoServiceL());

		}

	iClientMessage->CompleteRequestL(err);

	delete iClientMessage;

	iClientMessage = NULL;

	}

void CClientMessageTestSession::DoServiceL()

	{

	switch(iClientMessage->Function())

		{

		case ETestMessage0:

		case ETestMessage21:

		case ETestMessage23:

			{

			TestFunction0L();

			break;

			}

		case ETestMessage1:

			{

			TestFunction1L();

			break;

			}

		case ETestMessage4:

			{

			TestFunction4L();

			break;

			}

		case ETestMessage5:

			{

			TestFunction5L();

			break;

			}

		case ETestMessage6:

			{

			TestFunction6L();

			break;

			}

		case ETestMessage7:

			{

			TestFunction7L();

			break;

			}

		case ETestMessage9:

			{

			TestFunction9L();

			break;

			}

		case ETestMessage10:

			{

			TestFunction10L();

			break;

			}

		case ETestMessage11:

			{

			TestFunction11L();

			break;

			}

		case ETestMessage14:

			{

			TestFunction14L();

			break;

			}

		case ETestMessage15:

			{

			TestFunction15L();

			break;

			}

		case ETestMessage16:

			{

			TestFunction16L();

			break;

			}

		case ETestMessage17:

			{

			TestFunction17L();

			break;

			}

		case ETestMessage18:

			{

			TestFunction18L();

			break;

			}

		case ETestMessage19:

			{

			TestFunction19L();

			break;

			}

		case ETestMessage31:

			{

			TestFunction31L();

			break;

			}

		//Just testing the validation of these functions.

		//No action to be taken

		case ETestMessage12:

		case ETestMessage13:

		case ETestMessage25:

		case ETestMessage26:

		case ETestMessage27:

		case ETestMessage28:

		case ETestMessage29:

		case ETestMessage30:

		case ETestMessage32:

			{

			break;

			}

		//This should never happen because these functions have been

		//incorrectly defined in the message schema and calling these

		//functions should result in a server panic when creating the

		//CClientMessage object using the message.		

		case ETestMessage2:

		case ETestMessage3:

		case ETestMessage8:

		//These messages should never be called as they have a failing security policy

		//for the client server

		case ETestMessage20:

		case ETestMessage22:

		case ETestMessage24:

			User::Panic(_L("ClientMessageTest"),0);

			break;

		}

	}

/*The test functions below read from or write to the 

 *clients message using the CCLientMessage framework.

 */

/*

 * Int value tests

 */

void CClientMessageTestSession::TestFunction0L()

	{	

	TInt arg0;

	TInt arg1;

	//Validate the first parameter

	iClientMessage->ValidateL(0);

	iClientMessage->ValidateL(1);

	TRAPD(err,iClientMessage->ValidateL(2));

	if(err != KErrArgument)

		{

		User::Leave(KErrGeneral);

		}

	//read the data from the clients message

	arg0 = iClientMessage->GetIntL(0);

	arg1 = iClientMessage->GetIntL(1);

	TRAP(err,iClientMessage->GetIntL(-1));

	if(err != KErrArgument)

		{

		User::Leave(KErrGeneral);

		}

	TRAP(err,iClientMessage->GetIntL(34));

	if(err != KErrArgument)

		{

		User::Leave(KErrGeneral);

		}

	//Just use the variables to remove compiler warnings

	arg0 += arg1;

	}

void CClientMessageTestSession::TestFunction1L()

	{

	TInt arg0;

	const TAny* ptr0;

	arg0 = iClientMessage->GetIntL(0);

	//Trying to read this argument for function 1 should fail as function 1

	//has been defined as having 2 int parameters

	ptr0 = iClientMessage->GetPtrL(1);	

	//Just use the variables to remove compiler warnings

	if(ptr0!= NULL)

		{

		arg0++;

		}

	}

/*

 * Read Only Descriptor tests

 */

void CClientMessageTestSession::TestFunction4L()

	{

	TBuf8<16> des8;

	TBuf<32> des16;

	//Read the data from the clients message

	iClientMessage->ReadL(0,des8);

	iClientMessage->ReadL(1,des16);

	}

void CClientMessageTestSession::TestFunction5L()

	{

	TBuf8<3> des8;

	TBuf<32> des16;

	//This buffer is not large enough to hold the client message

	//which has a defined length of 16.  Attempting to read into this should fail

	iClientMessage->ReadL(0,des8);

	iClientMessage->ReadL(1,des16);

	}

void CClientMessageTestSession::TestFunction6L()

	{

	TBuf8<16> des8;

	TBuf<32> des16;

	//This offset is negative. Attempting to read into this should fail

	iClientMessage->ReadL(0,des8,-1);

	iClientMessage->ReadL(1,des16);

	}

void CClientMessageTestSession::TestFunction7L()

	{

	TBuf8<16> des8;

	TBuf<32> des16;

	//This offset is towards the end of the string - should be ok

	//but only a partial string should be returned

	iClientMessage->ReadL(0,des8,7);

	iClientMessage->ReadL(1,des16);

	}

/*

 * Read\Write Descriptor tests

 */

void CClientMessageTestSession::TestFunction9L()

	{

	_LIT8(KDes8,"CClientMessageTest");

	_LIT(KDes,"CClientMessageTest");

	TInt offSet0;

	TInt offSet1;

	//Read in the offets

	offSet0 = iClientMessage->GetIntL(1);

	offSet1 = iClientMessage->GetIntL(3);

	//Write the data to the clients message at the given offset

	iClientMessage->WriteL(0,KDes8,offSet0);

	iClientMessage->WriteL(2,KDes,offSet1);

	}

void CClientMessageTestSession::TestFunction10L()

	{

	_LIT8(KDes8,"CClientMessageTest. This Descriptor is larger than the maximum allowed descriptor");

	_LIT(KDes,"CClientMessageTest");

	TInt offSet0;

	TInt offSet1;

	offSet0 = iClientMessage->GetIntL(1);

	offSet1 = iClientMessage->GetIntL(3);

	//Thi descriptor is too large and this should fail

	iClientMessage->WriteL(0,KDes8,offSet0);

	iClientMessage->WriteL(2,KDes,offSet1);

	}

void CClientMessageTestSession::TestFunction11L()

	{

	TBuf8<32> des8;

	TBuf<128> des16;

	//This buffer is not large enough to hold the client message

	//which has a defined length of 64.  

	//Attempting to read into this should fail on UDEB

	iClientMessage->ReadL(0,des8);

	iClientMessage->ReadL(2,des16);

	}

void CClientMessageTestSession::TestFunction14L()

	{

	TInt offSet;

	TBuf8<16> des8;

	offSet = iClientMessage->GetIntL(1);

	//Read the data from the clients descriptor using the offset provided

	TInt length = iClientMessage->GetDesLengthL(0);

	//Get a reference to the local copy of the descriptor

	const TDesC8& aDes = iClientMessage->GetDes8L(0);

	//Just do a comparison here to sure the variables and avoid compiler warnings

	if((length == aDes.Length()) && (length <= des8.MaxLength()))

		{

		iClientMessage->ReadL(0,des8,offSet);

		}

	//Write what was read back to the client

	iClientMessage->WriteL(2,des8);

	}

void CClientMessageTestSession::TestFunction15L()

	{

	TInt offSet;

	TBuf<16> des;

	offSet = iClientMessage->GetIntL(1);

	//read from the second descriptor

	TInt length = iClientMessage->GetDesLengthL(2);

	iClientMessage->ReadL(2,des,0);

	//Read the data from the clients descriptor using the offset provided

	length = iClientMessage->GetDesLengthL(0);

	//Get a reference to the local copy of the descriptor

	const TDesC& aDes = iClientMessage->GetDes16L(0);

	//Just do a comparison here to sure the variables and avoid compiler warnings

	if((length == aDes.Length()) && (length <= des.MaxLength()))

		{

		iClientMessage->ReadL(0,des,offSet);

		}

	//Write what was read back to the client

	if( length <= iClientMessage->GetDesMaxLengthL(2))

		{

		iClientMessage->WriteL(2,des);

		}

	}

/*

 * Ptr tests

 */

void CClientMessageTestSession::TestFunction16L()

	{

	const TAny* ptr;

	ptr = iClientMessage->GetPtrL(0);

	//Just use the variables to remove compiler warnings

	if(ptr != NULL)

		{

		ptr = NULL;

		}

	}

void CClientMessageTestSession::TestFunction17L()

	{	

	_LIT8(KDes8,"CClientMessageTest");

	//Ptr variables dont havea  WriteL method so this should panic

	iClientMessage->WriteL(0,KDes8);	

	}

/*

 * Pckg tests

 */

void CClientMessageTestSession::TestFunction18L()

	{	

	CMTestStruct2 struct1;

	TPckg<CMTestStruct2> pData(struct1);

	TInt length = iClientMessage->GetDesLengthL(0);

	iClientMessage->ReadL(0,pData);

	if(length == sizeof(CMTestStruct2))

		{

		struct1.iCount--;

		struct1.iDes = _L("Message Handled");

		length = iClientMessage->GetDesMaxLengthL(0);

		if(length == sizeof(CMTestStruct2))

			{

			iClientMessage->WriteL(0,pData);

			}

		}

	}

void CClientMessageTestSession::TestFunction19L()

	{

	CMTestStruct1 struct1;

	TPckg<CMTestStruct1> pData(struct1);

	iClientMessage->ReadL(0,pData);

	}

void CClientMessageTestSession::TestFunction31L()

	{

	TInt function = iClientMessage->GetIntL(0);

	switch(function)

		{

		case EGetIntL:

			{

			function = iClientMessage->GetIntL(1);

			break;

			}

		case EGetDes8L:

			{

			const TDesC8& data = iClientMessage->GetDes8L(1);

			break;

			}

		case ERead8L:

			{

			TBuf8<16> buf;

			iClientMessage->ReadL(1,buf);

			break;

			}

		case EWrite8L:

			{

			iClientMessage->WriteL(1, _L8(""));

			break;

			}

		case EGetDes16L:

			{

			const TDesC& data = iClientMessage->GetDes16L(1);

			break;

			}

		case ERead16L:

			{

			TBuf<16> buf;

			iClientMessage->ReadL(1,buf);

			break;

			}

		case EWrite16L:

			{

			iClientMessage->WriteL(1, _L(""));

			break;

			}

		case EGetDesLengthL:

			{

			function = iClientMessage->GetDesLengthL(1);

			break;

			}

		case EGetDesMaxLengthL:

			{

			function = iClientMessage->GetDesMaxLengthL(1);

			break;

			}

		}

	}

/* CClientMessageTestServer2 is a lightweight Server that is used to test

 * the CClientMessage framework.  Client side code sends messages to the 

 * server which are processed and the client chceks the expected behaviour.

 * The server code does no testing itself.  The second server is used to 

 * test the ClientMessage Frameworks handling of Tls data.

 */

CServer2* CClientMessageTestServer2::NewLC()

	{

	CClientMessageTestServer2* self = new(ELeave) CClientMessageTestServer2(CActive::EPriorityStandard);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CClientMessageTestServer2::ConstructL()

	{

	StartL(KServer2Name);

	}

TInt CClientMessageTestServer2::RunError(TInt aError)

	{

	Message().Complete(aError);

	ReStart();

	return KErrNone;

	}

CClientMessageTestServer2::CClientMessageTestServer2(TInt aPriority):

		CServer2(aPriority)

	{	

	}

CSession2* CClientMessageTestServer2::NewSessionL(const TVersion& /*aVersion*/, const RMessage2& /*aMessage*/) const

	{

	return new(ELeave)CClientMessageTestSession2;

	}

/* CClientMessageTestSession2 is a lightweight Session class processes

 * messages from the client using the CClientMessage framework 

 */

CClientMessageTestSession2::~CClientMessageTestSession2()

	{

	delete iClientMessage;

	}

void CClientMessageTestSession2::CreateL(const CServer2& /*aServer*/)

	{

	}

void CClientMessageTestSession2::ServiceL(const RMessage2& aMessage)

	{

	TRAPD(err,iClientMessage = BSUL::CClientMessage::NewL(aMessage));

	if(err == BSUL::KErrNotInitialised)

		{

		BSUL::CClientMessage::InitialiseFrameworkL(KServer2Data);

		iClientMessage = BSUL::CClientMessage::NewL(aMessage);

		}

	TRAP(err, DoServiceL());

	iClientMessage->CompleteRequestL(err);

	delete iClientMessage;

	iClientMessage = NULL;

	}

void CClientMessageTestSession2::DoServiceL()

	{

	//Just do this to test the ::Message API

	const RMessage2& message = iClientMessage->Message();

	switch(message.Function())

		{

		case ETestMessage0:

			{

			TRAPD(err,TestFunction0L());

			if(err != BSUL::KErrNotValidated)

				{

				User::Leave(KErrGeneral);

				}

			iClientMessage->ValidateL();

			TestFunction0L();

			break;

			}

		case ETestMessage1:

			{

			TestFunction1L();

			break;

			}

		case ETestMessage2:

			{

			iClientMessage->ValidateL();

			TestFunction2L();

			break;

			}

		default:

			{

			User::Leave(KErrNotFound);

			break;

			}

		}

	}

/*The test function below reads from the clients message

 * using the CCLientMessage framework.

 */

void CClientMessageTestSession2::TestFunction0L()

	{	

	TInt arg0;

	TInt arg1;

	//read the data from the clients message

	arg0 = iClientMessage->GetIntL(0);

	arg1 = iClientMessage->GetIntL(1);

	//Just use the variables to remove compiler warnings

	arg0 += arg1;

	}

/*The test function below reads the int parameter from the message

 * The parameter is validated through a custom validation function

 */

void CClientMessageTestSession2::TestFunction1L()

	{	

	TInt arg0;

	iClientMessage->ValidateL(0);

	//read the data from the clients message

	arg0 = iClientMessage->GetIntL(0);

	arg0++;

	}

/*The test function below reads the descriptor from the clients message

 * The parameter is validated through a custom validation function

 */

void CClientMessageTestSession2::TestFunction2L()

	{	

	TBuf<32> data;

	//read the data from the clients message

	iClientMessage->ReadL(0,data,0);

	}

static void DoRunServer1L()

	{

	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install(scheduler);

	CServer2* server = CClientMessageTestServer::NewLC();

	TInt err = User::RenameThread(KServerName);

	RProcess().Rendezvous(KErrNone);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(server);

	CleanupStack::PopAndDestroy(scheduler);	

	}

static TInt RunServer1(TAny*)

	{

   	CTrapCleanup* cleanup=CTrapCleanup::New();

   	TInt r=KErrNoMemory;

   	if (cleanup)

   		{

 		TRAP(r,DoRunServer1L());

   		delete cleanup;

   		}

   	return r;

	}

static void DoRunServer2L()

	{

	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install(scheduler);

	CServer2* server = CClientMessageTestServer2::NewLC();

	TInt err = User::RenameThread(KServer2Name);

	RProcess().Rendezvous(KErrNone);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(server);

	CleanupStack::PopAndDestroy(scheduler);	

	}

static TInt RunServer2(TAny*)

	{

   	CTrapCleanup* cleanup=CTrapCleanup::New();

   	TInt r=KErrNoMemory;

   	if (cleanup)

   		{

 		TRAP(r,DoRunServer2L());

   		delete cleanup;

   		}

   	return r;

	}

/*Launch 2 servers in seperate threads to allow testing of ClientMessage Frameworks

 * Tls handling

 */

static void RunServersL()

	{

	RThread server1Thread;	

	TInt err = server1Thread.Create(_L("Test Server 1"), &RunServer1, KDefaultStackSize, NULL, NULL);

	if(err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

	RThread server2Thread;	

	err = server2Thread.Create(_L("Test Server 2"), &RunServer2, KDefaultStackSize, NULL, NULL);	

	if(err != KErrAlreadyExists)

		{

		User::LeaveIfError(err);

		}

	server1Thread.Resume();

	TRequestStatus thread1Stat;

	server1Thread.Logon(thread1Stat);

	server2Thread.Resume();

	TRequestStatus thread2Stat;

	server2Thread.Logon(thread2Stat);

	User::WaitForRequest(thread1Stat,thread2Stat);

	if(server1Thread.ExitType() != EExitPending)

		{

		User::Panic(server1Thread.ExitCategory(),server1Thread.ExitReason());

		}

	else

		{

		User::Panic(server2Thread.ExitCategory(),server2Thread.ExitReason());

		}

	}

TInt E32Main()

   //

   // Server process entry-point

   //

   	{

   	CTrapCleanup* cleanup=CTrapCleanup::New();

   	TInt r=KErrNoMemory;

   	if (cleanup)

   		{

 		TRAP(r,RunServersL());

   		delete cleanup;

   		}

   	return r;

   	}