/*

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

* Implements basic database test functions.

*

*/

/**

 @file

 @test

*/

#include "tupsdbstep.h"

#include <test/testexecutelog.h>

using namespace UserPromptService;

//

//CUpsDbBaseStep

//

CUpsDbBaseStep::CUpsDbBaseStep()

/**

	onstructor Code

 */

	{

	}

CUpsDbBaseStep::~CUpsDbBaseStep()

/**

	Destructor Code

 */

	{

	} 

CDecisionFilter *CUpsDbBaseStep::CreateFilterL(TInt aFlag, TInt aClientSid, TInt aEvaluatorId, TInt aServiceId, TInt aServerSid, TDesC8 &aFingerprint, TDesC8& aClientEntity,TInt aMajorPolicyVersion, TInt aRecordId, TDesC& aDescription, TInt aResult, TInt aEvaluatorInfo, TComparisonOp aComparisonOp)

 /**

	Creates an empty filter object and then passes it to SetFilterFiledsL to get assigned all filter keys separately. 

	This function is used to test NewL method of CDecisionFilter

	@param aFlag		 Shows which filter keys have been set 

	@param aClientSid	 Secure Id of client application

	@param aEvaluatorId	 UID for the policy evaluator DLL

	@param aServiceId	 UID for service 

	@param aServerSid	 UID for the system server

	@param aFingerprint	 Hash of the destination and/or opaque data.

	@param aClientEntity The name of the entity within the client that requested the service. 

	@param aMajorPolicyVersion The major version of the policy file.

	@param aRecordId	 An auto-incrementing record number.

	@param aDescription A copy of description and/or opaque

	@param aResult Whether the request should be approved

	@param aEvaluatorInfo Policy evaluator specific data

	@param aComparisonOp Comparison Operator (=,!=,<,> etc.)

	@return				 A pointer to the newly allocated filter object.

 */	

	{

	//Create an empty filter

	CDecisionFilter *filter = CDecisionFilter::NewL();

	CleanupStack::PushL(filter);

	SetFilterFiledsL(*filter, aFlag, aClientSid, aEvaluatorId, aServiceId, aServerSid,aFingerprint, aClientEntity, aMajorPolicyVersion, aRecordId, aDescription, aResult, aEvaluatorInfo, aComparisonOp);

	CleanupStack::Pop(filter);

	return filter;

	}

CDecisionFilter *CUpsDbBaseStep::CreateFilterLC(TInt aFlag, TInt aClientSid, TInt aEvaluatorId, TInt aServiceId, TInt aServerSid, TDesC8 &aFingerprint, TDesC8& aClientEntity,TInt aMajorPolicyVersion, TInt aRecordId, TDesC& aDescription, TInt aResult, TInt aEvaluatorInfo, TComparisonOp aComparisonOp)

/**

	Creates an empty filter object and then calls SetFilterFiledsL to get assigned all filter keys separately. 

	This function is used to test NewLC method of CDecisionFilter

	@see CUpsDbBaseStep::CreateFilterL

	@return A pointer to the newly allocated filter object. The pointer is also put onto the cleanup stack.

 */	

	{

	//Create an empty filter

	CDecisionFilter *filter = CDecisionFilter::NewLC();

	SetFilterFiledsL(*filter, aFlag, aClientSid, aEvaluatorId, aServiceId, aServerSid,aFingerprint, aClientEntity, aMajorPolicyVersion, aRecordId, aDescription, aResult, aEvaluatorInfo, aComparisonOp);

	return filter;

	}

void CUpsDbBaseStep::SetFilterFiledsL(CDecisionFilter &aFilter, TInt aFlag, TInt aClientSid, TInt aEvaluatorId, TInt aServiceId, TInt aServerSid, TDesC8 &aFingerprint, TDesC8& aClientEntity, TInt aMajorPolicyVersion, TInt aRecordId, TDesC& aDescription, TInt aResult, TInt aEvaluatorInfo, TComparisonOp aComparisonOp)

