/*

* 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 <ups/upserr.h>

#include "f32file.h"

using namespace UserPromptService;

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

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

/**

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

	does not have to connect to the server.

 */

static RUpsSession 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 RUpsSubsession sTestSubsession;

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

static void TestOpenCloseSession()

/**

	Open and close a connection to the UPS server.

 */

	{

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

	RUpsSession s;

	TInt r = s.Connect();

	test(r == KErrNone);

	r = s.ShareAuto();

	test(r == KErrNone);

	s.Close();

	test.End();

	}

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

static void TestOpenCloseSubsession()

/**

	Open and close a subsession on the UPS server.

 */

	{

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

	RUpsSubsession ss;

	RThread thd;

	TInt r = ss.Initialise(sTestSession, thd);

	test(r == KErrNone);

	ss.Close();

	test.End();

	}

// -------- Authorise succeed, cancel --------

_LIT8(KOpaqueData, "<ce>fred</ce>");

static void TestAuthoriseL()

/**

	Launch an asynchronous Authorise request on a UPS subsession.

	Let it complete normally, and also cancel it.

 */

	{

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

	TServiceId serviceId = {43};

	TRequestStatus rs;

	test.Next(_L("complete normally - no opaque data\n"));

	TUpsDecision dec = EUpsDecYes;

	sTestSubsession.Authorise(EFalse, serviceId, KNullDesC, dec, rs);

	test(dec == EUpsDecYes);	// not changed yet

	User::WaitForRequest(rs);

	test(rs == KErrNone);

	test(dec == EUpsDecNo);

	test.Next(_L("cancel - empty opaque data\n"));

	dec = EUpsDecYes;	// ensure changed

	sTestSubsession.Authorise(EFalse, serviceId, KNullDesC, KNullDesC8, dec, rs);

	test(dec == EUpsDecYes);	// not changed yet

	test.Printf(_L("About to cancel - current status is %d"), rs.Int());

	sTestSubsession.CancelPrompt();

	User::WaitForRequest(rs);

	test(rs == KErrCancel);

	test(dec == EUpsDecYes);	// not changed

	test.Next(_L("Opaque data\n"));

	dec = EUpsDecYes;	// ensure changed

	sTestSubsession.Authorise(EFalse, serviceId, _L("opaque data test"), KOpaqueData, dec, rs);

	test(dec == EUpsDecYes);	// not changed yet

	User::WaitForRequest(rs);

	test(rs == KErrNone);

	test(dec == EUpsDecNo);

	test.Next(_L("cancel when no outstanding - harmless\n"));

	sTestSubsession.CancelPrompt();

	test.Next(_L("cancel/close when sub session never created - harmless\n"));

	RUpsSubsession uninitialisedCancel;

	uninitialisedCancel.CancelPrompt();

	uninitialisedCancel.Close();

	test.End();

	}

static void TestFlurryL()

/**

	Launch multiple requests

 */

	{

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

	RThread thd;

	RUpsSubsession testSubsession1;

	testSubsession1.Initialise(sTestSession, thd);

	RUpsSubsession testSubsession2;

	testSubsession2.Initialise(sTestSession, thd);

	RUpsSubsession testSubsession3;

	testSubsession3.Initialise(sTestSession, thd);

	RUpsSubsession testSubsession4;

	testSubsession4.Initialise(sTestSession, thd);

	RUpsSubsession testSubsession5;

	testSubsession5.Initialise(sTestSession, thd);

	RUpsSubsession testSubsession6;

	testSubsession6.Initialise(sTestSession, thd);

	TServiceId serviceId = {43};

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

#if 0

	// Will change immediately in non-interactive testing

	test(dec1 == EUpsDecYes);	// not changed yet

	test(dec2 == EUpsDecYes);	// not changed yet

	test(dec3 == EUpsDecYes);	// not changed yet

	test(dec4 == EUpsDecYes);	// not changed yet

	test(dec5 == EUpsDecYes);	// not changed yet

	test(dec6 == EUpsDecYes);	// not changed yet

#endif

	User::After(1000);

	User::WaitForRequest(rs1);

	User::WaitForRequest(rs2);

	User::WaitForRequest(rs4);

	User::WaitForRequest(rs3);

	User::WaitForRequest(rs5);

	User::WaitForRequest(rs6);

	test(rs1 == KErrNone);

	test(rs2 == KErrNone);

	test(rs3 == KErrNone);

	test(rs4 == KErrNone);

	test(rs5 == KErrNone);

	test(rs6 == KErrNone);

	test(dec1 == EUpsDecNo);

	test(dec2 == EUpsDecNo);

	test(dec3 == EUpsDecNo);

	test(dec4 == EUpsDecNo);

	test(dec5 == EUpsDecNo);

	test(dec6 == EUpsDecNo);

	test.End();

	}

