Gather all violations while validating NumberSchema

Author: adyach

core/src/main/java/org/everit/json/schema/NumberSchema.java

@@ -4,6 +4,8 @@
 import org.json.JSONException;
 
 import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Objects;
 
 import static java.lang.String.format;
@@ -109,6 +111,8 @@ public static Builder builder() {
 
     private final boolean requiresInteger;
 
+    private final List<ValidationException> validationExceptions;
+
     public NumberSchema() {
         this(builder());
     }
@@ -129,34 +133,36 @@ public NumberSchema(final Builder builder) {
         this.requiresInteger = builder.requiresInteger;
         this.exclusiveMinimumLimit = builder.exclusiveMinimumLimit;
         this.exclusiveMaximumLimit = builder.exclusiveMaximumLimit;
+        this.validationExceptions = new ArrayList<>();
     }
 
     private void checkMaximum(final double subject) {
         if (maximum != null) {
             if (exclusiveMaximum && maximum.doubleValue() <= subject) {
-                throw failure(subject + " is not less than " + maximum, "exclusiveMaximum");
+                validationExceptions.add(failure(subject + " is not less than " + maximum, "exclusiveMaximum"));
             } else if (maximum.doubleValue() < subject) {
-                throw failure(subject + " is not less or equal to " + maximum, "maximum");
+                validationExceptions.add(failure(subject + " is not less or equal to " + maximum, "maximum"));
             }
         }
         if (exclusiveMaximumLimit != null) {
             if (subject >= exclusiveMaximumLimit.doubleValue()) {
-                throw failure(format("is not less than " + exclusiveMaximumLimit), "exclusiveMaximum");
+                validationExceptions.add(
+                        failure(format("is not less than " + exclusiveMaximumLimit),"exclusiveMaximum"));
             }
         }
     }
 
     private void checkMinimum(final double subject) {
         if (minimum != null) {
             if (exclusiveMinimum && subject <= minimum.doubleValue()) {
-                throw failure(subject + " is not greater than " + minimum, "exclusiveMinimum");
+                validationExceptions.add(failure(subject + " is not greater than " + minimum, "exclusiveMinimum"));
             } else if (subject < minimum.doubleValue()) {
-                throw failure(subject + " is not greater or equal to " + minimum, "minimum");
+                validationExceptions.add(failure(subject + " is not greater or equal to " + minimum, "minimum"));
             }
         }
         if (exclusiveMinimumLimit != null) {
             if (subject <= exclusiveMinimumLimit.doubleValue()) {
-                throw failure(subject + " is not greater than " + exclusiveMinimumLimit, "exclusiveMinimum");
+                validationExceptions.add(failure(subject + " is not greater than " + exclusiveMinimumLimit, "exclusiveMinimum"));
             }
         }
     }
@@ -166,7 +172,7 @@ private void checkMultipleOf(final double subject) {
             BigDecimal remainder = BigDecimal.valueOf(subject).remainder(
                     BigDecimal.valueOf(multipleOf.doubleValue()));
             if (remainder.compareTo(BigDecimal.ZERO) != 0) {
-                throw failure(subject + " is not a multiple of " + multipleOf, "multipleOf");
+                validationExceptions.add(failure(subject + " is not a multiple of " + multipleOf, "multipleOf"));
             }
         }
     }
@@ -206,9 +212,11 @@ public void validate(final Object subject) {
                 throw failure(Integer.class, subject);
             }
             double intSubject = ((Number) subject).doubleValue();
+            validationExceptions.clear();
             checkMinimum(intSubject);
             checkMaximum(intSubject);
             checkMultipleOf(intSubject);
+            ValidationException.throwFor(this, validationExceptions);
         }
     }
 

core/src/test/java/org/everit/json/schema/NumberSchemaTest.java

@@ -15,19 +15,18 @@
  */
 package org.everit.json.schema;
 
+import nl.jqno.equalsverifier.EqualsVerifier;
+import nl.jqno.equalsverifier.Warning;
+import org.everit.json.schema.loader.SchemaLoader;
+import org.json.JSONObject;
+import org.junit.Test;
+
 import static org.everit.json.schema.TestSupport.buildWithLocation;
 import static org.everit.json.schema.TestSupport.loadAsV6;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
-import org.everit.json.schema.loader.SchemaLoader;
-import org.json.JSONObject;
-import org.junit.Test;
-
-import nl.jqno.equalsverifier.EqualsVerifier;
-import nl.jqno.equalsverifier.Warning;
-
 public class NumberSchemaTest {
 
     private final ResourceLoader loader = new ResourceLoader("/org/everit/jsonvalidator/tostring/");
@@ -104,6 +103,20 @@ public void multipleOfFailure() {
                 .expect();
     }
 
+    @Test
+    public void shouldListAllViolationsWhenThereIsMoreThanOne() {
+        try {
+            NumberSchema.builder()
+                    .multipleOf(10).minimum(10.0).maximum(15.0)
+                    .build()
+                    .validate(3);
+        } catch (ValidationException ve) {
+            assertEquals(2, ve.getViolationCount());
+            assertEquals("minimum", ve.getCausingExceptions().get(0).getKeyword());
+            assertEquals("multipleOf", ve.getCausingExceptions().get(1).getKeyword());
+        }
+    }
+
     @Test
     public void notRequiresNumber() {
         NumberSchema.builder().requiresNumber(false).build().validate("foo");
@@ -154,7 +167,10 @@ public void longNumber() {
     public void equalsVerifier() {
         EqualsVerifier.forClass(NumberSchema.class)
                 .withRedefinedSuperclass()
-                .withIgnoredFields("schemaLocation")
+                .withPrefabValues(ValidationException.class,
+                        new ValidationException(null, "msg1", "key1", "loc1"),
+                        new ValidationException(null, "msg", "key2", "loc2"))
+                .withIgnoredFields("schemaLocation", "validationExceptions")
                 .suppress(Warning.STRICT_INHERITANCE)
                 .verify();
     }