Mercurial Mercurial > oss > FCL > sf > mw > qtextensions / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
qtmobility/tests/auto/qcontactasync/unittest/tst_qcontactasync.cpp
changeset 14 6fbed849b4f4
parent 11 06b8e2af4411
equal deleted inserted replaced
11:06b8e2af4411 14:6fbed849b4f4 
    71 class QThreadSignalSpy: public QObject
 
    71 class QThreadSignalSpy: public QObject
 
    72 {
 
    72 {
 
    73 public:
 
    73 public:
 
    74     QThreadSignalSpy(QObject *obj, const char *aSignal)
 
    74     QThreadSignalSpy(QObject *obj, const char *aSignal)
 
    75     {
 
    75     {
 
       
    76         QMutexLocker m(&lock);
 
    76 #ifdef Q_CC_BOR
 
    77 #ifdef Q_CC_BOR
 
    77         const int memberOffset = QObject::staticMetaObject.methodCount();
 
    78         const int memberOffset = QObject::staticMetaObject.methodCount();
 
    78 #else
 
    79 #else
 
    79         static const int memberOffset = QObject::staticMetaObject.methodCount();
 
    80         static const int memberOffset = QObject::staticMetaObject.methodCount();
 
    80 #endif
 
    81 #endif
 
   134     }
 
   135     }
 
   135 
   136 
   136 private:
 
   137 private:
 
   137     void initArgs(const QMetaMethod &member)
 
   138     void initArgs(const QMetaMethod &member)
 
   138     {
 
   139     {
 
   139         QMutexLocker m(&lock);
 
       
   140         QList<QByteArray> params = member.parameterTypes();
 
   140         QList<QByteArray> params = member.parameterTypes();
 
   141         for (int i = 0; i < params.count(); ++i) {
 
   141         for (int i = 0; i < params.count(); ++i) {
 
   142             int tp = QMetaType::type(params.at(i).constData());
 
   142             int tp = QMetaType::type(params.at(i).constData());
 
   143             if (tp == QMetaType::Void)
 
   143             if (tp == QMetaType::Void)
 
   144                 qWarning("Don't know how to handle '%s', use qRegisterMetaType to register it.",
 
   144                 qWarning("Don't know how to handle '%s', use qRegisterMetaType to register it.",
 
   179 public slots:
 
   179 public slots:
 
   180     void initTestCase();
 
   180     void initTestCase();
 
   181     void cleanupTestCase();
 
   181     void cleanupTestCase();
 
   182 
   182 
   183 private:
 
   183 private:
 
   184     void addManagers(); // add standard managers to the data
 
   184     void addManagers(QStringList includes = QStringList()); // add standard managers to the data
 
   185 
   185 
   186 private slots:
 
   186 private slots:
 
   187     void testDestructor();
 
   187     void testDestructor();
 
   188     void testDestructor_data() { addManagers(); }
 
   188     void testDestructor_data() { addManagers(QStringList(QString("maliciousplugin"))); }
 
   189 
   189 
   190     void contactFetch();
 
   190     void contactFetch();
 
   191     void contactFetch_data() { addManagers(); }
 
   191     void contactFetch_data() { addManagers(); }
 
   192     void contactIdFetch();
 
   192     void contactIdFetch();
 
   193     void contactIdFetch_data() { addManagers(); }
 
   193     void contactIdFetch_data() { addManagers(); }
 
   211     void relationshipSave_data() { addManagers(); }
 
   211     void relationshipSave_data() { addManagers(); }
 
   212 
   212 
   213     void maliciousManager(); // uses it's own custom data (manager)
 
   213     void maliciousManager(); // uses it's own custom data (manager)
 
   214 
   214 
   215     void testQuickDestruction();
 
   215     void testQuickDestruction();
 
   216     void testQuickDestruction_data() { addManagers(); }
 
   216     void testQuickDestruction_data() { addManagers(QStringList(QString("maliciousplugin"))); }
 
   217 
   217 
   218     void threadDelivery();
 
   218     void threadDelivery();
 
   219     void threadDelivery_data() { addManagers(); }
 
   219     void threadDelivery_data() { addManagers(QStringList(QString("maliciousplugin"))); }
 
   220 protected slots:
 
   220 protected slots:
 
   221     void resultsAvailableReceived();
 
   221     void resultsAvailableReceived();
 
       
   222     void deleteRequest();
 
   222 
   223 
   223 private:
 
   224 private:
 
   224     bool compareContactLists(QList<QContact> lista, QList<QContact> listb);
 
   225     bool compareContactLists(QList<QContact> lista, QList<QContact> listb);
 
   225     bool compareContacts(QContact ca, QContact cb);
 
   226     bool compareContacts(QContact ca, QContact cb);
 
   226     bool containsIgnoringTimestamps(const QList<QContact>& list, const QContact& c);
 
   227     bool containsIgnoringTimestamps(const QList<QContact>& list, const QContact& c);
 
   371     delete req;
 
   372     delete req;
 
   372 
   373 
   373     // second, delete request then manager
 
   374     // second, delete request then manager
 
   374     delete req2;
 
   375     delete req2;
 
   375     delete cm2;
 
   376     delete cm2;
 
       
   377 }
 
       
   378 
       
   379 void tst_QContactAsync::deleteRequest()
 
       
   380 {
 
       
   381     // Delete the sender (request) - check that it doesn't crash in this common coding error
 
       
   382     delete sender();
 
   376 }
 
   383 }
 
   377 
   384 
   378 void tst_QContactAsync::contactFetch()
 
   385 void tst_QContactAsync::contactFetch()
 
   379 {
 
   386 {
 
   380     QFETCH(QString, uri);
 
   387     QFETCH(QString, uri);
 
   599         QVERIFY(!cfr.isActive());
 
   606         QVERIFY(!cfr.isActive());
 
   600         QVERIFY(cfr.state() == QContactAbstractRequest::CanceledState);
 
   607         QVERIFY(cfr.state() == QContactAbstractRequest::CanceledState);
 
   601         break;
 
   608         break;
 
   602     }
 
   609     }
 
   603 
   610 
       
   611     // Now test deletion in the first slot called
 
       
   612     QContactFetchRequest *cfr2 = new QContactFetchRequest();
 
       
   613     QPointer<QObject> obj(cfr2);
 
       
   614     cfr2->setManager(cm.data());
 
       
   615     connect(cfr2, SIGNAL(resultsAvailable()), this, SLOT(deleteRequest()));
 
       
   616     QVERIFY(cfr2->start());
 
       
   617     int i = 100;
 
       
   618     // at this point we can't even call wait for finished..
 
       
   619     while(obj && i > 0) {
 
       
   620         QTest::qWait(50); // force it to process events at least once.
 
       
   621         i--;
 
       
   622     }
 
       
   623     QVERIFY(obj == NULL);
 
   604 }
 
   624 }
 
   605 
   625 
   606 void tst_QContactAsync::contactIdFetch()
 
   626 void tst_QContactAsync::contactIdFetch()
 
   607 {
 
   627 {
 
   608     QFETCH(QString, uri);
 
   628     QFETCH(QString, uri);
 
  2082     destroyedRequest->setFilter(fil);
 
  2102     destroyedRequest->setFilter(fil);
 
  2083     QVERIFY(!destroyedRequest->start());
 
  2103     QVERIFY(!destroyedRequest->start());
 
  2084     delete destroyedRequest;
 
  2104     delete destroyedRequest;
 
  2085 
  2105 
  2086     // now use a malicious manager that deliberately calls
 
  2106     // now use a malicious manager that deliberately calls
 
  2087     // incorrect "updateRequest" functions in base class:
 
  2107     // things in a different thread
 
  2088     QContactManager mcm("maliciousplugin");
 
  2108     QContactManager mcm("maliciousplugin");
 
  2089     QCOMPARE(mcm.managerName(), QString("maliciousplugin"));
 
  2109     QCOMPARE(mcm.managerName(), QString("maliciousplugin"));
 
  2090     QList<QContact> emptyCList;
 
  2110     QList<QContact> emptyCList;
 
  2091     QList<QContactLocalId> emptyIList;
 
  2111     QList<QContactLocalId> emptyIList;
 
  2092     QList<QContactDetailDefinition> emptyDList;
 
  2112     QList<QContactDetailDefinition> emptyDList;
 
  2093     QStringList emptyDNList;
 
  2113     QStringList emptyDNList;
 
  2094     QMap<QString, QContactDetailDefinition> emptyDMap;
 
  2114     QMap<QString, QContactDetailDefinition> emptyDMap;
 
  2095     cfr.setFilter(fil);
 
  2115     cfr.setFilter(fil);
 
  2096     cfr.setManager(&mcm);
 
  2116     cfr.setManager(&mcm);
 
  2097     QVERIFY(cfr.start());
 
  2117     QVERIFY(cfr.start());
 
  2098     QVERIFY(cfr.cancel());
 
       
  2099     QVERIFY(cfr.waitForFinished(100));
 
       
  2100     QVERIFY(cfr.start());
 
       
  2101     QVERIFY(!cfr.waitForFinished(100));
 
       
  2102     QVERIFY(cfr.cancel());
 
       
  2103 
  2118 
  2104     QContactLocalIdFetchRequest cifr;
 
  2119     QContactLocalIdFetchRequest cifr;
 
  2105     cifr.setFilter(fil);
 
  2120     cifr.setFilter(fil);
 
  2106     cifr.setManager(&mcm);
 
  2121     cifr.setManager(&mcm);
 
  2107     QVERIFY(cifr.start());
 
  2122     QVERIFY(cifr.start());
 
  2108     QVERIFY(cifr.cancel());
 
       
  2109     QVERIFY(cifr.waitForFinished(100));
 
       
  2110     QVERIFY(cifr.start());
 
       
  2111     QVERIFY(!cifr.waitForFinished(100));
 
       
  2112     QVERIFY(cifr.cancel());
 
       
  2113 
  2123 
  2114     QContactRemoveRequest crr;
 
  2124     QContactRemoveRequest crr;
 
  2115     crr.setContactIds(mcm.contactIds(fil));
 
  2125     crr.setContactIds(mcm.contactIds(fil));
 
  2116     crr.setManager(&mcm);
 
  2126     crr.setManager(&mcm);
 
  2117     QVERIFY(crr.start());
 
  2127     QVERIFY(crr.start());
 
  2118     QVERIFY(crr.cancel());
 
       
  2119     QVERIFY(crr.waitForFinished(100));
 
       
  2120     QVERIFY(crr.start());
 
       
  2121     QVERIFY(!crr.waitForFinished(100));
 
       
  2122     QVERIFY(crr.cancel());
 
       
  2123 
  2128 
  2124     QContactSaveRequest csr;
 
  2129     QContactSaveRequest csr;
 
  2125     csr.setContacts(emptyCList);
 
  2130     csr.setContacts(emptyCList);
 
  2126     csr.setManager(&mcm);
 
  2131     csr.setManager(&mcm);
 
  2127     QVERIFY(csr.start());
 
  2132     QVERIFY(csr.start());
 
  2128     QVERIFY(csr.cancel());
 
  2133 
  2129     QVERIFY(csr.waitForFinished(100));
 
  2134     {
 
  2130     QVERIFY(csr.start());
 
       
  2131     QVERIFY(!csr.waitForFinished(100));
 
       
  2132     QVERIFY(csr.cancel());
 
       
  2133 
       
  2134     QContactDetailDefinitionFetchRequest dfr;
 
  2135     QContactDetailDefinitionFetchRequest dfr;
 
  2135     dfr.setDefinitionNames(emptyDNList);
 
  2136     dfr.setDefinitionNames(emptyDNList);
 
  2136     dfr.setManager(&mcm);
 
  2137     dfr.setManager(&mcm);
 
  2137     QVERIFY(dfr.start());
 
  2138     QVERIFY(dfr.start());
 
  2138     QVERIFY(dfr.cancel());
 
  2139     }
 
  2139     QVERIFY(dfr.waitForFinished(100));
 
  2140 
  2140     QVERIFY(dfr.start());
 
  2141     {
 
  2141     QVERIFY(!dfr.waitForFinished(100));
 
  2142     QContactDetailDefinitionFetchRequest dfr;
 
  2142     QVERIFY(dfr.cancel());
 
  2143     dfr.setDefinitionNames(emptyDNList);
 
       
  2144     dfr.setManager(&mcm);
 
       
  2145     }
 
  2143 
  2146 
  2144     QContactDetailDefinitionSaveRequest dsr;
 
  2147     QContactDetailDefinitionSaveRequest dsr;
 
  2145     dsr.setDefinitions(emptyDList);
 
  2148     dsr.setDefinitions(emptyDList);
 
  2146     dsr.setManager(&mcm);
 
  2149     dsr.setManager(&mcm);
 
  2147     QVERIFY(dsr.start());
 
  2150     QVERIFY(dsr.start());
 
  2148     QVERIFY(dsr.cancel());
 
       
  2149     QVERIFY(dsr.waitForFinished(100));
 
       
  2150     QVERIFY(dsr.start());
 
       
  2151     QVERIFY(!dsr.waitForFinished(100));
 
       
  2152     QVERIFY(dsr.cancel());
 
       
  2153 
  2151 
  2154     QContactDetailDefinitionRemoveRequest drr;
 
  2152     QContactDetailDefinitionRemoveRequest drr;
 
  2155     drr.setDefinitionNames(emptyDNList);
 
  2153     drr.setDefinitionNames(emptyDNList);
 
  2156     drr.setManager(&mcm);
 
  2154     drr.setManager(&mcm);
 
  2157     QVERIFY(drr.start());
 
  2155     QVERIFY(drr.start());
 
  2158     QVERIFY(drr.cancel());
 
       
  2159     QVERIFY(drr.waitForFinished(100));
 
       
  2160     QVERIFY(drr.start());
 
       
  2161     QVERIFY(!drr.waitForFinished(100));
 
       
  2162     QVERIFY(drr.cancel());
 
       
  2163 }
 
  2156 }
 
  2164 
  2157 
  2165 void tst_QContactAsync::testQuickDestruction()
 
  2158 void tst_QContactAsync::testQuickDestruction()
 
  2166 {
 
  2159 {
 
  2167     QFETCH(QString, uri);
 
  2160     QFETCH(QString, uri);
 
  2245 {
 
  2238 {
 
  2246     QContactFetchRequest *req = qobject_cast<QContactFetchRequest *>(QObject::sender());
 
  2239     QContactFetchRequest *req = qobject_cast<QContactFetchRequest *>(QObject::sender());
 
  2247     if (req)
 
  2240     if (req)
 
  2248         m_resultsAvailableSlotThreadId = req->thread()->currentThreadId();
 
  2241         m_resultsAvailableSlotThreadId = req->thread()->currentThreadId();
 
  2249     else
 
  2242     else
 
  2250         qDebug() << "resultsAvailableReceived() : request deleted; unable to set thread id!";
 
  2243         qWarning() << "resultsAvailableReceived() : request deleted; unable to set thread id!";
 
  2251 }
 
  2244 }
 
  2252 
  2245 
  2253 void tst_QContactAsync::addManagers()
 
  2246 void tst_QContactAsync::addManagers(QStringList stringlist)
 
  2254 {
 
  2247 {
 
  2255     QTest::addColumn<QString>("uri");
 
  2248     QTest::addColumn<QString>("uri");
 
  2256 
  2249 
  2257     // retrieve the list of available managers
 
  2250     // retrieve the list of available managers
 
  2258     QStringList managers = QContactManager::availableManagers();
 
  2251     QStringList managers = QContactManager::availableManagers();
 
  2259 
  2252 
  2260     // remove ones that we know will not pass
 
  2253     // remove ones that we know will not pass
 
  2261     managers.removeAll("invalid");
 
  2254     if (!stringlist.contains("invalid"))
 
  2262     managers.removeAll("maliciousplugin");
 
  2255         managers.removeAll("invalid");
 
  2263     managers.removeAll("testdummy");
 
  2256     if (!stringlist.contains("maliciousplugin"))
 
  2264     managers.removeAll("symbiansim"); // SIM backend does not support all the required details for tests to pass.
 
  2257         managers.removeAll("maliciousplugin");
 
       
  2258     if (!stringlist.contains("testdummy"))
 
       
  2259         managers.removeAll("testdummy");
 
       
  2260     if (!stringlist.contains("symbiansim"))
 
       
  2261         managers.removeAll("symbiansim"); // SIM backend does not support all the required details for tests to pass.
 
  2265 
  2262 
  2266     foreach(QString mgr, managers) {
 
  2263     foreach(QString mgr, managers) {
 
  2267         QMap<QString, QString> params;
 
  2264         QMap<QString, QString> params;
 
  2268         QTest::newRow(QString("mgr='%1'").arg(mgr).toLatin1().constData()) << QContactManager::buildUri(mgr, params);
 
  2265         QTest::newRow(QString("mgr='%1'").arg(mgr).toLatin1().constData()) << QContactManager::buildUri(mgr, params);
 
  2269         if (mgr == "memory") {
 
  2266         if (mgr == "memory") {
FCL/sf/mw/qtextensions