rework of ArraySchema in progress

Author: erosb

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

@@ -19,6 +19,7 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
+import java.util.Optional;
 
 import org.json.JSONArray;
 
@@ -172,6 +173,15 @@ public Schema getSchemaOfAdditionalItems() {
     return schemaOfAdditionalItems;
   }
 
+  private Optional<ValidationException> ifFails(final Schema schema, final Object input) {
+    try {
+      schema.validate(input);
+      return Optional.empty();
+    } catch (ValidationException e) {
+      return Optional.of(e);
+    }
+  }
+
   public boolean needsUniqueItems() {
     return uniqueItems;
   }
@@ -196,7 +206,8 @@ private void testItemCount(final JSONArray subject) {
     }
   }
 
-  private void testItems(final JSONArray subject) {
+  private List<ValidationException> testItems(final JSONArray subject) {
+    List<ValidationException> rval = new ArrayList<>();
     if (allItemSchema != null) {
       for (int i = 0; i < subject.length(); ++i) {
         allItemSchema.validate(subject.get(i));
@@ -208,34 +219,43 @@ private void testItems(final JSONArray subject) {
       }
       int itemValidationUntil = Math.min(subject.length(), itemSchemas.size());
       for (int i = 0; i < itemValidationUntil; ++i) {
-        itemSchemas.get(i).validate(subject.get(i));
+        int copyOfI = i; // i is not effectively final so we copy it
+        ifFails(itemSchemas.get(i), subject.get(i))
+            .map(exc -> exc.prepend(String.valueOf(copyOfI)))
+            .ifPresent(rval::add);
       }
       if (schemaOfAdditionalItems != null) {
         for (int i = itemValidationUntil; i < subject.length(); ++i) {
-          schemaOfAdditionalItems.validate(subject.get(i));
+          int copyOfI = i; // i is not effectively final so we copy it
+          ifFails(schemaOfAdditionalItems, subject.get(i))
+              .map(exc -> exc.prepend(String.valueOf(copyOfI)))
+              .ifPresent(rval::add);
         }
       }
     }
+    return rval;
   }
 
-  private void testUniqueness(final JSONArray subject) {
+  private Optional<ValidationException> testUniqueness(final JSONArray subject) {
     if (subject.length() == 0) {
-      return;
+      return Optional.empty();
     }
     Collection<Object> uniqueItems = new ArrayList<Object>(subject.length());
     for (int i = 0; i < subject.length(); ++i) {
       Object item = subject.get(i);
       for (Object contained : uniqueItems) {
         if (ObjectComparator.deepEquals(contained, item)) {
-          throw new ValidationException("array items are not unique");
+          return Optional.of(new ValidationException(this, "array items are not unique"));
         }
       }
       uniqueItems.add(item);
     }
+    return Optional.empty();
   }
 
   @Override
   public void validate(final Object subject) {
+    List<ValidationException> failures = new ArrayList<>();
     if (!(subject instanceof JSONArray)) {
       if (requiresArray) {
         throw new ValidationException(JSONArray.class, subject);
@@ -244,10 +264,11 @@ public void validate(final Object subject) {
       JSONArray arrSubject = (JSONArray) subject;
       testItemCount(arrSubject);
       if (uniqueItems) {
-        testUniqueness(arrSubject);
+        testUniqueness(arrSubject).ifPresent(failures::add);
       }
-      testItems(arrSubject);
+      failures.addAll(testItems(arrSubject));
     }
+    ValidationException.throwFor(this, failures);
   }
 
 }

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

@@ -32,12 +32,14 @@ public void additionalItemsSchema() {
         .build().validate(ARRAYS.get("additionalItemsSchema"));
   }
 
-  @Test(expected = ValidationException.class)
+  @Test
   public void additionalItemsSchemaFailure() {
-    ArraySchema.builder()
+    ArraySchema subject = ArraySchema.builder()
         .addItemSchema(BooleanSchema.INSTANCE)
         .schemaOfAdditionalItems(NullSchema.INSTANCE)
-        .build().validate(ARRAYS.get("additionalItemsSchemaFailure"));
+        .build();
+    TestSupport.expectFailure(subject, NullSchema.INSTANCE, "#/2",
+        ARRAYS.get("additionalItemsSchemaFailure"));
   }
 
   @Test(expected = ValidationException.class)
@@ -85,9 +87,10 @@ public void noItemSchema() {
     ArraySchema.builder().build().validate(ARRAYS.get("noItemSchema"));
   }
 
-  @Test(expected = ValidationException.class)
+  @Test
   public void nonUniqueArrayOfArrays() {
-    ArraySchema.builder().uniqueItems(true).build().validate(ARRAYS.get("nonUniqueArrayOfArrays"));
+    ArraySchema subject = ArraySchema.builder().uniqueItems(true).build();
+    TestSupport.expectFailure(subject, "#", ARRAYS.get("nonUniqueArrayOfArrays"));
   }
 
   @Test(expected = SchemaException.class)
@@ -96,10 +99,11 @@ public void tupleAndListFailure() {
         .build();
   }
 
-  @Test(expected = ValidationException.class)
+  @Test
   public void tupleWithOneItem() {
-    ArraySchema.builder().addItemSchema(BooleanSchema.INSTANCE).build()
-        .validate(ARRAYS.get("tupleWithOneItem"));
+    ArraySchema subject = ArraySchema.builder().addItemSchema(BooleanSchema.INSTANCE).build();
+    TestSupport.expectFailure(subject, BooleanSchema.INSTANCE, "#/0",
+        ARRAYS.get("tupleWithOneItem"));
   }
 
   @Test(expected = ValidationException.class)