integrating nullable + require* checks by calling #passesTypeCheck()

for the following Schema classes:
 * ArraySchema
 * NumberSchema

Author: erosb

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

@@ -30,11 +30,7 @@ public ArraySchemaValidatingVisitor(Object subject, ValidatingVisitor owner) {
     }
 
     @Override void visitArraySchema(ArraySchema arraySchema) {
-        if (!(subject instanceof JSONArray)) {
-            if (arraySchema.requiresArray()) {
-                owner.failure(JSONArray.class, subject);
-            }
-        } else {
+        if (owner.passesTypeCheck(JSONArray.class, arraySchema.requiresArray(), arraySchema.isNullable())) {
             this.arraySubject = (JSONArray) subject;
             this.subjectLength = arraySubject.length();
             this.arraySchema = arraySchema;

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

@@ -8,27 +8,23 @@ class NumberSchemaValidatingVisitor extends Visitor {
 
     private final Object subject;
 
-    private final ValidationFailureReporter failureReporter;
+    private final ValidatingVisitor owner;
 
     private boolean exclusiveMinimum;
 
     private boolean exclusiveMaximum;
 
     private double numberSubject;
 
-    NumberSchemaValidatingVisitor(Object subject, ValidationFailureReporter failureReporter) {
+    NumberSchemaValidatingVisitor(Object subject, ValidatingVisitor owner) {
         this.subject = subject;
-        this.failureReporter = failureReporter;
+        this.owner= owner;
     }
 
     @Override void visitNumberSchema(NumberSchema numberSchema) {
-        if (!(subject instanceof Number)) {
-            if (numberSchema.isRequiresNumber()) {
-                failureReporter.failure(Number.class, subject);
-            }
-        } else {
+        if (owner.passesTypeCheck(Number.class, numberSchema.isRequiresNumber(), numberSchema.isNullable())) {
             if (!(subject instanceof Integer || subject instanceof Long) && numberSchema.requiresInteger()) {
-                failureReporter.failure(Integer.class, subject);
+                owner.failure(Integer.class, subject);
             } else {
                 this.numberSubject = ((Number) subject).doubleValue();
                 super.visitNumberSchema(numberSchema);
@@ -45,16 +41,16 @@ class NumberSchemaValidatingVisitor extends Visitor {
             return;
         }
         if (exclusiveMinimum && numberSubject <= minimum.doubleValue()) {
-            failureReporter.failure(subject + " is not greater than " + minimum, "exclusiveMinimum");
+            owner.failure(subject + " is not greater than " + minimum, "exclusiveMinimum");
         } else if (numberSubject < minimum.doubleValue()) {
-            failureReporter.failure(subject + " is not greater or equal to " + minimum, "minimum");
+            owner.failure(subject + " is not greater or equal to " + minimum, "minimum");
         }
     }
 
     @Override void visitExclusiveMinimumLimit(Number exclusiveMinimumLimit) {
         if (exclusiveMinimumLimit != null) {
             if (numberSubject <= exclusiveMinimumLimit.doubleValue()) {
-                failureReporter.failure(subject + " is not greater than " + exclusiveMinimumLimit, "exclusiveMinimum");
+                owner.failure(subject + " is not greater than " + exclusiveMinimumLimit, "exclusiveMinimum");
             }
         }
     }
@@ -64,9 +60,9 @@ class NumberSchemaValidatingVisitor extends Visitor {
             return;
         }
         if (exclusiveMaximum && maximum.doubleValue() <= numberSubject) {
-            failureReporter.failure(subject + " is not less than " + maximum, "exclusiveMaximum");
+            owner.failure(subject + " is not less than " + maximum, "exclusiveMaximum");
         } else if (maximum.doubleValue() < numberSubject) {
-            failureReporter.failure(subject + " is not less or equal to " + maximum, "maximum");
+            owner.failure(subject + " is not less or equal to " + maximum, "maximum");
         }
     }
 
@@ -77,7 +73,7 @@ class NumberSchemaValidatingVisitor extends Visitor {
     @Override void visitExclusiveMaximumLimit(Number exclusiveMaximumLimit) {
         if (exclusiveMaximumLimit != null) {
             if (numberSubject >= exclusiveMaximumLimit.doubleValue()) {
-                failureReporter.failure(format("is not less than " + exclusiveMaximumLimit), "exclusiveMaximum");
+                owner.failure(format("is not less than " + exclusiveMaximumLimit), "exclusiveMaximum");
             }
         }
     }
@@ -87,7 +83,7 @@ class NumberSchemaValidatingVisitor extends Visitor {
             BigDecimal remainder = BigDecimal.valueOf(numberSubject).remainder(
                     BigDecimal.valueOf(multipleOf.doubleValue()));
             if (remainder.compareTo(BigDecimal.ZERO) != 0) {
-                failureReporter.failure(subject + " is not a multiple of " + multipleOf, "multipleOf");
+                owner.failure(subject + " is not a multiple of " + multipleOf, "multipleOf");
             }
         }
     }

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

@@ -33,7 +33,7 @@ void visit(Schema schema) {
     }
 
     @Override void visitNumberSchema(NumberSchema numberSchema) {
-        numberSchema.accept(new NumberSchemaValidatingVisitor(subject, failureReporter));
+        numberSchema.accept(new NumberSchemaValidatingVisitor(subject, this));
     }
 
     @Override void visitArraySchema(ArraySchema arraySchema) {

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

@@ -247,4 +247,10 @@ public void containedItemSchemaEmptyArr() {
                 .expect();
     }
 
+    @Test
+    public void requiresArray_nullable() {
+        ArraySchema subject = ArraySchema.builder().requiresArray(true).nullable(true).build();
+        subject.validate(JSONObject.NULL);
+    }
+
 }

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

@@ -233,4 +233,25 @@ public void exclusiveMinimumDoubleBoundary() {
                 .expectedMessageFragment("3.0 is not greater than")
                 .expect();
     }
+
+    @Test
+    public void requiresNumber_nullable() {
+        NumberSchema subject = NumberSchema.builder().requiresNumber(true).nullable(true).build();
+        subject.validate(JSONObject.NULL);
+    }
+
+    @Test
+    public void requiresInteger_nullable() {
+        NumberSchema subject = NumberSchema.builder().requiresInteger(true).nullable(true).build();
+        subject.validate(JSONObject.NULL);
+    }
+
+    @Test
+    public void requiresInteger_nonNullable() {
+        Schema.Builder<?> subject = NumberSchema.builder().requiresInteger(true).nullable(false);
+        TestSupport.failureOf(subject)
+                .input(JSONObject.NULL)
+                .expect();
+    }
+
 }