diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index f1f8097..a5c95ef 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -232,7 +232,10 @@ jobs: paket: macos-apple-silicon - arch: x86_64 paket: macos-intel - runs-on: macos-14 + # macos-14 statt 15 lief bis zum 05.11.2026; ab dem 06.11. brach GitHub + # jeden Lauf darauf nach null Sekunden ab, ohne einen Schritt. Longpath + # fordert macos-15 an und lief am selben Tag durch. + runs-on: macos-15 steps: - uses: actions/checkout@v4 with: diff --git a/src/app/AppController.cpp b/src/app/AppController.cpp index 3565e59..5d40ea5 100644 --- a/src/app/AppController.cpp +++ b/src/app/AppController.cpp @@ -218,7 +218,7 @@ void AppController::superviseRigctld(bool mayStart) // failed dial brings a fresh one. stopRigctld(); } - if (!mayStart) { + if (!mayStart || !m_rigctldSelbstStarten) { return; } // A rigctld that just died (a serial port that is not there, a @@ -280,6 +280,18 @@ void AppController::superviseRotctld(int slot, bool mayStart) AppController::~AppController() { + vorDemBeenden(); +} + +void AppController::vorDemBeenden() +{ + // Zuerst die Leitungen kappen. Wer gleich rotctld und rigctld beendet, + // verliert die Verbindung zu ihnen, und die Aufsicht wuerde sie + // sofort neu starten -- im Destruktor auf schon abgebauten Mitgliedern + // (SIGSEGV in RigctldProcess::start, gemessen 2026-11-07). + disconnect(&m_rigctldClient, nullptr, this, nullptr); + disconnect(&m_rotor1, nullptr, this, nullptr); + disconnect(&m_rotor2, nullptr, this, nullptr); if (m_logBackup && m_database.isOpen()) { m_logBackup->backupNow(false); } diff --git a/src/app/AppController.h b/src/app/AppController.h index 7adb078..a352140 100644 --- a/src/app/AppController.h +++ b/src/app/AppController.h @@ -71,11 +71,28 @@ class AppController : public QObject { // timer never sees the QSOs of the final minutes otherwise. ~AppController() override; + // Was beim Beenden geschehen muss: die letzte Sicherung und das Ende + // der eigenen rotctld/rigctld. Aufruf aus MainWindow::closeEvent() + // UND aus dem Destruktor, mehrfach ohne Schaden. + // + // Der Destruktor allein reicht nicht. Gemessen am 2026-11-07 (Qt 6.11, + // macOS): Cmd+Q und QCoreApplication::quit() enden über + // [NSApp terminate:] in exit(), noch innerhalb von closeEvent(). Die + // Objekte auf dem Stapel von main() werden dabei nie zerstört. Nur + // der rote Punkt erreicht den Destruktor. closeEvent() läuft auf + // allen drei Wegen. + void vorDemBeenden(); + // Opens `path`, loads settings + available ContestDefinitions, and // applies them to the network clients/GeoFilter. Returns false and // fills `errorOut` (if given) on failure. bool openDatabase(const QString& path, QString* errorOut = nullptr); + /// In Longpath eingebettet ist Longpath der CAT-Server und haelt den + /// Anschluss. Ein eigener rigctld wuerde ihm beides wegnehmen, sobald + /// der erste Anruf noch vor dessen Server kommt. Vor openDatabase(). + void setRigctldSelbstStarten(bool darf) { m_rigctldSelbstStarten = darf; } + ContestDatabase& database() { return m_database; } // Periodic copies of the database (data/LogBackup.h); created in // openDatabase() beside the database file, null before that. @@ -297,6 +314,7 @@ class AppController : public QObject { RigctldLaunch m_rigctldLaunch; // what m_rigctld runs with; empty when not ours/not running QDateTime m_rigctldFailedAt; // last failure, for the restart cool-down bool m_rigctldStopping = false; // true while our own stopRigctld() is ending it + bool m_rigctldSelbstStarten = true; TransverterSetup m_transverter; CallsignLocatorLookup m_callsignLocatorLookup; // holds ContestDatabase& -- declared after m_database TerrainDataManager m_terrainDataManager; // declared before m_geoFilter -- setTerrainDataManager() takes its address diff --git a/src/core/RigctldClient.cpp b/src/core/RigctldClient.cpp index 3984f93..56dd7c1 100644 --- a/src/core/RigctldClient.cpp +++ b/src/core/RigctldClient.cpp @@ -10,6 +10,9 @@ // Longpath/NereusSDR's RotctldClient.cpp. AI-assisted // via Anthropic Claude Code, operator Ralph Martin // Fischer. +// 2026-11-11 — setTarget(): ein neues Ziel gilt sofort (auflegen, +// neu waehlen). Ralph Martin Fischer, KI-gestuetzt +// ueber Anthropic Claude. // ================================================================= #include "RigctldClient.h" @@ -109,8 +112,32 @@ RigctldClient::RigctldClient(QObject* parent) : QObject(parent) void RigctldClient::setTarget(const QString& host, quint16 port) { - m_host = host.trimmed(); + const QString neu = host.trimmed(); + if (neu == m_host && port == m_port) { return; } + m_host = neu; m_port = port; + + // Ein neues Ziel gilt sofort (2026-11-11). Bis dahin merkte sich + // setTarget() nur Host und Port: ein Anruf, der schon unterwegs war, + // ging beim ALTEN Ziel zu Ende, und ein verbundener Klient blieb dort + // bis zum naechsten Abriss. AppController::openDatabase() waehlt mit + // den Vorgaben (127.0.0.1:4532), bevor die eigenen Einstellungen + // greifen -- auf Martins Rechner lauscht dort Longpaths CAT-Server, + // und ein Pruefstand schickte ihm seine Befehle. Also: auflegen und + // beim neuen Ziel neu waehlen. Ohne Ziel bleibt es aufgelegt. + if (m_socket.state() == QAbstractSocket::UnconnectedState) { return; } + m_poll->stop(); + m_deadline->stop(); + m_queue.clear(); + m_buffer.clear(); + m_awaiting = Pending::None; + m_socket.abort(); + if (m_host.isEmpty()) { + m_retry->stop(); + setState(State::Disconnected); + return; + } + connectToRig(); } void RigctldClient::setPollIntervalMs(int ms) diff --git a/src/core/RotctldClient.cpp b/src/core/RotctldClient.cpp index 4d3b0cf..aa7ae55 100644 --- a/src/core/RotctldClient.cpp +++ b/src/core/RotctldClient.cpp @@ -10,6 +10,9 @@ // Longpath/NereusSDR's RotctldClient.cpp. AI-assisted // via Anthropic Claude Code, operator Ralph Martin // Fischer. +// 2026-11-11 — setTarget(): ein neues Ziel gilt sofort (auflegen, +// neu waehlen). Ralph Martin Fischer, KI-gestuetzt +// ueber Anthropic Claude. // ================================================================= #include "RotctldClient.h" @@ -114,8 +117,32 @@ RotctldClient::RotctldClient(QObject* parent) : QObject(parent) void RotctldClient::setTarget(const QString& host, quint16 port) { - m_host = host.trimmed(); + const QString neu = host.trimmed(); + if (neu == m_host && port == m_port) { return; } + m_host = neu; m_port = port; + + // Ein neues Ziel gilt sofort (2026-11-11). Bis dahin merkte sich + // setTarget() nur Host und Port: ein Anruf, der schon unterwegs war, + // ging beim ALTEN Ziel zu Ende, und ein verbundener Klient blieb dort + // bis zum naechsten Abriss. AppController::openDatabase() waehlt mit + // den Vorgaben (127.0.0.1:4532), bevor die eigenen Einstellungen + // greifen -- auf Martins Rechner lauscht dort Longpaths CAT-Server, + // und ein Pruefstand schickte ihm seine Befehle. Also: auflegen und + // beim neuen Ziel neu waehlen. Ohne Ziel bleibt es aufgelegt. + if (m_socket.state() == QAbstractSocket::UnconnectedState) { return; } + m_poll->stop(); + m_deadline->stop(); + m_queue.clear(); + m_buffer.clear(); + m_awaiting = Pending::None; + m_socket.abort(); + if (m_host.isEmpty()) { + m_retry->stop(); + setState(State::Disconnected); + return; + } + connectToRotor(); } void RotctldClient::setPollIntervalMs(int ms) diff --git a/src/ui/MainWindow.cpp b/src/ui/MainWindow.cpp index b7181bd..bbd7ec2 100644 --- a/src/ui/MainWindow.cpp +++ b/src/ui/MainWindow.cpp @@ -2262,6 +2262,9 @@ void MainWindow::aktualisiereMitschnittAnzeige() void MainWindow::closeEvent(QCloseEvent* event) { saveWindowGeometry(); + // Hier und nicht erst im Destruktor: bei Cmd+Q läuft keiner mehr, + // siehe AppController::vorDemBeenden(). + m_appController.vorDemBeenden(); QMainWindow::closeEvent(event); } @@ -6252,6 +6255,20 @@ void MainWindow::openReadinessWindow() m_readinessWindow->activateWindow(); } +QWidget* MainWindow::zeigeStartcheck(bool alsWerkzeugfenster) +{ + openReadinessWindow(); + if (alsWerkzeugfenster && m_readinessWindow + && m_readinessWindow->windowType() != Qt::Tool) { + m_readinessWindow->setWindowFlags( + (m_readinessWindow->windowFlags() & ~Qt::WindowType_Mask) | Qt::Tool); + m_readinessWindow->setAttribute(Qt::WA_MacAlwaysShowToolWindow); + m_readinessWindow->show(); + m_readinessWindow->raise(); + } + return m_readinessWindow; +} + void MainWindow::openShortcutsWindow() { if (!m_shortcutsWindow) { diff --git a/src/ui/MainWindow.h b/src/ui/MainWindow.h index a6334cb..603241e 100644 --- a/src/ui/MainWindow.h +++ b/src/ui/MainWindow.h @@ -82,6 +82,11 @@ class MainWindow : public QMainWindow { explicit MainWindow(AppController& appController, QWidget* parent = nullptr); ~MainWindow() override; + // Der Startcheck fuer einen Wirt ohne dieses Menue (Longpath bettet das + // Logbuch ein und zeigt nur seine Panels). Als Werkzeugfenster steht er + // auf derselben Ebene wie die schwebenden Panels und nicht darunter. + QWidget* zeigeStartcheck(bool alsWerkzeugfenster); + // The restore itself, without the dialogs (public for the tests): // safety backup, close, replace the file, restartRequested(). // False = nothing replaced (the safety backup failed) or the copy diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index f1d251e..7cc743f 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -127,6 +127,7 @@ contestprogramm_add_test(test_rotctldprocess) contestprogramm_add_test(test_client_reconnect) contestprogramm_add_test(test_rotctld_supervision) contestprogramm_add_test(test_rigctld_supervision) +contestprogramm_add_test(test_cmdq_ohne_destruktor) contestprogramm_add_test(test_netz_unter_stoerung) contestprogramm_add_test(test_readiness_check) contestprogramm_add_test(test_clock_check) diff --git a/tests/test_client_reconnect.cpp b/tests/test_client_reconnect.cpp index 13011a8..bfc0f66 100644 --- a/tests/test_client_reconnect.cpp +++ b/tests/test_client_reconnect.cpp @@ -59,8 +59,10 @@ class FakeDaemon : public QObject { connect(&m_server, &QTcpServer::newConnection, this, [this] { QTcpSocket* socket = m_server.nextPendingConnection(); - connect(socket, &QTcpSocket::readyRead, socket, [socket] { + ++m_anrufe; + connect(socket, &QTcpSocket::readyRead, socket, [this, socket] { const QByteArray request = socket->readAll(); + m_empfangen += request; if (request.startsWith("p")) { socket->write("123.0\n0.0\n"); } else if (request.startsWith("f")) { @@ -77,8 +79,14 @@ class FakeDaemon : public QObject return m_server.listen(QHostAddress::LocalHost, port); } + // Wie oft angerufen wurde und was ankam -- fuer die Zielwechsel-Faelle. + int anrufe() const { return m_anrufe; } + QByteArray empfangen() const { return m_empfangen; } + private: QTcpServer m_server; + int m_anrufe = 0; + QByteArray m_empfangen; }; } // namespace @@ -92,8 +100,105 @@ private slots: void rigClientFindsARigctldThatAppearsLater(); void on4kstClientDialsAgainAfterARefusedConnect(); void clusterClientDialsAgainAfterARefusedConnect(); + void rigClientDialsTheNewTargetNotTheOld(); + void rigClientLeavesAConnectedOldTarget(); + void rotorClientDialsTheNewTargetNotTheOld(); }; +// ── Zielwechsel (2026-11-11) ──────────────────────────────────────── +// +// AppController::openDatabase() waehlt mit den Vorgaben 127.0.0.1:4532, +// bevor setSettings() das eigentliche Ziel setzt -- ohne dass dazwischen +// ein Ereignis verarbeitet wird. setTarget() merkte sich das neue Ziel +// nur; der Anruf beim alten ging zu Ende, und dort bekam ein fremder +// Dienst die Abfragen und Befehle (auf Martins Rechner: Longpaths +// CAT-Server, gemessen mit test_seitenband_folgt_dem_band). Genau diese +// Reihenfolge hier: waehlen, Ziel wechseln, waehlen -- dann erst die +// Ereignisschleife. Das alte Ziel darf kein einziges Byte bekommen. +void TestClientReconnect::rigClientDialsTheNewTargetNotTheOld() +{ + FakeDaemon alt; + FakeDaemon neu; + const quint16 altPort = freePort(); + QVERIFY(alt.listen(altPort)); + const quint16 neuPort = freePort(); + QVERIFY(neu.listen(neuPort)); + + RigctldClient client; + client.setTarget(QStringLiteral("127.0.0.1"), altPort); + client.connectToRig(); + client.setTarget(QStringLiteral("127.0.0.1"), neuPort); + client.connectToRig(); // wie AppController::applyNetworkSettings + + QTRY_VERIFY_WITH_TIMEOUT(client.isConnected(), 10000); + QTRY_VERIFY_WITH_TIMEOUT(neu.empfangen().contains("f\n"), 10000); + QTest::qWait(300); + QCOMPARE(client.port(), neuPort); + QVERIFY2(alt.empfangen().isEmpty(), + qPrintable(QStringLiteral("das alte Ziel bekam: %1") + .arg(QString::fromLatin1(alt.empfangen())))); +} + +// Verbunden, und dann ein anderer Port in den Einstellungen: der Klient +// geht hinueber, sofort -- nicht erst, wenn das alte Geraet abreisst. +void TestClientReconnect::rigClientLeavesAConnectedOldTarget() +{ + FakeDaemon alt; + FakeDaemon neu; + const quint16 altPort = freePort(); + QVERIFY(alt.listen(altPort)); + const quint16 neuPort = freePort(); + QVERIFY(neu.listen(neuPort)); + + RigctldClient client; + client.setTarget(QStringLiteral("127.0.0.1"), altPort); + client.connectToRig(); + QTRY_VERIFY_WITH_TIMEOUT(client.isConnected(), 10000); + QTRY_VERIFY_WITH_TIMEOUT(alt.empfangen().contains("f\n"), 10000); + + client.setTarget(QStringLiteral("127.0.0.1"), neuPort); + client.connectToRig(); + // Unter der Wiederwahl-Frist (3 s): kein Abriss, auf den es wartet. + QTRY_VERIFY_WITH_TIMEOUT(neu.anrufe() == 1, 2500); + QTRY_VERIFY_WITH_TIMEOUT(client.isConnected(), 10000); + + // Dasselbe Ziel noch einmal: kein Auflegen, kein neuer Anruf. + client.setTarget(QStringLiteral("127.0.0.1"), neuPort); + QTest::qWait(300); + QVERIFY(client.isConnected()); + QCOMPARE(neu.anrufe(), 1); + + // Kein Ziel mehr: aufgelegt, und es wird auch nicht neu gewaehlt. + client.setTarget(QString(), 0); + QCOMPARE(client.state(), RigctldClient::State::Disconnected); + QTest::qWait(3500); + QCOMPARE(client.state(), RigctldClient::State::Disconnected); + QCOMPARE(neu.anrufe(), 1); +} + +void TestClientReconnect::rotorClientDialsTheNewTargetNotTheOld() +{ + FakeDaemon alt; + FakeDaemon neu; + const quint16 altPort = freePort(); + QVERIFY(alt.listen(altPort)); + const quint16 neuPort = freePort(); + QVERIFY(neu.listen(neuPort)); + + RotctldClient client; + client.setTarget(QStringLiteral("127.0.0.1"), altPort); + client.connectToRotor(); + client.setTarget(QStringLiteral("127.0.0.1"), neuPort); + client.connectToRotor(); + + QTRY_VERIFY_WITH_TIMEOUT(client.isConnected(), 10000); + QTRY_VERIFY_WITH_TIMEOUT(neu.empfangen().contains("p\n"), 10000); + QTest::qWait(300); + QVERIFY2(alt.empfangen().isEmpty(), + qPrintable(QStringLiteral("das alte Ziel bekam: %1") + .arg(QString::fromLatin1(alt.empfangen())))); +} + void TestClientReconnect::rotorClientFindsARotctldThatAppearsLater() { const quint16 port = freePort(); diff --git a/tests/test_cmdq_ohne_destruktor.cpp b/tests/test_cmdq_ohne_destruktor.cpp new file mode 100644 index 0000000..2ecffc4 --- /dev/null +++ b/tests/test_cmdq_ohne_destruktor.cpp @@ -0,0 +1,205 @@ +// SPDX-License-Identifier: GPL-3.0-or-later +// ================================================================= +// tests/test_cmdq_ohne_destruktor.cpp (Contestprogramm) +// ================================================================= +// +// Die letzte Sicherung und das Ende von rigctld standen im Destruktor +// von AppController. Bei Cmd+Q läuft der nicht. +// +// Gemessen am 2026-11-07 mit einer kleinen Qt-6.11-Sonde unter macOS: +// +// Weg closeEvent exec() zurück Destruktor atexit +// Cmd+Q ja nein nein ja +// quit() ja nein nein ja +// roter Punkt ja ja ja ja +// +// Das exit() kommt noch innerhalb von closeEvent(). Hier wird darum nur +// das Fenster geschlossen und AppController bewusst NICHT zerstört -- +// genau so viel, wie der Betrieb bei Cmd+Q erlebt. +// +// Modification history (Contestprogramm): +// 2026-11-07 — Original von Martin Fischer (OE5SOS), KI-gestützt +// über Anthropic Claude. +// ================================================================= + +#include + +#include +#include +#include +#include +#include + +#include "app/AppController.h" +#include "app/ContestSettings.h" +#include "data/LogBackup.h" +#include "data/QsoRecord.h" +#include "ui/MainWindow.h" + +#include + +using namespace Contestprogramm; + +namespace { + +QsoRecord einQso(const QString& rufzeichen) +{ + QsoRecord r; + r.callsign = rufzeichen; + r.band = QStringLiteral("144"); + r.mode = QStringLiteral("SSB"); + r.timestampUtc = QStringLiteral("2026-11-07T08:00:00Z"); + r.contestId = QStringLiteral("IARU_R1_VHF_UHF"); + return r; +} + +quint16 freierPort() +{ + QTcpServer probe; + probe.listen(QHostAddress::LocalHost, 0); + const quint16 port = probe.serverPort(); + probe.close(); + return port; +} + +std::unique_ptr baueSteuerung(QTemporaryDir& dir) +{ + auto c = std::make_unique(); + if (!c->openDatabase(dir.filePath(QStringLiteral("cmdq.sqlite")))) { return nullptr; } + ContestSettings s = c->settings(); + s.ownCallsign = QStringLiteral("OE5SOS"); + s.ownGrid = QStringLiteral("JN67UT"); + s.rigctldHost.clear(); + s.rotor1Enabled = false; + s.rotor2Enabled = false; + c->setSettings(s); + return c; +} + +} // namespace + +class TestCmdQOhneDestruktor : public QObject +{ + Q_OBJECT + +private slots: + void dasSchliessenSchreibtDieLetzteSicherung(); + void dasSchliessenBeendetRigctld(); + void zweimalSchliessenSchadetNicht(); + void derAbbauStartetKeinRigctldNeu(); +}; + +// ── Die QSOs der letzten Minute ───────────────────────────────────── +void TestCmdQOhneDestruktor::dasSchliessenSchreibtDieLetzteSicherung() +{ + QTemporaryDir dir; + QVERIFY(dir.isValid()); + auto c = baueSteuerung(dir); + QVERIFY(c); + MainWindow fenster(*c); + + QVERIFY(c->logBackup()); + const QString ordner = c->logBackup()->directory(); + const int vorher = LogBackup::listBackups(ordner).size(); + + QsoRecord qso = einQso(QStringLiteral("DL1ABC")); + QVERIFY(c->database().insertQso(qso)); + + fenster.close(); + + QVERIFY2(LogBackup::listBackups(ordner).size() > vorher, + "nach dem Schliessen fehlt die letzte Sicherung -- bei Cmd+Q " + "wuerde der Destruktor sie nicht mehr schreiben"); +} + +// ── rigctld hält sonst den Anschluss des Funkgeräts ───────────────── +void TestCmdQOhneDestruktor::dasSchliessenBeendetRigctld() +{ +#ifdef Q_OS_WIN + QSKIP("Der Stellvertreter-rigctld ist ein Shell-Skript; unter Windows startet QProcess es nicht."); +#else + QTemporaryDir dir; + QVERIFY(dir.isValid()); + + QFile skript(dir.filePath(QStringLiteral("rigctld"))); + QVERIFY(skript.open(QIODevice::WriteOnly | QIODevice::Text)); + skript.write("#!/bin/sh\nexec sleep 60\n"); + skript.close(); + QVERIFY(skript.setPermissions(QFile::ReadOwner | QFile::WriteOwner | QFile::ExeOwner)); + const QByteArray altePfade = qgetenv("PATH"); + qputenv("PATH", (dir.path() + QLatin1Char(':') + QString::fromLocal8Bit(altePfade)).toLocal8Bit()); + + auto c = baueSteuerung(dir); + QVERIFY(c); + MainWindow fenster(*c); + + ContestSettings s = c->settings(); + s.rigctldHost = QStringLiteral("127.0.0.1"); + s.rigctldPort = freierPort(); + s.rigctldHamlibModel = 2031; + s.rigctldDevice = QStringLiteral("/dev/cu.fake"); + s.rigctldBaud = 115200; + c->setSettings(s); + + // Voraussetzung: ohne laufenden Daemon sagte die Prüfung nichts. + QTRY_VERIFY_WITH_TIMEOUT(c->rigctldRunning(), 8000); + + fenster.close(); + + QVERIFY2(!c->rigctldRunning(), + "rigctld laeuft nach dem Schliessen weiter -- bei Cmd+Q bliebe " + "er als Waise zurueck und hielte den seriellen Anschluss"); + + qputenv("PATH", altePfade); +#endif +} + +// ── Schliessen, dann der Destruktor auf dem roten Punkt ───────────── +void TestCmdQOhneDestruktor::zweimalSchliessenSchadetNicht() +{ + QTemporaryDir dir; + QVERIFY(dir.isValid()); + auto c = baueSteuerung(dir); + QVERIFY(c); + + QsoRecord qso = einQso(QStringLiteral("DL2ABC")); + QVERIFY(c->database().insertQso(qso)); + + c->vorDemBeenden(); + const QString ordner = c->logBackup()->directory(); + const int nachDemErsten = LogBackup::listBackups(ordner).size(); + QVERIFY(nachDemErsten > 0); + + c->vorDemBeenden(); + QCOMPARE(LogBackup::listBackups(ordner).size(), nachDemErsten); +} + +// Beim Abbau meldete sich die CAT-Verbindung ab, und die Aufsicht startete +// rigctld auf einem schon zerstoerten Mitglied: SIGSEGV in +// RigctldProcess::start, gemessen 2026-11-07 in Longpath. +void TestCmdQOhneDestruktor::derAbbauStartetKeinRigctldNeu() +{ +#ifdef Q_OS_WIN + QSKIP("Der Windows-Laeufer verbindet hier nicht; der Weg ist derselbe."); +#endif + QTemporaryDir dir; + QVERIFY(dir.isValid()); + QTcpServer geraet; + QVERIFY(geraet.listen(QHostAddress::LocalHost, 0)); + + auto c = baueSteuerung(dir); + QVERIFY(c); + ContestSettings s = c->settings(); + s.rigctldHost = QStringLiteral("127.0.0.1"); + s.rigctldPort = geraet.serverPort(); + s.rigctldHamlibModel = 2031; + s.rigctldDevice = QStringLiteral("/dev/cu.fake"); + s.rigctldBaud = 115200; + c->setSettings(s); + + QTRY_VERIFY_WITH_TIMEOUT(c->rigctldClient().isConnected(), 5000); + c.reset(); // darf nicht abstuerzen +} + +QTEST_MAIN(TestCmdQOhneDestruktor) +#include "test_cmdq_ohne_destruktor.moc" diff --git a/tests/test_rigctld_supervision.cpp b/tests/test_rigctld_supervision.cpp index 7f01ece..8914b71 100644 --- a/tests/test_rigctld_supervision.cpp +++ b/tests/test_rigctld_supervision.cpp @@ -69,11 +69,44 @@ private slots: void launchOnlyForALoopbackHostWithADevice(); void argumentsAreTheDocumentedRigctldForm(); void startsAfterTheClientFailsAndFollowsTheSettings(); + void inLongpathStartetEsKeinenEigenen(); void theModelListComesFromTheInstalledHamlib(); void theWholeChainWorksWithARealHamlib(); void thePickerOffersEveryRadioHamlibKnows(); }; +// Eingebettet in Longpath: der abgewiesene Anruf darf nichts starten, sonst +// nimmt ein eigener rigctld Longpath den Anschluss weg. +void TestRigctldSupervision::inLongpathStartetEsKeinenEigenen() +{ +#ifdef Q_OS_WIN + QSKIP("Der Stellvertreter-rigctld ist ein Shell-Skript; unter Windows startet QProcess es nicht."); +#endif + QTemporaryDir dir; + QVERIFY(dir.isValid()); + const QString argsFile = dir.filePath(QStringLiteral("rigctld.args")); + QVERIFY(installFakeRigctld(QDir(dir.path()), argsFile)); + + AppController controller; + controller.setRigctldSelbstStarten(false); + QVERIFY(controller.openDatabase(dir.filePath(QStringLiteral("eingebettet.sqlite")))); + ContestSettings settings = controller.settings(); + settings.ownCallsign = QStringLiteral("OE5SOS"); + settings.ownGrid = QStringLiteral("JN67UT"); + settings.rotor1Enabled = false; + settings.rotor2Enabled = false; + settings.rigctldHost = QStringLiteral("127.0.0.1"); + settings.rigctldPort = freePort(); + settings.rigctldHamlibModel = 2037; + settings.rigctldDevice = QStringLiteral("/dev/cu.fake-A"); + settings.rigctldBaud = 115200; + controller.setSettings(settings); + + QTest::qWait(2500); + QVERIFY(!controller.rigctldRunning()); + QVERIFY(readArgs(argsFile).isEmpty()); +} + void TestRigctldSupervision::launchOnlyForALoopbackHostWithADevice() { ContestSettings settings;