File indexing completed on 2024-04-21 03:53:39

 /*
     This file is part of the KDE project
     SPDX-FileCopyrightText: 2006 Kevin Ottens <ervin@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-only
 */
 
 #include "kjobtest.h"
 
 #include <QList>
 #include <QMetaEnum>
 #include <QSignalSpy>
 #include <QTest>
 #include <QTimer>
 
 #include <string>
 
 QTEST_MAIN(KJobTest)
 
 KJobTest::KJobTest()
     : loop(this)
 {
 }
 
 void KJobTest::testEmitResult_data()
 {
     QTest::addColumn<int>("errorCode");
     QTest::addColumn<QString>("errorText");
 
     QTest::newRow("no error") << int(KJob::NoError) << QString();
     QTest::newRow("error no text") << 2 << QString();
     QTest::newRow("error with text") << 6 << "oops! an error? naaah, really?";
 }
 
 void KJobTest::testEmitResult()
 {
     TestJob *job = new TestJob;
 
     connect(job, &KJob::result, this, [this](KJob *job) {
         slotResult(job);
         loop.quit();
     });
 
     QFETCH(int, errorCode);
     QFETCH(QString, errorText);
 
     job->setError(errorCode);
     job->setErrorText(errorText);
 
     QSignalSpy destroyed_spy(job, &QObject::destroyed);
     job->start();
     QVERIFY(!job->isFinished());
     loop.exec();
     QVERIFY(job->isFinished());
 
     QCOMPARE(m_lastError, errorCode);
     QCOMPARE(m_lastErrorText, errorText);
 
     // Verify that the job is not deleted immediately...
     QCOMPARE(destroyed_spy.size(), 0);
     QTimer::singleShot(0, &loop, &QEventLoop::quit);
     // ... but when we enter the event loop again.
     loop.exec();
     QCOMPARE(destroyed_spy.size(), 1);
 }
 
 void KJobTest::testProgressTracking()
 {
     TestJob *testJob = new TestJob;
     KJob *job = testJob;
 
     qRegisterMetaType<KJob *>("KJob*");
     qRegisterMetaType<qulonglong>("qulonglong");
 
     QSignalSpy processedChanged_spy(job, &KJob::processedAmountChanged);
     QSignalSpy totalChanged_spy(job, &KJob::totalAmountChanged);
     QSignalSpy percentChanged_spy(job, &KJob::percentChanged);
 
     /* Process a first item. Corresponding signal should be emitted.
      * Total size didn't change.
      * Since the total size is unknown, no percent signal is emitted.
      */
     testJob->setProcessedSize(1);
 
     QCOMPARE(processedChanged_spy.size(), 1);
     QCOMPARE(processedChanged_spy.at(0).at(0).value<KJob *>(), static_cast<KJob *>(job));
     QCOMPARE(processedChanged_spy.at(0).at(2).value<qulonglong>(), qulonglong(1));
     QCOMPARE(totalChanged_spy.size(), 0);
     QCOMPARE(percentChanged_spy.size(), 0);
 
     /* Now, we know the total size. It's signaled.
      * The new percentage is signaled too.
      */
     testJob->setTotalSize(10);
 
     QCOMPARE(processedChanged_spy.size(), 1);
     QCOMPARE(totalChanged_spy.size(), 1);
     QCOMPARE(totalChanged_spy.at(0).at(0).value<KJob *>(), job);
     QCOMPARE(totalChanged_spy.at(0).at(2).value<qulonglong>(), qulonglong(10));
     QCOMPARE(percentChanged_spy.size(), 1);
     QCOMPARE(percentChanged_spy.at(0).at(0).value<KJob *>(), job);
     QCOMPARE(percentChanged_spy.at(0).at(1).value<unsigned long>(), static_cast<unsigned long>(10));
 
     /* We announce a new percentage by hand.
      * Total, and processed didn't change, so no signal is emitted for them.
      */
     testJob->setPercent(15);
 
     QCOMPARE(processedChanged_spy.size(), 1);
     QCOMPARE(totalChanged_spy.size(), 1);
     QCOMPARE(percentChanged_spy.size(), 2);
     QCOMPARE(percentChanged_spy.at(1).at(0).value<KJob *>(), job);
     QCOMPARE(percentChanged_spy.at(1).at(1).value<unsigned long>(), static_cast<unsigned long>(15));
 
     /* We make some progress.
      * Processed size and percent are signaled.
      */
     testJob->setProcessedSize(3);
 
     QCOMPARE(processedChanged_spy.size(), 2);
     QCOMPARE(processedChanged_spy.at(1).at(0).value<KJob *>(), job);
     QCOMPARE(processedChanged_spy.at(1).at(2).value<qulonglong>(), qulonglong(3));
     QCOMPARE(totalChanged_spy.size(), 1);
     QCOMPARE(percentChanged_spy.size(), 3);
     QCOMPARE(percentChanged_spy.at(2).at(0).value<KJob *>(), job);
     QCOMPARE(percentChanged_spy.at(2).at(1).value<unsigned long>(), static_cast<unsigned long>(30));
 
     /* We set a new total size, but equals to the previous one.
      * No signal is emitted.
      */
     testJob->setTotalSize(10);
     QCOMPARE(processedChanged_spy.size(), 2);
     QCOMPARE(totalChanged_spy.size(), 1);
     QCOMPARE(percentChanged_spy.size(), 3);
 
     /* We 'lost' the previous work done.
      * Signals both percentage and new processed size.
      */
     testJob->setProcessedSize(0);
 
     QCOMPARE(processedChanged_spy.size(), 3);
     QCOMPARE(processedChanged_spy.at(2).at(0).value<KJob *>(), job);
     QCOMPARE(processedChanged_spy.at(2).at(2).value<qulonglong>(), qulonglong(0));
     QCOMPARE(totalChanged_spy.size(), 1);
     QCOMPARE(percentChanged_spy.size(), 4);
     QCOMPARE(percentChanged_spy.at(3).at(0).value<KJob *>(), job);
     QCOMPARE(percentChanged_spy.at(3).at(1).value<unsigned long>(), static_cast<unsigned long>(0));
 
     /* We process more than the total size!?
      * Signals both percentage and new processed size.
      * Percentage is 150%
      *
      * Might sounds weird, but verify that this case is handled gracefully.
      */
     testJob->setProcessedSize(15);
 
     QCOMPARE(processedChanged_spy.size(), 4);
     QCOMPARE(processedChanged_spy.at(3).at(0).value<KJob *>(), job);
     QCOMPARE(processedChanged_spy.at(3).at(2).value<qulonglong>(), qulonglong(15));
     QCOMPARE(totalChanged_spy.size(), 1);
     QCOMPARE(percentChanged_spy.size(), 5);
     QCOMPARE(percentChanged_spy.at(4).at(0).value<KJob *>(), job);
     QCOMPARE(percentChanged_spy.at(4).at(1).value<unsigned long>(), static_cast<unsigned long>(150));
 
     processedChanged_spy.clear();
     totalChanged_spy.clear();
     percentChanged_spy.clear();
 
     /**
      * Try again with Files as the progress unit
      */
     testJob->setProgressUnit(KJob::Files);
     testJob->setProcessedSize(16);
     QCOMPARE(percentChanged_spy.size(), 0);
 
     testJob->setTotalFiles(5);
     QCOMPARE(percentChanged_spy.size(), 1);
     QCOMPARE(percentChanged_spy.at(0).at(1).value<unsigned long>(), static_cast<unsigned long>(0));
 
     testJob->setProcessedFiles(2);
     QCOMPARE(percentChanged_spy.size(), 2);
     QCOMPARE(percentChanged_spy.at(1).at(1).value<unsigned long>(), static_cast<unsigned long>(40));
 
     delete job;
 }
 
 void KJobTest::testExec_data()
 {
     QTest::addColumn<int>("errorCode");
     QTest::addColumn<QString>("errorText");
 
     QTest::newRow("no error") << int(KJob::NoError) << QString();
     QTest::newRow("error no text") << 2 << QString();
     QTest::newRow("error with text") << 6 << "oops! an error? naaah, really?";
 }
 
 void KJobTest::testExec()
 {
     TestJob *job = new TestJob;
 
     QFETCH(int, errorCode);
     QFETCH(QString, errorText);
 
     job->setError(errorCode);
     job->setErrorText(errorText);
 
     int resultEmitted = 0;
     // Prove to Kai Uwe that one can connect a job to a lambdas, despite the "private" signal
     connect(job, &KJob::result, this, [&resultEmitted](KJob *) {
         ++resultEmitted;
     });
 
     QSignalSpy destroyed_spy(job, &QObject::destroyed);
 
     QVERIFY(!job->isFinished());
     bool status = job->exec();
     QVERIFY(job->isFinished());
 
     QCOMPARE(resultEmitted, 1);
     QCOMPARE(status, (errorCode == KJob::NoError));
     QCOMPARE(job->error(), errorCode);
     QCOMPARE(job->errorText(), errorText);
 
     // Verify that the job is not deleted immediately...
     QCOMPARE(destroyed_spy.size(), 0);
     QTimer::singleShot(0, &loop, &QEventLoop::quit);
     // ... but when we enter the event loop again.
     loop.exec();
     QCOMPARE(destroyed_spy.size(), 1);
 }
 
 void KJobTest::testKill_data()
 {
     QTest::addColumn<int>("killVerbosity");
     QTest::addColumn<int>("errorCode");
     QTest::addColumn<QString>("errorText");
     QTest::addColumn<int>("resultEmitCount");
     QTest::addColumn<int>("finishedEmitCount");
 
     QTest::newRow("killed with result") << int(KJob::EmitResult) << int(KJob::KilledJobError) << QString() << 1 << 1;
     QTest::newRow("killed quietly") << int(KJob::Quietly) << int(KJob::KilledJobError) << QString() << 0 << 1;
 }
 
 void KJobTest::testKill()
 {
     auto *const job = setupErrorResultFinished();
     QSignalSpy destroyed_spy(job, &QObject::destroyed);
 
     QFETCH(int, killVerbosity);
     QFETCH(int, errorCode);
     QFETCH(QString, errorText);
     QFETCH(int, resultEmitCount);
     QFETCH(int, finishedEmitCount);
 
     QVERIFY(!job->isFinished());
     job->kill(static_cast<KJob::KillVerbosity>(killVerbosity));
     QVERIFY(job->isFinished());
     loop.processEvents(QEventLoop::AllEvents, 2000);
 
     QCOMPARE(m_lastError, errorCode);
     QCOMPARE(m_lastErrorText, errorText);
 
     QCOMPARE(job->error(), errorCode);
     QCOMPARE(job->errorText(), errorText);
 
     QCOMPARE(m_resultCount, resultEmitCount);
     QCOMPARE(m_finishedCount, finishedEmitCount);
 
     // Verify that the job is not deleted immediately...
     QCOMPARE(destroyed_spy.size(), 0);
     QTimer::singleShot(0, &loop, &QEventLoop::quit);
     // ... but when we enter the event loop again.
     loop.exec();
     QCOMPARE(destroyed_spy.size(), 1);
 
     QVERIFY(m_jobFinishCount.size() == (finishedEmitCount - resultEmitCount));
     m_jobFinishCount.clear();
 }
 
 void KJobTest::testDestroy()
 {
     auto *const job = setupErrorResultFinished();
     QVERIFY(!job->isFinished());
     delete job;
     QCOMPARE(m_lastError, static_cast<int>(KJob::NoError));
     QCOMPARE(m_lastErrorText, QString{});
     QCOMPARE(m_resultCount, 0);
     QCOMPARE(m_finishedCount, 1);
 
     QVERIFY(m_jobFinishCount.size() == 1);
     m_jobFinishCount.clear();
 }
 
 void KJobTest::testEmitAtMostOnce_data()
 {
     QTest::addColumn<bool>("autoDelete");
     QTest::addColumn<QList<Action>>("actions");
 
     const auto actionName = [](Action action) {
         return QMetaEnum::fromType<Action>().valueToKey(static_cast<int>(action));
     };
 
     for (bool autoDelete : {true, false}) {
         for (Action a : {Action::Start, Action::KillQuietly, Action::KillVerbosely}) {
             for (Action b : {Action::Start, Action::KillQuietly, Action::KillVerbosely}) {
                 const auto dataTag = std::string{actionName(a)} + '-' + actionName(b) + (autoDelete ? "-autoDelete" : "");
                 QTest::newRow(dataTag.c_str()) << autoDelete << QList<Action>{a, b};
             }
         }
     }
 }
 
 void KJobTest::testEmitAtMostOnce()
 {
     auto *const job = setupErrorResultFinished();
     QSignalSpy destroyed_spy(job, &QObject::destroyed);
 
     QFETCH(bool, autoDelete);
     job->setAutoDelete(autoDelete);
 
     QFETCH(QList<Action>, actions);
     for (auto action : actions) {
         switch (action) {
         case Action::Start:
             job->start(); // in effect calls QTimer::singleShot(0, ... emitResult)
             break;
         case Action::KillQuietly:
             QTimer::singleShot(0, job, [=] {
                 job->kill(KJob::Quietly);
             });
             break;
         case Action::KillVerbosely:
             QTimer::singleShot(0, job, [=] {
                 job->kill(KJob::EmitResult);
             });
             break;
         }
     }
 
     QVERIFY(!job->isFinished());
     loop.processEvents(QEventLoop::AllEvents, 2000);
     QCOMPARE(destroyed_spy.size(), autoDelete);
     if (!autoDelete) {
         QVERIFY(job->isFinished());
     }
 
     QVERIFY(!actions.empty());
     // The first action alone should determine the job's error and result.
     const auto firstAction = actions.front();
 
     const int errorCode = firstAction == Action::Start ? KJob::NoError : KJob::KilledJobError;
     QCOMPARE(m_lastError, errorCode);
     QCOMPARE(m_lastErrorText, QString{});
     if (!autoDelete) {
         QCOMPARE(job->error(), m_lastError);
         QCOMPARE(job->errorText(), m_lastErrorText);
     }
 
     QCOMPARE(m_resultCount, firstAction == Action::KillQuietly ? 0 : 1);
     QCOMPARE(m_finishedCount, 1);
 
     if (!autoDelete) {
         delete job;
     }
 }
 
 void KJobTest::testDelegateUsage()
 {
     TestJob *job1 = new TestJob;
     TestJob *job2 = new TestJob;
     TestJobUiDelegate *delegate = new TestJobUiDelegate;
     QPointer<TestJobUiDelegate> guard(delegate);
 
     QVERIFY(job1->uiDelegate() == nullptr);
     job1->setUiDelegate(delegate);
     QVERIFY(job1->uiDelegate() == delegate);
 
     QVERIFY(job2->uiDelegate() == nullptr);
     job2->setUiDelegate(delegate);
     QVERIFY(job2->uiDelegate() == nullptr);
 
     delete job1;
     delete job2;
     QVERIFY(guard.isNull()); // deleted by job1
 }
 
 void KJobTest::testNestedExec()
 {
     m_innerJob = nullptr;
     QTimer::singleShot(100, this, &KJobTest::slotStartInnerJob);
     m_outerJob = new WaitJob();
     m_outerJob->exec();
 }
 
 void KJobTest::slotStartInnerJob()
 {
     QTimer::singleShot(100, this, &KJobTest::slotFinishOuterJob);
     m_innerJob = new WaitJob();
     m_innerJob->exec();
 }
 
 void KJobTest::slotFinishOuterJob()
 {
     QTimer::singleShot(100, this, &KJobTest::slotFinishInnerJob);
     m_outerJob->makeItFinish();
 }
 
 void KJobTest::slotFinishInnerJob()
 {
     m_innerJob->makeItFinish();
 }
 
 void KJobTest::slotResult(KJob *job)
 {
     const auto testJob = qobject_cast<const TestJob *>(job);
     QVERIFY(testJob);
     QVERIFY(testJob->isFinished());
 
     // Ensure the job has already emitted finished() if we are tracking from
     // setupErrorResultFinished
     if (m_jobFinishCount.contains(job)) {
         QVERIFY(m_jobFinishCount.value(job) == 1);
         QVERIFY(m_jobFinishCount.remove(job) == 1 /* num items removed */);
     }
 
     if (job->error()) {
         m_lastError = job->error();
         m_lastErrorText = job->errorText();
     } else {
         m_lastError = KJob::NoError;
         m_lastErrorText.clear();
     }
 
     m_resultCount++;
 }
 
 void KJobTest::slotFinished(KJob *job)
 {
     QVERIFY2(m_jobFinishCount.value(job) == 0, "Ensure we have not double-emitted KJob::finished()");
     m_jobFinishCount[job]++;
 
     if (job->error()) {
         m_lastError = job->error();
         m_lastErrorText = job->errorText();
     } else {
         m_lastError = KJob::NoError;
         m_lastErrorText.clear();
     }
 
     m_finishedCount++;
 }
 
 TestJob *KJobTest::setupErrorResultFinished()
 {
     m_lastError = KJob::UserDefinedError;
     m_lastErrorText.clear();
     m_resultCount = 0;
     m_finishedCount = 0;
 
     auto *job = new TestJob;
     m_jobFinishCount[job] = 0;
     connect(job, &KJob::result, this, &KJobTest::slotResult);
     connect(job, &KJob::finished, this, &KJobTest::slotFinished);
     return job;
 }
 
 TestJob::TestJob()
     : KJob()
 {
 }
 
 TestJob::~TestJob()
 {
 }
 
 void TestJob::start()
 {
     QTimer::singleShot(0, this, [this] {
         emitResult();
     });
 }
 
 bool TestJob::doKill()
 {
     return true;
 }
 
 void TestJob::setError(int errorCode)
 {
     KJob::setError(errorCode);
 }
 
 void TestJob::setErrorText(const QString &errorText)
 {
     KJob::setErrorText(errorText);
 }
 
 void TestJob::setProcessedSize(qulonglong size)
 {
     KJob::setProcessedAmount(KJob::Bytes, size);
 }
 
 void TestJob::setTotalSize(qulonglong size)
 {
     KJob::setTotalAmount(KJob::Bytes, size);
 }
 
 void TestJob::setProcessedFiles(qulonglong files)
 {
     KJob::setProcessedAmount(KJob::Files, files);
 }
 
 void TestJob::setTotalFiles(qulonglong files)
 {
     KJob::setTotalAmount(KJob::Files, files);
 }
 
 void TestJob::setPercent(unsigned long percentage)
 {
     KJob::setPercent(percentage);
 }
 
 void WaitJob::start()
 {
 }
 
 void WaitJob::makeItFinish()
 {
     emitResult();
 }
 
 void TestJobUiDelegate::connectJob(KJob *job)
 {
     QVERIFY(job->uiDelegate() != nullptr);
 }
 
 #include "moc_kjobtest.cpp"