/**

	This method assigns all the fields of a provided filter object with the supplied parameters.

	The method is called by CreateFilterL and CreateFilterLC methods.

	@see CUpsDbBaseStep::CreateFilterL

	@param aFilter Empty decision filter object

 */

	{

	//Sets the variables using aFlag

	if(aFlag & KSetClientSid)

		{

		aFilter.SetClientSid(TSecureId(aClientSid), aComparisonOp);

		}

	if(aFlag & KSetEvaluatorId)

		{

		aFilter.SetEvaluatorId(TUid::Uid(aEvaluatorId),aComparisonOp);

		}

	if(aFlag & KSetServiceId)

		{

		aFilter.SetServiceId(TUid::Uid(aServiceId),aComparisonOp);

		}

	if(aFlag & KSetServerSid)

		{

		aFilter.SetServerSid(TSecureId(aServerSid),aComparisonOp);

		}

	if(aFlag & KSetFingerprint)

		{

		aFilter.SetFingerprintL(aFingerprint,aComparisonOp);

		}

	if(aFlag & KSetClientEntity)

		{

		aFilter.SetClientEntityL(aClientEntity,aComparisonOp);

		}

	if(aFlag & KSetMajorPolicyVersion)

		{

		aFilter.SetMajorPolicyVersion(aMajorPolicyVersion,aComparisonOp);

		}

	if(aFlag & KSetRecordId)

		{

		aFilter.SetRecordId(aRecordId,aComparisonOp);

		}

	if(aFlag & KSetDescription)

		{

		aFilter.SetDescriptionL(aDescription,aComparisonOp);

		}

	if(aFlag & KSetResult)

		{

		aFilter.SetResult(aResult,aComparisonOp);

		}

	if(aFlag & KSetEvaluatorInfo)

		{

		aFilter.SetEvaluatorInfo(aEvaluatorInfo,aComparisonOp);

		}

	}

CDecisionRecord *CUpsDbBaseStep::CreateRecordL(TInt aClientSid, TInt aEvaluatorId, TInt aServiceId, TInt aServerSid, TDesC8 &aFingerprint, TDesC8 &aClientEntity,

											   TDesC &aDecription, TInt aResult, TInt aMajorPolicyVersion, TInt aEvaluatorInfo, TInt aRecordId)

/**

	Creates a decision record from provided parameters.

	@param aClientSid	  Secure Id of client application

	@param aEvaluatorId	  UID for the policy evaluator DLL

	@param aServiceId	  UID for service e.g. sms, mms, telephony, gprs

	@param aServerSid	  UID for the system server that the decision applies to

	@param aFingerprint	  Hash of the destination and/or opaque data. Maximum length is 32 bytes.

	@param aClientEntity  The name of the entity within the client that requested the service. Maximum length is 32 bytes. 

	@param aDescription	  A copy of description and/or opaque. 

	@param aResult		  Whether the request should be approved (=1) or denied (=0)

	@param aMajorPolicyVersion The major version of the policy file.

	@param aEvaluatorInfo Policy evaluator specific data

	@param aRecordId	  An auto-incrementing record number.

	@return				  A pointer to the newly allocated decision record object, if creation is successful.

 */

	{

	CDecisionRecord *newRecord;

	newRecord = CDecisionRecord::NewL(TSecureId(aClientSid),TUid::Uid(aEvaluatorId),TUid::Uid(aServiceId),TSecureId(aServerSid),aFingerprint,aClientEntity,aDecription,aResult,aMajorPolicyVersion,aEvaluatorInfo, aRecordId);

	return newRecord;

	}

void CUpsDbBaseStep::StartTimer(TTime &aTime)

/**

	Assigns current time to the provided parameter

	@param aTime Keeps the current time

 */

	{

	aTime.HomeTime();

	}

void CUpsDbBaseStep::StopTimer(TTime &aStartTime, TInt64 &aElapsedTime)

/**

	Substracts the provided time from current time and returns the elapsed time.

	@param aStartTime First measured time

	@param aElapsedTime The elapsed time from the first measurement

 */

	{

	TTime endTime;

	endTime.HomeTime();

	TTimeIntervalMicroSeconds timeDiff = endTime.MicroSecondsFrom(aStartTime);

	aElapsedTime = timeDiff.Int64();

	if(iLog)

		{

		_LIT8(KMessage,"%Ld");

		iBuffer.AppendFormat(KMessage,aElapsedTime);

		iFile.Write(iBuffer);

		iFile.Write(_L8(";"));

		iBuffer.Zero();

		}

	}

void CUpsDbBaseStep::FillTableL(CDecisionDbW &aUpsDb, TInt aRecordNum, TInt aClientNum, TInt aServiceNum, TInt aServerNum, TInt aEvaluatorNum)

