test(jvm-codegen): cover Kotlin long/double/bool scalar arrays + Java extract throw-on-lost-required + Kotlin optional-absent

Gap A: Kotlin compile-run extractor fixture extended with required
List<Long>/List<Double>/List<Boolean> scalar arrays (counts/weights/active),
asserting typed values + boxed element types — exercising the it.toLong()/
it.toDouble()/it.toBoolean() element parses the int/float fixture left untested.

Gap B: Java GeneratedExtractorCompileRunTest now asserts the generated
<Name>Extractor.extract(loader, lostRequiredText) throws — reflectively unwraps
InvocationTargetException and asserts the cause is
com.metaobjects.render.extract.ExtractException (a RuntimeException) naming the
lost required path, for both pojoAware + valueObject flavors.

Gap C (Kotlin optional-absent -> null): N/A. KotlinPayloadGenerator types every
payload field non-null (via KotlinTypeMapper.kotlinTypeName, no @required-based
nullability) — same all-required-payload shape as the C# port — so an
absent-optional cannot be represented as null; documented as the no-skew
invariant in KotlinExtractorGenerator.

Test-only. codegen-kotlin + codegen-spring: 81 tests green, no regression.

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

Author: dmealing

server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/KotlinExtractorCompilesTest.kt

@@ -26,6 +26,9 @@ import kotlin.test.fail
  *  - REQUIRED string scalar-array (tags: List<String>)
  *  - REQUIRED int scalar-array (scores: List<Int>) — proves non-string scalar arrays (the C# bug)
  *  - REQUIRED float scalar-array (ratings: List<Float>) — proves a non-Int numeric element parse
+ *  - REQUIRED long scalar-array (counts: List<Long>) — proves the Long element parse (it.toLong())
+ *  - REQUIRED double scalar-array (weights: List<Double>) — proves the Double element parse
+ *  - REQUIRED bool scalar-array (active: List<Boolean>) — proves the Boolean element parse
  *  - REQUIRED enum scalar-array (flags: List<String>) — proves the enum element type passthrough
  *  - OPTIONAL scalar (note: String)
  *
@@ -51,6 +54,9 @@ class KotlinExtractorCompilesTest {
             { "field.string":   { "name": "tags", "isArray": true, "@required": true } },
             { "field.int":      { "name": "scores", "isArray": true, "@required": true } },
             { "field.float":    { "name": "ratings", "isArray": true, "@required": true } },
+            { "field.long":     { "name": "counts", "isArray": true, "@required": true } },
+            { "field.double":   { "name": "weights", "isArray": true, "@required": true } },
+            { "field.boolean":  { "name": "active", "isArray": true, "@required": true } },
             { "field.enum":     { "name": "flags", "isArray": true, "@required": true, "@values": ["A", "B"] } },
             { "field.string":   { "name": "note" } }
         ] } },
