test(#1975): boundary + dispatch + sealed-schema tests

Second batch for #1975. After first batch (4b2f564) dropped the cluster
65 → 41, PIT identified the residual mutants as concentrated in:

- coerceToInt/coerceToLong Double/Float branch boundaries
- coerceValue private dispatch (Float type, raw-List early-return)
- hasGenerableAnnotation cache vs reflection short-circuits
- variantJsonSchema / sealedJsonSchema / sealedLlmDescription —
  the sealed-hierarchy schema-generation surfaces

Two new files:

**CoerceBoundaryAndDispatchTest** (20 tests) — exact-boundary tests for
the Double/Float branches inside coerceToInt + coerceToLong (lines 590,
596, 677, 683). Plus coerceValue dispatch through constructFromMap with
new @generable wrappers (IntWrap, LongWrap, DoubleWrap, FloatWrap,
RawListWrap). Plus hasGenerableAnnotation tests with @generable and
non-@generable classes (PlainGenerable vs String).

**SealedSchemaGenerationTest** (11 tests) — uses a 3-variant ReviewDecision
sealed hierarchy (Approved + Rejected + Deferred) to exercise:
- sealedJsonSchema separator placement (`if (i > 0) append(",")` — kills
  the ConditionalsBoundary mutant that would produce `[,{...},{...}]`)
- variantJsonSchema type discriminator emission (const string per variant)
- variantJsonSchema required-list filter (nullable fields like
  Approved.notes must NOT appear in required; non-nullable must appear)
- variantJsonSchema null-ctor handling (Deferred data-object has only
  the type discriminator in properties + required)
- sealedLlmDescription optional-description guard (with and without
  @generable description text)
- toLlmDescription sealed-vs-data-class dispatch
- "Choose one of the following variants:" intro present for sealed,
  absent for data class

31 new tests total, all green. Expected PIT impact: GenerableSupportKt
cluster drops from 41 → low teens (target was <25 per #1975 acceptance).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Skobeltsyn

src/test/kotlin/agents_engine/generation/CoerceBoundaryAndDispatchTest.kt

@@ -0,0 +1,189 @@
+package agents_engine.generation
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+// Second batch for #1975. Focuses on the residual mutants
+// CoerceHelpersBranchTest didn't reach:
+//
+// - coerceToInt:590, 596   — Double/Float branch boundary at Int.MAX_VALUE.toDouble()
+//                            (ConditionalsBoundary mutants)
+// - coerceToLong:677, 683  — Float branch boundary at Long.MAX_VALUE.toDouble()
+// - coerceValue:561        — Float dispatch path (private — via constructFromMap)
+// - coerceValue:565        — List-without-type-parameter early-return (private)
+// - hasGenerableAnnotation:619, 620  — KSP cache-hit short-circuit
+//
+// Tests exercise these via constructFromMap with @Generable wrappers — the
+// helpers are private, so we drive them through the public surface.
+
+@Generable("Int wrapper") data class IntWrap(val n: Int)
+@Generable("Long wrapper") data class LongWrap(val n: Long)
+@Generable("Double wrapper") data class DoubleWrap(val v: Double)
+@Generable("Float wrapper") data class FloatWrap(val v: Float)
+@Generable("Raw list wrapper") data class RawListWrap(val items: List<*>)
+@Generable("Plain marker") data class PlainGenerable(val name: String)
+
+class CoerceBoundaryAndDispatchTest {
+
+    // ── coerceToInt — Double branch boundary (line 590) ───────────────────────
+
+    @Test fun `coerceInt accepts Int_MAX_VALUE_toDouble exactly (Double branch)`() {
+        // Kills ConditionalsBoundaryMutator on line 590:
+        //   if (n > Int.MAX_VALUE.toDouble()) return null
+        // The mutant flips `>` to `>=`. The mutated condition would reject
+        // n == Int.MAX_VALUE.toDouble(). We assert it ACCEPTS this exact value.
+        val result = IntWrap::class.constructFromMap(mapOf("n" to Int.MAX_VALUE.toDouble()))
+        assertNotNull(result, "Int.MAX_VALUE as Double exactly must coerce successfully")
+        assertEquals(Int.MAX_VALUE, result!!.n)
+    }
+
+    @Test fun `coerceInt accepts Int_MIN_VALUE_toDouble exactly (Double branch)`() {
+        // Mirror — the lower boundary mutant.
+        val result = IntWrap::class.constructFromMap(mapOf("n" to Int.MIN_VALUE.toDouble()))
+        assertNotNull(result)
+        assertEquals(Int.MIN_VALUE, result!!.n)
+    }
+
+    @Test fun `coerceInt rejects just-above Int_MAX as Double`() {
+        // Anchors the boundary from the other side.
+        val result = IntWrap::class.constructFromMap(
+            mapOf("n" to Int.MAX_VALUE.toDouble() + 1.0)
+        )
+        assertNull(result, "Int.MAX_VALUE + 1.0 (Double) must reject")
+    }
+
+    @Test fun `coerceInt rejects just-below Int_MIN as Double`() {
+        val result = IntWrap::class.constructFromMap(
+            mapOf("n" to Int.MIN_VALUE.toDouble() - 1.0)
+        )
+        assertNull(result, "Int.MIN_VALUE - 1.0 (Double) must reject")
+    }
+
+    // ── coerceToInt — Float branch boundary (line 596) ────────────────────────
+
+    @Test fun `coerceInt Float branch accepts whole value within range`() {
+        // Kills ConditionalsBoundaryMutator on line 596 (Float branch's range check).
+        // Float can't exactly represent Int.MAX_VALUE; use a value safely within
+        // the Float's precision so the equality with floor(n) holds.
+        val result = IntWrap::class.constructFromMap(mapOf("n" to 1_000_000.0f))
+        assertNotNull(result)
+        assertEquals(1_000_000, result!!.n)
+    }
+
+    @Test fun `coerceInt Float branch rejects huge value above Int_MAX`() {
+        val result = IntWrap::class.constructFromMap(mapOf("n" to 1e10f))
+        assertNull(result, "1e10 as Float exceeds Int.MAX_VALUE → reject")
+    }
+
+    @Test fun `coerceInt Float branch rejects huge negative value below Int_MIN`() {
+        val result = IntWrap::class.constructFromMap(mapOf("n" to -1e10f))
+        assertNull(result, "-1e10 as Float below Int.MIN_VALUE → reject")
+    }
+
+    // ── coerceToLong — Float branch boundary (lines 677, 683) ─────────────────
+
+    @Test fun `coerceLong Float branch accepts whole value within range`() {
+        val result = LongWrap::class.constructFromMap(mapOf("n" to 1_000_000.0f))
+        assertNotNull(result)
+        assertEquals(1_000_000L, result!!.n)
+    }
+
+    @Test fun `coerceLong Double branch boundary at large value within range`() {
+        // 1e15 is exactly representable as Double (within mantissa precision)
+        // AND well within Long range — covers the upper-branch happy path.
+        val result = LongWrap::class.constructFromMap(mapOf("n" to 1e15))
+        assertNotNull(result)
+        assertEquals(1_000_000_000_000_000L, result!!.n)
+    }
+
+    @Test fun `coerceLong Double branch rejects out-of-Long-range`() {
+        // 1e20 exceeds Long.MAX_VALUE (~9.2e18). Kills the boundary check.
+        val result = LongWrap::class.constructFromMap(mapOf("n" to 1e20))
+        assertNull(result)
+    }
+
+    @Test fun `coerceLong Float branch rejects out-of-Long-range`() {
+        val result = LongWrap::class.constructFromMap(mapOf("n" to 1e20f))
+        assertNull(result)
+    }
+
+    // ── coerceValue — Float dispatch path (line 561) ──────────────────────────
+
+    @Test fun `coerceValue Float type accepts Number-as-Float`() {
+        // Drives coerceValue line 561: Float::class -> (value as? Number)?.toFloat()
+        val result = FloatWrap::class.constructFromMap(mapOf("v" to 3.14))
+        assertNotNull(result)
+        assertEquals(3.14f, result!!.v, 1e-3f)
+    }
+
+    @Test fun `coerceValue Float type rejects non-Number`() {
+        // Drives the `(value as? Number)?` short-circuit at line 561.
+        // The mutant that strips `as? Number` would NPE; current code returns null.
+        val result = FloatWrap::class.constructFromMap(mapOf("v" to "3.14"))
+        assertNull(result, "String value must not silently coerce to Float")
+    }
+
+    @Test fun `coerceValue Double type accepts Number-as-Double`() {
+        val result = DoubleWrap::class.constructFromMap(mapOf("v" to 42))
+        assertNotNull(result)
+        assertEquals(42.0, result!!.v, 1e-9)
+    }
+
+    @Test fun `coerceValue Double type rejects non-Number`() {
+        val result = DoubleWrap::class.constructFromMap(mapOf("v" to "42.0"))
+        assertNull(result)
+    }
+
+    // ── coerceValue — List-without-type-parameter (line 565) ──────────────────
+
+    @Test fun `coerceValue raw List (star-projected) returns items as-is`() {
+        // Line 565: `val elementType = type.arguments.firstOrNull()?.type ?: return items`
+        // The early return happens when the List has no type argument (raw or
+        // star-projected). Test asserts items are passed through untouched.
+        val result = RawListWrap::class.constructFromMap(
+            mapOf("items" to listOf("a", 1, true, null))
+        )
+        assertNotNull(result)
+        assertEquals(4, result!!.items.size)
+        assertEquals("a", result.items[0])
+        assertEquals(1, result.items[1])
+        assertEquals(true, result.items[2])
+        assertNull(result.items[3])
+    }
+
+    @Test fun `coerceValue raw List with empty input returns empty list`() {
+        val result = RawListWrap::class.constructFromMap(mapOf("items" to emptyList<Any?>()))
+        assertNotNull(result)
+        assertEquals(0, result!!.items.size)
+    }
+
+    @Test fun `coerceValue raw List rejects non-List value`() {
+        // Same line 565 — preceding `value as? List<*> ?: return null` is the
+        // typed-cast guard. Kills the mutant that swaps `?:` for non-null assert.
+        val result = RawListWrap::class.constructFromMap(mapOf("items" to "not a list"))
+        assertNull(result)
+    }
+
+    // ── hasGenerableAnnotation (lines 619, 620) ───────────────────────────────
+
+    @Test fun `hasGenerableAnnotation true for @Generable class via reflection fallback`() {
+        // Line 620: `if (GeneratedMetaCache.lookupLlmDescription(this) != null) return true`
+        // (and the reflection fallback after). Kills the boolean-return mutant.
+        assertTrue(
+            PlainGenerable::class.hasGenerableAnnotation(),
+            "PlainGenerable carries @Generable; probe must return true",
+        )
+    }
+
+    @Test fun `hasGenerableAnnotation false for non-Generable class`() {
+        // Kills mutant that hardcodes true.
+        assertEquals(
+            false,
+            String::class.hasGenerableAnnotation(),
+            "String has no @Generable; probe must return false",
+        )
+    }
+}

src/test/kotlin/agents_engine/generation/SealedSchemaGenerationTest.kt

@@ -0,0 +1,162 @@
+package agents_engine.generation
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.test.assertFalse
+
+// Third batch for #1975. Targets the sealed-hierarchy schema/description
+// generators that the existing GenerableSupportTest doesn't exercise deeply:
+//
+// - variantJsonSchema:255, 260, 759  — 7 mutants on the per-variant emitter
+// - sealedJsonSchema:243              — `if (i > 0) append(",")` separator
+// - sealedLlmDescription:167          — `if (genDescription.isNotEmpty())` guard
+// - toLlmDescription:138              — sealed-dispatch in the public entry
+//
+// These are the "byte-identical to runtime" surfaces #1975 calls out as
+// load-bearing for prompt-cache determinism (and for KSP parity).
+
+@Generable("A decision a user can make")
+sealed interface ReviewDecision {
+    @Generable("Approve the request") data class Approved(val by: String, val notes: String?) : ReviewDecision
+    @Generable("Reject with a reason") data class Rejected(val by: String, val reason: String) : ReviewDecision
+    @Generable("Defer to later — no fields") data object Deferred : ReviewDecision
+}
+
+@Generable
+sealed interface UndescribedRoot {
+    @Generable data class Variant(val n: Int) : UndescribedRoot
+}
+
+@Generable("Empty root")
+sealed interface EmptyRoot
+
+class SealedSchemaGenerationTest {
+
+    // ── sealedJsonSchema separator + variant ordering (line 243) ──────────────
+
+    @Test fun `sealed JSON schema wraps oneOf around all variants`() {
+        val schema = ReviewDecision::class.jsonSchema()
+        assertTrue(schema.startsWith("""{"oneOf":["""), "must lead with oneOf array")
+        assertTrue(schema.endsWith("]}"), "must close with array + outer brace")
+    }
+
+    @Test fun `sealed JSON schema places comma BETWEEN variants, not before first or after last`() {
+        // Kills ConditionalsBoundaryMutator on line 243: `if (i > 0) append(",")`
+        // Mutant flips `>` to `>=` which would prepend a comma before variant 0
+        // — `[,{"type":...},{"type":...}]` — invalid JSON.
+        val schema = ReviewDecision::class.jsonSchema()
+        assertFalse(schema.contains("[,"), "leading comma is broken JSON: $schema")
+        assertFalse(schema.contains(",]"), "trailing comma is broken JSON: $schema")
+        // Three variants → exactly two commas between variant objects.
+        val variantCommas = Regex("\\},\\{").findAll(schema).count()
+        assertEquals(2, variantCommas, "ReviewDecision has 3 variants → exactly 2 inter-variant commas, got $variantCommas in $schema")
+    }
+
+    // ── variantJsonSchema: type discriminator + properties (lines 255, 260) ──
+
+    @Test fun `each variant carries type discriminator with const matching simpleName`() {
+        // variantJsonSchema:254 emits the const string. Kills mutants that drop
+        // the const or use a wrong source.
+        val schema = ReviewDecision::class.jsonSchema()
+        assertTrue(
+            schema.contains(""""type":{"type":"string","const":"Approved"}"""),
+            "missing Approved type discriminator in: $schema",
+        )
+        assertTrue(schema.contains(""""const":"Rejected""""))
+        assertTrue(schema.contains(""""const":"Deferred""""))
+    }
+
+    @Test fun `variant properties include all primary-ctor params`() {
+        // variantJsonSchema:255 forEach loop emits property entries.
+        // The forEach is mutated by `negated conditional` (skipping iterations).
+        // Three Approved params expected: type (discriminator), by, notes.
+        val schema = ReviewDecision::class.jsonSchema()
+        // The "Approved" variant should reference "by" and "notes" in its properties.
+        val approvedFragment = schema.substringAfter(""""const":"Approved"""").substringBefore("""{"type":"object"""")
+        assertTrue(approvedFragment.contains(""""by"""), "Approved schema missing 'by' field")
+        assertTrue(approvedFragment.contains(""""notes"""), "Approved schema missing 'notes' field")
+    }
+
+    @Test fun `required list includes type and only non-nullable non-optional params`() {
+        // variantJsonSchema:260 filter — kills the "skip filter" mutant
+        // (would include nullable fields like Approved.notes in required).
+        val schema = ReviewDecision::class.jsonSchema()
+        // Approved.notes is nullable → must NOT be in its variant's required list.
+        // Approved.by is non-null → MUST be in its required list.
+        val approvedFragment = schema.substringAfter(""""const":"Approved"""")
+            .substringBefore("""{"type":"object"""")
+        val requiredSection = approvedFragment.substringAfter(""""required":[""", "").substringBefore("""]""", "")
+        assertTrue(requiredSection.contains(""""type""""), "type discriminator must always be required")
+        assertTrue(requiredSection.contains(""""by""""), "non-nullable 'by' must be required")
+        assertFalse(requiredSection.contains(""""notes""""), "nullable 'notes' must NOT be required, got: $requiredSection")
+    }
+
+    @Test fun `data-object variant has only the type discriminator and required`() {
+        // Deferred has no ctor params. variantJsonSchema:251 — if ctor is null,
+        // no properties are emitted beyond the discriminator.
+        // sealedSubclasses ordering is NOT source-order; can't substringBefore("]}")
+        // across the whole schema. Instead, assert the immediate sequence after
+        // the Deferred discriminator: `}},"required":["type"],"additionalProperties":false}`
+        // (no comma → no extra property, no comma in required → no extra required).
+        val schema = ReviewDecision::class.jsonSchema()
+        assertTrue(
+            schema.contains(""""const":"Deferred"}},"required":["type"],"additionalProperties":false}"""),
+            "Deferred should have no ctor params: properties should hold ONLY the type discriminator, " +
+                "required list should hold ONLY \"type\". Actual schema: $schema",
+        )
+    }
+
+    // ── sealedLlmDescription: optional-description guard (line 167) ──────────
+
+    @Test fun `sealed description includes Generable description when present`() {
+        // Line 167: `if (genDescription.isNotEmpty())` — mutant flips to always-true
+        // or always-false. Test asserts the description text appears.
+        val desc = ReviewDecision::class.toLlmDescription()
+        assertTrue(
+            desc.contains("A decision a user can make"),
+            "Generable description must appear in sealed output: $desc",
+        )
+    }
+
+    @Test fun `sealed description omits empty-description gap`() {
+        // Same line 167, other side. UndescribedRoot has no description text
+        // → no blank line + description block; just `## UndescribedRoot` followed by
+        // the variants section.
+        val desc = UndescribedRoot::class.toLlmDescription()
+        assertTrue(desc.startsWith("## UndescribedRoot"))
+        // Should NOT have a `description` text — only the variants intro.
+        assertTrue(desc.contains("Choose one of the following variants:"))
+    }
+
+    @Test fun `sealed description lists all variants`() {
+        val desc = ReviewDecision::class.toLlmDescription()
+        // Each variant should be enumerated by name in the variants section.
+        assertTrue(desc.contains("Approved"), "missing Approved variant in: $desc")
+        assertTrue(desc.contains("Rejected"))
+        assertTrue(desc.contains("Deferred"))
+    }
+
+    // ── toLlmDescription: sealed dispatch (line 138) ─────────────────────────
+
+    @Test fun `sealed root routes to sealedLlmDescription not dataClassLlmDescription`() {
+        // toLlmDescription:137 `if (isSealed) sealedLlmDescription() else dataClassLlmDescription()`.
+        // Mutant negates the conditional → routes sealed to dataClass path,
+        // which would NOT contain "Choose one of the following variants:".
+        val desc = ReviewDecision::class.toLlmDescription()
+        assertTrue(
+            desc.contains("Choose one of the following variants:"),
+            "sealed dispatch broken — must include variants intro: $desc",
+        )
+    }
+
+    @Test fun `non-sealed data class routes to dataClassLlmDescription not sealedLlmDescription`() {
+        // The other side of the dispatch.
+        val desc = IntWrap::class.toLlmDescription()
+        assertFalse(
+            desc.contains("Choose one of the following variants:"),
+            "non-sealed routed to sealed path — wrong dispatch: $desc",
+        )
+        assertTrue(desc.startsWith("## IntWrap"))
+    }
+}