Issue #89 Update CI test count to 463 after adding integer validation edge case tests

Author: simbo1905

json-java21-jtd/README.md

@@ -69,6 +69,14 @@ Validates primitive types:
 
 Supported types: `boolean`, `string`, `timestamp`, `int8`, `uint8`, `int16`, `uint16`, `int32`, `uint32`, `float32`, `float64`
 
+#### Integer Type Validation
+Integer types (`int8`, `uint8`, `int16`, `uint16`, `int32`, `uint32`) validate based on **numeric value**, not textual representation:
+
+- **Valid integers**: `3`, `3.0`, `3.000`, `42.00` (mathematically integers)
+- **Invalid integers**: `3.1`, `3.14`, `3.0001` (have fractional components)
+
+This follows RFC 8927 §2.2.3.1: "An integer value is a number without a fractional component."
+
 ### 4. Enum Schema
 Validates against string values:
 ```json

json-java21-jtd/src/main/java/json/java21/jtd/JtdSchema.java

@@ -244,8 +244,10 @@ Jtd.Result validateInteger(JsonValue instance, String type, boolean verboseError
           return Jtd.Result.failure(Jtd.Error.EXPECTED_INTEGER.message());
         }
 
-        // Handle BigDecimal - check if it has fractional part
-        if (value instanceof java.math.BigDecimal bd && bd.scale() > 0) {
+        // Handle BigDecimal - check if it has fractional component (not just scale > 0)
+        // RFC 8927 §2.2.3.1: "An integer value is a number without a fractional component"
+        // Values like 3.0 or 3.000 are valid integers despite positive scale, but 3.1 is not
+        if (value instanceof java.math.BigDecimal bd && bd.remainder(java.math.BigDecimal.ONE).signum() != 0) {
           return Jtd.Result.failure(Jtd.Error.EXPECTED_INTEGER.message());
         }
 

json-java21-jtd/src/test/java/json/java21/jtd/TestRfc8927.java

@@ -469,4 +469,65 @@ public void testInt32RejectsDecimal() throws Exception {
       .as("Should have validation errors for decimal value")
       .isNotEmpty();
   }
+
+  /// Test that integer types accept valid integer representations with trailing zeros
+  /// RFC 8927 §2.2.3.1: "An integer value is a number without a fractional component"
+  /// Values like 3.0, 3.000 are valid integers despite positive scale
+  @Test  
+  public void testIntegerTypesAcceptTrailingZeros() throws Exception {
+    JsonValue schema = Json.parse("{\"type\": \"int32\"}");
+    
+    // Valid integer representations with trailing zeros
+    JsonValue[] validIntegers = {
+      JsonNumber.of(new java.math.BigDecimal("3.0")),
+      JsonNumber.of(new java.math.BigDecimal("3.000")),
+      JsonNumber.of(new java.math.BigDecimal("42.00")),
+      JsonNumber.of(new java.math.BigDecimal("0.0"))
+    };
+    
+    Jtd validator = new Jtd();
+    
+    for (JsonValue validValue : validIntegers) {
+      Jtd.Result result = validator.validate(schema, validValue);
+      
+      LOG.fine(() -> "Testing int32 with valid integer representation: " + validValue);
+      
+      assertThat(result.isValid())
+        .as("int32 should accept integer representation %s", validValue)
+        .isTrue();
+      assertThat(result.errors())
+        .as("Should have no validation errors for integer representation %s", validValue)
+        .isEmpty();
+    }
+  }
+
+  /// Test that integer types reject values with actual fractional components
+  /// RFC 8927 §2.2.3.1: "An integer value is a number without a fractional component"  
+  @Test
+  public void testIntegerTypesRejectFractionalComponents() throws Exception {
+    JsonValue schema = Json.parse("{\"type\": \"int32\"}");
+    
+    // Invalid values with actual fractional components
+    JsonValue[] invalidValues = {
+      JsonNumber.of(new java.math.BigDecimal("3.1")),
+      JsonNumber.of(new java.math.BigDecimal("3.0001")),
+      JsonNumber.of(new java.math.BigDecimal("3.14")),
+      JsonNumber.of(new java.math.BigDecimal("0.1"))
+    };
+    
+    Jtd validator = new Jtd();
+    
+    for (JsonValue invalidValue : invalidValues) {
+      Jtd.Result result = validator.validate(schema, invalidValue);
+      
+      LOG.fine(() -> "Testing int32 with fractional value: " + invalidValue);
+      
+      assertThat(result.isValid())
+        .as("int32 should reject fractional value %s", invalidValue)
+        .isFalse();
+      assertThat(result.errors())
+        .as("Should have validation errors for fractional value %s", invalidValue)
+        .isNotEmpty();
+    }
+  }
 }