/*

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

*

*/

#include <test/testexecutelog.h>

#include "tauthcliservstep.h"

#include "authserver/aspubsubdefs.h"

#include <e32property.h>

#include <authserver/authpatchdata.h>

#include <u32hal.h>

#include <e32svr.h>

using namespace AuthServer;

class CAuthActive : CActive

    {

public:

    CAuthActive(RAuthClient& aClient, CIdentity*& aResult, CTStepClient* aStep,

				TBool aStop = ETrue) : 

         CActive(EPriorityNormal),

         iFirstTime(true),

         iClient(aClient), 

         iResult(aResult), 

         iStep(aStep),

		 iStop(aStop)

	    {

        CActiveScheduler::Add(this);

        }

    void doAuthenticate(TPluginId aPlugin, TTimeIntervalSeconds aTime )

        {

		iPlugin = aPlugin;

        SetActive();		

		TRequestStatus* status = &iStatus;		    

		User::RequestComplete(status, KErrNone);

		iFirstTime = ETrue;

		iTime = aTime;

        }

        void DoCancel() 

        {

        }

        void RunL() 

        {

		static TBool client = ETrue;

		static TBool withString = ETrue;

		client = !client;

        if (iFirstTime)

            {

			// inactive | plugin id

            iAe = AuthExpr(0x10274106) | AuthExpr(iPlugin);

			User::LeaveIfNull(iAe);

			SetActive();

            iStatus = KRequestPending;

            iClient.AuthenticateL(*iAe, iTime, client, withString,

								  iResult, iStatus);

            iFirstTime = false;

            }

        else

            {

			if (iStop)

				{

				CActiveScheduler::Stop();

				}

            delete iAe;

			}

		iErr =  iStatus.Int();

		}

    TBool iFirstTime;

    RAuthClient& iClient;

    CIdentity*& iResult;

    CTStepClient* iStep;

    CAuthExpression* iAe;

    TPluginId        iPlugin;

	TTimeIntervalSeconds iTime;

	TInt iErr;

	TBool iStop;

    };

const TPluginId KIdentity1Id = 0xE0494423;

_LIT(KIdentity1Desc, "identity-1-desc");

const TPluginId KIdentity2Id = 0xE0494443;

_LIT(KIdentity2Desc, "identity-2-desc");

const TPluginId KIdentity3Id = 0xE0494453;

CTStepClient::CTStepClient()

/**

	Record this test step's name.

 */

	{

 	SetTestStepName(KTStepClient);

	}

void CTStepClient::TestIdentitiesL()

/**

	Test can retrieve correct identity arrays and

	descritptinos from auth db.

 */

	{

	__UHEAP_MARK;

	RemoveExistingDbL();

	RArray<TIdentityId> ids;

	// one identities (first start adds one)

	GetIdentitiesLC(ids);

	TESTL(ids.Count() == 1);

	CleanupStack::PopAndDestroy(&ids);

	// two identity

	AddIdentityL(KIdentity1Id, KIdentity1Desc);

	GetIdentitiesLC(ids);

	TESTL(ids.Count() == 2);

	TESTL(ids[0] == KIdentity1Id || ids[1] == KIdentity1Id);

	CleanupStack::PopAndDestroy(&ids);

	TestIdentityL(KIdentity1Id, KIdentity1Desc);

	// three identities

	AddIdentityL(KIdentity2Id, KIdentity2Desc);

	GetIdentitiesLC(ids);

	TESTL(ids.Count() == 3);

	TESTL(	ids.Find(KIdentity1Id) >= 0 && 

	        ids.Find(KIdentity2Id) >= 0);

	CleanupStack::PopAndDestroy(&ids);

	TestIdentityL(KIdentity1Id, KIdentity1Desc);

	TestIdentityL(KIdentity2Id, KIdentity2Desc);

	// test fail to get description for non-existent identity

	RAuthClient ac;

	User::LeaveIfError(ac.Connect());

	CleanupClosePushL(ac);

	TRAPD(r, ac.IdentityStringL(KIdentity3Id));

	TESTL(r == KErrAuthServIdentityNotFound);

	// check id and string retrieval

	RIdAndStringArray idWithString;

	ac.IdentitiesWithStringL(idWithString);

	CleanupClosePushL(idWithString);

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

	    {

	    TestIdentityL(idWithString[i]->Id(), *idWithString[i]->String());

		INFO_PRINTF3(_L("0x%x - %S"), idWithString[i]->Id(), idWithString[i]->String()); 

	    }

	CleanupStack::PopAndDestroy(2,&ac);

	__UHEAP_MARKEND;

	}

