diff -r 000000000000 -r e686773b3f54 phonebookengines/contactsmodel/tsrc/Integration/PerfFuncSuite/src/TransactionsStep.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/phonebookengines/contactsmodel/tsrc/Integration/PerfFuncSuite/src/TransactionsStep.cpp Tue Feb 02 10:12:17 2010 +0200 @@ -0,0 +1,757 @@ +// 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 "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: +// + +/** + @file + @publishedAll + @released +*/ +#include "TransactionsStep.h" +#include "PerformanceFunctionalityDefs.h" + +_LIT(KVcardFile,"c:\\ExportedContacts.vcf"); +const TInt KTransactionSize = 16;//number of crud operations performed within a transaction + +//number of contacts used by transaction performance +const TInt KMinContacts = 10; +const TInt KMidContacts = 100; +const TInt KManyContacts = 300; +const TInt KMaxContacts = 1000; + +const TInt KPerfIter = 1;//number of times performance tests are repeated to get a more accurate average +const TInt KMediumFields = 10;//number of fields to use when a contact is partially filled +const TInt KManyFields = 69;//number of (template-derived) fields in a Contact Item + +_LIT(KRun1,"Nested"); +_LIT(KRun2,"EmptyCommit"); +_LIT(KRun3,"EmptyRevert"); +_LIT(KRun4,"UpdateCommit"); +_LIT(KRun5,"UpdateRevert"); +_LIT(KRun6,"CreateCommit"); +_LIT(KRun7,"CreatRevert"); +_LIT(KRun8,"DeleteCommit"); +_LIT(KRun9,"DeleteRevert"); +_LIT(KRun10,"CudCommit"); +_LIT(KRun11,"CudRevert"); +_LIT(KRun12,"EmptyPerfomance"); +_LIT(KRun13,"EmptyEmptyPerformance"); +_LIT(KRun14,"MediumPerformance"); +_LIT(KRun15,"MediumEmptyPerformance"); +_LIT(KRun16,"FullPerformance"); +_LIT(KRun17,"FullEmptyPerformance"); +_LIT(KRun18,"MultipleCommit"); +_LIT(KRun19,"TransactionMultiple"); + +_LIT(KTest1, "Nested Transaction tests"); +_LIT(KTest2, "Empty; Commit Transaction tests"); +_LIT(KTest3, "Empty; Revert Transaction tests"); +_LIT(KTest4, "Update; Commit Transaction tests"); +_LIT(KTest5, "Update; Revert Transaction tests"); +_LIT(KTest6, "Create; Commit Transaction tests"); +_LIT(KTest7, "Create; Revert Transaction tests"); +_LIT(KTest8, "Delete; Commit Transaction tests"); +_LIT(KTest9, "Delete; Revert Transaction tests"); +_LIT(KTest10, "Many CUD; Commit Transaction tests"); +_LIT(KTest11, "Many CUD; Revert Transaction tests"); +_LIT(KTest12, "***Empty fields; Performance Transaction tests***"); +_LIT(KTest13, "***Empty fields, Empty DB; Performance Transaction tests***"); +_LIT(KTest14, "***Medium fields; Performance Transaction tests***"); +_LIT(KTest15, "***Medium fields, Empty DB; Performance Transaction tests***"); +_LIT(KTest16, "***Full fields; Performance Transaction tests***"); +_LIT(KTest17, "***Full fields, Empty DB; Performance Transaction tests***"); +_LIT(KTest18, "Multiple commit test"); +_LIT(KTest19, "Transaction Multiple commit test"); + +//number of contacts used by this test step +#define KNumberOfContacts 10 + +#ifdef __WINSCW__ +#define KMaxTimeAllowed 500 //seconds, minimum performance +#else +#define KMaxTimeAllowed 10000 //hardware is much slower +#endif + +#define KNumCUDOperations 3 + +_LIT(KMinContactsPrint,"$Min contacts$"); +_LIT(KMidContactsPrint,"$Mid contacts$"); +_LIT(KManyContactsPrint,"$Many contacts$"); +_LIT(KMaxContactsPrint,"$Max contacts$"); + + +CTransactionsStep::CTransactionsStep(CPerformanceFunctionalityTestsSuite &aParent) : CPerformanceFunctionalityBase(KNumberOfContacts, aParent) + { + SetTestStepName(KTransactionsStep); + } + +TVerdict CTransactionsStep::doTestStepPostambleL() + { + const TInt error = iParent->Fs().Delete(KVcardFile); + if( KErrNotFound != error && KErrNone != KErrNone ) + { + _LIT(KDeleteError,"Unexpected error when deleting vcard file, error: %d"); + ERR_PRINTF2(KDeleteError, error); + } + return CPerformanceFunctionalityBase::doTestStepPostambleL(); + } + +void CTransactionsStep::PreTestL() + { + User::LeaveIfError( iParent->Fs().Connect() ); + } + + +TVerdict CTransactionsStep::doTestStepL() +/** + * @return - TVerdict code + * Override of base class pure virtual + * Our implementation only gets called if the base class doTestStepPreambleL() did + * not leave. That being the case, the current test result value will be EPass. + */ + { + __UHEAP_MARK; + InitializeL(); + _LIT(KStartTest,"CTransactionsStep::doTestStepL()"); + ALLPRINT(KStartTest); //Block start + iIterate->Reset(); + + const TDesC &run = ConfigSection(); + + if( run == KRun1 ) + { + ALLPRINT(KTest1); + NestedTransactionTestL(); + } + else if( run == KRun2 ) + { + ALLPRINT(KTest2); + EmptyCommitTransactionTestL(EFalse); + } + else if( run == KRun3 ) + { + ALLPRINT(KTest3); + EmptyCommitTransactionTestL(ETrue); + } + else if( run == KRun4 ) + { + ALLPRINT(KTest4); + UpdateCommitTransactionTestL(EFalse); + } + else if( run == KRun5 ) + { + ALLPRINT(KTest5); + UpdateCommitTransactionTestL(ETrue); + } + else if( run == KRun6 ) + { + ALLPRINT(KTest6); + CreateCommitTransactionTestL(EFalse); + } + else if( run == KRun7 ) + { + ALLPRINT(KTest7); + CreateCommitTransactionTestL(ETrue); + } + else if( run == KRun8 ) + { + ALLPRINT(KTest8); + DeleteCommitTransactionTestL(EFalse); + } + else if( run == KRun9 ) + { + ALLPRINT(KTest9); + DeleteCommitTransactionTestL(ETrue); + } + else if( run == KRun10 ) + { + ALLPRINT(KTest10); + ManyUpdateCommitTransactionTestL(EFalse); + } + else if( run == KRun11 ) + { + ALLPRINT(KTest11); + ManyUpdateCommitTransactionTestL(ETrue); + } + else if( run == KRun12 ) + { + ALLPRINT(KTest12); + EmptyTransactionPerformanceTestL( EFalse); + } + else if( run == KRun13 ) + { + ALLPRINT(KTest13); + EmptyTransactionPerformanceTestL( ETrue ); + } + else if( run == KRun14 ) + { + ALLPRINT(KTest14); + MediumTransactionPerformanceTestL( EFalse); + } + else if( run == KRun15 ) + { + ALLPRINT(KTest15); + MediumTransactionPerformanceTestL( ETrue); + } + else if( run == KRun16 ) + { + ALLPRINT(KTest16); + FullTransactionPerformanceTestL( EFalse); + } + else if( run == KRun17 ) + { + ALLPRINT(KTest17); + FullTransactionPerformanceTestL( ETrue); + } + else if( run == KRun18 ) + { + ALLPRINT(KTest18); + MultipleCommitTestL( EFalse); + } + else if( run == KRun19 ) + { + ALLPRINT(KTest19); + MultipleCommitTestL( ETrue); + } + else + { + MissingTestPanic(); + } + + Cleanup(); + __UHEAP_MARKEND; + + return TestStepResult(); + } + +/** +if in revert mode rollback transaction, otherwise commit +*/ +void CTransactionsStep::EndTransactionL(const TBool aRevert) + { + if(aRevert) + { + iContactsDatabase->DatabaseRollback(); + CleanupStack::Pop(); + if( iContactsDatabase->IsDamaged() ) + { + iContactsDatabase->RecoverL(); + } + } + else + { + iContactsDatabase->DatabaseCommitLP(EFalse); + } + } + +void CTransactionsStep::NestedTransactionTestL() + { + TContactItemId cid = iIterate->NextL(); + + iContactsDatabase->DatabaseBeginLC(EFalse); + iContactsDatabase->DatabaseBeginLC(ETrue); + OpenL(cid); + SetFieldL(1, GetFieldL(KStringFields, KField, 1) ); + CommitL(ETrue); + iContactsDatabase->DatabaseCommitLP(ETrue); + OpenL(cid); + SetFieldL(2, GetFieldL(KStringFields, KField, 2) ); + CommitL(ETrue); + EndTransactionL(ETrue); + + iIterate->Reset(); + TInt err = KErrNone; + TInt k = 0; + TESTPRINT( iContactsDatabase->CountL() == iContacts ); + + for( k = 0; k < iContacts; ++k) + { + TRAP(err, ReadL( iIterate->NextL() ) ); + TESTPRINTI( KErrNone == err, k ); + TESTPRINTI( CheckAllFieldsL(KNullDesC), k ); + CloseL( ETrue ); + } + } + +void CTransactionsStep::EmptyCommitTransactionTestL(const TBool aRevert) + { + CPerformanceFunctionalityBase::InitializeL(); + + iContactsDatabase->DatabaseBeginLC(EFalse); + EndTransactionL(aRevert); + iContactsDatabase->DatabaseBeginLC(EFalse); + ReadL( iIterate->NextL() ); + EndTransactionL(aRevert); + CloseL( ETrue ); + + iIterate->Reset(); + TInt i = 0; + for(; i < iContacts; ++i) + { + ReadL( iIterate->NextL() ); + TESTPRINTI( CheckAllFieldsL(KNullDesC), i ); + CloseL( ETrue ); + } + + } + +void CTransactionsStep::UpdateCommitTransactionTestL(const TBool aRevert) + { + CPerformanceFunctionalityBase::InitializeL(); + + const TContactItemId cid = iIterate->NextL(); + const TContactItemId cid2 = iIterate->NextL(); + + iContactsDatabase->DatabaseBeginLC(EFalse); + OpenL( cid ); + SetAllFieldsL( GetNextFieldL(KStringFields, KField, ETrue) ); + CommitL(ETrue); + EndTransactionL(aRevert); + + iContactsDatabase->DatabaseBeginLC(EFalse); + ReadL( cid2 ); + SetAllFieldsL( GetNextFieldL(KStringFields, KField, EFalse) ); + iContactsDatabase->UpdateContactLC(cid2, iContactItem); + CleanupStack::PopAndDestroy(); + CloseL( ETrue ); + EndTransactionL(aRevert); + + if(aRevert) + { + iIterate->Reset(); + TInt i = 0; + for(; i < iContacts; ++i) + { + ReadL( iIterate->NextL() ); + TESTPRINTI( CheckAllFieldsL(KNullDesC), i ); + CloseL( ETrue ); + } + } + else + { + ReadL( cid ); + TESTPRINT( CheckAllFieldsL( GetNextFieldL(KStringFields, KField, ETrue) ) ); + CloseL( ETrue ); + + ReadL( cid2 ); + TESTPRINT( CheckAllFieldsL( GetNextFieldL(KStringFields, KField, EFalse) ) ); + CloseL( ETrue ); + } + } + +void CTransactionsStep::CreateCommitTransactionTestL(const TBool aRevert) + { + iContacts = 0; + CPerformanceFunctionalityBase::InitializeL(); + + CContactItemFieldSet& templateFields = iTemplate->CardFields(); + TInt fieldsCount = templateFields.Count() - 1; + + iContactsDatabase->DatabaseBeginLC(EFalse); + + iContacts = 2; + TInt k = 0; + CContactCard* contact = CContactCard::NewLC(iTemplate); + for(; k < iContacts; k++) + { + iIterate->AddL( iContactsDatabase->doAddNewContactL(*contact,EFalse,ETrue) ); + } + CleanupStack::PopAndDestroy(contact); + + EndTransactionL(aRevert); + + if(aRevert) + { + iIterate->Reset(); + TInt err = KErrNone; + TESTPRINT( iContactsDatabase->CountL() == 0 ); + + for( k = 0; k < iContacts; ++k) + { + TRAP(err, ReadL( iIterate->NextL() ) ); + TESTPRINTI( KErrNotFound == err, k ); + CloseL( ETrue ); + } + } + else + { + iIterate->Reset(); + TESTPRINT( ( iContactsDatabase->CountL() == iContacts ) ); + + for(k = 0; k < iContacts; ++k) + { + ReadL( iIterate->NextL() ); + TESTPRINTI( iFields->Count() == fieldsCount, k ); + TESTPRINTI( CheckAllFieldsL(KNullDesC), k ); + CloseL( ETrue ); + } + } + } + +void CTransactionsStep::DeleteCommitTransactionTestL(const TBool aRevert) + { + iContacts = 10; + CPerformanceFunctionalityBase::InitializeL(); + iContactsDatabase->DatabaseBeginLC(EFalse); + + TInt k = 0; + for(; k < iContacts; k++) + { + iContactsDatabase->doDeleteContactL(iIterate->NextL(), ETrue, ETrue); + } + + EndTransactionL(aRevert); + + if(aRevert) + { + TESTPRINT( iContactsDatabase->CountL() == iContacts ); + iIterate->Reset(); + TInt err = KErrNone; + for(k = 0; k < iContacts; ++k) + { + TRAP(err, ReadL( iIterate->NextL() ) ); + TESTPRINTI( KErrNone == err, k ); + TESTPRINTI( CheckAllFieldsL( KNullDesC ), k ); + CloseL( ETrue ); + } + } + else + { + TESTPRINT( iContactsDatabase->CountL() == 0 ); + + iIterate->Reset(); + TInt err = KErrNone; + for(k = 0; k < iContacts; ++k) + { + TRAP(err, ReadL( iIterate->NextL() ) ); + TESTPRINTI( KErrNotFound == err, k ); + CloseL( ETrue ); + } + iIterate->Clear(); + } + } + +void CTransactionsStep::ManyUpdateCommitTransactionTestL( const TBool aRevert ) + { + iContacts = 1000; + CPerformanceFunctionalityBase::InitializeL(); + RCntList backuplist; + backuplist.CopyL( *iIterate ); + iContactsDatabase->DatabaseBeginLC(EFalse); + + TInt added = 0; + TInt deleted = 0; + TInt updated = 0; + TInt k = 0; + for(; k < iContacts; k++) + { + switch( k % KNumCUDOperations ) + { + case ( EOpen ): + { + OpenL( iIterate->NextL() ); + //if setting first contact read first field from stringfields section + //otherwise read next field in list of fields stored in ini file secion + SetAllFieldsL( GetNextFieldL(KStringFields, KField, 0 == k ) ); + CommitL(ETrue); + ++updated; + } + break; + case ( EUpdate ): + { + TContactItemId cid = iIterate->NextL(); + ReadL( cid ); + //if setting first contact read first field from stringfields section + //otherwise read next field in list of fields stored in ini file secion + SetAllFieldsL( GetNextFieldL(KStringFields, KField, 0 == k ) ); + iContactsDatabase->UpdateContactLC(cid, iContactItem); + CleanupStack::PopAndDestroy(); + CloseL( ETrue ); + ++updated; + } + break; + case ( EAddDelete ): + { + DeleteContactL( iIterate->NextL(), ETrue ); + //iterator position is shifted back, so that next nextL call is correct + iIterate->PreviousL(); + ++deleted; + //Empty contact is appended to the database, + //Contact id is stored at the end of iterator list not at current iterator position + AddEmptyContactsL( 1, ETrue ); + ++added; + } + break; + default: + { + _LIT(KInvalidTest, "Invalid Case"); + User::Panic(KInvalidTest, 555); + } + break; + } + } + + EndTransactionL(aRevert); + TESTPRINT( iContactsDatabase->CountL() == iContacts ); + + CContactItemFieldSet& templateFields = iTemplate->CardFields(); + TInt fieldsCount = templateFields.Count() - 1; + + if(aRevert) + { + //if transaction is reverted / rolledback, all contacts should be + //unchanged, i.e. they should all contain empty fields only + backuplist.Reset(); + TInt err = KErrNone; + for(k = 0; k < iContacts; ++k) + { + TRAP(err, ReadL( backuplist.NextL() ) ); + TESTPRINTI( KErrNone == err, k ); + TESTPRINTI( CheckAllFieldsL( KNullDesC ), k ); + CloseL( ETrue ); + } + } + else + { + iIterate->Reset(); + //all updated contact should contain the appropriated updated field value + for(k = 0; k < updated; ++k) + { + ReadL( iIterate->NextL() ); + TESTPRINTI(iFields->Count() == fieldsCount, k); + //if reading first contact read first field from stringfields section + //otherwise read next field in list of fields stored in ini file secion + TESTPRINTI( CheckAllFieldsL( GetNextFieldL(KStringFields, KField, 0 == k ) ), k ); + CloseL( ETrue ); + } + + //all newly added contacts, should contain empty fields only. + for(k = 0; k < added; ++k) + { + ReadL( iIterate->NextL() ); + TESTPRINTI( iFields->Count() == fieldsCount, k); + TESTPRINTI( CheckAllFieldsL( KNullDesC ), k); + CloseL( ETrue ); + } + } + } + +void CTransactionsStep::TransactionPerformanceL( const TBool aDelete, + const FieldFullness aField, + const TInt aContacts, + TReal &aDiffseconds, + TReal &aCumseconds) + { + iContacts = ( ( aContacts / KTransactionSize ) + 1 ) * KTransactionSize ; + TInt64 cumlative = 0; + TInt64 diff = 0; + TTime startT; + TTime finishT; + TTime start; + TTime finish; + + TInt j = 0; + for(; j < KPerfIter; ++j) + { + CPerformanceFunctionalityBase::InitializeL(); + ModifyContactsL(aField); + ExportVcardL( aDelete, KVcardFile ); + RFileReadStream rfrs; + CleanupClosePushL( rfrs ); + User::LeaveIfError( rfrs.Open( iParent->Fs(), KVcardFile, EFileRead | EFileShareAny ) ); + + TInt i = 0; + start.UniversalTime(); + for(; i < iContacts; i+=KTransactionSize) + { + iContactsDatabase->DatabaseBeginLC(EFalse); + ImportVcardL(KTransactionSize, rfrs); + startT.UniversalTime(); + iContactsDatabase->DatabaseCommitLP(EFalse); + finishT.UniversalTime(); + cumlative += ( finishT.MicroSecondsFrom( startT ).Int64() ); + } + finish.UniversalTime(); + diff += ( finish.MicroSecondsFrom(start).Int64() ); + CleanupStack::PopAndDestroy(&rfrs); + } + User::LeaveIfError( iParent->Fs().Delete(KVcardFile) ); + + aDiffseconds = (TReal) diff / (1000000 * KPerfIter); + aCumseconds = (TReal) cumlative / (1000000 * KPerfIter); + + _LIT(KMicroPerformance, "Micro performance: %d"); + _LIT(KSecondsPerformance, "performance in seconds: %f"); + _LIT(KCommitPerformance, "commit performance in seconds: %f"); + ALLPRINT2(KMicroPerformance, diff); + ALLPRINT2(KSecondsPerformance, aDiffseconds ); + ALLPRINT2(KCommitPerformance, aCumseconds ); + } + +void CTransactionsStep::EmptyTransactionPerformanceTestL(const TBool aDelete) + { + TReal diffsecondsMax = 0; + TReal commitsecondsMax = 0; + + _LIT(KMaxContactsPrint,"$Max contacts$"); + ALLPRINT(KMaxContactsPrint); + TransactionPerformanceL(aDelete, EEmpty, KMaxContacts, diffsecondsMax, commitsecondsMax); + + TESTPRINT( diffsecondsMax < KMaxTimeAllowed ); + } + +void CTransactionsStep::MediumTransactionPerformanceTestL(const TBool aDelete) + { + TReal diffsecondsMin = 0; + TReal commitsecondsMin = 0; + TReal diffsecondsMid = 0; + TReal commitsecondsMid = 0; + TReal diffsecondsMan = 0; + TReal commitsecondsMan = 0; + TReal diffsecondsMax = 0; + TReal commitsecondsMax = 0; + + ALLPRINT(KMinContactsPrint); + TransactionPerformanceL(aDelete, EMedium, KMinContacts, diffsecondsMin, commitsecondsMin); + ALLPRINT(KMidContactsPrint); + TransactionPerformanceL(aDelete, EMedium, KMidContacts, diffsecondsMid, commitsecondsMid); + ALLPRINT(KManyContactsPrint); + TransactionPerformanceL(aDelete, EMedium, KManyContacts, diffsecondsMan, commitsecondsMan); + ALLPRINT(KMaxContactsPrint); + TransactionPerformanceL(aDelete, EMedium, KMaxContacts, diffsecondsMax, commitsecondsMax); + + + TESTPRINT( diffsecondsMax < KMaxTimeAllowed ); + } + +void CTransactionsStep::FullTransactionPerformanceTestL(const TBool aDelete) + { + TReal diffsecondsMin = 0; + TReal commitsecondsMin = 0; + TReal diffsecondsMid = 0; + TReal commitsecondsMid = 0; + TReal diffsecondsMan = 0; + TReal commitsecondsMan = 0; + TReal diffsecondsMax = 0; +#ifdef __WINSCW__ + TReal commitsecondsMax = 0; +#endif + + ALLPRINT(KMinContactsPrint); + TransactionPerformanceL(aDelete, EFull, KMinContacts, diffsecondsMin, commitsecondsMin); + ALLPRINT(KMidContactsPrint); + TransactionPerformanceL(aDelete, EFull, KMidContacts, diffsecondsMid, commitsecondsMid); + ALLPRINT(KManyContactsPrint); + TransactionPerformanceL(aDelete, EFull, KManyContacts, diffsecondsMan, commitsecondsMan); + //is too slow on hardware, also takes up too much disk space + #ifdef __WINSCW__ + ALLPRINT(KMaxContactsPrint); + TransactionPerformanceL(aDelete, EFull, KMaxContacts, diffsecondsMax, commitsecondsMax); + #endif + + TESTPRINT( diffsecondsMax < KMaxTimeAllowed ); + } + +void CTransactionsStep::MultipleCommitTestL(const TBool aTrans) + { + iContacts = 40; + CPerformanceFunctionalityBase::InitializeL(); + if(aTrans) + { + iContactsDatabase->DatabaseBeginLC(EFalse); + } + MultipleCommitL(aTrans); + if(aTrans) + { + EndTransactionL(EFalse); + } + TInt k = 0; + iIterate->Reset(); + for(; k < iContacts; ++k) + { + ReadL( iIterate->NextL() ); + TESTPRINTI( CheckAllFieldsL( GetNextFieldL(KStringFields, KField, 0 == k ) ), k ); + CloseL( ETrue ); + } + } + +/** +destroy array from within cleanupstack +*/ +static void ArrayCleanup(TAny *aArray) + { + RPointerArray *parray = static_cast< RPointerArray * >(aArray); + parray->ResetAndDestroy(); + } + +void CTransactionsStep::MultipleCommitL(const TBool aTrans) + { + RPointerArray itemarray( 500, 512 ); + TCleanupItem tclean(ArrayCleanup,&itemarray); + CleanupStack::PushL( tclean ); + TInt k = 0; + iIterate->Reset(); + for(; k < iContacts; ++k) + { + itemarray.Append( iContactsDatabase->OpenContactLX( iIterate->NextL(), *iViewAll ) ); + iFields = &( itemarray[k]->CardFields() ); + SetAllFieldsL( GetNextFieldL(KStringFields, KField, 0 == k ) ); + } + + iIterate->Reset(); + if(aTrans) + { + for( k = iContacts - 1; k >=0 ; --k ) + { + iContactsDatabase->doCommitContactL(*itemarray[k], ETrue, ETrue ); + CleanupStack::Pop(); + } + } + else + { + for( k = iContacts - 1; k >=0 ; --k ) + { + iContactsDatabase->CommitContactL(*itemarray[k]); + CleanupStack::Pop(); + } + } + CleanupStack::PopAndDestroy();//tclean + } + +/** +populates all contacts either moderately, fully, or not at all +*/ +void CTransactionsStep::ModifyContactsL(const FieldFullness aField) + { + if(aField == EEmpty) + { + return; + } + iIterate->Reset(); + TInt j = 0; + for(; j < iContacts; ++j) + { + OpenL(iIterate->NextL()); + if(aField == EFull) + { + SetAllFieldsL( GetFieldL(KStringFields, KField, 2) ); + } + else + { + SetManyFieldsL(GetFieldL(KStringFields, KField, 4) , KMediumFields); + } + CommitL(EFalse); + } + } +