-only compares with Long value when the schema type is int/long and the compare node is integer type, otherwise means one of schema or compare node is with decimal, so convert it to BigDecimal to do the compare.

BalloonWen · BalloonWen · commit a456ff53d507 · 2019-06-11T13:13:17.000-04:00
-change some edge test cases, due to the way of measuring is changed, some edge scenarios don't apply anymore.
diff --git a/src/main/java/com/networknt/schema/MaximumValidator.java b/src/main/java/com/networknt/schema/MaximumValidator.java
@@ -20,6 +20,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.util.Collections;
 import java.util.Set;
@@ -46,34 +47,17 @@ public MaximumValidator(String schemaPath, JsonNode schemaNode, JsonSchema paren
         }
 
         parseErrorCode(getValidatorType().getErrorCodeKey());
-        //if the schema type is not integer, or the maximum value is not an integer, try to compare using double values;
-        if (!JsonType.INTEGER.toString().equals(getNodeFieldType()) || !JsonType.INTEGER.toString().equals(schemaNode.getNodeType())) {
-            // "number" or no type
-            // by default treat value as double: compatible with previous behavior
-            final double dm = schemaNode.doubleValue();
-            typedMaximum = new ThresholdMixin() {
-                @Override
-                public boolean crossesThreshold(JsonNode node) {
-                    double value = node.asDouble();
-                    return greaterThan(value, dm) || (excludeEqual && MaximumValidator.this.equals(value, dm));
-                }
-
-                @Override
-                public String thresholdValue() {
-                    return String.valueOf(dm);
-                }
-            };
 
-        } else if ( schemaNode.isLong() || schemaNode.isInt() ) {
+        if (( schemaNode.isLong() || schemaNode.isInt() ) && (JsonType.INTEGER.toString().equals(getNodeFieldType()))) {
             // "integer", and within long range
             final long lm = schemaNode.asLong();
             typedMaximum = new ThresholdMixin() {
                 @Override
                 public boolean crossesThreshold(JsonNode node) {
                     long val = node.asLong();
-                    if(node.isBigInteger()) {
+                    if (node.isBigInteger()) {
                         //node.isBigInteger is not trustable, the type BigInteger doesn't mean it is a big number.
-                        if(node.bigIntegerValue().compareTo(new BigInteger(String.valueOf(Long.MAX_VALUE))) > 0) {
+                        if (node.bigIntegerValue().compareTo(new BigInteger(String.valueOf(Long.MAX_VALUE))) > 0) {
                             return true;
                         }
                     }
@@ -85,20 +69,22 @@ public String thresholdValue() {
                     return String.valueOf(lm);
                 }
             };
-
         } else {
-            // "integer" outside long range
-            final BigInteger bim = new BigInteger(schemaNode.asText());
             typedMaximum = new ThresholdMixin() {
                 @Override
                 public boolean crossesThreshold(JsonNode node) {
-                    int cmp = bim.compareTo(node.bigIntegerValue());
-                    return cmp < 0 || (excludeEqual && cmp <= 0);
+                    if(schemaNode.doubleValue() == Double.POSITIVE_INFINITY) {
+                        return false;
+                    }
+                    final BigDecimal max = new BigDecimal(schemaNode.asText());
+                    if(node.doubleValue() == Double.POSITIVE_INFINITY) {return true;}
+                    BigDecimal value = new BigDecimal(node.asText());
+                    return value.compareTo(max) > 0 || (excludeEqual && value.compareTo(max) == 0);
                 }
 
                 @Override
                 public String thresholdValue() {
-                    return String.valueOf(bim);
+                    return schemaNode.asText();
                 }
             };
         }
@@ -117,5 +103,4 @@ public Set<ValidationMessage> validate(JsonNode node, JsonNode rootNode, String
         }
         return Collections.emptySet();
     }
-
 }
diff --git a/src/test/java/com/networknt/schema/MaximumValidatorTest.java b/src/test/java/com/networknt/schema/MaximumValidatorTest.java
@@ -40,6 +40,8 @@ public class MaximumValidatorTest {
     @Before
     public void setUp() {
         mapper = new ObjectMapper();
+        // due to a jackson bug, a float number which is larger than Double.POSITIVE_INFINITY cannot be convert to BigDecimal correctly
+        // https://github.com/FasterXML/jackson-databind/issues/1770
         bigDecimalMapper = new ObjectMapper().enable(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS);
         bigIntegerMapper = new ObjectMapper().enable(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS);
     }
@@ -137,14 +139,25 @@ public void negativeDoubleOverflowTest() throws IOException {
             assertTrue(format("Maximum %s and value %s are interpreted as Infinity, thus no schema violation should be reported", maximum, value), messages.isEmpty());
 
             // document parsed with BigDecimal
+
             doc = bigDecimalMapper.readTree(value);
-            messages = v.validate(doc);
-            assertTrue(format("Maximum %s and value %s are interpreted as Infinity, thus no schema violation should be reported", maximum, value), messages.isEmpty());
+            Set<ValidationMessage> messages2 = v.validate(doc);
+            if(Double.valueOf(maximum) == Double.POSITIVE_INFINITY) {
+                assertTrue(format("Maximum %s and value %s are equal, thus no schema violation should be reported", maximum, value), messages2.isEmpty());
+            } else {
+                assertFalse(format("Maximum %s is smaller than value %s ,  should be validation error reported", maximum, value), messages2.isEmpty());
+            }
+
 
             // schema and document parsed with BigDecimal
             v = factory.getSchema(bigDecimalMapper.readTree(schema));
-            messages = v.validate(doc);
-            assertTrue(format("Maximum %s and value %s are interpreted as Infinity, thus no schema violation should be reported", maximum, value), messages.isEmpty());
+            Set<ValidationMessage> messages3 = v.validate(doc);
+            //when the schema and value are both using BigDecimal, the value should be parsed in same mechanism.
+            if(maximum.toLowerCase().equals(value.toLowerCase()) || Double.valueOf(maximum) == Double.POSITIVE_INFINITY) {
+                assertTrue(format("Maximum %s and value %s are equal, thus no schema violation should be reported", maximum, value), messages3.isEmpty());
+            } else {
+                assertFalse(format("Maximum %s is smaller than value %s ,  should be validation error reported", maximum, value), messages3.isEmpty());
+            }
         }
     }
 
@@ -165,7 +178,9 @@ public void doubleValueCoarsing() throws IOException {
 
         doc = bigDecimalMapper.readTree(content);
         messages = v.validate(doc);
-        assertTrue("Validation should succeed as by default double values are used by mapper", messages.isEmpty());
+        // "1.7976931348623158e+308" == "1.7976931348623157e+308" == Double.MAX_VALUE
+        // new BigDecimal("1.7976931348623158e+308").compareTo(new BigDecimal("1.7976931348623157e+308")) > 0
+        assertFalse("Validation should not succeed because content is using bigDecimalMapper, and bigger than the maximum", messages.isEmpty());
 
         /**
          * Note: technically this is where 1.7976931348623158e+308 rounding to 1.7976931348623157e+308 could be spotted,
@@ -176,7 +191,7 @@ public void doubleValueCoarsing() throws IOException {
          */
         v = factory.getSchema(bigDecimalMapper.readTree(schema));
         messages = v.validate(doc);
-        assertTrue("Validation should succeed as by default double values are used by mapper", messages.isEmpty());
+        assertFalse("Validation should succeed as by default double values are used by mapper", messages.isEmpty());
     }
 
     @Test
@@ -421,6 +436,86 @@ public void testIntegerTypeWithFloatMaxNegative() throws IOException {
             assertFalse(format("Expecting validation error with maximum %s and value %s", maximum, value), messages.isEmpty());
         }
     }
+
+    @Test
+    public void testMaximumDoubleValue() throws IOException {
+        String[][] values = {
+//            maximum,                       value
+                {"1E39",         "1000"}
+        };
+
+        for(String[] aTestCycle : values) {
+            String maximum = aTestCycle[0];
+            String value = aTestCycle[1];
+            String schema = format("{ \"$schema\":\"http://json-schema.org/draft-04/schema#\", \"type\": \"integer\", \"maximum\": %s, \"exclusiveMaximum\": false}", maximum);
+
+            JsonSchema v = factory.getSchema(mapper.readTree(schema));
+            JsonNode doc = mapper.readTree(value);
+
+            Set<ValidationMessage> messages = v.validate(doc);
+            assertTrue(format("Expecing no validation errors as maximum %s is greater than value %s", maximum, value), messages.isEmpty());
+        }
+    }
+
+    @Test
+    public void testMaximumDoubleValueNegative() throws IOException {
+        String[][] values = {
+//            maximum,                       value
+                {"1000",         "1E39"}
+        };
+
+        for(String[] aTestCycle : values) {
+            String maximum = aTestCycle[0];
+            String value = aTestCycle[1];
+            String schema = format("{ \"$schema\":\"http://json-schema.org/draft-04/schema#\", \"type\": \"integer\", \"maximum\": %s, \"exclusiveMaximum\": false}", maximum);
+
+            JsonSchema v = factory.getSchema(mapper.readTree(schema));
+            JsonNode doc = mapper.readTree(value);
+
+            Set<ValidationMessage> messages = v.validate(doc);
+            assertFalse(format("Expecting  validation errors as value %s is greater than maximum %s", maximum, value), messages.isEmpty());
+        }
+    }
+
+    @Test
+    public void testMaximumDoubleValueWithNumberType() throws IOException {
+        String[][] values = {
+//            maximum,                       value
+                {"1000.1",         "1000"}
+        };
+
+        for(String[] aTestCycle : values) {
+            String maximum = aTestCycle[0];
+            String value = aTestCycle[1];
+            String schema = format("{ \"$schema\":\"http://json-schema.org/draft-04/schema#\", \"type\": \"number\", \"maximum\": %s, \"exclusiveMaximum\": false}", maximum);
+
+            JsonSchema v = factory.getSchema(mapper.readTree(schema));
+            JsonNode doc = mapper.readTree(value);
+
+            Set<ValidationMessage> messages = v.validate(doc);
+            assertTrue(format("Expecting no validation errors as maximum %s is greater than value %s", maximum, value), messages.isEmpty());
+        }
+    }
+
+    @Test
+    public void testMaximumDoubleValueWithNumberTypeNegative() throws IOException {
+        String[][] values = {
+//            maximum,                       value
+                {"1000",         "1000.1"}
+        };
+
+        for(String[] aTestCycle : values) {
+            String maximum = aTestCycle[0];
+            String value = aTestCycle[1];
+            String schema = format("{ \"$schema\":\"http://json-schema.org/draft-04/schema#\", \"type\": \"number\", \"maximum\": %s, \"exclusiveMaximum\": false}", maximum);
+
+            JsonSchema v = factory.getSchema(mapper.readTree(schema));
+            JsonNode doc = mapper.readTree(value);
+
+            Set<ValidationMessage> messages = v.validate(doc);
+            assertFalse(format("Expecting  validation errors as value %s is greater than maximum %s", maximum, value), messages.isEmpty());
+        }
+    }
 }
 
 
