ZacharyZhang-NY/OmaPhoto
1
1 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity
Files
bc9d43f1e8654e636aaf0c62319768d0ffe02eca
OmaPhoto/tests/EditorSessionTests.cpp
T

449 lines
18 KiB
C++
Raw Blame History

#include "Document/EditorSession.h"
#include "SessionFixtures.h"
#include <QtTest>
namespace {
ImportedImage asset(int width, int height, const QString &name)
{
return ImportedImage(QImage(width, height, QImage::Format_RGBA8888_Premultiplied), QImage(), name);
}
QStringList names(const EditorSession &session)
{
QStringList result;
for (const ImageLayer &layer : session.document().value().layers)
result << layer.name;
return result;
}
ImageLayer layerNamed(const EditorSession &session, const QString &name)
{
for (const ImageLayer &layer : session.document().value().layers) {
if (layer.name == name)
return layer;
}
throw std::runtime_error("no layer named " + name.toStdString());
}
}
class EditorSessionTests : public QObject {
Q_OBJECT
private slots:
void settersKeepExactlyWhatTheyAreGiven();
void theSelectionFollowsTheActiveLayer();
void aBusyProjectKeepsItsTool();
void tabSwitchesEachToolsShapeOrMode();
void everyGateClosesLayerEdits_data();
void everyGateClosesLayerEdits();
void theFirstImageMakesTheCanvas();
void imagesLandCentredOnWholePixels();
void newLayersJoinTheActiveFolder();
void foldersAreNamedPlacedAndLimited();
void aWideFolderIsWalkedOnce();
void foldingAFolderTakesTheSelectionFromItsContents();
void deletingAFolderTakesItsContents();
void movingStaysAmongSiblings();
void aNewCanvasCanStartWithALayer();
void sessionChangesAreLogged();
};
void EditorSessionTests::settersKeepExactlyWhatTheyAreGiven()
{
EditorSession session;
const auto flags = [&] {
return QList<bool>{session.isProjectBusy(), session.showsNewDocument(), session.showsImporter(), session.isImporting()};
};
QCOMPARE(flags(), (QList<bool>{false, false, false, false}));
QVERIFY(!session.importError().has_value() && !session.renamingLayerID().has_value());
// Each flag is its own.
session.setIsProjectBusy(true);
QCOMPARE(flags(), (QList<bool>{true, false, false, false}));
session.setIsProjectBusy(false);
session.setShowsNewDocument(true);
QCOMPARE(flags(), (QList<bool>{false, true, false, false}));
session.setShowsNewDocument(false);
session.setShowsImporter(true);
QCOMPARE(flags(), (QList<bool>{false, false, true, false}));
session.setShowsImporter(false);
session.setIsImporting(true);
QCOMPARE(flags(), (QList<bool>{false, false, false, true}));
session.setIsImporting(false);
QCOMPARE(flags(), (QList<bool>{false, false, false, false}));
const QUuid first = QUuid::createUuid(), second = QUuid::createUuid();
session.setRenamingLayerID(first);
session.setImportError(QString("first.png: unreadable"));
QCOMPARE(session.renamingLayerID(), std::optional(first));
QCOMPARE(session.importError(), std::optional(QString("first.png: unreadable")));
session.setRenamingLayerID(second);
session.setImportError(QString("second.png: too large"));
QCOMPARE(session.renamingLayerID(), std::optional(second));
QCOMPARE(session.importError(), std::optional(QString("second.png: too large")));
session.setRenamingLayerID(std::nullopt);
session.setImportError(std::nullopt);
QVERIFY(!session.importError().has_value() && !session.renamingLayerID().has_value());
QCOMPARE(flags(), (QList<bool>{false, false, false, false}));
}
void EditorSessionTests::theSelectionFollowsTheActiveLayer()
{
EditorSession session;
session.createDocument(64, 64);
QCOMPARE(session.selectedLayerIDs(), QSet<QUuid>());
QVERIFY(!session.activeLayer().has_value());
session.addBlankLayer();
const QUuid first = session.activeLayerID().value();
session.addBlankLayer();
QCOMPARE(session.selectedLayerIDs(), QSet<QUuid>{session.activeLayerID().value()});
session.selectLayer(first);
QCOMPARE(session.selectedLayerIDs(), QSet<QUuid>{first});
QCOMPARE(session.activeLayer().value().name, QString("Layer 1"));
session.selectLayer(std::nullopt);
QCOMPARE(session.selectedLayerIDs(), QSet<QUuid>());
// An id the document does not hold selects no layer.
session.setActiveLayerID(QUuid::createUuid());
QVERIFY(!session.activeLayer().has_value());
}
void EditorSessionTests::aBusyProjectKeepsItsTool()
{
EditorSession session;
QCOMPARE(session.tool(), NavigationTool::move);
session.selectTool(NavigationTool::hand);
QCOMPARE(session.tool(), NavigationTool::hand);
session.setIsProjectBusy(true);
session.selectTool(NavigationTool::zoom);
QCOMPARE(session.tool(), NavigationTool::hand);
}
void EditorSessionTests::everyGateClosesLayerEdits_data()
{
QTest::addColumn<int>("gate");
QTest::newRow("a busy project") << 0;
QTest::newRow("an import") << 1;
QTest::newRow("the new canvas sheet") << 2;
QTest::newRow("the importer") << 3;
QTest::newRow("a rename") << 4;
}
void EditorSessionTests::everyGateClosesLayerEdits()
{
QFETCH(int, gate);
EditorSession session;
QVERIFY(!session.canEditLayers());
session.createDocument(64, 64);
session.addBlankLayer();
QVERIFY(session.canEditLayers());
const auto set = [&](bool on) {
if (gate == 0)
session.setIsProjectBusy(on);
else if (gate == 1)
session.setIsImporting(on);
else if (gate == 2)
session.setShowsNewDocument(on);
else if (gate == 3)
session.setShowsImporter(on);
else
session.setRenamingLayerID(on ? std::optional(QUuid::createUuid()) : std::nullopt);
};
set(true);
QVERIFY(!session.canEditLayers());
session.addBlankLayer();
QCOMPARE(int(session.document().value().layers.size()), 1);
set(false);
QVERIFY(session.canEditLayers());
// An import error stops history, not layer edits.
session.setImportError(QString("failed"));
QVERIFY(session.canEditLayers() && !session.canUseHistory());
}
void EditorSessionTests::tabSwitchesEachToolsShapeOrMode()
{
EditorSession session;
session.createDocument(20, 20);
session.addBlankLayer();
session.selectTool(NavigationTool::marquee);
session.cycleToolMode();
QCOMPARE(session.marqueeKind(), LassoKind::ellipse);
session.selectTool(NavigationTool::lasso);
session.cycleToolMode();
QCOMPARE(session.lassoKind(), LassoKind::polygonal);
session.cycleToolMode();
QCOMPARE(session.lassoKind(), LassoKind::freehand);
QCOMPARE(session.marqueeKind(), LassoKind::ellipse);
session.selectTool(NavigationTool::brush);
session.cycleToolMode();
QCOMPARE(session.brushMode(), BrushToolMode::erase);
// Busy or mid-stroke, nothing switches, and nothing is said.
QSignalSpy changes(&session, &EditorSession::changed);
session.setIsProjectBusy(true);
changes.clear();
session.cycleToolMode();
session.setIsProjectBusy(false);
session.beginBrush(QPointF(5, 5));
changes.clear();
session.cycleToolMode();
QCOMPARE(changes.count(), 0);
QCOMPARE(session.brushMode(), BrushToolMode::erase);
session.cancelBrush();
// A tool without modes stays silent.
session.selectTool(NavigationTool::hand);
changes.clear();
session.cycleToolMode();
QCOMPARE(changes.count(), 0);
}
void EditorSessionTests::theFirstImageMakesTheCanvas()
{
EditorSession session;
session.viewport.resize(QSizeF(400, 300), 1, std::nullopt);
session.viewport.setZoom(3, session.viewport.center(), QSizeF(64, 32));
session.insert(asset(64, 32, "First"), QPointF(999, 999));
const CanvasDocument document = session.document().value();
QCOMPARE(document.size(), QSizeF(64, 32));
QVERIFY(session.viewport.followsFit());
QCOMPARE(session.history.undoName(), QString("Import Image"));
// The drop point still places the layer.
QCOMPARE(document.layers[0].origin(), QPointF(967, 983));
QCOMPARE(session.activeLayerID(), std::optional(document.layers[0].id));
session.undo();
QVERIFY(!session.document().has_value());
}
void EditorSessionTests::imagesLandCentredOnWholePixels()
{
EditorSession session;
session.createDocument(101, 51);
session.insert(asset(64, 32, "Centred"));
// Half pixels fall to the left and up.
QCOMPARE(session.activeLayer().value().origin(), QPointF(18, 9));
QCOMPARE(session.activeLayer().value().size(), QSizeF(64, 32));
// Odd in odd centres exactly: both halves count.
session.insert(asset(65, 33, "Odd"));
QCOMPARE(session.activeLayer().value().origin(), QPointF(18, 9));
session.insert(asset(64, 33, "Dropped"), QPointF(10.25, -4.5));
QCOMPARE(session.activeLayer().value().origin(), QPointF(-22, -21));
QCOMPARE(names(session), (QStringList{"Centred", "Odd", "Dropped"}));
QCOMPARE(session.document().value().size(), QSizeF(101, 51));
}
void EditorSessionTests::newLayersJoinTheActiveFolder()
{
EditorSession session;
session.createDocument(64, 64);
session.addBlankLayer();
session.addGroup();
const QUuid folder = session.activeLayerID().value();
session.addBlankLayer();
QCOMPARE(session.activeLayer().value().parentID, std::optional(folder));
// Beside a layer in the folder, the next joins it.
session.addBlankLayer();
QCOMPARE(session.activeLayer().value().parentID, std::optional(folder));
session.insert(asset(4, 4, "Image"));
QCOMPARE(session.activeLayer().value().parentID, std::optional(folder));
session.selectLayer(folder);
session.toggleGroupExpansion(folder);
QVERIFY(session.collapsedGroupIDs().contains(folder));
// Filling a folded folder opens it, above all it holds.
session.addBlankLayer();
QVERIFY(!session.collapsedGroupIDs().contains(folder));
QCOMPARE(names(session), (QStringList{"Layer 1", "Folder 1", "Layer 2", "Layer 3", "Image", "Layer 4"}));
session.selectLayer(folder);
session.toggleGroupExpansion(folder);
session.insert(asset(4, 4, "Inside"));
QVERIFY(!session.collapsedGroupIDs().contains(folder));
QCOMPARE(session.activeLayer().value().parentID, std::optional(folder));
// A nested folder's contents count as the outer folder's.
session.addGroup();
const QUuid inner = session.activeLayerID().value();
session.addBlankLayer();
QCOMPARE(session.activeLayer().value().parentID, std::optional(inner));
session.selectLayer(folder);
session.addBlankLayer();
QCOMPARE(names(session).last(), QString("Layer 6"));
QCOMPARE(session.activeLayer().value().parentID, std::optional(folder));
session.selectLayer(std::nullopt);
session.insert(asset(4, 4, "Outside"));
QCOMPARE(session.activeLayer().value().parentID, std::nullopt);
}
void EditorSessionTests::foldersAreNamedPlacedAndLimited()
{
EditorSession session;
session.createDocument(64, 64);
session.addBlankLayer();
session.addBlankLayer();
session.selectLayer(session.document().value().layers[0].id);
session.addGroup();
QCOMPARE(names(session), (QStringList{"Layer 1", "Folder 1", "Layer 2"}));
QCOMPARE(session.history.undoName(), QString("New Folder"));
const ImageLayer folder = session.activeLayer().value();
QVERIFY(folder.isGroup && !folder.asset.has_value());
QCOMPARE(folder.size(), QSizeF(64, 64));
QCOMPARE(folder.parentID, std::nullopt);
// Each new folder nests in the active one, 64 deep.
for (int depth = 0; depth < 70; ++depth)
session.addGroup();
QCOMPARE(int(session.document().value().layers.size()), 2 + 64);
QCOMPARE(session.activeLayer().value().name, QString("Folder 64"));
session.toggleGroupExpansion(folder.id);
QCOMPARE(session.activeLayerID(), std::optional(folder.id));
session.addGroup();
QVERIFY(!session.collapsedGroupIDs().contains(folder.id));
// Ten thousand layers leave no room for a folder.
EditorSession crowded;
crowded.createDocument(8, 8);
crowded.beginEdit("Fill");
const ImportedImage dot = asset(1, 1, "Dot");
for (int index = 0; index < 9'999; ++index)
crowded.insert(dot);
crowded.endEdit();
crowded.addGroup();
QCOMPARE(int(crowded.document().value().layers.size()), 10'000);
crowded.addGroup();
QCOMPARE(int(crowded.document().value().layers.size()), 10'000);
}
void EditorSessionTests::aWideFolderIsWalkedOnce()
{
EditorSession session;
session.createDocument(8, 8);
session.addGroup();
const QUuid folder = session.activeLayerID().value();
session.beginEdit("Fill");
const ImportedImage dot = asset(1, 1, "Dot");
for (int index = 0; index < 9'999; ++index) {
session.selectLayer(folder);
session.insert(dot);
}
session.endEdit();
// Copying the layers for each child would take minutes.
QElapsedTimer timer;
timer.start();
QCOMPARE(int(session.descendantIDs(folder).size()), 9'999);
QVERIFY2(timer.elapsed() < 2'000, qPrintable(QString::number(timer.elapsed())));
}
void EditorSessionTests::foldingAFolderTakesTheSelectionFromItsContents()
{
EditorSession session;
session.createDocument(64, 64);
session.addBlankLayer();
const QUuid outside = session.activeLayerID().value();
session.addGroup();
const QUuid folder = session.activeLayerID().value();
session.addGroup();
const QUuid inner = session.activeLayerID().value();
session.addBlankLayer();
const QUuid deep = session.activeLayerID().value();
QCOMPARE(session.descendantIDs(folder), (QSet<QUuid>{inner, deep}));
QCOMPARE(session.descendantIDs(inner), QSet<QUuid>{deep});
QCOMPARE(session.descendantIDs(deep), QSet<QUuid>());
QCOMPARE(session.descendantIDs(QUuid::createUuid()), QSet<QUuid>());
QCOMPARE(EditorSession().descendantIDs(folder), QSet<QUuid>());
session.toggleGroupExpansion(folder);
QCOMPARE(session.activeLayerID(), std::optional(folder));
QCOMPARE(session.collapsedGroupIDs(), QSet<QUuid>{folder});
session.toggleGroupExpansion(folder);
QCOMPARE(session.collapsedGroupIDs(), QSet<QUuid>());
// A selection outside stays; layers and strangers do not fold.
session.selectLayer(outside);
session.toggleGroupExpansion(inner);
QCOMPARE(session.activeLayerID(), std::optional(outside));
session.toggleGroupExpansion(outside);
session.toggleGroupExpansion(QUuid::createUuid());
QCOMPARE(session.collapsedGroupIDs(), QSet<QUuid>{inner});
session.setIsProjectBusy(true);
session.toggleGroupExpansion(inner);
QCOMPARE(session.collapsedGroupIDs(), QSet<QUuid>{inner});
}
void EditorSessionTests::deletingAFolderTakesItsContents()
{
EditorSession session;
session.createDocument(64, 64);
session.addBlankLayer();
session.addGroup();
const QUuid folder = session.activeLayerID().value();
session.addBlankLayer();
session.addGroup();
session.addBlankLayer();
session.selectLayer(std::nullopt);
session.addBlankLayer();
QCOMPARE(names(session), (QStringList{"Layer 1", "Folder 1", "Layer 2", "Folder 2", "Layer 3", "Layer 4"}));
session.selectLayer(layerNamed(session, "Layer 3").id);
const int count = session.history.undoCount();
session.deleteLayer(folder);
QCOMPARE(names(session), (QStringList{"Layer 1", "Layer 4"}));
// The folder sat at index 1; its successor is selected.
QCOMPARE(session.activeLayer().value().name, QString("Layer 4"));
QCOMPARE(session.history.undoCount(), count + 1);
session.undo();
QCOMPARE(int(session.document().value().layers.size()), 6);
QCOMPARE(session.activeLayer().value().name, QString("Layer 3"));
// Deleting something else leaves the selection alone.
session.deleteLayer(layerNamed(session, "Layer 4").id);
QCOMPARE(session.activeLayer().value().name, QString("Layer 3"));
}
void EditorSessionTests::movingStaysAmongSiblings()
{
EditorSession session;
session.createDocument(64, 64);
session.addBlankLayer();
session.addGroup();
session.addBlankLayer();
session.addBlankLayer();
session.selectLayer(std::nullopt);
session.addBlankLayer();
QCOMPARE(names(session), (QStringList{"Layer 1", "Folder 1", "Layer 2", "Layer 3", "Layer 4"}));
// Layer 4's siblings: Layer 1 and the folder, both below.
QVERIFY(session.canMoveActiveLayer(-2) && !session.canMoveActiveLayer(-3) && !session.canMoveActiveLayer(1));
session.moveActiveLayer(-1);
QCOMPARE(names(session), (QStringList{"Layer 1", "Layer 4", "Layer 2", "Layer 3", "Folder 1"}));
// Inside the folder two layers trade places and no more.
session.selectLayer(layerNamed(session, "Layer 2").id);
QVERIFY(session.canMoveActiveLayer(1) && !session.canMoveActiveLayer(-1) && !session.canMoveActiveLayer(2));
session.moveActiveLayer(1);
QCOMPARE(names(session), (QStringList{"Layer 1", "Layer 4", "Layer 3", "Layer 2", "Folder 1"}));
session.selectLayer(std::nullopt);
QVERIFY(!session.canMoveActiveLayer(0));
}
void EditorSessionTests::aNewCanvasCanStartWithALayer()
{
EditorSession session;
session.setShowsNewDocument(true);
session.setRenamingLayerID(QUuid::createUuid());
session.createDocument(640, 480, true);
const CanvasDocument document = session.document().value();
QCOMPARE(int(document.layers.size()), 1);
QCOMPARE(session.activeLayer().value().name, QString("Layer 1"));
QVERIFY(!session.activeLayer().value().asset.has_value());
QCOMPARE(session.activeLayer().value().size(), QSizeF(640, 480));
QVERIFY(!session.showsNewDocument() && !session.renamingLayerID().has_value());
QCOMPARE(document.resolution, 72.0);
// A plain canvas selects nothing; busy or importing makes none.
session.createDocument(10, 10);
QVERIFY(!session.activeLayerID().has_value() && session.document().value().layers.empty());
session.setIsProjectBusy(true);
session.createDocument(20, 20);
session.setIsProjectBusy(false);
session.setIsImporting(true);
session.createDocument(30, 30);
QCOMPARE(session.document().value().size(), QSizeF(10, 10));
}
void EditorSessionTests::sessionChangesAreLogged()
{
EditorSession session;
QTest::ignoreMessage(QtInfoMsg, "new canvas 12 x 34");
session.createDocument(12, 34);
session.addBlankLayer();
QTest::ignoreMessage(QtInfoMsg, "restored a history snapshot of 0 layers");
session.undo();
}
// Alt-dragging a row drops a duplicate, one step.
QTEST_GUILESS_MAIN(EditorSessionTests)
#include "EditorSessionTests.moc"
Reference in new issue View Git Blame Copy Permalink