/*

* 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: 

* Test program exercises the skeleton UPS server API.

* See individual test functions for more information.

*

*/

/**

 @file

*/

#include <e32ldr.h>

#include <e32ldr_private.h>

#include "rtestwrapper.h"

#include <ups/upsclient.h>

#include "f32file.h"

using namespace UserPromptService;

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

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

static void TestFlurryL()

/**

	Launch multiple requests

 */

	{

	RUpsSession session;

	User::LeaveIfError(session.Connect());

	CleanupClosePushL(session);

	RThread thd;

#if 0

	RUpsSubsession testSubsession1;

	testSubsession1.Initialise(session, thd);

	TServiceId serviceId = {42};

	TRequestStatus rs1;

	// complete normally - no opaque data

	TUpsDecision dec1 = EUpsDecYes;

	testSubsession1.Authorise(EFalse, serviceId, _L("req1"), dec1, rs1);

	User::After(1000);

	User::WaitForRequest(rs1);

	User::LeaveIfError(rs1.Int());

	test(dec1 == EUpsDecNo);

#else

	RUpsSubsession testSubsession1;

	testSubsession1.Initialise(session, thd);

	RUpsSubsession testSubsession2;

	testSubsession2.Initialise(session, thd);

	RUpsSubsession testSubsession3;

	testSubsession3.Initialise(session, thd);

	RUpsSubsession testSubsession4;

	testSubsession4.Initialise(session, thd);

	RUpsSubsession testSubsession5;

	testSubsession5.Initialise(session, thd);

	RUpsSubsession testSubsession6;

	testSubsession6.Initialise(session, thd);

	TServiceId serviceId = {42};

	TRequestStatus rs1;

	TRequestStatus rs2;

	TRequestStatus rs3;

	TRequestStatus rs4;

	TRequestStatus rs5;

	TRequestStatus rs6;

	// complete normally - no opaque data

	TUpsDecision dec1 = EUpsDecYes;

	TUpsDecision dec2 = EUpsDecYes;

	TUpsDecision dec3 = EUpsDecYes;

	TUpsDecision dec4 = EUpsDecYes;

	TUpsDecision dec5 = EUpsDecYes;

	TUpsDecision dec6 = EUpsDecYes;

	testSubsession1.Authorise(EFalse, serviceId, _L("req1"), dec1, rs1);

	testSubsession2.Authorise(EFalse, serviceId, _L("reqX"), dec2, rs2);

	testSubsession3.Authorise(EFalse, serviceId, _L("req2"), dec3, rs3);

	testSubsession4.Authorise(EFalse, serviceId, _L("reqX"), dec4, rs4);

	testSubsession5.Authorise(EFalse, serviceId, _L("req3"), dec5, rs5);

	testSubsession6.Authorise(EFalse, serviceId, _L("req4"), dec6, rs6);

	User::After(1000);

	User::WaitForRequest(rs1);

	User::WaitForRequest(rs2);

	User::WaitForRequest(rs4);

	User::WaitForRequest(rs3);

	User::WaitForRequest(rs5);

	User::WaitForRequest(rs6);

	User::LeaveIfError(rs1.Int());

	User::LeaveIfError(rs2.Int());

	User::LeaveIfError(rs3.Int());

	User::LeaveIfError(rs4.Int());

	User::LeaveIfError(rs5.Int());

	User::LeaveIfError(rs6.Int());

	test(dec1 == EUpsDecNo);

	test(dec2 == EUpsDecNo);

	test(dec3 == EUpsDecNo);

	test(dec4 == EUpsDecNo);

	test(dec5 == EUpsDecNo);

	test(dec6 == EUpsDecNo);

#endif

	CleanupStack::PopAndDestroy(&session);

	}

static void TestRUpsManagementL()

