/*

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

*

*/

#include "tpinpluginteststep.h"

#include <authserver/authplugininterface.h>

#include <test/testexecutelog.h>

#include <ecom/ecom.h>

#include <ecom/implementationinformation.h>

#include <s32file.h>

#include <authserver/auth_srv_errs.h>

#include <authserver/authpatchdata.h>

#include <u32hal.h>

#include <e32svr.h>

using namespace AuthServer;

_LIT(KTrainSuccess,   	"TrainingSuccess");

_LIT(KReTrainSuccess, 	"ReTrainingSuccess");

_LIT(KIdentifySuccess,	"IdentifySuccess");

_LIT(KIdentifyFailure,  "IdentifyFailure");

_LIT(KSuccess,   	"Success");

_LIT(KFailure,   	"Failure");

_LIT(KDialogCancel, "Cancel");

_LIT(KDialogQuit, 	"Quit");

_LIT(KServerCancel, "ServerCancel");

_LIT(KInputFile, 	"C:\\t_pinplugindlg_in.dat");

_LIT(KOutputFile, 	"C:\\t_pinplugindlg_out.dat");

const TPluginId KPinPluginImplementationUid = 0x200032E5;

const TUint32 KEntropy = 10000;

const TUint32 KFalsePositiveRate = 0;

const TUint32 KFalseNegativeRate = 0;

const TBool KActive = ETrue;

const TAuthPluginType KPluginType = EAuthKnowledge;

_LIT(KPluginName, "PinPlugin");

_LIT(KPluginDesc, "Pinplugin authenticates device holder using PIN numbers generated from 0-9 digits");

TInt CPinPluginTestActive::KAuthenticationServerStackSize=0x2000;

TInt CPinPluginTestActive::KAuthenticationServerInitHeapSize=0x1000;

TInt CPinPluginTestActive::KAuthenticationServerMaxHeapSize=0x1000000;

CPinPluginTestActive* CPinPluginTestActive::NewL(CTestExecuteLogger& aLogger, AuthServer::TIdentityId& aIdentityId, TPtrC& aPinProcessType, CPinPluginTestStep &aTestStep)

	{

	CPinPluginTestActive* pinPlugin = new (ELeave) CPinPluginTestActive(aLogger, aIdentityId, aPinProcessType, aTestStep);

	pinPlugin->ContructL();

	return pinPlugin;

	}

void CPinPluginTestActive::ContructL()

	{

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

	}

CPinPluginTestActive::CPinPluginTestActive(CTestExecuteLogger& aLogger, TIdentityId& aIdentityId,TPtrC& aPinProcessType, CPinPluginTestStep &aTestStep) 

	:CActive(EPriorityStandard), 

	iLogger(aLogger), 

	iOperation(EPinPluginInfo),

	iIdentityId(aIdentityId),

	iPinProcessType(aPinProcessType),

    iTestStep(aTestStep)

	{

	CActiveScheduler::Add( this );

	}

CPinPluginTestActive::~CPinPluginTestActive()

	{

	Cancel();

	iFs.Close();

	if (iPinPlugin)

		{

		REComSession::DestroyedImplementation(iDtor_ID_Key);

		delete iPinPlugin;

		}

	REComSession::FinalClose();

	}

void CPinPluginTestActive::RunL()

	{

        iTestStep.SetTestStepError(iStatus.Int()); 

    	CActiveScheduler::Stop();

	return;

	}

