settled-reach/client/tests/test_atlas_window_geometry_stroke_width.gd

## T-1170 live round (2026-07-23): tests for
## AtlasWindowGeometryNature.zoom_compensated_stroke_width() — the
## STROKE-WIDTH-specific sibling of zoom_compensated_size(), added after the
## course-polyline hairline finding (Araminta's pixel scan of
## D-district-courses.png/Q-quarter-courses.png: a UNIFORM 1px hairline for
## the ENTIRE visible course, no width/opacity variation at all, in BOTH
## District and Quarter captures). Split into its own file rather than
## folded into test_atlas_window_geometry_nature.gd, which was already at the
## gdlint max-file-lines cap — same file-per-concern precedent as every other
## split in this cluster.
##
## Live A/B evidence (temporary instrumentation, since reverted — the
## dossier discipline): draw_line()/draw_polyline() called with a
## canvas-local width in [0.6, 1.0) renders as a flat 1px hairline
## regardless of the input value, confirmed identically on BOTH APIs (ruling
## out a draw_polyline()-specific quirk) — Godot's line rasterizer has a
## ~1.0-canvas-local-unit floor that draw_circle()'s radius parameter does
## NOT share (confirmed: mouth ring radii at the same District/Quarter zoom
## render correctly-sized via the unchanged zoom_compensated_size()/_zs()
## path — only the STROKE WIDTH argument was affected). The compensation
## MATH itself was never wrong (0.373 * 3.75 round-trips to 1.4 exactly) —
## the bug was that nothing floored the intermediate value against Godot's
## own rasterizer minimum before handing it to draw_line()/draw_polyline().
class_name TestAtlasWindowGeometryStrokeWidth
extends GdUnitTestSuite

const AtlasWindowGeometryNature := preload(
	"res://ui/implant/apps/atlas/atlas_window_geometry_nature.gd"
)


## At zoom=1.0, unchanged from zoom_compensated_size() — no floor engages
## when the input is already >= 1.0.
func test_zoom_compensated_stroke_width_at_zoom_one_is_unchanged() -> void:
	assert_float(
		AtlasWindowGeometryNature.zoom_compensated_stroke_width(2.2, 1.0)
	).is_equal_approx(2.2, 0.0001)


## The EXACT regression shape this round closes: at District's real fit zoom
## (3.75, live capture), the tributary class's raw table width (1.4px)
## divides to 0.3733 canvas-local — BELOW the 1.0 floor under the OLD
## zoom_compensated_size() path (pinned directly, not just asserted) — and
## zoom_compensated_stroke_width() must instead return exactly 1.0 (the
## floor), never the sub-floor raw division result.
func test_zoom_compensated_stroke_width_district_tributary_hits_the_floor() -> void:
	var view_zoom := 3.75  # LENDEL's live District fit zoom, capture-confirmed
	var raw_width_px := 1.4  # COURSE_CLASS_WIDTH_PX[RIVER_CLASS_TRIBUTARY]
	var unfloored: float = AtlasWindowGeometryNature.zoom_compensated_size(raw_width_px, view_zoom)
	assert_float(unfloored).override_failure_message(
		"regression pin: the OLD unfloored division must be BELOW 1.0 at this"
		+ " zoom — this is the exact numeric shape of the hairline bug"
	).is_less(1.0)
	var floored: float = AtlasWindowGeometryNature.zoom_compensated_stroke_width(raw_width_px, view_zoom)
	assert_float(floored).override_failure_message(
		"zoom_compensated_stroke_width() must clamp to the 1.0 floor, not the"
		+ " sub-pixel unfloored value that collapses to Godot's hairline"
	).is_equal_approx(1.0, 0.0001)


## Same shape at Quarter's real fit zoom (7.5, live capture) — the floor
## engages even harder there (raw width divides to 0.1867).
func test_zoom_compensated_stroke_width_quarter_tributary_hits_the_floor() -> void:
	var view_zoom := 7.5  # LENDEL's live Quarter fit zoom, capture-confirmed
	var raw_width_px := 1.4
	var floored: float = AtlasWindowGeometryNature.zoom_compensated_stroke_width(raw_width_px, view_zoom)
	assert_float(floored).is_equal_approx(1.0, 0.0001)


