243 lines
14 KiB
C++
243 lines
14 KiB
C++
#include "MenuFixtures.h"
|
||
#include "UI/CommandPalette.h"
|
||
|
||
// The palette's search, model, menu reading and commands.
|
||
namespace {
|
||
CommandPaletteEntry entry(const QString &id, bool enabled = true)
|
||
{
|
||
return {.id = id, .title = id, .shortcut = std::nullopt, .isEnabled = enabled, .isOn = false, .perform = [] {}};
|
||
}
|
||
|
||
QStringList ids(const std::vector<CommandPaletteEntry> &entries)
|
||
{
|
||
QStringList result;
|
||
for (const CommandPaletteEntry &each : entries)
|
||
result << each.id;
|
||
return result;
|
||
}
|
||
|
||
const CommandPaletteEntry &titled(const std::vector<CommandPaletteEntry> &entries, const QString &title)
|
||
{
|
||
for (const CommandPaletteEntry &each : entries)
|
||
if (each.title == title)
|
||
return each;
|
||
throw std::runtime_error(title.toStdString() + " not listed");
|
||
}
|
||
}
|
||
|
||
class CommandPaletteTests : public QObject {
|
||
Q_OBJECT
|
||
private slots:
|
||
void lettersInOrderMatchAndWordStartsCount();
|
||
void scoresAreSwiftsOwn();
|
||
void rankingPutsTheBestAndEnabledFirst();
|
||
void wholeWordsBeatScatteredLetters();
|
||
void typedWordsStartingWords();
|
||
void theModelMovesAndWraps();
|
||
void aMenuBarReadsAsPaths();
|
||
void realMenuBarRunsItsCommands();
|
||
void layerCommandsAddAMask();
|
||
void toolsTakeTheirModes();
|
||
};
|
||
|
||
void CommandPaletteTests::lettersInOrderMatchAndWordStartsCount()
|
||
{
|
||
QVERIFY(CommandPaletteSearch::score("gb", "Filter › Gaussian Blur…"));
|
||
QVERIFY(CommandPaletteSearch::score("BLUR", "Filter › Gaussian Blur…"));
|
||
QVERIFY(!CommandPaletteSearch::score("bg", "Filter › Gaussian Blur…"));
|
||
QCOMPARE(CommandPaletteSearch::score("", "Anything").value(), 0);
|
||
QVERIFY(CommandPaletteSearch::score("gb", "Filter › Gaussian Blur…").value() > CommandPaletteSearch::score("gb", "Edit › Debug Tab").value());
|
||
}
|
||
|
||
void CommandPaletteTests::scoresAreSwiftsOwn()
|
||
{
|
||
// Swift 6.0.3 running v1.4.9's CommandPaletteSearch on each pair.
|
||
const std::vector<std::tuple<QString, QString, int>> cases{
|
||
{"gb", "Filter › Gaussian Blur…", 1001795}, {"gb", "Edit › Debug Tab", 1000196}, {"BLUR", "Filter › Gaussian Blur…", 4999995},
|
||
{"lasso", "Tool › Lasso", 4999997}, {"lasso", "Tool › Polygonal Lasso", 4999995},
|
||
{"lasso", "Layer › New Adjustment Layer › Hue/Saturation…", 1002589}, {"new layer", "Layer › New Blank Layer", 3999995},
|
||
{"new layer", "Layer › New Adjustment Layer › Curves…", 3999991}, {"ussian", "Filter › Gaussian Blur…", 2999995},
|
||
{"gaussianbl", "Filter › Gaussian Blur…", 1999995}, {" blur ", "Filter › Gaussian Blur…", 4999995}, {"2", "View › Zoom 2x", 4999997},
|
||
{"x2", "Layer › Box2", 2999997}, {"e u", "Edit › Undo", 3999998}, {"fl", "Layer › Flip Layer Horizontal", 4999993},
|
||
{"é", "Café › Crème", 2999997}, {"ab", "a1b c", 1000999}, {"b", "1b", 5000000}, {"mask", "Layer › Add Layer Mask (Hide All)", 4999992},
|
||
{"hide all", "Layer › Add Layer Mask (Hide All)", 4999992}, {"\tblur", "Filter › Gaussian Blur…", 4999995}, {"ab", "x-ab", 4999999},
|
||
{"lay mask", "Layer › Add Layer Mask", 3999995}, {"b a", "a bab", 1999999}, {"b a", "ab a", 2999999},
|
||
{"café", "File › Open Recent › Cafe\u0301", 4999994}, {"cafe\u0301", "File › Open Recent › Café", 4999994},
|
||
{"café", "File › Open Recent › Café", 4999994}, {"e\u0301", "File › Open Recent › Café", 2999994}};
|
||
for (const auto &[query, title, score] : cases)
|
||
QVERIFY2(CommandPaletteSearch::score(query, title).value() == score, qPrintable(query + " in " + title));
|
||
QVERIFY(!CommandPaletteSearch::score("new layer", "Layer › Duplicate Layer"));
|
||
}
|
||
|
||
void CommandPaletteTests::rankingPutsTheBestAndEnabledFirst()
|
||
{
|
||
const std::vector<CommandPaletteEntry> entries{entry("Edit › Paste"), entry("Layer › Flip Layer Horizontal"), entry("Filter › Gaussian Blur…"),
|
||
entry("Filter › Motion Blur…"), entry("Edit › Undo", false), entry("Image › Levels…")};
|
||
QCOMPARE(ids(CommandPaletteSearch::rank(entries, "gau")).value(0), QString("Filter › Gaussian Blur…"));
|
||
// Equal scores keep menu order.
|
||
QCOMPARE(ids(CommandPaletteSearch::rank(entries, "blur")), (QStringList{"Filter › Gaussian Blur…", "Filter › Motion Blur…"}));
|
||
QCOMPARE(ids(CommandPaletteSearch::rank(entries, "fl")).value(0), QString("Layer › Flip Layer Horizontal"));
|
||
QCOMPARE(ids(CommandPaletteSearch::rank(entries, "")),
|
||
(QStringList{"Edit › Paste", "Layer › Flip Layer Horizontal", "Filter › Gaussian Blur…", "Filter › Motion Blur…", "Image › Levels…", "Edit › Undo"}));
|
||
// Disabled after enabled, whatever it scores.
|
||
QCOMPARE(ids(CommandPaletteSearch::rank(entries, "e u")).last(), QString("Edit › Undo"));
|
||
QCOMPARE(ids(CommandPaletteSearch::rank({entry("Edit › Undo", false), entry("Layer › Merge Layers")}, "e")),
|
||
(QStringList{"Layer › Merge Layers", "Edit › Undo"}));
|
||
}
|
||
|
||
void CommandPaletteTests::wholeWordsBeatScatteredLetters()
|
||
{
|
||
const std::vector<CommandPaletteEntry> entries{entry("Layer › New Adjustment Layer › Hue/Saturation…"), entry("Tool › Lasso"), entry("Tool › Polygonal Lasso")};
|
||
QCOMPARE(ids(CommandPaletteSearch::rank(entries, "lasso")), (QStringList{"Tool › Lasso", "Tool › Polygonal Lasso", "Layer › New Adjustment Layer › Hue/Saturation…"}));
|
||
CommandPaletteModel model(entries);
|
||
model.setQuery("lasso");
|
||
model.move(1);
|
||
// Return writes the same text back: the choice stays.
|
||
model.setQuery("lasso");
|
||
QCOMPARE(model.selected().value().id, QString("Tool › Polygonal Lasso"));
|
||
model.setQuery("lass");
|
||
QCOMPARE(model.selection, 0);
|
||
}
|
||
|
||
void CommandPaletteTests::typedWordsStartingWords()
|
||
{
|
||
const std::vector<CommandPaletteEntry> entries{entry("Layer › New Adjustment Layer › Curves…"), entry("Layer › New Adjustment Layer › Exposure…"),
|
||
entry("Layer › Duplicate Layer"), entry("Layer › New Blank Layer")};
|
||
QCOMPARE(ids(CommandPaletteSearch::rank(entries, "new layer")).value(0), QString("Layer › New Blank Layer"));
|
||
}
|
||
|
||
void CommandPaletteTests::theModelMovesAndWraps()
|
||
{
|
||
CommandPaletteModel model({entry("A"), entry("B"), entry("C")});
|
||
model.move(-1);
|
||
QCOMPARE(model.selection, 2);
|
||
model.move(1);
|
||
QCOMPARE(model.selection, 0);
|
||
model.move(4);
|
||
QCOMPARE(model.selected().value().id, QString("B"));
|
||
model.setQuery("zzz");
|
||
QVERIFY(!model.selected());
|
||
model.move(1);
|
||
QCOMPARE(model.selection, 0);
|
||
}
|
||
|
||
void CommandPaletteTests::aMenuBarReadsAsPaths()
|
||
{
|
||
QMenuBar bar;
|
||
QMenu *filter = bar.addMenu("Fil&ter");
|
||
QAction *blur = filter->addAction("&Gaussian Blur…");
|
||
blur->setShortcut(QKeySequence(Qt::CTRL | Qt::ALT | Qt::Key_P));
|
||
filter->addSeparator();
|
||
filter->addSection("Section");
|
||
filter->addAction("Black && White…")->setEnabled(false);
|
||
filter->addAction("Hidden")->setVisible(false);
|
||
QAction *grid = filter->addMenu("Show")->addAction("Grid");
|
||
grid->setCheckable(true);
|
||
grid->setChecked(true);
|
||
filter->addAction("Twin");
|
||
filter->addAction("Twin");
|
||
filter->addAction("Search Commands…");
|
||
bar.addMenu("Skipped")->addAction("Inside");
|
||
const std::vector<CommandPaletteEntry> entries = CommandPaletteMenu::entries(bar, {"Search Commands…", "Skipped"});
|
||
QCOMPARE(ids(entries), (QStringList{"Filter › Gaussian Blur…", "Filter › Black & White…", "Filter › Show › Grid", "Filter › Twin", "Filter › Twin (2)"}));
|
||
QCOMPARE(entries[0].shortcut.value(), QKeySequence(Qt::CTRL | Qt::ALT | Qt::Key_P).toString(QKeySequence::NativeText));
|
||
QVERIFY(!entries[1].shortcut && !entries[1].isEnabled && entries[0].isEnabled);
|
||
QVERIFY(entries[2].isOn && !entries[0].isOn);
|
||
QCOMPARE(entries[4].title, QString("Filter › Twin"));
|
||
// An entry triggers its own action; a gone one warns.
|
||
QSignalSpy triggered(blur, &QAction::triggered);
|
||
entries[0].perform();
|
||
QCOMPARE(triggered.count(), 1);
|
||
delete blur;
|
||
QTest::ignoreMessage(QtWarningMsg, "palette: menu entry gone: \"Filter › Gaussian Blur…\"");
|
||
entries[0].perform();
|
||
QCOMPARE(CommandPaletteMenu::plain("A&&&B&"), QString("A&B"));
|
||
}
|
||
|
||
void CommandPaletteTests::realMenuBarRunsItsCommands()
|
||
{
|
||
Bar bar;
|
||
const auto read = [&] { return CommandPaletteMenu::entries(*bar.window.menuBar(), {"Search Commands…"}); };
|
||
const std::vector<CommandPaletteEntry> listed = read();
|
||
QVERIFY(std::ranges::none_of(listed, [](const CommandPaletteEntry &e) { return e.title == "View › Search Commands…"; }));
|
||
QVERIFY(titled(listed, "Filter › Gaussian Blur…").title == "Filter › Gaussian Blur…");
|
||
QVERIFY(!titled(listed, "View › Zoom In").isEnabled);
|
||
QCOMPARE(titled(listed, "View › Fit Canvas").shortcut.value(), QKeySequence(Qt::CTRL | Qt::Key_0).toString(QKeySequence::NativeText));
|
||
QCOMPARE(titled(listed, "Image › Black & White…").title, QString("Image › Black & White…"));
|
||
const CommandPaletteEntry grid = titled(listed, "View › Pixel Grid (800% and above)");
|
||
QVERIFY(grid.isOn && bar.session().showsPixelGrid());
|
||
grid.perform();
|
||
QVERIFY(!bar.session().showsPixelGrid() && !titled(read(), grid.title).isOn);
|
||
grid.perform();
|
||
QVERIFY(bar.session().showsPixelGrid());
|
||
}
|
||
|
||
void CommandPaletteTests::layerCommandsAddAMask()
|
||
{
|
||
EditorSession session;
|
||
std::vector<CommandPaletteEntry> commands = CommandPaletteCommands::layerCommands(session);
|
||
QCOMPARE(ids(commands), (QStringList{"Layer › Add Layer Mask", "Layer › Add Layer Mask (Hide All)"}));
|
||
QVERIFY(!commands[0].isEnabled && !commands[1].isEnabled);
|
||
session.createDocument(4, 4);
|
||
session.insert(white(), QPointF(2, 2));
|
||
session.selectAll();
|
||
commands = CommandPaletteCommands::layerCommands(session);
|
||
QCOMPARE(ids(commands), (QStringList{"Layer › Add Layer Mask from Selection", "Layer › Add Layer Mask Hiding Selection"}));
|
||
QVERIFY(commands[0].isEnabled && commands[1].isEnabled);
|
||
commands[1].perform();
|
||
QCOMPARE(session.history.undoName(), QString("Hide Selection"));
|
||
QVERIFY(!CommandPaletteCommands::layerCommands(session)[0].isEnabled);
|
||
session.undo();
|
||
session.deselect();
|
||
CommandPaletteCommands::layerCommands(session)[0].perform();
|
||
QCOMPARE(session.history.undoName(), QString("Add Reveal-All Mask"));
|
||
}
|
||
|
||
void CommandPaletteTests::toolsTakeTheirModes()
|
||
{
|
||
EditorSession session;
|
||
std::vector<CommandPaletteEntry> tools = CommandPaletteCommands::tools(session);
|
||
QCOMPARE(tools.size(), size_t(23));
|
||
QCOMPARE(tools[0].id, QString("Tool › Move / Transform"));
|
||
QCOMPARE(tools[4].shortcut.value(), QString("L"));
|
||
QVERIFY(std::ranges::none_of(tools, [](const CommandPaletteEntry &e) { return e.isEnabled; }));
|
||
session.createDocument(4, 4);
|
||
tools = CommandPaletteCommands::tools(session);
|
||
QVERIFY(std::ranges::all_of(tools, [](const CommandPaletteEntry &e) { return e.isEnabled; }));
|
||
// Each named mode, reached from its sibling.
|
||
const std::vector<std::tuple<QString, NavigationTool, std::function<bool()>>> modes{
|
||
{"Polygonal Lasso", NavigationTool::lasso, [&] { return session.lassoKind() == LassoKind::polygonal; }},
|
||
{"Lasso", NavigationTool::lasso, [&] { return session.lassoKind() == LassoKind::freehand; }},
|
||
{"Elliptical Marquee", NavigationTool::marquee, [&] { return session.marqueeKind() == LassoKind::ellipse; }},
|
||
{"Rectangular Marquee", NavigationTool::marquee, [&] { return session.marqueeKind() == LassoKind::rectangle; }},
|
||
{"Object Selection", NavigationTool::wand, [&] { return session.wandMode() == WandMode::object; }},
|
||
{"Magic Wand", NavigationTool::wand, [&] { return session.wandMode() == WandMode::wand; }},
|
||
{"Eraser", NavigationTool::brush, [&] { return session.brushMode() == BrushToolMode::erase; }},
|
||
{"Brush", NavigationTool::brush, [&] { return session.brushMode() == BrushToolMode::paint; }},
|
||
{"Blur", NavigationTool::blur, [&] { return session.blurMode() == BlurToolMode::blur; }},
|
||
{"Smudge", NavigationTool::blur, [&] { return session.blurMode() == BlurToolMode::smudge; }},
|
||
{"Liquify", NavigationTool::blur, [&] { return session.blurMode() == BlurToolMode::liquify; }},
|
||
{"Ellipse", NavigationTool::shape, [&] { return session.shapeKind() == ShapeKind::ellipse; }},
|
||
{"Rectangle", NavigationTool::shape, [&] { return session.shapeKind() == ShapeKind::rectangle; }},
|
||
{"Line", NavigationTool::shape, [&] { return session.shapeKind() == ShapeKind::line; }},
|
||
{"Move / Transform", NavigationTool::move, [] { return true; }}, {"Crop", NavigationTool::crop, [] { return true; }},
|
||
{"Spot Healing Brush", NavigationTool::spotHealing, [] { return true; }}, {"Clone Stamp", NavigationTool::cloneStamp, [] { return true; }},
|
||
{"Gradient", NavigationTool::gradient, [] { return true; }}, {"Type", NavigationTool::type, [] { return true; }},
|
||
{"Eyedropper", NavigationTool::eyedropper, [] { return true; }}, {"Hand", NavigationTool::hand, [] { return true; }}};
|
||
for (const auto &[name, tool, holds] : modes) {
|
||
titled(tools, "Tool › " + name).perform();
|
||
QVERIFY2(session.tool() == tool && holds(), qPrintable(name));
|
||
}
|
||
titled(tools, "Tool › Zoom").perform();
|
||
QVERIFY(session.tool() == NavigationTool::zoom);
|
||
// A refused tool change leaves the mode alone.
|
||
session.insert(white(), QPointF(2, 2));
|
||
session.beginLevels();
|
||
QVERIFY(session.levels());
|
||
titled(tools, "Tool › Rectangle").perform();
|
||
QVERIFY(session.tool() == NavigationTool::zoom && session.shapeKind() == ShapeKind::line);
|
||
}
|
||
|
||
QTEST_MAIN(CommandPaletteTests)
|
||
#include "CommandPaletteTests.moc"
|