/*

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

*

*/

#ifndef TAUTHDBSTEP_H

#define TAUTHDBSTEP_H

#include <test/testexecutestepbase.h>

#include <test/testexecutelog.h>

#include "tauthdbserver.h"

#include <f32file.h>

#include "authdb.h"

#include "encryptedprotectionkey.h"

#include "transientkey.h"  

#include "transientkey.h"  

#include "transientkeyinfo.h"

_LIT(KTStepCreateTestDb, "CreateTestDb");

_LIT(KTStepPersist2, "PERSIST2");

#define KNumPlugins 10

class CTAuthDbStepBase : public CTestStep

	{

protected:

	CTAuthDbStepBase() {}

	virtual ~CTAuthDbStepBase();

	void CreatePlugins();

	void CreateKeyInfo();

	virtual TVerdict doTestStepPreambleL()

	   {

	   iFs.Connect();

	   CreatePlugins();

	   CreateKeyInfo();

	   return TestStepResult();

	   }

	virtual TVerdict doTestStepPostambleL()

    	{

		iFs.Close();

		return TestStepResult();

		}

	void RemoveExistingDbL()

	/**

		Remove any existing database file.

	 */

		{

		CFileMan* fm = CFileMan::NewL(iFs);

		CleanupStack::PushL(fm);

		TFileName dbName(AuthServer::KDbName);

		dbName[0] = RFs::GetSystemDriveChar();

		TInt r = fm->Delete(dbName);

		if (r != KErrNotFound)

			User::LeaveIfError(r);

		CleanupStack::PopAndDestroy(fm);	

		}

	HBufC* GetNameLC(TInt i);

	void PluginData(AuthServer::TIdentityId aId,

					AuthServer::TPluginId aPlugin,

					TPtr8 aDes) 

	{

	aDes.Fill(aId*aPlugin);

	}

protected:

	RFs		iFs;

	AuthServer::CPluginDesc*       iPlugins[KNumPlugins];

	AuthServer::CTransientKeyInfo* iId1Keys[KNumPlugins];

	AuthServer::CTransientKeyInfo* iId2Keys[KNumPlugins];

	AuthServer::CTransientKeyInfo* iId3Keys[KNumPlugins];

  };

inline CTAuthDbStepBase::~CTAuthDbStepBase() 

    {

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

        {

        delete iPlugins[i];

        delete iId1Keys[i];

        delete iId2Keys[i];

        delete iId3Keys[i];

        }

    }

class CTStepCreateTestDb : public CTAuthDbStepBase

/**

	Creates a test database which tauthcliserv can

	use to test the manager later.

 */

	{

public:

	CTStepCreateTestDb();

	// implement CTestStep

	virtual TVerdict doTestStepL();

	};

class CTStepPersist2 : public CTAuthDbStepBase

	{

public:

	CTStepPersist2();

private:

	virtual TVerdict doTestStepL();

	void TestOpenCloseL();

	void TestIdentitiesL();

	void TestDescriptionL(AuthServer::CAuthDb2* aDb, AuthServer::TIdentityId aIdentityId, const TDesC& aExpDesc);

	void TestPrefsL();

	void TestTrainedPluginsL();

	void TestKeyPresentL(

		AuthServer::CAuthDb2* aAuthDb, AuthServer::TIdentityId aIdentityId, AuthServer::TPluginId aPluginId,

		const AuthServer::CTransientKeyInfo& aTarget);

	void TestTrainingStatusL();

	void TestRepairL();

	void TestCompressL();

	TInt DbFileSizeL();

	};

inline HBufC* CTAuthDbStepBase::GetNameLC(TInt id)

    {

    _LIT(nameTmpl, "Plugin_%d");

	HBufC* name = HBufC::NewLC(15);

	name->Des().Format(nameTmpl, id);

	return name;

    }

inline void CTAuthDbStepBase::CreatePlugins()

	{

	using namespace AuthServer;

	const TAuthPluginType   types[KNumPlugins]

		= { EAuthBiometric, EAuthToken, EAuthKnowledge,

			EAuthBiometric, EAuthToken, EAuthKnowledge,

			EAuthToken, EAuthKnowledge

		};

	const TAuthTrainingStatus   training[KNumPlugins]

		= { EAuthUntrained, EAuthTrained, EAuthFullyTrained,

			EAuthUntrained, EAuthTrained, EAuthFullyTrained,

			EAuthTrained, EAuthFullyTrained

		  };

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

		{

			HBufC* name = GetNameLC(i);

			iPlugins[i] = CPluginDesc::NewL(i,

											*name,

											types[i],

											training[i],

											i*10000,

											i,

											i*4);

		    CleanupStack::PopAndDestroy(name);									

		}

	}

inline void CTAuthDbStepBase::CreateKeyInfo()

	{

	using namespace AuthServer;

	CProtectionKey* protKey1 = CProtectionKey::NewLC(8);

	CProtectionKey* protKey2 = CProtectionKey::NewLC(8);

	CProtectionKey* protKey3 = CProtectionKey::NewLC(8);

	HBufC8* data = HBufC8::NewLC(4);

	for (TInt plugin = 0 ; plugin < KNumPlugins ; ++plugin)

		{

			CTransientKey* transient = 0;

			// id 1

			iId1Keys[plugin] = CTransientKeyInfo::NewL(plugin);

			PluginData(1, plugin, data->Des());

			transient = iId1Keys[plugin]->CreateTransientKeyL(data->Des());

			CEncryptedProtectionKey* epKey1 =

				transient->EncryptL(*protKey1);

			delete transient;

			iId1Keys[plugin]->SetEncryptedProtectionKeyL(epKey1);

			// id 2

			PluginData(2, plugin, data->Des());

			iId2Keys[plugin] = CTransientKeyInfo::NewL(plugin);

			transient = iId2Keys[plugin]->CreateTransientKeyL(data->Des());

			CEncryptedProtectionKey* epKey2 =

				transient->EncryptL(*protKey2);

			delete transient;

			iId2Keys[plugin]->SetEncryptedProtectionKeyL(epKey2);

			// id 3

			PluginData(3, plugin, data->Des());

			iId3Keys[plugin] = CTransientKeyInfo::NewL(plugin);

			transient = iId3Keys[plugin]->CreateTransientKeyL(data->Des());

			CEncryptedProtectionKey* epKey3 =

				transient->EncryptL(*protKey3);

			delete transient;

			iId3Keys[plugin]->SetEncryptedProtectionKeyL(epKey3);

		}

	CleanupStack::Pop(4, protKey1);

	}

#endif	/* TAUTHDBSTEP_H */