void CTestResources::CreateTestContactsL()
{
// Create a few test contacts in the db
// - Creating 'prefix' results for 'an'
CContactCard* card;
CContactItemField* field;
card = CContactCard::NewLC();
field = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldGivenName);
field->TextStorage()->SetTextL(_L("Annie"));
card->AddFieldL(*field);
CleanupStack::Pop(field);
iDb->AddNewContactL(*card);
CleanupStack::PopAndDestroy(card);
card = CContactCard::NewLC();
field = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldGivenName);
field->TextStorage()->SetTextL(_L("Anne"));
card->AddFieldL(*field);
CleanupStack::Pop(field);
iDb->AddNewContactL(*card);
CleanupStack::PopAndDestroy(card);
card = CContactCard::NewLC();
field = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldGivenName);
field->TextStorage()->SetTextL(_L("Andrew"));
card->AddFieldL(*field);
CleanupStack::Pop(field);
iDb->AddNewContactL(*card);
CleanupStack::PopAndDestroy(card);
// - Creating 'fullsearch' results for 'an'
card = CContactCard::NewLC();
field = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldGivenName);
field->TextStorage()->SetTextL(_L("Christan"));
card->AddFieldL(*field);
CleanupStack::Pop(field);
iDb->AddNewContactL(*card);
CleanupStack::PopAndDestroy(card);
card = CContactCard::NewLC();
field = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldGivenName);
field->TextStorage()->SetTextL(_L("Adan"));
card->AddFieldL(*field);
CleanupStack::Pop(field);
iDb->AddNewContactL(*card);
CleanupStack::PopAndDestroy(card);
}
void CAsyncTest::TestResultL()
{
CContactDatabase* db = iOpenOp->TakeDatabase();
if(db == NULL)
User::Leave(KErrNotFound);
// Test adding a contact
CContactItemViewDef* matchAll = CContactItemViewDef::NewLC(CContactItemViewDef::EIncludeFields,CContactItemViewDef::EIncludeHiddenFields);
matchAll->AddL(KUidContactFieldMatchAll);
CContactItem* cntTemplate = db->ReadContactL(0, *matchAll);
CleanupStack::PopAndDestroy(matchAll);
CleanupStack::PushL(cntTemplate);
CCntItemBuilder* cntItemBldr = CCntItemBuilder::NewLC(static_cast<CContactTemplate&>(*cntTemplate));
CContactItem* tempCntItem = cntItemBldr->GetCntItemLC();
db->AddNewContactL(*tempCntItem);
CleanupStack::PopAndDestroy(tempCntItem);
CleanupStack::PopAndDestroy(cntItemBldr);
CleanupStack::PopAndDestroy(cntTemplate);
delete iOpenOp;
delete db;
iOpenOp = NULL;
db = NULL;
iTest->Next(_L("Read data from Database\n"));
}
TContactItemId CPbTester::AddEntryL()
{
_LIT(KForename,"John");
_LIT(KSurname,"Smith");
_LIT(KPhoneNumber,"+441617779700");
// Create a contact card to contain the data
CContactCard* newCard = CContactCard::NewLC();
// Create the firstName field and add the data to it
CContactItemField* firstName = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldGivenName);
firstName->TextStorage()->SetTextL(KForename);
newCard->AddFieldL(*firstName);
CleanupStack::Pop(firstName);
// Create the lastName field and add the data to it
CContactItemField* lastName= CContactItemField::NewLC(KStorageTypeText, KUidContactFieldFamilyName);
lastName ->TextStorage()->SetTextL(KSurname);
newCard->AddFieldL(*lastName);
CleanupStack::Pop(lastName);
// Create the phoneNo field and add the data to it
CContactItemField* phoneNumber = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldPhoneNumber);
phoneNumber->SetMapping(KUidContactFieldVCardMapTEL);
phoneNumber ->TextStorage()->SetTextL(KPhoneNumber);
newCard->AddFieldL(*phoneNumber);
CleanupStack::Pop(phoneNumber);
// Add newCard to the database
const TContactItemId contactId = ipbDb->AddNewContactL(*newCard);
CleanupStack::PopAndDestroy(newCard);
return contactId;
}
/**
* 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;
}
TContactItemId CTestResources::CreateTestContactL
(const TDesC& aFamilyName, TBool aWithPhoneNumber)
{
// Create a contact card
CContactCard* card = CContactCard::NewLC();
// Create a name field
CContactItemField* field = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldFamilyName);
field->TextStorage()->SetTextL(aFamilyName);
card->AddFieldL(*field);
CleanupStack::Pop(field);
// Create a phone number field
if (aWithPhoneNumber)
{
// Create a phone number field
CContactItemField* field = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldPhoneNumber);
field->TextStorage()->SetTextL(_L("555"));
card->AddFieldL(*field);
CleanupStack::Pop(field);
}
// Add the contact to the DB
const TContactItemId contactId = iDb->AddNewContactL(*card);
CleanupStack::PopAndDestroy(card);
// Eat away contact db events
TContactDbObserverEvent event;
while
(iDbEventQueue->ListenForEvent(10,event) &&
(event.iType != EContactDbObserverEventContactAdded ||
event.iContactId != contactId))
{
}
iTestContactId = contactId;
return contactId;
}
/**
* 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));
}
//Creates a contact item. Then adds it to the default contacts database.
LOCAL_D TLogContactItemId CreateContactL(const TDesC& aGivenName,
const TDesC& aFamilyName,
const TDesC& aPhoneNumber)
{
CContactItem* item=CContactCard::NewLC();
if (aFamilyName.Length())
SetNameL(*item, KUidContactFieldFamilyName, aFamilyName, ETrue);
if (aGivenName.Length())
SetNameL(*item, KUidContactFieldGivenName, aGivenName, ETrue);
if (aPhoneNumber.Length())
SetNameL(*item, KUidContactFieldPhoneNumber, aPhoneNumber, ETrue);
CContactItemFieldSet& fieldSet= item->CardFields();
TLogContactItemId id = KLogNullContactId;
if (fieldSet.Count())
{
// Open the DB for writing
CContactDatabase* TheContacts = CContactDatabase::OpenL();
CleanupStack::PushL(TheContacts);
id = TheContacts->AddNewContactL(*item);
CleanupStack::PopAndDestroy(); // TheContacts,
}
else
User::Leave(KErrNotSupported);
CleanupStack::PopAndDestroy(item);
return id;
}
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);
}
/**
* Verify that adding contact cards doesn't call the synchroniser interface
* @param aDb Contact database
*/
void TestAddingContactCardL(CContactDatabase& aDb)
{
CContactCard* card = CContactCard::NewLC();
syncChecker->ResetMethodCallCountsL();
aDb.AddNewContactL(*card);
test(syncChecker->ValidateMethodCallCountL() == 0);
CleanupStack::PopAndDestroy(card);
}
/**
* 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);
}
LOCAL_C void LongNumSpeedDialTestsL()
{
_LIT(KLongNumSpeedDialTest, "Long Phone Number Speed Dial Test");
g_test.Start(KLongNumSpeedDialTest);
// create default, empty database
CContactDatabase* db = CContactDatabase::ReplaceL(KLongNumSpeedDialDbName);
CleanupStack::PushL(db);
// create a contact and add it to the db
CContactItem* contact = CContactCard::NewLC();
CContactItemField* fname = CContactItemField::NewLC(KStorageTypeText,
KUidContactFieldGivenName);
_LIT(KFname, "James");
fname->TextStorage()->SetTextL(KFname() );
contact->AddFieldL(*fname);
CleanupStack::Pop(fname);
CContactItemField* phone = CContactItemField::NewLC(KStorageTypeText,
KUidContactFieldPhoneNumber);
_LIT(KPhoneNum, "01234567890123456789012345678901234567890123456789012345678901234567890123456789"); // 80 chars
phone->TextStorage()->SetTextL(KPhoneNum() );
contact->AddFieldL(*phone);
CleanupStack::Pop(phone);
const TContactItemId KContactId = db->AddNewContactL(*contact);
CleanupStack::PopAndDestroy(contact);
contact = NULL;
// retrieve contact and assign its number to speed dial #1
contact = db->OpenContactL(KContactId);
CleanupStack::PushL(contact);
const TInt KSpeedDial1(1);
const TInt KPhoneNumIndex = contact->CardFields().Find(KUidContactFieldPhoneNumber);
db->SetFieldAsSpeedDialL(*contact, KPhoneNumIndex, KSpeedDial1);
TBuf<100> speedDialNumberText;
TContactItemId speedDialId = db->GetSpeedDialFieldL(KSpeedDial1, speedDialNumberText);
_LIT(KOutputFormat, "retrieved speed dial id: %d;\nretrieved speed dial phone number: ...\n%S\n");
g_test.Printf(KOutputFormat, speedDialId, &speedDialNumberText);
db->CloseContactL(KContactId);
// cleanup
CleanupStack::PopAndDestroy(2, db); // and contact
CContactDatabase::DeleteDatabaseL(KLongNumSpeedDialDbName);
// Since PDEF121954, long phone numbers set as speed dial are truncated to
// the length of KSpeedDialPhoneLength. So, we need to get the truncated
// version of the phone number for comparison with the speed dial value.
TPtrC phoneNum(KPhoneNum().Mid(0, KSpeedDialPhoneLength));
g_test(speedDialId == KContactId && speedDialNumberText.CompareC(phoneNum) == 0);
g_test.End();
g_test.Close();
}
LOCAL_C TContactItemId CreateTestContactL
(CContactDatabase& aDb,
const TDesC& aFamilyName,
const TDesC& aGivenName,
const TDesC& aCompanyName)
{
CContactCard* card = CContactCard::NewLC();
AddFieldToContactL(*card, KUidContactFieldFamilyName, aFamilyName);
AddFieldToContactL(*card, KUidContactFieldGivenName, aGivenName);
AddFieldToContactL(*card, KUidContactFieldCompanyName, aCompanyName);
const TContactItemId id = aDb.AddNewContactL(*card);
CleanupStack::PopAndDestroy(card);
return id;
}
/**
* 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 DbCreator::PopulateDatabaseL(CContactDatabase& aDb, TInt aNumContacts)
{
for(TInt i = 0; i < aNumContacts; ++i)
{
CContactCard* contact = CContactCard::NewLC();
// first name
HBufC* fnameBuf = RandomNameL();
CleanupStack::PushL(fnameBuf);
CContactItemField* fname = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldGivenName);
TPtr fnamePtr = fnameBuf->Des();
fname->TextStorage()->SetTextL(fnamePtr);
contact->AddFieldL(*fname);
CleanupStack::Pop(fname);
CleanupStack::PopAndDestroy(fnameBuf);
// last name
HBufC* lnameBuf = RandomNameL();
CleanupStack::PushL(lnameBuf);
CContactItemField* lname = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldFamilyName);
TPtr lnamePtr = lnameBuf->Des();
lname->TextStorage()->SetTextL(lnamePtr);
contact->AddFieldL(*lname);
CleanupStack::Pop(lname);
CleanupStack::PopAndDestroy(lnameBuf);
// company name
HBufC* cnameBuf = RandomNameL();
CleanupStack::PushL(cnameBuf);
CContactItemField* cname = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldCompanyName);
TPtr cnamePtr = cnameBuf->Des();
cname->TextStorage()->SetTextL(cnamePtr);
contact->AddFieldL(*cname);
CleanupStack::Pop(cname);
CleanupStack::PopAndDestroy(cnameBuf);
// phone number
HBufC* numBuf = RandomPhoneNumL();
CleanupStack::PushL(numBuf);
CContactItemField* num = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldPhoneNumber);
TPtr numPtr = numBuf->Des();
num->TextStorage()->SetTextL(numPtr);
contact->AddFieldL(*num);
CleanupStack::Pop(num);
CleanupStack::PopAndDestroy(numBuf);
aDb.AddNewContactL(*contact);
CleanupStack::PopAndDestroy(contact);
}
}
EXPORT_C TContactItemId CTestUtils::CreateContactL(const TDesC& aGivenName, const TDesC& aFamilyName, const TDesC& aPhoneNumber, const TDesC& aEmailAddress, TBool aReplaceContactsDb)
{
CContactDatabase* db = NULL;
if (aReplaceContactsDb)
{
db = CContactDatabase::ReplaceL();
}
else
{
TRAPD(err, db = CContactDatabase::OpenL());
if (err == KErrNotFound)
{
TRAP(err, db = CContactDatabase::CreateL());
}
User::LeaveIfError(err);
}
CleanupStack::PushL(db);
CContactItem* item=CContactCard::NewLC();
if (aFamilyName.Length())
SetNameL(*item, KUidContactFieldFamilyName, aFamilyName, ETrue);
if (aGivenName.Length())
SetNameL(*item, KUidContactFieldGivenName, aGivenName, ETrue);
if (aPhoneNumber.Length())
SetNameL(*item, KUidContactFieldPhoneNumber, aPhoneNumber, ETrue);
if (aEmailAddress.Length())
SetNameL(*item, KUidContactFieldEMail, aEmailAddress, ETrue);
CContactItemFieldSet& fieldSet= item->CardFields();
TContactItemId id = KNullContactId;
if (fieldSet.Count())
id = db->AddNewContactL(*item);
else
User::Leave(KErrNotSupported);
CleanupStack::PopAndDestroy(2); // item, db
return id;
}
/**
* Create a test contact with a Euro character name field.
* This bug can be reproduced with most of the cyrillic characters also.
*/
void CTestResources::CreateTestContactsL()
{
const TInt KContacts = 1;
TInt i;
for (i=1; i <= KContacts; ++i)
{
CContactCard* card = CContactCard::NewLC();
CContactItemField* field = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldFamilyName);
_LIT(KName, "\x20a0"); //Euro character
field->TextStorage()->SetTextL(KName);
card->AddFieldL(*field);
CleanupStack::Pop(field);
iAddedContact = iDb->AddNewContactL(*card);
CleanupStack::PopAndDestroy(card);
}
}
/**
* 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);
}
/**
* 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;
}
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);
}
}
}
TContactItemId CTestResources::AddNewContactL(const TDesC& aGivenName, const TDesC& aFamilyName, const TDesC& aCompanyName)
{
CContactItem* card=CContactCard::NewLC();
// Add first, last and company name fields
CContactItemField* field1 = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldGivenName);
field1->TextStorage()->SetTextL(aGivenName);
card->AddFieldL(*field1);
CleanupStack::Pop(field1);
CContactItemField* field2 = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldFamilyName);
field2->TextStorage()->SetTextL(aFamilyName);
card->AddFieldL(*field2);
CleanupStack::Pop(field2);
CContactItemField* field3 = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldCompanyName);
field3->TextStorage()->SetTextL(aCompanyName);
card->AddFieldL(*field3);
CleanupStack::Pop(field3);
TContactItemId id = iDb->AddNewContactL(*card);
CleanupStack::PopAndDestroy(card);
return id;
}
TContactItemId CFilteredViewTester::DoAddContactL(TInt aOrdinal)
{
TBuf<KTestBufSize> name(_L("MyContact"));
TBuf<KTestBufSize> num1(_L("123456"));
TBuf<KTestBufSize> num2(_L("123457"));
name.AppendNum (aOrdinal);
num1.AppendNum (aOrdinal);
num2.AppendNum (aOrdinal);
CContactCard* card = CContactCard::NewLC();
card->AddFieldL(*CreateFieldLC(KUidContactFieldVCardMapUnusedN, KUidContactFieldGivenName, _L("ContactField")));
CleanupStack::Pop();
card->AddFieldL (*CreateFieldLC(KUidContactFieldVCardMapUnusedN, KUidContactFieldFamilyName, name));
CleanupStack::Pop();
card->AddFieldL (*CreateFieldLC(KUidContactFieldVCardMapTEL, KUidContactFieldPhoneNumber, num1));
CleanupStack::Pop();
card->AddFieldL (*CreateFieldLC(KUidContactFieldVCardMapTELFAX, KUidContactFieldPhoneNumber, num2));
CleanupStack::Pop();
TContactItemId id = iContactDb->AddNewContactL(*card);
CleanupStack::PopAndDestroy(card);
return id;
}
/** 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
}
LOCAL_C void DoTestsL()
{
test.Start(_L("@SYMTESTCaseID:PIM-T-DB-SORTL-TEST-0001 T_DB_SortL_test"));
// create default, empty database
CContactDatabase* db = CContactDatabase::ReplaceL(KDbName);
CleanupStack::PushL(db);
// create contact 1 and add it to the db
CContactCard* contact1 = CContactCard::NewLC();
CContactItemField* fname1 = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldGivenName);
_LIT(KFname1, "Aaron");
fname1->TextStorage()->SetTextL(KFname1() );
contact1->AddFieldL(*fname1);
CleanupStack::Pop(fname1);
CContactItemField* lname1 = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldFamilyName);
_LIT(KLname1, "Zimmerman");
lname1->TextStorage()->SetTextL(KLname1() );
contact1->AddFieldL(*lname1);
CleanupStack::Pop(lname1);
db->AddNewContactL(*contact1);
// create contact 2 and add it to the db
CContactCard* contact2 = CContactCard::NewLC();
CContactItemField* fname2 = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldGivenName);
_LIT(KFname2, "Zachary");
fname2->TextStorage()->SetTextL(KFname2() );
contact2->AddFieldL(*fname2);
CleanupStack::Pop(fname2);
CContactItemField* lname2 = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldFamilyName);
_LIT(KLname2, "Abrahams");
lname2->TextStorage()->SetTextL(KLname2() );
contact2->AddFieldL(*lname2);
CleanupStack::Pop(lname2);
db->AddNewContactL(*contact2);
// fetch and print contact IDs. Expected order: 1, 2
const CContactIdArray* items = db->SortedItemsL(); // doesn't take ownership
_LIT(KFormattedIdList1, "Contact IDs *before* sorting: %d, %d\n");
test.Printf(KFormattedIdList1, (*items)[0], (*items)[1]);
TInt item1BeforeSort = (*items)[0];
TInt item2BeforeSort = (*items)[1];
// create sort order array
CArrayFix<CContactDatabase::TSortPref>* sortOrder = new (ELeave) CArrayFixFlat<CContactDatabase::TSortPref>(2);
CleanupStack::PushL(sortOrder);
sortOrder->AppendL(CContactDatabase::TSortPref(KUidContactFieldFamilyName) );
sortOrder->AppendL(CContactDatabase::TSortPref(KUidContactFieldGivenName) );
// sort db and measure differences in heap allocations as a proxy for
// whether sortOrder has been deleted by SortL() or not.
TInt totalAllocSize(0);
TInt heapCellsDifference = User::AllocSize(totalAllocSize);
db->SortL(sortOrder);
heapCellsDifference -= User::AllocSize(totalAllocSize);
CleanupStack::Pop(sortOrder);
// fetch and print contact IDs. Expected order: 2, 1
items = db->SortedItemsL(); // doesn't take ownership
_LIT(KFormattedIdList2, "Contact IDs *after* sorting: %d, %d\n");
test.Printf(KFormattedIdList2, (*items)[0], (*items)[1]);
TInt item1AfterSort = (*items)[0];
TInt item2AfterSort = (*items)[1];
//check the sort order to make sure
test(item1BeforeSort == item2AfterSort);
test(item2BeforeSort == item1AfterSort);
// check to see if sortOrder is still usable
if (heapCellsDifference == 0)
{
// attempt to re-use sortOrder -- should be allowed after workaround
CContactDatabase::TSortPref sortPref( (*sortOrder)[0]);
_LIT(KSortOrderInfo, "The first sort order preference's field type is: %d.\n");
test.Printf(KSortOrderInfo, sortPref.iFieldType);
_LIT(KYesSame, "Yes, have successfully re-used sortOrder.\n");
test.Printf(KYesSame);
}
else
{
// looks like sortOrder has been deleted so don't try to use it
_LIT(KNoDifferent, "No, have not reused sortOrder as it has probably been deleted.\n");
test.Printf(KNoDifferent);
}
// cleanup
CleanupStack::PopAndDestroy(3, db); // and contact1, contact2
CContactDatabase::DeleteDatabaseL(KDbName);
test.End();
test.Close();
}