/**

	Fill the decision table with a specified number of decision records.

	The parameteres are used as seeds to create sample decision records. 

	@param aUpsDb		 Handle to the database

	@param aRecordNum	 Number of records which will be inserted into the database

	@param aClientNum	 Number of different clients 

	@param aServiceNum	 Number of different services provided by each server

	@param aServerNum	 Number of different servers

	@param aEvaluatorNum Number of different policy evaluator DLLs

 */

	{

	TSecureId clientId = TSecureId(0);

	TSecureId serverId = TSecureId(0);

	TUid serviceId	 =TUid::Null();

	TUid evaluatorId =TUid::Null();

	TUint8 result = 0;

	TUint16 policyMajorVersion = 2;

	TBuf8<KDbMaxName> bufFP;

	TBuf8<KDbMaxName> bufCE;

	TBuf<KDbMaxName> bufD;

	CDecisionRecord* newRecord = NULL;

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

		{

		bufFP.AppendFormat(KFingerprint,i);

		bufCE.AppendFormat(KClientEntity,i);

		bufD.AppendFormat(KDescription,i);

		CMD5* md5FP = CMD5::NewL();

		CleanupStack::PushL(md5FP);

		CMD5* md5CE = CMD5::NewL();

		CleanupStack::PushL(md5CE);

		clientId=TSecureId(i%aClientNum + aRecordNum);

		serviceId=TUid::Uid(i%aServiceNum + 10000 + aRecordNum);

		serverId =TSecureId(i%aServerNum + 100000 + aRecordNum);

		evaluatorId = TUid::Uid(i%aEvaluatorNum + 1000000 + aRecordNum);

		result = i%2;

		newRecord = CDecisionRecord::NewLC(clientId,evaluatorId,serviceId,serverId,md5FP->Hash(bufFP),md5CE->Hash(bufCE),bufD, result,policyMajorVersion, 0);

		aUpsDb.CreateDecisionL(*newRecord);

		CleanupStack::PopAndDestroy(newRecord);

		CleanupStack::PopAndDestroy(2); //md5FP and md5CE

		bufFP.Zero();

		bufCE.Zero();

		bufD.Zero();

		}

	}

CDecisionDbW *CUpsDbBaseStep::CreateDatabaseLC(TDesC& aDbLocation, RFs& aFs)

/**

	Create a writable decision database object. Prints the consumed time to perform this operation.

	@param aDbLocation Where the database will be created

 */

	{

	TTime startTime;

	//Timer is started

	StartTimer(startTime);

	//Database is created

	CDecisionDbW *upsDb = CDecisionDbW::NewLC(aDbLocation, aFs);

	//Timer is stopped

	TInt64 elapsedTime = 0;

	StopTimer(startTime,elapsedTime);

	INFO_PRINTF2(_L("Decision database created in %Ld microseconds."), elapsedTime);

	return upsDb;

	}

CDecisionRecord *CUpsDbBaseStep::GetDecisionLC(CDecisionDbW &aUpsDb, CDecisionFilter &aFilter)

/**

	Get a decision record from the database. This function uses single record lookup method (RDbTable).

	Prints the consumed time to perform this operation.

	@param aUpsDb Handle to the database

	@param aFilter Filter

 */

	{

	TTime startTime;

	//Timer is started

	StartTimer(startTime);

	CDecisionRecord *retRecord = NULL;

	retRecord = aUpsDb.GetDecisionL(aFilter);

	if(retRecord)

		{

		CleanupStack::PushL(retRecord);

		}

	//Timer is stopped

	TInt64 elapsedTime = 0;

	StopTimer(startTime,elapsedTime);

	if(retRecord)

		{

		INFO_PRINTF2(_L("A single record retrieved in %Ld microseconds."), elapsedTime);

		}

	return retRecord;

	}

void CUpsDbBaseStep::GetDecisionsL(CDecisionDbW &aUpsDb, CDecisionFilter &aFilter, TBool aCancel, RPointerArray<CDecisionRecord>& aRecordList)

/**

   Get a set of decision records from the database. Uses multiple records lookup method (RDbView).

   Prints the consumed time to perform this operation.

 */

	{

	TTime startTime;

	//Timer is started

	StartTimer(startTime);

	CDecisionView *dbView = aUpsDb.CreateViewL(aFilter);

	CleanupStack::PushL(dbView);

	dbView->EvaluateView(iWaiter->iStatus);

	TInt num = 0;

	if(aCancel)

		{

		dbView->Cancel();

		iWaiter->WaitActiveL(KErrCancel);

		}

	else

		{

		iWaiter->WaitActiveL(KErrNone);

		CDecisionRecord *record = NULL;		

		while((record = dbView->NextDecisionL()) != NULL)

			{

			CleanupStack::PushL(record);

			num++;

			aRecordList.AppendL(record);

			CleanupStack::Pop(record);

			}

		}

	//Timer is stopped

	TInt64 elapsedTime = 0;

	StopTimer(startTime,elapsedTime);

	INFO_PRINTF3(_L("%d records retrieved in %Ld microseconds."), num, elapsedTime);

	CleanupStack::PopAndDestroy(dbView);

	}

