File indexing completed on 2024-04-28 15:20:30

 /*
    This file is part of libkdbus
 
     SPDX-FileCopyrightText: 2019 Harald Sitter <sitter@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include <QDBusConnection>
 #include <QDBusConnectionInterface>
 #include <QDBusServiceWatcher>
 #include <QDebug>
 #include <QProcess>
 #include <QTest>
 
 #include <signal.h>
 #include <unistd.h>
 
 static const QString s_serviceName = QStringLiteral("org.kde.kdbussimpleservice");
 
 class TestObject : public QObject
 {
     Q_OBJECT
 
     QList<int> m_danglingPids;
 private Q_SLOTS:
     void cleanupTestCase()
     {
         // Make sure we don't leave dangling processes even when we had an
         // error and the process is stopped.
         for (int pid : m_danglingPids) {
             kill(pid, SIGKILL);
         }
     }
 
     void testDeadService()
     {
         QVERIFY(!QDBusConnection::sessionBus().interface()->isServiceRegistered(s_serviceName).value());
 
         QProcess proc1;
         proc1.setProgram(QFINDTESTDATA("kdbussimpleservice"));
         proc1.setProcessChannelMode(QProcess::ForwardedChannels);
         proc1.start();
         QVERIFY(proc1.waitForStarted());
         m_danglingPids << proc1.processId();
 
         // Spy isn't very suitable here because we'd be racing with proc1 or
         // signal blocking since we'd need to unblock before spying but then
         // there is an ɛ between unblock and spy.
         qint64 pid1 = proc1.processId(); // store local, in case the proc disappears
         QVERIFY(pid1 >= 0);
         bool proc1Registered = QTest::qWaitFor(
             [&]() {
                 QTest::qSleep(1000);
                 return QDBusConnection::sessionBus().interface()->servicePid(s_serviceName).value() == pid1;
             },
             8000);
         QVERIFY(proc1Registered);
 
         // suspend proc1, we don't want it responding on dbus anymore, but still
         // be running so it holds the name.
         QCOMPARE(kill(proc1.processId(), SIGSTOP), 0);
 
         // start second instance
         QProcess proc2;
         proc2.setProgram(QFINDTESTDATA("kdbussimpleservice"));
         QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
         env.insert("KCRASH_AUTO_RESTARTED", "1");
         proc2.setProcessEnvironment(env);
         proc2.setProcessChannelMode(QProcess::ForwardedChannels);
         proc2.start();
         QVERIFY(proc2.waitForStarted());
         m_danglingPids << proc2.processId();
 
         // sleep a bit. fairly awkward. we need proc2 to be waiting on the name
         // but we can't easily determine when it started waiting. in lieu of
         // better instrumentation let's just sleep a bit.
         qDebug() << "sleeping";
         QTest::qSleep(4000);
 
         // Let proc1 go up in flames so that dbus-daemon reclaims the name and
         // gives it to proc2.
         qDebug() << "murder on the orient express";
         QCOMPARE(0, kill(proc1.processId(), SIGUSR1));
         QCOMPARE(0, kill(proc1.processId(), SIGCONT));
 
         qint64 pid2 = proc2.processId(); // store local, in case the proc disappears
         QVERIFY(pid2 >= 0);
         // Wait for service to be owned by proc2.
         bool proc2Registered = QTest::qWaitFor(
             [&]() {
                 QTest::qSleep(1000);
                 return QDBusConnection::sessionBus().interface()->servicePid(s_serviceName).value() == pid2;
             },
             8000);
         QVERIFY(proc2Registered);
 
         proc1.kill();
         m_danglingPids.removeAll(pid1);
         proc2.kill();
         m_danglingPids.removeAll(pid2);
     }
 };
 
 QTEST_MAIN(TestObject)
 
 #include "deadservicetest.moc"