/*

* Copyright (c) 2005-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: 

*

*/

/**

 @file

*/

#include "t_certapps_actions.h"

#include "t_certapps_defs.h"

#include "t_input.h"

#include "t_output.h"

#include "certificateapps.h"

/////////////////////////////////////////////////////////////////////////////////

//CCertAppTestAction base class

/////////////////////////////////////////////////////////////////////////////////

// singleton instance of the manager

CCertificateAppInfoManager* CCertAppTestAction::iAppManager = NULL;

CCertAppTestAction::~CCertAppTestAction()

	{

	}

CCertAppTestAction::CCertAppTestAction(RFs& aFs, CConsoleBase& aConsole, 

										 Output& aOut)

:	CTestAction(aConsole, aOut), iFs(aFs)

	{

	}

void CCertAppTestAction::ConstructL(const TTestActionSpec& aTestActionSpec)

	{

	CTestAction::ConstructL(aTestActionSpec);

	TInt pos = 0, error = 0;

	SetExpectedResult(ParseTagString(aTestActionSpec.iActionResult, KReturn, pos, error));

	}

void CCertAppTestAction::InitialiseL(TBool& /*aMemFailureFlag*/,

									 TBool& /*aCancel*/, TInt& /*aHeapMark*/, TInt& /*aHeapMarkEnd*/)

	{

	}

TPtrC8 CCertAppTestAction::ParseTagString(const TDesC8& aBuf, const TDesC8& aTagName, TInt& aPos, TInt& aError)

	{

	// wrapper around the Input::ParseElement function. Processes aTagName

	// and produces <aTagName> and </aTagName> used by ParseElement

	TBuf8<64> start(0);

	TBuf8<64> end(0);

	start.Append('<');

	start.Append(aTagName);

	start.Append('>');

	end.Append('<');

	end.Append('/');

	end.Append(aTagName);

	end.Append('>');

	return Input::ParseElement(aBuf, start, end, aPos, aError);

	}

TInt32 CCertAppTestAction::ParseTagInt(const TDesC8& aBuf, const TDesC8& aTagName, TInt& aPos, TInt& aError)

	{

	TPtrC8 ptr(ParseTagString(aBuf, aTagName, aPos, aError));

	// Get an integer value out of it

	TInt32 retVal = 0;

	TLex8 lex(ptr);

	lex.Val(retVal);

	return retVal;

	}

void CCertAppTestAction::SetExpectedResult(const TDesC8& aResult)

	{

	if (aResult == _L8("KErrNone") || aResult == KNullDesC8)

		{

		iExpectedResult = KErrNone;

		}

	else if (aResult == _L8("KErrAccessDenied"))

		{

		iExpectedResult = KErrAccessDenied;

		}

	else if (aResult == _L8("KErrNotReady"))

		{

		iExpectedResult = KErrNotReady;

		}

	else if (aResult == _L8("KErrAlreadyExists"))

		{

		iExpectedResult = KErrAlreadyExists;

		}

	else if (aResult == _L8("KErrInUse"))

		{

		iExpectedResult = KErrInUse;

		}

	else if (aResult == _L8("KErrNotFound"))

		{

		iExpectedResult = KErrNotFound;

		}

	else if (aResult == _L8("KErrBadName"))

		{

		iExpectedResult = KErrBadName;

		}

	else if (aResult == _L8("KErrArgument"))

		{

		iExpectedResult = KErrArgument;

		}

	else if (aResult == _L8("KErrNotReady"))

		{

		iExpectedResult = KErrNotReady;

		}

	else if (aResult == _L8("KErrCorrupt"))

		{

		iExpectedResult = KErrCorrupt;

		}

	else if (aResult == _L8("KErrPermissionDenied"))

		{

		iExpectedResult = KErrPermissionDenied;

		}

	else

		{

		iOut.write(_L("Unrecognised error code: "));

		iOut.writeString(aResult);

		iOut.writeNewLine();

		User::Leave(KErrArgument);

		}

	}

