Test new constructor-based parsing behaviors via t1-t3 pipeline

Adds two new immutable POJO fixtures wired into TestRootObjectType so the
t1 (expected roundtrip), t2 (generated-vs-expected), and t3 (generated
roundtrip) scripts all exercise the new behaviors:

- TestConstructorWithGenericsType — constructor params List<String>,
  Map<String,Integer>, Set<String>, int[], String[]. Covers stripGenerics
  matching plus the variableName overrides on CollectionFieldParser,
  MapFieldParser, and PrimitiveArrayFieldParser.
- TestConstructorWithIgnoredFieldType — final @JsonIgnore field that is
  NOT a constructor parameter (derived from another). Covers
  getParseableFields skipping @JsonIgnore on the constructor-based path
  so the single-arg constructor matches the single parseable field.

Plus a focused unit test CustomObjectFieldParserTest for the isJdkMap
guard (raw java.util Maps don't route to a non-existent parser; user
Map subclasses still pass through).

Author: JornC

gwt-beans-codegen-core/src/test/java/nl/aerius/codegen/generator/parser/CustomObjectFieldParserTest.java

@@ -0,0 +1,41 @@
+package nl.aerius.codegen.generator.parser;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.TreeMap;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Tests the canHandle dispatch guards on CustomObjectFieldParser, in particular the
+ * JDK-Map exclusion that prevents raw java.util Map types from routing to a
+ * non-existent generated parser, while still letting user Map subclasses fall through
+ * so they can be picked up by a custom parser.
+ */
+class CustomObjectFieldParserTest {
+
+  private final CustomObjectFieldParser parser = new CustomObjectFieldParser(new HashMap<>());
+
+  @Test
+  void canHandleRejectsRawJdkMapTypes() {
+    assertFalse(parser.canHandle(Map.class), "raw Map should not route to CustomObjectFieldParser");
+    assertFalse(parser.canHandle(HashMap.class), "raw HashMap should not route to CustomObjectFieldParser");
+    assertFalse(parser.canHandle(LinkedHashMap.class), "raw LinkedHashMap should not route to CustomObjectFieldParser");
+    assertFalse(parser.canHandle(TreeMap.class), "raw TreeMap should not route to CustomObjectFieldParser");
+  }
+
+  @Test
+  void canHandleAcceptsUserMapSubclass() {
+    assertTrue(parser.canHandle(UserMapSubclass.class),
+        "user-defined Map subclass should fall through so a custom parser can handle it by simple name");
+  }
+
+  /** User-defined Map subclass - by extending HashMap from a non-java.* package, it should not be excluded. */
+  private static final class UserMapSubclass extends HashMap<String, String> {
+    private static final long serialVersionUID = 1L;
+  }
+}

gwt-beans-codegen-core/src/test/java/nl/aerius/codegen/test/types/TestConstructorWithGenericsType.java

@@ -0,0 +1,72 @@
+package nl.aerius.codegen.test.types;
+
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Immutable test type whose constructor parameters cover the generic-collection
+ * and primitive-array cases that exercise:
+ * - ConstructorAnalyzer matching List<X>/Map<K,V>/Set<X> source
+ *   types against raw reflection types (stripGenerics).
+ * - CollectionFieldParser, MapFieldParser, and PrimitiveArrayFieldParser using
+ *   the field name for their result variable (variableName overload) so sibling
+ *   constructor params don't collide on level-based names.
+ */
+public class TestConstructorWithGenericsType {
+  private final List<String> tags;
+  private final Map<String, Integer> counts;
+  private final Set<String> labels;
+  private final int[] sizes;
+  private final String[] aliases;
+
+  public TestConstructorWithGenericsType(final List<String> tags, final Map<String, Integer> counts,
+      final Set<String> labels, final int[] sizes, final String[] aliases) {
+    this.tags = tags;
+    this.counts = counts;
+    this.labels = labels;
+    this.sizes = sizes;
+    this.aliases = aliases;
+  }
+
+  public List<String> getTags() {
+    return tags;
+  }
+
+  public Map<String, Integer> getCounts() {
+    return counts;
+  }
+
+  public Set<String> getLabels() {
+    return labels;
+  }
+
+  public int[] getSizes() {
+    return sizes;
+  }
+
+  public String[] getAliases() {
+    return aliases;
+  }
+
+  public static TestConstructorWithGenericsType createFullObject() {
+    final Map<String, Integer> counts = new LinkedHashMap<>();
+    counts.put("alpha", 1);
+    counts.put("beta", 2);
+    final Set<String> labels = new HashSet<>();
+    labels.add("first");
+    labels.add("second");
+    return new TestConstructorWithGenericsType(
+        List.of("a", "b", "c"),
+        counts,
+        labels,
+        new int[] {10, 20, 30},
+        new String[] {"x", "y"});
+  }
+
+  public static TestConstructorWithGenericsType createNullObject() {
+    return new TestConstructorWithGenericsType(null, null, null, null, null);
+  }
+}