/**

	Attempt to delete database

 */

	{

//	test.Start(_L("Testing RUpsManagement"));

	RThread thd;

	TRequestStatus rs;

	TInt r;

	// Create filter

	TServiceId serviceId = {43};

	CDecisionFilter *filter = CDecisionFilter::NewLC();

	filter->SetClientSid(thd.SecureId(), EEqual);

	filter->SetServerSid(thd.SecureId(), EEqual);

	filter->SetServiceId(serviceId, EEqual);

	RUpsSession session;

	User::LeaveIfError(session.Connect());

	CleanupClosePushL(session);

	RUpsSubsession clientSubsession;

	User::LeaveIfError(clientSubsession.Initialise(session, thd));

	CleanupClosePushL(clientSubsession);

	test.Printf(_L("Open management session\n"));

	RUpsManagement mngmnt;

	User::LeaveIfError(mngmnt.Connect());

	CleanupClosePushL(mngmnt);

	test.Printf(_L("View create - then delete DB\n"));

	mngmnt.CreateView(*filter, rs);

	test.Printf(_L("Delete database\n"));

	TRAP(r, mngmnt.DeleteDatabaseL());

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

	test.Printf(_L("Now see what view create completed with....\n"));

	User::WaitForRequest(rs);

	// The createview may actually complete if the DeleteDatabase fails due to OOM

//	test((rs.Int() == KErrAbort) || (rs.Int() == KErrNoMemory) || (rs.Int() == KErrNone));

	test((rs.Int() == KErrAbort) || (rs.Int() == KErrNoMemory));

	test.Printf(_L("Add entry to new database\n"));

	TUpsDecision dec = EUpsDecYes;

	clientSubsession.Authorise(EFalse, serviceId, _L("DB delete 1"), _L8("Opaque data"), dec, rs);

	User::WaitForRequest(rs);

	test(rs == KErrNone);

	test(dec == EUpsDecNo);

	dec = EUpsDecYes;

	clientSubsession.Authorise(EFalse, serviceId, _L("DB delete 2"), _L8("Opaque data"), dec, rs);

	User::WaitForRequest(rs);

	test(rs == KErrNone);

	test(dec == EUpsDecNo);

	test.Printf(_L("View create - immediate cancel\n"));

	mngmnt.CreateView(*filter, rs);

	mngmnt.CancelAndCloseView();

	User::WaitForRequest(rs);

	test((rs.Int() == KErrCancel) || (rs.Int() == KErrNoMemory));

	test.Printf(_L("View create - iterate through it\n"));

	mngmnt.CreateView(*filter, rs);

	User::WaitForRequest(rs);

	test((rs.Int() == KErrNone) || (rs.Int() == KErrNoMemory));

	CDecisionRecord *record = 0;

	r = KErrNone;

	while(r == KErrNone)

		{

		TRAP(r, record = mngmnt.NextMatchL());

		if(record == 0)

			{

			break;

			}

		test(r == KErrNone);

    	if(r == KErrNone)

    		{

    		CleanupStack::PushL(record);

			CDecisionFilter *exactFilter = CDecisionFilter::NewLC(record->iClientSid,

																  record->iEvaluatorId,

																  record->iServiceId,

																  record->iServerSid,

																  record->iFingerprint,

																  record->iClientEntity,

																  record->iMajorPolicyVersion);

			mngmnt.UpdateDecision(record->iRecordId, ETrue, rs);

			User::WaitForRequest(rs);

			test(rs.Int() == KErrNone);

			TRAP(r, mngmnt.RemoveDecisionsL(*exactFilter));

			test(r == KErrNone);

			CleanupStack::PopAndDestroy(exactFilter);

			CleanupStack::PopAndDestroy(record);

    		}

		};

	TRAP(r, record = mngmnt.NextMatchL());

	test((r == KErrNone) && (record == 0));

	mngmnt.CancelAndCloseView();

	test.Printf(_L("Close management session and clientSubsession\n"));

	CleanupStack::PopAndDestroy(&mngmnt);

	CleanupStack::PopAndDestroy(&clientSubsession);

	CleanupStack::PopAndDestroy(&session);

	CleanupStack::PopAndDestroy(filter);

//	test.End();

	}

