diff -r 000000000000 -r bde4ae8d615e os/security/authorisation/userpromptservice/database/test/tupsdb/source/tupsdbbase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/security/authorisation/userpromptservice/database/test/tupsdb/source/tupsdbbase.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,652 @@ +/* +* 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 + +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 bufFP; + TBuf8 bufCE; + TBuf bufD; + + CDecisionRecord* newRecord = NULL; + + for(TInt i=0; iHash(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& 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 recordList; + TBuf8 bufFp; + TBuf8 bufCe; + TBuf 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); + } + + }