test: compare the ported ConstraintSetParser against the oracle

[Lavmee]

A fourth differential harness in :parity, comparing the ported Kotlin ConstraintSetParser against the vendored upstream Java copy over generated ConstraintSet JSON documents.

Before this, ConstraintSetParser — 2040 lines, the largest file in core/state and the hot path for every JSON-driven ConstraintLayout and MotionLayout use — was covered by one test file of 101 lines containing two tests that print to stdout and share a single assertNotNull between them.

Nothing under compose/src/ is touched.

Results

Differential comparison	2000 generated documents × 2 entry points, 0 divergences
Axis liveness	42 of 42, none ignored
:parity:test	126 tests across 20 classes, 0 skipped

How it works

A syntax-free ConstraintSetSpec describes a document; JsonEmitter renders it to DSL text; two subjects parse that identical string with their own package's classes, apply the resulting State to a container, and render the geometry plus every custom attribute. The differential test requires the two renderings to be equal. Same shape as the solver/ and motion/ harnesses.

The subjects drive populateState(CLParser.parse(json), state, LayoutVariables()) rather than the public parseJSON wrapper. The wrapper catches CLParsingException and prints it, leaving the State half-populated with no signal — faithful to upstream, which does the same, but blind as an observation point.

The part worth reading

Nine of the forty-two axes were dead on the first pass. Seven — biases, weights, chain style, centerVertically — were generated and emitted while the observed result did not depend on them at all. The cause turned out to be deeper than a missing measure() call: neither subject told State the document's root size, so the root defaulted to WRAP_CONTENT, which silently disables bias-centering and chain/MATCH_CONSTRAINT resolution. The other two were variables, which the parser resolves through layoutVariables[...] for every transform and bias attribute — the emitter simply never referenced one by name.

Without that check, the headline "zero divergences over 2000 documents" would have been reported over a corpus where a large slice of the generated variety never reached the code. This is the same failure the motion/ harness shipped a month ago with five dead axes, green the whole time.

The first fix landed one level short. setWidth/setHeight went into the new measure entry, but the differential test called only parse — so seven axes were certified live through a path the 2000-seed comparison never used. The test now runs both entries, comparing each against its own counterpart, as SolverDifferentialTest already does. Measured independently: parse and measure produce different geometry for 1862 of 1876 laid-out documents, so the second entry is real coverage rather than a copy.

The harness is shown able to fail before being trusted to pass. Making parseDimensionMode return createWrap() for "spread" turns the differential test red on 405 of 2000 seeds; reverting turns it green. The guards are derived from measurement, not guessed: minimumPopulated catches wholesale rejection, minimumGeometryRows catches wholesale vacuity — a corpus of {} documents would satisfy the first and fail the second.

Upstream defects found, and deliberately not fixed

Three, all present verbatim in the vendored Java, so the port is faithful and correcting any of them would create a divergence:

• parseDesignElementsJSON indexes its inner loop with the outer loop's variable and labels every element with the literal string "Design" instead of its own id. Three separate agents reported this as a port defect during development; it is not.
• parseColorString's KDoc promises -1 on unparseable input but throws NumberFormatException for #-prefixed values that are not six hex digits.
• parseVariables reads numbers through CLNumber.getInt(), which does content().toInt() and throws on any fractional literal, inconsistently with getFloat() in the same class.

The generator deliberately draws inputs that reach the last two at a low rate, because a crash both sides produce identically is legitimate differential coverage of an error path.

What this does not cover

No generated document anchors a widget to a guideline, a barrier or a chain — the generator builds widgets first, so anchor targets can only name widgets. Guidelines and barriers do appear in the corpus and their own positions are compared, but the interaction they exist for is compared nowhere. This is recorded in the generator's KDoc so the coverage claim is not read as broader than it is.

parseMotionSceneJSON and parseTransitions are out of scope; they reach Transition.kt (1247 lines) and need their own scenario model. Natural next increment.

parseDesignElementsJSON's differential test necessarily passes, because the function is broken identically on both sides. Its own KDoc says so plainly: a pass there confirms the port matches upstream, not that the function does anything useful.