void CTStepClient::GetIdentitiesLC(RArray<TIdentityId>& aIds)

/**

	Populate the supplied array with the currently available

	identities, as returned by the server.

	@param	aIds			Array to populate.  Any existing entries

							are removed when this function is called.

							On success, the array is placed on the

							cleanup stack.

 */

	{

	aIds.Reset();

	CleanupClosePushL(aIds);

	RAuthClient ac;

	User::LeaveIfError(ac.Connect());

	CleanupClosePushL(ac);

	ac.IdentitiesL(aIds);	// clears array on failure?

	CleanupStack::PopAndDestroy(&ac);

	}

void CTStepClient::AddIdentityL(TIdentityId aIdentityId, const TDesC& aDesc)

/**

	Add the described identity directly to the database.

	This function does not use the authentication manager APIs.

 */

	{

	WaitForServerToReleaseDb();

	CAuthDb2* db = CAuthDb2::NewL(iFs);

	CleanupStack::PushL(db);

	db->AddIdentityL(aIdentityId, aDesc);

	CleanupStack::PopAndDestroy(db);

	}

void CTStepClient::TestIdentityL(TIdentityId aIdentityId, const TDesC& aExpDesc)

/**

	Test the supplied identity has the supplied description,

	as read via the RAuthClient API.

	@param	aIdentityId		Identity to retrieve description for.

	@param	aExpDesc		The expected description.

 */

	{

	RAuthClient ac;

	CleanupClosePushL(ac);

	User::LeaveIfError(ac.Connect());

	HBufC* desc = ac.IdentityStringL(aIdentityId);

	CleanupStack::PushL(desc);

	TESTL(*desc == aExpDesc);

	CleanupStack::PopAndDestroy(2, &ac);

	}

/**

	TestClientPluginListsL poulates this with a description for

	every plugin that can be seen with ECOM.

 */

static RCPointerArray<CPluginDesc> allPlugins;

/**

	Total number of plugins on the device.  Should be equal to

	allPlugins.Count().

 */

static TInt totalCount;

/**

	Maximum number of plugins which can are expected.  This is

	an arbitrary value which is used to size an array.  It can be

	changed if required.

 */

const TInt KMaxSeenCount = 17;

/**

	This array stores how many times each plugin from allPlugins

	has been seen.  It is set by SetSeenCountsL.

 */

static TFixedArray<TInt, KMaxSeenCount> seenCounts;

void CTStepClient::GetDescriptionsFromEComL(RPointerArray<CPluginDesc>& aDescs)

