/*
* 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 "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;
	}