mudlet/test/functional_tests/TelnetServerStub.cpp
Vadim Peretokin cb402cc3e6
infrastructure: use std::chrono literals for time durations (#9493)
#### Brief overview of PR changes/additions

Convert raw millisecond integer literals at time-duration call sites to
`std::chrono` literals, and add `#include <chrono>` to each touched
translation unit. Examples:

- `QTimer::singleShot(0, ...)` → `QTimer::singleShot(0ms, ...)`
- `mpTimerReplay->setInterval(1000)` → `setInterval(1s)`
- `mPendingTimer.start(60000)` → `start(1min)`
- `QObject::startTimer(50)` → `startTimer(50ms)`
- `QTest::qWait(100)` → `QTest::qWait(100ms)`
- `QThread::msleep(10)` → `QThread::sleep(10ms)`

This is a semantics-preserving refactor - every duration is kept exactly
equal to before (e.g. `1000` ms becomes `1s`, `60000` ms becomes
`1min`). No behavioural change.

#### Motivation for adding to Mudlet

Chrono literals make time durations self-documenting and type-safe. `1s`
/ `100ms` read unambiguously where a bare `1000` / `100` forces the
reader to remember each API's unit, and the compiler now rejects unit
mismatches. Only genuine duration arguments were converted - loop
counts, scroll-line counts, sizes, ports and the like were deliberately
left as plain integers.

All targeted APIs provide `std::chrono` overloads in the minimum
supported Qt (6.8.2): `QTimer::singleShot`/`start`/`setInterval` (5.8),
`QObject::startTimer` (5.9), `QThread::sleep(std::chrono::nanoseconds)`
(6.6) and `QTest::qWait(std::chrono::milliseconds)` (6.7).

#### Other info (issues closed, discussion etc)

Test case: the full application builds cleanly and the entire functional
`ctest` suite passes. The only failing test is the known, pre-existing
`PasswordMigrationTest` LSan exit-leak (GTK3/fontconfig noise), which is
unrelated to this change.

Assisted-by: Claude:claude-opus-4-8
2026-07-25 20:24:31 +02:00

94 lines
3.5 KiB
C++

/***************************************************************************
* Copyright (C) 2025 by Nicolas Keita - nicolaskeita2@@gmail.com *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include <QPointer>
#include <QTcpSocket>
#include <QTimer>
#include <QHostAddress>
#include <QDebug>
#include "TelnetServerStub.h"
#include "utils.h"
#include <chrono>
using namespace std::chrono_literals;
TelnetServerStub::TelnetServerStub(QObject* parent)
: QTcpServer(parent)
{
connect(this, &QTcpServer::newConnection, this, &TelnetServerStub::onNewConnection);
}
void TelnetServerStub::start(const QString& host, quint16 port)
{
Q_UNUSED(host)
const QHostAddress addr = QHostAddress::LocalHost;
if (listen(addr, port)) {
qInfo().noquote() << qsl("✅ TelnetServerStub listening on %1:%2").arg(addr.toString()).arg(serverPort());
} else {
qCritical().noquote() << qsl("❌ Failed to start TelnetServerStub: %1").arg(errorString());
}
}
void TelnetServerStub::sendRaw(const QByteArray& data)
{
if (!mpClient) {
qWarning() << "⚠️ sendRaw called without a connected client.";
return;
}
mpClient->write(data);
mpClient->flush();
}
void TelnetServerStub::onNewConnection()
{
QTcpSocket* client = nextPendingConnection();
if (!client) {
qWarning() << "⚠️ onNewConnection called but no pending connection.";
return;
}
mpClient = client;
qInfo().noquote() << qsl("🔌 Client connected: %1").arg(client->peerAddress().toString());
QPointer<QTcpSocket> safeClient = client;
QTimer::singleShot(100ms, [safeClient, welcomeMessage = mpWelcomeMessage]()
{
if (!safeClient) {
return;
}
const auto bytesWritten = safeClient->write(welcomeMessage.toUtf8() + "\r\n");
safeClient->flush();
if (bytesWritten <= 0) {
qWarning().noquote() << qsl("⚠️ Failed to send welcome message to %1")
.arg(safeClient->peerAddress().toString());
}
});
connect(client, &QTcpSocket::disconnected, [safeClient]()
{
if (!safeClient) {
return;
}
qInfo().noquote() << qsl("Client disconnected: %1").arg(safeClient->peerAddress().toString());
safeClient->deleteLater();
});
}