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 <QtTest/QtTest>

    43 

    44 #include <QCoreApplication>

    45 #include <QScopedPointer>

    46 

    47 #include "qtcontacts.h"

    48 #include "qcontactmanagerdataholder.h" //QContactManagerDataHolder

    49 

    50 QTM_USE_NAMESPACE

    51 /* Define an innocuous request (fetch ie doesn't mutate) to "fill up" any queues */

    52 #define FILL_QUEUE_WITH_FETCH_REQUESTS() QContactFetchRequest fqcfr1, fqcfr2, fqcfr3; \

    53                                          QContactDetailDefinitionFetchRequest fqdfr1, fqdfr2, fqdfr3; \

    54                                          fqcfr1.start(); \

    55                                          fqcfr2.start(); \

    56                                          fqcfr3.start(); \

    57                                          fqdfr1.start(); \

    58                                          fqdfr2.start(); \

    59                                          fqdfr3.start();

    60 

    61 

    62 //TESTED_CLASS=

    63 //TESTED_FILES=

    64 

    65 // Unfortunately the plumbing isn't in place to allow cancelling requests at arbitrary points

    66 // in their processing.  So we do multiple loops until things work out.. or not

    67 #define MAX_OPTIMISTIC_SCHEDULING_LIMIT 100

    68 

    69 

    70 // Thread capable QThreadSignalSpy (to avoid data races with count/appendArgS)

    71 class QThreadSignalSpy: public QObject

    72 {

    73 public:

    74     QThreadSignalSpy(QObject *obj, const char *aSignal)

    75     {

    76 #ifdef Q_CC_BOR

    77         const int memberOffset = QObject::staticMetaObject.methodCount();

    78 #else

    79         static const int memberOffset = QObject::staticMetaObject.methodCount();

    80 #endif

    81         Q_ASSERT(obj);

    82         Q_ASSERT(aSignal);

    83 

    84         if (((aSignal[0] - '0') & 0x03) != QSIGNAL_CODE) {

    85             qWarning("QThreadSignalSpy: Not a valid signal, use the SIGNAL macro");

    86             return;

    87         }

    88 

    89         QByteArray ba = QMetaObject::normalizedSignature(aSignal + 1);

    90         const QMetaObject *mo = obj->metaObject();

    91         int sigIndex = mo->indexOfMethod(ba.constData());

    92         if (sigIndex < 0) {

    93             qWarning("QThreadSignalSpy: No such signal: '%s'", ba.constData());

    94             return;

    95         }

    96 

    97         if (!QMetaObject::connect(obj, sigIndex, this, memberOffset,

    98                     Qt::DirectConnection, 0)) {

    99             qWarning("QThreadSignalSpy: QMetaObject::connect returned false. Unable to connect.");

   100             return;

   101         }

   102         sig = ba;

   103         initArgs(mo->method(sigIndex));

   104     }

   105 

   106     inline bool isValid() const { return !sig.isEmpty(); }

   107     inline QByteArray signal() const { return sig; }

   108 

   109     int qt_metacall(QMetaObject::Call call, int methodId, void **a)

   110     {

   111         methodId = QObject::qt_metacall(call, methodId, a);

   112         if (methodId < 0)

   113             return methodId;

   114 

   115         if (call == QMetaObject::InvokeMetaMethod) {

   116             if (methodId == 0) {

   117                 appendArgs(a);

   118             }

   119             --methodId;

   120         }

   121         return methodId;

   122     }

   123 

   124     // The QList<QVariantList> API we actually use

   125     int count() const

   126     {

   127         QMutexLocker m(&lock);

   128         return savedArgs.count();

   129     }

   130     void clear()

   131     {

   132         QMutexLocker m(&lock);

   133         savedArgs.clear();

   134     }

   135 

   136 private:

   137     void initArgs(const QMetaMethod &member)

   138     {

   139         QMutexLocker m(&lock);

   140         QList<QByteArray> params = member.parameterTypes();

   141         for (int i = 0; i < params.count(); ++i) {

   142             int tp = QMetaType::type(params.at(i).constData());

   143             if (tp == QMetaType::Void)

   144                 qWarning("Don't know how to handle '%s', use qRegisterMetaType to register it.",

   145                          params.at(i).constData());

   146             args << tp;

   147         }

   148     }

   149 

   150     void appendArgs(void **a)

   151     {

   152         QMutexLocker m(&lock);

   153         QList<QVariant> list;

   154         for (int i = 0; i < args.count(); ++i) {

   155             QMetaType::Type type = static_cast<QMetaType::Type>(args.at(i));

   156             list << QVariant(type, a[i + 1]);

   157         }

   158         savedArgs.append(list);

   159     }

   160 

   161     // the full, normalized signal name

   162     QByteArray sig;

   163     // holds the QMetaType types for the argument list of the signal

   164     QList<int> args;

   165 

   166     mutable QMutex lock;

   167     // Different API

   168     QList< QVariantList> savedArgs;

   169 };

   170 

   171 class tst_QContactAsync : public QObject

   172 {

   173     Q_OBJECT

   174 

   175 public:

   176     tst_QContactAsync();

   177     virtual ~tst_QContactAsync();

   178 

   179 public slots:

   180     void init();

   181     void cleanup();

   182 

   183 private:

   184     void addManagers(); // add standard managers to the data

   185 

   186 private slots:

   187     void testDestructor();

   188     void testDestructor_data() { addManagers(); }

   189 

   190     void contactFetch();

   191     void contactFetch_data() { addManagers(); }

   192     void contactIdFetch();

   193     void contactIdFetch_data() { addManagers(); }

   194     void contactRemove();

   195     void contactRemove_data() { addManagers(); }

   196     void contactSave();

   197     void contactSave_data() { addManagers(); }

   198 

   199     void definitionFetch();

   200     void definitionFetch_data() { addManagers(); }

   201     void definitionRemove();

   202     void definitionRemove_data() { addManagers(); }

   203     void definitionSave();

   204     void definitionSave_data() { addManagers(); }

   205 

   206     void relationshipFetch();

   207     void relationshipFetch_data() { addManagers(); }

   208     void relationshipRemove();

   209     void relationshipRemove_data() { addManagers(); }

   210     void relationshipSave();

   211     void relationshipSave_data() { addManagers(); }

   212 

   213     void maliciousManager(); // uses it's own custom data (manager)

   214 

   215     void testQuickDestruction();

   216     void testQuickDestruction_data() { addManagers(); }

   217 

   218     void threadDelivery();

   219     void progressReceived(QContactFetchRequest* request, bool appendOnly);

   220     void threadDelivery_data() { addManagers(); }

   221 

   222 private:

   223     bool containsIgnoringTimestamps(const QList<QContact>& list, const QContact& c);

   224     bool compareIgnoringTimestamps(const QContact& ca, const QContact& cb);

   225     QContactManager* prepareModel(const QString& uri);

   226 

   227     Qt::HANDLE m_mainThreadId;

   228     Qt::HANDLE m_progressSlotThreadId;

   229     QContactManagerDataHolder managerDataHolder;

   230 };

   231 

   232 tst_QContactAsync::tst_QContactAsync()

   233 {

   234     // ensure we can load all of the plugins we need to.

   235     QString path = QApplication::applicationDirPath() + "/dummyplugin/plugins";

   236     QApplication::addLibraryPath(path);

   237 

   238     qRegisterMetaType<QContactAbstractRequest::State>("QContactAbstractRequest::State");

   239 

   240 }

   241 

   242 tst_QContactAsync::~tst_QContactAsync()

   243 {

   244     QString path = QApplication::applicationDirPath() + "/dummyplugin/plugins";

   245     QApplication::removeLibraryPath(path);

   246 }

   247 

   248 void tst_QContactAsync::init()

   249 {

   250 }

   251 

   252 void tst_QContactAsync::cleanup()

   253 {

   254 }

   255 

   256 bool tst_QContactAsync::containsIgnoringTimestamps(const QList<QContact>& list, const QContact& c)

   257 {

   258     QList<QContact> cl = list;

   259     QContact a(c);

   260     for (int i = 0; i < cl.size(); i++) {

   261         QContact b(cl.at(i));

   262         if (compareIgnoringTimestamps(a, b))

   263             return true;

   264     }

   265 

   266     return false;

   267 }

   268 

   269 bool tst_QContactAsync::compareIgnoringTimestamps(const QContact& ca, const QContact& cb)

   270 {

   271     // Compares two contacts, ignoring any timestamp details

   272     QContact a(ca);

   273     QContact b(cb);

   274     QList<QContactDetail> aDetails = a.details();

   275     QList<QContactDetail> bDetails = b.details();

   276 

   277     // They can be in any order, so loop

   278     // First remove any matches, and any timestamps

   279     foreach (QContactDetail d, aDetails) {

   280         foreach (QContactDetail d2, bDetails) {

   281             if (d == d2) {

   282                 a.removeDetail(&d);

   283                 b.removeDetail(&d2);

   284                 break;

   285             }

   286 

   287             if (d.definitionName() == QContactTimestamp::DefinitionName) {

   288                 a.removeDetail(&d);

   289             }

   290 

   291             if (d2.definitionName() == QContactTimestamp::DefinitionName) {

   292                 b.removeDetail(&d2);

   293             }

   294         }

   295     }

   296 

   297     if (a == b)

   298         return true;

   299     return false;

   300 }

   301 

   302 void tst_QContactAsync::testDestructor()

   303 {

   304     QFETCH(QString, uri);

   305     QContactManager* cm = prepareModel(uri);

   306     QContactFetchRequest* req = new QContactFetchRequest;

   307     req->setManager(cm);

   308 

   309     QContactManager* cm2 = prepareModel(uri);

   310     QContactFetchRequest* req2 = new QContactFetchRequest;

   311     req2->setManager(cm2);

   312 

   313     // first, delete manager then request

   314     delete cm;

   315     delete req;

   316 

   317     // second, delete request then manager

   318     delete req2;

   319     delete cm2;

   320 }

   321 

   322 void tst_QContactAsync::contactFetch()

   323 {

   324     QFETCH(QString, uri);

   325     QScopedPointer<QContactManager> cm(prepareModel(uri));

   326 

   327     QContactFetchRequest cfr;

   328     QVERIFY(cfr.type() == QContactAbstractRequest::ContactFetchRequest);

   329 

   330     // initial state - not started, no manager.

   331     QVERIFY(!cfr.isActive());

   332     QVERIFY(!cfr.isFinished());

   333     QVERIFY(!cfr.start());

   334     QVERIFY(!cfr.cancel());

   335     QVERIFY(!cfr.waitForFinished());

   336 

   337     // "all contacts" retrieval

   338     QContactFilter fil;

   339     cfr.setManager(cm.data());

   340     QCOMPARE(cfr.manager(), cm.data());

   341     QVERIFY(!cfr.isActive());

   342     QVERIFY(!cfr.isFinished());

   343     QVERIFY(!cfr.cancel());

   344     QVERIFY(!cfr.waitForFinished());

   345     qRegisterMetaType<QContactFetchRequest*>("QContactFetchRequest*");

   346     QThreadSignalSpy spy(&cfr, SIGNAL(stateChanged(QContactAbstractRequest::State)));

   347     cfr.setFilter(fil);

   348     QCOMPARE(cfr.filter(), fil);

   349     QVERIFY(!cfr.cancel()); // not started

   350 

   351     QVERIFY(cfr.start());

   352     //QVERIFY(cfr.isFinished() || !cfr.start());  // already started. // thread scheduling means this is untestable

   353     QVERIFY((cfr.isActive() && cfr.state() == QContactAbstractRequest::ActiveState) || cfr.isFinished());

   354     QVERIFY(cfr.waitForFinished());

   355     QVERIFY(cfr.isFinished());

   356 

   357     QVERIFY(spy.count() >= 1); // active + finished progress signals

   358     spy.clear();

   359 

   360     QList<QContactLocalId> contactIds = cm->contactIds();

   361     QList<QContact> contacts = cfr.contacts();

   362     QCOMPARE(contactIds.size(), contacts.size());

   363     for (int i = 0; i < contactIds.size(); i++) {

   364         QContact curr = cm->contact(contactIds.at(i));

   365         QVERIFY(contacts.at(i) == curr);

   366     }

   367 

   368     // asynchronous detail filtering

   369     QContactDetailFilter dfil;

   370     dfil.setDetailDefinitionName(QContactUrl::DefinitionName, QContactUrl::FieldUrl);

   371     cfr.setFilter(dfil);

   372     QVERIFY(cfr.filter() == dfil);

   373     QVERIFY(!cfr.cancel()); // not started

   374 

   375     QVERIFY(cfr.start());

   376     QVERIFY((cfr.isActive() && cfr.state() == QContactAbstractRequest::ActiveState) || cfr.isFinished());

   377     //QVERIFY(cfr.isFinished() || !cfr.start());  // already started. // thread scheduling means this is untestable

   378     QVERIFY(cfr.waitForFinished());

   379     QVERIFY(cfr.isFinished());

   380     QVERIFY(spy.count() >= 1); // active + finished progress signals

   381     spy.clear();

   382 

   383     contactIds = cm->contactIds(dfil);

   384     contacts = cfr.contacts();

   385     QCOMPARE(contactIds.size(), contacts.size());

   386     for (int i = 0; i < contactIds.size(); i++) {

   387         QContact curr = cm->contact(contactIds.at(i));

   388         QVERIFY(contacts.at(i) == curr);

   389     }

   390 

   391     // sort order

   392     QContactSortOrder sortOrder;

   393     sortOrder.setDetailDefinitionName(QContactPhoneNumber::DefinitionName, QContactPhoneNumber::FieldNumber);

   394     QList<QContactSortOrder> sorting;

   395     sorting.append(sortOrder);

   396     cfr.setFilter(fil);

   397     cfr.setSorting(sorting);

   398     QCOMPARE(cfr.sorting(), sorting);

   399     QVERIFY(!cfr.cancel()); // not started

   400     QVERIFY(cfr.start());

   401     QVERIFY((cfr.isActive() && cfr.state() == QContactAbstractRequest::ActiveState) || cfr.isFinished());

   402     //QVERIFY(cfr.isFinished() || !cfr.start());  // already started. // thread scheduling means this is untestable

   403     QVERIFY(cfr.waitForFinished());

   404     QVERIFY(cfr.isFinished());

   405 

   406     QVERIFY(spy.count() >= 1); // active + finished progress signals

   407     spy.clear();

   408 

   409     contactIds = cm->contactIds(sorting);

   410     contacts = cfr.contacts();

   411     QCOMPARE(contactIds.size(), contacts.size());

   412     for (int i = 0; i < contactIds.size(); i++) {

   413         QContact curr = cm->contact(contactIds.at(i));

   414         QVERIFY(contacts.at(i) == curr);

   415     }

   416 

   417     // restrictions

   418     sorting.clear();

   419     cfr.setFilter(fil);

   420     cfr.setSorting(sorting);

   421     cfr.setDefinitionRestrictions(QStringList(QContactName::DefinitionName));

   422     QCOMPARE(cfr.definitionRestrictions(), QStringList(QContactName::DefinitionName));

   423     QVERIFY(!cfr.cancel()); // not started

   424     QVERIFY(cfr.start());

   425     QVERIFY((cfr.isActive() && cfr.state() == QContactAbstractRequest::ActiveState) || cfr.isFinished());

   426     //QVERIFY(cfr.isFinished() || !cfr.start());  // already started. // thread scheduling means this is untestable

   427     QVERIFY(cfr.waitForFinished());

   428     QVERIFY(cfr.isFinished());

   429 

   430     QVERIFY(spy.count() >= 1); // active + finished progress signals

   431     spy.clear();

   432 

   433     contactIds = cm->contactIds(sorting);

   434     contacts = cfr.contacts();

   435     QCOMPARE(contactIds.size(), contacts.size());

   436     for (int i = 0; i < contactIds.size(); i++) {

   437         // create a contact from the restricted data only (id + display label)

   438         QContact currFull = cm->contact(contactIds.at(i));

   439         QContact currRestricted;

   440         currRestricted.setId(currFull.id());

   441         QList<QContactName> names = currFull.details<QContactName>();

   442         foreach (const QContactName& name, names) {

   443             QContactName fullName = name;

   444             if (!fullName.isEmpty()) {

   445                 currRestricted.saveDetail(&fullName);

   446             }

   447         }

   448 

   449         // now find the contact in the retrieved list which our restricted contact mimics

   450         QContact retrievedRestricted;

   451         bool found = false;

   452         foreach (const QContact& retrieved, contacts) {

   453             if (retrieved.id() == currRestricted.id()) {

   454                 retrievedRestricted = retrieved;

   455                 found = true;

   456             }

   457         }

   458 

   459         QVERIFY(found); // must exist or fail.

   460 

   461         // ensure that the contact is the same (except synth fields)

   462         QList<QContactDetail> retrievedDetails = retrievedRestricted.details();

   463         QList<QContactDetail> expectedDetails = currRestricted.details();

   464         foreach (const QContactDetail& det, expectedDetails) {

   465             // ignore backend synthesised details

   466             // again, this requires a "default contact details" function to work properly.

   467             if (det.definitionName() == QContactDisplayLabel::DefinitionName

   468                 || det.definitionName() == QContactTimestamp::DefinitionName) {

   469                 continue;

   470             }

   471 

   472             // everything else in the expected contact should be in the retrieved one.

   473             QVERIFY(retrievedDetails.contains(det));

   474         }

   475     }

   476 

   477     // cancelling

   478     sorting.clear();

   479     cfr.setFilter(fil);

   480     cfr.setSorting(sorting);

   481     cfr.setDefinitionRestrictions(QStringList());

   482 

   483     int bailoutCount = MAX_OPTIMISTIC_SCHEDULING_LIMIT; // attempt to cancel 40 times.  If it doesn't work due to threading, bail out.

   484     while (true) {

   485         QVERIFY(!cfr.cancel()); // not started

   486         FILL_QUEUE_WITH_FETCH_REQUESTS();

   487         QVERIFY(cfr.start());

   488         if (!cfr.cancel()) {

   489             // due to thread scheduling, async cancel might be attempted

   490             // after the request has already finished.. so loop and try again.

   491             spy.clear();

   492             cfr.waitForFinished();

   493             sorting.clear();

   494             cfr.setFilter(fil);

   495             cfr.setSorting(sorting);

   496             cfr.setDefinitionRestrictions(QStringList());

   497             bailoutCount -= 1;

   498             if (!bailoutCount) {

   499                 qWarning("Unable to test cancelling due to thread scheduling!");

   500                 bailoutCount = MAX_OPTIMISTIC_SCHEDULING_LIMIT;

   501                 break;

   502             }

   503             continue;

   504         }

   505 

   506         // if we get here, then we are cancelling the request.

   507         QVERIFY(cfr.waitForFinished());

   508         QVERIFY(cfr.isCanceled());

   509 

   510         QVERIFY(spy.count() >= 1); // active + cancelled progress signals

   511         spy.clear();

   512         break;

   513     }

   514 

   515     // restart, and wait for progress after cancel.

   516     while (true) {

   517         QVERIFY(!cfr.cancel()); // not started

   518         FILL_QUEUE_WITH_FETCH_REQUESTS();

   519         QVERIFY(cfr.start());

   520         if (!cfr.cancel()) {

   521             // due to thread scheduling, async cancel might be attempted

   522             // after the request has already finished.. so loop and try again.

   523             cfr.waitForFinished();

   524             sorting.clear();

   525             cfr.setFilter(fil);

   526             cfr.setSorting(sorting);

   527             cfr.setDefinitionRestrictions(QStringList());

   528             bailoutCount -= 1;

   529             spy.clear();

   530             if (!bailoutCount) {

   531                 qWarning("Unable to test cancelling due to thread scheduling!");

   532                 bailoutCount = MAX_OPTIMISTIC_SCHEDULING_LIMIT;

   533                 break;

   534             }

   535             continue;

   536         }

   537         cfr.waitForFinished();

   538         QVERIFY(spy.count() >= 1); // active + cancelled progress signals

   539         spy.clear();

   540         QVERIFY(!cfr.isActive());

   541         QVERIFY(cfr.state() == QContactAbstractRequest::CanceledState);

   542         break;

   543     }

   544 

   545 }

   546 

   547 void tst_QContactAsync::contactIdFetch()

   548 {

   549     QFETCH(QString, uri);

   550     QScopedPointer<QContactManager> cm(prepareModel(uri));

   551     QContactLocalIdFetchRequest cfr;

   552     QVERIFY(cfr.type() == QContactAbstractRequest::ContactLocalIdFetchRequest);

   553 

   554     // initial state - not started, no manager.

   555     QVERIFY(!cfr.isActive());

   556     QVERIFY(!cfr.isFinished());

   557     QVERIFY(!cfr.start());

   558     QVERIFY(!cfr.cancel());

   559     QVERIFY(!cfr.waitForFinished());

   560 

   561     // "all contacts" retrieval

   562     QContactFilter fil;

   563     cfr.setManager(cm.data());

   564     QCOMPARE(cfr.manager(), cm.data());

   565     QVERIFY(!cfr.isActive());

   566     QVERIFY(!cfr.isFinished());

   567     QVERIFY(!cfr.cancel());

   568     QVERIFY(!cfr.waitForFinished());

   569     qRegisterMetaType<QContactLocalIdFetchRequest*>("QContactLocalIdFetchRequest*");

   570 

   571     QThreadSignalSpy spy(&cfr, SIGNAL(stateChanged(QContactAbstractRequest::State)));

   572     cfr.setFilter(fil);

   573     QCOMPARE(cfr.filter(), fil);

   574     QVERIFY(!cfr.cancel()); // not started

   575     QVERIFY(cfr.start());

   576 

   577     QVERIFY((cfr.isActive() &&cfr.state() == QContactAbstractRequest::ActiveState) || cfr.isFinished());

   578     //QVERIFY(cfr.isFinished() || !cfr.start());  // already started. // thread scheduling means this is untestable

   579     QVERIFY(cfr.waitForFinished());

   580     QVERIFY(cfr.isFinished());

   581 

   582     QVERIFY(spy.count() >= 1); // active + finished progress signals

   583     spy.clear();

   584 

   585     QList<QContactLocalId> contactIds = cm->contactIds();

   586     QList<QContactLocalId> result = cfr.ids();

   587     QCOMPARE(contactIds, result);

   588 

   589     // asynchronous detail filtering

   590     QContactDetailFilter dfil;

   591     dfil.setDetailDefinitionName(QContactUrl::DefinitionName, QContactUrl::FieldUrl);

   592     cfr.setFilter(dfil);

   593     QVERIFY(cfr.filter() == dfil);

   594     QVERIFY(!cfr.cancel()); // not started

   595 

   596     QVERIFY(cfr.start());

   597     QVERIFY((cfr.isActive() && cfr.state() == QContactAbstractRequest::ActiveState) || cfr.isFinished());

   598     //QVERIFY(cfr.isFinished() || !cfr.start());  // already started. // thread scheduling means this is untestable

   599     QVERIFY(cfr.waitForFinished());

   600     QVERIFY(cfr.isFinished());

   601 

   602     QVERIFY(spy.count() >= 1); // active + finished progress signals

   603     spy.clear();

   604 

   605     contactIds = cm->contactIds(dfil);

   606     result = cfr.ids();

   607     QCOMPARE(contactIds, result);

   608 

   609     // sort order

   610     QContactSortOrder sortOrder;

   611     sortOrder.setDetailDefinitionName(QContactPhoneNumber::DefinitionName, QContactPhoneNumber::FieldNumber);

   612     QList<QContactSortOrder> sorting;

   613     sorting.append(sortOrder);

   614     cfr.setFilter(fil);

   615     cfr.setSorting(sorting);

   616     QCOMPARE(cfr.sorting(), sorting);

   617     QVERIFY(!cfr.cancel()); // not started

   618     QVERIFY(cfr.start());

   619     QVERIFY((cfr.isActive() && cfr.state() == QContactAbstractRequest::ActiveState) || cfr.isFinished());

   620     //QVERIFY(cfr.isFinished() || !cfr.start());  // already started. // thread scheduling means this is untestable

   621     QVERIFY(cfr.waitForFinished());

   622     QVERIFY(cfr.isFinished());

   623 

   624     QVERIFY(spy.count() >= 1); // active + finished progress signals

   625     spy.clear();

   626 

   627     contactIds = cm->contactIds(sorting);

   628     result = cfr.ids();

   629     QCOMPARE(contactIds, result);

   630 

   631     // cancelling

   632     sorting.clear();

   633     cfr.setFilter(fil);

   634     cfr.setSorting(sorting);

   635 

   636     int bailoutCount = MAX_OPTIMISTIC_SCHEDULING_LIMIT; // attempt to cancel 40 times.  If it doesn't work due to threading, bail out.

   637     while (true) {

   638         QVERIFY(!cfr.cancel()); // not started

   639         FILL_QUEUE_WITH_FETCH_REQUESTS();

   640         QVERIFY(cfr.start());

   641         if (!cfr.cancel()) {

   642             // due to thread scheduling, async cancel might be attempted

   643             // after the request has already finished.. so loop and try again.

   644             cfr.waitForFinished();

   645             sorting.clear();

   646             cfr.setFilter(fil);

   647             cfr.setSorting(sorting);

   648             bailoutCount -= 1;

   649             spy.clear();

   650             if (!bailoutCount) {

   651                 qWarning("Unable to test cancelling due to thread scheduling!");

   652                 bailoutCount = MAX_OPTIMISTIC_SCHEDULING_LIMIT;

   653                 break;

   654             }

   655             continue;

   656         }

   657 

   658         // if we get here, then we are cancelling the request.

   659         QVERIFY(cfr.waitForFinished());

   660         QVERIFY(cfr.isCanceled());

   661 

   662         QVERIFY(spy.count() >= 1); // active + cancelled progress signals

   663         spy.clear();

   664 

   665         break;

   666     }

   667 

   668     // restart, and wait for progress after cancel.

   669     while (true) {

   670         QVERIFY(!cfr.cancel()); // not started

   671         FILL_QUEUE_WITH_FETCH_REQUESTS();

   672         QVERIFY(cfr.start());

   673         if (!cfr.cancel()) {

   674             // due to thread scheduling, async cancel might be attempted

   675             // after the request has already finished.. so loop and try again.

   676             cfr.waitForFinished();

   677             sorting.clear();

   678             cfr.setFilter(fil);

   679             cfr.setSorting(sorting);

   680             bailoutCount -= 1;

   681             if (!bailoutCount) {

   682                 qWarning("Unable to test cancelling due to thread scheduling!");

   683                 bailoutCount = MAX_OPTIMISTIC_SCHEDULING_LIMIT;

   684                 break;

   685             }

   686             continue;

   687         }

   688         cfr.waitForFinished();

   689         QVERIFY(cfr.isCanceled());

   690 

   691         QVERIFY(spy.count() >= 1); // active + cancelled progress signals

   692         spy.clear();

   693         break;

   694     }

   695 

   696 }

   697 

   698 void tst_QContactAsync::contactRemove()

   699 {

   700     QFETCH(QString, uri);

   701     QScopedPointer<QContactManager> cm(prepareModel(uri));

   702     QContactRemoveRequest crr;

   703     QVERIFY(crr.type() == QContactAbstractRequest::ContactRemoveRequest);

   704 

   705     // initial state - not started, no manager.

   706     QVERIFY(!crr.isActive());

   707     QVERIFY(!crr.isFinished());

   708     QVERIFY(!crr.start());

   709     QVERIFY(!crr.cancel());

   710     QVERIFY(!crr.waitForFinished());

   711 

   712     // specific contact removal via detail filter

   713     int originalCount = cm->contactIds().size();

   714     QContactDetailFilter dfil;

   715     dfil.setDetailDefinitionName(QContactUrl::DefinitionName, QContactUrl::FieldUrl);

   716     crr.setContactIds(cm->contactIds(dfil));

   717     crr.setManager(cm.data());

   718     QCOMPARE(crr.manager(), cm.data());

   719     QVERIFY(!crr.isActive());

   720     QVERIFY(!crr.isFinished());

   721     QVERIFY(!crr.cancel());

   722     QVERIFY(!crr.waitForFinished());

   723     qRegisterMetaType<QContactRemoveRequest*>("QContactRemoveRequest*");

   724     QThreadSignalSpy spy(&crr, SIGNAL(stateChanged(QContactAbstractRequest::State)));

   725     QVERIFY(!crr.cancel()); // not started

   726 

   727     QVERIFY(!cm->contactIds(dfil).isEmpty());

   728 

   729     QVERIFY(crr.start());

   730 

   731     QVERIFY((crr.isActive() &&crr.state() == QContactAbstractRequest::ActiveState) || crr.isFinished());

   732     //QVERIFY(crr.isFinished() || !crr.start());  // already started. // thread scheduling means this is untestable

   733     QVERIFY(crr.waitForFinished());

   734     QVERIFY(crr.isFinished());

   735 

   736     QVERIFY(spy.count() >= 1); // active + finished progress signals

   737     spy.clear();

   738 

   739     QCOMPARE(cm->contactIds().size(), originalCount - 1);

   740     QVERIFY(cm->contactIds(dfil).isEmpty());

   741 

   742     // remove all contacts

   743     dfil.setDetailDefinitionName(QContactDisplayLabel::DefinitionName); // delete everything.

   744     crr.setContactIds(cm->contactIds(dfil));

   745     

   746     QVERIFY(!crr.cancel()); // not started

   747     QVERIFY(crr.start());

   748 

   749     QVERIFY((crr.isActive() && crr.state() == QContactAbstractRequest::ActiveState) || crr.isFinished());

   750     //QVERIFY(crr.isFinished() || !crr.start());  // already started. // thread scheduling means this is untestable

   751     QVERIFY(crr.waitForFinished());

   752     QVERIFY(crr.isFinished());

   753 

   754     QCOMPARE(cm->contactIds().size(), 0); // no contacts should be left.

   755     QVERIFY(spy.count() >= 1); // active + finished progress signals

   756     spy.clear();

   757 

   758     // cancelling

   759     QContact temp;

   760     QContactName nameDetail;

   761     nameDetail.setFirstName("Should not be removed");

   762     temp.saveDetail(&nameDetail);

   763     cm->saveContact(&temp);

   764     crr.setContactIds(cm->contactIds(dfil));

   765 

   766     int bailoutCount = MAX_OPTIMISTIC_SCHEDULING_LIMIT; // attempt to cancel 40 times.  If it doesn't work due to threading, bail out.

   767     while (true) {

   768         QVERIFY(!crr.cancel()); // not started

   769         FILL_QUEUE_WITH_FETCH_REQUESTS();

   770         QVERIFY(spy.count() == 0);

   771         QVERIFY(crr.start());

   772         if (!crr.cancel()) {

   773             // due to thread scheduling, async cancel might be attempted

   774             // after the request has already finished.. so loop and try again.

   775             crr.waitForFinished();

   776             crr.setContactIds(cm->contactIds(dfil));

   777             temp.setId(QContactId());

   778             if (!cm->saveContact(&temp)) {

   779                 QSKIP("Unable to save temporary contact for remove request cancellation test!", SkipSingle);

   780             }

   781             bailoutCount -= 1;

   782             if (!bailoutCount) {

   783                 qWarning("Unable to test cancelling due to thread scheduling!");

   784                 bailoutCount = MAX_OPTIMISTIC_SCHEDULING_LIMIT;

   785                 break;

   786             }

   787             spy.clear();

   788             continue;

   789         }

   790 

   791         // if we get here, then we are cancelling the request.

   792         QVERIFY(crr.waitForFinished());

   793         QVERIFY(crr.isCanceled());

   794         QCOMPARE(cm->contactIds().size(), 1);

   795         QCOMPARE(cm->contact(cm->contactIds().first()), temp);

   796         QVERIFY(spy.count() >= 1); // active + cancelled progress signals

   797         spy.clear();

   798         break;

   799     }

   800 

   801     // restart, and wait for progress after cancel.

   802     while (true) {

   803         QVERIFY(!crr.cancel()); // not started

   804         FILL_QUEUE_WITH_FETCH_REQUESTS();

   805         QVERIFY(crr.start());

   806         if (!crr.cancel()) {

   807             // due to thread scheduling, async cancel might be attempted

   808             // after the request has already finished.. so loop and try again.

   809             crr.waitForFinished();

   810             crr.setContactIds(cm->contactIds(dfil));

   811             temp.setId(QContactId());

   812             cm->saveContact(&temp);

   813             bailoutCount -= 1;

   814             if (!bailoutCount) {

   815                 qWarning("Unable to test cancelling due to thread scheduling!");

   816                 bailoutCount = MAX_OPTIMISTIC_SCHEDULING_LIMIT;

   817                 break;

   818             }

   819             spy.clear();

   820             continue;

   821         }

   822         crr.waitForFinished();

   823         QVERIFY(crr.isCanceled());

   824         QCOMPARE(cm->contactIds().size(), 1);

   825         QCOMPARE(cm->contact(cm->contactIds().first()), temp);

   826         QVERIFY(spy.count() >= 1); // active + cancelled progress signals

   827         spy.clear();

   828         break;

   829     }

   830 

   831 }

   832 

   833 void tst_QContactAsync::contactSave()

   834 {

   835     QFETCH(QString, uri);

   836     QScopedPointer<QContactManager> cm(prepareModel(uri));

   837     QContactSaveRequest csr;

   838     QVERIFY(csr.type() == QContactAbstractRequest::ContactSaveRequest);

   839 

   840     // initial state - not started, no manager.

   841     QVERIFY(!csr.isActive());

   842     QVERIFY(!csr.isFinished());

   843     QVERIFY(!csr.start());

   844     QVERIFY(!csr.cancel());

   845     QVERIFY(!csr.waitForFinished());

   846 

   847     // save a new contact

   848     int originalCount = cm->contactIds().size();

   849     QContact testContact;

   850     QContactName nameDetail;

   851     nameDetail.setFirstName("Test Contact");

   852     testContact.saveDetail(&nameDetail);

   853     QList<QContact> saveList;

   854     saveList << testContact;

   855     csr.setManager(cm.data());

   856     QCOMPARE(csr.manager(), cm.data());

   857     QVERIFY(!csr.isActive());

   858     QVERIFY(!csr.isFinished());

   859     QVERIFY(!csr.cancel());

   860     QVERIFY(!csr.waitForFinished());

   861     qRegisterMetaType<QContactSaveRequest*>("QContactSaveRequest*");

   862     QThreadSignalSpy spy(&csr, SIGNAL(stateChanged(QContactAbstractRequest::State)));

   863     csr.setContacts(saveList);

   864     QCOMPARE(csr.contacts(), saveList);

   865     QVERIFY(!csr.cancel()); // not started

   866     QVERIFY(csr.start());

   867 

   868     QVERIFY((csr.isActive() && csr.state() == QContactAbstractRequest::ActiveState) || csr.isFinished());

   869     //QVERIFY(csr.isFinished() || !csr.start());  // already started. // thread scheduling means this is untestable

   870     QVERIFY(csr.waitForFinished());

   871     QVERIFY(csr.isFinished());

   872     QVERIFY(spy.count() >= 1); // active + finished progress signals

   873     spy.clear();

   874 

   875     QList<QContact> expected;

   876     expected << cm->contact(cm->contactIds().last());

   877     QList<QContact> result = csr.contacts();

   878     QCOMPARE(expected, result);

   879     QCOMPARE(cm->contactIds().size(), originalCount + 1);

   880 

   881     // update a previously saved contact

   882     QContactPhoneNumber phn;

   883     phn.setNumber("12345678");

   884     testContact = expected.first();

   885     testContact.saveDetail(&phn);

   886     saveList.clear();

   887     saveList << testContact;

   888     csr.setContacts(saveList);

   889     QCOMPARE(csr.contacts(), saveList);

   890     QVERIFY(!csr.cancel()); // not started

   891     QVERIFY(csr.start());

   892 

   893     QVERIFY((csr.isActive() && csr.state() == QContactAbstractRequest::ActiveState) || csr.isFinished());

   894     //QVERIFY(csr.isFinished() || !csr.start());  // already started. // thread scheduling means this is untestable

   895     QVERIFY(csr.waitForFinished());

   896 

   897     QVERIFY(csr.isFinished());

   898     QVERIFY(spy.count() >= 1); // active + finished progress signals

   899     spy.clear();

   900 

   901     expected.clear();

   902     expected << cm->contact(cm->contactIds().last());

   903     result = csr.contacts();

   904     QCOMPARE(expected, result);

   905 

   906     //here we can't compare the whole contact details, testContact would be updated by async call because we just use QThreadSignalSpy to receive signals.

   907     //QVERIFY(containsIgnoringTimestamps(expected, testContact));

   908     QVERIFY(expected.at(0).detail<QContactPhoneNumber>().number() == phn.number());

   909     

   910     QCOMPARE(cm->contactIds().size(), originalCount + 1);

   911 

   912     // cancelling

   913     QContact temp = testContact;

   914     QContactUrl url;

   915     url.setUrl("should not get saved");

   916     temp.saveDetail(&url);

   917     saveList.clear();

   918     saveList << temp;

   919     csr.setContacts(saveList);

   920 

   921     int bailoutCount = MAX_OPTIMISTIC_SCHEDULING_LIMIT; // attempt to cancel 40 times.  If it doesn't work due to threading, bail out.

   922     while (true) {

   923         QVERIFY(!csr.cancel()); // not started

   924         FILL_QUEUE_WITH_FETCH_REQUESTS();

   925         QVERIFY(csr.start());

   926         if (!csr.cancel()) {

   927             // due to thread scheduling, async cancel might be attempted

   928             // after the request has already finished.. so loop and try again.

   929             csr.waitForFinished();

   930             saveList = csr.contacts();

   931             if (cm->contactIds().size() > (originalCount + 1) && !cm->removeContact(saveList.at(0).localId())) {

   932                 QSKIP("Unable to remove saved contact to test cancellation of contact save request", SkipSingle);

   933             }

   934             saveList.clear();

   935             saveList << temp;

   936             csr.setContacts(saveList);

   937             bailoutCount -= 1;

   938             if (!bailoutCount) {

   939                 qWarning("Unable to test cancelling due to thread scheduling!");

   940                 bailoutCount = MAX_OPTIMISTIC_SCHEDULING_LIMIT;

   941                 break;

   942             }

   943             spy.clear();

   944             continue;

   945         }

   946 

   947         // if we get here, then we are cancelling the request.

   948         QVERIFY(csr.waitForFinished());

   949         QVERIFY(csr.isCanceled());

   950         QVERIFY(spy.count() >= 1); // active + cancelled progress signals

   951         spy.clear();

   952 

   953         // verify that the changes were not saved

   954         expected.clear();

   955         QList<QContactLocalId> allContacts = cm->contactIds();

   956         for (int i = 0; i < allContacts.size(); i++) {

   957             expected.append(cm->contact(allContacts.at(i)));

   958         }

   959         QVERIFY(!expected.contains(temp));

   960         QCOMPARE(cm->contactIds().size(), originalCount + 1);

   961         break;

   962     }

   963     // restart, and wait for progress after cancel.

   964 

   965     while (true) {

   966         QVERIFY(!csr.cancel()); // not started

   967         FILL_QUEUE_WITH_FETCH_REQUESTS();

   968         QVERIFY(csr.start());

   969         if (!csr.cancel()) {

   970             // due to thread scheduling, async cancel might be attempted

   971             // after the request has already finished.. so loop and try again.

   972             csr.waitForFinished();

   973             saveList = csr.contacts();

   974             if (cm->contactIds().size() > (originalCount + 1) && !cm->removeContact(saveList.at(0).localId())) {

   975                 QSKIP("Unable to remove saved contact to test cancellation of contact save request", SkipSingle);

   976             }

   977             saveList.clear();

   978             saveList << temp;

   979             csr.setContacts(saveList);

   980             bailoutCount -= 1;

   981             if (!bailoutCount) {

   982                 qWarning("Unable to test cancelling due to thread scheduling!");

   983                 bailoutCount = MAX_OPTIMISTIC_SCHEDULING_LIMIT;

   984                 break;

   985             }

   986             spy.clear();

   987             continue;

   988         }

   989         csr.waitForFinished(); // now wait until finished (if it hasn't already).

   990         QVERIFY(csr.isCanceled());

   991         QVERIFY(spy.count() >= 1); // active + cancelled progress signals

   992         spy.clear();

   993 

   994         // verify that the changes were not saved

   995         expected.clear();

   996         QList<QContactLocalId> allContacts = cm->contactIds();

   997         for (int i = 0; i < allContacts.size(); i++) {

   998             expected.append(cm->contact(allContacts.at(i)));

   999         }

  1000         QVERIFY(!expected.contains(temp));

  1001         QCOMPARE(cm->contactIds().size(), originalCount + 1);

  1002         break;

  1003     }

  1004 }

  1005 

  1006 void tst_QContactAsync::definitionFetch()

  1007 {

  1008     QFETCH(QString, uri);

  1009     QScopedPointer<QContactManager> cm(prepareModel(uri));

  1010     QContactDetailDefinitionFetchRequest dfr;

  1011     QVERIFY(dfr.type() == QContactAbstractRequest::DetailDefinitionFetchRequest);

  1012     dfr.setContactType(QContactType::TypeContact);

  1013     QVERIFY(dfr.contactType() == QString(QLatin1String(QContactType::TypeContact)));

  1014 

  1015     // initial state - not started, no manager.

  1016     QVERIFY(!dfr.isActive());

  1017     QVERIFY(!dfr.isFinished());

  1018     QVERIFY(!dfr.start());

  1019     QVERIFY(!dfr.cancel());

  1020     QVERIFY(!dfr.waitForFinished());

  1021 

  1022     // "all definitions" retrieval

  1023     dfr.setManager(cm.data());

  1024     QCOMPARE(dfr.manager(), cm.data());

  1025     QVERIFY(!dfr.isActive());

  1026     QVERIFY(!dfr.isFinished());

  1027     QVERIFY(!dfr.cancel());

  1028     QVERIFY(!dfr.waitForFinished());

  1029     qRegisterMetaType<QContactDetailDefinitionFetchRequest*>("QContactDetailDefinitionFetchRequest*");

  1030     QThreadSignalSpy spy(&dfr, SIGNAL(stateChanged(QContactAbstractRequest::State)));

  1031     dfr.setDefinitionNames(QStringList());

  1032     QVERIFY(!dfr.cancel()); // not started

  1033     QVERIFY(dfr.start());

  1034 

  1035     QVERIFY((dfr.isActive() && dfr.state() == QContactAbstractRequest::ActiveState) || dfr.isFinished());

  1036     //QVERIFY(dfr.isFinished() || !dfr.start());  // already started. // thread scheduling means this is untestable

  1037     QVERIFY(dfr.waitForFinished());

  1038     QVERIFY(dfr.isFinished());

  1039     QVERIFY(spy.count() >= 1); // active + finished progress signals

  1040     spy.clear();

  1041 

  1042     QMap<QString, QContactDetailDefinition> defs = cm->detailDefinitions();

  1043     QMap<QString, QContactDetailDefinition> result = dfr.definitions();

  1044     QCOMPARE(defs, result);

  1045 

  1046     // specific definition retrieval

  1047     QStringList specific;

  1048     specific << QContactUrl::DefinitionName;

  1049     dfr.setDefinitionNames(specific);

  1050     QVERIFY(!dfr.cancel()); // not started

  1051     QVERIFY(dfr.start());

  1052 

  1053     QVERIFY((dfr.isActive() && dfr.state() == QContactAbstractRequest::ActiveState) || dfr.isFinished());

  1054     //QVERIFY(dfr.isFinished() || !dfr.start());  // already started. // thread scheduling means this is untestable

  1055     QVERIFY(dfr.waitForFinished());

  1056     QVERIFY(dfr.isFinished());

  1057     QVERIFY(spy.count() >= 1); // active + finished progress signals

  1058     spy.clear();

  1059 

  1060     defs.clear();

  1061     defs.insert(QContactUrl::DefinitionName, cm->detailDefinition(QContactUrl::DefinitionName));

  1062     result = dfr.definitions();

  1063     QCOMPARE(defs, result);

  1064 

  1065     // cancelling

  1066     dfr.setDefinitionNames(QStringList());

  1067 

  1068     int bailoutCount = MAX_OPTIMISTIC_SCHEDULING_LIMIT; // attempt to cancel 40 times.  If it doesn't work due to threading, bail out.

  1069     while (true) {

  1070         QVERIFY(!dfr.cancel()); // not started

  1071         FILL_QUEUE_WITH_FETCH_REQUESTS();

  1072         QVERIFY(dfr.start());

  1073         if (!dfr.cancel()) {

  1074             // due to thread scheduling, async cancel might be attempted

  1075             // after the request has already finished.. so loop and try again.

  1076             dfr.waitForFinished();

  1077             dfr.setDefinitionNames(QStringList());

  1078             bailoutCount -= 1;

  1079             if (!bailoutCount) {

  1080                 qWarning("Unable to test cancelling due to thread scheduling!");

  1081                 bailoutCount = MAX_OPTIMISTIC_SCHEDULING_LIMIT;

  1082                 break;

  1083             }

  1084             spy.clear();

  1085             continue;

  1086         }

  1087 

  1088         // if we get here, then we are cancelling the request.

  1089         QVERIFY(dfr.waitForFinished());

  1090         QVERIFY(dfr.isCanceled());

  1091         QVERIFY(spy.count() >= 1); // active + cancelled progress signals

  1092         spy.clear();

  1093         break;

  1094     }

  1095 

  1096     // restart, and wait for progress after cancel.

  1097     while (true) {

  1098         QVERIFY(!dfr.cancel()); // not started

  1099         FILL_QUEUE_WITH_FETCH_REQUESTS();

  1100         QVERIFY(dfr.start());

  1101         if (!dfr.cancel()) {

  1102             // due to thread scheduling, async cancel might be attempted

  1103             // after the request has already finished.. so loop and try again.

  1104             dfr.waitForFinished();

  1105             dfr.setDefinitionNames(QStringList());

  1106             bailoutCount -= 1;

  1107             if (!bailoutCount) {

  1108                 qWarning("Unable to test cancelling due to thread scheduling!");

  1109                 bailoutCount = MAX_OPTIMISTIC_SCHEDULING_LIMIT;

  1110                 break;

  1111             }

  1112             spy.clear();

  1113             continue;

  1114         }

  1115         dfr.waitForFinished();

  1116         QVERIFY(dfr.isCanceled());

  1117         QVERIFY(spy.count() >= 1); // active + cancelled progress signals

  1118         spy.clear();

  1119 

  1120         break;

  1121     }

  1122 

  1123 }

  1124 

  1125 void tst_QContactAsync::definitionRemove()

  1126 {

  1127     QFETCH(QString, uri);

  1128 

  1129     QScopedPointer<QContactManager> cm(prepareModel(uri));

  1130     if (!cm->hasFeature(QContactManager::MutableDefinitions)) {

  1131        QSKIP("This contact manager doest not support mutable definitions, can't remove a definition!", SkipSingle);

  1132     }

  1133     QContactDetailDefinitionRemoveRequest drr;

  1134     QVERIFY(drr.type() == QContactAbstractRequest::DetailDefinitionRemoveRequest);