/**

	Populate the supplied array with plugin descriptions generated

	from the available ECOM plugins.  The array can then be used to

	check the results from the server.

 */

	{

	WaitForServerToReleaseDb();

	CAuthDb2* db = CAuthDb2::NewL(iFs);

	CleanupStack::PushL(db);

	// typedef RPointerArray<CImplementationInformation> RImplInfoPtrArray;

	RCPointerArray<CImplementationInformation> implInfo;

	REComSession::ListImplementationsL(KCAuthPluginInterfaceUid, implInfo);

	CleanupClosePushL(implInfo);

	TInt implCount = implInfo.Count();

	TInt err = 0;

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

		{

		// avoid RVCT warning C2874W: pi may be used before being set

		CAuthPluginInterface* pi = 0;

		TEComResolverParams resolverParams;

		TBufC8<16> pluginIdTxt;

		pluginIdTxt.Des().Format(_L8("%x"), implInfo[i]->ImplementationUid().iUid);

		pluginIdTxt.Des().UpperCase();	  

		resolverParams.SetDataType(pluginIdTxt);

		//To load plugins from sources other than ROM the patch 

		// data KEnablePostMarketAuthenticationPlugins must be set to True.

		TUint32 enablePostMarketPlugin = KEnablePostMarketAuthenticationPlugins;

#ifdef __WINS__

    	// Default SymbianOS behavior is to only load auth plugins from ROM.

		enablePostMarketPlugin = 0;

		// For the emulator allow the constant to be patched via epoc.ini

		UserSvr::HalFunction(EHalGroupEmulator, EEmulatorHalIntProperty,

		(TAny*)"KEnablePostMarketAuthenticationPlugins", &enablePostMarketPlugin); // read emulator property (if present)

#endif			  

		TAny* plugin = 0; 

		TUid Dtor_ID_Key = TUid::Null();

		if(enablePostMarketPlugin == 0) 

			{

			TRAP(err, plugin = 

			REComSession::CreateImplementationL(KCAuthPluginInterfaceUid,

												Dtor_ID_Key,

												resolverParams,

												KRomOnlyResolverUid));

			}

		else

		  	{

		  	TRAP(err, plugin = 

			REComSession::CreateImplementationL(KCAuthPluginInterfaceUid,

												Dtor_ID_Key,

												resolverParams));

		  	}

		if (err == KErrAuthServNoSuchPlugin)

			continue;

		User::LeaveIfError(err);

		pi = reinterpret_cast<CAuthPluginInterface*>(plugin);	

		// get training status from db

		TAuthTrainingStatus ts = db->PluginStatusL(pi->Id());

		CleanupStack::PushL(pi);

		CPluginDesc* pd = CPluginDesc::NewL(

			pi->Id(), pi->Name(), pi->Type(),

			ts, pi->MinEntropy(),

			pi->FalsePositiveRate(), pi->FalseNegativeRate() );

		CleanupStack::PopAndDestroy(pi);

		REComSession::DestroyedImplementation(Dtor_ID_Key);

		CleanupStack::PushL(pd);

		aDescs.AppendL(pd);

		CleanupStack::Pop(pd);

		}

	CleanupStack::PopAndDestroy(2, db);

	REComSession::FinalClose();

	}

static TBool AreDescsEqual(const CPluginDesc& aLeft, const CPluginDesc& aRight)

/**

	Predicate function determines whether the two supplied

	plugin descriptions contain the same information.

	@param	aLeft			Plugin description to compare to aRight.

	@param	aRight			Plugin description to compare to aLeft.

	@return					Zero if the two descriptions contains different

							information, non-zero otherwise.

 */

	{

	return	aLeft.Id() == aRight.Id()

		&&	*aLeft.Name() == *aRight.Name()

		&&	aLeft.Type() == aRight.Type()

		&&	aLeft.TrainingStatus() == aRight.TrainingStatus()

		&&	aLeft.MinEntropy() == aRight.MinEntropy()

		&&	aLeft.FalsePositiveRate() == aRight.FalsePositiveRate()

		&&	aLeft.FalseNegativeRate() == aRight.FalseNegativeRate();

	}

inline TBool AreDescsEqual(const CPluginDesc* aLeftP, const CPluginDesc* aRightP)

	{

	return AreDescsEqual(*aLeftP, *aRightP);

	}

void CTStepClient::SetSeenCountsL(const RCPointerArray<const CPluginDesc>& aPlugins)

/**

	Update seenCounts array so each entry contains the

	number of times that plugin was seen in aPlugins.

 */

	{

	const TInt suppliedCount = aPlugins.Count();

	const TInt totalCount = allPlugins.Count();

	// i = index into seenCounts

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

		{

		seenCounts[i] = 0;

		// j = index into aPlugins

		TInt j = 0;

		for (; j < suppliedCount; ++j)

			{

			if (AreDescsEqual(*allPlugins[i], *aPlugins[j]))

				{

				++seenCounts[i];

				break;		// assume plugins in allPlugins are unique

				}

			}

		// if plugin not found in reference set then abort

		TESTL(j < totalCount);

		}

	}

