// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 #include <e32test.h>

 #include "bm_suite.h"

 class RIpcSession : public RSessionBase

 	{

 public:

 	TInt CreateSession(TDesC& aName, TVersion aVer, TInt aSlots)

 		{

 		return RSessionBase::CreateSession(aName, aVer, aSlots);

 		}

 	void SendReceive(TInt aService, TIpcArgs& args, TRequestStatus& aStatus)

 		{

 		RSessionBase::SendReceive(aService, args, aStatus);

 		}

 	TInt SendReceive(TInt aService, TIpcArgs& args)

 		{

 		return RSessionBase::SendReceive(aService, args);

 		}

 	};

 class CIpcScheduler : public CActiveScheduler

 	{

 public:

 	CIpcScheduler()

 		{

 		CActiveScheduler::Install(this);

 		}

 	};

 class CIpcServer : public CServer2

 	{

 public:

 	enum TService 

 		{

 		ERunTest,

 		EGetTimes,

 		EStop

 		};

 	struct TServerTimes

 		{

 		TBMTicks iNewSessionEntryTime;

 		TBMTicks iNewSessionLeaveTime;

 		TBMTicks iServiceLTime;

 		};

 	CIpcServer() : CServer2(0)

 		{

 		}

 	virtual CSession2* NewSessionL(const TVersion& aVer, const RMessage2&) const;

 	TServerTimes	iTimes;

 	static TInt Entry(TAny* ptr);

 	};

 class CIpcSession : public CSession2

 	{

 public:

 	CIpcSession(CIpcServer* aServer)

 		{

 		iServer = aServer;

 		}

 	virtual void ServiceL(const RMessage2& aMessage);

 	CIpcServer*	iServer;

 	};

 class SpawnArgs : public TBMSpawnArgs

 	{

 public:

 	TBuf<16>	iServerName;

 	TVersion	iVersion;

 	RSemaphore	iSem;

 	TInt		iIterationCount;

 	SpawnArgs(const TPtrC& aServerName, TInt aPrio, TInt aRemote, TInt aIter);

 	void Close();

 	void ServerOpen();

 	void ServerClose();

 	};

 SpawnArgs::SpawnArgs(const TPtrC& aServerName, TInt aPrio, TInt aRemote, TInt aIter) :

 	TBMSpawnArgs(CIpcServer::Entry, aPrio, aRemote, sizeof(*this)),

 		iServerName(aServerName),

 		iVersion(1,0,1), 

 		iIterationCount(aIter)

 	{

 	TInt r;

 	if (aRemote)

 		{

 		r = iSem.CreateGlobal(_L("Semaphore"), 0);

 		BM_ERROR(r, r == KErrNone);

 		}

 	else

 		{

 		r = iSem.CreateLocal(0);

 		BM_ERROR(r, r == KErrNone);

 		}

 	}

 void SpawnArgs::ServerOpen()

 	{

 	if (iRemote)

 		{

 		iSem.Duplicate(iParent);

 		}

 	}

 void SpawnArgs::ServerClose()

 	{

 	if (iRemote)

 		{

 		iSem.Close();

 		}

 	}

 void SpawnArgs::Close()

 	{

 	iSem.Close();

 	}

 void CIpcSession::ServiceL(const RMessage2& aMessage)

 	{

 	CIpcServer::TService f = (CIpcServer::TService) aMessage.Function();

 	switch (f) 

 		{

 	case CIpcServer::ERunTest:

 		::bmTimer.Stamp(&iServer->iTimes.iServiceLTime);

 		break;

 	case CIpcServer::EGetTimes:

 		aMessage.WriteL(0, TPtrC8((TUint8*) &iServer->iTimes, sizeof(iServer->iTimes)));

 		break;

 	case CIpcServer::EStop:

 		CActiveScheduler::Stop();

 		break;

 	default:

 		BM_ASSERT(0);

 		}

 	aMessage.Complete(KErrNone);

 	}

 CSession2* CIpcServer::NewSessionL(const TVersion&, const RMessage2&) const

 	{

 	CIpcServer* srv = (CIpcServer*) this;

 	::bmTimer.Stamp(&srv->iTimes.iNewSessionEntryTime);

 	CSession2* s  = new CIpcSession(srv);

 	BM_ERROR(KErrNoMemory, s);

 	::bmTimer.Stamp(&srv->iTimes.iNewSessionLeaveTime);

 	return s;

 	}

 TInt CIpcServer::Entry(TAny* ptr)

 	{

 	SpawnArgs* sa = (SpawnArgs*) ptr;

 	sa->ServerOpen();

 	CIpcScheduler* sched = new CIpcScheduler();

 	BM_ERROR(KErrNoMemory, sched);

 	CIpcServer* srv = new CIpcServer();

 	BM_ERROR(KErrNoMemory, srv);

 	TInt r = srv->Start(sa->iServerName);

 	BM_ERROR(r, r == KErrNone);

 		// signal to the parent the end of the server intialization

 	sa->iSem.Signal();

 	sched->Start();

 	delete srv;

 	delete sched;

 	sa->ServerClose();

 	return KErrNone;

 }

 static const TInt KMaxIpcLatencyResults = 5;

 class IpcLatency : public BMProgram

 	{

 public :

 	TBool		iRemote;

 	TInt		iPriority;

 	TBMResult	iResults[KMaxIpcLatencyResults];

 	IpcLatency(TBool aRemote, TInt aPriority) : 

 		BMProgram(

 			aRemote 

 				? ((aPriority == KBMPriorityHigh) 

 					? _L("Client-server Framework[Remote High Prioirty Server]")

 					: _L("Client-server Framework[Remote Low Prioirty Server]"))

 				: ((aPriority == KBMPriorityHigh) 

 					? _L("Client-server Framework[Local High Prioirty Server]")

 					: _L("Client-server Framework[Local Low Prioirty Server]")))

 		{

 		iPriority = aPriority;

 		iRemote = aRemote;

 		}

 	virtual TBMResult* Run(TBMUInt64 aIter, TInt* aCount);

 	};

 TBMResult* IpcLatency::Run(TBMUInt64 aIter, TInt* aCount)

 	{

 	SpawnArgs sa(_L("BMServer"), iPriority, iRemote, (TInt) aIter);

 		// spawn the server

 	MBMChild* child = SpawnChild(&sa);

 	TInt n = 0;

 	iResults[n++].Reset(_L("Connection Request Latency"));

 	iResults[n++].Reset(_L("Connection Reply Latency"));

 	iResults[n++].Reset(_L("Request Latency"));

 	iResults[n++].Reset(_L("Request Response Time"));

 	iResults[n++].Reset(_L("Reply Latency"));

 	BM_ASSERT(KMaxIpcLatencyResults >= n);

 		// wait for the srever intialization

 	sa.iSem.Wait();

 		// wait 2ms (ie more than one tick) to allow the server to complete its ActiveScheduler intialization ...

 	User::After(2000);

 	RIpcSession s;

 	for (TBMUInt64 i = 0; i < aIter; ++i)

 		{	

 		TBMTicks t1;

 		::bmTimer.Stamp(&t1);

 		TInt r = s.CreateSession(sa.iServerName, sa.iVersion, 1);

 		BM_ERROR(r, r == KErrNone);

 		TBMTicks t2;

 		::bmTimer.Stamp(&t2);

 		TRequestStatus st;

 		TBMTicks t3;

 		::bmTimer.Stamp(&t3);

 			{

 			TIpcArgs args;

 			s.SendReceive(CIpcServer::ERunTest, args, st);

 			}

 		TBMTicks t4;

 		::bmTimer.Stamp(&t4);

 		User::WaitForRequest(st);

 		BM_ERROR(r, st == KErrNone);

 		TBMTicks t5;

 		::bmTimer.Stamp(&t5);

 		CIpcServer::TServerTimes serverTimes;

 		TPtr8 serverTimesDes((TUint8*) &serverTimes, sizeof(serverTimes), sizeof(serverTimes));

 			{

 			TIpcArgs args(&serverTimesDes);

 			r = s.SendReceive(CIpcServer::EGetTimes, args);

 			BM_ERROR(r, r == KErrNone);

 			}

 		s.Close();	

 		n = 0;

 		iResults[n++].Cumulate(TBMTicksDelta(t1, serverTimes.iNewSessionEntryTime));

 		iResults[n++].Cumulate(TBMTicksDelta(serverTimes.iNewSessionLeaveTime, t2));

 		iResults[n++].Cumulate(TBMTicksDelta(t3, serverTimes.iServiceLTime));

 		iResults[n++].Cumulate(TBMTicksDelta(t3, t4));

 		iResults[n++].Cumulate(TBMTicksDelta(serverTimes.iServiceLTime, t5));

 		BM_ASSERT(KMaxIpcLatencyResults >= n);	

 			// wait 2ms (ie more than one tick) to allow the server to complete.

 		User::After(2000);

 		}

 	TInt r = s.CreateSession(sa.iServerName, sa.iVersion, 1);

 	BM_ERROR(r, r == KErrNone);

 		{

 		TIpcArgs args;

 		s.SendReceive(CIpcServer::EStop, args);

 		}

 	s.Close();

 	child->WaitChildExit();

 	sa.Close();

 	for (TInt j = 0; j < KMaxIpcLatencyResults; ++j)

 		{

 		iResults[j].Update();

 		}

 	*aCount = KMaxIpcLatencyResults;

 	return iResults;

 	}

 IpcLatency test1(EFalse,KBMPriorityHigh);

 IpcLatency test2(EFalse,KBMPriorityLow );

 IpcLatency test3(ETrue, KBMPriorityHigh);

 IpcLatency test4(ETrue, KBMPriorityLow );

 void AddIpc()

 	{

 	BMProgram* next = bmSuite;

 	bmSuite=(BMProgram*)&test4;

 	bmSuite->Next()=next;

 	bmSuite=(BMProgram*)&test3;

 	bmSuite->Next()=&test4;

 	bmSuite=(BMProgram*)&test2;

 	bmSuite->Next()=&test3;

 	bmSuite=(BMProgram*)&test1;

 	bmSuite->Next()=&test2;

 	}