cryptoservices/filebasedcertificateandkeystores/test/tcertapps/t_certapps_actions.cpp
/*
* 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);
}
}
}