/*

 * Copyright (c) 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:

 *

 */

 /**

 Overview:

 	Test DLL Writeable Static Data support

 API Information:

 Details:

 	- Each process has independent DLL WSD

 	- Whether DLL linked directly or indirectly

 	- Whether DLL loaded dynamically or statically

 	- DLL WSD is consistent under heavy usage by multiple processes

 	- IPC works to/from DLL WSD descriptors & TRequestStatus

 	This source file builds in 4 configurations, with each of

 	direct and indirect linking either used or not used.

 	These configurations are set by 4 MM files, t_dllwsd[d][i].mmp

 	Any of the exe created from the MMP files can be started 

 	to run the tests, it does not matter which is used. 

 	All exe configurations will be used during the tests.

 Platforms/Drives/Compatibility:

 	All.

 Assumptions/Requirement/Pre-requisites:

 Failures and causes:

 Base Port information:

 */

 #define __E32TEST_EXTENSION__

 #include <e32test.h>

 #include <e32svr.h>

 #include <f32dbg.h>

 #include <u32std.h>

 #include "t_dllwsd_dll.h"

 #include "t_dllwsd_dlli.h"

 LOCAL_D RTest test(_L("T_DLLWSD"));

 enum TTestFunc

 	{

 	ETestFuncTestCons=1,

 	ETestFuncThrash1,

 	ETestFuncIpcTest,

 	ETestFuncIpcGet,

 	ETestFuncIpcReverse,

 	ETestFuncIpcSet,

 	ETestFuncPanic,

 	};

 // Test session for IPC use of WSD, talks to the same server as RDllWsd

 class RIpcTestSession : public RSessionBase

 	{

 	public:

 	TInt Connect()

 		{

 		return CreateSession(_L("IpcTestServer"), TVersion());

 		}

 	void Get(TBuf<60000>& buf, TRequestStatus& req)

 		{

 		SendReceive(ETestFuncIpcGet, TIpcArgs(&buf), req);

 		}

 	void Reverse(TRequestStatus& req)

 		{

 		SendReceive(ETestFuncIpcReverse, req);

 		}

 	void Set(const TBuf<60000>& buf, TRequestStatus& req)

 		{

 		SendReceive(ETestFuncIpcSet, TIpcArgs(&buf), req);

 		}

 	};

 #ifdef T_DLLWSD_DIRECT

 void FillBuf(TInt start, TInt inc)

 	{

 	for (int ii=0; ii<WsdBuf().Length(); ii++)

 		{

 		WsdBuf()[ii] = (unsigned short)start;

 		start += inc;

 		}

 	}

 TInt CheckBuf(TInt start, TInt inc)

 	{

 	for (int ii=0; ii<WsdBuf().Length(); ii++)

 		{

 		if (WsdBuf()[ii] != start)

 			return KErrGeneral;

 		start += inc;

 		}

 	return KErrNone;

 	}

 #endif

 class CDllWsdServer : public CServer2

 	{

 public:

 	CDllWsdServer() : CServer2(EPriorityStandard)

 		{

 		}

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

 	mutable TInt iCount;

 	};

 class CDllWsdSession : public CSession2

 	{

 public:

 	CDllWsdSession()

 		{

 		ResetConsistencyCheck();

 		}

 	~CDllWsdSession()

 		{

 		// transient server immediate shutdown when last client disconnects

 		if (--((CDllWsdServer*)Server())->iCount == 0)

 			CActiveScheduler::Stop();

 		}

 	void ResetConsistencyCheck()

 		{

 		iX=42;

 		iY=0;

 		}

 	void OptResetConsistencyCheck()

 		{

 #if !defined(T_DLLWSD_DIRECT) && !defined(T_DLLWSD_INDIRECT)

 		// if DLL has been unloaded (dynamic library closed, no static link)

 		// WSD will be reset

 		ResetConsistencyCheck();

 #endif

 		}

 	TInt TestConsistency()

 		{

 #ifdef T_DLLWSD_DIRECT

 		// static direct

 		if (WsdFuncX() != iX++)

 			return KErrGeneral;

 		if (WsdFuncY() != iY++)

 			return KErrGeneral;

 #endif

 #ifdef T_DLLWSD_INDIRECT

 		// static indirect

 		if (IndWsdFuncX() != iX++)

 			return KErrGeneral;

 		if (IndWsdFuncY() != iY++)

 			return KErrGeneral;

 #endif

 		// dynamic direct

 		OptResetConsistencyCheck();

 		RLibrary lib;

 		TInt err = lib.Load(_L("t_dllwsd_dll"));

 		if (err) return err;

 		if ((*lib.Lookup(1))/*WsdFuncX*/() != iX++)

 			return KErrGeneral;

 		if ((*lib.Lookup(2))/*WsdFuncX*/() != iY++)

 			return KErrGeneral;

 		lib.Close();

 		// dynamic indirect

 		OptResetConsistencyCheck();

 		err = lib.Load(_L("t_dllwsd_dlli"));

 		if (err) return err;

 		if ((*lib.Lookup(1))/*IndWsdFuncX*/() != iX++)

 			return KErrGeneral;

 		if ((*lib.Lookup(2))/*IndWsdFuncX*/() != iY++)

 			return KErrGeneral;

 		lib.Close();

 		return KErrNone;

 		}

 	TInt Thrash1()

 		{

 		TTime start;

 		start.HomeTime();

 		TInt count = 0;

 		const TTimeIntervalMicroSeconds limit(10000000); // 10 seconds

 		for (;; count++)

 			{

 			TInt err = TestConsistency();

 			if (err) return err;

 			TTime now;

 			now.HomeTime();

 			if (now.MicroSecondsFrom(start) > limit)

 				break;

 			}

 		return count > 0 ? count : -count;

 		}

 	TInt IpcTest()

 		{

 #ifdef T_DLLWSD_DIRECT

     	RIpcTestSession s;

     	TInt err = s.Connect();

     	if (!err) return err;

         WsdBuf().SetLength(WsdBuf().MaxLength());

     	for (int i=0; i<10; i++)

     		{

     		// 0..n -> buf

 	        FillBuf(0,1);

 	        err = CheckBuf(0,1);

 	    	if (!err) return err;

 	        // buf -> server

 	        s.Set(WsdBuf(), WsdReq());

 	        err = CheckBuf(0,1);

 	    	if (!err) return err;

 	    	// use TReqestStatus in WSD

 	        User::WaitForRequest(WsdReq());

 	        if (!WsdReq().Int()) return WsdReq().Int();

 	        // 0..0 -> buf

 	        FillBuf(0,0);

 	        err = CheckBuf(0,0);

 	    	if (!err) return err;

 	        WsdReq() = KRequestPending;

 			// reverse buf on server

 	        s.Reverse(WsdReq());

 			// local buf is still 0..0

 	        err = CheckBuf(0,0);

 	    	if (!err) return err;

 	    	// use TReqestStatus in WSD

 	        User::WaitForRequest(WsdReq());

 	        if (!WsdReq().Int()) return WsdReq().Int();

 			// local buf is still 0..0

 	        err = CheckBuf(0,0);

 	    	if (!err) return err;

 	        // get buf from server

 	        s.Get(WsdBuf(), WsdReq());

 	        User::WaitForRequest(WsdReq());

 	        // buf is n..0

 	        err = CheckBuf(59999,-1);

 	    	if (!err) return err;

     		}

     	s.Close();

 		return KErrNone;

 #else

 		return KErrNotSupported;

 #endif

 		}

 	void ServiceL(const RMessage2& aMessage)

 		{

 #ifdef T_DLLWSD_DIRECT

 		TInt ii=0;

 #endif

 		switch (aMessage.Function())

 			{

 			case ETestFuncTestCons:

 				aMessage.Complete(TestConsistency());

 				break;

 			case ETestFuncThrash1:

 				aMessage.Complete(Thrash1());

 				break;

 			case ETestFuncIpcTest:

 				aMessage.Complete(IpcTest());

 				break;

 			case ETestFuncIpcGet:

 #ifdef T_DLLWSD_DIRECT

 				aMessage.WriteL(0, WsdBuf());

 				aMessage.Complete(KErrNone);

 #else

 				aMessage.Complete(KErrNotSupported);

 #endif

 				break;

 			case ETestFuncIpcReverse:

 #ifdef T_DLLWSD_DIRECT

 				for (ii=0; ii<WsdBuf().Length()/2; ii++)

 					{

 					TInt o = WsdBuf().Length() - 1 - ii;

 					TInt t = WsdBuf()[ii];

 					WsdBuf()[ii] = WsdBuf()[o];

 					WsdBuf()[o] = (unsigned short)t;

 					}

 				aMessage.Complete(KErrNone);

 #else

 				aMessage.Complete(KErrNotSupported);

 #endif

 				break;

 			case ETestFuncIpcSet:

 #ifdef T_DLLWSD_DIRECT

 				aMessage.ReadL(0, WsdBuf());

 				aMessage.Complete(KErrNone);

 #else

 				aMessage.Complete(KErrNotSupported);

 #endif

 				break;

 			case ETestFuncPanic:

 				User::Panic(_L("As requested..."), 0);

 				break;

 			default:

 				aMessage.Panic(_L("Unrecognised"), aMessage.Function());

 				break;

 			}

 		}

 	int iX;

 	int iY;

 	};

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

 	{

 	iCount++;

 	return new(ELeave) CDllWsdSession;

 	}

 TInt SlaveMain()

 	{

 	TName name;

 	User::CommandLine(name);

 	CTrapCleanup* cleanup = CTrapCleanup::New();

 	if (!cleanup)

 		return KErrNoMemory;

 	TRAPD(err, 

 		{

 		CActiveScheduler* sched=new(ELeave) CActiveScheduler;

 		CActiveScheduler::Install(sched);

 		CDllWsdServer* server = new(ELeave) CDllWsdServer;

 		server->StartL(name);

 		RProcess::Rendezvous(KErrNone);

 		CActiveScheduler::Start();

 		delete server;

 		delete sched;

 		});

 	delete cleanup;

 	return err;

 	}

 //

 // Master test controller

 //

 class RDllWsd : public RSessionBase

 	{

 public:

 	RDllWsd(const TDesC& aServerName, const TDesC& aExeName = _L("t_dllwsddi"))

 		{

 		test.Start(_L("RDllWsd create"));

 		RProcess proc;

 		test_KErrNone(proc.Create(aExeName, aServerName));

 		TRequestStatus req;

 		proc.Rendezvous(req);

 		proc.Resume();

 		User::WaitForRequest(req);

 		test_KErrNone(req.Int());

 		test_KErrNone(CreateSession(aServerName, TVersion()));

 		proc.Close();

 		test.End();

 		}

 	TInt ConsistencyTest()

 		{

 		return SendReceive(ETestFuncTestCons);

 		}

 	void ThrashTest1(TRequestStatus& aStatus)

 		{

 		SendReceive(ETestFuncThrash1, aStatus);

 		}

 	TInt IpcTest()

 		{

 		return SendReceive(ETestFuncIpcTest);

 		}

 	TInt Panic()

 		{

 		return SendReceive(ETestFuncPanic);

 		}

 	};

 void BasicTest()

 	{

 	test.Start(_L("BasicConsistency"));

 	// create a test server/process for each link variant

 	RDllWsd slaves[] =

 		{

 		RDllWsd(_L("slave1"), _L("t_dllwsd")),

 		RDllWsd(_L("slave2"), _L("t_dllwsdd")),

 		RDllWsd(_L("slave3"), _L("t_dllwsdi")),

 		RDllWsd(_L("slave4"), _L("t_dllwsddi")),

 		RDllWsd(_L("slave5"), _L("t_dllwsd")),

 		RDllWsd(_L("slave6"), _L("t_dllwsdd")),

 		RDllWsd(_L("slave7"), _L("t_dllwsdi")),

 		RDllWsd(_L("slave8"), _L("t_dllwsddi"))

 		};

 	TInt nSlaves = sizeof(slaves)/sizeof(slaves[0]);

 	TInt ii;

 	// do this a few times

 	for (TInt jj=0; jj<10; jj++)

 		{

 		// all four test variants

 		for (ii=0; ii<nSlaves; ii++)

 			{

 			// repeat the test different numbers of times, to ensure WSD values diverge

 			for (TInt kk=0; kk<ii+2; kk++)

 				{

 				// change order in which processes run the tests

 				int idx = (ii + jj) % nSlaves;

 				test_KErrNone(slaves[idx].ConsistencyTest());

 				}

 			}

 		// start and stop an extra process

 		RDllWsd extra(_L("slave9"), _L("t_dllwsddi"));

 		test_KErrNone(extra.ConsistencyTest());

 		extra.Close();

 		}

 	for (ii=nSlaves-1; ii>=0; ii--)

 		slaves[ii].Close();

 	test.End();

 	}

 void ThrashTest1()

 	{

 	test.Start(_L("ThrashTest1"));

 	// create a test server/process for each link variant

 	RDllWsd slaves[4] =

 		{

 		RDllWsd(_L("slaveA"), _L("t_dllwsd")),

 		RDllWsd(_L("slaveB"), _L("t_dllwsdd")),

 		RDllWsd(_L("slaveC"), _L("t_dllwsdi")),

 		RDllWsd(_L("slaveD"), _L("t_dllwsddi"))

 		};

 	TRequestStatus req[4];

 	TInt ii;

 	// start the thrash tests

 	for (ii=0; ii<4; ii++)

 		{

 		slaves[ii].ThrashTest1(req[ii]);

 		test.Printf(_L("slave %d thrash started\n"), ii);

 		}

 	// show some progress to indicate that things are running		

 	for (ii=0; ii<8; ii++)

 		{

 		test.Printf(_L("Waiting %d\n"), ii);

 		User::After(1000000);

 		}

 	// demonstrate that test processes are still doing their stuff

 	test.Printf(_L("Still a couple of seconds to wait...\n"));

 	// wait till the test process are done

 	for (ii=0; ii<4; ii++)

 		{

 		User::WaitForRequest(req[ii]);

 		// show how much each process did

 		test.Printf(_L("Slave %d count = %d\n"), ii, req[ii].Int());

 		test_NotNegative(req[ii].Int());

 		}

 	for (ii=3; ii>=0; ii--)

 		slaves[ii].Close();

 	test.End();

 	}

 void PanicTest()

 	{

 	test.Start(_L("PanicTest1"));

 	// create a test server/process for each link variant

 	RDllWsd slaves[4] =

 		{

 		RDllWsd(_L("slaveP1"), _L("t_dllwsd")),

 		RDllWsd(_L("slaveP2"), _L("t_dllwsdd")),

 		RDllWsd(_L("slaveP3"), _L("t_dllwsdi")),

 		RDllWsd(_L("slaveP4"), _L("t_dllwsddi"))

 		};

 	TInt ii;

 	for (ii=0; ii<4; ii++)

 		slaves[ii].Panic();

 	for (ii=0; ii<4; ii++)

 		slaves[ii].Close();

 	}

 void IpcTest()

 	{

 	test.Start(_L("IPC test"));

 	// these two processes will use t_dllwsddi, static link variant

 	RDllWsd server(_L("IpcTestServer"));

 	RDllWsd client(_L("IpcTestClient"));

 	// client will talk to IpcTestServer, ie the server

 	test_KErrNone(client.IpcTest());

 	client.Close();

 	server.Close();

 	test.End();

 	}

 TInt MasterMain()

 	{

 	test.Title();

 	test.Start(_L("Test"));

 	BasicTest();

 	ThrashTest1();

 	IpcTest();

 //	PanicTest();

 	test.End();

 	return KErrNone;

 	}

 TInt E32Main()

 	{

 	if (User::CommandLineLength() > 0)	// command line contains server name

 		return SlaveMain();

 	else

 		return MasterMain();

 	}