migrated NumberSchema to new ViolationException constructor

Author: erosb

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

@@ -125,19 +125,19 @@ public NumberSchema(final Builder builder) {
   private void checkMaximum(final double subject) {
     if (maximum != null) {
       if (exclusiveMaximum && maximum.doubleValue() <= subject) {
-        throw new ValidationException(subject + " is not lower than " + maximum);
+        throw new ValidationException(this, subject + " is not lower than " + maximum);
       } else if (maximum.doubleValue() < subject) {
-        throw new ValidationException(subject + " is not lower or equal to " + maximum);
+        throw new ValidationException(this, subject + " is not lower or equal to " + maximum);
       }
     }
   }
 
   private void checkMinimum(final double subject) {
     if (minimum != null) {
       if (exclusiveMinimum && subject <= minimum.doubleValue()) {
-        throw new ValidationException(subject + " is not higher than " + minimum);
+        throw new ValidationException(this, subject + " is not higher than " + minimum);
       } else if (subject < minimum.doubleValue()) {
-        throw new ValidationException(subject + " is not higher or equal to " + minimum);
+        throw new ValidationException(this, subject + " is not higher or equal to " + minimum);
       }
     }
   }
@@ -147,7 +147,7 @@ private void checkMultipleOf(final double subject) {
       BigDecimal remainder = BigDecimal.valueOf(subject).remainder(
           BigDecimal.valueOf(multipleOf.doubleValue()));
       if (remainder.compareTo(BigDecimal.ZERO) != 0) {
-        throw new ValidationException(subject + " is not a multiple of " + multipleOf);
+        throw new ValidationException(this, subject + " is not a multiple of " + multipleOf);
       }
     }
   }
@@ -180,11 +180,11 @@ public boolean requiresInteger() {
   public void validate(final Object subject) {
     if (!(subject instanceof Number)) {
       if (requiresNumber) {
-        throw new ValidationException(Number.class, subject);
+        throw new ValidationException(this, Number.class, subject);
       }
     } else {
       if (!(subject instanceof Integer) && requiresInteger) {
-        throw new ValidationException(Integer.class, subject);
+        throw new ValidationException(this, Integer.class, subject);
       }
       double intSubject = ((Number) subject).doubleValue();
       checkMinimum(intSubject);

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

@@ -15,72 +15,76 @@
  */
 package org.everit.json.schema;
 
-import org.everit.json.schema.NumberSchema;
-import org.everit.json.schema.ValidationException;
 import org.junit.Test;
 
 public class NumberSchemaTest {
 
-  @Test(expected = ValidationException.class)
+  @Test
   public void exclusiveMinimum() {
-    NumberSchema.builder().minimum(10.0).exclusiveMinimum(true).build().validate(10);
+    NumberSchema subject = NumberSchema.builder().minimum(10.0).exclusiveMinimum(true).build();
+    TestSupport.exceptFailure(subject, 10);
   }
 
-  @Test(expected = ValidationException.class)
+  @Test
   public void maximum() {
-    NumberSchema.builder().maximum(20.0).build().validate(21);
+    NumberSchema subject = NumberSchema.builder().maximum(20.0).build();
+    TestSupport.exceptFailure(subject, 21);
   }
 
-  @Test(expected = ValidationException.class)
+  @Test
   public void maximumExclusive() {
-    NumberSchema.builder().maximum(20.0).exclusiveMaximum(true).build().validate(20);
+    NumberSchema subject = NumberSchema.builder().maximum(20.0).exclusiveMaximum(true).build();
+    TestSupport.exceptFailure(subject, 20);
   }
 
-  @Test(expected = ValidationException.class)
+  @Test
   public void minimumFailure() {
-    NumberSchema.builder().minimum(10.0).build().validate(9);
+    NumberSchema subject = NumberSchema.builder().minimum(10.0).build();
+    TestSupport.exceptFailure(subject, 9);
   }
 
-  @Test(expected = ValidationException.class)
+  @Test
   public void multipleOfFailure() {
-    NumberSchema.builder().multipleOf(10).build().validate(15);
+    NumberSchema subject = NumberSchema.builder().multipleOf(10).build();
+    TestSupport.exceptFailure(subject, 15);
   }
 
   @Test
   public void notRequiresNumber() {
     NumberSchema.builder().requiresNumber(false).build().validate("foo");
   }
 
-  @Test(expected = ValidationException.class)
+  @Test
   public void requiresIntegerFailure() {
-    NumberSchema.builder().requiresInteger(true).build().validate(new Float(10.2));
+    NumberSchema subject = NumberSchema.builder().requiresInteger(true).build();
+    TestSupport.exceptFailure(subject, 10.2f);
   }
 
   @Test
   public void requiresIntegerSuccess() {
     NumberSchema.builder().requiresInteger(true).build().validate(10);
   }
 
+  @Test
+  public void smallMultipleOf() {
+    NumberSchema.builder()
+        .multipleOf(0.0001)
+        .build().validate(0.0075);
+  }
+
   @Test
   public void success() {
     NumberSchema.builder()
-    .minimum(10.0)
-    .maximum(11.0)
-    .exclusiveMaximum(true)
-    .multipleOf(10)
-    .build().validate(10.0);
+        .minimum(10.0)
+        .maximum(11.0)
+        .exclusiveMaximum(true)
+        .multipleOf(10)
+        .build().validate(10.0);
   }
 
   @Test(expected = ValidationException.class)
   public void typeFailure() {
     NumberSchema.builder().build().validate(null);
   }
 
-  @Test
-  public void smallMultipleOf() {
-    NumberSchema.builder()
-    .multipleOf(0.0001)
-    .build().validate(0.0075);
-  }
-
 }