adding checking of actual type of subject in ValidatingVisitor ctor to avoid confusion on handled types

Author: erosb

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

@@ -1,11 +1,11 @@
 package org.everit.json.schema;
 
-import org.json.JSONArray;
-import org.json.JSONObject;
-
 import java.util.Arrays;
 import java.util.Objects;
 
+import org.json.JSONArray;
+import org.json.JSONObject;
+
 /**
  * Deep-equals implementation on primitive wrappers, {@link JSONObject} and {@link JSONArray}.
  */
@@ -14,11 +14,13 @@ public final class ObjectComparator {
     /**
      * Deep-equals implementation on primitive wrappers, {@link JSONObject} and {@link JSONArray}.
      *
-     * @param obj1 the first object to be inspected
-     * @param obj2 the second object to be inspected
+     * @param obj1
+     *         the first object to be inspected
+     * @param obj2
+     *         the second object to be inspected
      * @return {@code true} if the two objects are equal, {@code false} otherwise
      */
-    public static boolean deepEquals(final Object obj1, final Object obj2) {
+    public static boolean deepEquals(Object obj1, Object obj2) {
         if (obj1 instanceof JSONArray) {
             if (!(obj2 instanceof JSONArray)) {
                 return false;
@@ -33,7 +35,7 @@ public static boolean deepEquals(final Object obj1, final Object obj2) {
         return Objects.equals(obj1, obj2);
     }
 
-    private static boolean deepEqualArrays(final JSONArray arr1, final JSONArray arr2) {
+    private static boolean deepEqualArrays(JSONArray arr1, JSONArray arr2) {
         if (arr1.length() != arr2.length()) {
             return false;
         }
@@ -45,7 +47,7 @@ private static boolean deepEqualArrays(final JSONArray arr1, final JSONArray arr
         return true;
     }
 
-    private static String[] sortedNamesOf(final JSONObject obj) {
+    private static String[] sortedNamesOf(JSONObject obj) {
         String[] raw = JSONObject.getNames(obj);
         if (raw == null) {
             return null;
@@ -54,7 +56,7 @@ private static String[] sortedNamesOf(final JSONObject obj) {
         return raw;
     }
 
-    private static boolean deepEqualObjects(final JSONObject jsonObj1, final JSONObject jsonObj2) {
+    private static boolean deepEqualObjects(JSONObject jsonObj1, JSONObject jsonObj2) {
         String[] obj1Names = sortedNamesOf(jsonObj1);
         if (!Arrays.equals(obj1Names, sortedNamesOf(jsonObj2))) {
             return false;

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

@@ -1,16 +1,32 @@
 package org.everit.json.schema;
 
 import static java.lang.String.format;
+import static java.util.Arrays.asList;
+import static java.util.Collections.unmodifiableList;
+import static java.util.stream.Collectors.joining;
 import static org.everit.json.schema.EnumSchema.toJavaValue;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
+import org.json.JSONArray;
 import org.json.JSONObject;
 
 class ValidatingVisitor extends Visitor {
 
+    private static final List<Class<?>> VALIDATED_TYPES = unmodifiableList(asList(
+            Number.class,
+            String.class,
+            Boolean.class,
+            JSONObject.class,
+            JSONArray.class,
+            JSONObject.NULL.getClass()
+    ));
+
+    static final String TYPE_FAILURE_MSG = "subject is an instance of non-handled type %s. Should be one of "
+            + VALIDATED_TYPES.stream().map(Class::getSimpleName).collect(joining(", "));
+
     private static boolean isNull(Object obj) {
         return obj == null || JSONObject.NULL.equals(obj);
     }
@@ -31,6 +47,9 @@ void visit(Schema schema) {
     }
 
     ValidatingVisitor(Object subject, ValidationFailureReporter failureReporter, ReadWriteValidator readWriteValidator) {
+        if (subject != null && !VALIDATED_TYPES.stream().anyMatch(type -> type.isAssignableFrom(subject.getClass()))) {
+            throw new IllegalArgumentException(format(TYPE_FAILURE_MSG, subject.getClass().getSimpleName()));
+        }
         this.subject = subject;
         this.failureReporter = failureReporter;
         this.readWriteValidator = readWriteValidator;

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

@@ -19,10 +19,8 @@
 import static org.junit.Assert.assertEquals;
 
 import java.io.StringWriter;
-import java.util.HashMap;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 
@@ -79,10 +77,8 @@ public void objectInArrayMatches() {
         possibleValues.add(arr);
 
         EnumSchema subject = subject().build();
-        Map<String, Object> map = new HashMap<>();
-        map.put("a", true);
-        List<Object> list = asList(map);
-        subject.validate(list);
+        
+        subject.validate(new JSONArray("[{\"a\":true}]"));
     }
 
     private List<Object> asSet(final JSONArray array) {

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

@@ -6,10 +6,20 @@
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyZeroInteractions;
 
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.ArrayList;
+
+import org.json.JSONArray;
 import org.json.JSONObject;
 import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import junitparams.JUnitParamsRunner;
+import junitparams.Parameters;
 
+@RunWith(JUnitParamsRunner.class)
 public class ValidatingVisitorTest {
 
     private ValidationFailureReporter reporter;
@@ -68,4 +78,40 @@ public void passesTypeCheck_sameType() {
         verifyZeroInteractions(reporter);
     }
 
+    public Object[] permittedTypes() {
+        return new Object[] {
+                new Object[] { "str" },
+                new Object[] { 1 },
+                new Object[] { 1L },
+                new Object[] { 1.0 },
+                new Object[] { 1.0f },
+                new Object[] { new BigInteger("42") },
+                new Object[] { new BigDecimal("42.3") },
+                new Object[] { true },
+                new Object[] { null },
+                new Object[] { JSONObject.NULL },
+                new Object[] { new JSONObject("{}") },
+                new Object[] { new JSONArray("[]") },
+        };
+    }
+
+    public Object[] notPermittedTypes() {
+        return new Object[] {
+                new Object[] { new ArrayList<String>() },
+                new Object[] { new RuntimeException() }
+        };
+    }
+
+    @Test
+    @Parameters(method = "permittedTypes")
+    public void permittedTypeSuccess(Object subject) {
+        new ValidatingVisitor(subject, reporter, ReadWriteValidator.NONE);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    @Parameters(method = "notPermittedTypes")
+    public void notPermittedTypeFailure(Object subject) {
+        new ValidatingVisitor(subject, reporter, ReadWriteValidator.NONE);
+    }
+
 }