1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the Qt Mobility Components.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "ut_qtcontacts_trackerplugin.h"

    43 

    44 #include <QMap>

    45 #include <QPair>

    46 #include <QUuid>

    47 

    48 #include <QtTracker/Tracker>

    49 #include <QtTracker/ontologies/nco.h>

    50 #include <QtTracker/ontologies/nie.h>

    51 #include <qcontactfilters.h>

    52 #include <QContactChangeLogFilter>

    53 #include <qtcontacts.h>

    54 #include <trackerchangelistener.h>

    55 #include <qcontactrelationshipsaverequest.h>

    56 #include <qcontactrelationshipfetchrequest.h>

    57 #include <qtrackercontactidfetchrequest.h>

    58 #include <qcontacttrackerbackend_p.h>

    59 #include <qtrackercontactasyncrequest.h>

    60 

    61 #include "contactmanager.h"

    62 

    63 // update this when creating debian package

    64 const QString PATH_TO_SPARQL_TESTS("./ut_qtcontacts_trackerplugin_data");

    65 

    66 ut_qtcontacts_trackerplugin::ut_qtcontacts_trackerplugin()

    67 {

    68 

    69 }

    70 

    71 void ut_qtcontacts_trackerplugin::initTestCase()

    72 {

    73     QMap<QString, QString> trackerEngineParams;

    74     trackerEngine = new QContactTrackerEngine(trackerEngineParams);

    75     errorMap = new QMap<int, QContactManager::Error>();

    76 }

    77 

    78 void ut_qtcontacts_trackerplugin::testContacts()

    79 {

    80     QContact c1;

    81     QContact c2;

    82 

    83     trackerEngine->saveContact(&c1, error);

    84     trackerEngine->saveContact(&c2, error);

    85     QVERIFY2((error == QContactManager::NoError),"Saving contact");

    86     QList<QContactLocalId> contacts = trackerEngine->contactIds(queryFilter, sortOrders, error);

    87     QVERIFY2(contacts.contains(c1.localId()), "Previously added contact is not found");

    88     QVERIFY2(contacts.contains(c2.localId()), "Previously added contact is not found");

    89 }

    90 

    91 void ut_qtcontacts_trackerplugin::testContact()

    92 {

    93     // Test invalid contact id

    94     QContact invalidContact = trackerEngine->contact_impl( -1, error);

    95     QVERIFY(error != QContactManager::NoError);

    96 

    97     // Add a contact

    98     QContact newContact;

    99     const QContactLocalId oldid = newContact.localId();

   100     QVERIFY( trackerEngine->saveContact( &newContact, error ) );

   101 

   102     QContactLocalId id = newContact.localId();

   103     QVERIFY( id != oldid );

   104 

   105     // Find the added contact

   106     QContact c = trackerEngine->contact_impl( id, error );

   107     QVERIFY( c.localId() == newContact.localId() );

   108 }

   109 

   110 void ut_qtcontacts_trackerplugin::testSaveName()

   111 {

   112     QContact c;

   113     QContactLocalId initialId = c.localId();

   114     int detailsAdded = 0;

   115 

   116     QMap<QString,QString> nameValues;

   117     QContactName name;

   118     nameValues.insert(QLatin1String(QContactName::FieldPrefix), "Mr");

   119     nameValues.insert(QLatin1String(QContactName::FieldFirst), "John");

   120     nameValues.insert(QLatin1String(QContactName::FieldMiddle), "Rupert");

   121     nameValues.insert(QLatin1String(QContactName::FieldLast), "Doe");

   122 //    nameValues.insert(QContactName::FieldSuffix, "III");

   123 

   124     foreach (QString field, nameValues.keys()) {

   125         name.setValue(field, nameValues.value(field));

   126     }

   127     c.saveDetail(&name);

   128 

   129     QContactNickname nick;

   130     nick.setValue(QLatin1String(QContactNickname::FieldNickname), "Johnny");

   131     c.saveDetail(&nick);

   132 

   133     QVERIFY(c.detail<QContactName>().prefix() == "Mr");

   134     QVERIFY(c.detail<QContactName>().firstName() == "John");

   135     QVERIFY(c.detail<QContactName>().middleName() == "Rupert");

   136     QVERIFY(c.detail<QContactName>().lastName() == "Doe");

   137     QVERIFY(c.detail<QContactNickname>().nickname() == "Johnny");

   138 

   139     detailsAdded++;

   140 

   141     trackerEngine->saveContact(&c, error);

   142     QCOMPARE(error,  QContactManager::NoError);

   143     QVERIFY(c.localId() != initialId);

   144     QContact contact = trackerEngine->contact_impl(c.localId(), error);

   145     QList<QContactName> details = contact.details<QContactName>();

   146     QList<QContactNickname> details2 = contact.details<QContactNickname>();

   147     QCOMPARE(details.count(), detailsAdded);

   148     QCOMPARE(details2.count(), detailsAdded);

   149     // Name is unique

   150     foreach(QString field, nameValues.keys()) {

   151         QCOMPARE(details.at(0).value(field), nameValues.value(field));

   152     }

   153     QCOMPARE(details2.at(0).value(QLatin1String(QContactNickname::FieldNickname)), QString("Johnny"));

   154 

   155     // Try changing the name of the saved contact.

   156     {

   157         QMap<QString,QString> nameValues;

   158         QContactName name = c.detail<QContactName>();

   159         nameValues.insert(QLatin1String(QContactName::FieldPrefix), "Mr2");

   160         nameValues.insert(QLatin1String(QContactName::FieldFirst), "John2");

   161         nameValues.insert(QLatin1String(QContactName::FieldMiddle), "Rupert2");

   162         nameValues.insert(QLatin1String(QContactName::FieldLast), "");

   163         //    nameValues.insert(QContactName::FieldSuffix, "III");

   164 

   165         foreach (QString field, nameValues.keys()) {

   166             name.setValue(field, nameValues.value(field));

   167         }

   168         c.saveDetail(&name);

   169 

   170         QContactNickname nick = c.detail<QContactNickname>();

   171         nick.setValue(QLatin1String(QContactNickname::FieldNickname), "Johnny2");

   172         c.saveDetail(&nick);

   173 

   174 

   175         QVERIFY(trackerEngine->saveContact(&c, error));

   176         QCOMPARE(error,  QContactManager::NoError);

   177         QVERIFY(c.localId() != initialId);

   178 

   179         QContact contact = trackerEngine->contact_impl(c.localId(), error);

   180         QCOMPARE(error,  QContactManager::NoError);

   181         QList<QContactName> details = contact.details<QContactName>();

   182         QList<QContactNickname> details2 = contact.details<QContactNickname>();

   183         QCOMPARE(details.count(), detailsAdded);

   184         QCOMPARE(details2.count(), detailsAdded);

   185         // Name is unique

   186         foreach(QString field, nameValues.keys()) {

   187             QCOMPARE(details.at(0).value(field), nameValues.value(field));

   188         }

   189         QCOMPARE(details2.at(0).value(QLatin1String(QContactNickname::FieldNickname)), QString("Johnny2"));

   190 

   191         // now try to add new name detail fails - this is how currently unique fields are implemented

   192         // so cover it in unit tests

   193         QContactName name1;

   194         name1.setValue(QContactName::FieldFirst, "Something that wont be stored as name is unique");

   195         c.saveDetail(&name1);

   196         // validate that unique name is not saved

   197         QVERIFY(!trackerEngine->saveContact(&c, error));

   198         details = contact.details<QContactName>();

   199         details2 = contact.details<QContactNickname>();

   200         QCOMPARE(details.count(), detailsAdded);

   201         QCOMPARE(details2.count(), detailsAdded);

   202     }

   203 }

   204 

   205 void ut_qtcontacts_trackerplugin::testSavePhoneNumber()

   206 {

   207     // use the same values for 2 contacts

   208     for (int i = 0; i <2; i++ )

   209     {

   210     QContact c;

   211     QContactLocalId initialId = c.localId();

   212     int detailsAdded = 0;

   213     QContactName name;

   214     name.setFirstName("I have phone numbers");

   215     name.setLastName("Girl");

   216     c.saveDetail(&name);

   217 

   218     // key: phonenumber; value: context,subtype

   219     QMap<QString,QPair<QString,QString> > phoneValues;

   220 

   221     phoneValues.insert("(704)486-6472", QPair<QString,QString>(QLatin1String(QContactDetail::ContextHome), QString()));

   222     phoneValues.insert("(765)957-1663", QPair<QString,QString>(QLatin1String(QContactDetail::ContextHome), QString()));

   223     phoneValues.insert("(999)888-1111", QPair<QString,QString>(QLatin1String(QContactDetail::ContextHome),

   224                                                                QLatin1String(QContactPhoneNumber::SubTypeMobile)));

   225 

   226     phoneValues.insert("(792)123-6113", QPair<QString,QString>(QLatin1String(QContactDetail::ContextWork), QString()));

   227     phoneValues.insert("(918)491-7361", QPair<QString,QString>(QLatin1String(QContactDetail::ContextWork),

   228                                                   QLatin1String(QContactPhoneNumber::SubTypeMobile)));

   229     phoneValues.insert("(412)670-1514", QPair<QString,QString>(QLatin1String(QContactDetail::ContextWork),

   230                                                   QLatin1String(QContactPhoneNumber::SubTypeCar)));

   231     QMap<QString,QPair<QString,QString> > formattedPhoneValues;

   232 

   233 

   234     foreach (QString number, phoneValues.keys()) {

   235         QContactPhoneNumber phone;

   236         phone.setNumber(number);

   237         // Stripped automatically on saving RFC 3966 visual-separators reg exp "[(|-|.|)| ]"

   238         formattedPhoneValues.insert(QString(number).replace( QRegExp("[\\(|" \

   239                 "\\-|" \

   240                 "\\.|" \

   241                 "\\)|" \

   242                 " ]"), ""),phoneValues.value(number));

   243         if (!phoneValues.value(number).first.isEmpty()) {

   244             phone.setContexts(phoneValues.value(number).first);

   245         }

   246         if (!phoneValues.value(number).second.isEmpty()) {

   247             phone.setSubTypes(phoneValues.value(number).second);

   248         }

   249         c.saveDetail(&phone);

   250         detailsAdded++;

   251     }

   252 

   253     trackerEngine->saveContact(&c, error);

   254     QCOMPARE(error,  QContactManager::NoError);

   255     QVERIFY(c.localId() != initialId);

   256     // wait for commit transaction to be done, no signals yet

   257     for(int i = 0; i < 100; i++)

   258     {

   259         usleep(10000);

   260         QCoreApplication::processEvents();

   261     }

   262 

   263 

   264     // verify with synchronous read too

   265     QContact contact = trackerEngine->contact_impl(c.localId(), error);

   266     QCOMPARE(error,  QContactManager::NoError);

   267     QList<QContactPhoneNumber> details = contact.details<QContactPhoneNumber>();

   268 

   269 

   270     QCOMPARE(details.count(), detailsAdded);

   271 

   272 

   273     foreach (QContactPhoneNumber detail, details) {

   274         // Verify that the stored values and attributes are the same as given

   275         QVERIFY(formattedPhoneValues.contains(detail.number()));

   276         QCOMPARE(detail.contexts()[0], formattedPhoneValues.value(detail.number()).first);

   277         if( formattedPhoneValues.value(detail.number()).second.isEmpty()) // default empty is voice

   278             QCOMPARE(detail.subTypes()[0], QLatin1String(QContactPhoneNumber::SubTypeVoice));

   279         else

   280             QCOMPARE(detail.subTypes()[0], formattedPhoneValues.value(detail.number()).second);

   281     }

   282 

   283     // edit one of numbers . values, context and subtypes and save again

   284     QString editedPhoneValue = "+7044866473";

   285     QContactPhoneNumber phone = details[0];

   286     phone.setNumber(editedPhoneValue);

   287     phone.setContexts(QContactDetail::ContextWork);

   288     phone.setSubTypes(QContactPhoneNumber::SubTypeMobile);

   289     c = contact;

   290     c.saveDetail(&phone);

   291     trackerEngine->saveContact(&c, error);

   292     QCOMPARE(error,  QContactManager::NoError);

   293     c = this->contact(c.localId(), QStringList()<<QContactPhoneNumber::DefinitionName);

   294     details = c.details<QContactPhoneNumber>();

   295     QCOMPARE(details.count(), detailsAdded);

   296     bool found = false;

   297     foreach (QContactPhoneNumber detail, details) {

   298         if(detail.number() == phone.number())

   299         {

   300             found = true;

   301             QVERIFY(detail.subTypes().contains(QContactPhoneNumber::SubTypeMobile));

   302             QVERIFY(detail.contexts().contains(QContactPhoneNumber::ContextWork));

   303             break;

   304         }

   305     }

   306     QVERIFY(found);

   307     }

   308 }

   309 

   310 void ut_qtcontacts_trackerplugin::testPhoneNumberContext()

   311 {

   312     QContact c;

   313     QContactPhoneNumber phone;

   314     phone.setContexts(QContactDetail::ContextHome);

   315     phone.setNumber("555-888");

   316     phone.setSubTypes(QContactPhoneNumber::SubTypeMobile);

   317     c.saveDetail(&phone);

   318     QContact contactToSave = c;

   319     // Let's do this all twice, first time save new detail, and next iteration change the context

   320     for (int iterations = 0; iterations < 2; iterations++) {

   321         QVERIFY(trackerEngine->saveContact(&contactToSave, error));

   322         // wait for commit transaction to be done, no signals yet

   323         for(int i = 0; i < 100; i++) {

   324             usleep(10000);

   325             QCoreApplication::processEvents();

   326         }

   327 

   328         QContactFetchRequest request;

   329         QContactLocalIdFilter filter;

   330         QList<QContactLocalId> ids;

   331         ids.append(contactToSave.localId());

   332         filter.setIds(ids);

   333         request.setFilter(filter);

   334 

   335         QStringList details;

   336         details << QContactPhoneNumber::DefinitionName;

   337         request.setDefinitionRestrictions(details);

   338 

   339         Slots slot;

   340         QObject::connect(&request, SIGNAL(progress(QContactFetchRequest*, bool)),

   341                 &slot, SLOT(progress(QContactFetchRequest*, bool )));

   342 

   343         trackerEngine->startRequest(&request);

   344 

   345         for(int i = 0; i < 100; i++) {

   346             usleep(100000);

   347             QCoreApplication::processEvents();

   348             if(request.isFinished() )

   349                 break;

   350         }

   351 

   352         // if it takes more, then something is wrong

   353         QVERIFY(request.isFinished());

   354         QVERIFY(!slot.contacts.isEmpty());

   355 

   356         QContact contactToTest;

   357         foreach (QContact savedContact, slot.contacts) {

   358             if (savedContact.localId() == contactToSave.localId()) {

   359                 contactToTest = savedContact;

   360             }

   361         }

   362         QVERIFY(contactToTest.localId() == contactToSave.localId()); // Just to be sure we got the saved contact

   363         qDebug()<<contactToTest.details<QContactPhoneNumber>().count();

   364         

   365         QVERIFY(contactToTest.details<QContactPhoneNumber>().count() == 1);

   366         if (0 == iterations) {

   367             // perform context change

   368             QContactPhoneNumber phoneToEdit = contactToTest.detail<QContactPhoneNumber>();

   369             phoneToEdit.setContexts(QContactDetail::ContextWork);

   370             contactToTest.saveDetail(&phoneToEdit);

   371             contactToSave = contactToTest;

   372         }

   373         QVERIFY(contactToTest.details<QContactPhoneNumber>().count() == 1);

   374     }

   375 }

   376 

   377 void ut_qtcontacts_trackerplugin::testWritingOnlyWorkMobile()

   378 {

   379     QContact c;

   380     QContactPhoneNumber phone;

   381     phone.setContexts(QContactDetail::ContextWork);

   382     phone.setNumber("555999");

   383     phone.setSubTypes(QContactPhoneNumber::SubTypeMobile);

   384     c.saveDetail(&phone);

   385     QContact& contactToSave = c;

   386     QVERIFY(trackerEngine->saveContact(&contactToSave, error));

   387     // wait for commit transaction to be done, no signals yet

   388     for(int i = 0; i < 100; i++) {

   389         usleep(10000);

   390         QCoreApplication::processEvents();

   391     }

   392 

   393     QContactFetchRequest request;

   394     QContactLocalIdFilter filter;

   395     QList<QContactLocalId> ids;

   396     ids.append(contactToSave.localId());

   397     filter.setIds(ids);

   398     request.setFilter(filter);

   399     QStringList details;

   400     details << QContactPhoneNumber::DefinitionName;

   401     request.setDefinitionRestrictions(details);

   402 

   403     Slots slot;

   404     QObject::connect(&request, SIGNAL(progress(QContactFetchRequest*, bool)),

   405             &slot, SLOT(progress(QContactFetchRequest*, bool )));

   406 

   407     trackerEngine->startRequest(&request);

   408 

   409     for(int i = 0; i < 100; i++) {

   410         usleep(100000);

   411         QCoreApplication::processEvents();

   412         if(request.isFinished() )

   413             break;

   414     }

   415 

   416     // if it takes more, then something is wrong

   417     QVERIFY(request.isFinished());

   418     QVERIFY(!slot.contacts.isEmpty());

   419 

   420     QContact contactToTest;

   421     foreach (QContact savedContact, slot.contacts) {

   422         if (savedContact.localId() == c.localId()) {

   423             contactToTest = savedContact;

   424         }

   425     }

   426     QVERIFY(contactToTest.localId() == c.localId()); // Just to be sure we got the saved contact

   427     QVERIFY(contactToTest.details<QContactPhoneNumber>().count() == 1);

   428     QVERIFY(contactToTest.detail<QContactPhoneNumber>().number() == phone.number());

   429     QVERIFY(contactToTest.detail<QContactPhoneNumber>().subTypes() == phone.subTypes());

   430     QVERIFY(contactToTest.detail<QContactPhoneNumber>().contexts() == phone.contexts());

   431 }

   432 

   433 void ut_qtcontacts_trackerplugin::testSaveAddress()

   434 {

   435     QContact c;

   436     QContactName name;

   437     name.setFirstName("Aruba & Barbados");

   438     name.setLastName("Girl");

   439     c.saveDetail(&name);

   440     QContactLocalId initialId = c.localId();

   441     int detailsAdded = 0;

   442 

   443     // List of pairs of field-value map and context

   444     typedef QMap<QString,QString> typeAddress;

   445     typedef QPair<typeAddress,QString> typeAddressWithContext;

   446     QList<typeAddressWithContext> addressValues;

   447 

   448     // TODO check status of 137174 and other libqttracker1pre6 bugs before refactoring

   449     typeAddress values;

   450     values.insert(QLatin1String(QContactAddress::FieldCountry), "Barbados");

   451     values.insert(QLatin1String(QContactAddress::FieldPostcode), "55555");

   452     values.insert(QLatin1String(QContactAddress::FieldStreet), "Martindales Rd");

   453     values.insert(QLatin1String(QContactAddress::FieldRegion), "Bridgetown");

   454     addressValues.append(typeAddressWithContext(values, QLatin1String(QContactDetail::ContextHome)));

   455     values.clear();

   456     values.insert(QLatin1String(QContactAddress::FieldCountry), "Aruba");

   457     values.insert(QLatin1String(QContactAddress::FieldPostcode), "44444");

   458     values.insert(QLatin1String(QContactAddress::FieldStreet), "Brazilie Straat");

   459     values.insert(QLatin1String(QContactAddress::FieldRegion), "Oranjestad");

   460     addressValues.append(typeAddressWithContext(values, QLatin1String(QContactDetail::ContextHome)));

   461     values.clear();

   462     values.insert(QLatin1String(QContactAddress::FieldCountry), "ArubaWork");

   463     values.insert(QLatin1String(QContactAddress::FieldPostcode), "44445");

   464     values.insert(QLatin1String(QContactAddress::FieldStreet), "Sunset Blvd");

   465     values.insert(QLatin1String(QContactAddress::FieldRegion), "Oranjestad");

   466     addressValues.append(typeAddressWithContext(values, QLatin1String(QContactDetail::ContextHome)));

   467     foreach (typeAddressWithContext addressWithContext, addressValues) {

   468         QContactAddress address;

   469         foreach (QString field, addressWithContext.first.keys()) {

   470             address.setValue(field, addressWithContext.first.value(field));

   471         }

   472         address.setContexts(addressWithContext.second);

   473         c.saveDetail(&address);

   474         detailsAdded++;

   475     }

   476 

   477     trackerEngine->saveContact(&c, error);

   478     QCOMPARE(error,  QContactManager::NoError);

   479     QVERIFY(c.localId() != initialId);

   480     QContact contact = trackerEngine->contact_impl(c.localId(), error);

   481     QList<QContactAddress> details = contact.details<QContactAddress>();

   482     QCOMPARE(details.count(), detailsAdded);

   483     bool found = false;

   484     // Test if inserted values are found in some of the details

   485     foreach (typeAddressWithContext addressWithContext, addressValues) {

   486         foreach (QContactAddress detail, details) {

   487             foreach (QString field, addressWithContext.first.keys()) {

   488                 found = (detail.value(field) == addressWithContext.first.value(field));

   489                 if (!found)

   490                     break;

   491             }

   492             if (found)

   493                 break;

   494         }

   495         QVERIFY2(found, "Inserted detail was not found in the fetched details");

   496     }

   497 }

   498 

   499 void ut_qtcontacts_trackerplugin::testSaveEmailAddress()

   500 {

   501     QContact c;

   502     QContactLocalId initialId = c.localId();

   503     int detailsAdded = 0;

   504 

   505     QMap<QString,QString> values;

   506     values.insert("john.does@hotmail.com", QContactDetail::ContextHome);

   507     values.insert("john.doe@gmail.com", QContactDetail::ContextWork);

   508     values.insert("john.doe@nokia.com", QContactDetail::ContextWork);

   509     values.insert("john.doe@johndoe.com", QContactDetail::ContextHome);

   510     foreach(QString address, values.keys()) {

   511         QContactEmailAddress emailAddress;

   512         emailAddress.setEmailAddress(address);

   513         emailAddress.setContexts(values.value(address));

   514         c.saveDetail(&emailAddress);

   515         detailsAdded++;

   516     }

   517     QContactName name;

   518     name.setFirstName("Jo");

   519     name.setLastName("H N Doe");

   520     c.saveDetail(&name);

   521     trackerEngine->saveContact(&c, error);

   522     QCOMPARE(error,  QContactManager::NoError);

   523     QVERIFY(c.localId() != initialId);

   524     QContact contact = trackerEngine->contact_impl(c.localId(), error);

   525     QList<QContactEmailAddress> details = contact.details<QContactEmailAddress>();

   526     QCOMPARE(details.count(), detailsAdded);

   527     foreach (QContactEmailAddress detail, details) {

   528         QString address = detail.value(QContactEmailAddress::FieldEmailAddress);

   529         QVERIFY(values.contains(address));

   530         QCOMPARE(detail.contexts()[0], values.value(address));

   531     }

   532 }

   533 

   534 void ut_qtcontacts_trackerplugin::testRemoveContact()

   535 {

   536     QContact c;

   537     QContactPhoneNumber phone;

   538     phone.setNumber("+358501234567");

   539     c.saveDetail(&phone);

   540     QContactEmailAddress email;

   541     email.setEmailAddress("super.man@hotmail.com");

   542     c.saveDetail(&email);

   543     QContactName name;

   544     name.setFirstName("Super");

   545     name.setLastName("Man");

   546     c.saveDetail(&name);

   547 

   548     QVERIFY2(trackerEngine->saveContact(&c, error) && error == QContactManager::NoError, "Saving a contact failed");

   549     QVERIFY2(trackerEngine->removeContact(c.localId(), error), "Removing a contact failed");

   550     QCOMPARE(error, QContactManager::NoError);

   551     QVERIFY2(trackerEngine->contact_impl(c.localId(), error) == QContact(), "Found a contact, which should have been removed");

   552 }

   553 

   554 void ut_qtcontacts_trackerplugin::testSaveContacts()

   555 {

   556     QList<QContact> contacts;

   557     for (int i = 0; i < 3; i++) {

   558         QContact c;

   559         QContactName name;

   560         name.setFirstName("John");

   561         name.setLastName(QString::number(i,10));

   562         c.saveDetail(&name);

   563         contacts.append(c);

   564     }

   565 

   566     QMap<int, QContactManager::Error>* errorMap;    

   567     trackerEngine->saveContacts(&contacts, errorMap, error);

   568     QCOMPARE(error, QContactManager::NoError);

   569     for (int i = 0; i < contacts.count(); i++) {

   570         QVERIFY(contacts[i].localId() != 0);

   571         QList<QContactName> details = trackerEngine->contact_impl(contacts[i].localId(), error).details<QContactName>();

   572         QVERIFY(details.count());

   573         QCOMPARE(details.at(0).lastName(),

   574                  QString("%1").arg(QString::number(i,10)));

   575     }

   576 }

   577 

   578 void ut_qtcontacts_trackerplugin::testRemoveContacts()

   579 {

   580     QList<QContactLocalId> addedIds;

   581     for (int i = 0; i < 5; i++) {

   582         QContact c;

   583         QContactName name;

   584         name.setFirstName(QString("John%1").arg(QString::number(i,10)));

   585         c.saveDetail(&name);

   586         QVERIFY2(trackerEngine->saveContact(&c, error) && error == QContactManager::NoError, "Saving a contact failed");

   587         addedIds.append(c.localId());

   588     }

   589     QList<QContactLocalId> toApiRemove;

   590     toApiRemove.append(addedIds.takeLast());

   591     toApiRemove.append(addedIds.takeLast());

   592     QList<QContactLocalId> toPluginRemove(addedIds);

   593     // Remove all, but last of the added contacts

   594     bool success = trackerEngine->removeContacts(&toPluginRemove, errorMap, error);

   595     QCOMPARE(success, true);

   596     for (int i = 0; i < errorMap->count(); i++) {

   597         QVERIFY(toPluginRemove[i] == 0);

   598     }

   599     QCOMPARE(error, QContactManager::NoError);

   600 

   601     success = ContactManager::instance()->removeContacts(&toApiRemove, errorMap);

   602     QCOMPARE(success, true);

   603     for (int i = 0; i < errorMap->count(); i++) {

   604         QVERIFY(toApiRemove[i] == 0);

   605     }

   606 

   607     // Try to remove some previously removed contacts, but one valid contact

   608     success = trackerEngine->removeContacts(&addedIds, errorMap, error);

   609     QCOMPARE(errorMap->count(), addedIds.count());

   610     for (int i = 0; i < errorMap->count() - 1; i++) {

   611         QVERIFY2(addedIds[i] != 0, "Manager should not mark id as zero");

   612     }

   613 }

   614 

   615 void ut_qtcontacts_trackerplugin::testAvatar()

   616 {

   617     QContact contactWithAvatar;

   618     QContactAvatar avatar;

   619 

   620     avatar.setAvatar("file:///home/user/.contacts/avatars/default_avatar.png");

   621     contactWithAvatar.saveDetail(&avatar);

   622     QContactName name;

   623     name.setFirstName("John");name.setLastName("A Frog");

   624     contactWithAvatar.saveDetail(&name);

   625     QVERIFY(trackerEngine->saveContact( &contactWithAvatar, error));

   626 

   627     QContact c = trackerEngine->contact_impl( contactWithAvatar.localId(), error);

   628     QList<QContactAvatar> avatars = c.details<QContactAvatar>();

   629     QVERIFY( avatars.size() );

   630     QCOMPARE( avatars[0].avatar(), avatar.avatar() );

   631 }

   632 

   633 void ut_qtcontacts_trackerplugin::testUrl()

   634 {

   635 

   636     //Context home, homepage url

   637     QContact contactWithUrl1;

   638     QContactUrl url1;

   639     url1.setUrl("http://home.homepage");

   640     url1.setContexts(QContactDetail::ContextHome);

   641     url1.setSubType(QContactUrl::SubTypeHomePage);

   642     QContactName name;

   643     name.setFirstName("John");name.setLastName("TestUrl1");

   644     contactWithUrl1.saveDetail(&name);

   645     contactWithUrl1.saveDetail(&url1);

   646     QVERIFY(trackerEngine->saveContact(&contactWithUrl1, error));

   647 

   648     //Context work, homepage url

   649     QContact contactWithUrl2;

   650     QContactUrl url2;

   651     url2.setUrl("http://work.homepage");

   652     url2.setContexts(QContactDetail::ContextWork);

   653     url2.setSubType(QContactUrl::SubTypeHomePage);

   654     QContactName name2;

   655     name2.setLastName("TestUrl2");

   656     contactWithUrl2.saveDetail(&name2);

   657     contactWithUrl2.saveDetail(&url2);

   658     QVERIFY(trackerEngine->saveContact(&contactWithUrl2, error));

   659 

   660     //Context home, favourite url

   661     QContact contactWithUrl3;

   662     QContactUrl url3;

   663     url3.setUrl("http://home.favourite");

   664     url3.setContexts(QContactDetail::ContextHome);

   665     url3.setSubType(QContactUrl::SubTypeFavourite);

   666 

   667     name2.setLastName("TestUrl3");

   668     contactWithUrl3.saveDetail(&name2);

   669     contactWithUrl3.saveDetail(&url3);

   670     QVERIFY(trackerEngine->saveContact(&contactWithUrl3, error));

   671 

   672 

   673     QContactLocalId id1 = contactWithUrl1.localId();

   674     QContactLocalId id2 = contactWithUrl2.localId();

   675     QContactLocalId id3 = contactWithUrl3.localId();

   676     QCOMPARE(trackerEngine->contact_impl(id1, error).detail<QContactUrl>().url(), QString("http://home.homepage"));

   677     QCOMPARE(trackerEngine->contact_impl(id2, error).detail<QContactUrl>().url(), QString("http://work.homepage"));

   678     QCOMPARE(trackerEngine->contact_impl(id3, error).detail<QContactUrl>().url(), QString("http://home.favourite"));

   679 

   680     QVERIFY(trackerEngine->contact_impl(id1, error).detail<QContactUrl>().contexts()[0] ==

   681             QContactDetail::ContextHome );

   682     QVERIFY(trackerEngine->contact_impl(id2, error).detail<QContactUrl>().contexts()[0] ==

   683             QContactDetail::ContextWork );

   684     QVERIFY(trackerEngine->contact_impl(id3, error).detail<QContactUrl>().contexts()[0] ==

   685             QContactDetail::ContextHome );

   686 

   687     QVERIFY(trackerEngine->contact_impl(id1, error).detail<QContactUrl>().subType() ==

   688             QContactUrl::SubTypeHomePage );

   689     QVERIFY(trackerEngine->contact_impl(id2, error).detail<QContactUrl>().subType() ==

   690             QContactUrl::SubTypeHomePage );

   691     QVERIFY(trackerEngine->contact_impl(id3, error).detail<QContactUrl>().subType() ==

   692             QContactUrl::SubTypeFavourite );

   693 

   694 }

   695 

   696 /*

   697 void ut_qtcontacts_trackerplugin::testGroups()

   698 {

   699     qDebug() << "Not implemented";

   700     QVERIFY(false);

   701 }

   702 

   703 void ut_qtcontacts_trackerplugin::testGroup()

   704 {

   705     qDebug() << "Not implemented";

   706     QVERIFY(false);

   707 }

   708 

   709 void ut_qtcontacts_trackerplugin::testSaveGroup()

   710 {

   711     qDebug() << "Not implemented";

   712     QVERIFY(false);

   713 }

   714 

   715 void ut_qtcontacts_trackerplugin::testRemoveGroup()

   716 {

   717     qDebug() << "Not implemented";

   718     QVERIFY(false);

   719 }

   720 

   721 void ut_qtcontacts_trackerplugin::testDetailDefinitions()

   722 {

   723     qDebug() << "Not implemented";

   724     QVERIFY(false);

   725 }

   726 

   727 void ut_qtcontacts_trackerplugin::testDetailDefinition()

   728 {

   729     qDebug() << "Not implemented";

   730     QVERIFY(false);

   731 }

   732 

   733 void ut_qtcontacts_trackerplugin::testSaveDetailDefinition()

   734 {

   735     qDebug() << "Not implemented";

   736     QVERIFY(false);

   737 }

   738 

   739 void ut_qtcontacts_trackerplugin::testRemoveDetailDefinition()

   740 {

   741     qDebug() << "Not implemented";

   742     QVERIFY(false);

   743 }

   744 */

   745 

   746 void ut_qtcontacts_trackerplugin::testSyncContactManagerContactsAddedSince()

   747 {

   748     QDateTime start;

   749     QList<QContactLocalId> addedIds;

   750     syncContactsAddedSinceHelper(start, addedIds);

   751 

   752     QContactChangeLogFilter filter(QContactChangeLogFilter::EventAdded);

   753     filter.setSince(start);

   754 

   755     QList<QContactSortOrder> sortOrder;

   756     

   757     QList<QContact> contactIds = ContactManager::instance()->contacts( filter, sortOrder, QStringList() );

   758     qDebug() << "addedIds" << addedIds.size();

   759     qDebug() << "contactIds" << contactIds.size();

   760     QEXPECT_FAIL("", "ContactManager is returning an empty list", Continue);

   761     QVERIFY2( contactIds.size() == addedIds.size(), "Incorrect number of filtered contacts");

   762 }

   763 

   764 void ut_qtcontacts_trackerplugin::testSyncTrackerEngineContactsIdsAddedSince()

   765 {

   766     QDateTime start;

   767     QList<QContactLocalId> addedIds;

   768     syncContactsAddedSinceHelper(start, addedIds);

   769 

   770     QContactChangeLogFilter filter(QContactChangeLogFilter::EventAdded);

   771     filter.setSince(start);

   772 

   773     QList<QContactSortOrder> sortOrder;

   774     QContactManager::Error error;

   775 

   776     QList<QContactLocalId> contactIds = trackerEngine->contactIds( filter, sortOrder, error );

   777     qDebug() << "addedIds" << addedIds;

   778     qDebug() << "contactIds" << contactIds;

   779     QVERIFY2( contactIds.size() == addedIds.size(), "Incorrect number of filtered contacts");

   780 }

   781 

   782 void ut_qtcontacts_trackerplugin::testSyncContactManagerContactIdsAddedSince()

   783 {

   784     QDateTime start;

   785     QList<QContactLocalId> addedIds;

   786     syncContactsAddedSinceHelper(start, addedIds);

   787     QContactChangeLogFilter filter(QContactChangeLogFilter::EventAdded);

   788     filter.setSince(start);

   789     QList<QContactSortOrder> sortOrder;

   790 

   791 

   792     QList<QContactLocalId> contactIds = ContactManager::instance()->contactIds(filter, sortOrder);

   793     qDebug() << "addedIds" << addedIds;

   794     qDebug() << "contactIds" << contactIds;

   795     QEXPECT_FAIL("", "ContactManager is returning an empty list", Continue);

   796     QVERIFY2( contactIds.size() == addedIds.size(), "Incorrect number of filtered contacts");

   797 }

   798 

   799 

   800 void ut_qtcontacts_trackerplugin::syncContactsAddedSinceHelper(QDateTime& start, QList<QContactLocalId>& addedIds)

   801 {

   802     for (int i = 0; i < 3; i++) {

   803         QContact c;

   804         QContactName name;

   805         name.setFirstName("A"+QString::number(i));

   806         QVERIFY2(c.saveDetail(&name), "Failed to save detail");

   807         QVERIFY2(trackerEngine->saveContact(&c, error), "Failed to save contact");

   808     }

   809 

   810     QTest::qWait(1000);

   811     start = QDateTime::currentDateTime();

   812 

   813     for (int i = 0; i < 3; i++) {

   814         QContact c;

   815         QContactName name;

   816         name.setFirstName("B"+QString::number(i));

   817         QVERIFY2(c.saveDetail(&name), "Failed to save detail");

   818         QVERIFY2(trackerEngine->saveContact(&c, error), "Failed to save contact");

   819         addedIds.append(c.localId());

   820     }

   821 }

   822 

   823 void ut_qtcontacts_trackerplugin::testContactsAddedSince()

   824 {

   825     QList<QContactLocalId> addedIds;

   826     QDateTime start;

   827     for (int i = 0; i < 3; i++) {

   828         QContact c;

   829         QContactName name;

   830         name.setFirstName("A"+QString::number(i));

   831         QVERIFY2(c.saveDetail(&name), "Failed to save detail");

   832         QVERIFY2(trackerEngine->saveContact(&c, error), "Failed to save contact");

   833     }

   834 

   835     QTest::qWait(1000);

   836     start = QDateTime::currentDateTime();

   837 

   838     for (int i = 0; i < 3; i++) {

   839         QContact c;

   840         QContactName name;

   841         name.setFirstName("B"+QString::number(i));

   842         QVERIFY2(c.saveDetail(&name), "Failed to save detail");

   843         QVERIFY2(trackerEngine->saveContact(&c, error), "Failed to save contact");

   844         addedIds.append(c.localId());

   845     }

   846 

   847     // now one asynchronous request to read all the

   848     QContactFetchRequest request;

   849     QContactChangeLogFilter filter(QContactChangeLogFilter::EventAdded);

   850     filter.setSince(start);

   851     request.setFilter(filter);

   852 

   853     // here You specify which details are of interest

   854     QStringList details;

   855     details << QContactAvatar::DefinitionName

   856             << QContactBirthday::DefinitionName

   857             << QContactAddress::DefinitionName

   858             << QContactEmailAddress::DefinitionName

   859             << QContactDisplayLabel::DefinitionName

   860             << QContactGender::DefinitionName

   861             << QContactAnniversary::DefinitionName

   862             << QContactName::DefinitionName

   863             << QContactOnlineAccount::DefinitionName

   864             << QContactOrganization::DefinitionName

   865             << QContactPhoneNumber::DefinitionName;

   866     request.setDefinitionRestrictions(details);

   867 

   868     Slots slot;

   869     QObject::connect(&request, SIGNAL(progress(QContactFetchRequest*, bool)),

   870             &slot, SLOT(progress(QContactFetchRequest*, bool )));

   871 

   872     // start. clients should, instead of following use

   873     // request.setManager(trackermanagerinstance);

   874     // request.start();

   875     trackerEngine->startRequest(&request);

   876     trackerEngine->waitForRequestFinished(&request, 10000);

   877     // if it takes more, then something is wrong

   878     QVERIFY(request.isFinished());

   879     QCOMPARE(slot.contacts.count(), addedIds.count());

   880 

   881     foreach(QContact cont, slot.contacts) {

   882         QVERIFY2(addedIds.contains(cont.localId()), "One of the added contacts was not reported as added");

   883     }

   884 

   885     QContactLocalIdFetchRequest idreq;

   886     filter.setSince(start);

   887     idreq.setFilter(filter);

   888 

   889     Slots slot2;

   890     QObject::connect(&idreq, SIGNAL(progress(QContactLocalIdFetchRequest*, bool)),

   891             &slot2, SLOT(progress(QContactLocalIdFetchRequest*, bool )));

   892     trackerEngine->startRequest(&idreq);

   893     trackerEngine->waitForRequestFinished(&idreq, 10000);

   894     QVERIFY(idreq.isFinished());

   895     QCOMPARE(slot2.ids.count(), addedIds.count());

   896     foreach(QContactLocalId id, slot2.ids) {

   897         QVERIFY2(addedIds.contains(id), "One of the added contacts was not reported as added");

   898     }

   899 

   900 }

   901 

   902 void ut_qtcontacts_trackerplugin::testContactsModifiedSince()

   903 {

   904     QDateTime start;

   905     QList<QContactLocalId> addedIds;

   906     QList<QContactLocalId> modified;

   907 

   908     const int contactsToAdd = 5;

   909     const int contactsToModify = 3;

   910     QVERIFY2(contactsToAdd >= contactsToModify, "Cannot modify more contacts than this test has added");

   911     QVERIFY2(contactsToModify+1 <= contactsToAdd, "Cannot modify more contacts than this test has added");

   912 

   913     // Add contacts with only first name and store them to list of added

   914     for (int i = 0; i < contactsToAdd; i++) {

   915         QContact c;

   916         QContactName name;

   917         name.setFirstName("A"+QString::number(i));

   918         QVERIFY2(c.saveDetail(&name), "Failed to save detail");

   919         QVERIFY2(trackerEngine->saveContact(&c, error), "Failed to save contact");

   920         addedIds.append(c.localId());

   921     }

   922 

   923     QTest::qWait(2000);

   924     start = QDateTime::currentDateTime();

   925 

   926    // Modify and save rest of the contacts

   927     for (int i = 0; i < contactsToModify; i++) {

   928         QContact c = trackerEngine->contact_impl(addedIds[i], error);

   929         QContactName name = c.detail<QContactName>();

   930         // Modify name

   931         name.setFirstName("B"+QString::number(i));

   932         QVERIFY2(c.saveDetail(&name), "Failed to save detail");

   933         QVERIFY2(trackerEngine->saveContact(&c, error), "Failed to save contact");

   934         modified.append(c.localId());

   935     }

   936     // Set filter

   937     QContactChangeLogFilter filter(QContactChangeLogFilter::EventChanged);

   938     filter.setSince(start);

   939 

   940     QContactLocalIdFetchRequest idfetch;

   941     QContactFetchRequest fetch;

   942     idfetch.setFilter(filter);

   943     fetch.setFilter(filter);

   944     trackerEngine->startRequest(&idfetch);

   945     trackerEngine->waitForRequestFinished(&idfetch, 10000);

   946     QVERIFY2(idfetch.isFinished(), "Id fetch request did not finish on time");

   947     QVERIFY2(idfetch.error() == QContactManager::NoError, "Id fetch request finished with errors");

   948     QList<QContactLocalId> actuallyModifiedIds = idfetch.ids();

   949     trackerEngine->startRequest(&fetch);

   950     trackerEngine->waitForRequestFinished(&fetch, 10000);

   951     QVERIFY2(fetch.isFinished(), "Fetch request did not finish on time");

   952     QVERIFY2(fetch.error() == QContactManager::NoError, "Fetch request finished with errors");

   953     QList<QContact> actuallyModified = fetch.contacts();

   954 

   955     // Num of actually modified should be same as supposedly modified

   956     QCOMPARE(actuallyModifiedIds.count(), modified.count());

   957     QCOMPARE(actuallyModified.count(), modified.count());

   958     // All the ids of the modified contacts should be found in the result list

   959     foreach (QContactLocalId id, modified) {

   960         QVERIFY2(actuallyModifiedIds.contains(id), "One the modified contacts was not reported as modified");

   961     }

   962 }

   963 

   964 void ut_qtcontacts_trackerplugin::testContactsRemovedSince()

   965 {

   966     QDateTime start = QDateTime::currentDateTime();

   967     QContactChangeLogFilter filter(QContactChangeLogFilter::EventRemoved);

   968     filter.setSince(start);

   969     QList<QContactSortOrder> sorts;

   970     QList<QContactLocalId> actuallyRemoved = trackerEngine->contactIds(filter, sorts, error);

   971     QVERIFY(actuallyRemoved.isEmpty());

   972     QVERIFY(error == QContactManager::NotSupportedError);

   973 }

   974 /*

   975 void ut_qtcontacts_trackerplugin::testGroupsAddedSince()

   976 {

   977     qDebug() << "Not implemented";

   978     QVERIFY(false);

   979 }

   980 

   981 void ut_qtcontacts_trackerplugin::testGroupsModifiedSince()

   982 {

   983     qDebug() << "Not implemented";

   984     QVERIFY(false);

   985 }

   986 

   987 void ut_qtcontacts_trackerplugin::testGroupsRemovedSince()

   988 {

   989     qDebug() << "Not implemented";

   990     QVERIFY(false);

   991 }

   992 */

   993 

   994 void ut_qtcontacts_trackerplugin::cleanupTestCase()

   995 {

   996     delete trackerEngine;

   997     delete errorMap;

   998 }

   999 

  1000 void ut_qtcontacts_trackerplugin::cleanup()

  1001 {

  1002     foreach (QContactLocalId id, addedContacts) {

  1003         trackerEngine->removeContact(id, error);

  1004     }

  1005     addedContacts.clear();

  1006 }

  1007 

  1008 

  1009 void ut_qtcontacts_trackerplugin::testNcoTypes()

  1010 {

  1011     using namespace SopranoLive;

  1012 

  1013     QList<QContactLocalId> ids;

  1014     RDFVariable RDFContact = RDFVariable::fromType<nco::PersonContact>();

  1015     RDFSelect query;

  1016 

  1017     query.addColumn("contact_uri", RDFContact);

  1018     query.addColumn("contactId", RDFContact.property<nco::contactUID>());

  1019     LiveNodes ncoContacts = ::tracker()->modelQuery(query);

  1020     foreach( Live<nco::PersonContact> p, ncoContacts ) {

  1021         QVERIFY(p.hasType<nco::Contact>());

  1022         QVERIFY(p.hasType<nco::Role>());

  1023         QVERIFY(p.hasType<nco::PersonContact>());

  1024     }

  1025 }

  1026 

  1027 void ut_qtcontacts_trackerplugin::testAsyncReadContacts()

  1028 {

  1029     addedContacts.clear();

  1030     // Add at least one contact to be sure that this doesn't fail because tracker is clean

  1031 

  1032     QStringList firstNames, lastNames;

  1033     firstNames << "aa" << "ab" << "ac" << "dd" << "fe";

  1034     lastNames << "fe" << "ab" << "dd" << "dd" << "aa";

  1035     for (int i = 0; i < firstNames.count(); i++) {

  1036         QContact c;

  1037         QContactName name;

  1038         name.setFirstName(firstNames.at(i));

  1039         name.setLastName(lastNames.at(i));

  1040         QContactAvatar avatar;

  1041         avatar.setAvatar("default_avatar.png");

  1042         avatar.setSubType(QContactAvatar::SubTypeImage);

  1043         QVERIFY(c.saveDetail(&name));

  1044         QVERIFY(c.saveDetail(&avatar));

  1045         QVERIFY(trackerEngine->saveContact(&c, error));

  1046         addedContacts.append(c.localId());

  1047     }

  1048     

  1049     // Prepare the filter for the request - we really should test only the contact we add here.

  1050     QContactLocalIdFilter filter;

  1051     filter.setIds(addedContacts);

  1052 

  1053     // this one will get complete contacts

  1054 

  1055     Slots slot;

  1056     QContactFetchRequest request;

  1057     QList<QContactSortOrder> sorting;

  1058     QContactSortOrder sort, sort1;

  1059     sort.setDetailDefinitionName(QContactName::DefinitionName, QContactName::FieldLast);

  1060     sort1.setDetailDefinitionName(QContactName::DefinitionName, QContactName::FieldFirst);

  1061     sorting << sort << sort1;

  1062     QStringList details; details << QContactName::DefinitionName << QContactAvatar::DefinitionName;

  1063     request.setDefinitionRestrictions(details);

  1064     request.setSorting(sorting);

  1065     request.setFilter(filter);

  1066 

  1067     QObject::connect(&request, SIGNAL(progress(QContactFetchRequest*, bool)),

  1068             &slot, SLOT(progress(QContactFetchRequest*, bool )));

  1069 

  1070     // this one only ids

  1071     QContactLocalIdFetchRequest request1;

  1072     request1.setFilter(filter);

  1073     QObject::connect(&request1, SIGNAL(progress(QContactLocalIdFetchRequest*, bool)),

  1074             &slot, SLOT(progress(QContactLocalIdFetchRequest*, bool )));

  1075 

  1076     // the purpose is to compare if all contacts are loaded, and

  1077     // if optional fields are defined properly in request

  1078 

  1079     // start both at once

  1080     trackerEngine->startRequest(&request);

  1081     trackerEngine->startRequest(&request1);

  1082     trackerEngine->waitForRequestFinished(&request, 10000);

  1083     trackerEngine->waitForRequestFinished(&request1, 10000);

  1084 

  1085 

  1086     // if it takes more, then something is wrong

  1087     QVERIFY(request.isFinished());

  1088     QVERIFY(request1.isFinished());

  1089 

  1090     // there need1 to be something added to be verified

  1091     QVERIFY(!request.contacts().isEmpty());

  1092     // now ask for one contact

  1093     QVERIFY(!slot.contacts.isEmpty());

  1094     // there need to be something added to be verified

  1095     QVERIFY(!request1.ids().isEmpty());

  1096     // now ask for one contact

  1097     QVERIFY(!slot.ids.isEmpty());

  1098 

  1099     QVERIFY2(slot.contacts.count() == slot.ids.count(), "not all contacts were loaded");

  1100     QVERIFY(slot.contacts.count() >= firstNames.count());

  1101     for( int i = 0; i < slot.contacts.size() -1 ; i++)

  1102     {

  1103         QContact contact = slot.contacts[i];

  1104         QContact contact1 = slot.contacts[i+1];

  1105         QString last0 = contact.detail<QContactName>().lastName();

  1106         QString first0 = contact.detail<QContactName>().firstName();

  1107         QString last1 = contact1.detail<QContactName>().lastName();

  1108         QString first1 = contact1.detail<QContactName>().firstName();

  1109         // sorting

  1110         qDebug() << "contacts:" << contact.localId() << first0 << last0;

  1111         bool test = last0 < last1 || (last0 == last1 && first0 <= first1);

  1112         if (!test) {

  1113             qDebug() << "contacts sort failed. First: " << contact1.localId() << first0 << last1 << "lasts: " << last0 << last1;

  1114         }

  1115         QVERIFY2(test, "Sorting failed.");

  1116     }

  1117 

  1118 }

  1119 

  1120 void ut_qtcontacts_trackerplugin::testFilterContacts()

  1121 {

  1122     // this one will get complete contacts

  1123     QContact c;

  1124     QContactName name;

  1125     name.setFirstName("Zuba");

  1126     name.setLastName("Zub");

  1127     c.saveDetail(&name);

  1128     QContactPhoneNumber phone;

  1129 

  1130     phone.setNumber("4872444");

  1131     c.saveDetail(&phone);

  1132 

  1133     QContactBirthday birthday;

  1134     birthday.setDate(QDate(2010, 2, 14));