/*
* 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 swi observer UPS 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("UPSTESTOBSIFOOM"));

static RUpsManagement sMngmntSession;

void PopulateDatabaseL()
	{
	//test.Start(_L("Populate database"));
	RUpsSession session;
	User::LeaveIfError(session.Connect());
	CleanupClosePushL(session);

	RThread thd;
	RUpsSubsession clientSubsession;
	TInt r = clientSubsession.Initialise(session, thd);
	test(r == KErrNone);
	CleanupClosePushL(clientSubsession);

	RBuf destination;
	destination.CreateL(100);
	CleanupClosePushL(destination);

	for(TInt i=0 ; i<10; ++i)
		{
		TServiceId serviceId = {42};
		if( i & 1) serviceId.iUid = 43;
		destination.Zero();
		destination.AppendFormat(_L("destination %x"), i);
		
		TUpsDecision dec = EUpsDecNo;
		TRequestStatus rs;
		clientSubsession.Authorise(EFalse, serviceId, destination, _L8("Opaque data"), dec, rs);
		User::WaitForRequest(rs);
		test((rs == KErrNone) || (rs == KErrNoMemory));
		if(rs == KErrNone)
			{
			if(serviceId.iUid == 42)
				{
				test(dec == EUpsDecYes);
				}
			else
				{
				test(dec == EUpsDecNo);
				}
			}
		}

	CleanupStack::PopAndDestroy(&destination);
	CleanupStack::PopAndDestroy(&clientSubsession);
	CleanupStack::PopAndDestroy(&session);
	//test.End();
	}
	
#if 1
class CTestSwiIf;
NONSHARABLE_CLASS(CRequest) : public CActive
	{
public:
	static CRequest *NewL(RUpsSession &aSession, CTestSwiIf &aParent, TInt aId, TUpsDecision aExpected);
	~CRequest();
private:
	CRequest(CTestSwiIf &aParent, TUpsDecision aExpected);
	void ConstructL(RUpsSession &aSession, TInt aId);

	virtual void RunL();
	virtual void DoCancel();
	virtual TInt RunError(TInt aError);

	CTestSwiIf &iParent;

	RUpsSubsession iSubSession;

	TUpsDecision iDec;
	TUpsDecision iExpected;
	};


NONSHARABLE_CLASS(CTestSwiIf) : public CActive
	{
public:
	static CTestSwiIf *NewL();

	~CTestSwiIf();

	void IncUsers();
	void DecUsers();

	TInt Result();
private:
	CTestSwiIf();
	void ConstructL();

	enum EState
		{
		EPrePolicyChange,
		EPostPolicyChange,
		ERevertPolicyChange,
		ETestingComplete
		};
	
	virtual void RunL();
	virtual void DoCancel();
	virtual TInt RunError(TInt aError);

	TInt iUsers;

	RFs iFs;
	EState iState;
	RUpsSession iUpsSession;
	RUpsManagement iManagementSession;

	TInt iResult;
	};

CTestSwiIf *CTestSwiIf::NewL()
	{
	CTestSwiIf *self = new(ELeave) CTestSwiIf;
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CTestSwiIf::CTestSwiIf()
	:	CActive(CActive::EPriorityStandard), iState(EPrePolicyChange)
	{
	CActiveScheduler::Add(this);
	}

_LIT(KCheckIfFailed, "z:\\private\\10283558\\policies\\ups_102836c3_0000002b_checkiffailed.rsc");
_LIT(KResourceFileDirC, "c:\\private\\10283558\\policies\\");
_LIT(KResourceFileOnC, "c:\\private\\10283558\\policies\\ups_102836c3_0000002b.rsc");

void CTestSwiIf::ConstructL()
	{
	User::LeaveIfError(iFs.Connect());


	User::LeaveIfError(iUpsSession.Connect());
	User::LeaveIfError(iManagementSession.Connect());


	TRequestStatus *rs = &iStatus;
	*rs = KRequestPending;
	User::RequestComplete(rs, KErrNone);
	SetActive();
	}


CTestSwiIf::~CTestSwiIf()
	{
	Cancel();
	iManagementSession.Close();
	iUpsSession.Close();
	iFs.Close();
	}

TInt CTestSwiIf::Result()
	{
	return iResult;
	}

void CTestSwiIf::IncUsers()
	{
	++iUsers;
	}

void CTestSwiIf::DecUsers()
	{
	--iUsers;
	if((iUsers <= 0) && 
		((iState == ETestingComplete) || (iResult != KErrNone)))
		{
		CActiveScheduler::Stop();
		}
	}
void CTestSwiIf::RunL()
	{
	User::LeaveIfError(iStatus.Int());
	switch(iState)
		{
		case EPrePolicyChange:
			{
			PopulateDatabaseL();

			(void)CRequest::NewL(iUpsSession, *this, 8, EUpsDecYes);
			(void)CRequest::NewL(iUpsSession, *this, 4, EUpsDecYes);
			(void)CRequest::NewL(iUpsSession, *this, 5, EUpsDecNo);
			(void)CRequest::NewL(iUpsSession, *this, 2, EUpsDecYes);
			(void)CRequest::NewL(iUpsSession, *this, 7, EUpsDecNo);

			(void)iFs.MkDirAll(KResourceFileDirC);

			CFileMan *fileman = CFileMan::NewL(iFs);
			CleanupStack::PushL(fileman);
			TInt r = fileman->Copy(KCheckIfFailed, KResourceFileOnC);
			User::LeaveIfError(r);
			CleanupStack::PopAndDestroy(fileman);

			TRequestStatus rs;
			iManagementSession.NotifyPolicyFilesChanged(rs);
			iManagementSession.CancelNotifyPolicyFilesChanged();
			User::WaitForRequest(rs);
			if(rs.Int() != KErrCancel) User::Leave(rs.Int());

			iState = EPostPolicyChange;
			iManagementSession.NotifyPolicyFilesChanged(iStatus);
			SetActive();
			break;
			}
		case EPostPolicyChange:
			// Notify complete, do some more queries
			(void)CRequest::NewL(iUpsSession, *this, 2, EUpsDecYes);
			(void)CRequest::NewL(iUpsSession, *this, 8, EUpsDecYes);
			(void)CRequest::NewL(iUpsSession, *this, 5, EUpsDecYes);
			(void)CRequest::NewL(iUpsSession, *this, 4, EUpsDecYes);
			(void)CRequest::NewL(iUpsSession, *this, 3, EUpsDecYes);

			// Revert change
			User::LeaveIfError(iFs.Delete(KResourceFileOnC));

			iState = ERevertPolicyChange;
			iManagementSession.NotifyPolicyFilesChanged(iStatus);
			SetActive();
			break;

		case ERevertPolicyChange:
			iState = ETestingComplete;
			if(iUsers <= 0)
				{
				CActiveScheduler::Stop();
				}
			break;
			
		case ETestingComplete:
			break;
		}
	}

void CTestSwiIf::DoCancel()
	{
	switch(iState)
		{
		case EPrePolicyChange:
			{
			TRequestStatus *rs = &iStatus;
			if(*rs == KRequestPending)
				{
				User::RequestComplete(rs, KErrCancel);
				}
			break;
			}

		case EPostPolicyChange:
			iManagementSession.CancelNotifyPolicyFilesChanged();
			break;

		case ERevertPolicyChange:
			iManagementSession.CancelNotifyPolicyFilesChanged();
			break;

		case ETestingComplete:
			break;
		default:
			ASSERT(0); // Unknown state				
		}

	}

TInt CTestSwiIf::RunError(TInt aError)
	{
	iResult = aError;
	if(iUsers <= 0)
		{
		CActiveScheduler::Stop();
		}
	return KErrNone;
	}

CRequest *CRequest::NewL(RUpsSession &aSession, CTestSwiIf &aParent, TInt aId, TUpsDecision aExpected)
	{
	CRequest *self = new(ELeave) CRequest(aParent, aExpected);
	CleanupStack::PushL(self);
	self->ConstructL(aSession, aId);
	CleanupStack::Pop(self);
	return self;
	}

CRequest::CRequest(CTestSwiIf &aParent, TUpsDecision aExpected)
	:	CActive(CActive::EPriorityStandard-1),
		iParent(aParent),
		iExpected(aExpected)
	{
	CActiveScheduler::Add(this);
	iParent.IncUsers();
	}

void CRequest::ConstructL(RUpsSession &aSession, TInt aId)
	{
	RThread thd;
	User::LeaveIfError(iSubSession.Initialise(aSession, thd));
	TServiceId serviceId = {42};
	if( aId & 1) serviceId.iUid = 43;
	RBuf destination;
	destination.CreateL(100);
	CleanupClosePushL(destination);
	destination.AppendFormat(_L("destination %x"), aId);
		
	iDec = EUpsDecNo;
	iSubSession.Authorise(EFalse, serviceId, destination, _L8("Opaque data"), iDec, iStatus);
	SetActive();

	CleanupStack::PopAndDestroy(&destination);
	}

CRequest::~CRequest()
	{
	iSubSession.Close();
	iParent.DecUsers();
	}

void CRequest::RunL()
	{
	test((iStatus.Int() == KErrNone) || (iStatus.Int() == KErrNoMemory));
	if(iStatus.Int() == KErrNone)
		{
		// Some OOM situations appear to cause us to return NO.
		test((iDec == iExpected) || (iDec == EUpsDecNo));
		}
	delete this;
	}

void CRequest::DoCancel()
	{
	}

TInt CRequest::RunError(TInt aError)
	{
	User::Panic(_L("CRequest::RunError"), aError);
	/*lint -unreachable*/
	return KErrNone;
	}


