196 lines
7.9 KiB
C++
196 lines
7.9 KiB
C++
//SPDX-License-Identifier: LGPL-3.0-only
|
|
//SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®
|
|
|
|
// Regression test for issue #56: InputField_HitTestCursor used to map a click
|
|
// x-coord to a cursor byte offset by calling Font::GetLineWidth on every
|
|
// prefix `value[0..i]` for i = 1..size — each call re-walks from byte 0, so it
|
|
// was O(n^2) glyph-metric lookups. Worse, it iterated raw byte boundaries, so
|
|
// on multibyte UTF-8 input it could return an offset that splits a codepoint
|
|
// (an invalid cursor position, since cursorPos is a byte offset edited via
|
|
// value.erase(cursorPos, 1)).
|
|
//
|
|
// The hit test now delegates to Font::NearestCursorByte: one left-to-right
|
|
// cumulative-advance pass (O(n) metrics) over codepoint boundaries, returning
|
|
// the byte offset of the boundary whose cumulative advance is nearest the
|
|
// target. This test pins:
|
|
// - the result matches an independent brute-force "nearest codepoint
|
|
// boundary" reference (built from per-prefix GetLineWidth) for many click
|
|
// positions across ASCII and multibyte strings,
|
|
// - clicks at/left of the text start return 0, clicks far past the end
|
|
// return value.size() (the end-of-text caret),
|
|
// - every returned offset lands on a codepoint boundary (never mid-sequence),
|
|
// - clicking exactly on a glyph's left edge lands on that glyph's boundary.
|
|
//
|
|
// Pure CPU + a TrueType file — no Vulkan device or window needed. The font is
|
|
// copied next to the binary; the test also probes the project-root path.
|
|
|
|
#include <cstdlib>
|
|
|
|
import Crafter.Graphics;
|
|
import std;
|
|
|
|
using namespace Crafter;
|
|
|
|
namespace {
|
|
|
|
int failures = 0;
|
|
|
|
void Check(bool ok, std::string_view what) {
|
|
std::println("{} {}", ok ? "PASS" : "FAIL", what);
|
|
if (!ok) ++failures;
|
|
}
|
|
|
|
std::filesystem::path FindFont() {
|
|
for (const char* cand : {
|
|
"font.ttf",
|
|
"tests/InputFieldHitTest/font.ttf",
|
|
"../../examples/HelloUI/font.ttf" }) {
|
|
if (std::filesystem::exists(cand)) return cand;
|
|
}
|
|
return "font.ttf";
|
|
}
|
|
|
|
// All codepoint-boundary byte offsets of `s`, including 0 and s.size().
|
|
std::vector<std::size_t> Boundaries(std::string_view s) {
|
|
std::vector<std::size_t> b{0};
|
|
std::size_t i = 0;
|
|
while (i < s.size()) {
|
|
std::uint32_t cp = DecodeUtf8(s, i); // advances i to the next boundary
|
|
if (cp == 0) break;
|
|
b.push_back(i);
|
|
}
|
|
return b;
|
|
}
|
|
|
|
// Independent reference: the codepoint boundary whose prefix advance is
|
|
// nearest `target`, ties resolved to the earlier boundary (matching the
|
|
// implementation's strict `d < bestDist`). Built with per-prefix GetLineWidth
|
|
// — the slow path the optimisation replaces, used here only as the oracle.
|
|
std::size_t NearestBoundaryRef(Font& font, std::string_view s, float size, float target) {
|
|
if (target <= 0.0f) return 0;
|
|
auto bounds = Boundaries(s);
|
|
std::size_t best = 0;
|
|
float bestDist = std::abs(target); // boundary 0 has width 0
|
|
for (std::size_t k = 1; k < bounds.size(); ++k) {
|
|
float w = static_cast<float>(font.GetLineWidth(s.substr(0, bounds[k]), size));
|
|
float d = std::abs(target - w);
|
|
if (d < bestDist) {
|
|
bestDist = d;
|
|
best = bounds[k];
|
|
}
|
|
// No early break: the reference scans every boundary regardless, so a
|
|
// mismatch would also catch any over-eager break in the implementation.
|
|
}
|
|
return best;
|
|
}
|
|
|
|
bool IsBoundary(std::string_view s, std::size_t off) {
|
|
if (off > s.size()) return false;
|
|
for (std::size_t b : Boundaries(s)) if (b == off) return true;
|
|
return false;
|
|
}
|
|
|
|
const InputFieldColors kColors{
|
|
{0, 0, 0, 1}, {0, 0, 0, 1}, {0, 0, 0, 1}, {0, 0, 0, 1},
|
|
{1, 1, 1, 1}, {1, 1, 1, 1},
|
|
};
|
|
|
|
// Drive the public hit-test for a click at window-x `clickX`, given a field
|
|
// rect at `rectX`. paddingX is taken from kColors.
|
|
std::size_t Hit(const InputField& f, Font& font, float size, float rectX, float clickX) {
|
|
Rect rect{rectX, 0.0f, 200.0f, 24.0f};
|
|
return InputField_HitTestCursor(f, rect, clickX, font, size, kColors);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
int main() {
|
|
Font font(FindFont());
|
|
|
|
constexpr float kSize = 18.0f;
|
|
const float rectX = 30.0f;
|
|
const float textStart = rectX + kColors.paddingX; // x where the text begins
|
|
|
|
const std::array<std::string_view, 4> samples = {
|
|
"Hello, world",
|
|
"1234567890",
|
|
"iiiiWWWWmmmm", // wildly varying advances
|
|
"caf\xC3\xA9 na\xC3\xAFve \xE2\x9C\x93", // "café naïve ✓" — 2- and 3-byte cps
|
|
};
|
|
|
|
// 1. Across each sample, sweep target px and compare to the oracle.
|
|
bool sweepOk = true;
|
|
bool allBoundaries = true;
|
|
for (std::string_view s : samples) {
|
|
InputField f;
|
|
f.type = InputFieldType::Text;
|
|
f.value = std::string(s);
|
|
float fullW = static_cast<float>(font.GetLineWidth(s, kSize));
|
|
// Step finely enough to cross every glyph edge several times, and run
|
|
// past the end of the text to exercise the end-of-text caret.
|
|
for (float t = -10.0f; t <= fullW + 40.0f; t += 1.0f) {
|
|
std::size_t got = Hit(f, font, kSize, rectX, textStart + t);
|
|
std::size_t ref = NearestBoundaryRef(font, s, kSize, t);
|
|
if (got != ref) {
|
|
sweepOk = false;
|
|
std::println(" mismatch on \"{}\": target={} got={} ref={}",
|
|
s, t, got, ref);
|
|
}
|
|
if (!IsBoundary(s, got)) allBoundaries = false;
|
|
}
|
|
}
|
|
Check(sweepOk, "hit test matches the brute-force nearest-boundary oracle across a px sweep");
|
|
Check(allBoundaries, "every returned offset lands on a UTF-8 codepoint boundary");
|
|
|
|
// 2. Clicks at or left of the text start return 0.
|
|
{
|
|
InputField f; f.value = "Hello";
|
|
Check(Hit(f, font, kSize, rectX, textStart) == 0,
|
|
"click exactly at the text start returns offset 0");
|
|
Check(Hit(f, font, kSize, rectX, textStart - 5.0f) == 0,
|
|
"click left of the text start returns offset 0");
|
|
Check(Hit(f, font, kSize, rectX, 0.0f) == 0,
|
|
"click far to the left of the field returns offset 0");
|
|
}
|
|
|
|
// 3. A click far past the end lands on the end-of-text caret (value.size()).
|
|
{
|
|
InputField f; f.value = "Hello";
|
|
float fullW = static_cast<float>(font.GetLineWidth(f.value, kSize));
|
|
Check(Hit(f, font, kSize, rectX, textStart + fullW + 1000.0f) == f.value.size(),
|
|
"click far past the end returns value.size()");
|
|
}
|
|
|
|
// 4. An empty field always resolves to offset 0.
|
|
{
|
|
InputField f; f.value = "";
|
|
Check(Hit(f, font, kSize, rectX, textStart + 50.0f) == 0,
|
|
"empty field returns offset 0 regardless of click x");
|
|
}
|
|
|
|
// 5. Clicking just past a glyph's right edge selects that glyph's boundary
|
|
// (cursor sits after the glyph). Walk the boundaries of an ASCII string
|
|
// and click slightly past each cumulative advance.
|
|
{
|
|
std::string_view s = "abcXYZ";
|
|
InputField f; f.value = std::string(s);
|
|
auto bounds = Boundaries(s);
|
|
bool edgeOk = true;
|
|
for (std::size_t k = 1; k < bounds.size(); ++k) {
|
|
float w = static_cast<float>(font.GetLineWidth(s.substr(0, bounds[k]), kSize));
|
|
// Click a hair before the glyph's right edge → nearest boundary is
|
|
// this one (its advance is the closest of all boundaries).
|
|
std::size_t got = Hit(f, font, kSize, rectX, textStart + w - 0.5f);
|
|
if (got != bounds[k]) {
|
|
edgeOk = false;
|
|
std::println(" edge mismatch at boundary {} (w={}): got {}",
|
|
bounds[k], w, got);
|
|
}
|
|
}
|
|
Check(edgeOk, "clicking near a glyph's right edge resolves to that glyph's boundary");
|
|
}
|
|
|
|
if (failures == 0) std::println("\nAll InputField hit-test checks passed.");
|
|
else std::println("\n{} InputField hit-test check(s) FAILED.", failures);
|
|
return failures == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
|
|
}
|