void CCertAppTestAction::PerformAction(TRequestStatus& aStatus)

	{

	TInt err = KErrNone;

	TRAP(err, DoPerformActionL());

	if (err != KErrNoMemory)

		{

		iFinished = ETrue;

		}

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CCertAppTestAction::DoPerformPrerequisite(TRequestStatus& aStatus)

	{

	TInt err = KErrNone;

	// For all tests (with the exception of InitManager which overrides this

	// method), we check to make sure that the AppManager is set

	if (iAppManager)

		{

		iActionState = EAction;

		}

	else

		{

		iFinished = ETrue;

		err = KErrNotFound;

		}

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CCertAppTestAction::DoPerformPostrequisite(TRequestStatus& aStatus)

	{

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, KErrNone);

	}

void CCertAppTestAction::PerformCancel()

	{

	}

void CCertAppTestAction::Reset()

	{

	}

void CCertAppTestAction::DoReportAction()

	{

	}

void CCertAppTestAction::DoCheckResult(TInt aError)

	{

	iResult = (aError == iExpectedResult);

	}

/////////////////////////////////////////////////////////////////////////////////

//CInitManager - initialises the singleton manager

/////////////////////////////////////////////////////////////////////////////////

CInitManager::CInitManager(RFs& aFs, CConsoleBase& aConsole, Output& aOut)

:	CCertAppTestAction(aFs, aConsole, aOut)

	{

	}

void CInitManager::DoPerformPrerequisite(TRequestStatus& aStatus)

	{

	TInt err = KErrNone;

	// If it does not exist, then we are OK

	if (!iAppManager)

		{

		iActionState = EAction;

		}

	else

		{

		iFinished = ETrue;

		err = KErrAlreadyExists;

		}

	TRequestStatus* status = &aStatus;

	User::RequestComplete(status, err);

	}

void CInitManager::DoPerformActionL()

	{

	iAppManager = CCertificateAppInfoManager::NewL();

	}

/////////////////////////////////////////////////////////////////////////////////

//CDestroyManager - destroys the singleton manager

/////////////////////////////////////////////////////////////////////////////////

CDestroyManager::CDestroyManager(RFs& aFs, CConsoleBase& aConsole, Output& aOut)

:	CCertAppTestAction(aFs, aConsole, aOut)

	{

	}

void CDestroyManager::DoPerformActionL()

	{

	delete iAppManager;

	iAppManager = NULL;

	}

/////////////////////////////////////////////////////////////////////////////////

//CClearAllApps - removes all the applications from the app list

/////////////////////////////////////////////////////////////////////////////////

CClearAllApps::CClearAllApps(RFs& aFs, CConsoleBase& aConsole, Output& aOut)

:	CCertAppTestAction(aFs, aConsole, aOut)

	{

	}

void CClearAllApps::DoPerformActionL()

	{

	for (;;)

		{

		// apps is owned by the app manager, don't try accessing it after we've

		// removed any of the applications though

		RArray<TCertificateAppInfo> apps;

		apps = iAppManager->Applications();

		if (apps.Count() == 0)

			{

			break;

			}

		iAppManager->RemoveL(apps[0].Id());

		}

	}

/////////////////////////////////////////////////////////////////////////////////

//CAddApp - adds applications

/////////////////////////////////////////////////////////////////////////////////

CAddApp::CAddApp(RFs& aFs, CConsoleBase& aConsole, Output& aOut)

:	CCertAppTestAction(aFs, aConsole, aOut)

	{

	}

CAddApp::~CAddApp()

	{

	iAppArray.Close();

	}

void CAddApp::ConstructL(const TTestActionSpec& aTestActionSpec)

	{

	CCertAppTestAction::ConstructL(aTestActionSpec);

	TInt pos = 0;

	TInt err = KErrNone;

	// Parse the UID and name for the new app

	do

		{

		TUid uid(TUid::Uid(ParseTagInt(aTestActionSpec.iActionBody, KUid, pos, err)));

		if (!err)

			{

			TName name;

			name.Copy(ParseTagString(aTestActionSpec.iActionBody, KAppName, pos, err));

			iAppArray.Append(TCertificateAppInfo(uid, name));

			}

		}

	while (!err);

	}

void CAddApp::DoPerformActionL()

	{

	for (TInt i = 0; i < iAppArray.Count(); ++i)

		{

		iAppManager->AddL(iAppArray[i]);

		}

	}

/////////////////////////////////////////////////////////////////////////////////

//CRemoveApp - removes an application

/////////////////////////////////////////////////////////////////////////////////

CRemoveApp::CRemoveApp(RFs& aFs, CConsoleBase& aConsole, Output& aOut)

:	CCertAppTestAction(aFs, aConsole, aOut)

	{

	}

void CRemoveApp::ConstructL(const TTestActionSpec& aTestActionSpec)

	{

	CCertAppTestAction::ConstructL(aTestActionSpec);

	TInt pos = 0;

	TInt err = KErrNone;

	// Parse the UID

	iUid = TUid::Uid(ParseTagInt(aTestActionSpec.iActionBody, KUid, pos, err));

	}

void CRemoveApp::DoPerformActionL()

	{

	iAppManager->RemoveL(iUid);

	}

/////////////////////////////////////////////////////////////////////////////////

//CAppCount - Gets the number of applications

/////////////////////////////////////////////////////////////////////////////////

CAppCount::CAppCount(RFs& aFs, CConsoleBase& aConsole, Output& aOut)

:	CCertAppTestAction(aFs, aConsole, aOut)

	{

	}

void CAppCount::ConstructL(const TTestActionSpec& aTestActionSpec)

	{

	CCertAppTestAction::ConstructL(aTestActionSpec);

	TInt pos = 0;

	TInt err = KErrNone;

	// Parse the expected number of applications

	iCount = ParseTagInt(aTestActionSpec.iActionBody, KCount, pos, err);

	}

void CAppCount::DoPerformActionL()

	{

	if (iCount != iAppManager->Applications().Count())

		User::Leave(KErrArgument);

	}

/////////////////////////////////////////////////////////////////////////////////

//CGetApp - Gets an application with a given ID

/////////////////////////////////////////////////////////////////////////////////

CGetApp::CGetApp(RFs& aFs, CConsoleBase& aConsole, Output& aOut)

:	CCertAppTestAction(aFs, aConsole, aOut)

	{

	}

void CGetApp::ConstructL(const TTestActionSpec& aTestActionSpec)

	{

	CCertAppTestAction::ConstructL(aTestActionSpec);

	TInt pos = 0;

	TInt err = KErrNone;

	// Parse the UID to retrieve and the name to expect

	iUid = TUid::Uid(ParseTagInt(aTestActionSpec.iActionBody, KUid, pos, err));

	iName.Copy(ParseTagString(aTestActionSpec.iActionBody, KAppName, pos, err));

	}

void CGetApp::DoPerformActionL()

	{

	TCertificateAppInfo app;

	TInt index;

	app = iAppManager->ApplicationL(iUid, index);

	if (app.Name() != iName)

		User::Leave(KErrCorrupt);

	}

/////////////////////////////////////////////////////////////////////////////////

//CGetApplications - Gets the applications and compares with what is expected

/////////////////////////////////////////////////////////////////////////////////

CGetApplications::CGetApplications(RFs& aFs, CConsoleBase& aConsole, Output& aOut)

:	CCertAppTestAction(aFs, aConsole, aOut)

	{

	}

CGetApplications::~CGetApplications()

	{

	iAppArray.Close();

	}

void CGetApplications::ConstructL(const TTestActionSpec& aTestActionSpec)

	{

	CCertAppTestAction::ConstructL(aTestActionSpec);

	TInt pos = 0;

	TInt err = KErrNone;

	// Parse the UID and name for the new app

	do

		{

		TUid uid(TUid::Uid(ParseTagInt(aTestActionSpec.iActionBody, KUid, pos, err)));

		if (!err)

			{

			TName name;

			name.Copy(ParseTagString(aTestActionSpec.iActionBody, KAppName, pos, err));

			iAppArray.Append(TCertificateAppInfo(uid, name));

			}

		}

	while (!err);

	}

void CGetApplications::DoPerformActionL()

	{

	const RArray<TCertificateAppInfo>& recArray = iAppManager->Applications();

	TInt count = iAppArray.Count();

	if (count != recArray.Count())

		{

		User::Leave(KErrArgument);

		}

	for (TInt i = 0 ; i < count ; ++i)

		{

		TInt j;

		for (j = 0 ; j < count ; ++j)

			{

			if ((iAppArray[i].Id() == recArray[j].Id()) &&

				(iAppArray[i].Name() == recArray[j].Name()))

				{

				break;

				}

			}

		if (j == count)

			{

			// If we get to the end of recArray and there is no match then

			// the arrays definitely do not match

			User::Leave(KErrArgument);

			}

		}

	}