ArraySchema rework finished

Author: erosb

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

@@ -194,42 +194,47 @@ public boolean requiresArray() {
     return requiresArray;
   }
 
-  private void testItemCount(final JSONArray subject) {
+  private Optional<ValidationException> testItemCount(final JSONArray subject) {
     int actualLength = subject.length();
     if (minItems != null && actualLength < minItems) {
-      throw new ValidationException(this, "expected minimum item count: " + minItems + ", found: "
-          + actualLength);
+      return Optional.of(new ValidationException(this, "expected minimum item count: " + minItems
+          + ", found: " + actualLength));
     }
     if (maxItems != null && maxItems < actualLength) {
-      throw new ValidationException(this, "expected maximum item count: " + minItems + ", found: "
-          + actualLength);
+      return Optional.of(new ValidationException(this, "expected maximum item count: " + minItems
+          + ", found: " + actualLength));
     }
+    return Optional.empty();
   }
 
   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));
+        int copyOfI = i; // i is not effectively final so we copy it
+        ifFails(allItemSchema, subject.get(i))
+            .map(exc -> exc.prepend(String.valueOf(copyOfI)))
+            .ifPresent(rval::add);
       }
     } else if (itemSchemas != null) {
       if (!additionalItems && subject.length() > itemSchemas.size()) {
-        throw new ValidationException(this, String.format("expected: [%d] array items, found: [%d]",
-            itemSchemas.size(), subject.length()));
+        rval.add(new ValidationException(this, String.format(
+            "expected: [%d] array items, found: [%d]",
+            itemSchemas.size(), subject.length())));
       }
       int itemValidationUntil = Math.min(subject.length(), itemSchemas.size());
       for (int i = 0; i < itemValidationUntil; ++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);
+        .map(exc -> exc.prepend(String.valueOf(copyOfI)))
+        .ifPresent(rval::add);
       }
       if (schemaOfAdditionalItems != null) {
         for (int i = itemValidationUntil; i < subject.length(); ++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);
+          .map(exc -> exc.prepend(String.valueOf(copyOfI)))
+          .ifPresent(rval::add);
         }
       }
     }
@@ -258,11 +263,11 @@ public void validate(final Object subject) {
     List<ValidationException> failures = new ArrayList<>();
     if (!(subject instanceof JSONArray)) {
       if (requiresArray) {
-        throw new ValidationException(JSONArray.class, subject);
+        throw new ValidationException(this, JSONArray.class, subject);
       }
     } else {
       JSONArray arrSubject = (JSONArray) subject;
-      testItemCount(arrSubject);
+      testItemCount(arrSubject).ifPresent(failures::add);
       if (uniqueItems) {
         testUniqueness(arrSubject).ifPresent(failures::add);
       }

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

@@ -27,9 +27,9 @@ public class ArraySchemaTest {
   @Test
   public void additionalItemsSchema() {
     ArraySchema.builder()
-        .addItemSchema(BooleanSchema.INSTANCE)
-        .schemaOfAdditionalItems(NullSchema.INSTANCE)
-        .build().validate(ARRAYS.get("additionalItemsSchema"));
+    .addItemSchema(BooleanSchema.INSTANCE)
+    .schemaOfAdditionalItems(NullSchema.INSTANCE)
+    .build().validate(ARRAYS.get("additionalItemsSchema"));
   }
 
   @Test
@@ -42,34 +42,30 @@ public void additionalItemsSchemaFailure() {
         ARRAYS.get("additionalItemsSchemaFailure"));
   }
 
-  @Test(expected = ValidationException.class)
+  @Test
   public void booleanItems() {
-    ArraySchema.builder().allItemSchema(BooleanSchema.INSTANCE).build()
-        .validate(ARRAYS.get("boolArrFailure"));
+    ArraySchema subject = ArraySchema.builder().allItemSchema(BooleanSchema.INSTANCE).build();
+    TestSupport.expectFailure(subject, BooleanSchema.INSTANCE, "#/2", ARRAYS.get("boolArrFailure"));
   }
 
   @Test
   public void doesNotRequireExplicitArray() {
     ArraySchema.builder()
-        .requiresArray(false)
-        .uniqueItems(true)
-        .build().validate(ARRAYS.get("doesNotRequireExplicitArray"));
-  }
-
-  private void exceptFailure(final Schema failingSchema, final String testInputName) {
-    TestSupport.expectFailure(failingSchema, ARRAYS.get(testInputName));
+    .requiresArray(false)
+    .uniqueItems(true)
+    .build().validate(ARRAYS.get("doesNotRequireExplicitArray"));
   }
 
   @Test
   public void maxItems() {
     ArraySchema subject = ArraySchema.builder().maxItems(0).build();
-    exceptFailure(subject, "onlyOneItem");
+    TestSupport.expectFailure(subject, "#", ARRAYS.get("onlyOneItem"));
   }
 
   @Test
   public void minItems() {
     ArraySchema subject = ArraySchema.builder().minItems(2).build();
-    exceptFailure(subject, "onlyOneItem");
+    TestSupport.expectFailure(subject, "#", ARRAYS.get("onlyOneItem"));
   }
 
   @Test
@@ -79,7 +75,7 @@ public void noAdditionalItems() {
         .addItemSchema(BooleanSchema.INSTANCE)
         .addItemSchema(NullSchema.INSTANCE)
         .build();
-    exceptFailure(subject, "twoItemTupleWithAdditional");
+    TestSupport.expectFailure(subject, "#", ARRAYS.get("twoItemTupleWithAdditional"));
   }
 
   @Test
@@ -96,7 +92,7 @@ public void nonUniqueArrayOfArrays() {
   @Test(expected = SchemaException.class)
   public void tupleAndListFailure() {
     ArraySchema.builder().addItemSchema(BooleanSchema.INSTANCE).allItemSchema(NullSchema.INSTANCE)
-        .build();
+    .build();
   }
 
   @Test
@@ -106,30 +102,32 @@ public void tupleWithOneItem() {
         ARRAYS.get("tupleWithOneItem"));
   }
 
-  @Test(expected = ValidationException.class)
+  @Test
   public void typeFailure() {
-    ArraySchema.builder().build().validate(true);
+    TestSupport.expectFailure(ArraySchema.builder().build(), true);
   }
 
-  @Test(expected = ValidationException.class)
+  @Test
   public void uniqueItemsObjectViolation() {
-    ArraySchema.builder().uniqueItems(true).build().validate(ARRAYS.get("nonUniqueObjects"));
+    ArraySchema subject = ArraySchema.builder().uniqueItems(true).build();
+    TestSupport.expectFailure(subject, "#", ARRAYS.get("nonUniqueObjects"));
   }
 
-  @Test(expected = ValidationException.class)
+  @Test
   public void uniqueItemsViolation() {
-    ArraySchema.builder().uniqueItems(true).build().validate(ARRAYS.get("nonUniqueItems"));
+    ArraySchema subject = ArraySchema.builder().uniqueItems(true).build();
+    TestSupport.expectFailure(subject, "#", ARRAYS.get("nonUniqueItems"));
   }
 
   @Test
   public void uniqueItemsWithSameToString() {
     ArraySchema.builder().uniqueItems(true).build()
-        .validate(ARRAYS.get("uniqueItemsWithSameToString"));
+    .validate(ARRAYS.get("uniqueItemsWithSameToString"));
   }
 
   @Test
   public void uniqueObjectValues() {
     ArraySchema.builder().uniqueItems(true).build()
-        .validate(ARRAYS.get("uniqueObjectValues"));
+    .validate(ARRAYS.get("uniqueObjectValues"));
   }
 }