/*

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

	}