Java, adjusts schema validator argument order

samples/client/petstore/java/src/main/java/org/openapijsonschematools/schemas/SchemaValidator.java

@@ -57,17 +57,17 @@ static PathToSchemasMap validate(
         Class<SchemaValidator> castSchemaCls = (Class<SchemaValidator>) schemaCls;
         for (Map.Entry<String, Object> entry: fieldsToValues.entrySet()) {
             String jsonKeyword = entry.getKey();
-            Object value = entry.getValue();
+            Object constraint = entry.getValue();
             if (jsonKeyword.equals("additionalProperties") && fieldsToValues.containsKey("properties")) {
                 extra = fieldsToValues.get("properties");
             }
             KeywordValidator validatorClass = keywordToValidator.get(jsonKeyword);
             PathToSchemasMap otherPathToSchemas = validatorClass.validate(
-                    arg,
-                    value,
-                    extra,
                     castSchemaCls,
-                    validationMetadata
+                    arg,
+                    constraint,
+                    validationMetadata,
+                    extra
             );
             if (otherPathToSchemas == null) {
                 continue;

samples/client/petstore/java/src/main/java/org/openapijsonschematools/schemas/validators/AdditionalPropertiesValidator.java

@@ -14,12 +14,12 @@
 
 public class AdditionalPropertiesValidator implements KeywordValidator {
     @Override
-    public PathToSchemasMap validate(Object arg, Object value, Object extra, Class<SchemaValidator> cls, ValidationMetadata validationMetadata) {
+    public PathToSchemasMap validate(Class<SchemaValidator> cls, Object arg, Object constraint, ValidationMetadata validationMetadata, Object extra) {
         if (!(arg instanceof Map)) {
             return null;
         }
         Map<String, Object> castArg = (Map<String, Object>) arg;
-        Class<Schema> addPropSchema = (Class<Schema>) value;
+        Class<Schema> addPropSchema = (Class<Schema>) constraint;
         Map<String, Class<Schema>> properties = (Map<String, Class<Schema>>) extra;
         if (properties == null) {
             properties = new LinkedHashMap<>();

samples/client/petstore/java/src/main/java/org/openapijsonschematools/schemas/validators/FormatValidator.java

@@ -6,52 +6,78 @@
 import org.openapijsonschematools.schemas.ValidationMetadata;
 
 import java.math.BigDecimal;
+import java.math.BigInteger;
 import java.time.format.DateTimeParseException;
 import java.util.UUID;
 
 public class FormatValidator implements KeywordValidator {
-    private final static BigDecimal int32InclusiveMinimum = BigDecimal.valueOf(-2147483648);
-    private final static BigDecimal int32InclusiveMaximum = BigDecimal.valueOf(2147483647);
-    private final static BigDecimal int64InclusiveMinimum = BigDecimal.valueOf(-9223372036854775808L);
-    private final static BigDecimal int64InclusiveMaximum = BigDecimal.valueOf(9223372036854775807L);
+    private final static BigInteger int32InclusiveMinimum = BigInteger.valueOf(-2147483648L);
+    private final static BigInteger int32InclusiveMaximum = BigInteger.valueOf(2147483647L);
+    private final static BigInteger int64InclusiveMinimum = BigInteger.valueOf(-9223372036854775808L);
+    private final static BigInteger int64InclusiveMaximum = BigInteger.valueOf(9223372036854775807L);
     private final static BigDecimal floatInclusiveMinimum = BigDecimal.valueOf(-3.4028234663852886e+38);
     private final static BigDecimal floatInclusiveMaximum = BigDecimal.valueOf(3.4028234663852886e+38);
     private final static BigDecimal doubleInclusiveMinimum = BigDecimal.valueOf(-1.7976931348623157E+308d);
     private final static BigDecimal doubleInclusiveMaximum = BigDecimal.valueOf(1.7976931348623157E+308d);
 
-    private Void validateNumericFormat(BigDecimal arg, String format, ValidationMetadata validationMetadata) {
+    private Void validateNumericFormat(Number arg, String format, ValidationMetadata validationMetadata) {
         if (format.startsWith("int")) {
             // there is a json schema test where 1.0 validates as an integer
-            if (arg.stripTrailingZeros().scale() > 0) {
-                throw new RuntimeException(
-                        "Invalid non-integer value " + arg + " for format " + format + " at " + validationMetadata.pathToItem()
-                );
+            BigInteger intArg;
+            if (arg instanceof Float || arg instanceof Double) {
+                Double doubleArg = (Double) arg;
+                if (Math.floor((Double) arg) != doubleArg) {
+                    throw new RuntimeException(
+                            "Invalid non-integer value " + arg + " for format " + format + " at " + validationMetadata.pathToItem()
+                    );
+                }
+                if (arg instanceof Float) {
+                    Integer smallInt = Math.round((Float) arg);
+                    intArg = BigInteger.valueOf(smallInt.longValue());
+                } else {
+                    intArg = BigInteger.valueOf(Math.round((Double) arg));
+                }
+            } else if (arg instanceof Integer) {
+                intArg = BigInteger.valueOf(arg.longValue());
+            } else if (arg instanceof Long) {
+                intArg = BigInteger.valueOf((Long) arg);
+            } else {
+                intArg = (BigInteger) arg;
             }
             if (format.equals("int32")) {
-                if (arg.compareTo(int32InclusiveMinimum) < 0  || arg.compareTo(int32InclusiveMaximum) > 0 ){
+                if (intArg.compareTo(int32InclusiveMinimum) < 0 || intArg.compareTo(int32InclusiveMaximum) > 0) {
                     throw new RuntimeException(
-                        "Invalid value "+arg+" for format int32 at "+validationMetadata.pathToItem()
+                            "Invalid value " + arg + " for format int32 at " + validationMetadata.pathToItem()
                     );
                 }
                 return null;
             } else if (format.equals("int64")) {
-                if (arg.compareTo(int64InclusiveMinimum) < 0  || arg.compareTo(int64InclusiveMaximum) > 0 ){
+                if (intArg.compareTo(int64InclusiveMinimum) < 0 || intArg.compareTo(int64InclusiveMaximum) > 0) {
                     throw new RuntimeException(
-                        "Invalid value "+arg+" for format int64 at "+validationMetadata.pathToItem()
+                            "Invalid value " + arg + " for format int64 at " + validationMetadata.pathToItem()
                     );
                 }
                 return null;
             }
             return null;
-        } else if (format.equals("float")) {
-            if (arg.compareTo(floatInclusiveMinimum) < 0  || arg.compareTo(floatInclusiveMaximum) > 0 ){
+        }
+        BigDecimal decimalArg;
+        if (arg instanceof Float) {
+            decimalArg = new BigDecimal((Float) arg);
+        } else if (arg instanceof Double) {
+            decimalArg = BigDecimal.valueOf((Double) arg);
+        } else {
+            decimalArg = (BigDecimal) arg;
+        }
+        if (format.equals("float")) {
+            if (decimalArg.compareTo(floatInclusiveMinimum) < 0  || decimalArg.compareTo(floatInclusiveMaximum) > 0 ){
                 throw new RuntimeException(
                     "Invalid value "+arg+" for format float at "+validationMetadata.pathToItem()
                 );
             }
             return null;
         } else if (format.equals("double")) {
-            if (arg.compareTo(doubleInclusiveMinimum) < 0  || arg.compareTo(doubleInclusiveMaximum) > 0 ){
+            if (decimalArg.compareTo(doubleInclusiveMinimum) < 0  || decimalArg.compareTo(doubleInclusiveMaximum) > 0 ){
                 throw new RuntimeException(
                     "Invalid value "+arg+" for format double at "+validationMetadata.pathToItem()
                 );
@@ -107,11 +133,11 @@ private Void validateStringFormat(String arg, String format, ValidationMetadata
     }
 
     @Override
-    public PathToSchemasMap validate(Object arg, Object value, Object extra, Class<SchemaValidator> cls, ValidationMetadata validationMetadata) {
-        String format = (String) value;
-        if (arg instanceof BigDecimal) {
+    public PathToSchemasMap validate(Class<SchemaValidator> cls, Object arg, Object constraint, ValidationMetadata validationMetadata, Object extra) {
+        String format = (String) constraint;
+        if (arg instanceof Number) {
             validateNumericFormat(
-                (BigDecimal) arg,
+                (Number) arg,
                 format,
                 validationMetadata
             );

samples/client/petstore/java/src/main/java/org/openapijsonschematools/schemas/validators/ItemsValidator.java

@@ -10,12 +10,12 @@
 
 public class ItemsValidator implements KeywordValidator {
     @Override
-    public PathToSchemasMap validate(Object arg, Object value, Object extra, Class<SchemaValidator> cls, ValidationMetadata validationMetadata) {
+    public PathToSchemasMap validate(Class<SchemaValidator> cls, Object arg, Object constraint, ValidationMetadata validationMetadata, Object extra) {
         if (!(arg instanceof List)) {
             return null;
         }
         List<Object> castArg = (List<Object>) arg;
-        Class<Schema> itemsSchema = (Class<Schema>) value;
+        Class<Schema> itemsSchema = (Class<Schema>) constraint;
         PathToSchemasMap pathToSchemas = new PathToSchemasMap();
         // todo add handling for prefixItems
         int i = 0;

samples/client/petstore/java/src/main/java/org/openapijsonschematools/schemas/validators/KeywordValidator.java

@@ -6,9 +6,9 @@
 
 public interface KeywordValidator {
     PathToSchemasMap validate(
-            Object arg,
-            Object value,
-            Object extra,
             Class<SchemaValidator> cls,
-            ValidationMetadata validationMetadata);
+            Object arg,
+            Object constraint,
+            ValidationMetadata validationMetadata,
+            Object extra);
 }

samples/client/petstore/java/src/main/java/org/openapijsonschematools/schemas/validators/PropertiesValidator.java

@@ -13,13 +13,13 @@
 
 public class PropertiesValidator implements KeywordValidator {
     @Override
-    public PathToSchemasMap validate(Object arg, Object value, Object extra, Class<SchemaValidator> cls, ValidationMetadata validationMetadata) {
+    public PathToSchemasMap validate(Class<SchemaValidator> cls, Object arg, Object constraint, ValidationMetadata validationMetadata, Object extra) {
         if (!(arg instanceof Map)) {
             return null;
         }
         PathToSchemasMap pathToSchemas = new PathToSchemasMap();
         Map<String, Object> castArg = (Map<String, Object>) arg;
-        Map<String, Class<Schema>> properties = (Map<String, Class<Schema>>) value;
+        Map<String, Class<Schema>> properties = (Map<String, Class<Schema>>) constraint;
         Set<String> presentProperties = new LinkedHashSet<>(castArg.keySet());
         presentProperties.retainAll(properties.keySet());
         for(String propName: presentProperties) {

samples/client/petstore/java/src/main/java/org/openapijsonschematools/schemas/validators/RequiredValidator.java

@@ -11,12 +11,12 @@
 
 public class RequiredValidator implements KeywordValidator {
     @Override
-    public PathToSchemasMap validate(Object arg, Object value, Object extra, Class<SchemaValidator> cls, ValidationMetadata validationMetadata) {
+    public PathToSchemasMap validate(Class<SchemaValidator> cls, Object arg, Object constraint, ValidationMetadata validationMetadata, Object extra) {
         if (!(arg instanceof Map)) {
             return null;
         }
         Map<String, Object> castArg = (Map<String, Object>) arg;
-        Set<String> requiredProperties = (Set<String>) value;
+        Set<String> requiredProperties = (Set<String>) constraint;
         Set<String> missingRequiredProperties = new HashSet<>(requiredProperties);
         missingRequiredProperties.removeAll(castArg.keySet());
         if (!missingRequiredProperties.isEmpty()) {

samples/client/petstore/java/src/main/java/org/openapijsonschematools/schemas/validators/TypeValidator.java

@@ -8,8 +8,8 @@
 
 public class TypeValidator implements KeywordValidator {
     @Override
-    public PathToSchemasMap validate(Object arg, Object value, Object extra, Class<SchemaValidator> cls, ValidationMetadata validationMetadata) {
-        HashSet<Class<?>> types = (HashSet<Class<?>>) value;
+    public PathToSchemasMap validate(Class<SchemaValidator> cls, Object arg, Object constraint, ValidationMetadata validationMetadata, Object extra) {
+        HashSet<Class<?>> types = (HashSet<Class<?>>) constraint;
         Class<?> argClass;
         if (arg == null) {
             argClass = Void.class;

samples/client/petstore/java/src/test/java/org/openapijsonschematools/schemas/validators/AdditionalPropertiesValidatorTest.java

@@ -37,11 +37,11 @@ public void testCorrectPropertySucceeds() {
         FrozenMap<String, Object> arg = new FrozenMap<>(mutableMap);
         final AdditionalPropertiesValidator validator = new AdditionalPropertiesValidator();
         PathToSchemasMap pathToSchemas = validator.validate(
+                SchemaValidator.class,
                 arg,
                 StringSchema.class,
-                properties,
-                SchemaValidator.class,
-                validationMetadata
+                validationMetadata,
+                properties
         );
         List<Object> expectedPathToItem = new ArrayList<>();
         expectedPathToItem.add("args[0]");
@@ -66,11 +66,11 @@ public void testNotApplicableTypeReturnsNull() {
         );
         final AdditionalPropertiesValidator validator = new AdditionalPropertiesValidator();
         PathToSchemasMap pathToSchemas = validator.validate(
+                SchemaValidator.class,
                 1,
                 StringSchema.class,
-                null,
-                SchemaValidator.class,
-                validationMetadata
+                validationMetadata,
+                null
         );
         Assert.assertNull(pathToSchemas);
     }
@@ -94,11 +94,11 @@ public void testIncorrectPropertyValueFails() {
         FrozenMap<String, Object> arg = new FrozenMap<>(mutableMap);
         final AdditionalPropertiesValidator validator = new AdditionalPropertiesValidator();
         Assert.assertThrows(RuntimeException.class, () -> validator.validate(
+                SchemaValidator.class,
                 arg,
                 StringSchema.class,
-                properties,
-                SchemaValidator.class,
-                validationMetadata
+                validationMetadata,
+                properties
         ));
     }
 }