#include "Session.hpp" #include "UnitTest++/UnitTest++.h" #include #include #include #include using namespace tp; using namespace tp::sketch2d; namespace { struct PaintedDocument { Document document; Brush brush; ViewSettings settings; PaintedDocument() { brush.apply(*findBrushPreset(BrushType::Calligraphy)); brush.color = { 0.25f, 0.5f, 0.75f, 1 }; brush.setSize(37); brush.set(BrushParameter::Texture, 0.4f); brush.setUsesPressure(PressureTarget::Opacity, true); brush.setStabilizer(0.7f); brush.setEraserMode(true); brush.setMarkerBlend(true); Brush paint; paint.setSize(80); document.stampBrushDab({ 10, 10 }, paint); document.stampBrushDab({ 300, 40 }, paint); document.finishStroke(); Layer* top = document.addLayer("Ink \"top\""); top->setOpacity(0.5f); top->setBlend(BlendMode::Multiply); top->setAlphaLocked(true); document.stampBrushDab({ -50, 5 }, paint); document.finishStroke(); document.setZoom(2.5f); document.setPanWorld({ -120, 33 }); settings.useBrushStabilizer = false; settings.globalStabilizer = 0.4f; settings.viewStiffness = 0.75f; settings.showChannel = true; settings.channel = ViewChannel::Green; document.setBackground({ { 30, 0.2f, 0.3f }, true }); } SessionSnapshot capture() const { return SessionSnapshot::capture(document, brush, settings, { "abc", "Radeon", "today", { 1600, 1000 }, 1.25f }); } }; bool samePixels(const Document& left, const Document& right) { if (left.layers().size() != right.layers().size()) return false; for (size_t index = 0; index < left.layers().size(); index++) { const Layer& a = *left.layers()[index]; const Layer& b = *right.layers()[index]; if (a.tileCount() != b.tileCount()) return false; bool equal = true; a.forEachTile([&](const TileCoord& coord, Tile* tile) { const Tile* other = b.tileIfExists(coord); equal = equal && other && std::memcmp(tile->pixels(), other->pixels(), kTileSize * kTileSize * 4) == 0; }); if (!equal) return false; } return true; } } SUITE(Sketch2DSession) { TEST(SnapshotTextRoundTripsEveryRecordedSetting) { const PaintedDocument source; const std::optional parsed = SessionSnapshot::parse(source.capture().serialize()); REQUIRE CHECK(parsed.has_value()); CHECK(parsed->brush == source.brush); CHECK_EQUAL(2.5f, parsed->view.zoom); CHECK_EQUAL(-120.0f, parsed->view.pan.x); CHECK_EQUAL(1.25f, parsed->environment.contentScale); CHECK_EQUAL("Radeon", parsed->environment.device); CHECK(!parsed->settings.useBrushStabilizer); CHECK_EQUAL(0.4f, parsed->settings.globalStabilizer); CHECK_CLOSE(0.75f, parsed->settings.viewStiffness, 0.0001f); CHECK(parsed->settings.channel == ViewChannel::Green); CHECK(parsed->document.background == source.document.background()); REQUIRE CHECK_EQUAL(2u, parsed->document.layers.size()); const Layer::Properties& top = parsed->document.layers[1].properties; CHECK_EQUAL("Ink \"top\"", top.name); CHECK_EQUAL(0.5f, top.opacity); CHECK(top.blend == BlendMode::Multiply); CHECK(top.alphaLocked); CHECK_EQUAL(source.document.activeLayer()->id(), parsed->document.active); } TEST(SnapshotRejectsUnknownLines) { CHECK(!SessionSnapshot::parse("sketch2d-session 1\nwhat 1\n").has_value()); CHECK(!SessionSnapshot::parse("not a session\n").has_value()); CHECK(!SessionSnapshot::parse("sketch2d-session 1\nbrush.parameter nonsense 3\n").has_value()); } TEST(LayerTilesRoundTripExactly) { const PaintedDocument source; const Layer::State original = source.document.layers().front()->state(); Layer::State loaded; REQUIRE CHECK(parseLayerTiles(serializeLayerTiles(original), loaded)); CHECK_EQUAL(original.tiles.size(), loaded.tiles.size()); CHECK(!parseLayerTiles("garbage", loaded)); } std::string storedTiles(const std::string& header, int4 size, const std::vector& coords) { std::string bytes = header; for (size_t index = 0; index < coords.size(); index++) { const int32_t xy[2] = { coords[index].x, coords[index].y }; bytes.append(reinterpret_cast(xy), sizeof(xy)); std::string pixels((size_t) size * size * 4, '\0'); for (int4 y = 0; y < size; y++) for (int4 x = 0; x < size; x++) { const size_t at = ((size_t) y * size + x) * 4; pixels[at + 0] = (char) (index + 1); pixels[at + 1] = (char) (x % 256); pixels[at + 2] = (char) (y % 256); pixels[at + 3] = (char) 255; } bytes += pixels; } return bytes; } const uint1* storedPixel(const Layer::State& layer, int4 x, int4 y) { const TileCoord coord = { floordiv(x, kTileSize), floordiv(y, kTileSize) }; auto found = layer.tiles.presents(coord.key()); if (!found.isValid()) return nullptr; const Tile* tile = layer.tiles.getSlotVal(found).tile.get(); return tile->pixels() + ((size_t) (y - coord.y * kTileSize) * kTileSize + (size_t) (x - coord.x * kTileSize)) * 4; } TEST(LegacyTilesLoadAtAnyTileSize) { Layer::State loaded; REQUIRE CHECK(parseLayerTiles(storedTiles("sketch2d-tiles 1\n", 256, { { 0, 0 }, { -1, 2 } }), loaded)); for (const auto& [x, y, owner] : std::vector>{ { 0, 0, 1 }, { 255, 255, 1 }, { 130, 70, 1 }, { -256, 512, 2 }, { -1, 767, 2 }, { -100, 600, 2 } }) { const uint1* pixel = storedPixel(loaded, x, y); REQUIRE CHECK(pixel != nullptr); CHECK_EQUAL(owner, (int) pixel[0]); CHECK_EQUAL(((x % 256) + 256) % 256, (int) pixel[1]); CHECK_EQUAL(((y % 256) + 256) % 256, (int) pixel[2]); } CHECK(storedPixel(loaded, 300, 0) == nullptr || storedPixel(loaded, 300, 0)[3] == 0); const ualni expected = 2 * (ualni) std::max(1, 256 / kTileSize) * std::max(1, 256 / kTileSize); if (kTileSize <= 256) CHECK_EQUAL(expected, loaded.tiles.size()); } TEST(TilesOfAnotherSizeAreResliced) { Layer::State loaded; REQUIRE CHECK(parseLayerTiles(storedTiles("sketch2d-tiles 2 128\n", 128, { { 3, -2 } }), loaded)); Layer::State older; CHECK(parseLayerTiles(storedTiles("leo-tiles 2 128\n", 128, { { 3, -2 } }), older)); CHECK(parseLayerTiles(storedTiles("leo-tiles 1\n", 256, { { 0, 0 } }), older)); const uint1* pixel = storedPixel(loaded, 3 * 128 + 5, -2 * 128 + 7); REQUIRE CHECK(pixel != nullptr); CHECK_EQUAL(1, (int) pixel[0]); CHECK_EQUAL(5, (int) pixel[1]); CHECK_EQUAL(7, (int) pixel[2]); CHECK(!parseLayerTiles("sketch2d-tiles 2 0\n", loaded)); } TEST(SavedSessionRestoresTheSameDocumentViewAndBrush) { const PaintedDocument source; RecordedSession session; session.snapshot = source.capture(); session.input.windowSize = { 1600, 1000 }; session.input.events.push_back({ 3.5, PointerMoved{ { 40, 50 } } }); session.recordedFrames = "frame\twall\n0\t1.5\n"; const std::filesystem::path directory = std::filesystem::temp_directory_path() / "sketch2d-session-test"; std::filesystem::remove_all(directory); REQUIRE CHECK(session.save(directory.string())); const std::optional loaded = RecordedSession::load(directory.string()); REQUIRE CHECK(loaded.has_value()); CHECK_EQUAL(1u, loaded->input.events.size()); CHECK_EQUAL(session.recordedFrames, loaded->recordedFrames); Document document; Brush brush; ViewSettings settings; loaded->snapshot.applyTo(document, brush, settings); CHECK(samePixels(source.document, document)); CHECK(brush == source.brush); CHECK_EQUAL(2.5f, document.zoom()); CHECK_EQUAL(33.0f, document.panWorld().y); CHECK_EQUAL(1u, document.history().entries().size()); CHECK_EQUAL("Ink \"top\"", document.activeLayer()->name()); Layer* added = document.addLayer("after"); CHECK(added->id() > document.layers()[1]->id()); std::filesystem::remove_all(directory); } TEST(MissingLayerFileFailsTheLoad) { const PaintedDocument source; RecordedSession session; session.snapshot = source.capture(); const std::filesystem::path directory = std::filesystem::temp_directory_path() / "sketch2d-session-broken"; std::filesystem::remove_all(directory); REQUIRE CHECK(session.save(directory.string())); std::filesystem::remove_all(directory / "layers"); CHECK(!RecordedSession::load(directory.string()).has_value()); std::filesystem::remove_all(directory); } }