#endif
void TestSwiObserverL()
	{
	RUpsManagement session;
	User::LeaveIfError(session.Connect());
	CleanupClosePushL(session);

	session.NotifyPluginsMayHaveChangedL();

	TRequestStatus rs;
	session.NotifyPolicyFilesChanged(rs);
	User::WaitForRequest(rs);

	test((rs.Int() == KErrNone) || (rs.Int() == KErrNoMemory));
	if(rs.Int() == KErrNone)
		{
		session.CancelNotifyPolicyFilesChanged();
		}

	TSecureId ourSid(0x10283559);
	session.DeleteDecisionsForExeL(ourSid);


	CleanupStack::PopAndDestroy(&session);
	}


// -------- entrypoint --------
void MainL()
	{
 	// 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);

	CActiveScheduler *scheduler = new(ELeave) CActiveScheduler;
	CActiveScheduler::Install(scheduler);
	CleanupStack::PushL(scheduler);
	
	test.Title(_L("c:\\upstestobsifoom.log"));
	test.Start(_L(" @SYMTestCaseID:SEC-UPS-OBSIF_OOM-0001 Testing RUpsSession SWI observer IF "));

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

	User::LeaveIfError(sMngmntSession.Connect());
	sMngmntSession.ShutdownServer();
	sMngmntSession.Close();

	TBuf<21> notifierConfig(_L("!:\\upsrefnotifier.txt"));
	notifierConfig[0] = fs.GetSystemDriveChar();

	TInt lineLength = User::CommandLineLength();
	switch(lineLength)
		{
		default:
		// fall through - extra command line arguments are ignored
		case 2:
			// 2 char arg - Delete DB and run interactive
			(void) fs.Delete(_L("c:\\Private\\10283558\\database\\ups.db"));
			// Fall through to also delete notifier config file
		case 1:
			// 1 char arg - Run interactive, without deleting DB 
			(void) fs.Delete(notifierConfig);
			break;
		case 0:
			{
			// No args - delete DB and run in silent mode
			(void) fs.Delete(_L("c:\\Private\\10283558\\database\\ups.db"));

			(void) fs.Delete(notifierConfig);
			RFile file;
			User::LeaveIfError(file.Create(fs, notifierConfig, EFileShareExclusive | EFileWrite));
			User::LeaveIfError(file.Write(_L8("Always")));
			file.Close();
			break;
			}
		}

	User::LeaveIfError(sMngmntSession.Connect());
	CleanupClosePushL(sMngmntSession);


	TInt err = KErrNone;
	TInt errTmp = 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\nOBSIF OOM -- Run %d\n"), run);

		// Make sure the C: policy is deleted.
		(void)fs.Delete(KResourceFileOnC);

		// Make sure server is not holding cached values for the C: policy
		// We could stop/restart the server, but that is very slow...
		TRequestStatus rs;
		sMngmntSession.NotifyPolicyFilesChanged(rs);
		User::WaitForRequest(rs);

		err = sMngmntSession.SetServerHeapFail(run);
		if(err == KErrNoMemory)
			{
			// Reinitialisation failed
			test.Printf(_L("\tReinitialisation failed\n"));
			sMngmntSession.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"), err);
			test(EFalse);
			break;
			}

		// Run the test
		#if 1
		CTestSwiIf *t = 0;
		TRAP(err, t = CTestSwiIf::NewL());
		if(err == KErrNone)
			{
			CActiveScheduler::Start();
			err = t->Result();
			delete t;
			}
		#else
		err = KErrNone;
		#endif

#if 1
		if(err == KErrNone)
			{
			TRAP(err, TestSwiObserverL());
			}
#endif

		// Clear the heap fail
		test.Printf(_L("Reseting heap failure\n"));
		errTmp = sMngmntSession.ResetServerHeapFail();		
		if((err == KErrServerTerminated) || (errTmp == KErrServerTerminated))
			{
			test.Printf(_L("\tUPS server died"));
			test(EFalse);
			break;
			}
		if((err == KErrNone) && (errTmp != KErrNone))
			{
			err = errTmp;
			}
		
		// Did it work?
		if(err == KErrNone)
			{
			++passingRuns;
			}
		else
			{
			passingRuns = 0;
			}
		
		if(passingRuns > passThreshold) break;
		} // End of OOM loop

	if(run > maxRun)
		{
		User::Leave(err);
		}

	sMngmntSession.ShutdownServer();

	// Close top level session (low level session was closed by
	// ShutdownServer, but we still need to do the RUpsManagement
	// cleanup).
	CleanupStack::PopAndDestroy(&sMngmntSession);

	(void) fs.Delete(notifierConfig);
	CleanupStack::PopAndDestroy(&fs);
	
	test.End();
	test.Close();

	CleanupStack::PopAndDestroy(scheduler);
}

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