@@ -102,6 +108,9 @@ class KotlinExtractorCompilesTest {
                 "\"tags\":[\"x\",\"y\"]," +
                 "\"scores\":[3,7]," +
                 "\"ratings\":[1.5,2.5]," +
+                "\"counts\":[10,20]," +
+                "\"weights\":[1.25,2.75]," +
+                "\"active\":[true,false]," +
                 "\"flags\":[\"A\",\"B\"]," +
                 "\"note\":\"hi\",}\n```"
 
@@ -135,6 +144,24 @@ class KotlinExtractorCompilesTest {
             assertEquals(listOf(1.5f, 2.5f), ratings,
                 "float scalar-array must populate as typed List<Float> (non-Int numeric element parse)")
 
+            @Suppress("UNCHECKED_CAST")
+            val counts = orderClass.getDeclaredMethod("getCounts").invoke(order) as List<Long>
+            assertEquals(listOf(10L, 20L), counts,
+                "long scalar-array must populate as typed List<Long> (it.toLong() element parse)")
+            counts.forEach { assertTrue(it is Long, "counts element must be a boxed Long, got ${it!!::class}") }
+
+            @Suppress("UNCHECKED_CAST")
+            val weights = orderClass.getDeclaredMethod("getWeights").invoke(order) as List<Double>
+            assertEquals(listOf(1.25, 2.75), weights,
+                "double scalar-array must populate as typed List<Double> (it.toDouble() element parse)")
+            weights.forEach { assertTrue(it is Double, "weights element must be a boxed Double, got ${it!!::class}") }
+
+            @Suppress("UNCHECKED_CAST")
+            val active = orderClass.getDeclaredMethod("getActive").invoke(order) as List<Boolean>
+            assertEquals(listOf(true, false), active,
+                "boolean scalar-array must populate as typed List<Boolean> (it.toBoolean() element parse)")
+            active.forEach { assertTrue(it is Boolean, "active element must be a boxed Boolean, got ${it!!::class}") }
+
             @Suppress("UNCHECKED_CAST")
             val flags = orderClass.getDeclaredMethod("getFlags").invoke(order) as List<String>
             assertEquals(listOf("A", "B"), flags,
@@ -156,7 +183,8 @@ class KotlinExtractorCompilesTest {
             val extractLenientMethod = extractorClass.getDeclaredMethod("extractLenient", loaderClass, String::class.java)
             val clean = "{\"customer\":{\"name\":\"Ada\"}," +
                 "\"lines\":[{\"sku\":\"A\",\"qty\":1}]," +
-                "\"tags\":[\"x\"],\"scores\":[3],\"ratings\":[1.5],\"flags\":[\"A\"],\"note\":\"hi\"}"
+                "\"tags\":[\"x\"],\"scores\":[3],\"ratings\":[1.5]," +
+                "\"counts\":[10],\"weights\":[1.25],\"active\":[true],\"flags\":[\"A\"],\"note\":\"hi\"}"
             val rr = extractLenientMethod.invoke(extractorInstance, loader, clean)
             val reportClass = cl.loadClass("com.metaobjects.render.extract.ExtractionReport")
             val report = rr.javaClass.getMethod("report").invoke(rr)

server/java/codegen-spring/src/test/java/com/metaobjects/generator/spring/GeneratedExtractorCompileRunTest.java

@@ -262,6 +262,33 @@ private void runFlavor(String flavor, String loaderName) throws Exception {
             Object extracted = result.getClass().getMethod("data").invoke(result);
             assertSame("extractLenient().data() must be the generated flavored type",
                     answerCls, extracted.getClass());
+
+            // --- extract(loader, lostRequired) — the strict orThrow() gate fires ---
+            // The payload marks `title` @required. Feed input that loses it (well-formed JSON with
+            // NO title); the generated extract(...) must throw the strict lost-required exception
+            // (com.metaobjects.render.extract.ExtractException, a RuntimeException), surfaced via
+            // reflection as an InvocationTargetException whose cause is that type.
+            String lostRequired = "{\"count\":3,"
+                    + "\"address\":{\"city\":\"Austin\",\"zip\":\"78701\"},"
+                    + "\"items\":[{\"sku\":\"A1\",\"qty\":2}]}";
+            Class<?> extractExceptionCls = cl.loadClass("com.metaobjects.render.extract.ExtractException");
+            try {
+                extract.invoke(null, loader, lostRequired);
+                fail("extract(...) must throw when a required field is lost (flavor=" + flavor + ")");
+            } catch (java.lang.reflect.InvocationTargetException ite) {
+                Throwable cause = ite.getCause();
+                assertNotNull("InvocationTargetException must carry a cause (flavor=" + flavor + ")", cause);
+                assertSame("extract(...) lost-required cause must be ExtractException (flavor=" + flavor
+                                + "); got " + cause.getClass().getName(),
+                        extractExceptionCls, cause.getClass());
+                assertTrue("ExtractException must be a RuntimeException",
+                        cause instanceof RuntimeException);
+                // and it must name the lost required path
+                @SuppressWarnings("unchecked")
+                List<String> lost = (List<String>) cause.getClass().getMethod("lostRequired").invoke(cause);
+                assertTrue("lostRequired() must name `title` (flavor=" + flavor + "); got " + lost,
+                        lost.contains("title"));
+            }
         }
     }
 }