gwt-beans-codegen-core/src/test/java/nl/aerius/codegen/test/types/TestConstructorWithIgnoredFieldType.java

@@ -0,0 +1,42 @@
+package nl.aerius.codegen.test.types;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+
+/**
+ * Immutable test type with a {@code @JsonIgnore} field that is NOT a constructor
+ * parameter (it is derived from another field). Verifies that the constructor-based
+ * code path skips {@code @JsonIgnore} fields in {@code getParseableFields}, so the
+ * single-arg constructor matches the single parseable field {@code name} instead of
+ * failing because the analyzer thinks there are two parseable fields.
+ *
+ * The {@code derivedHash} getter is annotated so Jackson also leaves it out of the
+ * round-trip JSON.
+ */
+public class TestConstructorWithIgnoredFieldType {
+  private final String name;
+
+  @JsonIgnore
+  private final int derivedHash;
+
+  public TestConstructorWithIgnoredFieldType(final String name) {
+    this.name = name;
+    this.derivedHash = name == null ? 0 : name.hashCode();
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  @JsonIgnore
+  public int getDerivedHash() {
+    return derivedHash;
+  }
+
+  public static TestConstructorWithIgnoredFieldType createFullObject() {
+    return new TestConstructorWithIgnoredFieldType("ignored-field-test");
+  }
+
+  public static TestConstructorWithIgnoredFieldType createNullObject() {
+    return new TestConstructorWithIgnoredFieldType(null);
+  }
+}

gwt-beans-codegen-core/src/test/java/nl/aerius/codegen/test/types/TestRootObjectType.java

@@ -23,6 +23,8 @@ public class TestRootObjectType {
   private TestPolyBase testPolyBase;
   private TestPrimitiveArrayType primitiveArrays;
   private TestConstructorBasedType constructorBased;
+  private TestConstructorWithGenericsType constructorWithGenerics;
+  private TestConstructorWithIgnoredFieldType constructorWithIgnoredField;
 
   public String getFoo() {
     return foo;
@@ -144,6 +146,22 @@ public void setConstructorBased(TestConstructorBasedType constructorBased) {
     this.constructorBased = constructorBased;
   }
 
+  public TestConstructorWithGenericsType getConstructorWithGenerics() {
+    return constructorWithGenerics;
+  }
+
+  public void setConstructorWithGenerics(TestConstructorWithGenericsType constructorWithGenerics) {
+    this.constructorWithGenerics = constructorWithGenerics;
+  }
+
+  public TestConstructorWithIgnoredFieldType getConstructorWithIgnoredField() {
+    return constructorWithIgnoredField;
+  }
+
+  public void setConstructorWithIgnoredField(TestConstructorWithIgnoredFieldType constructorWithIgnoredField) {
+    this.constructorWithIgnoredField = constructorWithIgnoredField;
+  }
+
   public static TestRootObjectType createFullObject() {
     TestRootObjectType obj = new TestRootObjectType();
     obj.setFoo("test string");
@@ -161,6 +179,8 @@ public static TestRootObjectType createFullObject() {
     obj.setTestPolyBase(new TestPolySubA("BaseValueA", 123));
     obj.setPrimitiveArrays(TestPrimitiveArrayType.createFullObject());
     obj.setConstructorBased(TestConstructorBasedType.createFullObject());
+    obj.setConstructorWithGenerics(TestConstructorWithGenericsType.createFullObject());
+    obj.setConstructorWithIgnoredField(TestConstructorWithIgnoredFieldType.createFullObject());
     return obj;
   }
 

gwt-beans-codegen-core/src/test/resources/parsers/expected/TestConstructorWithGenericsTypeParser.java

@@ -0,0 +1,84 @@
+package nl.aerius.codegen.test.generated;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.annotation.processing.Generated;
+
+import nl.aerius.codegen.test.types.TestConstructorWithGenericsType;
+import nl.aerius.json.JSONArrayHandle;
+import nl.aerius.json.JSONObjectHandle;
+
+@Generated(value = "nl.aerius.codegen.ParserGenerator", date = "2024-01-01T00:00:00")
+public class TestConstructorWithGenericsTypeParser {
+  public static TestConstructorWithGenericsType parse(final String jsonText) {
+    if (jsonText == null) {
+      return null;
+    }
+
+    return parse(JSONObjectHandle.fromText(jsonText));
+  }
+
+  public static TestConstructorWithGenericsType parse(final JSONObjectHandle baseObj) {
+    if (baseObj == null) {
+      return null;
+    }
+
+    // Parse tags
+    if (!baseObj.has("tags")) {
+      throw new RuntimeException("Required field 'tags' is missing");
+    }
+    final JSONArrayHandle tagsArray = baseObj.getArray("tags");
+    final List<String> tags = new ArrayList<>();
+    tagsArray.forEachString(tags::add);
+
+    // Parse counts
+    if (!baseObj.has("counts")) {
+      throw new RuntimeException("Required field 'counts' is missing");
+    }
+    final JSONObjectHandle obj = baseObj.getObject("counts");
+    final Map<String, Integer> counts = new LinkedHashMap<>();
+    obj.keySet().forEach(key -> {
+      final Integer level2Value = obj.getInteger(key);
+      counts.put(key, level2Value);
+    });
+
+    // Parse labels
+    if (!baseObj.has("labels")) {
+      throw new RuntimeException("Required field 'labels' is missing");
+    }
+    final JSONArrayHandle labelsArray = baseObj.getArray("labels");
+    final Set<String> labels = new HashSet<>();
+    labelsArray.forEachString(labels::add);
+
+    // Parse sizes
+    if (!baseObj.has("sizes")) {
+      throw new RuntimeException("Required field 'sizes' is missing");
+    }
+    int[] sizes = null;
+    final JSONArrayHandle sizesJsonArray = baseObj.getArray("sizes");
+    if (sizesJsonArray != null) {
+      final List<Integer> sizesTempList = new ArrayList<>();
+      sizesJsonArray.forEachInteger(sizesTempList::add);
+      sizes = sizesTempList.stream().mapToInt(i -> i != null ? i.intValue() : 0).toArray();
+    }
+
+    // Parse aliases
+    if (!baseObj.has("aliases")) {
+      throw new RuntimeException("Required field 'aliases' is missing");
+    }
+    String[] aliases = null;
+    final JSONArrayHandle aliasesJsonArray = baseObj.getArray("aliases");
+    if (aliasesJsonArray != null) {
+      final List<String> aliasesTempList = new ArrayList<>();
+      aliasesJsonArray.forEachString(aliasesTempList::add);
+      aliases = aliasesTempList.toArray(new String[0]);
+    }
+
+    return new TestConstructorWithGenericsType(tags, counts, labels, sizes, aliases);
+  }
+}

gwt-beans-codegen-core/src/test/resources/parsers/expected/TestConstructorWithIgnoredFieldTypeParser.java

@@ -0,0 +1,31 @@
+package nl.aerius.codegen.test.generated;
+
+import javax.annotation.processing.Generated;
+
+import nl.aerius.codegen.test.types.TestConstructorWithIgnoredFieldType;
+import nl.aerius.json.JSONObjectHandle;
+
+@Generated(value = "nl.aerius.codegen.ParserGenerator", date = "2024-01-01T00:00:00")
+public class TestConstructorWithIgnoredFieldTypeParser {
+  public static TestConstructorWithIgnoredFieldType parse(final String jsonText) {
+    if (jsonText == null) {
+      return null;
+    }
+
+    return parse(JSONObjectHandle.fromText(jsonText));
+  }
+
+  public static TestConstructorWithIgnoredFieldType parse(final JSONObjectHandle baseObj) {
+    if (baseObj == null) {
+      return null;
+    }
+
+    // Parse name
+    if (!baseObj.has("name")) {
+      throw new RuntimeException("Required field 'name' is missing");
+    }
+    final String name = baseObj.getString("name");
+
+    return new TestConstructorWithIgnoredFieldType(name);
+  }
+}

gwt-beans-codegen-core/src/test/resources/parsers/expected/TestRootObjectTypeParser.java

@@ -7,6 +7,8 @@
 import nl.aerius.codegen.test.types.TestAdvancedMapType;
 import nl.aerius.codegen.test.types.TestComplexCollectionType;
 import nl.aerius.codegen.test.types.TestConstructorBasedType;
+import nl.aerius.codegen.test.types.TestConstructorWithGenericsType;
+import nl.aerius.codegen.test.types.TestConstructorWithIgnoredFieldType;
 import nl.aerius.codegen.test.types.TestCustomParserType;
 import nl.aerius.codegen.test.types.TestEnumListType;
 import nl.aerius.codegen.test.types.TestEnumType;
@@ -132,5 +134,17 @@ public static void parse(final JSONObjectHandle baseObj, final TestRootObjectTyp
       final TestConstructorBasedType value = TestConstructorBasedTypeParser.parse(baseObj.getObject("constructorBased"));
       config.setConstructorBased(value);
     }
+
+    // Parse constructorWithGenerics
+    if (baseObj.has("constructorWithGenerics") && !baseObj.isNull("constructorWithGenerics")) {
+      final TestConstructorWithGenericsType value = TestConstructorWithGenericsTypeParser.parse(baseObj.getObject("constructorWithGenerics"));
+      config.setConstructorWithGenerics(value);
+    }
+
+    // Parse constructorWithIgnoredField
+    if (baseObj.has("constructorWithIgnoredField") && !baseObj.isNull("constructorWithIgnoredField")) {
+      final TestConstructorWithIgnoredFieldType value = TestConstructorWithIgnoredFieldTypeParser.parse(baseObj.getObject("constructorWithIgnoredField"));
+      config.setConstructorWithIgnoredField(value);
+    }
   }
 }