void CTStepClient::TestClientPluginListsL()

/**

	Test the expected plugins are returned when the

	client asks the server to list them.

 */

	{	

	__UHEAP_MARK;

	CleanupClosePushL(allPlugins);

	GetDescriptionsFromEComL(allPlugins);

	PrepareTrainedPluginsL();

	// re-read plugins now training statuses have been set

	allPlugins.ResetAndDestroy();	

	GetDescriptionsFromEComL(allPlugins);

	CleanupClosePushL(allPlugins);

	totalCount = allPlugins.Count();

	TESTL(totalCount <= KMaxSeenCount);

	RAuthClient ac;

	User::LeaveIfError(ac.Connect());

	CleanupClosePushL(ac);

	// ensure all plugins are returned by PluginsL

	RCPointerArray<const CPluginDesc> fullPlugins;

	ac.PluginsL(fullPlugins);

	CleanupClosePushL(fullPlugins);

	TESTL(fullPlugins.Count() == totalCount);

	SetSeenCountsL(fullPlugins);

	for (TInt k = 0; k < totalCount; ++k)

		{

		TESTL(seenCounts[k] == 1);

		}

	CleanupStack::PopAndDestroy(&fullPlugins);

	// ensure expected plugins are returned for each type

	TestTypedPluginsL(ac, EAuthKnowledge);

	TestTypedPluginsL(ac, EAuthBiometric);

	TestTypedPluginsL(ac, EAuthToken);

	TestActivePluginsL(ac);

	CleanupStack::PopAndDestroy(&ac);

	TestTrainedPluginsL();

	CleanupStack::PopAndDestroy(2, &allPlugins);

	__UHEAP_MARKEND;

	}

void CTStepClient::TestTypedPluginsL(RAuthClient& aClient,

									 TAuthPluginType aPluginType)

/**

	Ensure the plugin descriptions returned by the server

	match those directly seen by ECOM.

	@param	aPluginType		Type of plugin to retrieve.

 */

	{

	__UHEAP_MARK;

	RCPointerArray<const CPluginDesc> typedPlugins;

	aClient.PluginsOfTypeL(aPluginType, typedPlugins);

	CleanupClosePushL(typedPlugins);

	SetSeenCountsL(typedPlugins);

	for (TInt k = 0; k < totalCount; ++k)

		{

		TInt& recCount = seenCounts[k];

		TESTL(recCount == (allPlugins[k]->Type() == aPluginType) ? 1 : 0);

		}

	CleanupStack::PopAndDestroy(&typedPlugins);

	__UHEAP_MARKEND;

	}

void CTStepClient::TestActivePluginsL(RAuthClient& aClient)

/**

	Ensure the plugin descriptions returned by the server

	match those directly seen by ECOM.

 */

	{

	__UHEAP_MARK;

	RCPointerArray<const CPluginDesc> activePlugins;

	aClient.ActivePluginsL(activePlugins);

	CleanupClosePushL(activePlugins);

	CleanupStack::PopAndDestroy(&activePlugins);

	__UHEAP_MARKEND;

	}

void CTStepClient::TestTrainedPluginsL()

/**

	Test the expected plugins are returned when filtering

	for training types.

	@param	aClient			Client with open connection to auth server.

 */

	{

	RCPointerArray<const CPluginDesc> pids;

	CleanupClosePushL(pids);

	RAuthClient ac;

	User::LeaveIfError(ac.Connect());

	CleanupClosePushL(ac);

	const CPluginDesc* pdsc0 = allPlugins[0];

	const CPluginDesc* pdsc1 = allPlugins[1];

	const CPluginDesc* pdsc2 = allPlugins[2];

	const CPluginDesc* pdsc3 = allPlugins[3];

	ac.PluginsWithTrainingStatusL(EAuthUntrained, pids);

	TInt filterCount = pids.Count();

	TESTL(filterCount == totalCount - 4);

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

	{

		const CPluginDesc* pidF = pids[i];

		TBool eq0 = AreDescsEqual(pidF, pdsc0);

		TBool eq1 = AreDescsEqual(pidF, pdsc1);