/*

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

 * Exercises the test implementation of the session count server,

 * to test the base SCS functionality.

 *

 */

 /**

  @file

 */

 #include <e32ldr.h>

 #include <e32ldr_private.h>

 #include <f32file.h>

 #include "rtestwrapper.h"

 #include <e32def_private.h>

 #include <scs/scscommon.h>

 #include "scstestcommon.h"

 #include "scstestclient.h"

 const TInt KOneSecondUs = 1000 * 1000;		///< One second in microseconds.

 /** Top-level test object renders stages and confirms conditions. */

 static RTestWrapper test(_L("SCSTEST"));

 /**

 	This session handle is defined at the file level so each individual test

 	does not have to connect to the server.

  */

 static RScsTestSession sTestSession;

 /**

 	This subsession handle is defined at the file level so each individual test

 	does not have to connect to the server and create a subssesion.

  */

 static RScsTestSubsession sTestSubsession;

 /** Arbitrary integer value used to construct subsession. */

 static const TInt KSubsessValue = 10;

 static void LetServerRun()

 /**

 	Sleep for 100ms so the server thread can run to clean up,

 	terminate, or just process the last request which it was sent.

  */

 	{

 	User::After(100 * 1000);

 	}

 // -------- OOM testing --------

 static void RunOomTest(TInt (*aAllocFunc)(), void (*aFreeFunc)())

 /**

 	Run the supplied allocator function while forcing OOM on the server side.

 	On failure, this functions tests that the server heap is balanced.  On

 	success, it runs the free function and also tests that the server heap is

 	balanced.

 	@param	aAllocFunc		Function which allocates resources on the server heap.

 	@param	aFreeFunc		Frees the resources allocated with aAllocFunc.  It should

 							only be necessary to call this function if aAllocFunc

 							succeeds.  This argument can be NULL if there is no

 							corresponding free function.

  */

 	{

 	TInt r = KErrNoMemory;

 	for (TInt i = 1; r == KErrNoMemory; ++i)

 		{

 		sTestSession.SetServerHeapFail(i);

 		r = aAllocFunc();

 		test(r == KErrNone || r == KErrNoMemory);

 		if (r == KErrNone && aFreeFunc != NULL)	

 			aFreeFunc();

 		sTestSession.ResetServerHeapFail();

 		}

 	}

 // -------- panic testing --------

 /**

 	To test that a client is panicked, pass a function with this

 	signature to TestPanic.  It will be called from a new thread.

 	@see TestPanic

  */

 typedef void (*TPanicFunc)(RScsTestSession&);

 static void ConfirmPanicReason(RThread aThread, TInt aExpectedReason)

 /**

 	Test the supplied thread was panicked with category

 	ScsImpl::KScsClientPanicCat and the supplied reason.

 	@param	aThread			Panicked thread.

 	@param	aExpectedReason	The thread should have been panicked with

 							this reason.

 	@see ScsImpl::KScsClientPanicCat

  */

 	{

 	TExitType exitType = aThread.ExitType();

 	TExitCategoryName exitCat = aThread.ExitCategory();

 	TInt exitReason = aThread.ExitReason();

 	test(exitType == EExitPanic);

 	test(exitCat == ScsImpl::KScsClientPanicCat);

 	test(exitReason == aExpectedReason);

 	}

 static TInt TestPanicEntrypoint(TAny* aPtr)

 /**

 	This entrypoint is called by the panic thread.  The

 	function connects to the SCS test server and passes

 	the handle to the function that should be panicked.

 	@param	aPtr			Standard entrypoint argument.  This is actually

 							a pointer to the function to call with the connected

 							session.

 	@return					KErrNone.  Required to satisfy entrypoint signature.

  */

 	{

 	RScsTestSession s;

 	TInt r = s.Connect();

 	test(r == KErrNone);

 	TPanicFunc f = TAnyPtrToFuncPtr<TPanicFunc>(aPtr);

 	f(s);

 	test(EFalse);			// should not reach here

 	return KErrNone;

 	}

 static void TestPanic(TPanicFunc aFunc, TInt aExpectedReason)

 /**

 	Create a thread which should be panicked because it will

 	pass invalid data to the SCS test server.  Test the thread

 	is panicked with the expected category and reason.

 	@param	aFunc			Function to call from panic thread.

 	@param	aExpectedReason	Reason with which the thread should

 							be panicked.

  */

 	{

 	RThread thd;

 	TInt r = thd.Create(

 		_L("ScsTestPanic"), TestPanicEntrypoint,

 		KDefaultStackSize, KMinHeapSize, KMinHeapSize, (TAny*) aFunc);

 	test(r == KErrNone);

 	TRequestStatus rs;

 	thd.Rendezvous(rs);

 	test(rs == KRequestPending);

 	TBool jit = User::JustInTime();

 	User::SetJustInTime(EFalse);

 	thd.Resume();

 	User::WaitForRequest(rs);

 	User::SetJustInTime(jit);

 	ConfirmPanicReason(thd, aExpectedReason);

 	thd.Close();

 	}

 // -------- open / close --------

 /** Handle to a session which the test code attempts to open in server-side OOM. */

 RScsTestSession sOomTestSession;

 static TInt OpenOomSession()

 /**

 	This function is invoked by RunOomTest.  It just

 	attempts to connect to the SCS test server.

 	@return					Return code from RScsTestSession::Connect.

 	@see CloseOomSession

  */

 	{

 	return sOomTestSession.Connect();

 	}

 static void CloseOomSession()

 /**

 	Closes the session which was opened by OpenOomSession.

 	@see OpenOomSession

 	@pre OpenOomSession was successfully opened by OpenOomSession.

  */

 	{

 	sOomTestSession.Close();

 	}

 static void TestServerDeath()

 	{

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

 	test.Next(_L("Starting server without shutdown timer"));

 	// Create marker file to get server to run without a activity timeout

 	RFs fs;

 	TInt r = fs.Connect();

 	test(r == KErrNone);

 	(void) fs.Delete(KDisableScsTestServerTimeout());

 	RFile file;

 	r = file.Create(fs, KDisableScsTestServerTimeout(), EFileShareAny|EFileWrite);

 	test(r == KErrNone);

 	file.Close();

 	// Start server

 	RScsTestSession scsts;

 	r = scsts.Connect();

 	test(r == KErrNone);

 	test.Next(_L("Checking ShutdownServer is not allowed"));

 	r = scsts.ShutdownServer();

 	test(r == KErrNotSupported);

 	test.Next(_L("Doing an async call to check server does not attempt to restart the timer and crash"));

 	TPckgBuf<TInt> x1 = 1;

 	TRequestStatus rs1;

 	scsts.Treble(x1, rs1);

 	User::WaitForRequest(rs1);

 	test.Printf(_L("NukeServer - scstestserver.exe SHOULD panic\n"));

 	r = scsts.NukeServer();

 	test(r == KErrServerTerminated);

 	(void) fs.Delete(KDisableScsTestServerTimeout());

 	fs.Close();

 	scsts.Close();

 	test.End();

 	}

 static void TestOpenClose()

 /**

 	Attempt to connect to the server when supplying default,

 	lower, and higher version numbers.  Attempt to open a session

 	in server-side OOM.

  */

 	{

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

 	TInt r;

 	RScsTestSession scsts;

 	// default version

 	r = scsts.Connect();

 	test(r == KErrNone);

 	scsts.Close();

 	// lower-than-supported version

 	TVersion v = ScsTestImpl::Version();

 	--v.iMajor;

 	r = scsts.Connect(v);

 	test(r == KErrNone);

 	scsts.Close();

 	// supported version (should be same as default)

 	++v.iMajor;

 	r = scsts.Connect(v);

 	test(r == KErrNone);

 	scsts.Close();

 	// greater-than-supported version

 	++v.iMajor;

 	r = scsts.Connect(v);

 	test(r == KErrNotSupported);

 	// test opening session when server running out of memory

 	r = sTestSession.Connect();		// required to send OOM commands

 	test(r == KErrNone);

 	RunOomTest(OpenOomSession, CloseOomSession);

 	sTestSession.Close();

 #if 0

 	// Test closing server with an out standing request

 	r = scsts.Connect();

 	test(r == KErrNone);

 	test(r == KErrNone);

 	TPckgBuf<TInt> x1 = 1;

 	TRequestStatus rs1;

 	scsts.Treble(x1, rs1);

 	// Bypass the presession close

 	RSessionBase *session = &scsts;

 	session->Close();

 	User::WaitForRequest(rs1);

 	test(rs1 == KErrCancel);

 #endif

 	test.End();

 	}

 // -------- invalid session function --------

 static void TestInvalidSessionFunction()

 /**

 	Send an unrecognized SCS code and confirm that it is

 	rejected with KErrNotSupported.  This tests the SCS

 	implementation.

 	Send an unrecognized function identifier to the session

 	and confirm that it is also rejected with KErrNotSupported.

 	This tests the test server session implementation.

  */

 	{

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

 	TInt r;

 	r = sTestSession.SendCustomFunction(ScsImpl::EScsUnused);

 	test(r == KErrNotSupported);

 	r = sTestSession.SendCustomFunction(ScsImpl::ECallSessionFunc | ScsTestImpl::ESessUnused);

 	test(r == KErrNotSupported);

 	test.End();

 	}

 // -------- synchronous session function --------

 static void TestSyncSessionFunction()

 /**

 	Send a recognized function to the SCS test session,

 	and confirm that it is executed correctly.

  */

 	{

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

 	TInt x = 3;

 	TInt r = sTestSession.Double(x);

 	test(r == KErrNone);

 	test(x == 6);

 	test.End();

 	}

 // -------- asynchronous session function --------

 static TInt LaunchSessionTrebleOom()

 /**

 	Attempt to launch an asynchronous command on a session

 	under OOM conditions.

  */

 	{

 	TPckgBuf<TInt> x = 3;

 	TRequestStatus rs;

 	sTestSession.Treble(x, rs);

 	User::WaitForRequest(rs);

 	if (rs == KErrNone)

 		{

 		test(x() == 9);

 		}

 	return rs.Int();

 	}

 static void TestAsyncInvalidDescPanic(RScsTestSession& aSession)

 /**

 	Pass an invalid descriptor to the SCS test server.

 	The current thread should be panicked.

 	@param	aSession		Open session to SCS test server,

 							supplied by TestPanic.

 	@see TestPanic

  */

 	{

 	TDes8* nullDes8 = 0;

 	TRequestStatus rs;

 	aSession.Treble(*nullDes8, rs);

 	User::WaitForRequest(rs);

 	}

 static void TestRequeueOutstandingPanic(RScsTestSession& aSession)

 /**

 	Attempt to requeue an asynchronous request which is still

 	outstanding.  The current thread should be panicked.

 	@param	aSession		Connected session to SCS test server.

 	@see TestPanic

  */

 	{

 	TPckgBuf<TInt> x1 = 1;

 	TRequestStatus rs1;

 	aSession.Treble(x1, rs1);

 	TPckgBuf<TInt> x2 = 2;

 	TRequestStatus rs2;

 	aSession.Treble(x2, rs2);

 	User::WaitForRequest(rs1, rs2);

 	User::WaitForRequest(rs1, rs2);

 	}

 static void TestAsyncSessionFunction()

 /**

 	Test asynchronous session-relative functions.

 	Launch a request and wait for it to complete.

 	Launch a request and cancel it.

 	Launch a request with an invalid descriptor.

 	Cancel a request which is not outstanding.

 	Launch a request in OOM.

 	Launch an asynchronous request on a session and wait

 	for it to complete.

  */

 	{

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

 	TInt r;

 	LaunchSessionTrebleOom();

 	// test launching async request in OOM

 	RunOomTest(LaunchSessionTrebleOom, NULL);

 	// cancel async request

 	TPckgBuf<TInt> x = 3;

 	TRequestStatus rs;

 	sTestSession.Treble(x, rs);

 	sTestSession.CancelTreble();

 	User::WaitForRequest(rs);

 	test(rs == KErrCancel);

 	// bad descriptor panic

 	TestPanic(TestAsyncInvalidDescPanic, ScsImpl::EScsClBadDesc);

 	// safely cancel async request which is not queued

 	sTestSession.CancelTreble();

 	// panic if requeue outstanding request

 	TestPanic(TestRequeueOutstandingPanic, ScsImpl::EScsClAsyncAlreadyQueued);

 	// test outstanding request cancelled when session closed with RScsSessionBase::Close

 	RScsTestSession asyncSession;

 	r = asyncSession.Connect();

 	test(r == KErrNone);

 	x() = 4;

 	asyncSession.Treble(x, rs);

 	asyncSession.Close();

 	User::After(ScsTestImpl::KTrebleTimerDelayUs + KOneSecondUs);

 	test(rs == KErrCancel);

 	User::WaitForRequest(rs);

 	// test outstanding request not cancelled when session closed with RSessionBase::Close

 	r = asyncSession.Connect();

 	test(r == KErrNone);

 	x() = 4;

 	asyncSession.Treble(x, rs);

 	asyncSession.RSessionBase::Close();

 	User::After(ScsTestImpl::KTrebleTimerDelayUs + KOneSecondUs);

 	test(rs == KRequestPending);		// client request not cancelled or completed

 	test.End();

 	}

 // -------- open / close subsession --------

 /**

 	This subsession handle is opened in OOM testing.

 	@see OpenOomSubsession

 	@see CloseOomSubsession

  */

 RScsTestSubsession sOomSubsession;

 static TInt OpenOomSubsession()

 /**

 	Attempt to open a subsession in OOM.

 	@see CloseOomSubsession

 	@see RunOomTest

  */

 	{

 	return sOomSubsession.Create(sTestSession, 10);

 	}

 static void CloseOomSubsession()

 /**

 	Free the subsession which was opened in OOM.

 	@see OpenOomSubsession

 	@see RunOomTest

  */

 	{

 	sOomSubsession.Close();

 	}

 static void TestOpenCloseSubsession()

 /**

 	Test opening and closing a subsession, including

 	opening in OOM.

  */

 	{

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

 	TInt r;

 	RScsTestSubsession ss;

 	r = ss.Create(sTestSession, 10);

 	test(r == KErrNone);

 	ss.Close();

 	// test creating in OOM

 	RunOomTest(OpenOomSubsession, CloseOomSubsession);

 	test.End();

 	}

 // -------- invalid subsession function --------

 static void TestInvalidSubsessionFunction()

 /**

 	Pass an unrecognized function to a subession and test

 	the subsession handles it properly.  This tests the SCS

 	test implementation, rather than the SCS itself.

  */

 	{

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

 	TInt r = sTestSubsession.SendFunction(ScsTestImpl::ESubsessUnused);	

 	test(r == KErrNotSupported);

 	test.End();

 	}

 // -------- synchronous subsession function --------

 static void TestBadHandlePanic(RScsTestSession& aSession)

 /**

 	Call a subsession function passing in an invalid handle.

 	The current thread should be panicked.

 	@param	aSession		Open session to SCS test server,

 							supplied by TestPanic.

 	@see TestPanic

  */

 	{

 	RScsTestSubsession ss;

 	TInt r = ss.Create(aSession, 10);

 	test(r == KErrNone);

 	// modify the subsession handle

 	TUint8* addrOfHandle;

 	addrOfHandle = (TUint8*)&ss;

 	addrOfHandle += sizeof(RSessionBase);

 	*((TInt*)addrOfHandle) ^= ~0;

 	TInt x = 3;

 	r = ss.Quadruple(x);	// should be panicked with EScsClBadHandle

 	}

 static void TestSyncSubsessionFunction()

 /**

 	Call a synchronous function on a subsession.  This ensures

 	the request is routed to the subsession by the SCS.  Also test

 	the SCS correctly handles an invalid subsession handle.

  */

 	{

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

 	TInt x = -1;

 	TInt r = sTestSubsession.Quadruple(x);

 	test(r == KErrNone);

 	test(x == 4 * KSubsessValue);

 	TestPanic(TestBadHandlePanic, ScsImpl::EScsClBadHandle);

 	test.End();

 	}

 // -------- asynchronous subsession function --------

 static TInt LaunchSsTrebleOom()

 /**

 	Launch an asynchronous request on a subsession in OOM.

 	@see RunOomTest

  */

 	{

 	TPckgBuf<TInt> x = 3;

 	TRequestStatus rs;

 	sTestSubsession.Treble(x, rs);

 	User::WaitForRequest(rs);

 	if (rs == KErrNone)

 		{

 		test(x() == 9);

 		}

 	return rs.Int();

 	}

 static void TestAsyncSubsessionFunction()

 /**

 	Test queueing and cancelling asynchronous requests on a subsession.

  */

 	{

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

 	TPckgBuf<TInt> x = 7;

 	TRequestStatus rs;

 	sTestSubsession.Treble(x, rs);

 	User::WaitForRequest(rs);

 	test(rs == KErrNone);

 	test(x() == 21);

 	// test launching async request in OOM

 	RunOomTest(LaunchSsTrebleOom, NULL);

 	// cancel async request

 	sTestSubsession.Treble(x, rs);

 	sTestSubsession.CancelTreble();

 	User::WaitForRequest(rs);

 	test(rs == KErrCancel);

 	// cancel when no outstanding request

 	sTestSubsession.CancelTreble();

 	test.End();

 	}

 // -------- leak subsession --------

 static void TestLeakSubsession()

 /**

 	Test closing a session with a remaining subsession;

 	ensure server does not leak memory.

  */

 	{

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

 	TInt r;

 	sTestSession.SetServerHeapFail(KMaxTInt);

 	RScsTestSession s;

 	r = s.Connect();

 	test(r == KErrNone);

 	RScsTestSubsession ss;

 	r = ss.Create(s, KSubsessValue);

 	test(r == KErrNone);

 	s.Close();

 	LetServerRun();			// 100ms, let server clean up

 	sTestSession.ResetServerHeapFail();

 	test.End();

 	}

 // -------- correct async requests cancelled  --------

 static void TestCorrectAsyncCancelled()

 /**

 	Test the correct requests are cancelled.

  */

 	{	

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

 	TInt r;

 	RScsTestSession s1;

 	r = s1.Connect();

 	test(r == KErrNone);

 	RScsTestSubsession ss1a;

 	r = ss1a.Create(s1, KSubsessValue);

 	test(r == KErrNone);

 	RScsTestSubsession ss1b;

 	r = ss1b.Create(s1, KSubsessValue);

 	test(r == KErrNone);

 	RScsTestSession s2;

 	r = s2.Connect();

 	test(r == KErrNone);

 	RScsTestSubsession ss2a;

 	r = ss2a.Create(s2, KSubsessValue);

 	test(r == KErrNone);

 	TRequestStatus r1, r1a, r1b, r2, r2a;

 	TPckgBuf<TInt> i1(10), i1a(20), i1b(30), i2(40), i2a(50);

 	s1.Treble(i1, r1);

 	ss1a.Treble(i1a, r1a);

 	ss1b.Treble(i1b, r1b);

 	s2.Treble(i2, r2);

 	ss2a.Treble(i2a, r2a);

 	test(r1 == KRequestPending);

 	test(r1a == KRequestPending);

 	test(r1b == KRequestPending);

 	test(r2 == KRequestPending);

 	test(r2a == KRequestPending);

 	ss1a.CancelTreble();				// subsession doesn't affect parent or siblings

 	LetServerRun();

 	test(r1 == KRequestPending);

 	test(r1a == KErrCancel);

 	test(r1b == KRequestPending);

 	test(r2 == KRequestPending);

 	test(r2a == KRequestPending);

 	s2.CancelTreble();					// session doesn't affect child

 	LetServerRun();

 	test(r1 == KRequestPending);

 	test(r1a == KErrCancel);

 	test(r1b == KRequestPending);

 	test(r2 == KErrCancel);

 	test(r2a == KRequestPending);

 	ss2a.Close();						// close subsession cancels outstanding request

 	LetServerRun();

 	test(r1 == KRequestPending);

 	test(r1a == KErrCancel);

 	test(r1b == KRequestPending);

 	test(r2 == KErrCancel);

 	test(r2a == KErrCancel);

 	// consume pending signals

 	User::WaitForRequest(r1);

 	User::WaitForRequest(r1a);

 	User::WaitForRequest(r1b);

 	User::WaitForRequest(r2);

 	User::WaitForRequest(r2a);

 	test(r1 == KErrNone);

 	test(r1a == KErrCancel);

 	test(r1b == KErrNone);

 	test(r2 == KErrCancel);

 	test(r2a == KErrCancel);

 	s1.Close();

 	s2.Close();

 	test.End();

 	}

 // -------- entrypoint --------

 void MainL()

 	{

 	test.Title(_L("c:\\scstest.log"));

 	test.Start(_L(" @SYMTestCaseID:SEC-SCSTEST-0001 scstest "));

 	TestServerDeath();

 	TestOpenClose();

 	TInt r = sTestSession.Connect();

 	test(r == KErrNone);

 	TestInvalidSessionFunction();

 	TestSyncSessionFunction();

 	TestAsyncSessionFunction();

 	TestOpenCloseSubsession();

 	r = sTestSubsession.Create(sTestSession, KSubsessValue);

 	test(r == KErrNone);

 	TestInvalidSubsessionFunction();

 	TestSyncSubsessionFunction();

 	TestAsyncSubsessionFunction();

 	TestLeakSubsession();

 	TestCorrectAsyncCancelled();

 	sTestSubsession.Close();

 	sTestSession.ShutdownServer(); // Synchronous shutdown of server

 	test.End();

 	test.Close();

 	}

 void PanicIfError(TInt r)

 	{

 	if(r != KErrNone)

 		{

 		User::Panic(_L("upstest failed: "), r);

 		}

 	}

 TInt E32Main()

 /**

 	Executable entrypoint establishes connection with SCS test server

 	and then invokes tests for each functional area.

  */

 	{

 	// disable lazy DLL unloading so kernel heap balances at end

 	RLoader l;

 	PanicIfError(l.Connect());

 	PanicIfError(l.CancelLazyDllUnload());

 	l.Close();

 	(void)test.Console();

 	__UHEAP_MARK;

 	__KHEAP_MARK;

 	// allocating a cleanup stack also installs it

 	CTrapCleanup* tc = CTrapCleanup::New();

 	if (tc == 0)

 		return KErrNoMemory;

 	TRAPD(err, MainL());

 	PanicIfError(err);

 	delete tc;

 	// The kernel appears to leave some memory allocated related to

 	// econs.dll (maybe some sort of internal cache), which is

 	// indirectly used by the test code, so we need to ignore this

 	// allocation to allow our test to pass...

 	User::__DbgMarkEnd(TRUE,1);

 	__UHEAP_MARKEND;

 	return KErrNone;

 	}

 // End of file