--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/phonebookengines/contactsmodel/tsrc/T_NOMACH.CPP Tue Feb 02 10:12:17 2010 +0200
@@ -0,0 +1,805 @@
+// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include <e32test.h>
+#include <f32file.h>
+#include "T_UTILS.H"
+#include <coreappstest/testserver.h>
+
+_LIT(KCntTestTitle,"T_NOMACH");
+_LIT(KDatabaseFileName,"c:T_NOMACH");
+
+#ifndef __SYMBIAN_CNTMODEL_USE_SQLITE__
+_LIT(KSrcDatabaseName, "z:\\t_old_contacts_original.cdb");
+_LIT(KDatabaseName, "C:\\private\\10003A73\\t_old_contacts_in_use.cdb");
+_LIT(KDatabaseOpenName, "C:t_old_contacts_in_use.cdb");
+_LIT(KTestDbUpdate, "-- Test database update\n");
+#endif //__SYMBIAN_CNTMODEL_USE_SQLITE__
+
+_LIT(KTestName,"Test Name No %d");
+_LIT(KTestAddress,"Test Address No %d");
+_LIT(KTestFamilyName,"Test Family Name No %d");
+_LIT(KTestEmail,"Test@Email.com No %d");
+_LIT(KTestCountry,"Test Country No %d");
+_LIT(KTestCompany,"Test Company No %d");
+_LIT(KCntName,"Firstname");
+_LIT(KCntSurname,"Surname");
+
+_LIT(KTestNoPhoneMatchLibrary,"-- Regression testcode for DUG-4ZVNBW - MatchPhoneNumberL doesn't match correctly without CNTPHONE.DLL\n");
+_LIT(KTestNewMatching,"-- Test matching; all following tests should match 1234567\n");
+_LIT(KTestFaxSMSMatching,"-- Test adding fax and SMS numbers to the phone number match list, regression for COY-567J99\n");
+_LIT(KSpeedDialSimpleTest,"-- Basic speed-dial tests.\n");
+_LIT(KTestRemovingSpeedDials,"\n-- Test removing speed-dials; add five contacts, Set two speed dials - remove one & check the other is still there.\n");
+_LIT(KTest11Digitmatching, "-- Test 11 digit matching\n");
+_LIT(KTest15Digitmatching, "-- Test 15 digit matching\n");
+_LIT(KTestEmbeddedZeroes, "-- Test Embedded Zeroes\n");
+
+const TInt KMatch6Digits = 6;
+const TInt KMatch7Digits = 7;
+const TInt KMatch8Digits = 8;
+const TInt KMatch10Digits = 10;
+const TInt KMatch11Digits = 11;
+const TInt KMatch12Digits = 12;
+const TInt KMatch13Digits = 13;
+const TInt KMatch14Digits = 14;
+const TInt KMatch15Digits = 15;
+const TInt KMatch16Digits = 16;
+
+const TInt KTestContactsNum=10;
+
+GLDEF_D CCntTest* CntTest=NULL;
+GLDEF_D RTest test(KCntTestTitle);
+
+
+LOCAL_C void 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 PopulateDatabaseL(TInt aNumberToPopulate)
+//
+// Create and populate the database
+//
+ {
+ CContactItem* templ = CntTest->Db()->ReadContactL(0);
+ CleanupStack::PushL(templ);
+
+ for (TInt ii=0;ii<aNumberToPopulate;ii++)
+ {
+ CContactItem* item=CContactCard::NewLC(templ);
+ TBuf<20> name;
+ name.Format(KTestName,ii);
+ SetNameL(*item,KUidContactFieldGivenName,name,EFalse);
+ TBuf<20> number;
+ switch(ii%3)
+ {
+ case 0:
+ number.Format(_L("0171-%03d %04d"),(ii*9)%1000,((ii+11)*23)%10000);
+ break;
+ case 1:
+ number.Format(_L("%04d:%04d:%04d:%04d"),(ii*123)%10000,(ii*666)%10000,(ii*234)%10000);
+ break;
+ case 2:
+ number.Format(_L("+00%d-%03d %04d"),(ii*123)%100,(ii*13)%1000,((ii+13)*17)%10000);
+ break;
+ }
+ SetNameL(*item,KUidContactFieldPhoneNumber,_L("11111"),EFalse);
+ if (!(ii%2))
+ {
+ number.Format(_L("0181-%03d %04d"),(ii*8)%1000,((ii+11)*22)%10000);
+ SetNameL(*item,KUidContactFieldPhoneNumber,_L("111"),EFalse);
+ number.Format(_L("01734-%06d"),(ii*123456)%1000000);
+ SetNameL(*item,KUidContactFieldPhoneNumber,_L("1111"),EFalse);
+ CContactItemFieldSet& itemFields = item->CardFields();
+ for (TInt ii=0;ii<itemFields.Count();ii++)
+ {
+ CContactItemField& field = (itemFields)[ii];
+ if (!itemFields[ii].Storage()->IsFull() && itemFields[ii].StorageType()==KStorageTypeText &&
+ field.ContentType().ContainsFieldType(KUidContactFieldPhoneNumber))
+ itemFields[ii].TextStorage()->SetTextL(_L("111111"));
+ }
+ }
+ TBuf<32> address;
+ address.Format(KTestAddress,ii);
+ SetNameL(*item,KUidContactFieldAddress,address,EFalse);
+//
+ TBuf<32> familyName;
+ familyName.Format(KTestFamilyName,ii);
+ SetNameL(*item,KUidContactFieldFamilyName,familyName,EFalse);
+//
+ TBuf<32> email;
+ email.Format(KTestEmail,ii);
+ SetNameL(*item,KUidContactFieldEMail,email,EFalse);
+//
+ TBuf<32> country;
+ country.Format(KTestCountry,ii);
+ SetNameL(*item,KUidContactFieldCountry,country,EFalse);
+//
+ TBuf<32> company;
+ company.Format(KTestCompany,ii);
+ SetNameL(*item,KUidContactFieldCompanyName,company,EFalse);
+//
+ CntTest->Db()->AddNewContactL(*item);
+ CleanupStack::PopAndDestroy(item);
+
+ test.Printf(_L(".")); // Just to show some life
+ }
+ CleanupStack::PopAndDestroy(templ);
+ CntTest->Db()->CompactL();
+ }
+
+
+
+
+
+
+// Delete the current contacts database and create a new one
+//
+LOCAL_C void ResetDatabaseL()
+ {
+ // Reset all server side speed dials ;-)))
+ CntTest->Db()->ResetServerSpeedDialsL();
+
+ CntTest->CloseDatabase();
+ CntTest->DeleteDatabaseL();
+ CntTest->CreateDatabaseL();
+ CntTest->OpenDatabaseL();
+ }
+
+
+LOCAL_C TContactItemId CreateContactL(const TDesC& aFirstName, const TDesC& aFamilyName, const TDesC& aPhoneNo, const TDesC& aMobileNo)
+ {
+ test.Printf(_L("\tCreating contact %S %S, phone: %S mobile: %S\n"), &aFirstName, &aFamilyName, &aPhoneNo, &aMobileNo);
+ CContactItem* item=CContactCard::NewLC();
+ SetNameL(*item,KUidContactFieldGivenName,KUidContactFieldVCardMapUnusedN,aFirstName,ETrue);
+ SetNameL(*item,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,aFamilyName,ETrue);
+ SetNameL(*item,KUidContactFieldPhoneNumber,KUidContactFieldVCardMapTEL,aPhoneNo,ETrue);
+ SetNameL(*item,KUidContactFieldPhoneNumber,KUidContactFieldVCardMapCELL,aMobileNo,ETrue);
+ item->SetTemplateRefId(KGoldenTemplateId);
+ TContactItemId id=CntTest->Db()->AddNewContactL(*item);
+ CleanupStack::PopAndDestroy(item);
+ return id;
+ }
+
+LOCAL_C void CheckPhoneMatchL(const TDesC& aPhoneNumberToMatch, TInt aNumberOfMatchDigits, TInt aExpectedNumOfMatches)
+ {
+ TBuf<256> testCase;
+ _LIT(KFormat,"Checking %d matches to %S, matching %d digits");
+ testCase.Format(KFormat, aExpectedNumOfMatches, &aPhoneNumberToMatch, aNumberOfMatchDigits);
+ test.Next(_L(" "));
+
+ CContactDatabase& db = *(CntTest->Db());
+ CContactIdArray* array = db.MatchPhoneNumberL(aPhoneNumberToMatch,aNumberOfMatchDigits);
+ CleanupStack::PushL(array);
+ const TInt numberOfMatches = array->Count();
+ CleanupStack::PopAndDestroy(array);
+
+
+ TInt sfd = db.MachineId();
+ // OverrideMachineUniqueId
+
+
+ test(numberOfMatches==aExpectedNumOfMatches);
+ }
+
+/**
+Testcode for Graham's new API
+
+These all match 1234567:
+*#42# 0201234567 p123
+*#42# +358201234567 p123
+*61 0201234567
+*61 +358201234567
++358201234567 +3
++358201234567 p123
+
+*/
+LOCAL_C void TestNewMatchingL()
+ {
+ ResetDatabaseL();
+
+ const TInt KLastThreeDigits =3;
+ //These numbers match 1234567
+ _LIT(KCntDTMFNumber1,"*#42# 0201234567 p123");
+ _LIT(KCntDTMFNumber2,"*#42#+358401234567 p123");
+ _LIT(KCntDTMFNumber3,"*61 0201234567");
+ _LIT(KCntDTMFNumber4,"*61 +358201234567");
+ _LIT(KCntDTMFNumber5,"+358201234567 +3");
+ _LIT(KCntDTMFNumber6,"+358201234567 p123");
+ _LIT(KCntMatch1to7ExtraCharacters,"mobile 12 345-67");
+ _LIT(KCntMatch1to7Brackets,"(020) 0123-4567");
+ _LIT(KCntMatch1to7TooManyNumbers,"123456789012345678901234567");
+ //These shouldn't match 1234567
+ _LIT(KCntDTMFNumber7,"*#42# 0201234567#p123");//empty
+ _LIT(KCntDTMFNumber8,"*12345+0201234567"); //matches 12345
+ _LIT(KCntDTMFNumber9,"*+123+456+++++++++++"); //matches 123
+ //Graham's possible defects
+ _LIT(KCntPossibleDefect,"70000");
+ _LIT(KCntZeroAtEnd,"020 5632700");
+ //Match numbers
+ _LIT(KCntMatch1to7,"1234567");
+ _LIT(KCntMatch1to3,"123");
+ _LIT(KCntMatch700,"700");
+ //Spaces at the start
+ _LIT(KCntSpaceInNumber," 0 2 0 7 9 4 6 5 6 7 8 ");
+ _LIT(KCntSpaceMatch,"02079465678");
+ _LIT(KCntSpaceInNumberIntl," +44 7700 900 472");
+ _LIT(KCntSpaceInNumberIntlMatch,"+447700900472");
+ _LIT(KCntSpaceWorstCase," ");
+ _LIT(KCntNoRealDigitsInNumber,"Lycos SMS");
+
+ _LIT(KCntShortNumber1,"789");
+ _LIT(KCntShortNumber2,"456");
+
+ _LIT(KCntEndingByShortNumber1,"+44(0)79460064789");
+ _LIT(KCntEndingByShortNumber2,"+447946008731456");
+
+ _LIT(KCntMatchShortNumber1,"789"); // must not match other number ending with 789
+ _LIT(KCntMatchShortNumber2,"456"); // must not match other number ending with 456
+
+ CreateContactL(KCntName,KCntSurname,KCntShortNumber1,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KCntShortNumber2,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KCntEndingByShortNumber1,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KCntEndingByShortNumber2,KNullDesC);
+
+
+ CreateContactL(KCntName,KCntSurname,KCntDTMFNumber1,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KCntDTMFNumber2,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KCntDTMFNumber3,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KCntDTMFNumber4,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KCntDTMFNumber5,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KCntDTMFNumber6,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KCntDTMFNumber7,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KCntDTMFNumber8,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KCntDTMFNumber9,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KCntPossibleDefect,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KCntMatch1to7ExtraCharacters,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KCntMatch1to7Brackets,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KCntMatch1to7TooManyNumbers,KNullDesC);
+ TContactItemId id = CreateContactL(KCntName,KCntSurname,KCntZeroAtEnd,KNullDesC);
+
+ CheckPhoneMatchL(KCntMatch1to7,KMatch7Digits,9);
+ CheckPhoneMatchL(KCntMatch1to7,KLastThreeDigits,0); // no contact with 567 as phone number
+ CheckPhoneMatchL(KCntMatch1to7,KMatch7Digits,9);
+ CheckPhoneMatchL(KCntMatch1to7,KLastThreeDigits,0); // no contact with 567 as phone number
+
+ CheckPhoneMatchL(KCntMatch1to3,KMatch7Digits,1);
+ CheckPhoneMatchL(KCntMatch1to3,KMatch7Digits,1);
+
+ CheckPhoneMatchL(KCntPossibleDefect,KMatch7Digits,1);
+ CheckPhoneMatchL(KCntZeroAtEnd,KMatch7Digits,1);
+ CheckPhoneMatchL(KCntMatch700,KLastThreeDigits,0); // no contact with 700 as phone number at this point
+ CheckPhoneMatchL(KCntZeroAtEnd,KMatch7Digits,1);
+
+ CheckPhoneMatchL(KCntNoRealDigitsInNumber,KMatch7Digits,0);
+
+ CheckPhoneMatchL(KCntMatchShortNumber1,KLastThreeDigits,1); //
+ CheckPhoneMatchL(KCntMatchShortNumber2,KLastThreeDigits,1); //
+
+ // Simulate a synchronisation (increment the access count)
+ CContactItem* item = CntTest->Db()->OpenContactLX(id);
+ item->IncAccessCount();
+ CntTest->Db()->CommitContactL(*item);
+ CleanupStack::PopAndDestroy(); //lock record
+ delete item;
+
+ // Delete the contact and verify that it has been removed from the phone match table
+ CntTest->Db()->DeleteContactL(id);
+ CheckPhoneMatchL(KCntZeroAtEnd,KMatch7Digits,0);
+
+ CreateContactL(KCntName,KCntSurname,KCntSpaceInNumber,KNullDesC);
+ CheckPhoneMatchL(KCntSpaceMatch,KMatch7Digits,1);
+ CreateContactL(KCntName,KCntSurname,KCntSpaceInNumberIntl,KNullDesC);
+ CheckPhoneMatchL(KCntSpaceInNumberIntlMatch,KMatch7Digits,1);
+ CreateContactL(KCntName,KCntSurname,KCntSpaceWorstCase,KNullDesC);
+ }
+
+
+// Regression testcode for
+// DUG-4ZVNBW "MatchPhoneNumberL doesn't match correctly without CNTPHONE.DLL"
+//
+// Remove CNTPHONE.DLL before running this test to verify
+//
+LOCAL_C void TestNoPhoneMatchLibraryL()
+ {
+ ResetDatabaseL();
+ _LIT(KCntNumberWithSpaces,"+44 020 7946 0000");
+ _LIT(KCntNumberWithoutSpaces,"02079460000");
+ CreateContactL(KCntName,KCntSurname,KCntNumberWithSpaces,KNullDesC);
+ CheckPhoneMatchL(KCntNumberWithoutSpaces,KMatch7Digits,1);
+ }
+
+
+LOCAL_C TContactItemId CreateFaxSMSContactL(const TDesC& aFirstName, const TDesC& aFamilyName, const TDesC& aFaxNo, const TDesC& aSMSNo)
+ {
+ CContactItem* item=CContactCard::NewLC();
+ SetNameL(*item,KUidContactFieldGivenName,KUidContactFieldVCardMapUnusedN,aFirstName,ETrue);
+ SetNameL(*item,KUidContactFieldFamilyName,KUidContactFieldVCardMapUnusedN,aFamilyName,ETrue);
+ SetNameL(*item,KUidContactFieldFax,KUidContactFieldVCardMapFAX,aFaxNo,ETrue);
+ SetNameL(*item,KUidContactFieldSms,KUidContactFieldVCardMapTEL,aSMSNo,ETrue);
+ item->SetTemplateRefId(KGoldenTemplateId);
+ TContactItemId id=CntTest->Db()->AddNewContactL(*item);
+ CleanupStack::PopAndDestroy(item);
+ return id;
+ }
+
+
+/**
+Regression testcode for defect COY-567J99 "Phone number matching does not match Fax field"
+Testcode for adding fax and SMS numbers to the phone number match list
+*/
+LOCAL_C void TestFaxSMSMatchingL()
+ {
+ ResetDatabaseL();
+
+ _LIT(KCntFaxNumber1,"020 79460585");
+ _LIT(KCntFaxNumber2,"020 79460432");
+ _LIT(KCntSMSNumber1,"+442079460432");
+ _LIT(KCntSMSNumber2,"+442079460585");
+
+ _LIT(KCntDuplicateNumber,"0207 9460585");
+ _LIT(KCntNewSMSNumber,"020 79460696");
+
+ TContactItemId one = CreateFaxSMSContactL(KCntName,KCntSurname,KCntFaxNumber1,KCntSMSNumber1);
+ TContactItemId two = CreateFaxSMSContactL(KCntName,KCntSurname,KCntFaxNumber2,KCntSMSNumber2);
+
+ //check that there are only 2 matches
+ CheckPhoneMatchL(KCntDuplicateNumber,9,2);
+
+ // delete contact one
+ CntTest->Db()->DeleteContactL(one);
+
+ //check that there is only 1 match now
+ CheckPhoneMatchL(KCntDuplicateNumber,9,1);
+
+ //edit item two
+ CContactItem* item = CntTest->Db()->OpenContactL(two);
+ CleanupStack::PushL(item);
+ CContactItemFieldSet& fieldSet = item->CardFields();
+ TInt fieldId=fieldSet.Find(KUidContactFieldSms);
+ CContactItemField& field = fieldSet[fieldId];
+ field.TextStorage()->SetTextL(KCntNewSMSNumber);
+ CntTest->Db()->CommitContactL(*item);
+ CleanupStack::PopAndDestroy(item);
+
+ //check that there is no matches now
+ CheckPhoneMatchL(KCntDuplicateNumber,9,0);
+ }
+
+
+// Check that the speed dial at position aSpeedDialPosition matches the aExpectedId
+// and the contents of the field with aFieldId is the same in the speed dial.
+//
+LOCAL_C void CheckSpeedDialL(TInt aSpeedDialPosition, CContactItem& aContact, TInt aFieldId)
+ {
+ HBufC* buf=HBufC::NewLC(100);
+ TPtr fieldContents=buf->Des();
+
+ TContactItemId id = CntTest->Db()->GetSpeedDialFieldL(aSpeedDialPosition, fieldContents);
+ TPtrC actualContents =(aContact.CardFields()[aFieldId].TextStorage()->Text());
+ test(id==aContact.Id());
+ test(actualContents==fieldContents);
+
+ CleanupStack::PopAndDestroy(); //buf
+ }
+
+/**
+ * Check that speed dials are working correctly;
+ * Add first contact to speed dial 1, add second contact to speed dial 9.
+ * Check speed dial 1 still matches contact 1 after adding speed dial
+ * Check persistance of speed dial list
+ * Check overwriting old speed dial with new contact id
+ * Check deletion of contact removes all existing speed dials
+ */
+LOCAL_C void SpeedDialSimpleTest()
+ {
+ ResetDatabaseL();
+ TRAP_IGNORE(PopulateDatabaseL(KTestContactsNum));
+
+ const CContactIdArray* sortedItems = CntTest->Db()->SortedItemsL();
+
+ // first item in position 1
+ CContactItem* firstItem = CntTest->Db()->OpenContactL((*sortedItems)[0]);
+ CleanupStack::PushL(firstItem);
+ TInt fieldId=5;
+ const TInt speedDialPositionOne=1;
+ CntTest->Db()->SetFieldAsSpeedDialL(*firstItem, fieldId, speedDialPositionOne);
+ CheckSpeedDialL(speedDialPositionOne,*firstItem,fieldId);
+
+ // second item in position 2
+ CContactItem* secondItem = CntTest->Db()->OpenContactL((*sortedItems)[1]);
+ CleanupStack::PushL(secondItem);
+ fieldId=5;
+ const TInt speedDialPositionNine=9;
+ CntTest->Db()->SetFieldAsSpeedDialL(*secondItem, fieldId, speedDialPositionNine);
+ CheckSpeedDialL(speedDialPositionNine,*secondItem,fieldId);
+
+ // wrong answers.....
+ CheckSpeedDialL(speedDialPositionOne,*firstItem,5);
+
+ // check persistance
+ CntTest->CloseDatabase();
+ CntTest->OpenDatabaseL();
+ CheckSpeedDialL(speedDialPositionOne,*firstItem,5);
+ CheckSpeedDialL(speedDialPositionNine,*secondItem,5);
+
+ // check overwriting old speed dial (third contact, speed dial 1)
+ const CContactIdArray* newSortedItems = CntTest->Db()->SortedItemsL();
+ CContactItem* thirdItem = CntTest->Db()->OpenContactL((*newSortedItems)[2]);
+ CleanupStack::PushL(thirdItem);
+ fieldId=5;
+ CntTest->Db()->SetFieldAsSpeedDialL(*thirdItem, fieldId, speedDialPositionOne);
+ CheckSpeedDialL(speedDialPositionOne,*thirdItem,5);
+
+ // delete contact and check that speed dials have been removed
+ CntTest->Db()->DeleteContactL((*newSortedItems)[2]);
+ HBufC* temp8=HBufC::NewLC(100);
+ TPtr testText8=temp8->Des();
+ TContactItemId eightId = CntTest->Db()->GetSpeedDialFieldL(speedDialPositionOne, testText8);
+ test(eightId==KNullContactId);
+ test(testText8==KNullDesC);
+
+ // modify a contact with a speed dial - but do not change the relavent field.
+ CContactItem* fourthItem = CntTest->Db()->OpenContactL((*newSortedItems)[2]);
+ CleanupStack::PushL(fourthItem);
+ fieldId=5;
+
+ CntTest->Db()->SetFieldAsSpeedDialL(*fourthItem, fieldId, speedDialPositionOne);
+ TInt fieldPosOfSpeedDial = fourthItem->CardFields().Find(KUidSpeedDialOne);
+ test(fieldPosOfSpeedDial != KErrNotFound);
+
+ CContactItem* fifthItem = CntTest->Db()->OpenContactL(fourthItem->Id());
+ CleanupStack::PushL(fifthItem);
+
+ // remove the first field in the list.
+ fieldPosOfSpeedDial = fifthItem->CardFields().Find(KUidSpeedDialOne);
+
+ fifthItem->CardFields().Remove(1);
+ CntTest->Db()->CommitContactL(*fifthItem);
+
+ CleanupStack::PopAndDestroy(6); // firstItem, secondItem, thirdItem, fourthItem, fifthItem, temp8
+ }
+
+
+/**
+ *Add five contacts.
+ * Set two speed dials - remove one & check the other is still there.
+ */
+LOCAL_C void TestRemovingSpeedDialsL()
+ {
+ ResetDatabaseL();
+ PopulateDatabaseL(KTestContactsNum);
+ const CContactIdArray* sortedItems = CntTest->Db()->SortedItemsL(); //doesn't take ownership
+ const TInt speedDialPositionOne=1;
+ const TInt speedDialPositionNine=9;
+
+
+ const TContactItemId firstId = (*sortedItems)[3];
+ const TContactItemId secondId = (*sortedItems)[5];
+
+ CContactItem* first = CntTest->Db()->OpenContactL(firstId);
+ CleanupStack::PushL(first);
+ CContactItemFieldSet& aFieldSet = first->CardFields();
+ for(TInt fieldLoop=0;fieldLoop<aFieldSet.Count();fieldLoop++)
+ {
+ CContactItemField& field = aFieldSet[fieldLoop];
+ if (field.ContentType().ContainsFieldType(KUidContactFieldPhoneNumber))
+ {
+ // change it...
+ field.TextStorage()->SetTextL(_L("956431458"));
+ }
+ }
+ CntTest->Db()->CommitContactL(*first);
+ CleanupStack::PopAndDestroy(); //first
+
+ first = CntTest->Db()->OpenContactL(firstId);
+ CleanupStack::PushL(first);
+ TInt fieldId=first->CardFields().Find(KUidContactFieldPhoneNumber);
+ CntTest->Db()->SetFieldAsSpeedDialL(*first, fieldId, speedDialPositionOne);
+
+ CContactItem* second = CntTest->Db()->OpenContactL(secondId);
+ CleanupStack::PushL(second);
+ TInt fieldId2=first->CardFields().Find(KUidContactFieldPhoneNumber);
+ CntTest->Db()->SetFieldAsSpeedDialL(*second, fieldId2, speedDialPositionNine);
+
+ // check they are all established ok
+ HBufC* buf=HBufC::NewLC(100);
+ TPtr fieldContents=buf->Des();
+ TContactItemId id = CntTest->Db()->GetSpeedDialFieldL(speedDialPositionOne, fieldContents);
+ test(id==firstId);
+ id = CntTest->Db()->GetSpeedDialFieldL(speedDialPositionNine, fieldContents);
+ test(id==secondId);
+ CleanupStack::PopAndDestroy(); //buf
+
+ CntTest->Db()->RemoveSpeedDialFieldL(firstId, speedDialPositionOne);
+
+ HBufC* buf2=HBufC::NewLC(100);
+ TPtr phoneNum=buf2->Des();
+ TContactItemId idOne = CntTest->Db()->GetSpeedDialFieldL(speedDialPositionOne, phoneNum);
+ test(idOne==KNullContactId);
+ test(phoneNum==KNullDesC);
+ CleanupStack::PopAndDestroy(); //buf2
+
+
+ HBufC* buf3=HBufC::NewLC(100);
+ TPtr phoneNo2=buf3->Des();
+ TContactItemId id2 = CntTest->Db()->GetSpeedDialFieldL(speedDialPositionNine, phoneNo2);
+ test(id2==secondId);
+ CleanupStack::PopAndDestroy(); //buf
+
+ CntTest->Db()->RemoveSpeedDialFieldL(secondId, speedDialPositionNine);
+
+ HBufC* buf4=HBufC::NewLC(100);
+ TPtr phoneNo3=buf4->Des();
+ id = CntTest->Db()->GetSpeedDialFieldL(speedDialPositionNine, phoneNo3);
+ test(id==KNullContactId);
+ test(phoneNum==KNullDesC);
+ CleanupStack::PopAndDestroy(); //buf4
+
+ CleanupStack::PopAndDestroy(2); //first, second
+ }
+
+/**
+ * Verifies that matching of 11-digit phone number matching works correctly
+ */
+LOCAL_C void Test11DigitMatchingL()
+ {
+ ResetDatabaseL();
+
+ _LIT(K11DigitTestNumber1,"020 7700 9001");
+ _LIT(K11DigitTestNumber2,"20 7700 90012");
+ _LIT(K11DigitTestNumber3,"020 7700 9081");
+ _LIT(K11DigitTestNumber4,"120 7700 9081");
+ _LIT(K11DigitTestNumber5,"9120 7700 9081");
+
+ CreateContactL(KCntName,KCntSurname,K11DigitTestNumber1,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,K11DigitTestNumber2,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,K11DigitTestNumber3,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,K11DigitTestNumber4,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,K11DigitTestNumber5,KNullDesC);
+
+ //Match numbers
+ _LIT(K11DigitMatch1,"020 7700 9001");
+ _LIT(K11DigitMatch2,"20 7700 90012");
+ _LIT(K11DigitMatch3,"020 7700 9081");
+ _LIT(K11DigitMatch4,"120 7700 9081");
+ _LIT(K11DigitMatch5,"9120 7700 9081");
+ _LIT(K11DigitMatch6,"20 7700 9081");
+
+ CheckPhoneMatchL(K11DigitMatch1,KMatch10Digits,1);
+ CheckPhoneMatchL(K11DigitMatch1,KMatch11Digits,1);
+
+ CheckPhoneMatchL(K11DigitMatch2,KMatch10Digits,1);
+ CheckPhoneMatchL(K11DigitMatch2,KMatch11Digits,1);
+
+ CheckPhoneMatchL(K11DigitMatch3,KMatch10Digits,3);
+ CheckPhoneMatchL(K11DigitMatch3,KMatch11Digits,1);
+
+ CheckPhoneMatchL(K11DigitMatch4,KMatch10Digits,3);
+ CheckPhoneMatchL(K11DigitMatch4,KMatch11Digits,2);
+
+ CheckPhoneMatchL(K11DigitMatch5,KMatch12Digits,1);
+ CheckPhoneMatchL(K11DigitMatch5,KMatch13Digits,1);
+
+ CheckPhoneMatchL(K11DigitMatch6,KMatch10Digits,3);
+ CheckPhoneMatchL(K11DigitMatch6,KMatch11Digits,3);
+ }
+
+/**
+ * Verifies that 15 digit phone numbers are matched correctly.
+ */
+LOCAL_C void Test15DigitMatchingL()
+ {
+ ResetDatabaseL();
+
+ _LIT(K15DigitTestNumber1,"0086 207 9476 0454");
+ _LIT(K15DigitTestNumber2,"8186 207 9476 0454");
+ _LIT(K15DigitTestNumber3,"8620 794 7604 5400");
+
+ CreateContactL(KCntName,KCntSurname,K15DigitTestNumber1,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,K15DigitTestNumber2,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,K15DigitTestNumber3,KNullDesC);
+
+ //Match numbers
+ _LIT(K15DigitMatch1,"0086 207 9476 0454");
+ _LIT(K15DigitMatch2,"86 207 9476 0454");
+ _LIT(K15DigitMatch3,"8186 207 9476 0454");
+ _LIT(K15DigitMatch4,"08186 207 9476 0454");
+
+ CheckPhoneMatchL(K15DigitMatch1,KMatch15Digits,1);
+ CheckPhoneMatchL(K15DigitMatch1,KMatch14Digits,1);
+ CheckPhoneMatchL(K15DigitMatch1,KMatch13Digits,2);
+
+ CheckPhoneMatchL(K15DigitMatch2,KMatch13Digits,2);
+
+ CheckPhoneMatchL(K15DigitMatch3,KMatch15Digits,1);
+
+ CheckPhoneMatchL(K15DigitMatch4,KMatch16Digits,0);
+ CheckPhoneMatchL(K15DigitMatch4,KMatch15Digits,1);
+ }
+
+
+/**
+ * Verifies that phone numbers are matched correctly if they
+ * have leading, trailing and embedded zeroes.
+ */
+LOCAL_C void TestEmbeddedZeroesL()
+ {
+ ResetDatabaseL();
+
+ _LIT(KEmbeddedZeroesTestNumber1,"9999 9990 0999 999");
+ _LIT(KEmbeddedZeroesTestNumber2,"9000 0000 0000 000");
+ _LIT(KEmbeddedZeroesTestNumber3,"0000 0000 0000 000");
+ _LIT(KEmbeddedZeroesTestNumber4,"0000 0000 0000 009");
+ _LIT(KEmbeddedZeroesTestNumber5,"9 9000 000");
+ _LIT(KEmbeddedZeroesTestNumber6,"9000 000");
+
+ CreateContactL(KCntName,KCntSurname,KEmbeddedZeroesTestNumber1,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KEmbeddedZeroesTestNumber2,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KEmbeddedZeroesTestNumber3,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KEmbeddedZeroesTestNumber4,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KEmbeddedZeroesTestNumber5,KNullDesC);
+ CreateContactL(KCntName,KCntSurname,KEmbeddedZeroesTestNumber6,KNullDesC);
+
+ //Match numbers
+ _LIT(KEmbeddedZeroMatch1,"9999 9990 0999 999");
+ _LIT(KEmbeddedZeroMatch2,"9000 0000 0000 000");
+ _LIT(KEmbeddedZeroMatch3,"0000 0000 0000 000");
+ _LIT(KEmbeddedZeroMatch4,"0000 0000 0000 009");
+ _LIT(KEmbeddedZeroMatch5,"9 9000 000");
+ _LIT(KEmbeddedZeroMatch6,"9000 000");
+ _LIT(KEmbeddedZeroMatch7,"0000 000");
+
+ CheckPhoneMatchL(KEmbeddedZeroMatch1,KMatch15Digits,1);
+ CheckPhoneMatchL(KEmbeddedZeroMatch2,KMatch15Digits,1);
+ CheckPhoneMatchL(KEmbeddedZeroMatch3,KMatch15Digits,1);
+ CheckPhoneMatchL(KEmbeddedZeroMatch4,KMatch15Digits,1);
+ CheckPhoneMatchL(KEmbeddedZeroMatch5,KMatch15Digits,1);
+ CheckPhoneMatchL(KEmbeddedZeroMatch5,KMatch8Digits,1);
+ CheckPhoneMatchL(KEmbeddedZeroMatch6,KMatch7Digits,2);
+ CheckPhoneMatchL(KEmbeddedZeroMatch7,KMatch7Digits,2);
+ CheckPhoneMatchL(KEmbeddedZeroMatch6,KMatch6Digits,2);
+ }
+
+
+#ifndef __SYMBIAN_CNTMODEL_USE_SQLITE__ //we mark this since the new contact database based on SQLite
+ //as the porting on SQLite database allows the thorough DC break and
+ //doesn't support the feature of database update from old database on
+ //Symbian DBMS.
+void TestDbUpdateL()
+ {
+
+ RPIMTestServer serv;
+ User::LeaveIfError(serv.Connect());
+ serv.CopyFileL(KSrcDatabaseName, KDatabaseName);
+
+ serv.Close();
+
+ // Contact model must open and upgrade database
+ test.Printf(_L("Opening and upgrading database\n"));
+ CContactDatabase* db = NULL;
+ db = CContactDatabase::OpenL(KDatabaseOpenName);
+
+ // Add a contact with a 15 digit phone number and match the same number
+ _LIT(K15DigitTestNumber,"0086 207 3453 1212");
+ _LIT(K15DigitMatch,"0086 207 3453 1212");
+ CreateContactL(KCntName,KCntSurname,K15DigitTestNumber,KNullDesC);
+ CheckPhoneMatchL(K15DigitMatch,KMatch15Digits,1);
+
+ delete db;
+ db = NULL;
+ }
+#endif // __SYMBIAN_CNTMODEL_USE_SQLITE__
+
+/**
+
+@SYMTestCaseID PIM-T-NOMACH-0001
+
+*/
+
+LOCAL_C void DoTestsL()
+ {
+ test.Start(_L("@SYMTESTCaseID:PIM-T-NOMACH-0001 T_NOMACH"));
+
+
+ CTestRegister* TempFiles = CTestRegister::NewLC();
+
+
+#ifndef __SYMBIAN_CNTMODEL_USE_SQLITE__
+ TempFiles->RegisterL(KDatabaseOpenName, EFileTypeCnt);
+#endif // __SYMBIAN_CNTMODEL_USE_SQLITE__
+
+ TempFiles->RegisterL(KDatabaseFileName, EFileTypeCnt);
+
+ CntTest->CreateDatabaseL();
+ TInt err;
+
+#ifndef __SYMBIAN_CNTMODEL_USE_SQLITE__ //see comments above function TestDbUpdateL
+ test.Printf(KTestDbUpdate);
+ TRAP(err,TestDbUpdateL());
+ test(err==KErrNone);
+#endif // __SYMBIAN_CNTMODEL_USE_SQLITE__
+
+
+
+
+
+
+ test.Printf(KTest11Digitmatching);
+ TRAP(err,Test11DigitMatchingL());
+ test(err==KErrNone);
+
+ test.Printf(KTest15Digitmatching);
+ TRAP(err,Test15DigitMatchingL());
+ test(err==KErrNone);
+
+ test.Printf(KTestEmbeddedZeroes);
+ TRAP(err,TestEmbeddedZeroesL());
+ test(err==KErrNone);
+
+ test.Printf(KTestNoPhoneMatchLibrary);
+ TestNoPhoneMatchLibraryL();
+
+ test.Printf(KTestNewMatching);
+ TestNewMatchingL();
+
+
+ test.Printf(KTestFaxSMSMatching);
+ TestFaxSMSMatchingL();
+
+ test.Printf(KSpeedDialSimpleTest);
+ TRAP(err,SpeedDialSimpleTest());
+ test(err==KErrNone);
+
+ test.Printf(KTestRemovingSpeedDials);
+ TRAP(err,TestRemovingSpeedDialsL());
+ test(err==KErrNone);
+
+ CntTest->CloseDatabase();
+ CntTest->DeleteDatabaseL();
+
+ CleanupStack::PopAndDestroy(TempFiles);
+
+ // stop efsrv.lib warning on 8.1a wins
+ TEntry dummy;
+ (void)dummy.IsTypeValid();
+ }
+
+
+
+GLDEF_C TInt E32Main()
+ {
+ CntTest=new(ELeave) CCntTest;
+ CntTest->ConstructL(test,KDatabaseFileName);
+ TRAPD(err,DoTestsL());
+ test.Printf(_L("\n"));
+ CntTest->EndTestLib(err);
+
+ return KErrNone;
+ }