File indexing completed on 2024-05-12 05:10:38
0001 /* 0002 SPDX-FileCopyrightText: 2011 Sérgio Martins <iamsergio@gmail.com> 0003 0004 SPDX-License-Identifier: LGPL-2.0-or-later 0005 */ 0006 0007 #include "historytest.h" 0008 #include "helper.h" 0009 0010 #include <Akonadi/CollectionFetchJob> 0011 #include <Akonadi/CollectionFetchScope> 0012 #include <Akonadi/ItemCreateJob> 0013 #include <Akonadi/ItemFetchJob> 0014 #include <Akonadi/ItemFetchScope> 0015 #include <KCalendarCore/Event> 0016 #include <akonadi/qtest_akonadi.h> 0017 0018 #include <QTestEventLoop> 0019 0020 using namespace Akonadi; 0021 using namespace KCalendarCore; 0022 0023 Q_DECLARE_METATYPE(QList<Akonadi::IncidenceChanger::ChangeType>) 0024 0025 static bool checkSummary(const Akonadi::Item &item, const QString &expected) 0026 { 0027 auto job = new ItemFetchJob(item); 0028 job->fetchScope().fetchFullPayload(); 0029 bool ok = false; 0030 [&]() { 0031 QVERIFY(job->exec()); 0032 QVERIFY(!job->items().isEmpty()); 0033 ok = true; 0034 }(); 0035 if (!ok) { 0036 return false; 0037 } 0038 Item it = job->items().first(); 0039 if (!it.hasPayload()) { 0040 qWarning() << "Item has no payload"; 0041 return false; 0042 } 0043 0044 if (it.payload<KCalendarCore::Incidence::Ptr>()->summary() == expected) { 0045 return true; 0046 } else { 0047 qDebug() << "Got " << it.payload<KCalendarCore::Incidence::Ptr>()->summary() << "Expected " << expected; 0048 return false; 0049 } 0050 } 0051 0052 static Akonadi::Item item() 0053 { 0054 Item item; 0055 Incidence::Ptr incidence = Incidence::Ptr(new Event()); 0056 incidence->setSummary(QStringLiteral("random summary")); 0057 item.setMimeType(incidence->mimeType()); 0058 item.setPayload<KCalendarCore::Incidence::Ptr>(incidence); 0059 return item; 0060 } 0061 0062 static Akonadi::Item createItem(const Akonadi::Collection &collection) 0063 { 0064 Item i = item(); 0065 auto createJob = new ItemCreateJob(i, collection); 0066 [&]() { 0067 QVERIFY(createJob->exec()); 0068 QVERIFY(createJob->item().isValid()); 0069 }(); 0070 0071 return createJob->item(); 0072 } 0073 0074 void HistoryTest::initTestCase() 0075 { 0076 AkonadiTest::checkTestIsIsolated(); 0077 0078 mHistory = mChanger->history(); 0079 0080 connect(mChanger, &IncidenceChanger::createFinished, this, &HistoryTest::createFinished); 0081 0082 connect(mChanger, &IncidenceChanger::deleteFinished, this, &HistoryTest::deleteFinished); 0083 0084 connect(mChanger, &IncidenceChanger::modifyFinished, this, &HistoryTest::modifyFinished); 0085 0086 connect(mHistory, &History::undone, this, &HistoryTest::handleUndone); 0087 0088 connect(mHistory, &History::redone, this, &HistoryTest::handleRedone); 0089 } 0090 0091 void HistoryTest::testCreation_data() 0092 { 0093 QTest::addColumn<Akonadi::Item>("item"); 0094 QTest::newRow("item1") << item(); 0095 } 0096 0097 void HistoryTest::testCreation() 0098 { 0099 QFETCH(Akonadi::Item, item); 0100 mPendingSignals[CreationSignal] = 1; 0101 QCOMPARE(mHistory->d->redoCount(), 0); 0102 QCOMPARE(mHistory->d->undoCount(), 0); 0103 QVERIFY(item.hasPayload()); 0104 const int changeId = mChanger->createIncidence(item.payload<KCalendarCore::Incidence::Ptr>()); 0105 QVERIFY(changeId > 0); 0106 mKnownChangeIds << changeId; 0107 waitForSignals(); 0108 0109 // Check that it was created 0110 QVERIFY(Helper::confirmExists(mItemByChangeId.value(changeId))); 0111 0112 QCOMPARE(mHistory->d->redoCount(), 0); 0113 QCOMPARE(mHistory->d->undoCount(), 1); 0114 0115 // undo it 0116 mPendingSignals[UndoSignal] = 1; 0117 mHistory->undo(); 0118 waitForSignals(); 0119 0120 // Check that it doesn't exist anymore 0121 QVERIFY(Helper::confirmDoesntExist(mItemByChangeId.value(changeId))); 0122 0123 QCOMPARE(mHistory->d->redoCount(), 1); 0124 QCOMPARE(mHistory->d->undoCount(), 0); 0125 0126 mPendingSignals[RedoSignal] = 1; 0127 mHistory->redo(); 0128 waitForSignals(); 0129 0130 // Undo again just for fun 0131 mPendingSignals[UndoSignal] = 1; 0132 mHistory->undo(); 0133 waitForSignals(); 0134 0135 mHistory->clear(); 0136 QCOMPARE(mHistory->d->redoCount(), 0); 0137 QCOMPARE(mHistory->d->undoCount(), 0); 0138 } 0139 0140 void HistoryTest::testDeletion_data() 0141 { 0142 QTest::addColumn<Akonadi::Item::List>("items"); 0143 Akonadi::Item::List items; 0144 items << createItem(mCollection); 0145 QTest::newRow("one item") << items; 0146 0147 items.clear(); 0148 items << createItem(mCollection) << createItem(mCollection); 0149 QTest::newRow("two items") << items; 0150 0151 items.clear(); 0152 items << createItem(mCollection) << createItem(mCollection) << createItem(mCollection) << createItem(mCollection); 0153 QTest::newRow("four items") << items; 0154 } 0155 0156 void HistoryTest::testDeletion() 0157 { 0158 QFETCH(Akonadi::Item::List, items); 0159 mPendingSignals[DeletionSignal] = 1; 0160 QCOMPARE(mHistory->d->redoCount(), 0); 0161 QCOMPARE(mHistory->d->undoCount(), 0); 0162 0163 const int changeId = (items.count() == 1) ? mChanger->deleteIncidence(items.first()) : mChanger->deleteIncidences(items); 0164 QVERIFY(changeId > 0); 0165 mKnownChangeIds << changeId; 0166 waitForSignals(); 0167 0168 // Check that it doesn't exist anymore 0169 for (const Akonadi::Item &item : std::as_const(items)) { 0170 QVERIFY(Helper::confirmDoesntExist(item)); 0171 } 0172 0173 mPendingSignals[UndoSignal] = 1; 0174 mHistory->undo(); 0175 waitForSignals(); 0176 0177 mPendingSignals[RedoSignal] = 1; 0178 mHistory->redo(); 0179 waitForSignals(); 0180 0181 mHistory->clear(); 0182 QCOMPARE(mHistory->d->redoCount(), 0); 0183 QCOMPARE(mHistory->d->undoCount(), 0); 0184 } 0185 0186 void HistoryTest::testModification_data() 0187 { 0188 QTest::addColumn<Akonadi::Item>("item"); 0189 QTest::addColumn<QString>("oldSummary"); 0190 QTest::addColumn<QString>("newSummary"); 0191 Item item1 = createItem(mCollection); 0192 const QString oldSummary(QStringLiteral("old")); 0193 const QString newSummary(QStringLiteral("new")); 0194 item1.payload<KCalendarCore::Incidence::Ptr>()->setSummary(oldSummary); 0195 QTest::newRow("item1") << item1 << oldSummary << newSummary; 0196 } 0197 0198 void HistoryTest::testModification() 0199 { 0200 QFETCH(Akonadi::Item, item); 0201 QFETCH(QString, oldSummary); 0202 QFETCH(QString, newSummary); 0203 QVERIFY(item.hasPayload()); 0204 Incidence::Ptr originalPayload = Incidence::Ptr(item.payload<KCalendarCore::Incidence::Ptr>()->clone()); 0205 0206 item.payload<KCalendarCore::Incidence::Ptr>()->setSummary(newSummary); 0207 mPendingSignals[ModificationSignal] = 1; 0208 QCOMPARE(mHistory->d->redoCount(), 0); 0209 QCOMPARE(mHistory->d->undoCount(), 0); 0210 0211 const int changeId = mChanger->modifyIncidence(item, originalPayload); 0212 QVERIFY(changeId > 0); 0213 mKnownChangeIds << changeId; 0214 waitForSignals(); 0215 0216 QVERIFY(checkSummary(item, newSummary)); 0217 QCOMPARE(mHistory->d->redoCount(), 0); 0218 QCOMPARE(mHistory->d->undoCount(), 1); 0219 0220 mPendingSignals[UndoSignal] = 1; 0221 mHistory->undo(); 0222 waitForSignals(); 0223 QVERIFY(checkSummary(item, oldSummary)); 0224 QCOMPARE(mHistory->d->redoCount(), 1); 0225 QCOMPARE(mHistory->d->undoCount(), 0); 0226 0227 mPendingSignals[RedoSignal] = 1; 0228 mHistory->redo(); 0229 waitForSignals(); 0230 QVERIFY(checkSummary(item, newSummary)); 0231 QCOMPARE(mHistory->d->redoCount(), 0); 0232 QCOMPARE(mHistory->d->undoCount(), 1); 0233 0234 mHistory->clear(); 0235 QCOMPARE(mHistory->d->redoCount(), 0); 0236 QCOMPARE(mHistory->d->undoCount(), 0); 0237 0238 // Test that it isn't recorded to history when history is disabled 0239 mChanger->setHistoryEnabled(false); 0240 mPendingSignals[ModificationSignal] = 1; 0241 const int changeId2 = mChanger->modifyIncidence(item, originalPayload); 0242 mChanger->setHistoryEnabled(true); 0243 QVERIFY(changeId > 0); 0244 mKnownChangeIds << changeId2; 0245 waitForSignals(); 0246 QCOMPARE(mHistory->d->redoCount(), 0); 0247 QCOMPARE(mHistory->d->undoCount(), 0); 0248 } 0249 0250 void HistoryTest::testAtomicOperations_data() 0251 { 0252 QTest::addColumn<Akonadi::Item::List>("items"); 0253 QTest::addColumn<QList<Akonadi::IncidenceChanger::ChangeType>>("changeTypes"); 0254 0255 Akonadi::Item::List items; 0256 QList<Akonadi::IncidenceChanger::ChangeType> changeTypes; 0257 //------------------------------------------------------------------------------------------ 0258 // Create two incidences, should succeed 0259 items << item() << item(); 0260 changeTypes << IncidenceChanger::ChangeTypeCreate << IncidenceChanger::ChangeTypeCreate; 0261 0262 QTest::newRow("create two - success ") << items << changeTypes; 0263 //------------------------------------------------------------------------------------------ 0264 changeTypes.clear(); 0265 changeTypes << IncidenceChanger::ChangeTypeModify << IncidenceChanger::ChangeTypeModify; 0266 items.clear(); 0267 items << createItem(mCollection) << createItem(mCollection); 0268 0269 QTest::newRow("modify two - success ") << items << changeTypes; 0270 //------------------------------------------------------------------------------------------ 0271 changeTypes.clear(); 0272 changeTypes << IncidenceChanger::ChangeTypeDelete << IncidenceChanger::ChangeTypeDelete; 0273 QTest::newRow("delete two - success ") << items << changeTypes; 0274 } 0275 0276 void HistoryTest::testAtomicOperations() 0277 { 0278 mHistory->clear(); 0279 QFETCH(Akonadi::Item::List, items); 0280 QFETCH(QList<Akonadi::IncidenceChanger::ChangeType>, changeTypes); 0281 mChanger->setDefaultCollection(mCollection); 0282 mChanger->setRespectsCollectionRights(false); 0283 mChanger->setDestinationPolicy(IncidenceChanger::DestinationPolicyNeverAsk); 0284 mChanger->startAtomicOperation(); 0285 0286 for (int i = 0; i < items.count(); ++i) { 0287 const Akonadi::Item item = items[i]; 0288 int changeId = -1; 0289 switch (changeTypes[i]) { 0290 case IncidenceChanger::ChangeTypeCreate: 0291 changeId = mChanger->createIncidence(item.hasPayload() ? item.payload<KCalendarCore::Incidence::Ptr>() : Incidence::Ptr()); 0292 QVERIFY(changeId != -1); 0293 mKnownChangeIds << changeId; 0294 ++mPendingSignals[CreationSignal]; 0295 break; 0296 case IncidenceChanger::ChangeTypeDelete: 0297 changeId = mChanger->deleteIncidence(item); 0298 QVERIFY(changeId != -1); 0299 mKnownChangeIds << changeId; 0300 ++mPendingSignals[DeletionSignal]; 0301 break; 0302 case IncidenceChanger::ChangeTypeModify: { 0303 QVERIFY(item.isValid()); 0304 QVERIFY(item.hasPayload<KCalendarCore::Incidence::Ptr>()); 0305 Incidence::Ptr originalPayload = Incidence::Ptr(item.payload<KCalendarCore::Incidence::Ptr>()->clone()); 0306 item.payload<KCalendarCore::Incidence::Ptr>()->setSummary(QStringLiteral("Changed")); 0307 changeId = mChanger->modifyIncidence(item, originalPayload); 0308 QVERIFY(changeId != -1); 0309 mKnownChangeIds << changeId; 0310 ++mPendingSignals[ModificationSignal]; 0311 break; 0312 } 0313 default: 0314 QVERIFY(false); 0315 } 0316 } 0317 0318 mChanger->endAtomicOperation(); 0319 waitForSignals(); 0320 0321 QCOMPARE(mHistory->d->undoCount(), 1); 0322 QCOMPARE(mHistory->d->redoCount(), 0); 0323 0324 mPendingSignals[UndoSignal] = 1; 0325 mHistory->undo(); 0326 waitForSignals(); 0327 QCOMPARE(mHistory->d->undoCount(), 0); 0328 QCOMPARE(mHistory->d->redoCount(), 1); 0329 0330 // Verify that it got undone 0331 for (int i = 0; i < items.count(); ++i) { 0332 const Akonadi::Item item = items[i]; 0333 switch (changeTypes[i]) { 0334 case IncidenceChanger::ChangeTypeCreate: 0335 // It changed id, have no way to verify 0336 break; 0337 case IncidenceChanger::ChangeTypeDelete: 0338 QVERIFY(Helper::confirmDoesntExist(item)); 0339 break; 0340 case IncidenceChanger::ChangeTypeModify: 0341 QVERIFY(checkSummary(item, QStringLiteral("random summary"))); 0342 break; 0343 default: 0344 QVERIFY(false); 0345 } 0346 } 0347 0348 mPendingSignals[RedoSignal] = 1; 0349 mHistory->redo(); 0350 waitForSignals(); 0351 QCOMPARE(mHistory->d->undoCount(), 1); 0352 QCOMPARE(mHistory->d->redoCount(), 0); 0353 0354 mPendingSignals[UndoSignal] = 1; 0355 mHistory->undo(); 0356 waitForSignals(); 0357 QCOMPARE(mHistory->d->undoCount(), 0); 0358 QCOMPARE(mHistory->d->redoCount(), 1); 0359 0360 mHistory->clear(); 0361 QCOMPARE(mHistory->d->redoCount(), 0); 0362 QCOMPARE(mHistory->d->undoCount(), 0); 0363 } 0364 0365 // Tests a sequence of various create/delete/modify operations 0366 void HistoryTest::testMix_data() 0367 { 0368 QTest::addColumn<Akonadi::Item::List>("items"); 0369 QTest::addColumn<QList<Akonadi::IncidenceChanger::ChangeType>>("changeTypes"); 0370 0371 Akonadi::Item::List items; 0372 QList<Akonadi::IncidenceChanger::ChangeType> changeTypes; 0373 //------------------------------------------------------------------------------------------ 0374 // Create two incidences 0375 items.clear(); 0376 items << item() << item(); 0377 changeTypes.clear(); 0378 changeTypes << IncidenceChanger::ChangeTypeCreate << IncidenceChanger::ChangeTypeCreate; 0379 QTest::newRow("create two - success ") << items << changeTypes; 0380 //------------------------------------------------------------------------------------------ 0381 // Create one, then delete it 0382 Akonadi::Item i = item(); 0383 items.clear(); 0384 items << i << i; 0385 changeTypes.clear(); 0386 changeTypes << IncidenceChanger::ChangeTypeCreate << IncidenceChanger::ChangeTypeDelete; 0387 QTest::newRow("create then delete") << items << changeTypes; 0388 //------------------------------------------------------------------------------------------ 0389 // Create one, then modify it, then delete it 0390 i = item(); 0391 items.clear(); 0392 items << i << i << i; 0393 changeTypes.clear(); 0394 changeTypes << IncidenceChanger::ChangeTypeCreate << IncidenceChanger::ChangeTypeModify << IncidenceChanger::ChangeTypeDelete; 0395 QTest::newRow("create then modify then delete") << items << changeTypes; 0396 } 0397 0398 void HistoryTest::testMix() 0399 { 0400 QFETCH(Akonadi::Item::List, items); 0401 QFETCH(QList<Akonadi::IncidenceChanger::ChangeType>, changeTypes); 0402 int lastCreateChangeId = -1; 0403 mHistory->clear(); 0404 mChanger->setDefaultCollection(mCollection); 0405 mChanger->setRespectsCollectionRights(false); 0406 mChanger->setDestinationPolicy(IncidenceChanger::DestinationPolicyNeverAsk); 0407 0408 for (int i = 0; i < items.count(); ++i) { 0409 Akonadi::Item item = items[i]; 0410 int changeId = -1; 0411 switch (changeTypes[i]) { 0412 case IncidenceChanger::ChangeTypeCreate: 0413 lastCreateChangeId = mChanger->createIncidence(item.payload<KCalendarCore::Incidence::Ptr>()); 0414 QVERIFY(lastCreateChangeId != -1); 0415 mKnownChangeIds << lastCreateChangeId; 0416 ++mPendingSignals[CreationSignal]; 0417 waitForSignals(); 0418 break; 0419 case IncidenceChanger::ChangeTypeDelete: 0420 item = item.isValid() ? item : mItemByChangeId.value(lastCreateChangeId); 0421 QVERIFY(item.isValid()); 0422 changeId = mChanger->deleteIncidence(item); 0423 QVERIFY(changeId != -1); 0424 mKnownChangeIds << changeId; 0425 ++mPendingSignals[DeletionSignal]; 0426 waitForSignals(); 0427 break; 0428 case IncidenceChanger::ChangeTypeModify: { 0429 item = item.isValid() ? item : mItemByChangeId.value(lastCreateChangeId); 0430 QVERIFY(item.isValid()); 0431 QVERIFY(item.hasPayload<KCalendarCore::Incidence::Ptr>()); 0432 Incidence::Ptr originalPayload = Incidence::Ptr(item.payload<KCalendarCore::Incidence::Ptr>()->clone()); 0433 item.payload<KCalendarCore::Incidence::Ptr>()->setSummary(QStringLiteral("Changed")); 0434 QVERIFY(originalPayload); 0435 changeId = mChanger->modifyIncidence(item, originalPayload); 0436 QVERIFY(changeId != -1); 0437 mKnownChangeIds << changeId; 0438 ++mPendingSignals[ModificationSignal]; 0439 waitForSignals(); 0440 break; 0441 } 0442 default: 0443 QVERIFY(false); 0444 } 0445 } 0446 0447 QCOMPARE(mHistory->d->undoCount(), changeTypes.count()); 0448 0449 // All operations are done, now undo them: 0450 for (int i = 0; i < changeTypes.count(); i++) { 0451 QCOMPARE(mHistory->d->undoCount(), changeTypes.count() - i); 0452 QCOMPARE(mHistory->d->redoCount(), i); 0453 mPendingSignals[UndoSignal] = 1; 0454 mHistory->undo(); 0455 waitForSignals(); 0456 } 0457 0458 QCOMPARE(mHistory->d->undoCount(), 0); 0459 QCOMPARE(mHistory->d->redoCount(), changeTypes.count()); 0460 0461 // Now redo them 0462 for (int i = 0; i < changeTypes.count(); i++) { 0463 QCOMPARE(mHistory->d->undoCount(), i); 0464 QCOMPARE(mHistory->d->redoCount(), changeTypes.count() - i); 0465 mPendingSignals[RedoSignal] = 1; 0466 mHistory->redo(); 0467 waitForSignals(); 0468 } 0469 0470 QCOMPARE(mHistory->d->undoCount(), changeTypes.count()); 0471 QCOMPARE(mHistory->d->redoCount(), 0); 0472 } 0473 0474 void HistoryTest::waitForSignals() 0475 { 0476 bool somethingToWaitFor = false; 0477 for (int i = 0; i < NumSignals; ++i) { 0478 if (mPendingSignals.value(static_cast<SignalType>(i))) { 0479 somethingToWaitFor = true; 0480 break; 0481 } 0482 } 0483 0484 if (!somethingToWaitFor) { 0485 return; 0486 } 0487 0488 QTestEventLoop::instance().enterLoop(10); 0489 0490 if (QTestEventLoop::instance().timeout()) { 0491 for (int i = 0; i < NumSignals; ++i) { 0492 qDebug() << mPendingSignals.value(static_cast<SignalType>(i)); 0493 } 0494 } 0495 0496 QVERIFY(!QTestEventLoop::instance().timeout()); 0497 } 0498 0499 void HistoryTest::deleteFinished(int changeId, 0500 const QList<Akonadi::Item::Id> &deletedIds, 0501 Akonadi::IncidenceChanger::ResultCode resultCode, 0502 const QString &errorMessage) 0503 { 0504 QVERIFY(changeId != -1); 0505 0506 if (!mKnownChangeIds.contains(changeId)) { 0507 return; 0508 } 0509 0510 QVERIFY(mPendingSignals[DeletionSignal] > 0); 0511 --mPendingSignals[DeletionSignal]; 0512 0513 if (resultCode != IncidenceChanger::ResultCodeSuccess) { 0514 qDebug() << "Error string is " << errorMessage; 0515 } else { 0516 QVERIFY(!deletedIds.isEmpty()); 0517 for (Akonadi::Item::Id id : std::as_const(deletedIds)) { 0518 QVERIFY(id != -1); 0519 } 0520 } 0521 maybeQuitEventLoop(); 0522 } 0523 0524 void HistoryTest::createFinished(int changeId, const Akonadi::Item &item, Akonadi::IncidenceChanger::ResultCode resultCode, const QString &errorString) 0525 { 0526 QVERIFY(changeId != -1); 0527 0528 if (!mKnownChangeIds.contains(changeId)) { 0529 return; 0530 } 0531 0532 QVERIFY(mPendingSignals[CreationSignal] > 0); 0533 0534 --mPendingSignals[CreationSignal]; 0535 0536 if (resultCode == IncidenceChanger::ResultCodeSuccess) { 0537 QVERIFY(item.isValid()); 0538 QVERIFY(item.parentCollection().isValid()); 0539 mItemByChangeId.insert(changeId, item); 0540 QVERIFY(item.hasPayload()); 0541 auto incidence = item.payload<KCalendarCore::Incidence::Ptr>(); 0542 // mItemIdByUid.insert(incidence->uid(), item.id()); 0543 } else { 0544 qDebug() << "Error string is " << errorString; 0545 } 0546 0547 maybeQuitEventLoop(); 0548 } 0549 0550 void HistoryTest::modifyFinished(int changeId, const Akonadi::Item &item, Akonadi::IncidenceChanger::ResultCode resultCode, const QString &errorString) 0551 { 0552 if (!mKnownChangeIds.contains(changeId)) { 0553 return; 0554 } 0555 0556 QVERIFY(mPendingSignals[ModificationSignal] > 0); 0557 --mPendingSignals[ModificationSignal]; 0558 0559 QVERIFY(changeId != -1); 0560 QCOMPARE(resultCode, IncidenceChanger::ResultCodeSuccess); 0561 0562 if (resultCode == IncidenceChanger::ResultCodeSuccess) { 0563 QVERIFY(item.isValid()); 0564 } else { 0565 qDebug() << "Error string is " << errorString; 0566 } 0567 0568 maybeQuitEventLoop(); 0569 } 0570 0571 void HistoryTest::handleRedone(Akonadi::History::ResultCode result) 0572 { 0573 QCOMPARE(result, History::ResultCodeSuccess); 0574 --mPendingSignals[RedoSignal]; 0575 maybeQuitEventLoop(); 0576 } 0577 0578 void HistoryTest::handleUndone(Akonadi::History::ResultCode result) 0579 { 0580 QCOMPARE(result, History::ResultCodeSuccess); 0581 --mPendingSignals[UndoSignal]; 0582 maybeQuitEventLoop(); 0583 } 0584 0585 void HistoryTest::maybeQuitEventLoop() 0586 { 0587 for (int i = 0; i < NumSignals; ++i) { 0588 if (mPendingSignals.value(static_cast<SignalType>(i)) > 0) { 0589 return; 0590 } 0591 } 0592 QTestEventLoop::instance().exitLoop(); 0593 } 0594 0595 QTEST_AKONADIMAIN(HistoryTest) 0596 0597 #include "moc_historytest.cpp"