TVerdict CPinPluginTestActive::DoTestPropertyL()

	{

	TBool res = ETrue; 

__UHEAP_MARK;		// Check for memory leaks

	iPinPlugin = LoadPluginL();

	if (iPinPlugin != NULL)

		{

		if(iPinPlugin->Id() != KPinPluginImplementationUid)

			res = EFalse;

		if(iPinPlugin->Name().CompareF(KPluginName) != 0)

			res = EFalse;

		if(iPinPlugin->Description().CompareF(KPluginDesc) != 0)

			res = EFalse;

		if(iPinPlugin->Type() != KPluginType)

			res = EFalse;

		if(iPinPlugin->MinEntropy() != KEntropy)

			res = EFalse;

		if(iPinPlugin->FalsePositiveRate() != KFalsePositiveRate)

			res = EFalse;

		if(iPinPlugin->FalseNegativeRate() != KFalseNegativeRate)

			res = EFalse;

		if(iPinPlugin->IsActive() != KActive)

			res = EFalse;

		INFO_PRINTF2(_L("ID			 : 0x%x"), iPinPlugin->Id());

	    INFO_PRINTF2(_L("Name		 : %S"), &iPinPlugin->Name());

	    INFO_PRINTF2(_L("Description	 : %S"), &iPinPlugin->Description());

	    INFO_PRINTF2(_L("MinEntropy		 : %d"), iPinPlugin->MinEntropy());

	    INFO_PRINTF2(_L("False Positive Rate : %d"), iPinPlugin->FalsePositiveRate());

	    INFO_PRINTF2(_L("False Negative Rate : %d"), iPinPlugin->FalseNegativeRate());

	    _LIT(KETrue, "ETrue");

		_LIT(KEFalse, "EFalse");

	    INFO_PRINTF2(_L("IsActive   	 : %S"), iPinPlugin->IsActive() ? &KETrue : &KEFalse);

	    switch(iPinPlugin->Type())

	    	{

	    	case EAuthDefault:

	    		INFO_PRINTF1(_L("Type       	 : EAuthDefault"));

	    		break;

	    	case EAuthBiometric:

	    		INFO_PRINTF1(_L("Type       	 : EAuthBiometric"));

	    		break;

	    	case EAuthKnowledge:

	    		INFO_PRINTF1(_L("Type       	 : EAuthKnowledge"));

	    		break;

	    	case EAuthToken:

	    		INFO_PRINTF1(_L("Type       	 : EAuthToken"));

	    		break;

	    	case EAuthPerformance:

	    		INFO_PRINTF1(_L("Type       	 : EAuthPerformance"));

	    		break;

	    	default:

	    		INFO_PRINTF1(_L("Invalid Type"));

	    	}

		}

	else

		{

		iLogInfo.Copy( _L("Cannot Load PinPlugin") );

		return EFail;

		}

	UnLoadPlugin();

__UHEAP_MARKEND;

	if (!res)

		{

		INFO_PRINTF1(_L("PinPlugin returns Unexpected Values"));

		return EFail;

		}

	return EPass;

	}

TVerdict CPinPluginTestActive::DoTestDefaultDataL()

	{

	TBool res = ETrue;

__UHEAP_MARK;		// Check for memory leaks

	iPinPlugin = LoadPluginL();

	if (iPinPlugin != NULL)

		{

		HBufC8* result = NULL;

		TInt err = iPinPlugin->DefaultData(iIdentityId, result);

		if(result != NULL)

			{

			delete result;

			}

		if (err != KErrNone)

			{

			if (err == KErrNoMemory)

				{

				User::Leave(err);

				}

			res = EFalse;

			INFO_PRINTF3(_L("Err :%d while receiving the default data for the identity : %d"), err, iIdentityId);

			}

		else

			{

			_LIT(KPinValue, "11111");

			iPinValue.Copy(KPinValue);

			INFO_PRINTF2(_L("Requesting Identify the Identity : %d with the default pin"), iIdentityId);

			TIdentityId identityId = iIdentityId;

			PreferDialogInputL(KIdentifySuccess, EPinPluginIdentify, 1);

			res = DoIdentifyL(result);

			if(result != NULL)

				{

				INFO_PRINTF2(_L("The Identity : %d is Successfully identified"), iIdentityId);

				delete result;

				}

			else

				{

				INFO_PRINTF2(_L("IdentityId : %d is not identified"), identityId);

				}

			}

		}

	else

		{

		iLogInfo.Copy( _L("Cannot Load PinPlugin") );

		return EFail;

		}

	UnLoadPlugin();

__UHEAP_MARKEND;

	return ReturnResultL(res);

	}

TVerdict CPinPluginTestActive::DoTestIdentifyL()

	{ 

	if(!ReadDetailsFromIni(iTestStep))

		{

		return EFail;

		}

	PreferDialogInputL(iExpectedOutput, EPinPluginIdentify, iDialogNumber);

	TBool res = ETrue;

__UHEAP_MARK;		// Check for memory leaks

	TIdentityId identityId = iIdentityId;

	iPinPlugin = LoadPluginL();

	if (iPinPlugin != NULL)

		{

		HBufC8* result = NULL;

		INFO_PRINTF2(_L("Requesting Identify the Identity : %d"), iIdentityId);

		res = DoIdentifyL(result);

		if(result != NULL)

			{

			INFO_PRINTF2(_L("The Identity : %d is Successfully identified"), iIdentityId);

			delete result;

			}

		else

			{

			INFO_PRINTF2(_L("IdentityId : %d is not identified"), identityId);

			}

		}

	else

		{

		iLogInfo.Copy( _L("Cannot Load PinPlugin") );

		return EFail;

		}

	UnLoadPlugin();

__UHEAP_MARKEND;

	return ReturnResultL(res);

	}

