/** * Verify that the synchroniser is called when deleting an icc entry, and that the * deletion of an icc entry fails if the icc is locked. * @param aDb Contact database */ void TestDeleteL(CContactDatabase& aDb) { test.Next(_L("Test delete when ICC locked")); syncChecker->SetDeleteContactResponseL(KErrLocked); TContactItemId iccId=AddIccEntryL(aDb,KUidIccGlobalAdnPhonebook); syncChecker->ResetMethodCallCountsL(); TRAPD(err,aDb.DeleteContactL(iccId)); test(err==KErrLocked); test(syncChecker->ValidateMethodCallCountL() == 2); syncChecker->ResetMethodCallCountsL(); CContactItem* item=aDb.ReadContactLC(iccId); test(syncChecker->ValidateMethodCallCountL() == 1); test(item!=NULL); CleanupStack::PopAndDestroy(item); item=NULL; test.Next(_L("Test successful delete of non-icc entry when ICC locked")); TContactItemId nonIccId=AddContactCardL(aDb); syncChecker->ResetMethodCallCountsL(); TRAP(err,aDb.DeleteContactL(nonIccId)); test(err==KErrNone); test(syncChecker->ValidateMethodCallCountL() == 0); test.Next(_L("Test successful delete")); syncChecker->SetDeleteContactResponseL(KErrNone); syncChecker->ResetMethodCallCountsL(); TRAP(err,aDb.DeleteContactL(iccId)); test(syncChecker->ValidateMethodCallCountL() == 2); test(err==KErrNone); syncChecker->ResetMethodCallCountsL(); TRAP(err,aDb.ReadContactLC(iccId)); test(syncChecker->ValidateMethodCallCountL() == 0); test(err==KErrNotFound); }
void TestReadContactL(CContactDatabase& aDb, TContactItemId aIccId, TContactItemId aNonIccId) { test.Next(_L("Test ReadContactL")); // Successful read of icc entry syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrNone); syncChecker->ResetMethodCallCountsL(); test(syncChecker->ValidateMethodCallCountL() == 0); CContactItem* item=aDb.ReadContactLC(aIccId); test(syncChecker->ValidateMethodCallCountL() == 1); test(item!=NULL); CleanupStack::PopAndDestroy(item); item=NULL; // Unsuccessful read of icc entry because icc locked syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrAccessDenied); syncChecker->ResetMethodCallCountsL(); test(syncChecker->ValidateMethodCallCountL() == 0); TRAPD(err,item=aDb.ReadContactL(aIccId)); test(item==NULL); test(err==KErrAccessDenied); test(syncChecker->ValidateMethodCallCountL() == 1); // successful read of non-icc entry, even though icc locked syncChecker->ResetMethodCallCountsL(); test(syncChecker->ValidateMethodCallCountL() == 0); item=aDb.ReadContactLC(aNonIccId); test(syncChecker->ValidateMethodCallCountL() == 0); test(item!=NULL); CleanupStack::PopAndDestroy(item); item=NULL; }
void CContactsRamTest::AddContactsL(const TInt aNumber) /** Add number of contacts to db, using the system template. @return None @param aNumber number of contacts to be added @pre None @post database now contains aNumber of empty contacts */ { //viewdef that loads all fields CContactItemViewDef *viewAll = CContactItemViewDef::NewLC(CContactItemViewDef::EIncludeFields,CContactItemViewDef::EIncludeHiddenFields); viewAll->AddL(KUidContactFieldMatchAll); CContactTemplate *ttemplate = static_cast< CContactTemplate* >( iContactsDatabase->ReadContactLC( iContactsDatabase->TemplateId(), *viewAll ) ); CContactCard* contact = CContactCard::NewLC(ttemplate); SetManyFieldsL(KFieldValue, KManyFields, contact->CardFields()); for(TInt k = 0; k<aNumber; k++) { iContactsDatabase->AddNewContactL(*contact); } CleanupStack::PopAndDestroy(contact); CleanupStack::PopAndDestroy(ttemplate); CleanupStack::PopAndDestroy(viewAll); }
/** * Create an entry based on the template for this specific phonebook, and add * the entry to the contact database * @param aDb Contact database * @param aPhonebookUid The phonebook uid * @return TContactItemId Id of the newly created icc entry */ TContactItemId doAddIccEntryL(CContactDatabase& aDb,TUid aPhonebookUid) { syncChecker->ResetMethodCallCountsL(); TContactItemId templateId = aDb.ICCTemplateIdL(aPhonebookUid); test(syncChecker->ValidateMethodCallCountL() == 1); CContactItem* iccTemplate = aDb.ReadContactLC(templateId); CContactICCEntry* entry = CContactICCEntry::NewL(*iccTemplate); CleanupStack::PopAndDestroy(iccTemplate); CleanupStack::PushL(entry); // Add to the database CheckPhonebookField(*entry,aPhonebookUid, EFalse); syncChecker->ResetMethodCallCountsL(); TContactItemId id = aDb.AddNewContactL(*entry); test(syncChecker->ValidateMethodCallCountL() == 3); CleanupStack::PopAndDestroy(entry); test(id!=KNullContactId); // Check group membership syncChecker->ResetMethodCallCountsL(); CContactICCEntry* fetchedItem = static_cast<CContactICCEntry*>(aDb.ReadContactL(id)); test(syncChecker->ValidateMethodCallCountL() == 1); CleanupStack::PushL(fetchedItem); const CContactIdArray* owned = fetchedItem->GroupsJoined(); test(owned!=NULL && owned->Count() == 1); test((*owned)[0]==syncChecker->GroupIdL(aPhonebookUid)); test(fetchedItem->Type() == KUidContactICCEntry); // Verify that the phonebook field has been set CheckPhonebookField(*fetchedItem,aPhonebookUid, ETrue); CleanupStack::PopAndDestroy(fetchedItem); return id; }
/** * Test addition to database without adding to a group * @param aDb Contact database */ void TestAddingWithoutGroupL(CContactDatabase& aDb) { TContactItemId templateId = aDb.ICCTemplateIdL(KUidIccGlobalAdnPhonebook); CContactItem* iccTemplate = aDb.ReadContactLC(templateId); CContactICCEntry* entry = CContactICCEntry::NewL(*iccTemplate); CleanupStack::PopAndDestroy(iccTemplate); CleanupStack::PushL(entry); SetNameL(*entry,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,KGivenName,EFalse); SetNameL(*entry,KUidContactFieldPhoneNumber,KUidContactFieldVCardMapTEL,KTelephoneNum,EFalse); syncChecker->ResetMethodCallCountsL(); syncChecker->SetValidateWriteResponseL(KErrNone); TInt oldGroupId = syncChecker->GroupIdL(KUidIccGlobalAdnPhonebook); test(KErrNone == syncChecker->UpdatePhonebookGroupIdL(KUidIccGlobalAdnPhonebook, KNullContactId)); TContactItemId id = aDb.AddNewContactL(*entry); test(syncChecker->ValidateMethodCallCountL() == 3); CleanupStack::PopAndDestroy(entry); CContactICCEntry* fetchedItem = static_cast<CContactICCEntry*>(aDb.ReadContactL(id)); CleanupStack::PushL(fetchedItem); //Check group membership const CContactIdArray* owned = fetchedItem->GroupsJoined(); test(owned==NULL || owned->Count() == 0); CleanupStack::PopAndDestroy(fetchedItem); test(KErrNone == syncChecker->UpdatePhonebookGroupIdL(KUidIccGlobalAdnPhonebook, oldGroupId)); }
void CntThumbnailCreator::initializeThumbnailFieldL() { // Assume the golden template is not changed run-time and fetch it only // when initializeThumbnailFieldL is called for the first time during the // life-time of the CntThumbnailCreator object (requires the instance to // live longer than one thumbnail create operation to be effective, // otherwise we would end up opening contact database and reading the // system template every time a thumbnail is stored for a contact). if(!m_thumbnailFieldFromTemplate) { CContactDatabase *contactDatabase = CContactDatabase::OpenL(); CleanupStack::PushL(contactDatabase); CContactItem *goldenTemplate = contactDatabase->ReadContactLC(KGoldenTemplateId); const CContactItemFieldSet& cardFields = goldenTemplate->CardFields(); // Check if thumbnail field type is KUidContactFieldPictureValue TInt pictureFieldIndex = cardFields.Find(KUidContactFieldPicture, KUidContactFieldVCardMapPHOTO); // Check if thumbnail field type is KUidContactFieldVCardMapJPEG if(pictureFieldIndex == KErrNotFound) { pictureFieldIndex = cardFields.Find(KUidContactFieldVCardMapJPEG, KUidContactFieldVCardMapPHOTO); } if(pictureFieldIndex == KErrNotFound) { // Either KUidContactFieldPictureValue or KUidContactFieldVCardMapJPEG // thumbnail field types should be in the template User::Leave(KErrNotFound); } m_thumbnailFieldFromTemplate = CContactItemField::NewL(cardFields[pictureFieldIndex]); CleanupStack::PopAndDestroy(goldenTemplate); CleanupStack::PopAndDestroy(contactDatabase); } }
/** * To return a valid contact item id. */ TContactItemId CSyncTestStep::GetValidUIDFromContactsDbL() { TContactItemId firstId(KNullContactId); CContactDatabase *iDb = NULL; TRAPD(err,iDb = CContactDatabase::OpenL()); // open existing database CleanupStack::PushL(iDb); if (err != KErrNone) { CleanupStack::PopAndDestroy(); // iDb return firstId; } iDb->SetDbViewContactType(KUidContactICCEntry); // to get the unique groupId for the phonebook TContactItemId groupId(KNullContactId); User::LeaveIfError(iSession.GetPhoneBookId(groupId, RPhoneBookSession::ESyncGroupId)); TESTCHECKCONDITIONL(groupId != KNullContactId); // based on the groupId, get an item belonging to the phonebook CContactGroup* group = static_cast<CContactGroup*>(iDb->ReadContactLC(groupId)); const CContactIdArray* array = group->ItemsContained(); TInt count(array->Count()); if (count > 0) firstId = (*array)[0]; CleanupStack::PopAndDestroy(group); CleanupStack::PopAndDestroy(); // iDb return firstId; }
/** * Test successful addition to database. * @param aDb Contact database */ void TestSuccessfulAddL(CContactDatabase& aDb) { //Create group TContactItemId groupId = CreatePhonebookGroupL(aDb); test(KErrNone == syncChecker->UpdatePhonebookGroupIdL(KUidIccGlobalAdnPhonebook, groupId)); //Create item and add fields TContactItemId templateId = aDb.ICCTemplateIdL(KUidIccGlobalAdnPhonebook); CContactItem* iccTemplate = aDb.ReadContactLC(templateId); CContactICCEntry* entry = CContactICCEntry::NewL(*iccTemplate); CleanupStack::PopAndDestroy(iccTemplate); CleanupStack::PushL(entry); SetNameL(*entry,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,KGivenName,EFalse); SetNameL(*entry,KUidContactFieldPhoneNumber,KUidContactFieldVCardMapTEL,KTelephoneNum,EFalse); //Add to database syncChecker->ResetMethodCallCountsL(); syncChecker->SetValidateWriteResponseL(KErrNone); syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrNone); test(syncChecker->ValidateMethodCallCountL() == 0); TContactItemId id = aDb.AddNewContactL(*entry); CleanupStack::PopAndDestroy(entry); test(syncChecker->ValidateMethodCallCountL() == 3); test(id!=KNullContactId); CContactICCEntry* fetchedItem = static_cast<CContactICCEntry*>(aDb.ReadContactL(id)); CleanupStack::PushL(fetchedItem); //Check group membership const CContactIdArray* owned = fetchedItem->GroupsJoined(); test(owned!=NULL && owned->Count() == 1); test((*owned)[0]==groupId); //Check number of fields and content CContactItemFieldSet& fieldset = fetchedItem->CardFields(); TInt pos = fieldset.Find(KUidContactFieldTemplateLabel); test(pos==KErrNotFound); // test(fieldset.Count() == 3); /* for (TInt i=0; i<fieldset.Count(); i++) { CContactItemField& field = fieldset[i]; TInt count = field.ContentType().FieldTypeCount(); for (TInt j=0; j<count; j++) { TFieldType ft= field.ContentType().FieldType(j); } TUid mapping = field.ContentType().Mapping(); } */ CheckFieldContentL(fieldset,KUidContactFieldFamilyName,KGivenName); // CheckFieldContentL(fieldset,KUidContactFieldPhoneNumber,KTelephoneNum); CleanupStack::PopAndDestroy(fetchedItem); }
void TestCreationL(CContactDatabase& aDb) { _LIT(KTestCreation,"Create CContactICCEntry item"); test.Start(_L("@SYMTESTCaseID:PIM-T-ICCENTRY-0001 Create CContactICCEntry item")); //System Template TContactItemId systemTemplateId = aDb.TemplateId(); CContactItem* systemTemplate = aDb.ReadContactLC(systemTemplateId); CContactICCEntry* entry = CContactICCEntry::NewL(*systemTemplate); CleanupStack::PopAndDestroy(systemTemplate); CleanupStack::PushL(entry); //Test CContactICCEntry items can be identified from normal contact cards test(entry->Type() == KUidContactICCEntry); test(entry->TemplateRefId() == systemTemplateId); CleanupStack::PopAndDestroy(entry); //Create user defined template for ICC contacts test.Next(_L("CContactDatabase::ICCTemplateL()")); TContactItemId templateId = CreateICCTemplateL(aDb); test(KErrNone == syncChecker->UpdatePhonebookEntryL(KUidIccGlobalAdnPhonebook, templateId, KNullContactId)); //Check that contacts model calls the plug-in when asked for the //template ID. TInt callCount = syncChecker->ValidateMethodCallCountL(); test(callCount==0); TContactItemId templateIdFromCntmodel; templateIdFromCntmodel = aDb.ICCTemplateIdL(KUidIccGlobalAdnPhonebook); test(syncChecker->ValidateMethodCallCountL() == 1); test(templateId == templateIdFromCntmodel); CContactItem* iccTemplate = aDb.ReadContactLC(templateId); CheckTemplateL(*iccTemplate); //create ICC contact CContactICCEntry* iccentry = CContactICCEntry::NewL(*iccTemplate); CleanupStack::PopAndDestroy(iccTemplate); CleanupStack::PushL(iccentry); test(iccentry->Type() == KUidContactICCEntry); test(iccentry->TemplateRefId() == templateId); CleanupStack::PopAndDestroy(iccentry); test.End(); }
/** * Verify that adding contact cards doesn't call the synchroniser interface * @param aDb Contact database */ TContactItemId AddContactCardL(CContactDatabase& aDb) { _LIT(KTemplateName,"contact card template"); RArray<TFieldEntry> entries=fieldSetForPhonebook(KUidIccGlobalAdnPhonebook); TContactItemId templateId=CreatePhonebookTemplateL(aDb,KTemplateName,entries); entries.Close(); CContactItem* iccTemplate = aDb.ReadContactLC(templateId); CContactCard* card = CContactCard::NewLC(iccTemplate); syncChecker->ResetMethodCallCountsL(); TContactItemId id=aDb.AddNewContactL(*card); test(syncChecker->ValidateMethodCallCountL() == 0); CleanupStack::PopAndDestroy(2,iccTemplate); return id; }
void TestDatabaseIterationL(CContactDatabase& aDb) { test.Next(_L("Test database iteration")); aDb.SetDbViewContactType(KUidContactICCEntry); TContactIter iterator(aDb); TContactItemId id = iterator.FirstL(); while (id!=KNullContactId) { CContactItem* item = aDb.ReadContactLC(id); test(item->Type() == KUidContactICCEntry); CleanupStack::PopAndDestroy(item); id = iterator.NextL(); } }
/** * Test an unsuccessful addition to the database * @param aDb Contact database */ void TestUnsuccessfulAddL(CContactDatabase& aDb) { TContactItemId templateId = aDb.ICCTemplateIdL(KUidIccGlobalAdnPhonebook); CContactItem* iccTemplate = aDb.ReadContactLC(templateId); CContactICCEntry* entry = CContactICCEntry::NewL(*iccTemplate); CleanupStack::PopAndDestroy(iccTemplate); CleanupStack::PushL(entry); SetNameL(*entry,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,KGivenName,EFalse); SetNameL(*entry,KUidContactFieldPhoneNumber,KUidContactFieldVCardMapTEL,KTelephoneNum,EFalse); syncChecker->ResetMethodCallCountsL(); syncChecker->SetValidateWriteResponseL(KErrAccessDenied); TRAPD(error, aDb.AddNewContactL(*entry)); test(error==KErrAccessDenied); test(syncChecker->ValidateMethodCallCountL() == 1); CleanupStack::PopAndDestroy(entry); }
/** * Verify that the plug-in implementation is called when the * ReadContactL API is used. * * Tests code called by methods: * IMPORT_C CContactItem* ReadContactL(TContactItemId aContactId); * IMPORT_C CArrayPtr<CContactItem>* ReadContactAndAgentL(TContactItemId aContactId); * IMPORT_C CContactItem* ReadContactL(TContactItemId aContactId,const CContactItemViewDef& aViewDef); * IMPORT_C CContactItem* ReadContactLC(TContactItemId aContactId); * IMPORT_C CContactItem* ReadContactLC(TContactItemId aContactId,const CContactItemViewDef& aViewDef); * * @param aDb Contact database * @param aId Contact item ID to read */ void TestReadContactL(CContactDatabase& aDb, TContactItemId aId) { syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrNone); syncChecker->ResetMethodCallCountsL(); test(syncChecker->ValidateMethodCallCountL() == 0); CContactItem* item = aDb.ReadContactLC(aId); test(syncChecker->ValidateMethodCallCountL() == 1); CleanupStack::PopAndDestroy(item); syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrAccessDenied); syncChecker->ResetMethodCallCountsL(); test(syncChecker->ValidateMethodCallCountL() == 0); item=NULL; TRAPD(err, item = aDb.ReadContactL(aId)); delete item; test(err==KErrAccessDenied); test(syncChecker->ValidateMethodCallCountL() == 1); }
/** * Create example ICC Entry * @param aDb Contact database */ TContactItemId CreateTestICCEntryL(CContactDatabase& aDb) { TContactItemId templateId = aDb.ICCTemplateIdL(KUidIccGlobalAdnPhonebook); CContactItem* iccTemplate = aDb.ReadContactLC(templateId); CContactICCEntry* entry = CContactICCEntry::NewL(*iccTemplate); CleanupStack::PopAndDestroy(iccTemplate); CleanupStack::PushL(entry); SetNameL(*entry,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,KGivenName,EFalse); SetNameL(*entry,KUidContactFieldPhoneNumber,KUidContactFieldVCardMapTEL,KTelephoneNum,EFalse); //Add to database syncChecker->SetValidateWriteResponseL(KErrNone); syncChecker->SetValidateResponseL(MContactSynchroniser::ERead,KErrNone); syncChecker->SetDeleteContactResponseL(KErrNone); TContactItemId id = aDb.AddNewContactL(*entry); CleanupStack::PopAndDestroy(entry); test(id!=KNullContactId); return id; }
LOCAL_C void CheckConsistentL (CContactDatabase& aDb, const CContactGroupView& aGroupView, const CContactViewBase& aBaseView, TContactItemId aGroupId) { const TInt groupViewCount = aGroupView.CountL(); test(groupViewCount <= aBaseView.CountL()); CContactGroup* group = static_cast<CContactGroup*>(aDb.ReadContactLC(aGroupId)); const TInt count = aBaseView.CountL(); TInt checked = 0; for (TInt i=0; i < count; ++i) { const TContactItemId id = aBaseView.AtL(i); if (group->ContainsItem(id)) { test(aGroupView.FindL(id) != KErrNotFound); ++checked; } } test(checked == groupViewCount); CleanupStack::PopAndDestroy(group); }
/** Create Multiple Contact Item with field and Add all contact * Item to Contact database. Update the multiple contact item field value and * verify field is being updated. * aValue - field value * @param aStorageType - Storage type of each field * @param aContFieldUid - Uid of Contact field * @param avCardMapUid - Uid of vCard * @return - void */ void CTestUpdateMultipleContactsStep::CreateAndUpdateMultipleContactsL(TPtrC aValue, TInt aStorageType,TUid aContFieldUid, TUid avCardMap) { TPtrC value, updateVal, getUpdateValue; CContactDatabase *dBase = NULL; _LIT(KTestDbName, "c:contactmultiple.cdb"); TInt year, month, day,noOfCI; TContactItemId id = 0; RArray <TInt> idArray; CleanupClosePushL(idArray); //replace existing database name dBase = CContactDatabase::ReplaceL(KTestDbName); //Get the number of contact item from ini file GetIntFromConfig(ConfigSection(), KNoOfContactItem, noOfCI); //Get the int value GetIntFromConfig(ConfigSection(), KIniYear, year); GetIntFromConfig(ConfigSection(), KIniMonth, month); GetIntFromConfig(ConfigSection(), KIniDay, day); // Create contact item and add field to it for(TInt range=0;range<noOfCI;range++) { CContactItem* item = CContactCard::NewLC(); CContactItemField* field = CContactItemField::NewL(aStorageType, aContFieldUid); CleanupStack::PushL(field); field->SetMapping(avCardMap); if(aStorageType==KStorageTypeDateTime) { TDateTime date(year,(TMonth)month,day,0,0,0,0); field->DateTimeStorage()->SetTime(date); } else { field->TextStorage()->SetTextL(aValue); } item->AddFieldL(*field); CleanupStack::Pop(field); // add contact item to database id = dBase->AddNewContactL(*item); idArray.Append(id); CleanupStack::PopAndDestroy(item); } dBase->CloseContactL(id); // Get the value from ini file for update GetStringFromConfig(ConfigSection(), KIniUpdatedvalue, updateVal); GetIntFromConfig(ConfigSection(), KIniUpdateYear, year); GetIntFromConfig(ConfigSection(), KIniUpdateMonth, month); GetIntFromConfig(ConfigSection(), KIniUpdateDay, day); // update multiple contact item field value CContactItem *readItem = NULL; for(TInt readContact=0;readContact<noOfCI;readContact++) { readItem = dBase->ReadContactLC(idArray[readContact]); CContactItemFieldSet& ContactFieldSet = readItem->CardFields(); TInt pos = ContactFieldSet.Find(aContFieldUid, avCardMap); if(pos != KErrNotFound) { if(aStorageType==KStorageTypeDateTime) { // update the field value TDateTime date(year,(TMonth)month,day,0,0,0,0); ContactFieldSet[pos].DateTimeStorage()->SetTime(date); ContactFieldSet.UpdateFieldL(ContactFieldSet[pos],pos); // verify the updated field value TInt upadtePos = ContactFieldSet.Find(aContFieldUid, avCardMap); TDateTime result=ContactFieldSet[upadtePos].DateTimeStorage()->Time().DateTime(); if((result.Year() == year) && (result.Month() == (TMonth)month) && (result.Day() == day)) { SetTestStepResult(EPass); } else { SetTestStepResult(EFail); } } else { // Update the field value ContactFieldSet[pos].TextStorage()->SetTextL(updateVal); ContactFieldSet.UpdateFieldL(ContactFieldSet[pos],pos); // verify the field is being updated TInt upadtePos = ContactFieldSet.Find(aContFieldUid, avCardMap); getUpdateValue.Set(ContactFieldSet[upadtePos].TextStorage()->Text()); //set the results if(getUpdateValue.Compare(updateVal)==0 ) { SetTestStepResult(EPass); } else { SetTestStepResult(EFail); } } } CleanupStack::PopAndDestroy(readItem); } CleanupStack::PopAndDestroy(&idArray); delete dBase; }
void AddEntriesBasedOnEachOfTheTemplatesL(CContactDatabase& aDb) { test.Next(_L("Test successful adding")); TInt numberOfAdnEntries=3; TInt numberOfSdnEntries=2; TInt numberOfLdnEntries=1; TInt numberOfUsimEntries=4; TInt iter=0; for (iter=0; iter<numberOfAdnEntries; ++iter) { TContactItemId id=AddIccEntryL(aDb,KUidIccGlobalAdnPhonebook); CContactGroup* group=static_cast<CContactGroup*>(aDb.ReadContactLC(syncChecker->GroupIdL(KUidIccGlobalAdnPhonebook))); CContactIdArray* entries=group->ItemsContainedLC(); test(entries->Count() == iter+1); CleanupStack::PopAndDestroy(entries); test(group->ContainsItem(id)); CleanupStack::PopAndDestroy(group); } for (iter=0; iter<numberOfSdnEntries; ++iter) { TContactItemId id=AddIccEntryL(aDb,KUidIccGlobalSdnPhonebook); CContactGroup* group=static_cast<CContactGroup*>(aDb.ReadContactLC(syncChecker->GroupIdL(KUidIccGlobalSdnPhonebook))); CContactIdArray* entries=group->ItemsContainedLC(); test(entries->Count() == iter+1); CleanupStack::PopAndDestroy(entries); test(group->ContainsItem(id)); CleanupStack::PopAndDestroy(group); } for (iter=0; iter<numberOfLdnEntries; ++iter) { TContactItemId id=AddIccEntryL(aDb, KUidIccGlobalLndPhonebook); CContactGroup* group=static_cast<CContactGroup*>(aDb.ReadContactLC(syncChecker->GroupIdL(KUidIccGlobalLndPhonebook))); CContactIdArray* entries=group->ItemsContainedLC(); test(entries->Count() == iter+1); CleanupStack::PopAndDestroy(entries); test(group->ContainsItem(id)); CleanupStack::PopAndDestroy(group); } for (iter=0; iter<numberOfUsimEntries; ++iter) { TContactItemId id=AddIccEntryL(aDb,KUidUsimAppAdnPhonebook); CContactGroup* group=static_cast<CContactGroup*>(aDb.ReadContactLC(syncChecker->GroupIdL(KUidUsimAppAdnPhonebook))); CContactIdArray* entries=group->ItemsContainedLC(); test(entries->Count() == iter+1); CleanupStack::PopAndDestroy(entries); test(group->ContainsItem(id)); CleanupStack::PopAndDestroy(group); } // Add an ICC entry based on the system template, not one of the ICC templates TContactItemId templateId=aDb.TemplateId(); CContactItem* systemTemplate = aDb.ReadContactLC(templateId); CContactICCEntry* entry = CContactICCEntry::NewL(*systemTemplate); CleanupStack::PopAndDestroy(systemTemplate); CleanupStack::PushL(entry); syncChecker->ResetMethodCallCountsL(); TContactItemId id = aDb.AddNewContactL(*entry); test(syncChecker->ValidateMethodCallCountL() == 3); syncChecker->ResetMethodCallCountsL(); CContactItem* item=aDb.ReadContactLC(id); test(syncChecker->ValidateMethodCallCountL() == 1); // check the entry hasn't been added to any group CContactIdArray* array=static_cast<CContactICCEntry*>(item)->GroupsJoinedLC(); test(array->Count() == 0); CleanupStack::PopAndDestroy(3); // array, close item, item }