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

    	}