## Regression pin (PR #195 stroke-width-class shape, per the coordinator's
## explicit ask): for EACH course class, at District's real fit zoom, the
## EFFECTIVE on-screen width the render plan feeds (canvas-local width times
## view_zoom, exactly what the canvas transform multiplies at render time)
## must equal AT LEAST the table value — never less, since the floor can only
## push the effective width UP from what an unfloored divide would produce,
## never down. This is the "does the value actually reaching the screen
## match the table" pin the coordinator asked for, computed both ways
## (floored vs table) rather than eyeballed.
func test_effective_stroke_width_at_district_zoom_meets_table_value_per_class() -> void:
	var view_zoom := 3.75
	for cls in [
		AtlasWindowGeometryNature.RIVER_CLASS_STREAM,
		AtlasWindowGeometryNature.RIVER_CLASS_TRIBUTARY,
		AtlasWindowGeometryNature.RIVER_CLASS_TRUNK,
	]:
		var table_width: float = AtlasWindowGeometryNature.course_class_width_px(cls)
		var canvas_local: float = AtlasWindowGeometryNature.zoom_compensated_stroke_width(
			table_width, view_zoom
		)
		var effective_screen_px: float = canvas_local * view_zoom
		assert_float(effective_screen_px).override_failure_message(
			(
				"class %d's effective on-screen stroke width (%.3fpx) must be AT"
				+ " LEAST its table value (%.3fpx) — the floor must never make a"
				+ " course THINNER than the ruling specifies, only ever thicker"
				+ " when the literal value would otherwise be sub-pixel"
			)
			% [cls, effective_screen_px, table_width]
		).is_greater_equal(table_width - 0.001)


## Same pin at Quarter's fit zoom (7.5) — the floor engages harder there
## (streams' 0.9px table value divides to 0.12 canvas-local, furthest below
## the floor of any class/rung combination this batch draws).
func test_effective_stroke_width_at_quarter_zoom_meets_table_value_per_class() -> void:
	var view_zoom := 7.5
	for cls in [
		AtlasWindowGeometryNature.RIVER_CLASS_STREAM,
		AtlasWindowGeometryNature.RIVER_CLASS_TRIBUTARY,
		AtlasWindowGeometryNature.RIVER_CLASS_TRUNK,
	]:
		var table_width: float = AtlasWindowGeometryNature.course_class_width_px(cls)
		var canvas_local: float = AtlasWindowGeometryNature.zoom_compensated_stroke_width(
			table_width, view_zoom
		)
		var effective_screen_px: float = canvas_local * view_zoom
		assert_float(effective_screen_px).is_greater_equal(table_width - 0.001)


## At a LOW zoom (well under 1.0, e.g. an extreme zoom-out within a rung —
## not just Region's orbital case), the floor must NOT engage: the ordinary
## divide-then-scale math must still produce the literal table value exactly,
## matching zoom_compensated_size()'s own unfloored behavior. Pins that the
## floor is a ONE-DIRECTION safety net, not a blanket override.
func test_zoom_compensated_stroke_width_does_not_engage_at_low_zoom() -> void:
	var view_zoom := 0.1
	var raw_width_px := 2.2
	var floored: float = AtlasWindowGeometryNature.zoom_compensated_stroke_width(raw_width_px, view_zoom)
	var unfloored: float = AtlasWindowGeometryNature.zoom_compensated_size(raw_width_px, view_zoom)
	assert_float(floored).override_failure_message(
		"at a zoom where the unfloored value is already well above 1.0, the"
		+ " floor must be a no-op — identical to zoom_compensated_size()"
	).is_equal_approx(unfloored, 0.0001)


## A degenerate zero (or negative) view_zoom must not divide-by-zero/produce
## infinity/NaN — same total-function guarantee as zoom_compensated_size().
func test_zoom_compensated_stroke_width_zero_zoom_does_not_blow_up() -> void:
	var result: float = AtlasWindowGeometryNature.zoom_compensated_stroke_width(2.2, 0.0)
	assert_bool(is_finite(result)).override_failure_message(
		"a degenerate zero view_zoom must not produce inf/NaN"
	).is_true()