TVerdict CPinPluginTestActive::DoTestTrainL()

	{

	if(!ReadDetailsFromIni(iTestStep))

		{

		return EFail;

		}

	PreferDialogInputL(iExpectedOutput, EPinPluginTraining, iDialogNumber);

	TBool res = ETrue;

__UHEAP_MARK;		// Check for memory leaks

	iPinPlugin = LoadPluginL();

	if (iPinPlugin != NULL)

		{

		INFO_PRINTF2(_L("Requesting Train the Identity : %d"), iIdentityId);

		res = TrainIdentifyL();

		}

	else

		{

		iLogInfo.Copy( _L("Cannot Load PinPlugin") );

		return EFail;

		}

	UnLoadPlugin();

__UHEAP_MARKEND;

	return ReturnResultL(res);

	}

TVerdict CPinPluginTestActive::DoTestForgetL()

	{

	if(!ReadDetailsFromIni(iTestStep))

		{

		return EFail;

		}

	TBool res = ETrue;

__UHEAP_MARK;		// Check for memory leaks

	iPinPlugin = LoadPluginL();

	if (iPinPlugin != NULL)

		{

		ForgetIdentifyL();

		}

	else

		{

		iLogInfo.Copy( _L("Cannot Load PinPlugin") );

		return EFail;

		}

	UnLoadPlugin();

__UHEAP_MARKEND;

	return ReturnResultL(res);

	}

void CPinPluginTestActive::DoCancel() 

	{ 

	iPinPlugin->Cancel();

	}

TVerdict CPinPluginTestActive::DoTestReTrainL()

	{

	if(!ReadDetailsFromIni(iTestStep))

		{

		return EFail;

		}

	TInt dialogno = iDialogNumber;

	TBool DialogCancel = EFalse;

	if (iExpectedOutput.CompareF(KDialogCancel) == 0

		|| iExpectedOutput.CompareF(KDialogQuit) == 0)

		{

		DialogCancel = ETrue;

		}

	PreferDialogInputL(KTrainSuccess, EPinPluginTraining, 1);

	TBool res = ETrue;

__UHEAP_MARK;		// Check for memory leaks

	TIdentityId identityId = iIdentityId;

	iPinPlugin = LoadPluginL();

	if (iPinPlugin != NULL)

		{

		INFO_PRINTF2(_L("Requesting Train the Identity : %d"), iIdentityId);

		res = TrainIdentifyL();

		if (res)

			{

			iTempPinValue.Copy(iPinValue);

			if (DialogCancel)

				{

				PreferDialogInputL(KDialogCancel, EPinPluginTraining, dialogno);

				}

			else

				{

				PreferDialogInputL(KReTrainSuccess, EPinPluginTraining, dialogno);		

				}

			INFO_PRINTF2(_L("Requesting ReTrain the Identity : %d"), iIdentityId);

			res = TrainIdentifyL();

			if (res)

				{

				iPinValue.Copy(iTempPinValue);

				iIdentityId = identityId;

				if (DialogCancel)

					{

					PreferDialogInputL(KIdentifySuccess, EPinPluginIdentify, dialogno);	

					}

				else

					{

					PreferDialogInputL(KIdentifyFailure, EPinPluginIdentify, 3);		

					}		

				HBufC8* result = NULL;

				HBufC* pinVal = HBufC::NewLC(iPinValue.Length());

			   	pinVal->Des().Copy(iPinValue);

				INFO_PRINTF3(_L("Requesting Identify the Identity : %d with the pin : %S"), iIdentityId, pinVal);

				CleanupStack::PopAndDestroy(pinVal);

				res = DoIdentifyL(result);

				if(result != NULL)

					{

					INFO_PRINTF2(_L("The Identity : %d is Successfully identified"), iIdentityId);

					delete result;

					}

				else

					{

					INFO_PRINTF2(_L("IdentityId : %d is not identified"), identityId);

					}

				}

			}

		}

	else

		{

		iLogInfo.Copy( _L("Cannot Load PinPlugin") );

		return EFail;

		}

	UnLoadPlugin();

__UHEAP_MARKEND;

	return ReturnResultL(res);

	}

