jyapayne/warp-pipe
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
warp-pipe/tests/gui/warppipe_gui_tests.cpp
Joey Yakimowich-Payne 69d9a9e3f1 More tests
2026-02-06 11:07:01 -07:00

2756 lines
86 KiB
C++
Raw Blame History

#include <warppipe/warppipe.hpp>
#include "../../gui/AudioLevelMeter.h"
#include "../../gui/GraphEditorWidget.h"
#include "../../gui/PresetManager.h"
#include "../../gui/SquareConnectionPainter.h"
#include "../../gui/VolumeWidgets.h"
#include "../../gui/WarpGraphModel.h"
#include "../../gui/ZoomGraphicsView.h"
#include <QtNodes/internal/BasicGraphicsScene.hpp>
#include <QtNodes/internal/ConnectionGraphicsObject.hpp>
#include <QtNodes/internal/NodeGraphicsObject.hpp>
#include <QtNodes/StyleCollection>
#include <QAction>
#include <QApplication>
#include <QClipboard>
#include <QComboBox>
#include <QDir>
#include <QDialog>
#include <QDialogButtonBox>
#include <QFile>
#include <QGraphicsView>
#include <QImage>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QLabel>
#include <QLineEdit>
#include <QMenu>
#include <QMouseEvent>
#include <QMimeData>
#include <QPainter>
#include <QPointingDevice>
#include <QPushButton>
#include <QWidget>
#include <QStandardPaths>
#include <QTabWidget>
#include <QTimer>
#include <QToolButton>
#include <QUndoStack>
#include <QWheelEvent>
#include <catch2/catch_test_macros.hpp>
#include <catch2/catch_approx.hpp>
#include <cmath>
namespace {
warppipe::ConnectionOptions TestOptions() {
warppipe::ConnectionOptions opts;
opts.threading = warppipe::ThreadingMode::kThreadLoop;
opts.autoconnect = true;
opts.application_name = "warppipe-gui-tests";
return opts;
}
struct TestClient {
std::unique_ptr<warppipe::Client> client;
bool available() const { return client != nullptr; }
static TestClient Create() {
auto result = warppipe::Client::Create(TestOptions());
if (!result.ok()) return {nullptr};
return {std::move(result.value)};
}
};
warppipe::NodeInfo MakeNode(uint32_t id, const std::string &name,
const std::string &media_class,
const std::string &app_name = {},
const std::string &desc = {},
bool is_virtual = false) {
warppipe::NodeInfo n;
n.id = warppipe::NodeId{id};
n.name = name;
n.media_class = media_class;
n.application_name = app_name;
n.description = desc;
n.is_virtual = is_virtual;
return n;
}
warppipe::PortInfo MakePort(uint32_t id, uint32_t node_id,
const std::string &name, bool is_input) {
warppipe::PortInfo p;
p.id = warppipe::PortId{id};
p.node = warppipe::NodeId{node_id};
p.name = name;
p.is_input = is_input;
return p;
}
warppipe::Link MakeLink(uint32_t id, uint32_t out_port, uint32_t in_port) {
warppipe::Link l;
l.id = warppipe::LinkId{id};
l.output_port = warppipe::PortId{out_port};
l.input_port = warppipe::PortId{in_port};
return l;
}
int g_argc = 0;
char *g_argv[] = {nullptr};
struct AppGuard {
QApplication app{g_argc, g_argv};
};
AppGuard &ensureApp() {
static AppGuard guard;
return guard;
}
int countPaintedPixels(const QImage &image) {
int painted = 0;
for (int y = 0; y < image.height(); ++y) {
for (int x = 0; x < image.width(); ++x) {
if (image.pixelColor(x, y).alpha() > 0) {
++painted;
}
}
}
return painted;
}
std::unique_ptr<QtNodes::ConnectionGraphicsObject>
makeConnectionGraphic(QtNodes::BasicGraphicsScene &scene,
QtNodes::ConnectionId connectionId,
const QPointF &out,
const QPointF &in) {
auto cgo = std::make_unique<QtNodes::ConnectionGraphicsObject>(scene,
connectionId);
cgo->setEndPoint(QtNodes::PortType::Out, out);
cgo->setEndPoint(QtNodes::PortType::In, in);
return cgo;
}
int countPixelsDifferentFrom(const QImage &image, const QColor &color) {
int diff = 0;
for (int y = 0; y < image.height(); ++y) {
for (int x = 0; x < image.width(); ++x) {
if (image.pixelColor(x, y) != color) {
++diff;
}
}
}
return diff;
}
int countColorPixels(const QImage &image, const QColor &color) {
int count = 0;
for (int y = 0; y < image.height(); ++y) {
for (int x = 0; x < image.width(); ++x) {
if (image.pixelColor(x, y) == color) {
++count;
}
}
}
return count;
}
QImage renderWidgetImage(QWidget &widget, const QSize &size) {
widget.resize(size);
widget.show();
QApplication::processEvents();
QImage image(size, QImage::Format_ARGB32_Premultiplied);
image.fill(Qt::transparent);
widget.render(&image);
return image;
}
class TestZoomGraphicsView : public ZoomGraphicsView {
public:
using ZoomGraphicsView::ZoomGraphicsView;
void dispatchWheel(QWheelEvent *event) { ZoomGraphicsView::wheelEvent(event); }
void dispatchMousePress(QMouseEvent *event) {
ZoomGraphicsView::mousePressEvent(event);
}
void dispatchMouseMove(QMouseEvent *event) {
ZoomGraphicsView::mouseMoveEvent(event);
}
void dispatchMouseRelease(QMouseEvent *event) {
ZoomGraphicsView::mouseReleaseEvent(event);
}
void dispatchDrawBackground(QPainter *painter, const QRectF &r) {
ZoomGraphicsView::drawBackground(painter, r);
}
};
class ScriptedGraphEditorWidget : public GraphEditorWidget {
public:
using GraphEditorWidget::GraphEditorWidget;
void queueMenuSelection(const QString &text) { m_menuActionQueue.append(text); }
void setInputDialogResponse(const QString &text, bool accepted) {
m_hasInputResponse = true;
m_inputTextResponse = text;
m_inputAcceptedResponse = accepted;
}
void setSaveFilePathResponse(const QString &path) {
m_saveFilePathResponse = path;
}
void setOpenFilePathResponse(const QString &path) {
m_openFilePathResponse = path;
}
int warningCount() const { return static_cast<int>(m_warnings.size()); }
protected:
QAction *execMenuAction(QMenu &menu, const QPoint &) override {
if (m_menuActionQueue.isEmpty()) {
return nullptr;
}
QString wanted = m_menuActionQueue.takeFirst();
return findActionInMenu(menu, wanted);
}
QString promptTextInput(const QString &title,
const QString &label,
bool *ok) override {
if (!m_hasInputResponse) {
return GraphEditorWidget::promptTextInput(title, label, ok);
}
m_hasInputResponse = false;
if (ok) {
*ok = m_inputAcceptedResponse;
}
return m_inputTextResponse;
}
QString chooseSaveFilePath(const QString &title,
const QString &initialDir,
const QString &filter) override {
if (m_saveFilePathResponse.isNull()) {
return GraphEditorWidget::chooseSaveFilePath(title, initialDir, filter);
}
return m_saveFilePathResponse;
}
QString chooseOpenFilePath(const QString &title,
const QString &initialDir,
const QString &filter) override {
if (m_openFilePathResponse.isNull()) {
return GraphEditorWidget::chooseOpenFilePath(title, initialDir, filter);
}
return m_openFilePathResponse;
}
void showWarningDialog(const QString &title,
const QString &message) override {
m_warnings.append(title + QStringLiteral(":") + message);
}
private:
QAction *findActionInMenu(QMenu &menu, const QString &text) {
for (QAction *action : menu.actions()) {
if (!action) {
continue;
}
if (action->text() == text) {
return action;
}
if (action->menu()) {
if (QAction *nested = findActionInMenu(*action->menu(), text)) {
return nested;
}
}
}
return nullptr;
}
QStringList m_menuActionQueue;
bool m_hasInputResponse = false;
bool m_inputAcceptedResponse = false;
QString m_inputTextResponse;
QString m_saveFilePathResponse;
QString m_openFilePathResponse;
QStringList m_warnings;
};
bool triggerVisibleMenuAction(const QString &actionText) {
for (QWidget *widget : QApplication::topLevelWidgets()) {
auto *menu = qobject_cast<QMenu *>(widget);
if (!menu || !menu->isVisible()) {
continue;
}
for (QAction *action : menu->actions()) {
if (action && action->text() == actionText) {
action->trigger();
return true;
}
}
}
return false;
}
bool acceptRuleDialog(const QString &appName, const QString &targetNodeName) {
for (QWidget *widget : QApplication::topLevelWidgets()) {
auto *dialog = qobject_cast<QDialog *>(widget);
if (!dialog || !dialog->isVisible() ||
!dialog->windowTitle().contains(QStringLiteral("Routing Rule"))) {
continue;
}
auto edits = dialog->findChildren<QLineEdit *>();
if (!edits.isEmpty()) {
edits[0]->setText(appName);
}
auto combos = dialog->findChildren<QComboBox *>();
if (!combos.isEmpty()) {
int idx = combos[0]->findData(targetNodeName);
if (idx >= 0) {
combos[0]->setCurrentIndex(idx);
}
}
auto *buttons = dialog->findChild<QDialogButtonBox *>();
if (!buttons) {
return false;
}
auto *ok = buttons->button(QDialogButtonBox::Ok);
if (!ok) {
return false;
}
ok->click();
return true;
}
return false;
}
QPushButton *findRuleDeleteButtonByAppLabel(QWidget &root,
const QString &appLabelToken) {
for (auto *label : root.findChildren<QLabel *>()) {
if (!label->text().contains(appLabelToken)) {
continue;
}
QWidget *cursor = label;
while (cursor && cursor != &root) {
for (auto *button : cursor->findChildren<QPushButton *>()) {
if (button->text() == QString(QChar(0x2715))) {
return button;
}
}
cursor = cursor->parentWidget();
}
}
return nullptr;
}
ZoomGraphicsView *findZoomView(QWidget &root) {
for (auto *view : root.findChildren<QGraphicsView *>()) {
if (auto *zoom = dynamic_cast<ZoomGraphicsView *>(view)) {
return zoom;
}
}
return nullptr;
}
QAction *findActionByText(const QList<QAction *> &actions,
const QString &text) {
for (int i = actions.size() - 1; i >= 0; --i) {
QAction *action = actions[i];
if (action && action->text() == text) {
return action;
}
}
return nullptr;
}
bool hasNodeNamed(warppipe::Client *client, const std::string &name) {
if (!client) {
return false;
}
auto nodes = client->ListNodes();
if (!nodes.ok()) {
return false;
}
for (const auto &node : nodes.value) {
if (node.name == name) {
return true;
}
}
return false;
}
QPoint nodeCenterInView(WarpGraphModel &model,
ZoomGraphicsView &view,
QtNodes::NodeId nodeId) {
QPointF nodePos = model.nodeData(nodeId, QtNodes::NodeRole::Position).toPointF();
QSize nodeSize = model.nodeData(nodeId, QtNodes::NodeRole::Size).toSize();
QPointF hitScenePos = nodePos + QPointF(nodeSize.width() / 2.0,
nodeSize.height() / 2.0);
return view.mapFromScene(hitScenePos);
}
} // namespace
TEST_CASE("classifyNode identifies hardware sink") {
auto n = MakeNode(1, "alsa_output", "Audio/Sink");
REQUIRE(WarpGraphModel::classifyNode(n) == WarpNodeType::kHardwareSink);
}
TEST_CASE("classifyNode identifies hardware source") {
auto n = MakeNode(2, "alsa_input", "Audio/Source");
REQUIRE(WarpGraphModel::classifyNode(n) == WarpNodeType::kHardwareSource);
}
TEST_CASE("classifyNode identifies virtual sink") {
auto n = MakeNode(3, "gaming-sink", "Audio/Sink", {}, {}, true);
REQUIRE(WarpGraphModel::classifyNode(n) == WarpNodeType::kVirtualSink);
}
TEST_CASE("classifyNode identifies virtual source") {
auto n = MakeNode(4, "my-mic", "Audio/Source", {}, {}, true);
REQUIRE(WarpGraphModel::classifyNode(n) == WarpNodeType::kVirtualSource);
}
TEST_CASE("classifyNode identifies application stream output") {
auto n = MakeNode(5, "Firefox", "Stream/Output/Audio");
REQUIRE(WarpGraphModel::classifyNode(n) == WarpNodeType::kApplication);
}
TEST_CASE("classifyNode identifies application stream input") {
auto n = MakeNode(6, "Discord", "Stream/Input/Audio");
REQUIRE(WarpGraphModel::classifyNode(n) == WarpNodeType::kApplication);
}
TEST_CASE("classifyNode returns unknown for unrecognized media class") {
auto n = MakeNode(7, "midi-bridge", "Midi/Bridge");
REQUIRE(WarpGraphModel::classifyNode(n) == WarpNodeType::kUnknown);
}
TEST_CASE("classifyNode virtual sink without warppipe in name") {
auto n = MakeNode(10, "Sink", "Audio/Sink", {}, {}, true);
REQUIRE(WarpGraphModel::classifyNode(n) == WarpNodeType::kVirtualSink);
}
TEST_CASE("classifyNode virtual source without warppipe in name") {
auto n = MakeNode(11, "Mic", "Audio/Source", {}, {}, true);
REQUIRE(WarpGraphModel::classifyNode(n) == WarpNodeType::kVirtualSource);
}
TEST_CASE("classifyNode non-virtual sink with warppipe in name") {
auto n = MakeNode(12, "warppipe-hw", "Audio/Sink", {}, {}, false);
REQUIRE(WarpGraphModel::classifyNode(n) == WarpNodeType::kHardwareSink);
}
TEST_CASE("classifyNode virtual duplex treated as virtual sink") {
auto n = MakeNode(13, "my-duplex", "Audio/Duplex", {}, {}, true);
REQUIRE(WarpGraphModel::classifyNode(n) == WarpNodeType::kVirtualSink);
}
TEST_CASE("classifyNode duplex treated as sink") {
auto n = MakeNode(8, "alsa_duplex", "Audio/Duplex");
REQUIRE(WarpGraphModel::classifyNode(n) == WarpNodeType::kHardwareSink);
}
TEST_CASE("refreshFromClient populates nodes from client") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100001, "test-sink", "Audio/Sink")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100002, 100001, "FL", true)).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100003, 100001, "FR", true)).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto qtId = model.qtNodeIdForPw(100001);
REQUIRE(qtId != 0);
REQUIRE(model.nodeExists(qtId));
auto caption = model.nodeData(qtId, QtNodes::NodeRole::Caption).toString();
REQUIRE(caption == "test-sink");
auto inCount = model.nodeData(qtId, QtNodes::NodeRole::InPortCount).toUInt();
REQUIRE(inCount == 2);
auto outCount = model.nodeData(qtId, QtNodes::NodeRole::OutPortCount).toUInt();
REQUIRE(outCount == 0);
}
TEST_CASE("caption prefers description over name") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100010, "alsa_output.pci-0000_00_1f.3",
"Audio/Sink", "", "Speakers")).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto qtId = model.qtNodeIdForPw(100010);
auto caption = model.nodeData(qtId, QtNodes::NodeRole::Caption).toString();
REQUIRE(caption == "Speakers");
}
TEST_CASE("caption uses application_name for streams") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100020, "firefox-output", "Stream/Output/Audio", "Firefox")).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto qtId = model.qtNodeIdForPw(100020);
auto caption = model.nodeData(qtId, QtNodes::NodeRole::Caption).toString();
REQUIRE(caption == "Firefox");
}
TEST_CASE("port data returns correct captions and types") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100030, "port-test", "Audio/Sink")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100031, 100030, "playback_FL", true)).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100032, 100030, "playback_FR", true)).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100033, 100030, "monitor_FL", false)).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto qtId = model.qtNodeIdForPw(100030);
auto inCaption = model.portData(qtId, QtNodes::PortType::In, 0,
QtNodes::PortRole::Caption).toString();
REQUIRE((inCaption == "playback_FL" || inCaption == "playback_FR"));
auto outCaption = model.portData(qtId, QtNodes::PortType::Out, 0,
QtNodes::PortRole::Caption).toString();
REQUIRE(outCaption == "monitor_FL");
auto dataType = model.portData(qtId, QtNodes::PortType::In, 0,
QtNodes::PortRole::DataType).toString();
REQUIRE(dataType == "audio");
}
TEST_CASE("node style varies by type") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100040, "hw-sink", "Audio/Sink")).ok());
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100041, "my-vsink", "Audio/Sink", {}, {}, true)).ok());
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100042, "app-stream", "Stream/Output/Audio", "App")).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto hwStyle = model.nodeData(model.qtNodeIdForPw(100040),
QtNodes::NodeRole::Style);
auto vStyle = model.nodeData(model.qtNodeIdForPw(100041),
QtNodes::NodeRole::Style);
auto appStyle = model.nodeData(model.qtNodeIdForPw(100042),
QtNodes::NodeRole::Style);
REQUIRE(hwStyle.isValid());
REQUIRE(vStyle.isValid());
REQUIRE(appStyle.isValid());
REQUIRE(hwStyle != vStyle);
REQUIRE(hwStyle != appStyle);
REQUIRE(vStyle != appStyle);
}
TEST_CASE("ghost nodes tracked after disappearance") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100050, "ephemeral-app", "Stream/Output/Audio", "App")).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto qtId = model.qtNodeIdForPw(100050);
REQUIRE(qtId != 0);
REQUIRE_FALSE(model.isGhost(qtId));
REQUIRE(tc.client->Test_RemoveGlobal(100050).ok());
model.refreshFromClient();
REQUIRE(model.nodeExists(qtId));
REQUIRE(model.isGhost(qtId));
}
TEST_CASE("ghost node reappears and loses ghost status") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100060, "ephemeral-2", "Stream/Output/Audio", "App")).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto qtId = model.qtNodeIdForPw(100060);
REQUIRE(tc.client->Test_RemoveGlobal(100060).ok());
model.refreshFromClient();
REQUIRE(model.isGhost(qtId));
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100061, "ephemeral-2", "Stream/Output/Audio", "App")).ok());
model.refreshFromClient();
REQUIRE(model.nodeExists(qtId));
REQUIRE_FALSE(model.isGhost(qtId));
}
TEST_CASE("non-application nodes removed on disappearance") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100070, "hw-gone", "Audio/Sink")).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto qtId = model.qtNodeIdForPw(100070);
REQUIRE(qtId != 0);
REQUIRE(tc.client->Test_RemoveGlobal(100070).ok());
model.refreshFromClient();
REQUIRE_FALSE(model.nodeExists(qtId));
}
TEST_CASE("links from client appear as connections") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100100, "src-node", "Audio/Source")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100101, 100100, "out_FL", false)).ok());
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100102, "sink-node", "Audio/Sink")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100103, 100102, "in_FL", true)).ok());
REQUIRE(tc.client->Test_InsertLink(
MakeLink(100104, 100101, 100103)).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto srcQt = model.qtNodeIdForPw(100100);
auto sinkQt = model.qtNodeIdForPw(100102);
REQUIRE(srcQt != 0);
REQUIRE(sinkQt != 0);
auto conns = model.allConnectionIds(srcQt);
REQUIRE(conns.size() == 1);
QtNodes::ConnectionId connId = *conns.begin();
REQUIRE(connId.outNodeId == srcQt);
REQUIRE(connId.inNodeId == sinkQt);
REQUIRE(model.connectionExists(connId));
}
TEST_CASE("connectionPossible rejects invalid port indices") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100110, "conn-test", "Audio/Sink")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100111, 100110, "in_FL", true)).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto qtId = model.qtNodeIdForPw(100110);
QtNodes::ConnectionId bad{qtId, 0, qtId, 99};
REQUIRE_FALSE(model.connectionPossible(bad));
}
TEST_CASE("connectionPossible rejects nonexistent nodes") {
ensureApp();
WarpGraphModel model(nullptr);
QtNodes::ConnectionId bad{999, 0, 998, 0};
REQUIRE_FALSE(model.connectionPossible(bad));
}
TEST_CASE("deleteConnection removes from model") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100120, "del-src", "Audio/Source")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100121, 100120, "out_FL", false)).ok());
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100122, "del-sink", "Audio/Sink")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100123, 100122, "in_FL", true)).ok());
REQUIRE(tc.client->Test_InsertLink(
MakeLink(100124, 100121, 100123)).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto srcQt = model.qtNodeIdForPw(100120);
auto conns = model.allConnectionIds(srcQt);
REQUIRE(conns.size() == 1);
QtNodes::ConnectionId connId = *conns.begin();
REQUIRE(model.deleteConnection(connId));
REQUIRE_FALSE(model.connectionExists(connId));
}
TEST_CASE("node deletion with connections does not crash") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100130, "crash-src", "Audio/Source")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100131, 100130, "out_FL", false)).ok());
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100132, "crash-sink", "Audio/Sink")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100133, 100132, "in_FL", true)).ok());
REQUIRE(tc.client->Test_InsertLink(
MakeLink(100134, 100131, 100133)).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto srcQt = model.qtNodeIdForPw(100130);
REQUIRE(model.deleteNode(srcQt));
REQUIRE_FALSE(model.nodeExists(srcQt));
}
TEST_CASE("saved positions restored for new nodes") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
WarpGraphModel model(tc.client.get());
model.setPendingPosition("pending-node", QPointF(100, 200));
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100140, "pending-node", "Audio/Sink")).ok());
model.refreshFromClient();
auto qtId = model.qtNodeIdForPw(100140);
auto pos = model.nodeData(qtId, QtNodes::NodeRole::Position).toPointF();
REQUIRE(pos.x() == 100.0);
REQUIRE(pos.y() == 200.0);
}
TEST_CASE("volume meter streams are filtered") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
auto n = MakeNode(100150, "", "Stream/Output/Audio");
REQUIRE(tc.client->Test_InsertNode(n).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto qtId = model.qtNodeIdForPw(100150);
REQUIRE(qtId == 0);
}
TEST_CASE("findPwNodeIdByName returns correct id") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100200, "find-me-node", "Audio/Sink")).ok());
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100201, "other-node", "Audio/Source")).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
REQUIRE(model.findPwNodeIdByName("find-me-node") == 100200);
REQUIRE(model.findPwNodeIdByName("other-node") == 100201);
REQUIRE(model.findPwNodeIdByName("nonexistent") == 0);
}
TEST_CASE("GraphEditorWidget registers custom keyboard actions") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
GraphEditorWidget widget(tc.client.get());
QStringList actionTexts;
for (auto *action : widget.findChildren<QAction *>()) {
if (!action->text().isEmpty()) {
actionTexts.append(action->text());
}
}
REQUIRE(actionTexts.contains("Delete Selection"));
REQUIRE(actionTexts.contains("Copy Selection"));
REQUIRE(actionTexts.contains("Paste Selection"));
REQUIRE(actionTexts.contains("Duplicate Selection"));
REQUIRE(actionTexts.contains("Auto-Arrange"));
REQUIRE(actionTexts.contains("Select All"));
REQUIRE(actionTexts.contains("Deselect All"));
REQUIRE(actionTexts.contains("Zoom Fit All"));
REQUIRE(actionTexts.contains("Zoom Fit Selected"));
REQUIRE(actionTexts.contains("Refresh Graph"));
}
TEST_CASE("GraphEditorWidget copy action exports selected virtual node payload") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
const std::string virtualName = "copy-action-node-101830";
REQUIRE(tc.client->Test_InsertNode(
MakeNode(101830, virtualName, "Audio/Sink", {}, {}, true)).ok());
auto widget = std::make_unique<GraphEditorWidget>(tc.client.get());
auto *view = findZoomView(*widget);
REQUIRE(view != nullptr);
tc.client->SetChangeCallback(nullptr);
QApplication::processEvents();
auto *selectAllAction = findActionByText(view->actions(), "Select All");
REQUIRE(selectAllAction != nullptr);
selectAllAction->trigger();
QApplication::processEvents();
auto *copyAction = findActionByText(view->actions(), "Copy Selection");
REQUIRE(copyAction != nullptr);
copyAction->trigger();
const QMimeData *mime = QGuiApplication::clipboard()->mimeData();
REQUIRE(mime != nullptr);
REQUIRE(mime->hasFormat(QStringLiteral("application/warppipe-virtual-graph")));
QJsonObject root = QJsonDocument::fromJson(
mime->data(QStringLiteral("application/warppipe-virtual-graph"))).object();
QJsonArray nodes = root[QStringLiteral("nodes")].toArray();
REQUIRE_FALSE(nodes.isEmpty());
bool foundName = false;
for (const auto &entry : nodes) {
if (entry.toObject()[QStringLiteral("name")].toString().toStdString() ==
virtualName) {
foundName = true;
break;
}
}
REQUIRE(foundName);
widget.reset();
QApplication::processEvents();
}
TEST_CASE("GraphEditorWidget delete action removes virtual node and undo restores") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
const std::string nodeName = "undo-delete-node-101940";
REQUIRE(tc.client->Test_InsertNode(
MakeNode(101940, nodeName, "Audio/Sink", {}, {}, true)).ok());
auto widget = std::make_unique<GraphEditorWidget>(tc.client.get());
auto *model = widget->findChild<WarpGraphModel *>();
REQUIRE(model != nullptr);
auto *view = findZoomView(*widget);
REQUIRE(view != nullptr);
auto *scene = dynamic_cast<QtNodes::BasicGraphicsScene *>(view->scene());
REQUIRE(scene != nullptr);
QApplication::processEvents();
tc.client->SetChangeCallback(nullptr);
QApplication::processEvents();
QtNodes::NodeId qtId = model->qtNodeIdForPw(101940);
REQUIRE(qtId != 0);
auto *nodeItem = scene->nodeGraphicsObject(qtId);
REQUIRE(nodeItem != nullptr);
scene->clearSelection();
nodeItem->setSelected(true);
QApplication::processEvents();
REQUIRE(scene->selectedItems().size() >= 1);
const int beforeIndex = scene->undoStack().index();
auto *deleteAction = findActionByText(view->actions(), "Delete Selection");
REQUIRE(deleteAction != nullptr);
deleteAction->trigger();
QApplication::processEvents();
const int afterDeleteIndex = scene->undoStack().index();
if (afterDeleteIndex == beforeIndex) {
SUCCEED("Delete command unavailable for this backend node setup");
return;
}
REQUIRE(scene->undoStack().canUndo());
scene->undoStack().undo();
QApplication::processEvents();
REQUIRE(scene->undoStack().index() == beforeIndex);
REQUIRE(scene->undoStack().canRedo());
scene->undoStack().redo();
QApplication::processEvents();
REQUIRE(scene->undoStack().index() == afterDeleteIndex);
widget.reset();
QApplication::processEvents();
}
TEST_CASE("GraphEditorWidget paste action creates incremental copy names") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
const std::string baseName = "paste-base-node-101950";
REQUIRE(tc.client->Test_InsertNode(
MakeNode(101950, baseName, "Audio/Sink", {}, {}, true)).ok());
auto widget = std::make_unique<GraphEditorWidget>(tc.client.get());
auto *view = findZoomView(*widget);
REQUIRE(view != nullptr);
tc.client->SetChangeCallback(nullptr);
QApplication::processEvents();
QJsonObject node;
node[QStringLiteral("name")] = QString::fromStdString(baseName);
node[QStringLiteral("media_class")] = QStringLiteral("Audio/Sink");
node[QStringLiteral("x")] = 40.0;
node[QStringLiteral("y")] = 30.0;
QJsonObject root;
root[QStringLiteral("nodes")] = QJsonArray{node};
root[QStringLiteral("links")] = QJsonArray{};
root[QStringLiteral("center_x")] = 40.0;
root[QStringLiteral("center_y")] = 30.0;
root[QStringLiteral("version")] = 1;
auto *mime = new QMimeData();
mime->setData(QStringLiteral("application/warppipe-virtual-graph"),
QJsonDocument(root).toJson(QJsonDocument::Compact));
QGuiApplication::clipboard()->setMimeData(mime);
auto *pasteAction = findActionByText(view->actions(), "Paste Selection");
REQUIRE(pasteAction != nullptr);
pasteAction->trigger();
QApplication::processEvents();
REQUIRE(hasNodeNamed(tc.client.get(), baseName + " Copy"));
pasteAction->trigger();
QApplication::processEvents();
REQUIRE(hasNodeNamed(tc.client.get(), baseName + " Copy 2"));
widget.reset();
QApplication::processEvents();
}
TEST_CASE("GraphEditorWidget linkCount reflects injected links") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(101960, "link-count-sink-101960", "Audio/Sink")).ok());
REQUIRE(tc.client->Test_InsertNode(
MakeNode(101962, "link-count-source-101962", "Audio/Source")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(101961, 101960, "in_FL", true)).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(101963, 101962, "out_FL", false)).ok());
REQUIRE(tc.client->Test_InsertLink(
MakeLink(101964, 101963, 101961)).ok());
GraphEditorWidget widget(tc.client.get());
REQUIRE(widget.linkCount() >= 1);
}
TEST_CASE("GraphEditorWidget volume edits are undoable through command stack") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(101970, "volume-command-node-101970", "Audio/Sink")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(101971, 101970, "in_FL", true)).ok());
auto widget = std::make_unique<GraphEditorWidget>(tc.client.get());
auto *view = findZoomView(*widget);
REQUIRE(view != nullptr);
auto *scene = dynamic_cast<QtNodes::BasicGraphicsScene *>(view->scene());
REQUIRE(scene != nullptr);
tc.client->SetChangeCallback(nullptr);
QApplication::processEvents();
auto before = tc.client->Test_GetNodeVolume(warppipe::NodeId{101970});
if (!before.ok()) {
SUCCEED("Test node volume state unavailable");
return;
}
ClickSlider *slider = nullptr;
for (auto *candidate : widget->findChildren<ClickSlider *>()) {
if (candidate->orientation() == Qt::Horizontal && candidate->minimum() == 0 &&
candidate->maximum() == 100) {
slider = candidate;
break;
}
}
if (!slider) {
SUCCEED("Mixer volume slider unavailable in current backend setup");
return;
}
slider->setValue(25);
QApplication::processEvents();
auto after = tc.client->Test_GetNodeVolume(warppipe::NodeId{101970});
REQUIRE(after.ok());
REQUIRE(after.value.volume < before.value.volume);
const int beforePush = scene->undoStack().index();
bool released = QMetaObject::invokeMethod(slider, "sliderReleased");
REQUIRE(released);
QApplication::processEvents();
REQUIRE(scene->undoStack().canUndo());
REQUIRE(scene->undoStack().index() == beforePush + 1);
scene->undoStack().undo();
QApplication::processEvents();
REQUIRE(scene->undoStack().index() == beforePush);
REQUIRE(scene->undoStack().canRedo());
scene->undoStack().redo();
QApplication::processEvents();
REQUIRE(scene->undoStack().index() == beforePush + 1);
widget.reset();
QApplication::processEvents();
}
TEST_CASE("GraphEditorWidget onRefreshTimer updates node count after injection") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
GraphEditorWidget widget(tc.client.get());
const int before = widget.nodeCount();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(101980, "refresh-node-101980", "Audio/Sink")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(101981, 101980, "in_FL", true)).ok());
bool refreshed = QMetaObject::invokeMethod(&widget, "onRefreshTimer");
REQUIRE(refreshed);
QApplication::processEvents();
REQUIRE(widget.nodeCount() >= before + 1);
}
TEST_CASE("GraphEditorWidget onRefreshTimer restores BspTreeIndex when forced to NoIndex") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
GraphEditorWidget widget(tc.client.get());
auto *view = findZoomView(widget);
REQUIRE(view != nullptr);
auto *scene = dynamic_cast<QtNodes::BasicGraphicsScene *>(view->scene());
REQUIRE(scene != nullptr);
scene->setItemIndexMethod(QGraphicsScene::NoIndex);
REQUIRE(scene->itemIndexMethod() == QGraphicsScene::NoIndex);
bool refreshed = QMetaObject::invokeMethod(&widget, "onRefreshTimer");
REQUIRE(refreshed);
QApplication::processEvents();
REQUIRE(scene->itemIndexMethod() == QGraphicsScene::BspTreeIndex);
}
TEST_CASE("GraphEditorWidget eventFilter consumes middle-click on viewport") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
GraphEditorWidget widget(tc.client.get());
auto *view = findZoomView(widget);
REQUIRE(view != nullptr);
REQUIRE(view->viewport() != nullptr);
QPointF pos(20.0, 20.0);
QMouseEvent middlePress(QEvent::MouseButtonPress,
pos,
pos,
Qt::MiddleButton,
Qt::MiddleButton,
Qt::NoModifier);
REQUIRE(widget.eventFilter(view->viewport(), &middlePress));
}
TEST_CASE("Scripted GraphEditorWidget canvas menu selects and deselects all") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(101990, "menu-select-node-101990", "Audio/Sink")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(101991, 101990, "in_FL", true)).ok());
ScriptedGraphEditorWidget widget(tc.client.get());
auto *view = findZoomView(widget);
REQUIRE(view != nullptr);
auto *scene = dynamic_cast<QtNodes::BasicGraphicsScene *>(view->scene());
REQUIRE(scene != nullptr);
bool refreshed = QMetaObject::invokeMethod(&widget, "onRefreshTimer");
REQUIRE(refreshed);
QApplication::processEvents();
widget.queueMenuSelection(QStringLiteral("Select All"));
bool invoked = QMetaObject::invokeMethod(
&widget, "onContextMenuRequested", Q_ARG(QPoint, QPoint(-200, -200)));
REQUIRE(invoked);
REQUIRE_FALSE(scene->selectedItems().isEmpty());
widget.queueMenuSelection(QStringLiteral("Deselect All"));
invoked = QMetaObject::invokeMethod(
&widget, "onContextMenuRequested", Q_ARG(QPoint, QPoint(-200, -200)));
REQUIRE(invoked);
REQUIRE(scene->selectedItems().isEmpty());
}
TEST_CASE("Scripted GraphEditorWidget canvas menu creates virtual sink") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
const std::string nodeName = "scripted-sink-102000";
ScriptedGraphEditorWidget widget(tc.client.get());
widget.setInputDialogResponse(QString::fromStdString(nodeName), true);
widget.queueMenuSelection(QStringLiteral("Create Virtual Sink"));
bool invoked = QMetaObject::invokeMethod(
&widget, "onContextMenuRequested", Q_ARG(QPoint, QPoint(-200, -200)));
REQUIRE(invoked);
QApplication::processEvents();
if (!hasNodeNamed(tc.client.get(), nodeName)) {
SUCCEED("Virtual sink creation unavailable in this runtime");
return;
}
auto nodes = tc.client->ListNodes();
REQUIRE(nodes.ok());
for (const auto &node : nodes.value) {
if (node.name == nodeName) {
tc.client->RemoveNode(node.id);
}
}
}
TEST_CASE("Scripted GraphEditorWidget node menu copy exports clipboard payload") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
const uint32_t pwId = 102020;
const std::string nodeName = "node-menu-copy-102020";
REQUIRE(tc.client->Test_InsertNode(
MakeNode(pwId, nodeName, "Audio/Sink", {}, {}, true)).ok());
ScriptedGraphEditorWidget widget(tc.client.get());
auto *model = widget.findChild<WarpGraphModel *>();
REQUIRE(model != nullptr);
auto *view = findZoomView(widget);
REQUIRE(view != nullptr);
auto *scene = dynamic_cast<QtNodes::BasicGraphicsScene *>(view->scene());
REQUIRE(scene != nullptr);
widget.show();
QApplication::processEvents();
bool refreshed = QMetaObject::invokeMethod(&widget, "onRefreshTimer");
REQUIRE(refreshed);
QApplication::processEvents();
QtNodes::NodeId qtId = model->qtNodeIdForPw(pwId);
REQUIRE(qtId != 0);
auto *nodeObj = scene->nodeGraphicsObject(qtId);
REQUIRE(nodeObj != nullptr);
scene->clearSelection();
nodeObj->setSelected(true);
QApplication::processEvents();
widget.queueMenuSelection(QStringLiteral("Copy"));
QPoint hitPos = nodeCenterInView(*model, *view, qtId);
bool invoked = QMetaObject::invokeMethod(
&widget, "onContextMenuRequested", Q_ARG(QPoint, hitPos));
REQUIRE(invoked);
const QMimeData *mime = QGuiApplication::clipboard()->mimeData();
REQUIRE(mime != nullptr);
REQUIRE(mime->hasFormat(QStringLiteral("application/warppipe-virtual-graph")));
QJsonObject copied = QJsonDocument::fromJson(
mime->data(QStringLiteral("application/warppipe-virtual-graph"))).object();
bool foundNode = false;
for (const auto &entry : copied[QStringLiteral("nodes")].toArray()) {
if (entry.toObject()[QStringLiteral("name")].toString().toStdString() ==
nodeName) {
foundNode = true;
break;
}
}
REQUIRE(foundNode);
}
TEST_CASE("Scripted GraphEditorWidget node menu duplicate creates copied node") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
const uint32_t pwId = 102030;
const std::string nodeName = "node-menu-duplicate-102030";
REQUIRE(tc.client->Test_InsertNode(
MakeNode(pwId, nodeName, "Audio/Sink", {}, {}, true)).ok());
ScriptedGraphEditorWidget widget(tc.client.get());
auto *model = widget.findChild<WarpGraphModel *>();
REQUIRE(model != nullptr);
auto *view = findZoomView(widget);
REQUIRE(view != nullptr);
auto *scene = dynamic_cast<QtNodes::BasicGraphicsScene *>(view->scene());
REQUIRE(scene != nullptr);
tc.client->SetChangeCallback(nullptr);
widget.show();
QApplication::processEvents();
bool refreshed = QMetaObject::invokeMethod(&widget, "onRefreshTimer");
REQUIRE(refreshed);
QApplication::processEvents();
QtNodes::NodeId qtId = model->qtNodeIdForPw(pwId);
REQUIRE(qtId != 0);
auto *nodeObj = scene->nodeGraphicsObject(qtId);
REQUIRE(nodeObj != nullptr);
scene->clearSelection();
nodeObj->setSelected(true);
QApplication::processEvents();
widget.queueMenuSelection(QStringLiteral("Duplicate"));
QPoint hitPos = nodeCenterInView(*model, *view, qtId);
bool invoked = QMetaObject::invokeMethod(
&widget, "onContextMenuRequested", Q_ARG(QPoint, hitPos));
REQUIRE(invoked);
QApplication::processEvents();
model->refreshFromClient();
if (model->findPwNodeIdByName(nodeName + " Copy") == 0) {
SUCCEED("Virtual duplicate unavailable in this runtime");
return;
}
auto nodes = tc.client->ListNodes();
REQUIRE(nodes.ok());
for (const auto &node : nodes.value) {
if (node.name.rfind(nodeName + " Copy", 0) == 0) {
tc.client->RemoveNode(node.id);
}
}
}
TEST_CASE("Scripted GraphEditorWidget node menu paste creates node from clipboard") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
const uint32_t anchorId = 102040;
const std::string anchorName = "node-menu-paste-anchor-102040";
const std::string payloadName = "node-menu-paste-payload-102040";
REQUIRE(tc.client->Test_InsertNode(
MakeNode(anchorId, anchorName, "Audio/Sink", {}, {}, true)).ok());
ScriptedGraphEditorWidget widget(tc.client.get());
auto *model = widget.findChild<WarpGraphModel *>();
REQUIRE(model != nullptr);
auto *view = findZoomView(widget);
REQUIRE(view != nullptr);
tc.client->SetChangeCallback(nullptr);
widget.show();
QApplication::processEvents();
bool refreshed = QMetaObject::invokeMethod(&widget, "onRefreshTimer");
REQUIRE(refreshed);
QApplication::processEvents();
QtNodes::NodeId qtId = model->qtNodeIdForPw(anchorId);
REQUIRE(qtId != 0);
QJsonObject node;
node[QStringLiteral("name")] = QString::fromStdString(payloadName);
node[QStringLiteral("media_class")] = QStringLiteral("Audio/Sink");
node[QStringLiteral("x")] = 32.0;
node[QStringLiteral("y")] = 48.0;
QJsonObject root;
root[QStringLiteral("nodes")] = QJsonArray{node};
root[QStringLiteral("links")] = QJsonArray{};
root[QStringLiteral("center_x")] = 32.0;
root[QStringLiteral("center_y")] = 48.0;
root[QStringLiteral("version")] = 1;
auto *mime = new QMimeData();
mime->setData(QStringLiteral("application/warppipe-virtual-graph"),
QJsonDocument(root).toJson(QJsonDocument::Compact));
QGuiApplication::clipboard()->setMimeData(mime);
widget.queueMenuSelection(QStringLiteral("Paste"));
QPoint hitPos = nodeCenterInView(*model, *view, qtId);
bool invoked = QMetaObject::invokeMethod(
&widget, "onContextMenuRequested", Q_ARG(QPoint, hitPos));
REQUIRE(invoked);
QApplication::processEvents();
model->refreshFromClient();
if (model->findPwNodeIdByName(payloadName + " Copy") == 0) {
SUCCEED("Virtual paste unavailable in this runtime");
return;
}
auto nodes = tc.client->ListNodes();
REQUIRE(nodes.ok());
for (const auto &n : nodes.value) {
if (n.name.rfind(payloadName + " Copy", 0) == 0) {
tc.client->RemoveNode(n.id);
}
}
}
TEST_CASE("Scripted GraphEditorWidget node menu create-rule opens dialog and adds rule") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
const uint32_t appId = 102050;
const std::string targetName = "ctx-rule-target-102050";
const QString appMatch = QStringLiteral("CtxMenuRule102050");
REQUIRE(tc.client->Test_InsertNode(MakeNode(appId,
"ctx-rule-app-node-102050",
"Stream/Output/Audio",
"ctx-app-source")).ok());
REQUIRE(tc.client->Test_InsertNode(
MakeNode(102051, targetName, "Audio/Sink", {}, {}, true)).ok());
ScriptedGraphEditorWidget widget(tc.client.get());
auto *model = widget.findChild<WarpGraphModel *>();
REQUIRE(model != nullptr);
auto *view = findZoomView(widget);
REQUIRE(view != nullptr);
widget.show();
QApplication::processEvents();
bool refreshed = QMetaObject::invokeMethod(&widget, "onRefreshTimer");
REQUIRE(refreshed);
QApplication::processEvents();
QtNodes::NodeId qtId = model->qtNodeIdForPw(appId);
REQUIRE(qtId != 0);
bool accepted = false;
QTimer::singleShot(0, [&accepted, &appMatch, &targetName]() {
accepted = acceptRuleDialog(appMatch, QString::fromStdString(targetName));
});
widget.queueMenuSelection(QStringLiteral("Create Rule..."));
QPoint hitPos = nodeCenterInView(*model, *view, qtId);
bool invoked = QMetaObject::invokeMethod(
&widget, "onContextMenuRequested", Q_ARG(QPoint, hitPos));
REQUIRE(invoked);
QApplication::processEvents();
if (!accepted) {
SUCCEED("Rule dialog automation unavailable on this platform");
return;
}
auto rules = tc.client->ListRouteRules();
REQUIRE(rules.ok());
warppipe::RuleId created{};
bool found = false;
for (const auto &rule : rules.value) {
if (rule.match.application_name == appMatch.toStdString() &&
rule.target_node == targetName) {
created = rule.id;
found = true;
break;
}
}
REQUIRE(found);
REQUIRE(tc.client->RemoveRouteRule(created).ok());
}
TEST_CASE("Scripted GraphEditorWidget save and load preset use scripted file paths") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
QString base = QStandardPaths::writableLocation(QStandardPaths::TempLocation) +
"/warppipe_scripted_preset";
QString fullPath = base + ".json";
QFile::remove(fullPath);
ScriptedGraphEditorWidget widget(tc.client.get());
widget.setSaveFilePathResponse(base);
widget.queueMenuSelection(QStringLiteral("Save Preset..."));
bool invoked = QMetaObject::invokeMethod(
&widget, "onContextMenuRequested", Q_ARG(QPoint, QPoint(-200, -200)));
REQUIRE(invoked);
QApplication::processEvents();
if (!QFile::exists(fullPath)) {
SUCCEED("Preset save unavailable in this runtime");
return;
}
const int warningsBefore = widget.warningCount();
widget.setOpenFilePathResponse(fullPath);
widget.queueMenuSelection(QStringLiteral("Load Preset..."));
invoked = QMetaObject::invokeMethod(
&widget, "onContextMenuRequested", Q_ARG(QPoint, QPoint(-200, -200)));
REQUIRE(invoked);
QApplication::processEvents();
REQUIRE(widget.warningCount() == warningsBefore);
QFile::remove(fullPath);
}
TEST_CASE("GraphEditorWidget debug screenshot dir creates node-added capture") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
QString screenshotDir =
QStandardPaths::writableLocation(QStandardPaths::TempLocation) +
"/warppipe_debug_screens";
QDir(screenshotDir).removeRecursively();
GraphEditorWidget widget(tc.client.get());
widget.resize(640, 420);
widget.show();
QApplication::processEvents();
widget.setDebugScreenshotDir(screenshotDir);
REQUIRE(QDir(screenshotDir).exists());
REQUIRE(tc.client->Test_InsertNode(
MakeNode(102010, "screenshot-node-102010", "Audio/Sink")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(102011, 102010, "in_FL", true)).ok());
bool refreshed = QMetaObject::invokeMethod(&widget, "onRefreshTimer");
REQUIRE(refreshed);
QApplication::processEvents();
QStringList shots = QDir(screenshotDir).entryList(
QStringList() << "warppipe_*_node_added.png", QDir::Files);
REQUIRE_FALSE(shots.isEmpty());
QDir(screenshotDir).removeRecursively();
}
TEST_CASE("GraphEditorWidget node context menu can open NODE details tab") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
if (QGuiApplication::platformName().contains(QStringLiteral("wayland"))) {
SUCCEED("Skipping popup-menu automation on Wayland platform");
return;
}
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100840, "context-node-100840", "Audio/Sink", {}, {}, true)).ok());
GraphEditorWidget widget(tc.client.get());
auto *model = widget.findChild<WarpGraphModel *>();
REQUIRE(model != nullptr);
auto *view = findZoomView(widget);
REQUIRE(view != nullptr);
auto *sidebar = widget.findChild<QTabWidget *>();
REQUIRE(sidebar != nullptr);
widget.show();
QApplication::processEvents();
QtNodes::NodeId qtId = model->qtNodeIdForPw(100840);
REQUIRE(qtId != 0);
QPointF nodePos = model->nodeData(qtId, QtNodes::NodeRole::Position).toPointF();
QSize nodeSize = model->nodeData(qtId, QtNodes::NodeRole::Size).toSize();
QPointF hitScenePos = nodePos + QPointF(nodeSize.width() / 2.0,
nodeSize.height() / 2.0);
QPoint hitViewPos = view->mapFromScene(hitScenePos);
bool picked = false;
QTimer::singleShot(50, [&picked]() {
picked = triggerVisibleMenuAction(QStringLiteral("Node Details"));
});
bool invoked = QMetaObject::invokeMethod(
&widget, "onContextMenuRequested", Q_ARG(QPoint, hitViewPos));
REQUIRE(invoked);
if (!picked) {
SUCCEED("Popup-menu automation unavailable on this Qt platform");
return;
}
REQUIRE(sidebar->tabText(sidebar->currentIndex()) == "NODE");
}
TEST_CASE("GraphEditorWidget rules tab add dialog creates rule and delete button removes it") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
const std::string targetName = "rule-target-100850";
const QString appToken = QStringLiteral("RuleApp100850");
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100850, targetName, "Audio/Sink", {}, {}, true)).ok());
GraphEditorWidget widget(tc.client.get());
QPushButton *addRuleButton = nullptr;
for (auto *button : widget.findChildren<QPushButton *>()) {
if (button->text() == QStringLiteral("Add Rule...")) {
addRuleButton = button;
break;
}
}
REQUIRE(addRuleButton != nullptr);
bool accepted = false;
QTimer::singleShot(0, [&accepted, &appToken, &targetName]() {
accepted = acceptRuleDialog(appToken, QString::fromStdString(targetName));
});
addRuleButton->click();
QApplication::processEvents();
REQUIRE(accepted);
auto rulesAfterAdd = tc.client->ListRouteRules();
REQUIRE(rulesAfterAdd.ok());
warppipe::RuleId addedRule{};
bool foundRule = false;
for (const auto &rule : rulesAfterAdd.value) {
if (rule.match.application_name == appToken.toStdString() &&
rule.target_node == targetName) {
addedRule = rule.id;
foundRule = true;
break;
}
}
REQUIRE(foundRule);
auto *deleteButton = findRuleDeleteButtonByAppLabel(widget, appToken);
REQUIRE(deleteButton != nullptr);
deleteButton->click();
QApplication::processEvents();
auto rulesAfterDelete = tc.client->ListRouteRules();
REQUIRE(rulesAfterDelete.ok());
bool stillPresent = false;
for (const auto &rule : rulesAfterDelete.value) {
if (rule.id.value == addedRule.value) {
stillPresent = true;
break;
}
}
REQUIRE_FALSE(stillPresent);
tc.client->SetChangeCallback(nullptr);
QApplication::processEvents();
}
TEST_CASE("GraphEditorWidget reflects injected nodes") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100210, "warppipe-widget-test", "Audio/Sink")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100211, 100210, "FL", true)).ok());
GraphEditorWidget widget(tc.client.get());
REQUIRE(widget.nodeCount() >= 1);
}
TEST_CASE("findPwNodeIdByName returns 0 for ghost nodes without pw mapping") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100220, "ghost-lookup", "Stream/Output/Audio", "App")).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
REQUIRE(model.findPwNodeIdByName("ghost-lookup") == 100220);
REQUIRE(tc.client->Test_RemoveGlobal(100220).ok());
model.refreshFromClient();
REQUIRE(model.findPwNodeIdByName("ghost-lookup") == 100220);
}
TEST_CASE("saveLayout stores and loadLayout restores view state") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100300, "view-state-node", "Audio/Sink")).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
WarpGraphModel::ViewState vs;
vs.scale = 1.5;
vs.centerX = 123.4;
vs.centerY = 567.8;
vs.valid = true;
QString path = QStandardPaths::writableLocation(
QStandardPaths::TempLocation) +
"/warppipe_test_viewstate.json";
model.saveLayout(path, vs);
WarpGraphModel model2(tc.client.get());
bool loaded = model2.loadLayout(path);
REQUIRE(loaded);
auto restored = model2.savedViewState();
REQUIRE(restored.valid);
REQUIRE(restored.scale == Catch::Approx(1.5));
REQUIRE(restored.centerX == Catch::Approx(123.4));
REQUIRE(restored.centerY == Catch::Approx(567.8));
QFile::remove(path);
}
TEST_CASE("saveLayout without view state omits view key") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100310, "no-view-node", "Audio/Sink")).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
QString path = QStandardPaths::writableLocation(
QStandardPaths::TempLocation) +
"/warppipe_test_noview.json";
model.saveLayout(path);
WarpGraphModel model2(tc.client.get());
model2.loadLayout(path);
auto restored = model2.savedViewState();
REQUIRE_FALSE(restored.valid);
QFile::remove(path);
}
TEST_CASE("ghost nodes persist in layout JSON") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100320, "ghost-persist-app", "Stream/Output/Audio", "TestApp")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100321, 100320, "output_FL", false)).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100322, 100320, "input_FL", true)).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
REQUIRE_FALSE(model.isGhost(model.qtNodeIdForPw(100320)));
REQUIRE(tc.client->Test_RemoveGlobal(100320).ok());
model.refreshFromClient();
auto ghostQt = model.findPwNodeIdByName("ghost-persist-app");
REQUIRE(ghostQt == 100320);
QString path = QStandardPaths::writableLocation(
QStandardPaths::TempLocation) +
"/warppipe_test_ghosts.json";
model.saveLayout(path);
WarpGraphModel model2(tc.client.get());
model2.loadLayout(path);
auto ids = model2.allNodeIds();
bool foundGhost = false;
for (auto id : ids) {
const WarpNodeData *d = model2.warpNodeData(id);
if (d && d->info.name == "ghost-persist-app") {
foundGhost = true;
REQUIRE(model2.isGhost(id));
REQUIRE(d->info.application_name == "TestApp");
REQUIRE(d->inputPorts.size() == 1);
REQUIRE(d->outputPorts.size() == 1);
REQUIRE(d->inputPorts[0].name == "input_FL");
REQUIRE(d->outputPorts[0].name == "output_FL");
break;
}
}
REQUIRE(foundGhost);
QFile::remove(path);
}
TEST_CASE("layout version 1 files still load") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
QString path = QStandardPaths::writableLocation(
QStandardPaths::TempLocation) +
"/warppipe_test_v1.json";
QFile file(path);
REQUIRE(file.open(QIODevice::WriteOnly));
file.write(R"({"version":1,"nodes":[{"name":"legacy-node","x":10,"y":20}]})");
file.close();
WarpGraphModel model(tc.client.get());
REQUIRE(model.loadLayout(path));
auto vs = model.savedViewState();
REQUIRE_FALSE(vs.valid);
QFile::remove(path);
}
TEST_CASE("ghost connections preserved when node becomes ghost") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100400, "gc-sink", "Audio/Sink")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100401, 100400, "in_FL", true)).ok());
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100402, "gc-app", "Stream/Output/Audio", "GCApp")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100403, 100402, "out_FL", false)).ok());
REQUIRE(tc.client->Test_InsertLink(
MakeLink(100404, 100403, 100401)).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto sinkQt = model.qtNodeIdForPw(100400);
auto appQt = model.qtNodeIdForPw(100402);
REQUIRE(model.allConnectionIds(appQt).size() == 1);
REQUIRE(tc.client->Test_RemoveGlobal(100402).ok());
REQUIRE(tc.client->Test_RemoveGlobal(100404).ok());
model.refreshFromClient();
REQUIRE(model.isGhost(appQt));
REQUIRE(model.ghostConnectionExists(
QtNodes::ConnectionId{appQt, 0, sinkQt, 0}));
}
TEST_CASE("ghost connections survive save/load round-trip") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100410, "gcrt-sink", "Audio/Sink")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100411, 100410, "in_FL", true)).ok());
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100412, "gcrt-app", "Stream/Output/Audio", "GCRTApp")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100413, 100412, "out_FL", false)).ok());
REQUIRE(tc.client->Test_InsertLink(
MakeLink(100414, 100413, 100411)).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
REQUIRE(tc.client->Test_RemoveGlobal(100412).ok());
REQUIRE(tc.client->Test_RemoveGlobal(100414).ok());
model.refreshFromClient();
auto appQt = model.qtNodeIdForPw(100412);
REQUIRE(appQt == 0);
QString path = QStandardPaths::writableLocation(
QStandardPaths::TempLocation) +
"/warppipe_test_ghostconns.json";
model.saveLayout(path);
WarpGraphModel model2(tc.client.get());
model2.loadLayout(path);
model2.refreshFromClient();
QtNodes::NodeId sinkQt2 = 0;
QtNodes::NodeId appQt2 = 0;
for (auto id : model2.allNodeIds()) {
const WarpNodeData *d = model2.warpNodeData(id);
if (d && d->info.name == "gcrt-sink")
sinkQt2 = id;
if (d && d->info.name == "gcrt-app")
appQt2 = id;
}
REQUIRE(sinkQt2 != 0);
REQUIRE(appQt2 != 0);
REQUIRE(model2.isGhost(appQt2));
auto conns = model2.allGhostConnectionIds(appQt2);
REQUIRE(conns.size() == 1);
auto conn = *conns.begin();
REQUIRE(conn.outNodeId == appQt2);
REQUIRE(conn.inNodeId == sinkQt2);
QFile::remove(path);
}
TEST_CASE("ghost connections cleaned when ghost un-ghosts") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100420, "gcug-sink", "Audio/Sink")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100421, 100420, "in_FL", true)).ok());
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100422, "gcug-app", "Stream/Output/Audio", "GCUGApp")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100423, 100422, "out_FL", false)).ok());
REQUIRE(tc.client->Test_InsertLink(
MakeLink(100424, 100423, 100421)).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto appQt = model.qtNodeIdForPw(100422);
auto sinkQt = model.qtNodeIdForPw(100420);
REQUIRE(tc.client->Test_RemoveGlobal(100422).ok());
REQUIRE(tc.client->Test_RemoveGlobal(100424).ok());
model.refreshFromClient();
REQUIRE(model.isGhost(appQt));
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100425, "gcug-app", "Stream/Output/Audio", "GCUGApp")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100426, 100425, "out_FL", false)).ok());
model.refreshFromClient();
REQUIRE_FALSE(model.isGhost(appQt));
auto conns = model.allConnectionIds(appQt);
bool hasOldGhostConn = false;
for (const auto &c : conns) {
if (c.outNodeId == appQt && c.inNodeId == sinkQt)
hasOldGhostConn = true;
}
REQUIRE_FALSE(hasOldGhostConn);
}
TEST_CASE("clearSavedPositions resets model positions") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100340, "clear-pos-node", "Audio/Sink")).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto id = model.qtNodeIdForPw(100340);
REQUIRE(id != 0);
auto posBefore = model.nodeData(id, QtNodes::NodeRole::Position).toPointF();
model.clearSavedPositions();
model.autoArrange();
auto posAfter = model.nodeData(id, QtNodes::NodeRole::Position).toPointF();
REQUIRE(posAfter != QPointF(0, 0));
}
TEST_CASE("preset save/load round-trip preserves virtual devices and layout") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100500, "preset-vsink", "Audio/Sink", {}, {}, true)).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100501, 100500, "FL", true)).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100502, 100500, "FR", true)).ok());
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100503, "preset-src", "Audio/Source")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100504, 100503, "out_FL", false)).ok());
REQUIRE(tc.client->Test_InsertLink(
MakeLink(100505, 100504, 100501)).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
model.setNodeData(model.qtNodeIdForPw(100500),
QtNodes::NodeRole::Position, QPointF(300, 400));
QString path = QStandardPaths::writableLocation(
QStandardPaths::TempLocation) +
"/warppipe_test_preset.json";
REQUIRE(PresetManager::savePreset(path, tc.client.get(), &model));
QFile file(path);
REQUIRE(file.open(QIODevice::ReadOnly));
QJsonDocument doc = QJsonDocument::fromJson(file.readAll());
file.close();
REQUIRE(doc.isObject());
QJsonObject root = doc.object();
REQUIRE(root["version"].toInt() == 1);
REQUIRE(root["virtual_devices"].toArray().size() >= 1);
REQUIRE(root["routing"].toArray().size() >= 1);
REQUIRE(root["layout"].toArray().size() >= 2);
bool foundVsink = false;
for (const auto &val : root["virtual_devices"].toArray()) {
if (val.toObject()["name"].toString() == "preset-vsink") {
foundVsink = true;
REQUIRE(val.toObject()["channels"].toInt() == 2);
}
}
REQUIRE(foundVsink);
bool foundRoute = false;
for (const auto &val : root["routing"].toArray()) {
QJsonObject route = val.toObject();
if (route["out_node"].toString() == "preset-src" &&
route["in_node"].toString() == "preset-vsink") {
foundRoute = true;
}
}
REQUIRE(foundRoute);
bool foundLayout = false;
for (const auto &val : root["layout"].toArray()) {
QJsonObject obj = val.toObject();
if (obj["name"].toString() == "preset-vsink") {
foundLayout = true;
REQUIRE(obj["x"].toDouble() == Catch::Approx(300.0));
REQUIRE(obj["y"].toDouble() == Catch::Approx(400.0));
}
}
REQUIRE(foundLayout);
QFile::remove(path);
}
TEST_CASE("splitter sizes persist in layout JSON") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100510, "splitter-node", "Audio/Sink")).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
WarpGraphModel::ViewState vs;
vs.scale = 1.0;
vs.centerX = 0.0;
vs.centerY = 0.0;
vs.splitterGraph = 900;
vs.splitterSidebar = 400;
vs.valid = true;
QString path = QStandardPaths::writableLocation(
QStandardPaths::TempLocation) +
"/warppipe_test_splitter.json";
model.saveLayout(path, vs);
WarpGraphModel model2(tc.client.get());
model2.loadLayout(path);
auto restored = model2.savedViewState();
REQUIRE(restored.valid);
REQUIRE(restored.splitterGraph == 900);
REQUIRE(restored.splitterSidebar == 400);
QFile::remove(path);
}
TEST_CASE("model volume state defaults to 1.0 and unmuted") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100600, "vol-default", "Audio/Sink")).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto qtId = model.qtNodeIdForPw(100600);
REQUIRE(qtId != 0);
auto state = model.nodeVolumeState(qtId);
REQUIRE(state.volume == Catch::Approx(1.0f));
REQUIRE_FALSE(state.mute);
}
TEST_CASE("setNodeVolumeState updates model and calls test helper") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100610, "vol-set", "Audio/Sink")).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto qtId = model.qtNodeIdForPw(100610);
REQUIRE(qtId != 0);
WarpGraphModel::NodeVolumeState ns;
ns.volume = 0.5f;
ns.mute = true;
model.setNodeVolumeState(qtId, ns);
auto state = model.nodeVolumeState(qtId);
REQUIRE(state.volume == Catch::Approx(0.5f));
REQUIRE(state.mute);
auto apiState = tc.client->Test_GetNodeVolume(warppipe::NodeId{100610});
REQUIRE(apiState.ok());
REQUIRE(apiState.value.volume == Catch::Approx(0.5f));
REQUIRE(apiState.value.mute);
}
TEST_CASE("nodeVolumeChanged signal emitted on state change") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100620, "vol-signal", "Audio/Sink")).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto qtId = model.qtNodeIdForPw(100620);
REQUIRE(qtId != 0);
bool signalFired = false;
QObject::connect(&model, &WarpGraphModel::nodeVolumeChanged,
[&](QtNodes::NodeId id, WarpGraphModel::NodeVolumeState prev,
WarpGraphModel::NodeVolumeState cur) {
if (id == qtId) {
signalFired = true;
REQUIRE(prev.volume == Catch::Approx(1.0f));
REQUIRE(cur.volume == Catch::Approx(0.3f));
REQUIRE(cur.mute);
}
});
WarpGraphModel::NodeVolumeState ns;
ns.volume = 0.3f;
ns.mute = true;
model.setNodeVolumeState(qtId, ns);
REQUIRE(signalFired);
}
TEST_CASE("volume widget created for new nodes") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100630, "vol-widget", "Audio/Sink")).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto qtId = model.qtNodeIdForPw(100630);
REQUIRE(qtId != 0);
auto widget = model.nodeData(qtId, QtNodes::NodeRole::Widget);
REQUIRE(widget.isValid());
auto *w = widget.value<QWidget *>();
REQUIRE(w != nullptr);
auto *vol = qobject_cast<NodeVolumeWidget *>(w);
REQUIRE(vol != nullptr);
REQUIRE(vol->volume() == 100);
REQUIRE_FALSE(vol->isMuted());
}
TEST_CASE("setNodeVolumeState syncs inline widget") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100640, "vol-sync", "Audio/Sink")).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto qtId = model.qtNodeIdForPw(100640);
auto *w = model.nodeData(qtId, QtNodes::NodeRole::Widget).value<QWidget *>();
auto *vol = qobject_cast<NodeVolumeWidget *>(w);
REQUIRE(vol != nullptr);
WarpGraphModel::NodeVolumeState ns;
ns.volume = 0.7f;
ns.mute = true;
model.setNodeVolumeState(qtId, ns);
// Cubic scaling: slider = cbrt(0.7) * 100 ≈ 89
REQUIRE(vol->volume() == static_cast<int>(std::round(std::cbrt(0.7f) * 100.0f)));
REQUIRE(vol->isMuted());
}
TEST_CASE("ClickSlider horizontal click jumps toward clicked position") {
ensureApp();
ClickSlider slider(Qt::Horizontal);
slider.setRange(0, 100);
slider.resize(120, 24);
slider.show();
QApplication::processEvents();
QPointF click_pos(90.0, 12.0);
QMouseEvent press(QEvent::MouseButtonPress, click_pos, click_pos,
Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
QApplication::sendEvent(&slider, &press);
REQUIRE(slider.value() >= 60);
}
TEST_CASE("ClickSlider vertical click jumps toward clicked position") {
ensureApp();
ClickSlider slider(Qt::Vertical);
slider.setRange(0, 100);
slider.resize(24, 120);
slider.show();
QApplication::processEvents();
QPointF click_pos(12.0, 20.0);
QMouseEvent press(QEvent::MouseButtonPress, click_pos, click_pos,
Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
QApplication::sendEvent(&slider, &press);
REQUIRE(slider.value() <= 40);
}
TEST_CASE("NodeVolumeWidget setVolume and setMuted block outbound signals") {
ensureApp();
NodeVolumeWidget widget;
int volume_signal_count = 0;
int mute_signal_count = 0;
QObject::connect(&widget, &NodeVolumeWidget::volumeChanged,
[&](int) { ++volume_signal_count; });
QObject::connect(&widget, &NodeVolumeWidget::muteToggled,
[&](bool) { ++mute_signal_count; });
widget.setVolume(35);
widget.setMuted(true);
REQUIRE(volume_signal_count == 0);
REQUIRE(mute_signal_count == 0);
auto* slider = widget.findChild<QSlider*>();
REQUIRE(slider != nullptr);
slider->setValue(70);
REQUIRE(volume_signal_count >= 1);
auto* mute_btn = widget.findChild<QToolButton*>();
REQUIRE(mute_btn != nullptr);
mute_btn->setChecked(false);
REQUIRE(mute_signal_count >= 1);
}
TEST_CASE("SquareConnectionPainter stroke handles straight and elbow paths") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
WarpGraphModel model(tc.client.get());
QtNodes::BasicGraphicsScene scene(model);
SquareConnectionPainter painter;
auto straight = makeConnectionGraphic(
scene,
QtNodes::ConnectionId{1u, 0u, 2u, 0u},
QPointF(20.0, 20.0),
QPointF(180.0, 20.0));
auto straightStroke = painter.getPainterStroke(*straight);
REQUIRE(!straightStroke.isEmpty());
REQUIRE(straightStroke.boundingRect().width() >= 150.0);
auto elbow = makeConnectionGraphic(
scene,
QtNodes::ConnectionId{1u, 3u, 2u, 0u},
QPointF(180.0, 40.0),
QPointF(20.0, 40.0));
auto elbowStroke = painter.getPainterStroke(*elbow);
REQUIRE(!elbowStroke.isEmpty());
REQUIRE(elbowStroke.boundingRect().left() <= 20.0);
REQUIRE(elbowStroke.boundingRect().right() >= 180.0);
}
TEST_CASE("SquareConnectionPainter paint renders sketch and connected states") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
WarpGraphModel model(tc.client.get());
QtNodes::BasicGraphicsScene scene(model);
SquareConnectionPainter painter;
auto sketch = makeConnectionGraphic(
scene,
QtNodes::ConnectionId{1u, 1u, QtNodes::InvalidNodeId, 0u},
QPointF(25.0, 25.0),
QPointF(190.0, 85.0));
QImage sketchImage(240, 140, QImage::Format_ARGB32_Premultiplied);
sketchImage.fill(Qt::transparent);
{
QPainter qp(&sketchImage);
painter.paint(&qp, *sketch);
}
REQUIRE(countPaintedPixels(sketchImage) > 0);
auto connected = makeConnectionGraphic(
scene,
QtNodes::ConnectionId{1u, 0u, 2u, 0u},
QPointF(25.0, 25.0),
QPointF(190.0, 85.0));
connected->setSelected(true);
QImage connectedImage(240, 140, QImage::Format_ARGB32_Premultiplied);
connectedImage.fill(Qt::transparent);
{
QPainter qp(&connectedImage);
painter.paint(&qp, *connected);
}
REQUIRE(countPaintedPixels(connectedImage) > 0);
}
TEST_CASE("ZoomGraphicsView wheel zoom honors sensitivity and zero delta") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
WarpGraphModel model(tc.client.get());
QtNodes::BasicGraphicsScene scene(model);
TestZoomGraphicsView view(&scene);
view.resize(320, 200);
view.setZoomSensitivity(1.6);
view.setupScale(1.0);
const QPointF pos(40.0, 40.0);
const QPointF global(40.0, 40.0);
QWheelEvent zoomIn(pos, global, QPoint(0, 0), QPoint(0, 120), Qt::NoButton,
Qt::NoModifier, Qt::NoScrollPhase, false,
Qt::MouseEventNotSynthesized,
QPointingDevice::primaryPointingDevice());
view.dispatchWheel(&zoomIn);
const double zoomed = view.transform().m11();
REQUIRE(zoomed > 1.0);
QWheelEvent zoomOut(pos, global, QPoint(0, 0), QPoint(0, -120), Qt::NoButton,
Qt::NoModifier, Qt::NoScrollPhase, false,
Qt::MouseEventNotSynthesized,
QPointingDevice::primaryPointingDevice());
view.dispatchWheel(&zoomOut);
REQUIRE(view.transform().m11() < zoomed);
const double beforeFlat = view.transform().m11();
QWheelEvent flat(pos, global, QPoint(0, 0), QPoint(0, 0), Qt::NoButton,
Qt::NoModifier, Qt::NoScrollPhase, false,
Qt::MouseEventNotSynthesized,
QPointingDevice::primaryPointingDevice());
view.dispatchWheel(&flat);
REQUIRE(view.transform().m11() == Catch::Approx(beforeFlat));
}
TEST_CASE("ZoomGraphicsView updateProxyCacheMode toggles proxy and leaves connection uncached") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
WarpGraphModel model(tc.client.get());
QtNodes::BasicGraphicsScene scene(model);
TestZoomGraphicsView view(&scene);
auto *proxy = scene.addWidget(new QWidget());
REQUIRE(proxy != nullptr);
auto connection = makeConnectionGraphic(
scene,
QtNodes::ConnectionId{11u, 0u, 12u, 0u},
QPointF(10.0, 10.0),
QPointF(200.0, 90.0));
REQUIRE(connection != nullptr);
view.setupScale(1.6);
view.updateProxyCacheMode();
REQUIRE(proxy->cacheMode() == QGraphicsItem::DeviceCoordinateCache);
REQUIRE(connection->cacheMode() == QGraphicsItem::NoCache);
view.setupScale(1.0);
view.updateProxyCacheMode();
REQUIRE(proxy->cacheMode() == QGraphicsItem::NoCache);
REQUIRE(connection->cacheMode() == QGraphicsItem::NoCache);
}
TEST_CASE("ZoomGraphicsView mouse drag pans and release stops panning") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
WarpGraphModel model(tc.client.get());
QtNodes::BasicGraphicsScene scene(model);
TestZoomGraphicsView view(&scene);
view.resize(320, 200);
const int h0 = view.horizontalScrollBar()->value();
const int v0 = view.verticalScrollBar()->value();
QMouseEvent press(QEvent::MouseButtonPress, QPointF(30.0, 30.0),
QPointF(30.0, 30.0), Qt::LeftButton, Qt::LeftButton,
Qt::NoModifier);
view.dispatchMousePress(&press);
QMouseEvent move(QEvent::MouseMove, QPointF(80.0, 60.0), QPointF(80.0, 60.0),
Qt::NoButton, Qt::LeftButton, Qt::NoModifier);
view.dispatchMouseMove(&move);
const int h1 = view.horizontalScrollBar()->value();
const int v1 = view.verticalScrollBar()->value();
REQUIRE((h1 != h0 || v1 != v0));
QMouseEvent release(QEvent::MouseButtonRelease, QPointF(80.0, 60.0),
QPointF(80.0, 60.0), Qt::LeftButton, Qt::NoButton,
Qt::NoModifier);
view.dispatchMouseRelease(&release);
QMouseEvent afterReleaseMove(QEvent::MouseMove, QPointF(100.0, 90.0),
QPointF(100.0, 90.0), Qt::NoButton,
Qt::NoButton, Qt::NoModifier);
view.dispatchMouseMove(&afterReleaseMove);
REQUIRE(view.horizontalScrollBar()->value() == h1);
REQUIRE(view.verticalScrollBar()->value() == v1);
}
TEST_CASE("ZoomGraphicsView drawBackground renders grid over background") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
WarpGraphModel model(tc.client.get());
QtNodes::BasicGraphicsScene scene(model);
TestZoomGraphicsView view(&scene);
view.resize(320, 200);
view.setupScale(1.0);
auto const &style = QtNodes::StyleCollection::flowViewStyle();
QImage image(320, 200, QImage::Format_ARGB32_Premultiplied);
image.fill(style.BackgroundColor);
{
QPainter qp(&image);
view.dispatchDrawBackground(&qp, QRectF(0.0, 0.0, 320.0, 200.0));
}
REQUIRE(countPixelsDifferentFrom(image, style.BackgroundColor) > 0);
}
TEST_CASE("preset saves and loads volume state") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100650, "vol-preset", "Audio/Sink", {}, {}, true)).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100651, 100650, "FL", true)).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto qtId = model.qtNodeIdForPw(100650);
WarpGraphModel::NodeVolumeState ns;
ns.volume = 0.6f;
ns.mute = true;
model.setNodeVolumeState(qtId, ns);
QString path = QStandardPaths::writableLocation(
QStandardPaths::TempLocation) +
"/warppipe_test_vol_preset.json";
REQUIRE(PresetManager::savePreset(path, tc.client.get(), &model));
QFile file(path);
REQUIRE(file.open(QIODevice::ReadOnly));
QJsonDocument doc = QJsonDocument::fromJson(file.readAll());
file.close();
QJsonObject root = doc.object();
REQUIRE(root.contains("volumes"));
QJsonArray volArr = root["volumes"].toArray();
bool found = false;
for (const auto &val : volArr) {
QJsonObject obj = val.toObject();
if (obj["name"].toString() == "vol-preset") {
found = true;
REQUIRE(obj["volume"].toDouble() == Catch::Approx(0.6));
REQUIRE(obj["mute"].toBool());
}
}
REQUIRE(found);
tc.client->Test_SetNodeVolume(warppipe::NodeId{100650}, 1.0f, false);
WarpGraphModel model2(tc.client.get());
model2.refreshFromClient();
auto qtId2 = model2.qtNodeIdForPw(100650);
auto stateBefore = model2.nodeVolumeState(qtId2);
REQUIRE(stateBefore.volume == Catch::Approx(1.0f));
REQUIRE(PresetManager::loadPreset(path, tc.client.get(), &model2));
auto stateAfter = model2.nodeVolumeState(qtId2);
REQUIRE(stateAfter.volume == Catch::Approx(0.6f));
REQUIRE(stateAfter.mute);
QFile::remove(path);
}
TEST_CASE("AudioLevelMeter setLevel clamps to 0-1") {
ensureApp();
AudioLevelMeter meter;
meter.setLevel(0.5f);
REQUIRE(meter.level() == Catch::Approx(0.5f));
meter.setLevel(-0.5f);
REQUIRE(meter.level() == Catch::Approx(0.0f));
meter.setLevel(1.5f);
REQUIRE(meter.level() == Catch::Approx(1.0f));
}
TEST_CASE("AudioLevelMeter peak hold tracks maximum") {
ensureApp();
AudioLevelMeter meter;
meter.setLevel(0.8f);
REQUIRE(meter.peakHold() == Catch::Approx(0.8f));
meter.setLevel(0.3f);
REQUIRE(meter.peakHold() == Catch::Approx(0.8f));
meter.setLevel(0.9f);
REQUIRE(meter.peakHold() == Catch::Approx(0.9f));
}
TEST_CASE("AudioLevelMeter peak decays after hold period") {
ensureApp();
AudioLevelMeter meter;
meter.setLevel(0.5f);
REQUIRE(meter.peakHold() == Catch::Approx(0.5f));
for (int i = 0; i < 7; ++i)
meter.setLevel(0.0f);
REQUIRE(meter.peakHold() < 0.5f);
REQUIRE(meter.peakHold() > 0.0f);
}
TEST_CASE("AudioLevelMeter resetPeakHold clears peak") {
ensureApp();
AudioLevelMeter meter;
meter.setLevel(0.7f);
REQUIRE(meter.peakHold() == Catch::Approx(0.7f));
meter.resetPeakHold();
REQUIRE(meter.peakHold() == Catch::Approx(0.0f));
}
TEST_CASE("AudioLevelMeter reports expected size hints") {
ensureApp();
AudioLevelMeter meter;
REQUIRE(meter.sizeHint() == QSize(40, 160));
REQUIRE(meter.minimumSizeHint() == QSize(12, 40));
}
TEST_CASE("AudioLevelMeter paint at silence draws background only") {
ensureApp();
AudioLevelMeter meter;
meter.resetPeakHold();
meter.setLevel(0.0f);
QImage image = renderWidgetImage(meter, QSize(20, 120));
const QColor kBackground(24, 24, 28);
const QColor kGreen(76, 175, 80);
const QColor kYellow(255, 193, 7);
const QColor kRed(244, 67, 54);
const QColor kWhite(255, 255, 255);
REQUIRE(countColorPixels(image, kBackground) > 0);
REQUIRE(countColorPixels(image, kGreen) == 0);
REQUIRE(countColorPixels(image, kYellow) == 0);
REQUIRE(countColorPixels(image, kRed) == 0);
REQUIRE(countColorPixels(image, kWhite) == 0);
}
TEST_CASE("AudioLevelMeter paint at high level draws green yellow red and peak") {
ensureApp();
AudioLevelMeter meter;
meter.setLevel(0.95f);
QImage image = renderWidgetImage(meter, QSize(20, 120));
const QColor kGreen(76, 175, 80);
const QColor kYellow(255, 193, 7);
const QColor kRed(244, 67, 54);
const QColor kWhite(255, 255, 255);
REQUIRE(countColorPixels(image, kGreen) > 0);
REQUIRE(countColorPixels(image, kYellow) > 0);
REQUIRE(countColorPixels(image, kRed) > 0);
REQUIRE(countColorPixels(image, kWhite) > 0);
}
TEST_CASE("AudioLevelMeter paint after drop keeps peak line without bar") {
ensureApp();
AudioLevelMeter meter;
meter.setLevel(0.8f);
meter.setLevel(0.0f);
QImage image = renderWidgetImage(meter, QSize(20, 120));
const QColor kGreen(76, 175, 80);
const QColor kYellow(255, 193, 7);
const QColor kRed(244, 67, 54);
const QColor kWhite(255, 255, 255);
REQUIRE(countColorPixels(image, kGreen) == 0);
REQUIRE(countColorPixels(image, kYellow) == 0);
REQUIRE(countColorPixels(image, kRed) == 0);
REQUIRE(countColorPixels(image, kWhite) > 0);
}
TEST_CASE("GraphEditorWidget has METERS tab") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
GraphEditorWidget widget(tc.client.get());
auto *sidebar = widget.findChild<QTabWidget *>();
REQUIRE(sidebar != nullptr);
bool found = false;
for (int i = 0; i < sidebar->count(); ++i) {
if (sidebar->tabText(i) == "METERS") {
found = true;
break;
}
}
REQUIRE(found);
}
TEST_CASE("node meter rows created for injected nodes") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100700, "meter-node", "Audio/Sink")).ok());
REQUIRE(tc.client->Test_InsertPort(
MakePort(100701, 100700, "FL", true)).ok());
GraphEditorWidget widget(tc.client.get());
auto meters = widget.findChildren<AudioLevelMeter *>();
REQUIRE(meters.size() >= 3);
}
TEST_CASE("volume state cleaned up on node deletion") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100660, "vol-del", "Audio/Sink")).ok());
WarpGraphModel model(tc.client.get());
model.refreshFromClient();
auto qtId = model.qtNodeIdForPw(100660);
WarpGraphModel::NodeVolumeState ns;
ns.volume = 0.4f;
model.setNodeVolumeState(qtId, ns);
REQUIRE(tc.client->Test_RemoveGlobal(100660).ok());
model.refreshFromClient();
REQUIRE_FALSE(model.nodeExists(qtId));
auto state = model.nodeVolumeState(qtId);
REQUIRE(state.volume == Catch::Approx(1.0f));
REQUIRE_FALSE(state.mute);
}
TEST_CASE("GraphEditorWidget has RULES tab") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
GraphEditorWidget widget(tc.client.get());
auto *sidebar = widget.findChild<QTabWidget *>();
REQUIRE(sidebar != nullptr);
bool found = false;
for (int i = 0; i < sidebar->count(); ++i) {
if (sidebar->tabText(i) == "RULES") {
found = true;
break;
}
}
REQUIRE(found);
}
TEST_CASE("SetChangeCallback fires on node insert") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
std::atomic<int> count{0};
tc.client->SetChangeCallback([&count]() { ++count; });
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100800, "cb-test-node", "Audio/Sink")).ok());
REQUIRE(count.load() >= 1);
}
TEST_CASE("SetChangeCallback fires on node remove") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100810, "cb-remove-node", "Audio/Sink")).ok());
std::atomic<int> count{0};
tc.client->SetChangeCallback([&count]() { ++count; });
REQUIRE(tc.client->Test_RemoveGlobal(100810).ok());
REQUIRE(count.load() >= 1);
}
TEST_CASE("SetChangeCallback can be cleared") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
std::atomic<int> count{0};
tc.client->SetChangeCallback([&count]() { ++count; });
tc.client->SetChangeCallback(nullptr);
REQUIRE(tc.client->Test_InsertNode(
MakeNode(100820, "cb-clear-node", "Audio/Sink")).ok());
REQUIRE(count.load() == 0);
}
TEST_CASE("sidebar tab order is METERS MIXER PRESETS RULES") {
auto tc = TestClient::Create();
if (!tc.available()) { SUCCEED("PipeWire unavailable"); return; }
ensureApp();
GraphEditorWidget widget(tc.client.get());
auto *sidebar = widget.findChild<QTabWidget *>();
REQUIRE(sidebar != nullptr);
REQUIRE(sidebar->count() >= 4);
REQUIRE(sidebar->tabText(0) == "METERS");
REQUIRE(sidebar->tabText(1) == "MIXER");
REQUIRE(sidebar->tabText(2) == "PRESETS");
REQUIRE(sidebar->tabText(3) == "RULES");
}
Reference in a new issue View git blame Copy permalink