Modules/GraphicApplication/tests/CanvasTests.cpp
agent b552d7c324 Port agent-work onto master
Brings the agent-work branch tip onto master, keeping master's architecture
and putting every agent-work feature on top of it: the window/GpuDevice/
RenderTarget split, explicit per-instance profilers instead of a global, the
input layer with scroll sources and ends, the Widgets core and components
(shared SelectionModel/Commands lists, popup stack, titled panels, prompt
dialogs, file browser, kanban, outline tree, markdown, docking), the gallery
on the new UI, the Objects explorer and interpreter fixes, the Taskboard, the
Sketch2D render path and its tests and bench, and the headless Wayland
runner the UI tests drive.

No MODULES_BUILD_* switches are introduced: platform differences are plain
if (ANDROID) / if (NOT ANDROID).
2026-11-02 11:00:51 +03:00

220 lines
6.8 KiB
C++

#include "Canvas.hpp"
#include "RecordingCanvasBackend.hpp"
#include "UnitTest++/UnitTest++.h"
#include <memory>
using namespace tp;
namespace {
constexpr halnf kTolerance = 0.001f;
struct RecordingScene {
RecordingCanvasBackend* backend = nullptr;
std::unique_ptr<Canvas> canvas;
RecordingScene() {
auto recording = std::make_unique<RecordingCanvasBackend>();
backend = recording.get();
canvas = std::make_unique<Canvas>(std::move(recording));
canvas->beginFrame();
}
[[nodiscard]] const CanvasCommand& last() const { return backend->commands().back(); }
};
void checkRect(const RectF& expected, const RectF& actual) {
CHECK_CLOSE(expected.x, actual.x, kTolerance);
CHECK_CLOSE(expected.y, actual.y, kTolerance);
CHECK_CLOSE(expected.z, actual.z, kTolerance);
CHECK_CLOSE(expected.w, actual.w, kTolerance);
}
}
SUITE(Canvas) {
TEST(DrawingIsPlacedAtTheTranslatedOrigin) {
RecordingScene scene;
{
const Canvas::Translation translation(*scene.canvas, { 10, 20 });
scene.canvas->rect({ 1, 2, 3, 4 }, RGBA(1, 0, 0, 1));
}
checkRect({ 11, 22, 3, 4 }, scene.last().rect);
scene.canvas->rect({ 1, 2, 3, 4 }, RGBA(1, 0, 0, 1));
checkRect({ 1, 2, 3, 4 }, scene.last().rect);
}
TEST(ClipReachesTheBackendAndIntersectsNestedClips) {
RecordingScene scene;
{
const Canvas::Clip outer(*scene.canvas, { 0, 0, 100, 50 });
const Canvas::Translation translation(*scene.canvas, { 80, 10 });
const Canvas::Clip inner(*scene.canvas, { 0, 0, 40, 100 });
scene.canvas->rect({ 0, 0, 10, 10 }, RGBA(1, 1, 1, 1));
}
CHECK(scene.last().clipped);
checkRect({ 80, 10, 20, 40 }, scene.last().clip);
}
TEST(ClosingAClipScopeRestoresTheOuterClip) {
RecordingScene scene;
const Canvas::Clip outer(*scene.canvas, { 0, 0, 100, 100 });
{
const Canvas::Clip inner(*scene.canvas, { 10, 10, 20, 20 });
}
scene.canvas->rect({ 0, 0, 1, 1 }, RGBA(1, 1, 1, 1));
checkRect({ 0, 0, 100, 100 }, scene.last().clip);
}
TEST(DrawingAfterAllScopesCloseIsUnclipped) {
RecordingScene scene;
{
const Canvas::Clip clip(*scene.canvas, { 0, 0, 5, 5 });
}
scene.canvas->rect({ 0, 0, 1, 1 }, RGBA(1, 1, 1, 1));
CHECK(!scene.last().clipped);
}
TEST(OutsideClipIsReportedInLocalCoordinates) {
RecordingScene scene;
const Canvas::Clip clip(*scene.canvas, { 0, 0, 50, 50 });
const Canvas::Translation translation(*scene.canvas, { 40, 0 });
CHECK(!scene.canvas->isOutsideClip({ 0, 0, 20, 20 }));
CHECK(scene.canvas->isOutsideClip({ 20, 0, 20, 20 }));
}
TEST(TextOutsideTheClipIsNotDrawn) {
RecordingScene scene;
const Canvas::Clip clip(*scene.canvas, { 0, 0, 50, 50 });
scene.canvas->text("hidden", { 100, 100, 40, 20 }, TextStyle{});
CHECK(!scene.backend->hasText("hidden"));
}
TEST(TextIsClippedToItsPaddedArea) {
RecordingScene scene;
TextStyle style;
style.padding = 2;
scene.canvas->text("label", { 10, 10, 40, 20 }, style);
const CanvasCommand* command = scene.backend->findText("label");
REQUIRE CHECK(command);
checkRect({ 12, 12, 36, 16 }, command->rect);
CHECK(command->clipped);
checkRect({ 12, 12, 36, 16 }, command->clip);
}
TEST(SavedStateRestoresCompositeOperation) {
RecordingScene scene;
{
const Canvas::SavedState saved(*scene.canvas);
scene.canvas->setCompositeOperation(Canvas::CompositeOperation::DestinationOut);
scene.canvas->beginPath();
scene.canvas->addPathRect({ 0, 0, 1, 1 });
scene.canvas->fillPath(RGBA(0, 0, 0, 1));
}
CHECK(scene.last().composite == Canvas::CompositeOperation::DestinationOut);
scene.canvas->rect({ 0, 0, 1, 1 }, RGBA(1, 1, 1, 1));
CHECK(scene.last().composite == Canvas::CompositeOperation::SourceOver);
}
TEST(PointsAndGradientsFollowTheOrigin) {
RecordingScene scene;
const Canvas::Translation translation(*scene.canvas, { 5, 5 });
scene.canvas->polyline({ { 0, 0 }, { 10, 0 } }, RGBA(1, 1, 1, 1), 2);
REQUIRE CHECK_EQUAL(2u, scene.last().points.size());
CHECK_CLOSE(5, scene.last().points[0].x, kTolerance);
CHECK_CLOSE(15, scene.last().points[1].x, kTolerance);
CHECK_CLOSE(2, scene.last().width, kTolerance);
}
TEST(GradientTakesAnAxis) {
RecordingScene scene;
scene.canvas->gradientRect({ 0, 0, 10, 10 }, RGBA(0, 0, 0, 1), RGBA(1, 1, 1, 1), Axis::Vertical);
CHECK(scene.last().kind == CanvasCommand::Kind::Gradient);
CHECK_CLOSE(1, scene.last().endColor.r, kTolerance);
}
TEST(InvalidImagesAreIgnored) {
RecordingScene scene;
scene.canvas->drawImage({ 0, 0, 1, 1 }, ImageHandle());
scene.canvas->deleteImage(ImageHandle());
CHECK(scene.backend->commands().empty());
CHECK_CLOSE(0, scene.canvas->imageSize(ImageHandle()).x, kTolerance);
}
TEST(ImagesLiveUntilDeleted) {
RecordingScene scene;
const unsigned char pixel[4] = { 255, 255, 255, 255 };
const ImageHandle image = scene.canvas->createImageFromMemoryRGBA(3, 2, pixel);
REQUIRE CHECK(image.isValid());
CHECK_CLOSE(3, scene.canvas->imageSize(image).x, kTolerance);
CHECK_EQUAL(1u, scene.backend->liveImageCount());
scene.canvas->deleteImage(image);
CHECK_EQUAL(0u, scene.backend->liveImageCount());
}
TEST(ImageFilesLoadOnlyWhenKnown) {
RecordingScene scene;
scene.backend->addImageFile("icon.png", { 16, 16 });
CHECK(scene.canvas->createImageFromFile("icon.png").isValid());
CHECK(!scene.canvas->createImageFromFile("missing.png").isValid());
}
TEST(TextMeasurementIsAvailableWithoutAFrame) {
RecordingScene scene;
const TextMetrics& metrics = *scene.canvas;
CHECK_CLOSE(
4 * 10 * RecordingCanvasBackend::kCharacterWidthFactor,
metrics.textWidth("abcd", 10, FontFace::Regular),
kTolerance
);
const std::vector<halnf> prefixes = metrics.prefixWidths("ab", 10, FontFace::Regular);
REQUIRE CHECK_EQUAL(3u, prefixes.size());
CHECK_CLOSE(0, prefixes[0], kTolerance);
CHECK_CLOSE(10, prefixes[2], kTolerance);
}
TEST(BeginFrameResetsCompositeOperation) {
RecordingScene scene;
scene.canvas->setCompositeOperation(Canvas::CompositeOperation::DestinationOver);
scene.canvas->beginFrame();
scene.canvas->rect({ 1, 1, 1, 1 }, RGBA(1, 1, 1, 1));
CHECK(scene.last().composite == Canvas::CompositeOperation::SourceOver);
CHECK(!scene.last().clipped);
}
TEST(OpacityFadesDrawingNestsByMultiplyingAndEndsWithItsScope) {
RecordingScene scene;
{
const Canvas::Opacity half(*scene.canvas, 0.5f);
scene.canvas->rect({ 0, 0, 1, 1 }, RGBA(1, 0, 0, 1));
CHECK_CLOSE(0.5f, scene.last().color.a, kTolerance);
{
const Canvas::Opacity quarter(*scene.canvas, 0.5f);
scene.canvas->gradientRect({ 0, 0, 1, 1 }, RGBA(1, 1, 1, 1), RGBA(0, 0, 0, 0.8f), Axis::Horizontal);
CHECK_CLOSE(0.25f, scene.last().color.a, kTolerance);
CHECK_CLOSE(0.2f, scene.last().endColor.a, kTolerance);
}
scene.canvas->rect({ 0, 0, 1, 1 }, RGBA(1, 0, 0, 1));
CHECK_CLOSE(0.5f, scene.last().color.a, kTolerance);
}
scene.canvas->rect({ 0, 0, 1, 1 }, RGBA(1, 0, 0, 1));
CHECK_CLOSE(1.0f, scene.last().color.a, kTolerance);
}
}