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();
}
/** Add first and last name fields to the contact in the format "Given Name #n" and "Family Name #n",
where n is the supplied index.
@param aItem The contact database
@param aIndex The number attached to the first and last names
*/
LOCAL_C void AddNamesL(CContactItem& aItem, TInt aIndex)
{
CContactItemField* field=CContactItemField::NewLC(KStorageTypeText,KUidContactFieldFamilyName);
TBuf<32> text;
text.Format(KCardFamilyName,aIndex);
field->TextStorage()->SetTextL(text);
aItem.AddFieldL(*field);
CleanupStack::Pop(field);
field=CContactItemField::NewLC(KStorageTypeText,KUidContactFieldGivenName);
text.Format(KCardGivenName,aIndex);
field->TextStorage()->SetTextL(text);
aItem.AddFieldL(*field);
CleanupStack::Pop(field);
}
/**
* Create a new template and add it to the database
* @param aDb Contact database
* @param aTemplateName Name for the template
* @param aFieldSet Array of fields which should are added to the template
* @return TContactItemId Id of the newly created template
*/
TContactItemId CreatePhonebookTemplateL(CContactDatabase& aDb, const TDesC& aTemplateName, RArray<TFieldEntry>& aFieldSet)
{
CContactItem* temp = aDb.CreateContactCardTemplateLC(aTemplateName);
TContactItemId templateId = temp->Id();
CleanupStack::PopAndDestroy(temp);
temp=NULL;
//Remove all the unnecessary fields
temp = aDb.OpenContactLX(templateId);
CleanupStack::PushL(temp);
const TInt fieldCount = temp->CardFields().Count();
for(TInt i=fieldCount-1;i>=0;i--)
temp->RemoveField(i);
// Add each of the required fields to the template
for (TInt j=0; j<aFieldSet.Count(); ++j)
{
TFieldEntry fieldEntry=aFieldSet[j];
CContactItemField* field = CContactItemField::NewLC(KStorageTypeText,fieldEntry.iField);
if (fieldEntry.iFieldType!=KNullUid)
field->AddFieldTypeL(fieldEntry.iFieldType);
temp->AddFieldL(*field);
CleanupStack::Pop(field);
}
aDb.CommitContactL(*temp);
CleanupStack::PopAndDestroy(2); // temp, close template
return templateId;
}
TBool CPredictiveSearchSynchronizer::ReadMailAddressesL(CContactItem& aContact)
{
PRINT(_L("CPredictiveSearchSynchronizer::ReadMailAddressesL"));
// SELECT value FROM comm_addr
// WHERE contact_id = [contact id value] AND type = [type value];
_LIT(KSelectMailAddrFormat, "SELECT %S FROM %S WHERE %S = %d AND %S = %d;");
const TInt KContactIdLength = 10;
const TInt KCommAddrTypeLength = 2; // CPplCommAddrTable::EEmailAddress is enum
TInt bufSize = KSelectMailAddrFormat().Length() +
KCommAddrValue().Length() +
KSqlContactCommAddrTableName().Length() +
KCommAddrContactId().Length() +
KContactIdLength +
KCommAddrType().Length() +
KCommAddrTypeLength;
HBufC* sqlStatement = HBufC::NewLC(bufSize);
sqlStatement->Des().AppendFormat(KSelectMailAddrFormat,
&KCommAddrValue,
&KSqlContactCommAddrTableName,
&KCommAddrContactId,
aContact.Id(),
&KCommAddrType,
CPplCommAddrTable::EEmailAddress);
RSqlStatement stmnt;
CleanupClosePushL(stmnt);
PRINT1(_L("prepare SQL statement:%S"), sqlStatement);
stmnt.PrepareL(iDatabase, *sqlStatement);
const TInt KValueIndex = 0;
TBool foundMailAddress(EFalse);
TInt err(KErrNone);
while ((err = stmnt.Next()) == KSqlAtRow)
{
TPtrC value;
if (stmnt.ColumnText(KValueIndex, value) == KErrNone)
{
PRINT2(_L(" id=%d, found mail address=%S"), aContact.Id(), &value);
CContactItemField* field =
CContactItemField::NewLC(KStorageTypeText, KUidContactFieldEMail);
CContactTextField* textfield = field->TextStorage();
textfield->SetTextL(value);
aContact.AddFieldL(*field); // Takes ownership
CleanupStack::Pop(field);
foundMailAddress = ETrue;
}
}
if (err != KSqlAtEnd)
{
PRINT1(_L("CPredictiveSearchSynchronizer::ReadMailAddressesL SQL err=%d"), err);
User::Leave(err);
}
CleanupStack::PopAndDestroy(&stmnt);
CleanupStack::PopAndDestroy(sqlStatement);
PRINT1(_L("CPredictiveSearchSynchronizer::ReadMailAddressesL return %d"), foundMailAddress);
return foundMailAddress;
}
/** Create Contact Item and add field to it and
* verify the field is being added
* aValue - field value
* @param aStorageType - Storage type of each field
* @param aContFieldUid - Uid of Contact field
* @param avCardMapUid - Uid of vCard
* @return - void
*/
void CTestAddFieldsStep::AddFieldsL(TPtrC aValue, TInt aStorageType,TUid aContFieldUid, TUid avCardMap)
{
TPtrC value;
TInt year, month, day;
// Create contact Item and add field to it
CContactItem* item = CContactCard::NewLC();
CContactItemField* field = CContactItemField::NewL(aStorageType, aContFieldUid);
CleanupStack::PushL(field);
field->SetMapping(avCardMap);
if(aStorageType==KStorageTypeDateTime)
{
GetIntFromConfig(ConfigSection(), KIniYear, year);
GetIntFromConfig(ConfigSection(), KIniMonth, month);
GetIntFromConfig(ConfigSection(), KIniDay, day);
TDateTime date(year,(TMonth)month,day,0,0,0,0);
field->DateTimeStorage()->SetTime(date);
}
else
{
field->TextStorage()->SetTextL(aValue);
}
item->AddFieldL(*field);
// verify the field is being added
CContactItemFieldSet& ContactFieldSet = item->CardFields();
TInt pos = ContactFieldSet.Find(aContFieldUid, avCardMap);
if(pos != KErrNotFound)
{
if(aStorageType==KStorageTypeDateTime)
{
TDateTime result=ContactFieldSet[pos].DateTimeStorage()->Time().DateTime();
//compair the results
if((result.Year() == year) && (result.Month() == (TMonth)month) && (result.Day() == day))
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
else
{
value.Set(ContactFieldSet[pos].TextStorage()->Text());
//compair the results
if(aValue.Compare(value)==0 )
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
}
CleanupStack::Pop(field);
CleanupStack::PopAndDestroy(item);
}
LOCAL_C void AddFieldToContactL
(CContactItem& aContact, TFieldType aFieldType, const TDesC& aText)
{
CContactItemField* field = CContactItemField::NewLC(KStorageTypeText, aFieldType);
field->TextStorage()->SetTextL(aText);
aContact.AddFieldL(*field);
CleanupStack::Pop(field);
}
LOCAL_C void TestUpdateContactL()
{
test.Next(_L("TestUpdateContactL"));
SETUP;
CContactItem* contact = CContactItem::NewLC(KUidContactCard);
TContactItemId id = cntClient.CreateContactL(*contact);
CleanupStack::PopAndDestroy(contact);
// View definition to read image field
CContactItemViewDef* imageViewDef = CContactItemViewDef::NewLC(CContactItemViewDef::EIncludeFields, CContactItemViewDef::EMaskHiddenFields);
imageViewDef->AddL(KUidContactFieldMatchAll);
contact = cntClient.OpenContactLX(imageViewDef ,id);
CleanupStack::PushL(contact);
CContactItemField* newField = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldCodImage);
newField->SetMapping(KUidContactFieldVCardMapUnknown);
newField->TextStorage()->SetTextL(KSrcImage());
contact->AddFieldL(*newField); // Takes ownership
CleanupStack::Pop(newField);
cntClient.CommitContactL(*contact, EFalse);
CleanupStack::PopAndDestroy(2); // contact, imageViewDef
// View definition to read image field
imageViewDef = CContactItemViewDef::NewLC(CContactItemViewDef::EIncludeFields, CContactItemViewDef::EMaskHiddenFields);
imageViewDef->AddL(KUidContactFieldCodImage);
contact = cntClient.ReadContactL(imageViewDef ,id);
TInt index = contact->CardFields().Find(KUidContactFieldCodImage, KUidContactFieldVCardMapUnknown);
// Test image field found
test(index != KErrNotFound);
CContactItemField& field = contact->CardFields()[index];
TPtrC imagePtr = field.TextStorage()->Text();
// Image should exist
test(BaflUtils::FileExists(fs, imagePtr));
// Test for GUID
TPtrC guid = contact->Guid();
test(imagePtr.Find(guid));
cntClient.CloseContact(id);
CleanupStack::PopAndDestroy(2); // contact, imageViewDef
TEAR_DOWN;
}
/**
* Create template card for ICC contact items
* @param aDb Contact database
*/
TContactItemId CreateICCTemplateL(CContactDatabase& aDb)
{
CContactItem* temp = aDb.CreateContactCardTemplateLC(KTemplateName);
TContactItemId templateId = temp->Id();
CleanupStack::PopAndDestroy(temp);
temp=NULL;
//Remove all the unnecessary fields
temp = aDb.OpenContactLX(templateId);
CleanupStack::PushL(temp);
const TInt fieldCount = temp->CardFields().Count();
for(TInt i=fieldCount-1;i>=0;i--)
temp->RemoveField(i);
CContactItemField* name = CContactItemField::NewLC(KStorageTypeText,KUidContactFieldFamilyName);
name->SetMapping(KUidContactFieldVCardMapUnusedN);
temp->AddFieldL(*name);
CleanupStack::Pop(name);
CContactItemField* number = CContactItemField::NewLC(KStorageTypeText,KUidContactFieldPhoneNumber);
number->SetMapping(KUidContactFieldVCardMapTEL);
temp->AddFieldL(*number);
CleanupStack::Pop(number);
CContactItemField* slotnum = CContactItemField::NewLC(KStorageTypeText,KUidContactFieldICCSlot);
temp->AddFieldL(*slotnum);
CleanupStack::Pop(slotnum);
CContactItemField* phonebook = CContactItemField::NewLC(KStorageTypeText,KUidContactFieldICCPhonebook);
temp->AddFieldL(*phonebook);
CleanupStack::Pop(phonebook);
aDb.CommitContactL(*temp);
CleanupStack::PopAndDestroy(2); // temp, close template
return templateId;
}
//
// Set the contents of a text field, creating the field if required
//
LOCAL_D void SetNameL(CContactItem& aItem,const TUid& aType,const TDesC& aName, TBool aAddField)
{
CContactItemFieldSet& fieldSet=aItem.CardFields();
const TInt pos=fieldSet.Find(aType);
if (!aAddField && pos!=KErrNotFound)
fieldSet[pos].TextStorage()->SetTextL(aName);
else
{
CContactItemField* field=CContactItemField::NewLC(KStorageTypeText,aType);
field->SetMapping(KUidContactFieldVCardMapUnusedN);
field->TextStorage()->SetTextL(aName);
aItem.AddFieldL(*field);
CleanupStack::Pop(); // field
}
}
/**Utility function for adding agent to a contact item*/
void CAgentTest::MakeAgentL(TContactItemId aMainContactId, TContactItemId aAgentId)
{
CContactItem* mainItem = NULL;
CContactItemField* field = NULL;
mainItem = iDb->OpenContactL(aMainContactId);
CleanupStack::PushL(mainItem);
field = CContactItemField::NewLC(KStorageTypeContactItemId, KUidContactFieldVCardMapAGENT );
field->SetMapping(KUidContactFieldVCardMapAGENT);
field->AgentStorage()->SetAgentId(aAgentId);
mainItem->AddFieldL(*field);
CleanupStack::Pop();
iDb->CommitContactL(*mainItem);
CleanupStack::PopAndDestroy();
}
LOCAL_C void SetNameL(CContactItem& aItem,TUid aVcardType,const TDesC& aName)
//
// Set the contents of a text field, creating the field if required
//
{
CContactItemFieldSet& fieldSet=aItem.CardFields();
const TInt pos=fieldSet.Find(KUidContactFieldFamilyName);
if (pos!=KErrNotFound)
fieldSet[pos].TextStorage()->SetTextL(aName);
else
{
CContactItemField* field=CContactItemField::NewLC(KStorageTypeText,KUidContactFieldFamilyName);
field->SetMapping(aVcardType);
field->TextStorage()->SetTextL(aName);
aItem.AddFieldL(*field);
CleanupStack::Pop(); // item
}
}
EXPORT_C void CTestUtils::SetNameL(CContactItem& aItem,TUid aType,const TDesC& aName, TBool aAddField)
//
// Set the contents of a text field, creating the field if required
//
{
CContactItemFieldSet& fieldSet=aItem.CardFields();
const TInt pos=fieldSet.Find(aType);
if (!aAddField && pos!=KErrNotFound)
fieldSet[pos].TextStorage()->SetTextL(aName);
else
{
CContactItemField* field=CContactItemField::NewLC(KStorageTypeText,aType);
field->SetMapping(KUidContactFieldVCardMapUnusedN);
field->TextStorage()->SetTextL(aName);
aItem.AddFieldL(*field);
CleanupStack::Pop(); // field
}
}
LOCAL_C void TestDeleteContactL()
{
test.Next(_L("TestDeleteContactL"));
SETUP;
CContactItem* contact = CContactItem::NewLC(KUidContactCard);
CContactItemField* newField = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldCodImage);
newField->SetMapping(KUidContactFieldVCardMapUnknown);
newField->TextStorage()->SetTextL(KSrcImage());
contact->AddFieldL(*newField); // Takes ownership
CleanupStack::Pop(newField);
TContactItemId id = cntClient.CreateContactL(*contact);
CleanupStack::PopAndDestroy(contact);
// View definition to read image field
CContactItemViewDef* imageViewDef = CContactItemViewDef::NewLC(CContactItemViewDef::EIncludeFields, CContactItemViewDef::EMaskHiddenFields);
imageViewDef->AddL(KUidContactFieldCodImage);
contact = cntClient.ReadContactL(imageViewDef ,id);
CleanupStack::PopAndDestroy(imageViewDef); // imageViewDef
TInt index = contact->CardFields().Find(KUidContactFieldCodImage, KUidContactFieldVCardMapUnknown);
// Test image field found
test(index != KErrNotFound);
CContactItemField& field = contact->CardFields()[index];
TPtrC imagePtr = field.TextStorage()->Text();
test(BaflUtils::FileExists(fs, imagePtr));
cntClient.DeleteContactL(id, EDeferEvent, ETrue);
test(!BaflUtils::FileExists(fs, imagePtr));
cntClient.CloseContact(id);
delete contact;
TEAR_DOWN;
}
/**
* Add fields that meet some desired sort order
* @param aContact - Contact to be updated woth desired fields
* @param aSortOrder - specifies information about the desired fields
*/
void CTestContactViewCRUDOperationsStep::AddContactFieldL(CContactItem& aContact,
const RContactViewSortOrder& aSortOrder)
{
const TInt KMaxSortOrderCount = 3;
for(TInt i = 0; i < KMaxSortOrderCount; ++i)
{
TFieldType fieldType = aSortOrder[i];
TStorageType storageType = GetStorageType(fieldType);
CContentType* contentType = CContentType::NewL();
CleanupStack::PushL(contentType);
contentType->AddFieldTypeL(fieldType);
CContactItemField* field = CContactItemField::NewL(storageType, *contentType);
CleanupStack::PushL(field);
SetDataL(fieldType, *field);
aContact.AddFieldL(*field);
CleanupStack::Pop(field);
CleanupStack::PopAndDestroy(contentType);
}
}
void CLowDiskSpaceTest::AddContactToDatabaseL()
{
_LIT(KXChar, "x");
CContactItem* item = CContactCard::NewLC();
CContactItemField* field = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldCompanyName);
field->SetMapping(KUidContactFieldVCardMapORG);
field->TextStorage()->SetTextL(KXChar() );
item->AddFieldL(*field);
CleanupStack::Pop(); // field
field = CContactItemField::NewLC(KStorageTypeText,KUidContactFieldPhoneNumber);
field->SetMapping(KUidContactFieldVCardMapTEL);
field->TextStorage()->SetTextL(KXChar() );
item->AddFieldL(*field);
CleanupStack::Pop(); // field
field = CContactItemField::NewLC(KStorageTypeText,KUidContactFieldPhoneNumber);
field->SetMapping(KUidContactFieldVCardMapTEL);
field->TextStorage()->SetTextL(KXChar() );
item->AddFieldL(*field);
CleanupStack::Pop(); // field
field = CContactItemField::NewLC(KStorageTypeText,KUidContactFieldPhoneNumber);
field->SetMapping(KUidContactFieldVCardMapTEL);
field->TextStorage()->SetTextL(KXChar() );
item->AddFieldL(*field);
CleanupStack::Pop(); // field
field = CContactItemField::NewLC(KStorageTypeText,KUidContactFieldPhoneNumber);
field->SetMapping(KUidContactFieldVCardMapTEL);
field->SetHidden(ETrue);
field->TextStorage()->SetTextL(KXChar() );
item->AddFieldL(*field);
CleanupStack::Pop(); // field
field = CContactItemField::NewLC(KStorageTypeText,KUidContactFieldSuffixName);
field->SetMapping(KUidContactFieldVCardMapUnusedN);
field->TextStorage()->SetTextL(KXChar() );
item->AddFieldL(*field);
CleanupStack::Pop(); // field
field=CContactItemField::NewLC(KStorageTypeText,KUidContactFieldPrefixName);
field->SetMapping(KUidContactFieldVCardMapUnusedN);
field->TextStorage()->SetTextL(KXChar() );
item->AddFieldL(*field);
CleanupStack::Pop(); // field
iContactDatabase->AddNewContactL(*item);
CleanupStack::PopAndDestroy(); // item
}
LOCAL_C void AddFieldToGroup()
{
//
test.Next(_L("Add Field to Group"));
// assumes Prior Knowldege of KLargeSizeRecords+6 is a group
CContactItem* group = CntTest->Db()->OpenContactL(KLargeSizeRecords+6);
CleanupStack::PushL(group);
CContactItemField* field=CContactItemField::NewLC(KStorageTypeText);
field->SetMapping(KUidContactFieldVCardMapUnusedN);
field->TextStorage()->SetTextL(_L("Test Field"));
group->AddFieldL(*field);
//
CntTest->Db()->CommitContactL(*group);
CntTest->CloseDatabase();
CntTest->OpenDatabaseL();
CContactItem* group2 = CntTest->Db()->OpenContactL(KLargeSizeRecords+6);
CContactItemFieldSet& tempFieldSet = group2->CardFields();
test(tempFieldSet.Count()==2);
CntTest->Db()->CloseContactL(KLargeSizeRecords+6);
delete group2;
CleanupStack::Pop(); // field
CleanupStack::PopAndDestroy(); // group
}
void CTestContactViewCRUDOperationsStep::AddMatchingStringToContactL(CContactItem& aContact)
{
_LIT(KDesiredMatchingString, "matchingstring");
TPtrC desiredMatchingString;
GetStringFromConfig(ConfigSection(), KDesiredMatchingString, desiredMatchingString);
_LIT(KDesiredContactField, "contactfield");
TPtrC desiredContactField;
GetStringFromConfig(ConfigSection(), KDesiredContactField, desiredContactField);
TUid uidInfo = GetContactFieldType(desiredContactField);
CContactItemFieldSet& fieldSet = aContact.CardFields();
TInt pos = fieldSet.Find(uidInfo);
if(pos == KErrNotFound)
{
TFieldType fieldType = uidInfo;
TStorageType storageType = GetStorageType(fieldType);
CContentType* contentType = CContentType::NewL();
CleanupStack::PushL(contentType);
contentType->AddFieldTypeL(fieldType);
CContactItemField* field = CContactItemField::NewL(storageType, *contentType);
CleanupStack::PushL(field);
field->TextStorage()->SetTextL(desiredMatchingString);
aContact.AddFieldL(*field);
CleanupStack::Pop(field);
CleanupStack::PopAndDestroy(contentType);
}
else
{
CContactItemField& field = fieldSet[pos];
field.TextStorage()->SetTextL(desiredMatchingString);
}
}
void CPredictiveSearchSynchronizer::CreatePredSearchTablesL(TBool aAllTables)
{
PRINT1(_L("CPredictiveSearchSynchronizer::CreatePredSearchTablesL all=%d"), aAllTables);
if (aAllTables)
{
i12keyTable.CreateTableL();
iSettingsTable.CreateTableL();
iSettingsTable.StoreCurrentLanguageL();
}
iQwertyTable.CreateTableL();
_LIT(KSelectAllContactsFormat, "SELECT %S,%S,%S FROM %S;");
TInt bufSize = KSelectAllContactsFormat().Length() +
KContactId().Length() +
KContactFirstName().Length() +
KContactLastName().Length() +
KSqlContactTableName().Length();
HBufC* sqlStatement = HBufC::NewLC(bufSize);
sqlStatement->Des().AppendFormat(KSelectAllContactsFormat,
&KContactId,
&KContactFirstName,
&KContactLastName,
&KSqlContactTableName);
RSqlStatement stmnt;
CleanupClosePushL(stmnt);
PRINT1(_L("CreatePredSearchTablesL prepare SQL statement:%S"), sqlStatement);
stmnt.PrepareL(iDatabase, *sqlStatement);
const TInt KContactIdIndex = 0;
const TInt KFirstNameIndex = 1;
const TInt KLastNameIndex = 2;
TInt err(KErrNone);
while ((err = stmnt.Next()) == KSqlAtRow)
{
PRINT(_L("CreatePredSearchTablesL create CContactItem"));
TInt id = KUidContactCardValue;
TUid uid;
uid.iUid = id;
CContactItem* contact = CContactItem::NewLC(uid);
contact->SetId(stmnt.ColumnInt(KContactIdIndex));
// If first name exists, write it to contact item
TPtrC firstName;
if (stmnt.ColumnText(KFirstNameIndex, firstName) == KErrNone)
{
CContactItemField* field =
CContactItemField::NewLC(KStorageTypeText, KUidContactFieldGivenName);
CContactTextField* textfield = field->TextStorage();
textfield->SetTextL(firstName);
contact->AddFieldL(*field); // Takes ownership
CleanupStack::Pop(field);
}
TPtrC lastName;
if (stmnt.ColumnText(KLastNameIndex, lastName) == KErrNone)
{
CContactItemField* field =
CContactItemField::NewLC(KStorageTypeText, KUidContactFieldFamilyName);
CContactTextField* textfield = field->TextStorage();
textfield->SetTextL(lastName);
contact->AddFieldL(*field); // Takes ownership
CleanupStack::Pop(field);
}
PRINT(_L("CreatePredSearchTablesL create entry to tables"));
if (aAllTables)
{
i12keyTable.CreateInDbL(*contact);
}
if (ReadMailAddressesL(*contact))
{
iQwertyTable.CreateInDbL(*contact);
}
CleanupStack::PopAndDestroy(contact);
}
// Leave if we didn't complete going through the results properly
if (err != KSqlAtEnd)
{
PRINT1(_L("CreatePredSearchTablesL SQL err=%d"), err);
User::Leave(err);
}
CleanupStack::PopAndDestroy(&stmnt);
CleanupStack::PopAndDestroy(sqlStatement);
PRINT(_L("CPredictiveSearchSynchronizer::CreatePredSearchTablesL ends"));
}
void T_CntImageRescaler::testRescaleUtility()
{
// delete the possible image directory, it must not leave
// even if the folder was not found.
TRAPD( err, TCntImageRescaleUtility::DeleteImageDirectoryL() );
test( err == KErrNone );
// path for image directory, existense of the directory is not
// checked
TPath path = TCntImageRescaleUtility::ImageDirectoryL();
test( path.Length() > 0 );
test( path.Find(KImagesFolder) != KErrNotFound );
TPath dir = TCntImageRescaleUtility::CreateImageDirectoryL();
test( dir.Length() > 0 );
test( dir.Find( KImagesFolder) != KErrNotFound );
// make a test image file (empty file)
RFs fs;
CleanupClosePushL( fs );
User::LeaveIfError( fs.Connect() );
TPath imagePath;
imagePath.Append( dir );
imagePath.Append( KImageName );
RFile file;
CleanupClosePushL(file);
User::LeaveIfError(file.Create( fs, imagePath, EFileWrite ));
CleanupStack::PopAndDestroy();
CContactItem* item = CContactItem::NewLC(KUidContactCard);
CContactItemField* field = CContactItemField::NewL( KStorageTypeText, KUidContactFieldCodImage );
field->SetMapping( KUidContactFieldVCardMapUnknown );
item->AddFieldL( *field );
// add image without GUID
TRAPD( err2, TCntImageRescaleUtility::StoreImageFieldL( *item, imagePath ) );
test( err2 == KErrNone );
// then update with GUID value
_LIT(KGuid, "guid");
TBufC<4> buffer ( KGuid );
item->SetUidStringL( buffer );
TRAPD( err3, TCntImageRescaleUtility::UpdateImageNameL( *item ) );
test( err3 == KErrNone );
CContactItemFieldSet& fields = item->CardFields();
TInt privateImageIndex = fields.Find( KUidContactFieldCodImage, KUidContactFieldVCardMapUnknown );
test( privateImageIndex != KErrNotFound );
TPtrC fieldText = fields[privateImageIndex].TextStorage()->Text();
// how it should look like
TPath newPath;
newPath.Append( TCntImageRescaleUtility::ImageDirectoryL() );
newPath.Append( buffer );
newPath.Append( KImageName );
RDebug::Print( _L("%S"), &newPath );
RDebug::Print( _L("%S"), &fieldText );
test( newPath.Compare(fieldText) == 0 );
BaflUtils::DeleteFile( fs, newPath );
CleanupStack::PopAndDestroy(2); // item, RFs
}
/** Create Multiple Contact Item with field and Add all contact
* Item to Contact database. verify field is
* being added
* aValue - field value
* @param aStorageType - Storage type of each field
* @param aContFieldUid - Uid of Contact field
* @param avCardMapUid - Uid of vCard
* @return - void
*/
void CTestAddMultipleContactsStep::AddMultipleContactsL(TPtrC aValue, TInt aStorageType,TUid aContFieldUid, TUid avCardMap)
{
TPtrC value;
_LIT(KTestDbName, "c:contactmultiple.cdb");
TInt year, month, day,noOfCI;
RArray <TInt> idArray;
CleanupClosePushL(idArray);
//replace existing database name
database = 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 = database->AddNewContactL(*item);
//append the id in array
idArray.Append(id);
//Cleanup
CleanupStack::PopAndDestroy(item);
}
database->CloseContactL(id);
// verify for multiple contact item with field is being created
CContactItem *readItem = NULL;
for(TInt readContact=0;readContact<noOfCI;readContact++)
{
readItem = database->ReadContactL(idArray[readContact]);
CleanupStack::PushL(readItem);
CContactItemFieldSet& ContactFieldSet = readItem->CardFields();
TInt pos = ContactFieldSet.Find(aContFieldUid, avCardMap);
if(pos != KErrNotFound)
{
if(aStorageType==KStorageTypeDateTime)
{
TDateTime result=ContactFieldSet[pos].DateTimeStorage()->Time().DateTime();
if((result.Year() == year) && (result.Month() == (TMonth)month) && (result.Day() == day))
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
else
{
value.Set(ContactFieldSet[pos].TextStorage()->Text());
//compare the results
if(aValue.Compare(value)==0 )
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
}
CleanupStack::PopAndDestroy(readItem);
}
// Cleanup
CleanupStack::PopAndDestroy(&idArray);
delete database;
}
void CTestAddMultipleContactsStep::OpenExistingContactL(TPtrC aValue, TInt aStorageType,TUid aContFieldUid, TUid avCardMap)
{
TPtrC value,fielddel;
_LIT(KTestDbName, "c:contactexist.cdb");
_LIT(KExistDelete, "exist");
TInt year, month, day;
// Create contact item and add field to it
CContactItem* item = CContactCard::NewLC();
CContactItemField* field = CContactItemField::NewL(aStorageType, aContFieldUid);
CleanupStack::PushL(field);
field->SetMapping(avCardMap);
if(aStorageType==KStorageTypeDateTime)
{
GetIntFromConfig(ConfigSection(), KIniYear, year);
GetIntFromConfig(ConfigSection(), KIniMonth, month);
GetIntFromConfig(ConfigSection(), KIniDay, day);
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);
//replace existing database name
database = CContactDatabase::ReplaceL(KTestDbName);
// add contact item to database
id = database->AddNewContactL(*item);
CleanupStack::PopAndDestroy(item);
//reopen the contact
CContactItem *openItem = database->OpenContactL(id);
CleanupStack::PushL(openItem);
//create contactitem field and add to it.
CContactItemField* newField = CContactItemField::NewL(aStorageType, aContFieldUid);
CleanupStack::PushL(newField);
newField->SetMapping(avCardMap);
if(aStorageType==KStorageTypeDateTime)
{
GetIntFromConfig(ConfigSection(), KIniYear, year);
GetIntFromConfig(ConfigSection(), KIniMonth, month);
GetIntFromConfig(ConfigSection(), KIniDay, day);
TDateTime date(year,(TMonth)month,day,0,0,0,0);
newField->DateTimeStorage()->SetTime(date);
}
else
{
newField->TextStorage()->SetTextL(aValue);
}
openItem->AddFieldL(*newField);
CleanupStack::Pop(newField);
// verify the field is being added
CContactItemFieldSet& ContactFieldSetOpen = openItem->CardFields();
TInt startPos=0;
for(TInt check=0; check<2; check++)
{
TInt pos = ContactFieldSetOpen.FindNext(aContFieldUid, avCardMap, startPos);
TInt noOfFields = ContactFieldSetOpen.Count();
if(pos != KErrNotFound)
{
if(aStorageType==KStorageTypeDateTime)
{
TDateTime result=ContactFieldSetOpen[pos].DateTimeStorage()->Time().DateTime();
startPos=startPos+1;
if((result.Year() == year) && (result.Month() == (TMonth)month) && (result.Day() == day))
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
else
{
value.Set(ContactFieldSetOpen[pos].TextStorage()->Text());
startPos=startPos+1;
//compare the results
if(aValue.Compare(value)==0 )
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
}
}
GetStringFromConfig(ConfigSection(), KIniFlagDelete, fielddel);
if(KErrNone == fielddel.Compare(KExistDelete))
{
TRAPD(ret, DeleteExistContactL(aContFieldUid, avCardMap));
if(ret!=KErrNone)
{
database->CloseContactL(id);
delete database;
return;
}
}
database->CloseContactL(id);
CleanupStack::PopAndDestroy(openItem);
delete database;
}
/** Create Contact user defuned Template add add field to contact item
* through template and verify the field is being added
* aValue - field value
* @param aStorageType - Storage type of each field
* @param aContFieldUid - Uid of Contact field
* @param avCardMapUid - Uid of vCard
* @return - void
*/
void CTestAddFieldsStep::AddFieldsNewTemplateL(TPtrC aValue, TInt aStorageType,TUid aContFieldUid, TUid avCardMap)
{
TPtrC value;
TInt year, month, day;
CContactDatabase *base = NULL;
_LIT(KTestDbName, "c:mytemplate.cdb");
_LIT(KUserDefinedTemplate,"MyTemplate");
// replace existing database name
base = CContactDatabase::ReplaceL(KTestDbName);
CleanupStack::PushL(base);
TContactItemId TempId ;
CContactItemField* field = NULL;
//Create User defined Template
CContactItem* contactTemplate = base->CreateContactCardTemplateLC(KUserDefinedTemplate);
// Get the ID of Template
TempId = contactTemplate->Id();
//Add fields to it
field = CContactItemField::NewL(aStorageType, aContFieldUid);
CleanupStack::PushL(field);
field->SetMapping(avCardMap);
contactTemplate->AddFieldL(*field);
CleanupStack::Pop(field);
//Allocates and constructs a new contact card.
CContactItem* item = CContactCard::NewLC();
//Sets the ID of the template on which this contact item is based
item->SetTemplateRefId(TempId);
//create contact item and add field value to it
field = CContactItemField::NewL(aStorageType, aContFieldUid);
CleanupStack::PushL(field);
field->SetMapping(avCardMap);
if(aStorageType==KStorageTypeDateTime)
{
//Get the int value
TBool res;
res = GetIntFromConfig(ConfigSection(), KIniYear, year);
if(!res)
{
ERR_PRINTF1(_L("Unable to read year val from ini file"));
SetTestStepResult(EFail);
}
res = GetIntFromConfig(ConfigSection(), KIniMonth, month);
if(!res)
{
ERR_PRINTF1(_L("Unable to read month val from ini file"));
SetTestStepResult(EFail);
}
res = GetIntFromConfig(ConfigSection(), KIniDay, day);
if(!res)
{
ERR_PRINTF1(_L("Unable to read day val from ini file"));
SetTestStepResult(EFail);
}
TDateTime date(year,(TMonth)month,day,0,0,0,0);
field->DateTimeStorage()->SetTime(date);
}
else
{
field->TextStorage()->SetTextL(aValue);
}
item->AddFieldL(*field);
// verify the field is being added to the user defined template
CContactItemFieldSet& ContactFieldSet = item->CardFields();
TInt pos = ContactFieldSet.Find(aContFieldUid, avCardMap);
if(pos != KErrNotFound)
{
if(aStorageType==KStorageTypeDateTime)
{
TDateTime result=ContactFieldSet[pos].DateTimeStorage()->Time().DateTime();
//compair the results
if((result.Year() == year) && (result.Month() == (TMonth)month) && (result.Day() == day))
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
else
{
value.Set(ContactFieldSet[pos].TextStorage()->Text());
//compair the results
if(aValue.Compare(value)==0 )
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
}
CleanupStack::Pop(field);
CleanupStack::PopAndDestroy(item);
CleanupStack::PopAndDestroy(contactTemplate);
CleanupStack::PopAndDestroy(base);
}
/** Create Contact Item and add all fields to it and
* verify the field is being added
* @return - void
*/
void CTestAddFieldsStep::AddAllFieldsL()
{
RArray<TPtrC> readValues;
CleanupClosePushL(readValues);
TPtrC temp, value;
TInt year, month, day,readPos=0;
// get string value from ini file.
if(!GetStringFromConfig(ConfigSection(), KIniFieldAsstVal, temp))
{
ERR_PRINTF1(_L("Unable to read val from ini file"));
SetTestStepResult(EFail);
}
else
{
readValues.Append(temp);
}
if(!GetStringFromConfig(ConfigSection(), KIniFieldAsstTelVal, temp))
{
ERR_PRINTF1(_L("Unable to read val from ini file"));
SetTestStepResult(EFail);
}
else
{
readValues.Append(temp);
}
if(!GetStringFromConfig(ConfigSection(), KIniFieldSpouseVal, temp))
{
ERR_PRINTF1(_L("Unable to read val from ini file"));
SetTestStepResult(EFail);
}
else
{
readValues.Append(temp);
}
if(!GetStringFromConfig(ConfigSection(), KIniFieldChildVel, temp))
{
ERR_PRINTF1(_L("Unable to read val from ini file"));
SetTestStepResult(EFail);
}
else
{
readValues.Append(temp);
}
if(!GetStringFromConfig(ConfigSection(), KIniFieldClassVal, temp))
{
ERR_PRINTF1(_L("Unable to read val from ini file"));
SetTestStepResult(EFail);
}
else
{
readValues.Append(temp);
}
if(!GetStringFromConfig(ConfigSection(), KIniFieldDeptVal, temp))
{
ERR_PRINTF1(_L("Unable to read val from ini file"));
SetTestStepResult(EFail);
}
else
{
readValues.Append(temp);
}
// get int val from ini file
GetIntFromConfig(ConfigSection(), KIniYear, year);
GetIntFromConfig(ConfigSection(), KIniMonth, month);
GetIntFromConfig(ConfigSection(), KIniDay, day);
CContactItemField* field = NULL;
// Create contact Item and add all fields to it
CContactItem* item = CContactCard::NewLC();
for(TInt x=0; x<7; x++)
{
field = CContactItemField::NewL(iStorage[x], iFieldUid[x]);
CleanupStack::PushL(field);
field->SetMapping(iVcardUid[x]);
if(iStorage[x]==KStorageTypeDateTime)
{
TDateTime date(year,(TMonth)month,day,0,0,0,0);
field->DateTimeStorage()->SetTime(date);
}
else
{
field->TextStorage()->SetTextL(readValues[readPos++]);
}
item->AddFieldL(*field);
CleanupStack::Pop(field);
}
readPos=0;
// verify the field is being added
for(TInt x=0; x<7; x++)
{
CContactItemFieldSet& ContactFieldSet = item->CardFields();
TInt pos = ContactFieldSet.Find(iFieldUid[x], iVcardUid[x]);
if(pos != KErrNotFound)
{
if(iStorage[x]==KStorageTypeDateTime)
{
TDateTime result=ContactFieldSet[pos].DateTimeStorage()->Time().DateTime();
if((result.Year() == year) && (result.Month() == (TMonth)month) && (result.Day() == day))
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
else
{
value.Set(ContactFieldSet[pos].TextStorage()->Text());
if(value.Compare(readValues[readPos++])==0 )
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
}
}
//Cleanup stack
CleanupStack::PopAndDestroy(item);
CleanupStack::PopAndDestroy(&readValues);
}
/** Create Contact Item and add couple of same fields to it and
* verify the field is being added
* aValue - field value
* @param aStorageType - Storage type of each field
* @param aContFieldUid - Uid of Contact field
* @param avCardMapUid - Uid of vCard
* @return - void
*/
void CTestAddFieldsStep::AddCoupleFieldsL(TPtrC aValue, TInt aStorageType,TUid aContFieldUid, TUid avCardMap)
{
TPtrC value;
TInt year, month, day;
CContactItemField* field;
// Get the value form ini file
GetIntFromConfig(ConfigSection(), KIniYear, year);
GetIntFromConfig(ConfigSection(), KIniMonth, month);
GetIntFromConfig(ConfigSection(), KIniDay, day);
// Create contact Item and add same field twice to it
CContactItem* item = CContactCard::NewLC();
for(TInt x=0; x<2; x++)
{
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);
}
CContactItemFieldSet& ContactFieldSetOpen = item->CardFields();
// verify the field is being added
TInt startPos=0;
for(TInt check=0; check<2; check++)
{
TInt pos = ContactFieldSetOpen.FindNext(aContFieldUid, avCardMap,startPos);
if(pos != KErrNotFound)
{
if(aStorageType==KStorageTypeDateTime)
{
TDateTime result=ContactFieldSetOpen[pos].DateTimeStorage()->Time().DateTime();
startPos=startPos+1;
if((result.Year() == year) && (result.Month() == (TMonth)month) && (result.Day() == day))
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
else
{
value.Set(ContactFieldSetOpen[pos].TextStorage()->Text());
startPos=startPos+1;
//compair the results
if(aValue.Compare(value)==0 )
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
}
}
CleanupStack::PopAndDestroy(item);
}
/**
Test: opens contact item, add two identical uids to each field,
alternating between custom and existing uids,
then checks if uids were stored correctly
*/
void CCustomLabelUid::DuplicateUidsTestL( const TContactItemId aCid )
{
//open contact
CContactItem *contactItem = NULL;
contactItem = iContactsDatabase->OpenContactLX(aCid,*iViewAll);
CleanupStack::PushL(contactItem);
CContactItemFieldSet *contactFields = &(contactItem->CardFields());
//add two identical uids to each field, alternating between custom and existing uids
const TInt KFieldsCount = contactFields->Count();
TInt error = KErrNone;
//add duplicate custom uids
CContactItemField *contactField1 = CContactItemField::NewL(KStorageTypeText);
CleanupStack::PushL(contactField1);
contactField1->SetTemplateField(EFalse);
TRAP( error, contactField1->AddFieldTypeL( TFieldType::Uid(TestConstants::KInitialUID) ));
INTCOMPARE( KErrNone, ==, error, 0, 0 );
TRAP( error, contactField1->AddFieldTypeL( TFieldType::Uid(TestConstants::KInitialUID) ));
INTCOMPARE( KErrNone, ==, error, 0, 0 );
contactItem->AddFieldL(*contactField1);
CleanupStack::Pop(contactField1);
//add duplicate existing uids
CContactItemField *contactField2 = CContactItemField::NewL(KStorageTypeText);
CleanupStack::PushL(contactField2);
contactField2->SetTemplateField(EFalse);
TRAP( error, contactField2->AddFieldTypeL(KUidContactFieldAdditionalName));
INTCOMPARE( KErrNone, ==, error, 1, 0 );
TRAP( error, contactField2->AddFieldTypeL(KUidContactFieldAdditionalName));
INTCOMPARE( KErrNone, ==, error, 1, 0 );
contactItem->AddFieldL(*contactField2);
CleanupStack::Pop(contactField2);
//populate contact fields
SetContactFieldsL(*contactItem);
//update contact
iContactsDatabase->CommitContactL(*contactItem);
CleanupStack::PopAndDestroy(contactItem);
CleanupStack::Pop();//lock
contactItem = NULL;
//read contact item
contactItem = iContactsDatabase->ReadContactLC(aCid,*iViewAll);
contactFields = &(contactItem->CardFields());
//check that contact field uids updated correctly
const TInt KReadFieldsCount = contactFields->Count();
const CContentType *KContentType = NULL;
INTCOMPARE( KReadFieldsCount, >, 0, 0, 0 );
KContentType = &(*contactFields)[KFieldsCount].ContentType();
SINGLECOMPARE( KContentType->ContainsFieldType( TFieldType::Uid(TestConstants::KInitialUID) ), KFieldsCount,0 );
KContentType = &(*contactFields)[KFieldsCount+1].ContentType();
SINGLECOMPARE( KContentType->ContainsFieldType(KUidContactFieldAdditionalName), KFieldsCount+1,0 );
//check that contact fields updated correctly
SINGLECOMPARE( CheckContactFieldsL(*contactItem), 0, 0 );
CleanupStack::PopAndDestroy(contactItem);
}
/** Create Contact Item and add field to it.Update the field value and
* verify the 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 CTestUpdateFieldsStep::UpdateFieldsL(TPtrC aValue, TInt aStorageType,TUid aContFieldUid, TUid avCardMap)
{
TPtrC value, updateVal, getUpdateValue;
TInt year, month, day;
// get the value from ini file
GetIntFromConfig(ConfigSection(), KIniYear, year);
GetIntFromConfig(ConfigSection(), KIniMonth, month);
GetIntFromConfig(ConfigSection(), KIniDay, day);
//Create contact Item and add field to it.
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);
// Get the value from ini file for update
GetStringFromConfig(ConfigSection(), KIniUpdatedvalue, updateVal);
GetIntFromConfig(ConfigSection(), KIniUpdateYear, year);
GetIntFromConfig(ConfigSection(), KIniUpdateMonth, month);
GetIntFromConfig(ConfigSection(), KIniUpdateDay, day);
CContactItemFieldSet& ContactFieldSet = item->CardFields();
TInt pos = ContactFieldSet.Find(aContFieldUid, avCardMap);
if(aStorageType==KStorageTypeDateTime)
{
// update the field value
TDateTime date(year,(TMonth)month,day,0,0,0,0);
field->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());
//compair the results
if(getUpdateValue.Compare(updateVal)==0 )
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
// Cleanup
CleanupStack::Pop(field);
CleanupStack::PopAndDestroy(item);
}
/**
* Creating 1000 contact item with all new fields
* @return - void
*/
void CTestContactPerformanceStep::FieldPerformanceL()
{
TPtrC value, temp;
_LIT(KTestDbName, "c:contactmultiple.cdb");
TInt readPos=0;
TContactItemId id = 0;
_LIT(KUpdate, "update");
_LIT(KDelete, "delete");
CleanupClosePushL(idArray);
RArray<TPtrC> readValues;
CleanupClosePushL(readValues);
// get string value from ini file.
GetStringFromConfig(ConfigSection(), KIniFieldAsstVal, temp);
readValues.Append(temp);
GetStringFromConfig(ConfigSection(), KIniFieldAsstTelVal, temp);
readValues.Append(temp);
GetStringFromConfig(ConfigSection(), KIniFieldSpouseVal, temp);
readValues.Append(temp);
GetStringFromConfig(ConfigSection(), KIniFieldChildVel, temp);
readValues.Append(temp);
GetStringFromConfig(ConfigSection(), KIniFieldClassVal, temp);
readValues.Append(temp);
GetStringFromConfig(ConfigSection(), KIniFieldDeptVal, temp);
readValues.Append(temp);
// get int val from ini file
GetIntFromConfig(ConfigSection(), KIniYear, iYear);
GetIntFromConfig(ConfigSection(), KIniMonth, iMonth);
GetIntFromConfig(ConfigSection(), KIniDay, iDay);
//replace existing database name
dBase = CContactDatabase::ReplaceL(KTestDbName);
//Get the number of contact item from ini file
GetIntFromConfig(ConfigSection(), KNoOfContactItem, iNoOfCI);
// Create contact item and add all fields to it
for(TInt range=0; range<iNoOfCI; range++)
{
CContactItem* item = CContactCard::NewLC();
for(TInt noOfFields=0; noOfFields<7; noOfFields++)
{
CContactItemField* field = CContactItemField::NewL(iStorage[noOfFields], iFieldUid[noOfFields]);
CleanupStack::PushL(field);
field->SetMapping(iVcardUid[noOfFields]);
if(iStorage[noOfFields]==KStorageTypeDateTime)
{
TDateTime date(iYear,(TMonth)iMonth,iDay,0,0,0,0);
field->DateTimeStorage()->SetTime(date);
}
else
{
field->TextStorage()->SetTextL(readValues[readPos++]);
}
item->AddFieldL(*field);
CleanupStack::Pop(field);
}
// add contact item to database
id = dBase->AddNewContactL(*item);
//Append the id into array
idArray.Append(id);
readPos=0;
// Cleanup
CleanupStack::PopAndDestroy(item);
}
dBase->CloseContactL(id);
// verify for multiple contact item with all fields is being added
readPos=0;
CContactItem *readItem = NULL;
for(TInt readContact=0; readContact<iNoOfCI; readContact++)
{
readItem = dBase->ReadContactLC(idArray[readContact]);
for(TInt check=0; check<7; check++)
{
CContactItemFieldSet& ContactFieldSet = readItem->CardFields();
TInt pos = ContactFieldSet.Find(iFieldUid[check], iVcardUid[check]);
if(pos != KErrNotFound)
{
if(iStorage[check]==KStorageTypeDateTime)
{
TDateTime result=ContactFieldSet[pos].DateTimeStorage()->Time().DateTime();
//compare the results
if((result.Year() == iYear) && (result.Month() == (TMonth)iMonth) && (result.Day() == iDay))
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
else
{
value.Set(ContactFieldSet[pos].TextStorage()->Text());
//compare the results
if(value.Compare(readValues[readPos++])==0 )
{
SetTestStepResult(EPass);
}
else
{
SetTestStepResult(EFail);
}
}
}
}
readPos=0;
CleanupStack::PopAndDestroy(readItem);
}
CleanupStack::PopAndDestroy(&readValues);
GetStringFromConfig(ConfigSection(), KIniFlagvalue, temp);
if(KErrNone == temp.Compare(KUpdate))
{
UpdatePerformanceL();
}
else if(KErrNone == temp.Compare(KDelete))
{
DeletePerformanceL();
}
CleanupStack::PopAndDestroy(&idArray);
delete dBase;
}
LOCAL_C void TestCreateContactWithoutImagesFoldeL()
{
test.Next(_L("TestCreateContactWithoutImagesFoldeL"));
SETUP;
// Delete the images folder and all contents
TInt drive;
#ifdef __WINS__
TInt err = DriveInfo::GetDefaultDrive(DriveInfo::EDefaultPhoneMemory, drive);
#else
TInt err = DriveInfo::GetDefaultDrive(DriveInfo::EDefaultMassStorage, drive);
#endif
// Do not leave with this error. The phone does not have to have this support
if (err == KErrNone)
{
// Get the root path in this drive to create
// to create the images directory
TPath dir;
User::LeaveIfError(PathInfo::GetRootPath(dir, drive));
dir.Append(KImagesFolder);
CFileMan* fileMan = CFileMan::NewL(fs);
err = fileMan->RmDir(dir); // err not used
delete fileMan;
}
else
{
test.Printf(_L("Could not remove the images folder\n"));
return;
}
// Create an image and store an image without the images dir available
CContactItem *contact = CContactItem::NewLC(KUidContactCard);
CContactItemField *newField = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldCodImage);
newField->SetMapping(KUidContactFieldVCardMapUnknown);
newField->TextStorage()->SetTextL(KSrcImage());
contact->AddFieldL(*newField); // Takes ownership
CleanupStack::Pop(newField);
TContactItemId id = cntClient.CreateContactL(*contact);
CleanupStack::PopAndDestroy(contact);
// View definition to read image field
CContactItemViewDef *imageViewDef = CContactItemViewDef::NewLC(CContactItemViewDef::EIncludeFields, CContactItemViewDef::EMaskHiddenFields);
imageViewDef->AddL(KUidContactFieldCodImage);
contact = cntClient.ReadContactL(imageViewDef ,id);
CleanupStack::PopAndDestroy(imageViewDef); // imageViewDef
TInt index = contact->CardFields().Find(KUidContactFieldCodImage, KUidContactFieldVCardMapUnknown);
// Test image field found
test(index != KErrNotFound);
CContactItemField& field = contact->CardFields()[index];
TPtrC imagePtr = field.TextStorage()->Text();
// Image path should not change
test(imagePtr.Compare(KSrcImage()) == 0);
cntClient.CloseContact(id);
delete contact;
TEAR_DOWN;
}