/*

 * 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);	

 		}

 	}