void MainL()

	{

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

	test.Start(_L(" @SYMTestCaseID:SEC-UPS-OOM-0001 Testing UPS OOM "));

	// We need to increase the priority of the thread running the test code to make sure

	// that asynchronous ups management calls, for example CreateView() , won't finish

	// before following synchronous cancellation or termination calls, for example:

	// DeleteDatabaseL() or CancelAndCloseView().

	RThread thread;

	TThreadPriority currentPri = thread.Priority();

	currentPri = (TThreadPriority)((TInt)currentPri+10);

	thread.SetPriority(currentPri);

	RFs fs;

	User::LeaveIfError(fs.Connect());

	CleanupClosePushL(fs);

	TBuf<21> notifierConfig(_L("!:\\upsrefnotifier.txt"));

	notifierConfig[0] = fs.GetSystemDriveChar();

	TBuf<35> database(_L("!:\\Private\\10283558\\database\\ups.db"));

	database[0] = fs.GetSystemDriveChar();

	TInt lineLength = User::CommandLineLength();

	switch(lineLength)

		{

		default:

			// fall through - extra command line arguments are ignored

		case 2:

			(void) fs.Delete(database);

			// Fall through to also delete notifier config file

		case 1:

			(void) fs.Delete(notifierConfig);

			break;

		case 0:

			{

			// No args so run in silent mode

			(void) fs.Delete(database);

			(void) fs.Delete(notifierConfig);

			RFile file;

			User::LeaveIfError(file.Create(fs, notifierConfig, EFileShareExclusive | EFileWrite));

			User::LeaveIfError(file.Write(_L8("Never")));

			file.Close();

			break;

			}

		}

	// Connect to server

	RUpsSession session;

	User::LeaveIfError(session.Connect());

	CleanupClosePushL(session);

	TInt err = KErrNone;

	TInt err2 = KErrNone;

	TInt run = 0;

	TInt passingRuns = 0;

	static const TInt maxRun = 1000;

	static const TInt passThreshold = 5;

	for(run=1; run<=maxRun; ++run)

		{

		test.Printf(_L("\n\nOOM -- Run %d\n"), run);

		err = session.SetServerHeapFail(run);

		if(err == KErrNoMemory)

			{

			// Reinitialisation failed

			test.Printf(_L("\tReinitialisation failed\n"));

			session.ResetServerHeapFail();

			continue;

			}

		if(err != KErrNone)

			{

			// Failed to set heap fail, maybe the previous loop crashed the server??

			test.Printf(_L("Failed to set heap fail with error code %d\n"), err);

			test(EFalse);

			break;

			}

		// Run the test

		//test.Start(_L("TestFlurry"));

		test.Printf(_L("TestFlurry\n"));

		TRAP(err, TestFlurryL());

		test.Printf(_L("TestRUpsManagementL\n"));

		TRAP(err2, TestRUpsManagementL());

		if(err == KErrNone)

			{

			err = err2;

			}

		test.Printf(_L("done\n"));

		//test.End();

		// Clear the heap fail

		test.Printf(_L("Reseting heap failure\n"));

		err2 = session.ResetServerHeapFail();

		if((err == KErrServerTerminated) || (err2 == KErrServerTerminated))

			{

			test.Printf(_L("\tUPS server died\n"));

			test(EFalse);

			break;

			}

		if((err == KErrNone) && (err2 != KErrNone))

			{

			err = err2;

			}

		// Did it work?

		if(err == KErrNone)

			{

			++passingRuns;

			}

		else

			{

			passingRuns = 0;

			}

		if(passingRuns > passThreshold) break;

		} // End of OOM loop

	if(run > maxRun)

		{

		User::Leave(err);

		}

	// Synchronous call to shutdown the server

	session.ShutdownServer();

	// Close top level session (low level session was closed by

	// ShutdownServer, but we still need to do the RUpsSession

	// cleanup).

	CleanupStack::PopAndDestroy(&session);

	(void) fs.Delete(notifierConfig);

	CleanupStack::PopAndDestroy(&fs);

	test.End();

	test.Close();

}

void PanicIfError(TInt r)

	{

	if(r != KErrNone)

		{

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

		}

	}

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

TInt E32Main()

/**

	Executable entrypoint establishes connection with UPS server

	and then invokes tests for each functional area.

	@return					Symbian OS error code where KErrNone indicates

							success and any other value indicates failure.

 */

	{

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

	RLoader l;

	PanicIfError(l.Connect());

	PanicIfError(l.CancelLazyDllUnload());

	l.Close();

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

	//__KHEAP_MARKEND;

	__UHEAP_MARKEND;

	return KErrNone;

	}

// End of file