void CUpsDbBaseStep::RemoveDecisionsL(CDecisionDbW &aUpsDb, CDecisionFilter &aFilter)

/**

	Delete a set of records. Prints the consumed time to perform this operation.

 */

	{

	TTime startTime;

	//Timer is started

	StartTimer(startTime);

	aUpsDb.RemoveDecisionsL(aFilter);

	//Timer is stopped

	TInt64 elapsedTime = 0;

	StopTimer(startTime,elapsedTime);

	INFO_PRINTF2(_L("A set of records deleted in %Ld microseconds."), elapsedTime);

	}

void CUpsDbBaseStep::RemoveAllDecisionsL(CDecisionDbW &aUpsDb, RFs& aFs)

/**

	Deletes all records in the database. Actually delete all database.

	Prints the consumed time to perform this operation.

 */

	{

	TTime startTime;

	//Timer is started

	StartTimer(startTime);

	aUpsDb.DeleteDatabaseL(aFs);

	//Timer is stopped

	TInt64 elapsedTime = 0;

	StopTimer(startTime,elapsedTime);

	INFO_PRINTF2(_L("All records deleted in %Ld microseconds."), elapsedTime);

	}

void CUpsDbBaseStep::InsertRecordL(CDecisionDbW &aUpsDb, CDecisionRecord &aRecord)

/**

	Inserts the provided record into the decision database. Prints the consumed time to perform this operation.

 */

	{

	TTime startTime;

	//Timer is started

	StartTimer(startTime);

	aUpsDb.CreateDecisionL(aRecord);

	//Timer is stopped

	TInt64 elapsedTime = 0;

	StopTimer(startTime,elapsedTime);

	INFO_PRINTF2(_L("A record inserted in %Ld microseconds."), elapsedTime);

	}

void CUpsDbBaseStep::ReadConfigurationFile(TDes &aKeyNotFound)

/**

	Reads the key fileds from the ini file which are used to fill table with a specified number of

	sample records.

	@param aKeyNotFound The appended list of the key names which have not been found

 */

	{

	if(EFalse == GetIntFromConfig(ConfigSection(),KRecordNum, iRecordNum))

		{

		aKeyNotFound.Append(KRecordNum);

		aKeyNotFound.Append(_L(" "));

		}

	else if(EFalse == GetIntFromConfig(ConfigSection(),KServerNum, iServerNum))

		{

		aKeyNotFound.Append(KServerNum);

		aKeyNotFound.Append(_L(" "));

		}

	else if(EFalse == GetIntFromConfig(ConfigSection(),KServiceNum, iServiceNum))

		{

		aKeyNotFound.Append(KServiceNum);

		aKeyNotFound.Append(_L(" "));

		}

	else if(EFalse == GetIntFromConfig(ConfigSection(),KClientNum, iClientNum))

		{

		aKeyNotFound.Append(KClientNum);

		aKeyNotFound.Append(_L(" "));

		}

	else if(EFalse == GetIntFromConfig(ConfigSection(),KEvaluatorNum, iEvaluatorNum))

		{

		aKeyNotFound.Append(KEvaluatorNum);

		aKeyNotFound.Append(_L(" "));

		}

	else if(EFalse == GetIntFromConfig(ConfigSection(),KRetrieveNum, iRetrieveNum))

		{

		aKeyNotFound.Append(KRetrieveNum);

		aKeyNotFound.Append(_L(" "));

		}

	}

TInt CUpsDbBaseStep::ConvertNumber(TDesC& aError)

/**

	Converts error string  to number

	@param aError Error string

*/	

		{

		TInt error = KErrNotFound;

		if(!aError.CompareF(KStrErrNone))

			{

			error = KErrNone;	

			}

		else if(!aError.CompareF(KStrErrUpsBadFingerprintLength))

			{

			error = KErrUpsBadFingerprintLength;

			}

		else if(!aError.CompareF(KStrErrUpsMissingArgument))

			{

			error = KErrUpsMissingArgument;

			}

		else if(!aError.CompareF(KStrErrUpsBadClientEntityLength))

			{

			error = KErrUpsBadClientEntityLength;

			}

		return error;

		}