// -------- RUpsSubsession --------

_LIT(KSayYes,"SayYes");

static void TestRUpsSubsession()

/**

	Attempt query with server checks passed and without

 */

	{

	//

	// Tests for RUpsSubsession

	//

	RThread thd;

	test.Start(_L("Testing RUpsSubsession"));

	RUpsSubsession clientSubsession;

	TInt r = clientSubsession.Initialise(sTestSession, thd);

	test(r == KErrNone);

	test.Next(_L("Query with server checks passed"));

	TServiceId serviceId = {42};

	TUpsDecision dec = EUpsDecNo;

	TRequestStatus rs;

	// Query saying our checks were ok, expect to get decision set to EUpsDecYes

	clientSubsession.Authorise(ETrue, serviceId, _L("Destination"), _L8("Opaque data"), dec, rs);

	User::WaitForRequest(rs);

	test(rs == KErrNone);

	test(dec == EUpsDecYes);

	test.Next(_L("Try closing client subsession before it is really created"));

	clientSubsession.Close();

	test.Next(_L("Re-\"create\" client subsession"));

	r = clientSubsession.Initialise(sTestSession, thd);

	test(r == KErrNone);

	test.Next(_L("Query with server checks failed, ie query UPS, expect fail"));

	// Query saying our checks failed, should talk to UPS and change decision to EUpsDecNo

	dec = EUpsDecYes;

	clientSubsession.Authorise(EFalse, serviceId, KNullDesC, dec, rs);

	User::WaitForRequest(rs);

	test(rs == KErrNone);

	test(dec == EUpsDecNo);

	test.Next(_L("Query with server checks failed, ie query UPS, special destination, expect yes"));

	// Query saying our checks failed, should talk to UPS and change decision to EUpsDecNo

	dec = EUpsDecYes;

	clientSubsession.Authorise(EFalse, serviceId, KSayYes(), dec, rs);

	User::WaitForRequest(rs);

	test(rs == KErrNone);

	test(dec == EUpsDecYes);

	clientSubsession.Close();

	test.End();

	}

TInt ThreadFunction(TAny *)

	{

	return KErrNone;

	}

static void TestRUpsSubsessionDeathL()

	{

	RThread thd;

	TRequestStatus thdStatus;

	User::LeaveIfError(thd.Create(_L("MyThread"), ThreadFunction, 4096, 4096, 4096, 0, EOwnerThread));

//	thd.SetHandle(666);

	thd.Rendezvous(thdStatus);

	thd.Kill(KErrAbort);

	User::WaitForRequest(thdStatus);

	test.Start(_L("Testing RUpsSubsession"));

	RUpsSubsession clientSubsession;

	TInt r = clientSubsession.Initialise(sTestSession, thd);

	test(r == KErrNone);

	test.Next(_L("Query with dead thread id"));

	TServiceId serviceId = {43};

	TUpsDecision dec = EUpsDecYes;

	TRequestStatus rs;

	thd.Close();

	clientSubsession.Authorise(EFalse, serviceId, _L("req1"), dec, rs);

	User::WaitForRequest(rs);

	test(rs == KErrNone);

	test(dec == EUpsDecNo);

	clientSubsession.Close();

	test.End();

	}

static void TestRUpsManagementL()

