diff --git a/android/README.md b/android/README.md index 1a5ac8db..b120e449 100644 --- a/android/README.md +++ b/android/README.md @@ -111,8 +111,10 @@ stops it. fallback), loops and branches, pan/zoom, and run highlighting (under a run the executed stage/route is a solid full-colour stroke with an arrowhead and a filled, normal-bordered node, while a not-executed one is a dashed, arrowless - muted stroke with a hollow, dashed-bordered node and a muted label, plus a - one-line legend; the definition-only view is unchanged) plus a screen-reader + muted stroke with a hollow, dashed-bordered node and a muted label; an executed + `success`/`error` route is drawn noticeably heavier with a stronger same-hue + stroke and a larger arrowhead so pass/fail dominates; a one-line legend names + both states) plus a screen-reader description. Edges are drawn as axis-aligned orthogonal polylines like the TUI (`routePoints` computes the path once per layout and stores it on `EdgeLayout.points`), and each arrowhead @@ -1796,7 +1798,8 @@ on or driven). - **The definition-only view is untouched.** With no `runState` every stage/route is executed, so the graph renders exactly as before (solid, filled, arrowed) and the legend is not composed — confirmed against the pipeline Graph - tab. + tab. (Superseded later the same day: the pass/fail change below now widens an + executed `success`/`error` route in this view too.) - The run-detail Graph tab's help line was updated from "highlighted … dimmed" to "solid … dashed and outlined". @@ -1861,3 +1864,91 @@ Not verified in this pass: `:app:lintDebug`, the light theme, and a real hardwar fold (the wide/narrow layouts were produced with `wm size`/`wm density`); the on-device captures used the debug build of this source, while the published APK is a clean rebuild of the same source. + +## Pass/fail edges are the loudest lines (16 Oct 2026) + +`android/` only. Nothing outside `android/` was touched, no dependency was added, +no run was started from the app, and every `adb`/emulator command targeted +`emulator-5556` (lane A's `emulator-5554` was never used; the attached device was +never installed on or driven). + +- **Two decisive outcomes, drawn heavier.** `ui/graph/WorkflowGraph.kt` now + treats `success` (pass) and `error` (fail) as the emphasised outcomes + (`isPassFailOutcome`). An executed pass/fail edge is drawn at + `PASSFAIL_EDGE_STROKE = 7f` — noticeably heavier than the previous `3f` — with + a stronger, more saturated stroke and a matching `PASSFAIL_ARROW_HEAD_SIZE = + 20f` arrowhead, so pass/fail is obvious at a glance and from a distance. +- **Other lines stay finer.** Every other executed outcome keeps `EDGE_STROKE = + 3f`, and a not-executed edge uses the finer `INACTIVE_EDGE_STROKE = 2.5f`, so + the two emphasised outcomes dominate. No outcome hue changed. +- **Stronger, same-hue stroke.** `boostSaturation(color, factor)` in + `ui/graph/GraphPalette.kt` scales HSV saturation by `PASSFAIL_SATURATION = + 1.6f`, clamping at 1 while preserving hue, value and alpha. On the dark theme + the executed `success` stroke moves from `#F2C879` (hue 39.2°) to a vivid + `#F2AF30`-ish core (hue 39.3°, measured pixel `(242,175,48)`) and the executed + `error` stroke from `#FFB4AB` (hue 6.4°) to a stronger `(255,135,121)` (hue + 6.3°); the measured pixel hues match their unboosted originals, so meaning is + not conveyed by a new colour. A non-pass/fail or not-executed edge keeps its + exact outcome colour. +- **Widths come from named tokens, not call sites.** `edgeStrokeWidth`, + `edgeArrowHeadSize` and `edgeStrokeColor` pick the token for an edge; the old + `12f` arrowhead literal is gone (the draw scope takes the size as a + parameter). The legend swatch keeps the base `EDGE_STROKE`/`ARROW_HEAD_SIZE` + because it names the generic executed/not-executed states, not pass/fail. +- **Definition-only view.** With no run selected every route counts as executed, + so the definition graph now shows the same pass/fail emphasis (still no + legend). The run Graph tab help line now adds "Executed success and failure + routes are drawn thickest." + +Verification (macOS; Homebrew `openjdk@17`, +`JAVA_HOME=/opt/homebrew/opt/openjdk@17/libexec/openjdk.jdk/Contents/Home`, +Gradle 8.11.1 at +`~/.gradle/wrapper/dists/gradle-8.11.1-bin/…/gradle-8.11.1/bin/gradle`, +`ANDROID_HOME=/Users/alan/Library/Android/sdk`, `--offline`): + +- `gradle --offline clean :app:testDebugUnitTest :app:assembleDebug` → + **193 tests, 0 failures, 0 errors**; `WorkflowGraphTest` **36** (2 new: the + executed pass/fail edge is the widest and its arrowhead scales, and only + `success`/`error` are pass/fail outcomes) and `GraphPaletteTest` **10** (3 new: + `boostSaturation` raises saturation while keeping hue/value/alpha, is safe and + clamped at the edges, and only executed pass/fail strokes are saturated + further). The clean `:app:assembleDebug` produced `app-debug.apk` + **17,912,489 bytes**, sha256 + `ce63722b851ce26322da69fa47bdc91958c3d7db3e339c1340efc3e04b6780f8`. +- **Before/after on a run with both a success and an error edge.** Run 77 + (pipeline 11 "Focused tweak - implement review commit", failed at `ui_reviewer` + with `error`) was opened in the app against the live server + `ws://10.0.2.2:8080/connect` in dark mode; its taken routes include a `success` + and an `error` edge. "Before" is HEAD `9c47527` (the six edited files stashed, + rebuilt, installed; verified by the help line without "thickest"); "after" is + this change. Captures were written with + `android/scripts/capture_png.sh -s emulator-5556`: + - **Wide** 2208x1840 @ density 420 (≈841dp): `before_wide_1x.png` / + `after_wide_1x.png`. At the panel's fit scale the executed success/error + stroke's saturated core measures **1px before, 3px after** (sampled at the + same x), while the dashed non-pass/fail routes stay ~1px. + - **Wide 2x** 4416x3680 @ density 840: `before_wide_2x.png` / + `after_wide_2x.png`. + - Cropped graph panes `before_wide_{1x,2x}_graphcrop.png` / + `after_wide_{1x,2x}_graphcrop.png` and stacked before/after sheets + `compare_wide_1x.png` / `compare_wide_2x.png` show the two amber `success` + edges and the red `error` edge as the boldest lines after the change, with + the dashed `blocked`/`rejected`/`approved`/`skipped` routes and the + not-executed `committer`/`SUCCESS` edges unchanged. + - `adb -s emulator-5556 logcat -d` contained 0 `FATAL EXCEPTION` and 0 + `E AndroidRuntime` lines. +- **APK publish.** `app-debug.apk` copied to + `…/artifacts/98/1/pipelines-debug-wip-9c47527.apk` (`9c47527` = `git rev-parse + --short HEAD`); `shasum -a 256` matched. `curl -I + http://10.0.0.249:8080/artifacts/98/1/pipelines-debug-wip-9c47527.apk` (`10.0.0.249` + from `ipconfig getifaddr en0`) returned `HTTP/1.1 200 OK`, + `Content-Type: application/vnd.android.package-archive`, `Content-Length: + 17912489`, and a streamed `GET | shasum -a 256` equalled the local file. The + APK exceeds the server's per-file inventory cap, so it is served by direct URL + only. + +Not verified in this pass: `:app:lintDebug`, the light theme, and a real hardware +fold (the wide layout was produced with `wm size`/`wm density`); the on-device +captures used the debug build of this source, while the published APK is a clean +rebuild of the same source. + diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphPalette.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphPalette.kt index cf5d5b9c..b15bfca8 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphPalette.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/GraphPalette.kt @@ -94,6 +94,36 @@ internal fun graphNodeKind(terminal: Boolean, key: String, type: String?): Graph else -> GraphNodeKind.Custom } +/** + * A more vivid version of [color] with the same hue, value and alpha: the HSV + * saturation is scaled by [factor] and clamped to 1. Used to make an executed + * pass/fail edge stroke stronger without changing its outcome hue, so both + * terminal colours get more punch while staying recognisably success/failure. + * + * Pure sRGB maths. A non-finite/non-positive [factor], an achromatic colour or + * one already at full saturation returns [color] unchanged, so callers never get + * NaN and every input is safe. + */ +internal fun boostSaturation(color: Color, factor: Float): Color { + if (!factor.isFinite() || factor <= 0f) return color + val r = color.red + val g = color.green + val b = color.blue + val max = maxOf(r, g, b) + val min = minOf(r, g, b) + val delta = max - min + if (max <= 0f || delta <= 0f) return color + val current = delta / max + val saturation = (current * factor).coerceAtMost(1f) + if (saturation <= current) return color + val hue = (when (max) { + r -> ((g - b) / delta + 6f) % 6f + g -> (b - r) / delta + 2f + else -> (r - g) / delta + 4f + }) * 60f + return Color.hsv(hue, saturation, max, color.alpha) +} + /** * WCAG relative luminance of [color] (sRGB), the building block of the WCAG * contrast ratio. Pure so the palette's legibility is measured in a unit test diff --git a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt index 84940fcc..36030c23 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/graph/WorkflowGraph.kt @@ -145,8 +145,11 @@ internal data class ZoomResult(val offset: Offset, val scale: Float) * not-executed one is dashed and arrowless (nodes hollow with a muted, legible * label), so the two states differ in shape, fill and border style rather than * by a faded tint and survive a screenshot, a dim screen and a colour-blind - * reader; a one-line legend names both states. When [runState] is null the full - * definition is shown, unchanged. + * reader; a one-line legend names both states. An executed `success`/`error` + * edge is drawn noticeably heavier with a stronger, same-hue stroke and a larger + * arrowhead, so the two decisive outcomes are the loudest lines in the graph. + * When [runState] is null the full definition is shown, with the same pass/fail + * emphasis (every route counts as executed) and no legend. * * A tap that lands inside a node (stage or terminal) calls [onStageTap] with the * node key; tapping empty space does nothing. Pan/zoom keep working because the @@ -405,7 +408,7 @@ private fun LegendSwatch(executed: Boolean, colors: GraphColors) { strokeWidth = EDGE_STROKE, pathEffect = if (executed) null else INACTIVE_DASH_EFFECT, ) - if (executed) drawArrowHead(listOf(from, to), color) + if (executed) drawArrowHead(listOf(from, to), color, ARROW_HEAD_SIZE) } } @@ -1074,16 +1077,25 @@ private fun DrawScope.drawEdgePaths( // Executed = solid full-colour stroke plus an arrowhead; not executed = // dashed muted stroke with no arrowhead. The difference is carried by line // style and arrowhead presence, never by opacity alone, so it survives a - // screenshot, a dim screen and a colour-blind reader. + // screenshot, a dim screen and a colour-blind reader. An executed + // `success`/`error` edge uses the heavier pass/fail width, a stronger + // (same-hue) stroke and a matched arrowhead, so pass/fail dominates. if (edgeIsExecuted(edge.edge, runState)) { - val color = outcomeColor(edge.edge.outcome, colors) - drawPath(path, color = color, style = Stroke(width = EDGE_STROKE)) - drawArrowHead(points, color) + val color = edgeStrokeColor(edge.edge, runState, colors) + drawPath( + path, + color = color, + style = Stroke(width = edgeStrokeWidth(edge.edge, runState)), + ) + drawArrowHead(points, color, edgeArrowHeadSize(edge.edge, runState)) } else { drawPath( path, color = colors.labelText, - style = Stroke(width = EDGE_STROKE, pathEffect = INACTIVE_DASH_EFFECT), + style = Stroke( + width = edgeStrokeWidth(edge.edge, runState), + pathEffect = INACTIVE_DASH_EFFECT, + ), ) } } @@ -1128,17 +1140,18 @@ private fun DrawScope.drawEdgeLabels( } /** - * Draws an arrowhead at the tip of [points], oriented along the final segment's - * direction (see [arrowDirection]) instead of the from-to chord, so a route that - * turns a corner still gets an arrow pointing the way it actually travels. + * Draws an arrowhead of length [size] at the tip of [points], oriented along the + * final segment's direction (see [arrowDirection]) instead of the from-to chord, + * so a route that turns a corner still gets an arrow pointing the way it + * actually travels. [size] is passed by the caller from the matching named token + * (see [edgeArrowHeadSize]) rather than written here. */ -private fun DrawScope.drawArrowHead(points: List, color: Color) { +private fun DrawScope.drawArrowHead(points: List, color: Color, size: Float) { if (points.size < 2) return val to = points.last() val direction = arrowDirection(points) if (direction.x == 0f && direction.y == 0f) return val angle = kotlin.math.atan2(direction.y.toDouble(), direction.x.toDouble()) - val size = 12f val left = Offset( x = to.x - size * kotlin.math.cos(angle - 0.5).toFloat(), y = to.y - size * kotlin.math.sin(angle - 0.5).toFloat(), @@ -1263,6 +1276,46 @@ internal fun stageIsExecuted(key: String, runState: RunGraphState?): Boolean = internal fun edgeIsExecuted(edge: GraphEdge, runState: RunGraphState?): Boolean = runState == null || GraphRoute(edge.source, edge.outcome, edge.target) in runState.takenRoutes +/** + * True for the two decisive outcomes the graph emphasises: `success` (pass) and + * `error` (fail). These are the protocol's terminal outcomes, the only two whose + * stroke is widened. Pure, so drawing and the tests share one definition. + */ +internal fun isPassFailOutcome(outcome: String): Boolean = + outcome == "success" || outcome == "error" + +/** True for an executed pass/fail edge: the edges drawn heaviest. */ +internal fun isEmphasizedEdge(edge: GraphEdge, runState: RunGraphState?): Boolean = + isPassFailOutcome(edge.outcome) && edgeIsExecuted(edge, runState) + +/** + * The named stroke-width token for [edge]: the heavier pass/fail width for an + * executed `success`/`error`, the base width for any other executed outcome, and + * the finest width for a not-executed edge. Pure, so the widths are asserted in a + * unit test and no call site writes a stroke literal. + */ +internal fun edgeStrokeWidth(edge: GraphEdge, runState: RunGraphState?): Float = when { + !edgeIsExecuted(edge, runState) -> INACTIVE_EDGE_STROKE + isPassFailOutcome(edge.outcome) -> PASSFAIL_EDGE_STROKE + else -> EDGE_STROKE +} + +/** The named arrowhead-size token for [edge], scaled to match [edgeStrokeWidth]. */ +internal fun edgeArrowHeadSize(edge: GraphEdge, runState: RunGraphState?): Float = + if (isEmphasizedEdge(edge, runState)) PASSFAIL_ARROW_HEAD_SIZE else ARROW_HEAD_SIZE + +/** + * The stroke colour for an executed [edge]: its outcome colour, made more + * saturated when pass/fail so it is stronger without changing its hue (see + * [boostSaturation]). A not-executed edge is drawn muted elsewhere. + */ +internal fun edgeStrokeColor(edge: GraphEdge, runState: RunGraphState?, colors: GraphColors): Color = + if (isEmphasizedEdge(edge, runState)) { + boostSaturation(outcomeColor(edge.outcome, colors), PASSFAIL_SATURATION) + } else { + outcomeColor(edge.outcome, colors) + } + /** A screen-reader description so meaning is never conveyed by colour alone. */ private fun graphDescription(graph: Graph, runState: RunGraphState?): String { if (graph.stages.isEmpty()) return "Empty workflow graph" @@ -1290,12 +1343,38 @@ private val FIT_PADDING = 16.dp private val MIN_VISIBLE = 48.dp /** - * Line-style tokens shared by the graph and its legend. An executed stroke is - * solid; a not-executed stroke is dashed with [INACTIVE_DASH_INTERVALS] on/off + * Line-style tokens shared by the graph and its legend. Widths and the arrowhead + * size are named here so no call site writes a stroke literal. An executed route + * is solid; a not-executed route is dashed with [INACTIVE_DASH_INTERVALS] on/off * pixels, so the two states differ by shape, not by a faded tint. + * + * The two decisive outcomes (`success`/`error`) use the heavier + * [PASSFAIL_EDGE_STROKE] with the matching [PASSFAIL_ARROW_HEAD_SIZE] and a + * stronger [PASSFAIL_SATURATION] stroke, so pass/fail reads at a glance and from + * a distance, while every other outcome keeps the finer [EDGE_STROKE] and a + * not-executed route the finer still [INACTIVE_EDGE_STROKE]. */ private const val EDGE_STROKE = 3f +/** Stroke width for an executed `success`/`error` edge; heavier than [EDGE_STROKE]. */ +private const val PASSFAIL_EDGE_STROKE = 7f + +/** Stroke width for a not-executed edge; finer than either executed width. */ +private const val INACTIVE_EDGE_STROKE = 2.5f + +/** Arrowhead length for a normal executed edge. */ +private const val ARROW_HEAD_SIZE = 12f + +/** Arrowhead length for an executed pass/fail edge, scaled with its heavier stroke. */ +private const val PASSFAIL_ARROW_HEAD_SIZE = 20f + +/** + * How much more saturated an executed pass/fail stroke is than its outcome + * colour: hue and value are preserved (see [boostSaturation]) so the meaning of + * the colour does not change. + */ +private const val PASSFAIL_SATURATION = 1.6f + /** The dash pattern (on/off, px) for every not-executed stroke; pure data. */ internal val INACTIVE_DASH_INTERVALS = floatArrayOf(14f, 10f) diff --git a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt index fb1cb472..090ad2ab 100644 --- a/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt +++ b/android/app/src/main/java/net/awan/pipelines/ui/screens/RunDetailScreen.kt @@ -385,7 +385,7 @@ private fun RunGraphTab( Text("This server did not include the run graph.", style = text.meta) } else { Text( - "Executed stages and routes are solid; not-executed ones are dashed and outlined. Pinch to zoom, drag to pan, tap a stage for details.", + "Executed stages and routes are solid; not-executed ones are dashed and outlined. Executed success and failure routes are drawn thickest. Pinch to zoom, drag to pan, tap a stage for details.", style = text.meta, ) WorkflowGraph( diff --git a/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt index 9d237e56..7201cf25 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/graph/GraphPaletteTest.kt @@ -1,7 +1,10 @@ package net.awan.pipelines.ui.graph import androidx.compose.ui.graphics.Color +import net.awan.pipelines.data.protocol.GraphEdge +import net.awan.pipelines.data.protocol.GraphRoute import net.awan.pipelines.data.protocol.Protocol +import net.awan.pipelines.data.protocol.RunGraphState import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Assert.assertTrue @@ -98,6 +101,87 @@ class GraphPaletteTest { assertTrue(contrastRatio(errorRole, darkSurface) >= 4.5) } + /** + * The emphasis helper keeps the outcome hue and value and only raises + * saturation, so a stronger pass/fail stroke is still recognisably the same + * success/failure colour. + */ + @Test + fun boostSaturationRaisesSaturationButKeepsHueValueAndAlpha() { + val base = successRole + val boosted = boostSaturation(base, 1.6f) + assertTrue(saturationOf(boosted) > saturationOf(base)) + assertEquals(hueOf(base), hueOf(boosted), 1f) + assertEquals(valueOf(base), valueOf(boosted), 0.001f) + assertEquals(base.alpha, boosted.alpha, 0.001f) + // A second hue is left on its own hue, not shifted toward the first. + val red = errorRole + assertEquals(hueOf(red), hueOf(boostSaturation(red, 1.6f)), 1f) + } + + @Test + fun boostSaturationIsSafeAndClampedAtTheEdges() { + val base = successRole + // A no-op factor, and invalid factors, return the colour unchanged. + assertEquals(base, boostSaturation(base, 1f)) + assertEquals(base, boostSaturation(base, 0f)) + assertEquals(base, boostSaturation(base, -1f)) + assertEquals(base, boostSaturation(base, Float.NaN)) + // Achromatic colours have no saturation to raise. + assertEquals(Color.Gray, boostSaturation(Color.Gray, 2f)) + // An already fully-saturated colour clamps at 1 instead of overshooting. + assertEquals(Color.Red, boostSaturation(Color.Red, 2f)) + } + + /** + * Only an executed pass/fail edge is emphasised: its stroke is the stronger + * same-hue colour, while a non-pass/fail edge and a not-executed edge keep + * their exact outcome colour. + */ + @Test + fun onlyExecutedPassFailStrokesAreSaturatedFurther() { + val colors = colors() + val success = GraphEdge(1, "a", "success", Protocol.SUCCESS_END, "success") + val blocked = GraphEdge(2, "a", "blocked", Protocol.FAILURE_END, "blocked") + val error = GraphEdge(3, "b", "error", Protocol.FAILURE_END, "error") + val executed = RunGraphState( + visitedStages = setOf("a"), + takenRoutes = setOf(GraphRoute("a", "success", Protocol.SUCCESS_END)), + currentStage = "a", + ) + + val baseSuccess = outcomeColor("success", colors) + val strokeSuccess = edgeStrokeColor(success, executed, colors) + assertEquals(hueOf(baseSuccess), hueOf(strokeSuccess), 1f) + assertTrue(saturationOf(strokeSuccess) > saturationOf(baseSuccess)) + + // A non-pass/fail edge and a not-executed pass/fail edge are untouched. + assertEquals(outcomeColor("blocked", colors), edgeStrokeColor(blocked, executed, colors)) + assertEquals(outcomeColor("error", colors), edgeStrokeColor(error, executed, colors)) + } + + /** Hue in degrees, matching the conversion [boostSaturation] uses. */ + private fun hueOf(color: Color): Float { + val max = maxOf(color.red, color.green, color.blue) + val min = minOf(color.red, color.green, color.blue) + val delta = max - min + if (delta == 0f) return 0f + val h = when (max) { + color.red -> ((color.green - color.blue) / delta + 6f) % 6f + color.green -> (color.blue - color.red) / delta + 2f + else -> (color.red - color.green) / delta + 4f + } + return h * 60f + } + + private fun saturationOf(color: Color): Float { + val max = maxOf(color.red, color.green, color.blue) + val min = minOf(color.red, color.green, color.blue) + return if (max <= 0f) 0f else (max - min) / max + } + + private fun valueOf(color: Color): Float = maxOf(color.red, color.green, color.blue) + @Test fun nodeKindIsDeterministicAndCoversEveryKind() { assertEquals(GraphNodeKind.Model, graphNodeKind(false, "planner", null)) diff --git a/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt b/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt index aa643456..47ff4463 100644 --- a/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt +++ b/android/app/src/test/java/net/awan/pipelines/ui/graph/WorkflowGraphTest.kt @@ -518,6 +518,56 @@ class WorkflowGraphTest { assertFalse(edgeIsExecuted(notTaken, runState)) } + /** + * The emphasis contract: an executed `success`/`error` edge uses the widest + * named stroke token, every other executed outcome a finer one and a + * not-executed edge the finest, with the arrowhead scaled to match. The + * definition-only view applies the same pass/fail emphasis. + */ + @Test + fun executedPassFailEdgesAreTheWidest() { + val graph = sampleGraph() + val success = graph.edges().first { it.outcome == "success" } + val error = graph.edges().first { it.outcome == "error" } + val other = graph.edges().first { it.outcome == "blocked" } + val untaken = graph.edges().first { it.outcome == "rejected" } + val runState = RunGraphState( + visitedStages = setOf("planner", "implementer", "reviewer"), + takenRoutes = setOf( + GraphRoute(success.source, success.outcome, success.target), + GraphRoute(error.source, error.outcome, error.target), + GraphRoute(other.source, other.outcome, other.target), + ), + currentStage = "reviewer", + ) + + val passFailWidth = edgeStrokeWidth(success, runState) + assertEquals(passFailWidth, edgeStrokeWidth(error, runState), 0.001f) + assertTrue(edgeStrokeWidth(other, runState) < passFailWidth) + assertTrue(edgeStrokeWidth(untaken, runState) < edgeStrokeWidth(other, runState)) + assertTrue(edgeStrokeWidth(untaken, runState) > 0f) + + // The arrowhead scales with the heavier stroke. + assertEquals(edgeArrowHeadSize(success, runState), edgeArrowHeadSize(error, runState), 0.001f) + assertTrue(edgeArrowHeadSize(success, runState) > edgeArrowHeadSize(other, runState)) + + // The definition-only view emphasises the same pass/fail edges. + assertEquals(passFailWidth, edgeStrokeWidth(success, null), 0.001f) + assertTrue(isEmphasizedEdge(success, runState)) + assertFalse(isEmphasizedEdge(other, runState)) + assertFalse(isEmphasizedEdge(untaken, runState)) + } + + /** Only `success` and `error` are the decisive, emphasised outcomes. */ + @Test + fun onlySuccessAndErrorArePassFailOutcomes() { + assertTrue(isPassFailOutcome("success")) + assertTrue(isPassFailOutcome("error")) + for (outcome in listOf("blocked", "rejected", "skipped", "exhausted", "approved", "done", "")) { + assertFalse(outcome, isPassFailOutcome(outcome)) + } + } + /** * The not-executed dash pattern is a real on/off rhythm, not a faded tint: a * positive, even-length interval list so a dashed stroke reads differently