/** add agent field to contact b. set value of agent to contact a. export contacts a & b. check access count for a & b(should be 0), check value of agent(should equal b) open contact b, delete all fields. commit. import contacts a and b. check that agent field is not imported. */ void CAccessCountTests::AgentExportImportAccessTestL() { const TContactItemId KFirstContactId = iIterate->NextL();//contact a const TContactItemId KSecondContactId = iIterate->NextL();//contact b //open contact a and populate all fields OpenL(KFirstContactId, *iViewAll); SetContactFieldsL(*iContactItem); CommitL(); //open contact b OpenL(KSecondContactId,*iViewAll); //populate all fields SetContactFieldsL(*iContactItem); //add contact a id as an agent field value AddAgentFieldL(KFirstContactId); CommitL(); CContactIdArray *ArrayOfExportedContactIds = CContactIdArray::NewLC(); //set contact a and b to be export ArrayOfExportedContactIds->AddL(KFirstContactId); ArrayOfExportedContactIds->AddL(KSecondContactId); //export contact a & b ExportVcardL(*ArrayOfExportedContactIds); const TInt KFirstContactAccessCountAfterExport = GetAccessCountL(KFirstContactId); const TInt KSecondContactAccessCountAfterExport = GetAccessCountL(KSecondContactId); const TInt KSecondContactAgentFieldAfterExport = GetAgentFieldL(KSecondContactId); CleanupStack::PopAndDestroy(ArrayOfExportedContactIds); //delete all fields from contact b OpenL(KSecondContactId,*iViewAll); iFields->Reset(); CommitL(); //import exported contacts ImportVcardL(); const TInt KFirstContactAccessCountAfterImport = GetAccessCountL(KFirstContactId); const TInt KSecondContactAccessCountAfterImport = GetAccessCountL(KSecondContactId); const TContactItemId KSecondContactAgentFieldAfterImport = GetAgentFieldL(KSecondContactId); //importing & exporting contacts should not affect the access count INTCOMPARE( KFirstContactAccessCountAfterExport , ==, 0, 0, 0 ); INTCOMPARE( KSecondContactAccessCountAfterExport , ==, 0, 0, 0 ); INTCOMPARE( KFirstContactAccessCountAfterExport , ==, KFirstContactAccessCountAfterImport, 0, 0 ); INTCOMPARE( KSecondContactAccessCountAfterExport , ==, KSecondContactAccessCountAfterImport, 0, 0 ); //agent field values should not be exported/imported INTCOMPARE( KFirstContactId , ==, KSecondContactAgentFieldAfterImport, 0, 0 ); //exporting contacts should not affect the internal state of the contacts agent field INTCOMPARE( KSecondContactAgentFieldAfterExport , ==, KFirstContactId, 0, 0 ); iParent->Fs().Delete(KVcardFile);//cleanup of exported vcard file }
// Creates a few test contacts. void CTestResources::CreateTestContactsL() { TContactItemId id; id = CreateTestContactL(*iDb, _L("Hakkinen"), _L("Mika"), _L("McLaren")); iContacts->AddL(id); id = CreateTestContactL(*iDb, _L("Coulthard"), _L("David"), _L("McLaren")); iContacts->AddL(id); id = CreateTestContactL(*iDb, _L("Schumacher"), _L("Michael"), _L("Ferrari")); iContacts->AddL(id); id = CreateTestContactL(*iDb, _L("Raikkonen"), _L("Kimi"), _L("Sauber")); iContacts->AddL(id); }
CContactIdArray* CPackagerCntFactory::doCreateDefaultCContactIdArrayL() const /** Implementation method for constructing a new default CContactIdArray object. @return a Pointer to the CContactIdArray object. */ { CContactIdArray* theArray = CContactIdArray::NewL(); CleanupStack::PushL(theArray); theArray->AddL(KId1); theArray->AddL(KId2); theArray->AddL(KId3); theArray->AddL(KId4); theArray->AddL(KId5); CleanupStack::Pop(theArray); return theArray; }
void CFilteredViewTester::AddContactsL(TInt aCount) { for (TInt i = 0; i < aCount; ++i) { iIdArray->AddL(DoAddContactL(i)); } }
/** Searches the contacts database to find any contact items with an exact match on the address supplied. @param aCommAddr A descriptor containing the address to be found in the database. @param aAddrType The type of addresses that is being sought. @return An array of contact IDs which match the supplied address. */ CContactIdArray* CPplCommAddrTable::MatchNonPhoneAddrL(const TDesC& aCommAddr, TCommAddrType aAddrType) { // build statement RSqlStatement stmnt; CleanupClosePushL(stmnt); stmnt.PrepareL(iDatabase, iMatchSelectStmnt->SqlStringL() ); const TInt KValueParamIndex(KFirstParam); // first parameter in query... const TInt KTypeParamIndex(KValueParamIndex + 1); // ...and the second. User::LeaveIfError(stmnt.BindText(KValueParamIndex, aCommAddr) ); User::LeaveIfError(stmnt.BindInt(KTypeParamIndex, aAddrType) ); // fetch the list of any matching contact ids CContactIdArray* idArray = CContactIdArray::NewLC(); TInt err(KErrNone); const TInt KContactIdIdx(iMatchSelectStmnt->ParameterIndex(KCommAddrContactId() ) ); while ((err = stmnt.Next() ) == KSqlAtRow) { idArray->AddL(stmnt.ColumnInt(KContactIdIdx) ); } // leave if we didn't complete going through the results properly if(err != KSqlAtEnd) { User::Leave(err); } CleanupStack::Pop(idArray); CleanupStack::PopAndDestroy(&stmnt); return idArray; }
/** exports all contacts items in db to vcard file, if aDelete, cleans database afterwards */ void CPerformanceFunctionalityBase::ExportVcardL(const TBool aDelete, const TDesC &aVCard) { iIterate->Reset(); CContactIdArray *ids = CContactIdArray::NewLC(); TInt i = 0; for(; i < iContacts; ++i) { ids->AddL( iIterate->NextL() ); } RFileWriteStream rfws; CleanupClosePushL(rfws); User::LeaveIfError( rfws.Replace( iParent->Fs(),aVCard , EFileWrite | EFileShareAny ) ); iContactsDatabase->ExportSelectedContactsL( TUid::Uid(KUidVCardConvDefaultImpl), *ids, rfws, CContactDatabase::EIncludeX | CContactDatabase::ETTFormat ); CleanupStack::PopAndDestroy(&rfws); if( aDelete ) { CLEAR( iContactsDatabase ); iContactsDatabase = CContactDatabase::ReplaceL(); } CleanupStack::PopAndDestroy(ids); }
LOCAL_C void DoTestsL() { CleanupClosePushL(test); test.Start(_L("@SYMTESTCaseID:PIM-T-TEMPLATECACHE-0001 ----------- State Tests ----------")); __UHEAP_MARK; RCntModel cntClient; cntClient.ConnectL(); cntClient.OpenDatabase(); CCntTemplateCache* templateCache = CCntTemplateCache::NewL(cntClient); CleanupStack::PushL(templateCache); CContactIdArray* cardTemplateIds = CContactIdArray::NewLC(); // Add 15 templates CContactTemplate* contactTemplate = NULL; TInt ii = 0; for (; ii < 15; ++ii) { contactTemplate = CContactTemplate::NewLC(); cardTemplateIds->AddL(cntClient.CreateContactL(*contactTemplate)); CleanupStack::PopAndDestroy(); // contactTemplate } // Create a contactItem CCntItemBuilder* cntItemBldr = CCntItemBuilder::NewLC(static_cast<CContactTemplate&>(templateCache->SystemTemplateL())); CContactItem* cntItem = cntItemBldr->GetCntItemLC(); /*TContactItemId cntId = */cntClient.CreateContactL(*cntItem); ii = 0; for (; ii < 15; ++ii) { cntItem->SetTemplateRefId((*cardTemplateIds)[ii]); templateCache->MergeWithTemplateL(*cntItem); // Merge a second time... the template should now be cached templateCache->MergeWithTemplateL(*cntItem); } CleanupStack::PopAndDestroy(cntItem); CleanupStack::PopAndDestroy(cntItemBldr); CleanupStack::PopAndDestroy(cardTemplateIds); CleanupStack::PopAndDestroy(templateCache); cntClient.Close(); __UHEAP_MARKEND; test.Next(_L("---- All Tests Completed OK ----")); test.End(); CleanupStack::PopAndDestroy(1); // test.Close }
/** GetListForItemL has a dual nature. If aIsGroup is ETrue, a list of contact items belonging to specified group is returned. Otherwise a list of group ids to which contact id belongs is returned. @param aItemId contact item id @param aIsGroup ETrue if the method will fill a group. */ CContactIdArray* CPplGroupsTable::GetListForItemL(TContactItemId aItemId, TBool aIsGroup) { /* // Check if group membership information was not requested or if the item // is not derived from CContactItemPlusGroup. if (!(aType == KUidContactGroup || aType == KUidContactCard || aType == KUidContactOwnCard || aType == KUidContactICCEntry) ) { return NULL; } */ // build the RSqlStatement RSqlStatement stmnt; CleanupClosePushL(stmnt); TInt idIndex; // build the CCntSqlStatement statement const TInt KWhereParamIndex(KFirstIndex); // only one parameter in the query if (aIsGroup) { // group -> select members stmnt.PrepareL(iDatabase, iSelectMembersStmnt->SqlStringL() ); User::LeaveIfError(stmnt.BindInt(KWhereParamIndex, aItemId ) ); idIndex = stmnt.ColumnIndex(KGroupContactGroupMemberId() ); } else { // member -> select groups stmnt.PrepareL(iDatabase, iSelectGroupsStmnt->SqlStringL() ); User::LeaveIfError(stmnt.BindInt(KWhereParamIndex, aItemId ) ); idIndex = stmnt.ColumnIndex(KGroupContactGroupId() ); } User::LeaveIfError(idIndex); // fetch the list of any matching ids CContactIdArray* items = CContactIdArray::NewLC(); TInt err(KErrNone); while ((err = stmnt.Next() ) == KSqlAtRow) { items->AddL(stmnt.ColumnInt(idIndex) ); } // leave if we didn't complete going through the results properly if(err != KSqlAtEnd) { User::Leave(err); } CleanupStack::Pop(items); CleanupStack::PopAndDestroy(&stmnt); return items; }
/* Creates a random array of numbers corresponding to the Contacts Id in the Contacts model. No Contact Id is repeated */ void CDeleteMany::CreateRandomIdArrayL(CContactIdArray& aUids, TInt aNumIds, TInt aNumEntriesInDb) { TTime now; now.UniversalTime(); TInt64 KRandomSeed = now.DateTime().MicroSecond(); TInt uid(0); for(TInt i = 0; i < aNumIds; ++i) { uid = (Math::Rand(KRandomSeed) % aNumEntriesInDb) + 1; while(aUids.Find(uid) != KErrNotFound) { uid = (Math::Rand(KRandomSeed) % aNumEntriesInDb) + 1; } aUids.AddL(uid); } }
/** Convert between view indexes and contact ids. This method makes the request to the server. @capability ReadUserData */ void RContactRemoteView::GetContactIdsL(const CArrayFix<TInt>& aIndexes, CContactIdArray& aContactIds) { CBufBase* buffer = CBufFlat::NewL(32); CleanupStack::PushL(buffer); RBufWriteStream writeStream(*buffer); CleanupClosePushL(writeStream); const TInt count = aIndexes.Count(); writeStream.WriteUint32L(count); for (TInt i=0; i<count; ++i) { writeStream.WriteUint32L(aIndexes[i]); } writeStream.CommitL(); CleanupStack::PopAndDestroy(&writeStream); //writeStream.Close() TPtr8 indexes(buffer->Ptr(0)); const TInt bufferSize = buffer->Size(); TPckg<TInt> size(bufferSize); HBufC8* buf=HBufC8::NewLC(bufferSize); TPtr8 ids(buf->Des()); TIpcArgs args(&size, &indexes, &ids); User::LeaveIfError(SendReceive(ECntGetContactIds,args)); RDesReadStream readStream(ids); CleanupClosePushL(readStream); CContactIdArray* array = CContactIdArray::NewLC(); readStream >> *array; const TInt arrayCount = array->Count(); for(TInt loop=0;loop<arrayCount;loop++) aContactIds.AddL((*array)[loop]); CleanupStack::PopAndDestroy(4,buffer); //array, &readStream, buf, buffer }
void CTestResources::CreateTestContactsL() { const TInt KContacts = 4; TInt i; iContacts = CContactIdArray::NewL(); // Create contacts for (i=1; i <= KContacts; ++i) { CContactCard* card = CContactCard::NewLC(); CContactItemField* field = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldFamilyName); TBuf<30> name; name.Format(_L("Contact%02d"), i); field->TextStorage()->SetTextL(name); card->AddFieldL(*field); CleanupStack::Pop(field); const TContactItemId contactId = iDb->AddNewContactL(*card); iContacts->AddL(contactId); CleanupStack::PopAndDestroy(card); // Eat away contact db events TContactDbObserverEvent event; test(iDbEventQueue->ListenForEvent(10,event)); } // Create a group CContactItem* group = iDb->CreateContactGroupLC(_L("TestGroup")); iGroupId = group->Id(); CleanupStack::PopAndDestroy(group); // Connect half of the contacts to the group for (i=0; i < iContacts->Count(); ++i) { if (i%2 == 0) { iDb->AddContactToGroupL((*iContacts)[i], iGroupId); } } }
/** Returns an array of contact item IDs for all the contact items which may contain the specified telephone number in a telephone, fax or SMS type field. This is improved version of MatchPhoneNumberL method. The number is compared starting from the right side of the number and the method returns an array of candidate matches. Punctuation (e.g. spaces) and other alphabetic characters are ignored when comparing. Leading zeros are removed. Digits are compared up to the lenght of shorter number. @param aNumber Phone number string. @return Array of contact IDs which are candidate matches. */ CContactIdArray* CPplCommAddrTable::BestMatchingPhoneNumberL(const TDesC& aNumber) { const TInt KUpperMaxLength = KMaxPhoneMatchLength - KLowerSevenDigits; CContactIdArray* phoneMatchArray = CContactIdArray::NewLC(); TMatch phoneDigits = CreatePaddedPhoneDigitsL(aNumber, KLowerSevenDigits, KUpperMaxLength); if (phoneDigits.iNumLowerDigits + phoneDigits.iNumUpperDigits > 0) { // build statement RSqlStatement stmnt; CleanupClosePushL(stmnt); stmnt.PrepareL(iDatabase, iMatchSelectStmnt->SqlStringL()); const TInt KValueParamIndex(KFirstParam); // first parameter in query... const TInt KTypeParamIndex(KValueParamIndex + 1); // ...and the second. User::LeaveIfError(stmnt.BindInt(KValueParamIndex, phoneDigits.iLowerSevenDigits)); User::LeaveIfError(stmnt.BindInt(KTypeParamIndex, EPhoneNumber)); // fetch the list of any matching contact ids TInt err(KErrNone); const TInt KContactIdIdx(iMatchSelectStmnt->ParameterIndex( KCommAddrContactId())); const TInt KExtraValueIdx(iMatchSelectStmnt->ParameterIndex(KCommAddrExtraValue())); while ((err = stmnt.Next()) == KSqlAtRow) { // Check the upper digits... TInt32 number = phoneDigits.iUpperDigits; TPtrC extValString = stmnt.ColumnTextL(KExtraValueIdx); TInt32 storedUpperDigits; User::LeaveIfError(TLex(extValString).Val(storedUpperDigits)); TInt32 stored = storedUpperDigits; TBool nonZeroInStoredFound = EFalse; TBool nonZeroInNumberFound = EFalse; while ((number != 0) && (stored != 0)) { nonZeroInNumberFound |= (number % 10 != 0); nonZeroInStoredFound |= (stored % 10 != 0); if (nonZeroInStoredFound && nonZeroInNumberFound) { break; } number /= 10; stored /= 10; } if ( (phoneDigits.iUpperDigits == 0) || (storedUpperDigits == 0) || (number == stored) ) { phoneMatchArray->AddL(stmnt.ColumnInt(KContactIdIdx)); } } // leave if we didn't complete going through the results properly if (err != KSqlAtEnd) { User::Leave(err); } CleanupStack::PopAndDestroy(&stmnt); } CleanupStack::Pop(phoneMatchArray); return phoneMatchArray; }
/** Returns an array of contact item IDs for all the contact items which may contain the specified telephone number in a telephone, fax or SMS type field. The comparison method used is not exact. The number is compared starting from the right side of the number and the method returns an array of candidate matches. Punctuation (e.g. spaces) and other alphabetic characters are ignored when comparing. Additionally, if the Contacts Model Phone Parser (CNTPHONE.DLL) is available, then any DTMF digits are also excluded from the comparision. Note that due to the way numbers are stored in the database, it is recommended that at least 7 match digits are specified even when matching a number containing fewer digits. Failure to follow this guideline may (depending on the database contents) mean that the function will not return the expected Contact IDs. @param aNumber Phone number string. @param aMatchLengthFromRight Number of digits from the right of the phone number to use. Up to 15 digits can be specified, and it is recommended that at least 7 match digits are specified. @param aDatabase The database. @return Array of contact IDs which are candidate matches. */ CContactIdArray* CPplCommAddrTable::MatchPhoneNumberL(const TDesC& aNumber, const TInt aMatchLengthFromRight) { CContactIdArray* phoneMatchArray = CContactIdArray::NewLC(); TInt numLowerDigits = aMatchLengthFromRight; TInt numUpperDigits = 0; if(numLowerDigits > KLowerSevenDigits) { // New style matching. numLowerDigits = KLowerSevenDigits; numUpperDigits = aMatchLengthFromRight - KLowerSevenDigits; } TMatch phoneDigits = CreatePaddedPhoneDigitsL(aNumber, numLowerDigits, numUpperDigits); if (phoneDigits.iNumLowerDigits + phoneDigits.iNumUpperDigits > 0) { // build statement RSqlStatement stmnt; CleanupClosePushL(stmnt); stmnt.PrepareL(iDatabase, iMatchSelectStmnt->SqlStringL() ); const TInt KValueParamIndex(KFirstParam); // first parameter in query... const TInt KTypeParamIndex(KValueParamIndex + 1); // ...and the second. User::LeaveIfError(stmnt.BindInt(KValueParamIndex, phoneDigits.iLowerSevenDigits )); User::LeaveIfError(stmnt.BindInt(KTypeParamIndex, EPhoneNumber )); // fetch the list of any matching contact ids TInt err(KErrNone); const TInt KContactIdIdx(iMatchSelectStmnt->ParameterIndex(KCommAddrContactId() ) ); const TInt KExtraValueIdx(iMatchSelectStmnt->ParameterIndex(KCommAddrExtraValue() ) ); while ((err = stmnt.Next() ) == KSqlAtRow) { if (aMatchLengthFromRight <= KLowerSevenDigits) { // Matching 7 or less digits...we've already matched. phoneMatchArray->AddL(stmnt.ColumnInt(KContactIdIdx) ); } else { // Check the upper digits... TInt32 storedUpperDigits(0); TPtrC extValString = stmnt.ColumnTextL(KExtraValueIdx); User::LeaveIfError(TLex(extValString).Val(storedUpperDigits) ); const TInt KDigitsToRemove = KMaxPhoneMatchLength - KLowerSevenDigits - phoneDigits.iNumUpperDigits; for(TInt i = 0; i < KDigitsToRemove; ++i) { // repeatedly divide by 10 to lop off the appropriate number of digits from the right storedUpperDigits /= 10; } storedUpperDigits = TMatch::PadOutPhoneMatchNumber(storedUpperDigits, KDigitsToRemove); if (phoneDigits.iUpperDigits == storedUpperDigits) { phoneMatchArray->AddL(stmnt.ColumnInt(KContactIdIdx) ); } } } // leave if we didn't complete going through the results properly if(err != KSqlAtEnd) { User::Leave(err); } CleanupStack::PopAndDestroy(&stmnt); } CleanupStack::Pop(phoneMatchArray); return phoneMatchArray; }
void CGroupViewTester::RunL() { switch (iCurrentTest) { case ECreateLocalView: iLog.LogLine(_L("Creating local view")); iLocalView = CContactLocalView::NewL( *this, iDb, iSortOrder_1, EContactAndGroups ); break; case ECreateGroupOneView: iLog.LogLine(_L("Creating group view one.")); // Create a version 2 object. iGroupViewOne = CContactGroupView::NewL( *iLocalView, iDb, *this, iGroupOne->Id(), CContactGroupView::EShowContactsInGroup ); break; case ECreateGroupTwoView: { iLog.LogLine(_L("Creating group view two.")); iGroupViewTwo = CContactGroupView::NewL( *iLocalView, iDb, *this, KNullContactId, CContactGroupView::EShowContactsNotInAnyGroup ); } break; case EDeleteItemsFromView: { iLog.LogLine(_L("Deleting contacts from group one.")); TInt id1 = 1; TInt index = iGroupViewOne->FindL( id1 ); iLog.LogLine( _L("Deleting contact id %d. index = %d"), id1, index ); TInt id2 = 2; index = iGroupViewOne->FindL( 2 ); iLog.LogLine( _L("Deleting contact id %d. index = %d"), id2, index ); // Delete two contacts using a bulk delete. TInt numContactsInGroup = iGroupViewOne->CountL(); CContactIdArray* itemsToDelete = CContactIdArray::NewL(); CleanupStack::PushL( itemsToDelete ); itemsToDelete->AddL( id1 ); itemsToDelete->AddL( id2 ); iDb.DeleteContactsL( *itemsToDelete ); CleanupStack::PopAndDestroy( itemsToDelete ); break; } case EAddItemToGroup: { iLog.LogLine(_L("Adding contact to database and group one.")); // Create a new item and add it to group one. iIdAdded = iTestConductor->AddRandomContactL(); iDb.AddContactToGroupL( iIdAdded, iGroupOne->Id() ); break; } case ENumTests: // Tests complete. iLog.LogLine(_L("All tests complete.")); CActiveScheduler::Stop(); delete this; break; default: ASSERT( EFalse ); break; } }
void CTestContactsPBAPExport::ExportContactsL() { TInt err = KErrNone; // Retrieve the file name to which contact item is to be exported RFs fsSession; RFileWriteStream writeStream; // connect to file system User::LeaveIfError(fsSession.Connect()); CleanupClosePushL(fsSession); GetInputFromIni(); // Makes one or more directories. fsSession.MkDirAll(iExportTo); // Replaces a single file with another User::LeaveIfError(writeStream.Replace(fsSession, iExportTo, EFileWrite)); INFO_PRINTF1(_L("Exporting Contact.....")); // Existing database TPtrC databaseFile(_L("C:contactDb.cdb")); CContactDatabase* dBase = NULL; CContactIdArray* idArray = NULL; // Open the existing database dBase = CContactDatabase::OpenL(databaseFile); CleanupStack::PushL(dBase); // Create Utility class object, to export the contact from database CTestStep* self = static_cast<CTestStep*>(this); iExportObj = new(ELeave) CContactsPBAPExportUtilityClass(self); SetFilterL(); CCntFilter* exportFilter = CCntFilter::NewL(); CleanupStack::PushL(exportFilter); // Get all the contacts from the database to export exportFilter->SetContactFilterTypeCard(ETrue); dBase->FilterDatabaseL(*exportFilter); idArray = exportFilter->iIds; CleanupStack::PushL(idArray); if(iDamageDb) { #ifdef _DEBUG #ifndef __SYMBIAN_CNTMODEL_USE_SQLITE__ TRAPD(err1,dBase->DamageDatabaseL(0x666)); if(err1 == KErrNone) { TRAPD(err,iExportObj->ExportvCardL(dBase, iStandard, idArray, writeStream, iContactFilter)); INFO_PRINTF2(_L("Err:%d"),err); if(err == KErrNotReady) { SetTestStepResult(EPass); } else { SetTestStepResult(EFail); } if(dBase->IsDamaged()) { dBase->RecoverL(); } } else { INFO_PRINTF2(_L("Could not damage database Err:"),err1); } #else SetTestStepResult(EPass); #endif #endif } else { if(iInvalidFileSystem) { #ifdef _DEBUG fsSession.SetErrorCondition(KErrNotReady); TRAPD(err,iExportObj->ExportvCardL(dBase, iStandard, idArray, writeStream, iContactFilter)); if(err == KErrNotReady) { SetTestStepResult(EPass); } else { SetTestStepResult(EFail); } fsSession.SetErrorCondition(KErrNone); #endif } else { if(!iSetOOM) { if(idArray->Count() > 0) { for(TInt i=0; i<idArray->Count() ; i++) { TInt dCount = dBase->CountL(); if(i>=dCount) { break; } // temporary array used to export one contact at a time CContactIdArray* tempIdArray = CContactIdArray::NewL(); CleanupStack::PushL(tempIdArray); tempIdArray->AddL((*idArray)[i]); TRAPD(err,iExportObj->ExportvCardL(dBase, iStandard, tempIdArray, writeStream, iContactFilter)); if(err != KErrNone ) { if(err != KErrNotFound) { SetTestStepError(err); } } CleanupStack::PopAndDestroy(tempIdArray); } } else { if(idArray->Count()==0) { TRAPD(err,iExportObj->ExportvCardL(dBase, iStandard, idArray, writeStream, iContactFilter)); if(err != KErrNone) { SetTestStepError(err); } } } } else { TInt tryCount = 1; for ( ;; ) { __UHEAP_SETFAIL(RHeap::EDeterministic, tryCount); TRAP(err, iExportObj->ExportvCardL(dBase, iStandard, idArray, writeStream, iContactFilter)); if ( err == KErrNone ) { __UHEAP_RESET; INFO_PRINTF1(_L("OOM testing of CContactDatabase::ExportSelectedContactsL Api is done")); break; } if ( err != KErrNoMemory ) { INFO_PRINTF2(_L("The unexpected error code is:%d"),err); SetTestStepResult(EFail); break; } __UHEAP_SETFAIL(RHeap::ENone, 0); tryCount++; } } } } CleanupStack::Pop(idArray); CleanupStack::PopAndDestroy(exportFilter); INFO_PRINTF1(_L("Exported Contact")); writeStream.CommitL(); writeStream.Close(); INFO_PRINTF2(_L("Total number of contacts in database %d "), dBase->CountL()); // Cleanup CleanupStack::PopAndDestroy(dBase); CleanupStack::PopAndDestroy(&fsSession); }