static void PopulateFingerPrint(TDes8& aBuf, TInt aStart)

	{

	TUint8 *ptr = (TUint8 *)aBuf.Ptr();

	TInt pos;

	TInt value;

	for(pos = 0, value = aStart; pos < KUpsMaxFingerprintLength; ++pos, ++value )

		{

		ptr[pos] = value;

		}

	aBuf.SetLength(pos);	

	}

void CUpsDbBaseStep::TestFingerprintValuesL(CDecisionDbW& aUpsDb)

/**

	Creates a number of decision records by using all characters 

	between 0x01 and 0xFF in Fingerprint value.

 */

	{

	TInt clientId		= 1;

	TInt serverId		= 2;

	TInt serviceId		= 3;

	TInt evaluatorId	= 4;

	TInt evaluatorInfo	= 5;

	TInt result			= 0;

	TInt policyVersion	= 9;

	TInt recordId		= 0;

	CDecisionRecord *record = NULL;

	CDecisionFilter *filter = NULL;

	RPointerArray<CDecisionRecord> recordList;	

	TBuf8<KUpsMaxFingerprintLength> bufFp;

	TBuf8<KUpsMaxClientEntityLength> bufCe;

	TBuf<KUpsDescriptionLength> bufDes;

	bufFp.SetLength(KUpsMaxFingerprintLength);

	bufCe.SetLength(KUpsMaxClientEntityLength);

	TInt flag = KSetClientSid|KSetEvaluatorId|KSetServiceId|KSetServerSid|KSetFingerprint|KSetClientEntity;

	TInt pos = 0;

	for(pos=0; pos <= KUpsDescriptionLength+1; pos+= KUpsMaxFingerprintLength)

		{

		PopulateFingerPrint(bufFp, pos);

		record = CreateRecordL(++clientId,++evaluatorId,++serviceId,++serverId, bufFp, bufCe, bufDes, result, policyVersion, evaluatorInfo, recordId);

		CleanupStack::PushL(record);

		InsertRecordL(aUpsDb,*record);

		filter = CreateFilterLC(flag,clientId,evaluatorId,serviceId,serverId,bufFp,bufCe,policyVersion,recordId,bufDes,result,evaluatorInfo,EEqual);

		CleanupResetAndDestroyPushL(recordList);

		GetDecisionsL(aUpsDb, *filter, EFalse, recordList);

		if(recordList.Count() != 1)

			{

			SetTestStepResult(EFail);

			CleanupStack::PopAndDestroy(3, record);

			break;

			}		

		CleanupStack::PopAndDestroy(3, record);

		}	

	}

void CUpsDbBaseStep::CompactDatabaseL(CDecisionDbW& aUpsDb, TBool aCancel)

/**

	Compacts the decision database.

 */

	{

	TTime startTime;

	//Timer is started

	StartTimer(startTime);

	CDecisionDbCompactor *dbCompact = aUpsDb.PrepareCompactionLC();

	dbCompact->Compact(iWaiter->iStatus);

	if(aCancel)

		{

		dbCompact->Cancel();

		iWaiter->WaitActiveL(KErrCancel);

		}

	else

		{

		iWaiter->WaitActiveL(KErrNone);		

		}

	//Timer is stopped

	TInt64 elapsedTime = 0;

	StopTimer(startTime,elapsedTime);

	if(iWaiter->iStatus == 0)

		{

		INFO_PRINTF2(_L("Compaction has been achieved in %Ld microseconds."), elapsedTime);

		}

	else

		{

		if(!aCancel && iWaiter->iStatus!=KErrCancel)

			{

			ERR_PRINTF1(_L("Failed to compact database!"));

			SetTestStepResult(EFail);		

			}

		}

	CleanupStack::PopAndDestroy(dbCompact);

	}

void CUpsDbBaseStep::UpdateRecordL(CDecisionDbW& aUpsDb, CDecisionFilter& aFilter, CDecisionRecord& aRecord)

/**

	Updates a decision record from the decision database.

	@param aUpsDb A pointer to the decision database object

	@param aFilter Filter used to find the record which will be updated

	@param aRecord New record containing the values which will be updated

 */

	{

	TTime startTime;

	//Timer is started

	StartTimer(startTime);

	if(EFalse == aUpsDb.UpdateDecisionL(aFilter,aRecord))

		{

		SetTestStepResult(EFail);

		User::Leave(KErrNotFound);

		}

	else

		{

		//Timer is stopped

		TInt64 elapsedTime = 0;

		StopTimer(startTime,elapsedTime);

		INFO_PRINTF2(_L("The record was updated in %Ld microseconds."), elapsedTime);	

		}

	}