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