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