TVerdict CPinPluginTestActive::DoTestServerCancelL()

	{

	if(!ReadDetailsFromIni(iTestStep))

		{

		return EFail;

		}

	PreferDialogInputL(iExpectedOutput, EPinPluginTraining, 1);

	TBool res = ETrue;

__UHEAP_MARK;		// Check for memory leaks

	TIdentityId identityId = iIdentityId;

	iPinPlugin = LoadPluginL();

	if (iPinPlugin != NULL)

		{

		if (iPinProcessType.CompareF(KReTrainServerCancel) == 0)

			{

			INFO_PRINTF2(_L("Requesting Train the Identity : %d"), iIdentityId);

			res = TrainIdentifyL();

			}

		HBufC8* result = NULL;

		if (iPinProcessType.CompareF(KTrainServerCancel) == 0

			|| iPinProcessType.CompareF(KReTrainServerCancel) == 0)

			{

			iTempPinValue.Copy(iPinValue);

			INFO_PRINTF2(_L("Requesting Train the Identity : %d"), iIdentityId);

			iPinPlugin->Train(iIdentityId, result, iStatus);

			SetActive();

			}

		else if (iPinProcessType.CompareF(KIdentifyServerCancel) == 0)

			{

			INFO_PRINTF2(_L("Identify the Identity : %d"), iIdentityId);

			iPinPlugin->Identify(iIdentityId, KNullDesC(), result, iStatus);

			SetActive();

			}

		INFO_PRINTF1(_L("Cancel the process from the Authentication Server"));

		Cancel();

		if(iStatus.Int() != -3)

			{

			res = EFalse;

			}

		if (res && iPinProcessType.CompareF(KIdentifyServerCancel) != 0)

			{

			iIdentityId = identityId;

			if (iPinProcessType.CompareF(KTrainServerCancel) == 0)

				{

				_LIT(KPinValue, "123456");

				iPinValue.Copy(KPinValue);

				PreferDialogInputL(KIdentifyFailure, EPinPluginIdentify, 3);	

				}

			else

				{

				iPinValue.Copy(iTempPinValue);

				PreferDialogInputL(KIdentifySuccess, EPinPluginIdentify, 1);		

				}		

			HBufC8* result = NULL;

			HBufC* pinVal = HBufC::NewLC(iPinValue.Length());

		   	pinVal->Des().Copy(iPinValue);

			INFO_PRINTF3(_L("Requesting Identify the Identity : %d with the pin : %S"), iIdentityId, pinVal);

			CleanupStack::PopAndDestroy(pinVal);

			res = DoIdentifyL(result);

			if(result != NULL)

				{

				INFO_PRINTF2(_L("The Identity : %d is Successfully identified"), iIdentityId);

				delete result;

				}

			else

				{

				INFO_PRINTF2(_L("IdentityId : %d is not identified"), identityId);

				}

			}

		}

	else

		{

		iLogInfo.Copy( _L("Cannot Load PinPlugin") );

		return EFail;

		}

	UnLoadPlugin();

__UHEAP_MARKEND;

	return ReturnResultL(res);

	}

TVerdict CPinPluginTestActive::DoTestSequenceL()

	{

	PreferDialogInputL(KTrainSuccess, EPinPluginTraining, 1);

	TBool res = ETrue;

__UHEAP_MARK;		// Check for memory leaks

	iPinPlugin = LoadPluginL();

	if (iPinPlugin != NULL)

		{

		INFO_PRINTF2(_L("Requesting Train the Identity : %d"), iIdentityId);

		res = TrainIdentifyL();

		if (res)

			{

			PreferDialogInputL(KReTrainSuccess, EPinPluginTraining, 1);

			INFO_PRINTF2(_L("Requesting ReTrain the Identity : %d"), iIdentityId);

			HBufC8* result = NULL;

			res = DoTrainL(result);

			if (result != NULL)

				{

				delete result;

				}

			if (res)

				{

				TIdentityId id = iIdentityId;

				res = ForgetIdentifyL();

				if(res)

					{

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

						{

						iIdentityId = id;

						INFO_PRINTF2(_L("Requesting Train the Identity : %d"), iIdentityId);

						if (i==2)