/**

	Attempt to delete database

 */

	{

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

	RThread thd;

	TRequestStatus rs;

	// Create filter

	TServiceId serviceId = {43};

	CDecisionFilter *filter = CDecisionFilter::NewLC();

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

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

	filter->SetServiceId(serviceId, EEqual);

	RUpsSubsession clientSubsession;

	TInt r = clientSubsession.Initialise(sTestSession, thd);

	test(r == KErrNone);

	test.Next(_L("Open management session"));

	RUpsManagement mngmnt;

	r = mngmnt.Connect();

	test(r == KErrNone);

	User::LeaveIfError(r);

	test.Next(_L("View create - then delete DB"));

	mngmnt.CreateView(*filter, rs);

	test.Next(_L("Delete database"));

	TRAP(r, mngmnt.DeleteDatabaseL());

	test(r == KErrNone);

	test.Next(_L("Now see what view create completed with...."));

	User::WaitForRequest(rs);

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

	test.Next(_L("Add entry to new database"));

	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.Next(_L("View create - immediate cancel"));

	mngmnt.CreateView(*filter, rs);

	mngmnt.CancelAndCloseView();

	User::WaitForRequest(rs);

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

	mngmnt.UpdateDecision(TUint32(-23), ETrue, rs);

	mngmnt.CancelUpdateDecision();

	User::WaitForRequest(rs);

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

	mngmnt.UpdateDecision(TUint32(-23), ETrue, rs);

	User::WaitForRequest(rs);

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

	test.Next(_L("View create - when busy"));

	TRequestStatus rs2;

	mngmnt.CreateView(*filter, rs);

	mngmnt.CreateView(*filter, rs2);

	User::WaitForRequest(rs2);

	test(rs2.Int() == KErrServerBusy);

	User::WaitForRequest(rs);

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

	mngmnt.CancelAndCloseView();

	test.Next(_L("View create - iterate through it"));

	mngmnt.CreateView(*filter, rs);

	User::WaitForRequest(rs);

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

	CleanupStack::PopAndDestroy(filter);

	CDecisionRecord *record = 0;

	r = KErrNone;

	TInt recordCount = 0;

	while(r == KErrNone)

		{

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

		if(record == 0)

			{

			break;

			}

		test(r == KErrNone);

		if(r == KErrNone)

			{

			++recordCount;

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

			}

		};

	test(recordCount == 2);

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

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

	mngmnt.CancelAndCloseView();

	test.Next(_L("Close management session and clientSubsession"));

	mngmnt.Close();

	clientSubsession.Close();

	test.End();

	}

void TestSwiObserverSecurityL()

{

	test.Start(_L("Testing swi observer functions do not work from here..."));

	TInt r;

	RUpsManagement session;

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

	CleanupClosePushL(session);

	TUid ourSid;

	ourSid.iUid = 0x10283559;

	TRAP(r, session.DeleteDecisionsForExeL(ourSid));

	test(r == KErrPermissionDenied);

	TRAP(r, session.NotifyPluginsMayHaveChangedL());

	test(r == KErrPermissionDenied);

	TRequestStatus rs;

	session.NotifyPolicyFilesChanged(rs);

	User::WaitForRequest(rs);

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

	session.CancelNotifyPolicyFilesChanged();

	CleanupStack::PopAndDestroy(&session);

	test.End();

}

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

void MainL()

	{

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

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

	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:

		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;

			}

		}

	//RThread ourThread;

	//ourThread.SetPriority(EPriorityMore);

	//ourThread.Close();

//	User::SetProcessCritical(User::ESystemCritical);

//	User::SetCritical(User::ESystemCritical);

	TestOpenCloseSession();

	TInt r = sTestSession.Connect();

	test(r == KErrNone);

	User::LeaveIfError(r);

	TestRUpsSubsessionDeathL();

	TestOpenCloseSubsession();

	TestSwiObserverSecurityL();

	RThread thd;

	r = sTestSubsession.Initialise(sTestSession, thd);

	test(r == KErrNone);

	User::LeaveIfError(r);

	TestFlurryL();

	TestAuthoriseL();

	sTestSubsession.Close();

	TestRUpsSubsession();

	TestRUpsManagementL();

	sTestSession.ShutdownServer();

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

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

	// cleanup).

	sTestSession.Close();

	(void) fs.Delete(notifierConfig);

	CleanupStack::PopAndDestroy(&fs);

	test.End();

	test.Close();

}

void PanicIfError(TInt r)

	{

	if(r != KErrNone)

		{

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

		}

	}

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());

	if(err != KErrNone)

		{

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

		}

	delete tc;

	//__KHEAP_MARKEND;

	__UHEAP_MARKEND;

	return KErrNone;

	}