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

     2 **

     3 ** Copyright (C) 2010 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_cntsymbianengine.h"

    43 #include "cntsymbianengine.h"

    44 #include "qcontactrelationship.h"

    45 #include "qcontactrelationshipfilter.h"

    46 

    47 #include <qcontactmanager.h>

    48 #include <qcontactdetailfilter.h>

    49 #include <qcontactorganization.h>

    50 #include <qcontactemailaddress.h>

    51 #include <qcontactguid.h>

    52 

    53 #include <QtTest/QtTest>

    54 

    55 void TestSymbianEngine::initTestCase()

    56 {

    57     QContactManager::Error error;

    58     QMap<QString, QString> emptyParameters;

    59 

    60     m_engine = new CntSymbianEngine(emptyParameters, &error);

    61     if (error == QContactManager::NoError)

    62         removeAllContacts();

    63     else

    64         QSKIP("Error creating manager", SkipAll);

    65 }

    66 

    67 void TestSymbianEngine::cleanupTestCase()

    68 {

    69     removeAllContacts();

    70     delete m_engine;

    71 }

    72 

    73 void TestSymbianEngine::init()

    74 {

    75 }

    76 

    77 void TestSymbianEngine::cleanup()

    78 {

    79     removeAllContacts();

    80 }

    81 

    82 void TestSymbianEngine::removeAllContacts()

    83 {

    84     if(m_engine) {

    85         // Empty cnt database

    86         QContactManager::Error err(QContactManager::NoError);

    87         QList<QContactSortOrder> sortOrders;

    88         QContactFilter defaultFilter = QContactFilter();

    89         QList<QContactLocalId> cnts_ids = m_engine->contactIds(defaultFilter, sortOrders, &err);

    90         QVERIFY(err == QContactManager::NoError);

    91 

    92         for(int i=0; i<cnts_ids.count(); i++) {

    93             QVERIFY(m_engine->removeContact(cnts_ids[i], &err));

    94         }

    95     }

    96 }

    97 

    98 void TestSymbianEngine::ctors()

    99 {

   100     QContactManager::Error error;

   101     QMap<QString, QString> params;

   102 

   103     // Ctor

   104     CntSymbianEngine *ce;

   105     ce = new CntSymbianEngine(params, &error);

   106     QVERIFY(ce != NULL);

   107     QVERIFY(error == QContactManager::NoError);

   108     if (error == QContactManager::NoError) {

   109         QVERIFY(ce->managerName() == CNT_SYMBIAN_MANAGER_NAME);

   110         QVERIFY(ce->m_contactFilter != 0);

   111         QVERIFY(ce->m_dataBase != 0);

   112         QVERIFY(ce->m_relationship != 0);

   113         QVERIFY(ce->m_transformContact != 0);

   114     } else {

   115         QSKIP("Error creating CntSymbianEngine in ctor", SkipSingle);

   116     }

   117 

   118     delete ce;

   119 }

   120 

   121 void TestSymbianEngine::saveContact()

   122 {

   123     QContactManager::Error err;

   124     QList<QContactSortOrder> sortOrders;

   125     QContactId empty;

   126     QContactFilter defaultFilter = QContactFilter();

   127 

   128     int init_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

   129     QVERIFY(err == QContactManager::NoError);

   130 

   131     // Save a "NULL" contact

   132     QVERIFY(!m_engine->saveContact(NULL, &err));

   133     QVERIFY(err == QContactManager::BadArgumentError);

   134     int current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

   135     QVERIFY(err == QContactManager::NoError);

   136     QVERIFY(init_count == current_count);

   137 

   138     // Save a contact that is not in database

   139     QContact invaId;

   140     QVERIFY(m_engine->saveContact(&invaId, &err));   // Add to db

   141     QVERIFY(err == QContactManager::NoError);

   142     QContactId cId = invaId.id();

   143     m_engine->removeContact(invaId.localId(), &err);   // Ensure not in db

   144     QVERIFY(err == QContactManager::NoError);

   145     invaId.setId(cId);

   146     QVERIFY(!m_engine->saveContact(&invaId, &err));   // Update non existent contact

   147     QVERIFY(err == QContactManager::DoesNotExistError);

   148     current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

   149     QVERIFY(err == QContactManager::NoError);

   150     QVERIFY(init_count == current_count);

   151 

   152     QContact alice;

   153     alice.setType("Jargon");

   154 

   155     // Save a "non contact(Jargon) type" contact

   156     QVERIFY(!m_engine->saveContact(&alice, &err));

   157     QVERIFY(err == QContactManager::InvalidDetailError);

   158     QVERIFY(alice.id() == empty);

   159     QVERIFY(alice.localId() == 0);

   160     current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

   161     QVERIFY(err == QContactManager::NoError);

   162     QVERIFY(init_count == current_count);

   163 

   164     // Save a valid contact

   165     alice.setType(QContactType::TypeContact);

   166     QVERIFY(m_engine->saveContact(&alice, &err));

   167     QVERIFY(err == QContactManager::NoError);

   168     QVERIFY(alice.id() != empty);

   169     QVERIFY(alice.localId() != 0);

   170     QString uri = QString(QLatin1String(CNT_SYMBIAN_MANAGER_NAME));

   171     QVERIFY(alice.id().managerUri().contains(uri, Qt::CaseInsensitive));

   172     current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

   173     QVERIFY(err == QContactManager::NoError);

   174     QVERIFY(init_count + 1 == current_count);

   175     

   176     // Save a valid contact

   177     QContact g;

   178     g.setType(QContactType::TypeGroup);

   179     QContactName en;

   180     en.setCustomLabel("ccc");

   181     QVERIFY(g.saveDetail(&en));

   182     QVERIFY(m_engine->saveContact(&g, &err));

   183     QVERIFY(err == QContactManager::NoError);

   184     QVERIFY(g.id() != empty);

   185     QVERIFY(g.localId() != 0);

   186     QVERIFY(g.id().managerUri().contains(uri, Qt::CaseInsensitive));

   187 }

   188 

   189 void TestSymbianEngine::saveContactWithPreferredDetails()

   190 {

   191     QContactManager::Error err;

   192 

   193     //save a contact with preferred details

   194     QContact c;

   195     c.setType(QContactType::TypeContact);

   196 

   197     QContactPhoneNumber number1;

   198     number1.setNumber("123");

   199     number1.setSubTypes(QContactPhoneNumber::SubTypeMobile);

   200     c.saveDetail(&number1);

   201     c.setPreferredDetail("call", number1);

   202 

   203     QContactPhoneNumber number2;

   204     number2.setNumber("456");

   205     number2.setSubTypes(QContactPhoneNumber::SubTypeMobile);

   206     c.saveDetail(&number2);

   207     c.setPreferredDetail("videocall", number2);

   208 

   209     QContactPhoneNumber number3;

   210     number3.setNumber("789");

   211     number3.setSubTypes(QContactPhoneNumber::SubTypeMobile);

   212     c.saveDetail(&number3);

   213     c.setPreferredDetail("message", number3);

   214 

   215     QContactEmailAddress email;

   216     email.setEmailAddress("dummyemail");

   217     c.saveDetail(&email);

   218     c.setPreferredDetail("email", email);

   219 

   220     QVERIFY(m_engine->saveContact(&c, &err));

   221     QVERIFY(err == QContactManager::NoError);

   222 

   223     //fetch the saved contact and check preferred details

   224     QContactFetchHint hint = QContactFetchHint();

   225     QContact fetched = m_engine->contact(c.localId(), hint, &err);

   226     QVERIFY(err == QContactManager::NoError);

   227 

   228     QContactDetail callDetail1 = fetched.preferredDetail("call");

   229     QVERIFY(callDetail1.definitionName() == QContactPhoneNumber::DefinitionName);

   230     QContactPhoneNumber fetchedNumber1 = static_cast<QContactPhoneNumber>(callDetail1);

   231     QVERIFY(fetchedNumber1.number() == "123");

   232 

   233     QContactDetail callDetail2 = fetched.preferredDetail("videocall");

   234     QVERIFY(callDetail2.definitionName() == QContactPhoneNumber::DefinitionName);

   235     QContactPhoneNumber fetchedNumber2 = static_cast<QContactPhoneNumber>(callDetail2);

   236     QVERIFY(fetchedNumber2.number() == "456");

   237 

   238     QContactDetail callDetail3 = fetched.preferredDetail("message");

   239     QVERIFY(callDetail3.definitionName() == QContactPhoneNumber::DefinitionName);

   240     QContactPhoneNumber fetchedNumber3 = static_cast<QContactPhoneNumber>(callDetail3);

   241     QVERIFY(fetchedNumber3.number() == "789");

   242 

   243     QContactDetail emailDetail = fetched.preferredDetail("email");

   244     QVERIFY(emailDetail.definitionName() == QContactEmailAddress::DefinitionName);

   245     QContactEmailAddress fetchedEmail = static_cast<QContactEmailAddress>(emailDetail);

   246     QVERIFY(fetchedEmail.emailAddress() == "dummyemail");

   247 

   248     //save a contact with one preferred details for several actions

   249     QContact c2;

   250     c2.setType(QContactType::TypeContact);

   251     c2.saveDetail(&number1);

   252     c2.setPreferredDetail("call", number1);

   253     c2.setPreferredDetail("videocall", number1);

   254     c2.setPreferredDetail("message", number1);

   255 

   256     QVERIFY(m_engine->saveContact(&c2, &err));

   257     QVERIFY(err == QContactManager::NoError);

   258 

   259     //fetch the saved contact and check preferred details

   260     QContact fetched2 = m_engine->contact(c2.localId(), hint, &err);

   261     QVERIFY(err == QContactManager::NoError);

   262 

   263     QContactDetail callDetail4 = fetched2.preferredDetail("call");

   264     QVERIFY(callDetail4.definitionName() == QContactPhoneNumber::DefinitionName);

   265     QContactPhoneNumber fetchedNumber4 = static_cast<QContactPhoneNumber>(callDetail4);

   266     QVERIFY(fetchedNumber4.number() == "123");

   267 

   268     QContactDetail callDetail5 = fetched2.preferredDetail("videocall");

   269     QVERIFY(callDetail5.definitionName() == QContactPhoneNumber::DefinitionName);

   270     QContactPhoneNumber fetchedNumber5 = static_cast<QContactPhoneNumber>(callDetail5);

   271     QVERIFY(fetchedNumber5.number() == "123");

   272 

   273     QContactDetail callDetail6 = fetched2.preferredDetail("message");

   274     QVERIFY(callDetail6.definitionName() == QContactPhoneNumber::DefinitionName);

   275     QContactPhoneNumber fetchedNumber6 = static_cast<QContactPhoneNumber>(callDetail6);

   276     QVERIFY(fetchedNumber6.number() == "123");

   277 }

   278 

   279 void TestSymbianEngine::saveContacts()

   280 {

   281     QContactManager::Error err;

   282     QContactFilter defaultFilter = QContactFilter();

   283     QList<QContactSortOrder> sortOrders;

   284     QList<QContact> contacts;

   285     QContactId empty;

   286     int count = 5;

   287 

   288     int init_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

   289     QVERIFY(err == QContactManager::NoError);

   290 

   291     // NULL

   292     QMap<int, QContactManager::Error> errorMap;

   293     QVERIFY(!m_engine->saveContacts(NULL, &errorMap, &err));

   294     QVERIFY(errorMap.count() == 0);

   295     QVERIFY(err == QContactManager::BadArgumentError);

   296     int current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

   297     QVERIFY(err == QContactManager::NoError);

   298     QVERIFY(init_count == current_count);

   299 

   300     // Save a "non contact(Jargon) type" contacts

   301     for(int i=0; i<count; i++) {

   302         QContact alice;

   303         alice.setType("Jargon");

   304         contacts.append(alice);

   305     }

   306     QVERIFY(!m_engine->saveContacts(&contacts, &errorMap, &err));

   307     QVERIFY(err == QContactManager::InvalidDetailError);

   308     foreach(QContactManager::Error err, errorMap) {

   309         QVERIFY(err == QContactManager::InvalidDetailError);

   310     }

   311     foreach(const QContact& c, contacts) {

   312         QVERIFY(c.id() == empty);

   313         QVERIFY(c.localId() == 0);

   314     }

   315     current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

   316     QVERIFY(err == QContactManager::NoError);

   317     QVERIFY(init_count == current_count);

   318     contacts.clear();

   319 

   320     // Save valid contacts

   321     for(int i=0; i<count; i++) {

   322         QContact alice;

   323         alice.setType(QContactType::TypeContact);

   324         contacts.append(alice);

   325     }

   326     QVERIFY(m_engine->saveContacts(&contacts, &errorMap, &err));

   327     QVERIFY(err == QContactManager::NoError);

   328     foreach(QContactManager::Error err, errorMap) {

   329         QVERIFY(err == QContactManager::NoError);

   330     }

   331     QString uri = QString(QLatin1String(CNT_SYMBIAN_MANAGER_NAME));

   332     foreach(const QContact& c, contacts) {

   333         QVERIFY(c.id() != empty);

   334         QVERIFY(c.localId() != 0);

   335         QVERIFY(c.id().managerUri().contains(uri, Qt::CaseInsensitive));

   336     }

   337     current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

   338     QVERIFY(err == QContactManager::NoError);

   339     QVERIFY(init_count + count == current_count);

   340     contacts.clear();

   341 

   342     // Save with one invalid contact in list

   343     init_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

   344     for(int i=0; i<count; i++) {

   345         QContact alice;

   346         alice.setType(QContactType::TypeContact);

   347         contacts.append(alice);

   348     }

   349     QContact invalid;

   350     invalid.setType("Jasdfasd");

   351     contacts.insert(3, invalid);

   352 

   353     QVERIFY(!m_engine->saveContacts(&contacts, &errorMap, &err));

   354     QVERIFY(err == QContactManager::InvalidDetailError);

   355     foreach(QContactManager::Error err, errorMap) {

   356         QVERIFY(err == QContactManager::InvalidDetailError);

   357     }

   358 

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

   360         QContact c = contacts[i];

   361         if (i == 3) {

   362             QVERIFY(c.id() == empty);

   363             QVERIFY(c.localId() == 0);

   364         } else {

   365             QVERIFY(c.id() != empty);

   366             QVERIFY(c.localId() != 0);

   367             QVERIFY(c.id().managerUri().contains(uri, Qt::CaseInsensitive));

   368         }

   369     }

   370     current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

   371     QVERIFY(err == QContactManager::NoError);

   372     QVERIFY(init_count + count == current_count);

   373     contacts.clear();

   374 }

   375 

   376 void TestSymbianEngine::retrieveContact()

   377 {

   378     QContactManager::Error err;

   379     QContactFetchHint hint = QContactFetchHint();

   380 

   381     QContact alice;

   382     alice.setType(QContactType::TypeContact);

   383     QVERIFY(m_engine->saveContact(&alice, &err));

   384     QVERIFY(err == QContactManager::NoError);

   385 

   386     // Retrieve "non contact"

   387     QContact c = m_engine->contact(0, hint, &err);

   388     QVERIFY(&c != NULL);

   389     QVERIFY(c.localId() == 0);

   390     QVERIFY(err == QContactManager::DoesNotExistError);

   391 

   392     // Retrieve valid existing contact

   393     QContactLocalId aid = alice.localId();

   394     c = m_engine->contact(aid, hint, &err);

   395     QVERIFY(&c != NULL);

   396     QVERIFY(c.localId() == aid);

   397     QVERIFY(err == QContactManager::NoError);

   398 }

   399 

   400 void TestSymbianEngine::retrieveContacts()

   401 {

   402     QContactManager::Error err;

   403     QContactFilter f;

   404     QContactFilter defaultFilter = QContactFilter();

   405     QContactFetchHint hint = QContactFetchHint();

   406     QList<QContactSortOrder> s;

   407     QList<QContactLocalId> cnt_ids;

   408 

   409     QContact c;

   410     c.setType(QContactType::TypeContact);

   411     QContactName cn;

   412     cn.setFirstName("aaa");

   413     QVERIFY(c.saveDetail(&cn));

   414 

   415     QContactPhoneNumber number;

   416     number.setContexts("Home");

   417     number.setSubTypes("Mobile");

   418     number.setNumber("12345678");

   419     QVERIFY(c.saveDetail(&number));

   420     QVERIFY(m_engine->saveContact(&c, &err));

   421     QVERIFY(err == QContactManager::NoError);

   422 

   423     QContact d;

   424     d.setType(QContactType::TypeContact);

   425     QContactName dn;

   426     dn.setFirstName("bbb");

   427     QVERIFY(d.saveDetail(&dn));

   428     QVERIFY(m_engine->saveContact(&d, &err));

   429     QVERIFY(err == QContactManager::NoError);

   430 

   431     QContact e;

   432     e.setType(QContactType::TypeGroup);

   433     QContactName en;

   434     en.setCustomLabel("ccc");

   435     QVERIFY(e.saveDetail(&en));

   436     QVERIFY(m_engine->saveContact(&e, &err));

   437     QVERIFY(err == QContactManager::NoError);

   438 

   439     // Retrieve all contacts

   440     cnt_ids = m_engine->contactIds(f, s, &err);

   441     QVERIFY(err == QContactManager::NoError);

   442     QVERIFY(cnt_ids.count() > 0);

   443 

   444     QContactDetailFilter mobileFilter;

   445     mobileFilter.setDetailDefinitionName(QContactPhoneNumber::DefinitionName, QContactPhoneNumber::FieldSubTypes);

   446     mobileFilter.setValue(QLatin1String(QContactPhoneNumber::SubTypeMobile));

   447 

   448     // Retrieve contacts with mobile number

   449     cnt_ids = m_engine->contactIds(mobileFilter, s, &err);

   450     QVERIFY(err == QContactManager::NoError);

   451     QVERIFY(cnt_ids.count() > 0);

   452     

   453     // Slow filter

   454     QList<QContactLocalId> fast_ids = m_engine->contactIds(mobileFilter, s, &err);

   455     QList<QContactLocalId> all_ids = m_engine->contactIds(f, s, &err);

   456     QList<QContactLocalId> slow_ids = m_engine->slowFilter(mobileFilter, all_ids, &err);

   457     QVERIFY(err == QContactManager::NoError);

   458     QVERIFY(slow_ids.count() == fast_ids.count());

   459 

   460     QContactDetailFilter invalidFilter;

   461     mobileFilter.setDetailDefinitionName("asfdasdf", "asdfasdf");

   462 

   463     // Retrieve contacts with invalid filter

   464     cnt_ids = m_engine->contactIds(invalidFilter, s, &err);

   465     QVERIFY(err == QContactManager::NotSupportedError);

   466 

   467     // Retrieve sorted contacts

   468     QContactSortOrder sortOrder;

   469     QList<QContactSortOrder> s1;

   470     sortOrder.setDetailDefinitionName(QContactName::DefinitionName,  QContactName::FieldFirstName);

   471     sortOrder.setBlankPolicy(QContactSortOrder::BlanksLast);

   472     sortOrder.setDirection(Qt::AscendingOrder);

   473     sortOrder.setCaseSensitivity(Qt::CaseInsensitive);

   474     s1.append(sortOrder);

   475 

   476     cnt_ids = m_engine->contactIds(defaultFilter, s1, &err);

   477     QVERIFY(err == QContactManager::NoError);

   478 

   479     // Retrieve with invalid sort order

   480     QContactSortOrder sortOrder1;

   481     QList<QContactSortOrder> s2;

   482     sortOrder1.setDetailDefinitionName("asdfasdf", "asdfasd");

   483 

   484     cnt_ids = m_engine->contactIds(defaultFilter, s2, &err);

   485     QVERIFY(err == QContactManager::NoError);

   486     

   487     // Retrieve full contacts (with all details)

   488     QList<QContact> contactList;

   489     QList<QContactSortOrder> sortOrders;

   490     QStringList definitionRestrictions;

   491     contactList = m_engine->contacts(defaultFilter, sortOrders, hint, &err);

   492     QVERIFY(err == QContactManager::NoError);

   493     QContactFilter filter;

   494     contactList = m_engine->contacts(filter, sortOrders, hint, &err);

   495     QVERIFY(err == QContactManager::NoError);

   496 }

   497 

   498 void TestSymbianEngine::retrieveName()

   499 {

   500     QContactManager::Error err;

   501     QContactFetchHint hint = QContactFetchHint();

   502     QStringList hints;

   503     hints << QContactDisplayLabel::DefinitionName;

   504     hint.setDetailDefinitionsHint(hints);

   505 

   506     QContact alice;

   507     alice.setType(QContactType::TypeContact);

   508     QContactName name;

   509     name.setFirstName("Alice");

   510     name.setLastName("Wonders");

   511     alice.saveDetail(&name);

   512     QVERIFY(m_engine->saveContact(&alice, &err));

   513     QVERIFY(err == QContactManager::NoError);

   514 

   515     // Retrieve name of "non contact"

   516     QContact c = m_engine->contact(0, hint, &err);

   517     QVERIFY(&c != NULL);

   518     QVERIFY(c.localId() == 0);

   519     QVERIFY(err == QContactManager::DoesNotExistError);

   520 

   521     // Retrieve name of valid existing contact

   522     QContactLocalId aid = alice.localId();

   523     c = m_engine->contact(aid, hint, &err);

   524     QVERIFY(&c != NULL);

   525     QVERIFY(c.localId() == aid);

   526     QVERIFY(c.displayLabel() == alice.displayLabel());

   527     QVERIFY(err == QContactManager::NoError);

   528 }

   529 

   530 void TestSymbianEngine::retrieveNames()

   531 {

   532     QContactManager::Error err;

   533     QContactDetailFilter filter;

   534     filter.setDetailDefinitionName(QContactType::DefinitionName);

   535     filter.setValue(QContactType::TypeContact);

   536 

   537     QList<QContactSortOrder> sortOrders;

   538 

   539     QContactFetchHint hint = QContactFetchHint();

   540     QStringList hints;

   541     hints << QContactDisplayLabel::DefinitionName;

   542     hint.setDetailDefinitionsHint(hints);

   543 

   544     QContact alice;

   545     alice.setType(QContactType::TypeContact);

   546     QContactName name;

   547     name.setFirstName("Alice");

   548     name.setLastName("Wonders");

   549     alice.saveDetail(&name);

   550     QVERIFY(m_engine->saveContact(&alice, &err));

   551     QVERIFY(err == QContactManager::NoError);

   552 

   553     QContact charlie;

   554     charlie.setType(QContactType::TypeContact);

   555     name.setFirstName("Charlie");

   556     name.setLastName("Choco");

   557     charlie.saveDetail(&name);

   558     QVERIFY(m_engine->saveContact(&charlie, &err));

   559     QVERIFY(err == QContactManager::NoError);

   560 

   561     int numContacts = m_engine->contactIds(filter, sortOrders, &err).count();

   562 

   563     // Retrieve names

   564     QList<QContact> contacts = m_engine->contacts(filter, sortOrders, hint, &err);

   565     QVERIFY(contacts.count() == numContacts);

   566 

   567     int verifiedContacts = 0;

   568     foreach (QContact contact, contacts) {

   569         if (contact.localId() == alice.localId()) {

   570             TInt contactId = contact.localId();

   571             TInt aliceId = alice.localId();

   572             QString contactName = contact.displayLabel();

   573             QString aliceName = alice.displayLabel();

   574             QVERIFY(contact.displayLabel() == alice.displayLabel());  

   575             ++verifiedContacts;

   576         }

   577         if (contact.localId() == charlie.localId()) {

   578             QVERIFY(contact.displayLabel() == charlie.displayLabel());

   579             ++verifiedContacts;

   580         }

   581     }

   582 

   583     QVERIFY(verifiedContacts == 2);

   584 }

   585 

   586 void TestSymbianEngine::updateContact()

   587 {

   588     QContactManager::Error err;

   589     QContactFetchHint hint = QContactFetchHint();

   590     QContact c;

   591 

   592     QVERIFY(m_engine->saveContact(&c, &err));

   593     QVERIFY(err == QContactManager::NoError);

   594 

   595     int details_before = c.details().count();

   596 

   597     QContactName aliceName;

   598     aliceName.setFirstName("Alice");

   599     c.saveDetail(&aliceName);

   600 

   601     QContactPhoneNumber number;

   602     number.setContexts("Home");

   603     number.setSubTypes("Mobile");

   604     number.setNumber("12345678");

   605     c.saveDetail(&number);

   606 

   607     // update the contact

   608     QContactLocalId id = c.localId();

   609     QVERIFY(m_engine->saveContact(&c, &err));

   610     QVERIFY(err == QContactManager::NoError);

   611 

   612     // Verify that contact has been updated

   613     QContact d = m_engine->contact(id, hint, &err);

   614     QVERIFY(err == QContactManager::NoError);

   615     QVERIFY(d.localId() == id);

   616     QVERIFY(d.details().count() > details_before);

   617     QString str = d.detail(QContactPhoneNumber::DefinitionName).definitionName();

   618     QVERIFY(str == QContactPhoneNumber::DefinitionName);

   619 }

   620 

   621 void TestSymbianEngine::updateContactByUid()

   622 {

   623     QContactManager::Error err;

   624     QContact c;

   625 

   626     QVERIFY(m_engine->saveContact(&c, &err));

   627     QVERIFY(err == QContactManager::NoError);

   628     QContactLocalId initialId = c.localId();

   629     

   630     QContactGuid guidDetail = static_cast<QContactGuid>(c.details(QContactGuid::DefinitionName).at(0));

   631     QString uid = guidDetail.guid();

   632     

   633     //clear id

   634     QScopedPointer<QContactId> contactId(new QContactId());

   635     contactId->setLocalId(0);

   636     contactId->setManagerUri(QString());

   637     c.setId(*contactId);

   638     

   639     // update the contact   

   640     QContactName aliceName;

   641     aliceName.setFirstName("Alice");

   642     c.saveDetail(&aliceName);

   643     QContactPhoneNumber number;

   644     number.setContexts("Home");

   645     number.setSubTypes("Mobile");

   646     number.setNumber("12345678");

   647     c.saveDetail(&number);

   648 

   649     //verify that the same contact was updated

   650     QVERIFY(m_engine->saveContact(&c, &err));

   651     QContactLocalId id = c.localId();

   652     QVERIFY(err == QContactManager::NoError);

   653     QVERIFY(initialId == id);

   654 }

   655 

   656 void TestSymbianEngine::removeContact()

   657 {

   658     QContactManager::Error err;

   659     QContactFetchHint hint = QContactFetchHint();

   660 

   661     QContact c;

   662     c.setType(QContactType::TypeContact);

   663     QVERIFY(m_engine->saveContact(&c, &err));

   664     QVERIFY(err == QContactManager::NoError);

   665 

   666     // Remove existing contact

   667     QContactLocalId id = c.localId();

   668     QVERIFY(m_engine->removeContact(id, &err));

   669     QVERIFY(err == QContactManager::NoError);

   670 

   671     // Verify that contact has been removed

   672     QContact f = m_engine->contact(id, hint, &err);

   673     QVERIFY(f.localId() == 0);

   674     QVERIFY(err == QContactManager::DoesNotExistError);

   675 

   676     // Remove non existent contact

   677     QVERIFY(!m_engine->removeContact(0, &err));

   678     QVERIFY(err == QContactManager::DoesNotExistError);

   679 }

   680 

   681 void TestSymbianEngine::removeContacts()

   682 {

   683     QContactManager::Error err;

   684     QContactFetchHint hint = QContactFetchHint();

   685     QList<QContactLocalId> contacts;

   686     int count = 5;

   687 

   688     // Remove non existent contacts

   689     QMap<int, QContactManager::Error> errorMap;

   690     QVERIFY(!m_engine->removeContacts(contacts, &errorMap, &err));

   691     QVERIFY(err == QContactManager::BadArgumentError);

   692     QVERIFY(errorMap.count() == 0);

   693 

   694     // Remove existing contacts

   695     for(int i=0; i<count; i++) {

   696         QContact c;

   697         c.setType(QContactType::TypeContact);

   698         QVERIFY(m_engine->saveContact(&c, &err));

   699         QVERIFY(err == QContactManager::NoError);

   700         contacts.append(c.localId());

   701     }

   702     QVERIFY(m_engine->removeContacts(contacts, &errorMap, &err));

   703     QVERIFY(err == QContactManager::NoError);

   704     foreach(QContactManager::Error e, errorMap) {

   705         QVERIFY(e == QContactManager::NoError);

   706     }

   707 

   708     // Verify that contacts have been removed

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

   710         QContact f = m_engine->contact(contacts[i], hint, &err);

   711         QVERIFY(f.localId() == 0);

   712         QVERIFY(err == QContactManager::DoesNotExistError);

   713     }

   714 

   715     // Remove a list with one non existent contact

   716     contacts.clear();

   717     for(int i=0; i<count; i++) {

   718         QContact c;

   719         c.setType(QContactType::TypeContact);

   720         QVERIFY(m_engine->saveContact(&c, &err));

   721         QVERIFY(err == QContactManager::NoError);

   722         contacts.append(c.localId());

   723     }

   724     contacts.insert(3, 0);

   725 

   726     QVERIFY(!m_engine->removeContacts(contacts, &errorMap, &err));

   727     QVERIFY(err == QContactManager::DoesNotExistError);

   728     foreach(QContactManager::Error e, errorMap) {

   729         QVERIFY(e == QContactManager::DoesNotExistError);

   730     }

   731 

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

   733         QContact f = m_engine->contact(contacts[i], hint, &err);

   734         QVERIFY(f.localId() == 0);

   735         QVERIFY(err == QContactManager::DoesNotExistError);

   736     }

   737 }

   738 

   739 void TestSymbianEngine::addOwnCard()

   740 {

   741     QContactManager::Error err;

   742 

   743     // Create a new contact own card

   744     QContact own;

   745     QContactName ownName;

   746     ownName.setFirstName("Own");

   747     own.saveDetail(&ownName);

   748     QVERIFY(m_engine->saveContact(&own, &err));

   749     QVERIFY(err == QContactManager::NoError);

   750 

   751     // Set a non existent contact as own card and verify

   752     // ensure this contact does not exist in dbase

   753     QContactLocalId id(12);

   754     m_engine->removeContact(id, &err);   // Don't test err. May or may not be in dbase

   755     QVERIFY(!m_engine->setSelfContactId(id, &err)); // does not exist

   756     QVERIFY(err == QContactManager::DoesNotExistError);

   757 

   758     // Test a "0" contact id

   759     QVERIFY(!m_engine->setSelfContactId(0, &err)); // Bad argument

   760     QVERIFY(err == QContactManager::BadArgumentError);

   761 

   762     // Set an existent contact as own card

   763     QVERIFY(m_engine->setSelfContactId(own.localId(), &err));

   764     QVERIFY(err == QContactManager::NoError);

   765 }

   766 

   767 void TestSymbianEngine::retrieveOwnCard()

   768 {

   769     QContactManager::Error err;

   770 

   771     // Create a new contact own card

   772     QContact own;

   773     QContactName ownName;

   774     ownName.setFirstName("Own");

   775     own.saveDetail(&ownName);

   776     QVERIFY(m_engine->saveContact(&own, &err));

   777     QVERIFY(err == QContactManager::NoError);

   778     QVERIFY(m_engine->setSelfContactId(own.localId(), &err));

   779     QVERIFY(err == QContactManager::NoError);

   780 

   781     // Fetch existing self contact

   782     QContactLocalId own_id = m_engine->selfContactId(&err);

   783     QVERIFY(err == QContactManager::NoError);

   784     QVERIFY(own_id == own.localId());

   785 

   786     // Remove self contact and verify

   787     QVERIFY(m_engine->removeContact(own.localId(), &err));

   788     QContactLocalId idr = m_engine->selfContactId(&err);

   789     QVERIFY(err == QContactManager::DoesNotExistError);

   790     QVERIFY(idr == 0);

   791 }

   792 

   793 void TestSymbianEngine::filterSupport()

   794 {

   795     // Filter feature support

   796     QContactDetailFilter df;

   797     df.setDetailDefinitionName(QContactPhoneNumber::DefinitionName, QContactPhoneNumber::FieldSubTypes);

   798     QVERIFY(m_engine->isFilterSupported(df));

   799     QContactFilter f;

   800     QVERIFY(m_engine->isFilterSupported(f));

   801 }

   802 

   803 void TestSymbianEngine::featureSupport()

   804 {

   805     //hasFeature(QContactManager::ManagerFeature feature, const QString& contactType)

   806 

   807     // test with illegal feature enum value

   808     const int illegalFeature(198);

   809     QContactManager::ManagerFeature f = static_cast<QContactManager::ManagerFeature>(illegalFeature);

   810     QVERIFY(!m_engine->hasFeature(f, QContactType::TypeContact));

   811     QVERIFY(!m_engine->hasFeature(f, QContactType::TypeGroup));

   812 

   813     // empty contact type param

   814     QVERIFY(!m_engine->hasFeature(QContactManager::Groups, ""));

   815     QVERIFY(!m_engine->hasFeature(QContactManager::ActionPreferences, ""));

   816     QVERIFY(!m_engine->hasFeature(QContactManager::MutableDefinitions, ""));

   817     QVERIFY(!m_engine->hasFeature(QContactManager::Relationships, ""));

   818     QVERIFY(!m_engine->hasFeature(QContactManager::ArbitraryRelationshipTypes, ""));

   819     QVERIFY(!m_engine->hasFeature(QContactManager::SelfContact, ""));

   820     QVERIFY(!m_engine->hasFeature(QContactManager::Anonymous, ""));

   821     QVERIFY(!m_engine->hasFeature(QContactManager::ChangeLogs, ""));

   822 

   823     // wrong contact type param

   824     QVERIFY(!m_engine->hasFeature(QContactManager::Groups, "aserasdf"));

   825     QVERIFY(!m_engine->hasFeature(QContactManager::ActionPreferences, "aserasdf"));

   826     QVERIFY(!m_engine->hasFeature(QContactManager::MutableDefinitions, "aserasdf"));

   827     QVERIFY(!m_engine->hasFeature(QContactManager::Relationships, "aserasdf"));

   828     QVERIFY(!m_engine->hasFeature(QContactManager::ArbitraryRelationshipTypes, "aserasdf"));

   829     QVERIFY(!m_engine->hasFeature(QContactManager::SelfContact, "aserasdf"));

   830     QVERIFY(!m_engine->hasFeature(QContactManager::Anonymous, "aserasdf"));

   831     QVERIFY(!m_engine->hasFeature(QContactManager::ChangeLogs, "aserasdf"));

   832 

   833     // TypeContact contact type param

   834     QVERIFY(m_engine->hasFeature(QContactManager::Groups, QContactType::TypeContact));

   835     QVERIFY(!m_engine->hasFeature(QContactManager::ActionPreferences, QContactType::TypeContact));

   836     QVERIFY(!m_engine->hasFeature(QContactManager::MutableDefinitions, QContactType::TypeContact));

   837     QVERIFY(m_engine->hasFeature(QContactManager::Relationships, QContactType::TypeContact));

   838     QVERIFY(!m_engine->hasFeature(QContactManager::ArbitraryRelationshipTypes, QContactType::TypeContact));

   839     QVERIFY(m_engine->hasFeature(QContactManager::SelfContact, QContactType::TypeContact));

   840     QVERIFY(!m_engine->hasFeature(QContactManager::Anonymous, QContactType::TypeContact));

   841     QVERIFY(!m_engine->hasFeature(QContactManager::ChangeLogs, QContactType::TypeContact));

   842 

   843     // TypeGroup contact type param

   844     QVERIFY(m_engine->hasFeature(QContactManager::Groups, QContactType::TypeGroup));

   845     QVERIFY(!m_engine->hasFeature(QContactManager::ActionPreferences, QContactType::TypeGroup));

   846     QVERIFY(!m_engine->hasFeature(QContactManager::MutableDefinitions, QContactType::TypeGroup));

   847     QVERIFY(m_engine->hasFeature(QContactManager::Relationships, QContactType::TypeGroup));

   848     QVERIFY(!m_engine->hasFeature(QContactManager::ArbitraryRelationshipTypes, QContactType::TypeGroup));

   849     QVERIFY(m_engine->hasFeature(QContactManager::SelfContact, QContactType::TypeGroup));

   850     QVERIFY(!m_engine->hasFeature(QContactManager::Anonymous, QContactType::TypeGroup));

   851     QVERIFY(!m_engine->hasFeature(QContactManager::ChangeLogs, QContactType::TypeContact));

   852 }

   853 

   854 void TestSymbianEngine::addGroup()

   855 {

   856     QContactManager::Error err = QContactManager::NoError;

   857     QContactId empty;

   858 

   859     // Add valid group contact

   860     QContact g;

   861     g.setType(QContactType::TypeGroup);

   862 

   863     QVERIFY(m_engine->saveContact(&g, &err));

   864     QVERIFY(err == QContactManager::NoError);

   865     QVERIFY(g.id() != empty);

   866     QVERIFY(g.localId() != 0);

   867     QString uri = QString(QLatin1String(CNT_SYMBIAN_MANAGER_NAME));

   868     QVERIFY(g.id().managerUri().contains(uri, Qt::CaseInsensitive));

   869 

   870     // Add invalid group contact

   871     QContact g1;

   872     g1.setType("Jargon");

   873 

   874     QVERIFY(!m_engine->saveContact(&g1, &err));

   875     QVERIFY(err == QContactManager::InvalidDetailError);

   876     QVERIFY(g1.id() == empty);

   877     QVERIFY(g1.localId() == 0);

   878 }

   879 

   880 void TestSymbianEngine::retrieveGroup()

   881 {

   882     QContactManager::Error err;

   883     QList<QContactSortOrder> s;

   884 

   885     // retrieve group contacts

   886     QContactDetailFilter filter;

   887     filter.setDetailDefinitionName(QContactType::DefinitionName, QContactType::FieldType);

   888     filter.setValue(QString(QLatin1String(QContactType::TypeGroup)));

   889     

   890     QList<QContactLocalId> grp_ids = m_engine->contactIds(filter, s, &err);

   891     QVERIFY(err == QContactManager::NoError);

   892     QVERIFY(err == QContactManager::NoError);

   893 

   894     QContact g;

   895     g.setType(QContactType::TypeGroup);

   896     QVERIFY(m_engine->saveContact(&g, &err));

   897     QVERIFY(err == QContactManager::NoError);

   898 

   899     QList<QContactLocalId> grp_ids1 = m_engine->contactIds(filter, s, &err);

   900     QVERIFY(err == QContactManager::NoError);

   901     QVERIFY(grp_ids.count() + 1 == grp_ids1.count());

   902 

   903 }

   904 

   905 void TestSymbianEngine::singleRelationship()

   906 {

   907     // More relationships logic is tested in relationship unit tests.

   908     // We do simple tests here

   909     QContactManager::Error error;

   910 

   911     QContact a;

   912     QVERIFY(m_engine->saveContact(&a, &error));

   913     QContact b;

   914     QVERIFY(m_engine->saveContact(&b, &error));

   915 

   916     QContactRelationship rel;

   917     rel.setFirst(a.id());

   918     rel.setSecond(b.id());

   919     rel.setRelationshipType(QContactRelationship::HasSpouse);

   920 

   921     // Add relationship

   922     m_engine->saveRelationship(&rel, &error);

   923     bool isValid(false);

   924     if (error == QContactManager::NoError ||

   925         error == QContactManager::NotSupportedError)

   926         isValid = true;

   927 

   928     QVERIFY(isValid);

   929 

   930     // Remove relationship

   931     m_engine->removeRelationship(rel, &error);

   932     if (error == QContactManager::NoError ||

   933         error == QContactManager::NotSupportedError)

   934         isValid = true;

   935     else

   936         isValid = false;

   937     QVERIFY(isValid);

   938 

   939     // TODO: replacement?

   940     /*QStringList supportedRelationships =

   941         m_engine->supportedRelationshipTypes(QContactType::TypeGroup);

   942     QVERIFY(supportedRelationships.contains(QContactRelationship::HasMember));

   943     */

   944 }

   945 

   946 void TestSymbianEngine::batchRelationships()

   947 {

   948     // More relationships logic is tested somewhere else.

   949     // We do simple tests here

   950     QContactManager::Error error;

   951 

   952     QContact a;

   953     QVERIFY(m_engine->saveContact(&a, &error));

   954     QContact b;

   955     QVERIFY(m_engine->saveContact(&b, &error));

   956 

   957     QContactRelationship rel;

   958     rel.setFirst(a.id());

   959     rel.setSecond(b.id());

   960     rel.setRelationshipType(QContactRelationship::HasSpouse);

   961 

   962     QList<QContactRelationship> list;

   963     list.append(rel);

   964     bool isValid(false);

   965 

   966     // Add relationships

   967     QMap<int, QContactManager::Error> errorMap;

   968     QVERIFY(!m_engine->saveRelationships(&list, &errorMap, &error));

   969     foreach(QContactManager::Error err, errorMap) {

   970         if (err == QContactManager::NoError ||

   971                 err == QContactManager::NotSupportedError)

   972             isValid = true;

   973         else

   974             isValid = false;

   975         QVERIFY(isValid);

   976     }

   977 

   978     // fetch relationships

   979     QContactRelationship::Role role;

   980     role = QContactRelationship::First;

   981     list.clear();

   982     list = m_engine->relationships(QContactRelationship::HasSpouse, a.id(), role, &error);

   983     QVERIFY(&list != NULL);

   984     if (error == QContactManager::NoError ||

   985         error == QContactManager::NotSupportedError)

   986         isValid = true;

   987     else

   988         isValid = false;

   989     QVERIFY(isValid);

   990 

   991     // Remove relationships

   992     QVERIFY(m_engine->removeRelationships(list, &errorMap, &error));

   993     foreach(QContactManager::Error err, errorMap) {

   994         if (err == QContactManager::NoError ||

   995                 err == QContactManager::NotSupportedError)

   996             isValid = true;

   997         else

   998             isValid = false;

   999         QVERIFY(isValid);

  1000     }

  1001 }

  1002 

  1003 void TestSymbianEngine::dataTypeSupport()

  1004 {

  1005     QList<QVariant::Type> support = m_engine->supportedDataTypes();

  1006     QVERIFY(support.contains(QVariant::String));

  1007 }

  1008 

  1009 void TestSymbianEngine::synthesizeDisplaylable()

  1010 {

  1011     QContactManager::Error err = QContactManager::NoError;

  1012 

  1013     QContact empty;

  1014     QString label = m_engine->synthesizedDisplayLabel(empty, &err);

  1015     QVERIFY(err == QContactManager::NoError);

  1016     QVERIFY(label.isEmpty());

  1017 

  1018     QContact first;

  1019     QContactName fn;

  1020     fn.setFirstName("Alice");

  1021     first.saveDetail(&fn);

  1022     label = m_engine->synthesizedDisplayLabel(first, &err);

  1023     QVERIFY(err == QContactManager::NoError);

  1024     QVERIFY(label == QString("Alice"));

  1025 

  1026     QContact last;

  1027     QContactName ln;

  1028     ln.setLastName("Jones");

  1029     last.saveDetail(&ln);

  1030     label = m_engine->synthesizedDisplayLabel(last, &err);

  1031     QVERIFY(err == QContactManager::NoError);

  1032     QVERIFY(label == QString("Jones"));

  1033 

  1034     QContact orgContact;

  1035     QContactOrganization org;

  1036     org.setName("Nokia");

  1037     org.setDepartment(QStringList("Services"));

  1038     org.setTitle("Assistant Manager");

  1039     org.setLocation("Nokia Cyber Park");

  1040     orgContact.saveDetail(&org);

  1041     label = m_engine->synthesizedDisplayLabel(orgContact, &err);

  1042     QVERIFY(err == QContactManager::NoError);

  1043     QVERIFY(label == QString("Nokia"));

  1044 

  1045     QContact jargon;

  1046     jargon.setType("jargon");

  1047     label = m_engine->synthesizedDisplayLabel(jargon, &err);

  1048     QVERIFY(err == QContactManager::InvalidContactTypeError);

  1049     QVERIFY(label.isEmpty());

  1050 

  1051     QContact group;

  1052     group.setType(QContactType::TypeGroup);

  1053     QContactName gn;

  1054     gn.setCustomLabel("grouplable");

  1055     group.saveDetail(&gn);

  1056     label = m_engine->synthesizedDisplayLabel(group, &err);

  1057     QVERIFY(err == QContactManager::NoError);

  1058     QVERIFY(label == QString("grouplable"));

  1059 }

  1060 

  1061 void TestSymbianEngine::definitionDetails()

  1062 {

  1063     QMap<QString, QContactDetailDefinition> defs;

  1064     QContactManager::Error err;

  1065 

  1066     // Wrong contact type

  1067     defs = m_engine->detailDefinitions("aerafa", &err);

  1068     QVERIFY(err = QContactManager::InvalidContactTypeError);

  1069     QVERIFY(defs.count() == 0);

  1070 

  1071     // Valid defs

  1072     defs = m_engine->detailDefinitions(QContactType::TypeContact, &err);

  1073     QVERIFY(err == QContactManager::NoError);

  1074     defs = m_engine->detailDefinitions(QContactType::TypeGroup, &err);

  1075     QVERIFY(err == QContactManager::NoError);

  1076 }

  1077 

  1078 void TestSymbianEngine::asyncRequests()

  1079 {

  1080     //create a contact

  1081     QContactManager::Error err;

  1082     QContact dummy;

  1083     dummy.setType(QContactType::TypeContact);

  1084     QContactName name;

  1085     name.setFirstName("dummy");

  1086     dummy.saveDetail(&name);

  1087     QVERIFY(m_engine->saveContact(&dummy, &err));

  1088     QVERIFY(err == QContactManager::NoError);

  1089     

  1090     //create a group with members 

  1091     QContact groupContact;

  1092     groupContact.setType(QContactType::TypeGroup);

  1093     m_engine->saveContact(&groupContact, &err);

  1094     QVERIFY(err == QContactManager::NoError);

  1095     QContactRelationship relationship;

  1096     relationship.setRelationshipType(QContactRelationship::HasMember);

  1097     relationship.setFirst(groupContact.id());

  1098     relationship.setSecond(dummy.id());

  1099     bool returnValue(false);

  1100     returnValue = m_engine->saveRelationship(&relationship, &err);

  1101     QVERIFY(returnValue == true);

  1102     QVERIFY(err == QContactManager::NoError);

  1103     

  1104     //fetch request

  1105     QContactFetchRequest fetch;

  1106     QVERIFY(m_engine->startRequest(&fetch));

  1107     QTest::qWait(1000); //1sec

  1108     QVERIFY(fetch.error() == QContactManager::NoError);

  1109     QVERIFY(fetch.state() == QContactFetchRequest::FinishedState);

  1110     QVERIFY(fetch.contacts().count() > 0);

  1111     

  1112     //fetch ids request

  1113     QContactLocalIdFetchRequest fetchIds;

  1114     QVERIFY(m_engine->startRequest(&fetchIds));

  1115     QTest::qWait(1000); //1sec

  1116     QVERIFY(fetchIds.error() == QContactManager::NoError);

  1117     QVERIFY(fetchIds.state() == QContactFetchRequest::FinishedState);

  1118     QVERIFY(fetchIds.ids().count() > 0);

  1119     

  1120     //save request

  1121     QContactSaveRequest saveReq;

  1122     QContact c;

  1123     c.setType(QContactType::TypeContact);

  1124     QList<QContact> contactList;

  1125     contactList += c;

  1126     saveReq.setContacts(contactList);

  1127     QVERIFY(m_engine->startRequest(&saveReq));

  1128     QTest::qWait(1000); //1sec

  1129     QVERIFY(saveReq.error() == QContactManager::NoError);

  1130     QVERIFY(saveReq.state() == QContactFetchRequest::FinishedState);

  1131     QVERIFY(saveReq.contacts().count() > 0);

  1132     

  1133     //remove request

  1134     QContactRemoveRequest removeReq;