implementing the following ConditionalSchema events: isMismatch(), elseMatch(), elseMismatch()

    * also changing ValidationException#equals() to take the exception message into account

Author: erosb

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

@@ -1,13 +1,14 @@
 package org.everit.json.schema;
 
+import static java.util.Arrays.asList;
 import static java.util.Objects.requireNonNull;
+import static org.everit.json.schema.listener.ConditionalSchemaValidationEvent.Keyword.ELSE;
 import static org.everit.json.schema.listener.ConditionalSchemaValidationEvent.Keyword.IF;
 import static org.everit.json.schema.listener.ConditionalSchemaValidationEvent.Keyword.THEN;
 
-import java.util.Arrays;
-
 import org.everit.json.schema.listener.ConditionalSchemaMatchEvent;
 import org.everit.json.schema.listener.ConditionalSchemaMismatchEvent;
+import org.everit.json.schema.listener.ConditionalSchemaValidationEvent;
 
 class ConditionalSchemaValidatingVisitor extends Visitor {
 
@@ -38,8 +39,12 @@ void visitConditionalSchema(ConditionalSchema conditionalSchema) {
     void visitIfSchema(Schema ifSchema) {
         if (conditionalSchema.getIfSchema().isPresent()) {
             ifSchemaException = owner.getFailureOfSchema(ifSchema, subject);
+            if (ifSchemaException == null) {
+                owner.validationListener.ifSchemaMatch(createMatchEvent(IF));
+            } else {
+                owner.validationListener.ifSchemaMismatch(createMismatchEvent(IF, ifSchemaException));
+            }
         }
-        owner.validationListener.ifSchemaMatch(new ConditionalSchemaMatchEvent(conditionalSchema, subject, IF));
     }
 
     @Override
@@ -50,15 +55,14 @@ void visitThenSchema(Schema thenSchema) {
                 ValidationException failure = new ValidationException(conditionalSchema,
                         new StringBuilder(new StringBuilder("#")),
                         "input is invalid against the \"then\" schema",
-                        Arrays.asList(thenSchemaException),
+                        asList(thenSchemaException),
                         "then",
                         conditionalSchema.getSchemaLocation());
 
-                owner.validationListener
-                        .thenSchemaMismatch(new ConditionalSchemaMismatchEvent(conditionalSchema, subject, THEN, thenSchemaException));
+                owner.validationListener.thenSchemaMismatch(createMismatchEvent(THEN, thenSchemaException));
                 owner.failure(failure);
             } else {
-                owner.validationListener.thenSchemaMatch(new ConditionalSchemaMatchEvent(conditionalSchema, subject, THEN));
+                owner.validationListener.thenSchemaMatch(createMatchEvent(THEN));
             }
         }
     }
@@ -71,15 +75,24 @@ void visitElseSchema(Schema elseSchema) {
                 ValidationException failure = new ValidationException(conditionalSchema,
                         new StringBuilder(new StringBuilder("#")),
                         "input is invalid against both the \"if\" and \"else\" schema",
-                        Arrays.asList(ifSchemaException, elseSchemaException),
+                        asList(ifSchemaException, elseSchemaException),
                         "else",
                         conditionalSchema.getSchemaLocation());
-
-                //                owner.reportSchemaMatchEvent(elseSchema, failure);
+                owner.validationListener.elseSchemaMismatch(createMismatchEvent(ELSE, elseSchemaException));
                 owner.failure(failure);
+            } else {
+                owner.validationListener.elseSchemaMatch(createMatchEvent(ELSE));
             }
-            //            owner.reportSchemaMatchEvent(elseSchema, null);
         }
     }
 
+    private ConditionalSchemaMatchEvent createMatchEvent(ConditionalSchemaValidationEvent.Keyword keyword) {
+        return new ConditionalSchemaMatchEvent(conditionalSchema, subject, keyword);
+    }
+
+    private ConditionalSchemaMismatchEvent createMismatchEvent(ConditionalSchemaValidationEvent.Keyword keyword,
+            ValidationException failure) {
+        return new ConditionalSchemaMismatchEvent(conditionalSchema, subject, keyword, failure);
+    }
+
 }

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

@@ -469,7 +469,7 @@ public String getSchemaLocation() {
             return false;
         if (!causingExceptions.equals(that.causingExceptions))
             return false;
-        return Objects.equals(keyword, that.keyword);
+        return Objects.equals(keyword, that.keyword) && Objects.equals(getMessage(), that.getMessage());
     }
 
     @Override public int hashCode() {

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

@@ -3,6 +3,7 @@
 import static org.everit.json.schema.ConditionalSchemaTest.MAX_LENGTH_STRING_SCHEMA;
 import static org.everit.json.schema.ConditionalSchemaTest.MIN_LENGTH_STRING_SCHEMA;
 import static org.everit.json.schema.ConditionalSchemaTest.PATTERN_STRING_SCHEMA;
+import static org.everit.json.schema.listener.ConditionalSchemaValidationEvent.Keyword.ELSE;
 import static org.everit.json.schema.listener.ConditionalSchemaValidationEvent.Keyword.IF;
 import static org.everit.json.schema.listener.ConditionalSchemaValidationEvent.Keyword.THEN;
 import static org.mockito.Mockito.spy;
@@ -48,6 +49,7 @@ public void ifMatch_thenMatch() {
     public void ifMatch_thenMismatch() {
         String instance = "foo";
         validateInstance(instance);
+
         verify(listener).ifSchemaMatch(new ConditionalSchemaMatchEvent(schema, instance, IF));
         ValidationException failure = new ValidationException(MIN_LENGTH_STRING_SCHEMA,
                 "expected minLength: 6, actual: 3", "minLength",
@@ -56,4 +58,32 @@ public void ifMatch_thenMismatch() {
         verifyNoMoreInteractions(listener);
     }
 
+    @Test
+    public void ifMismatch_elseMatch() {
+        String instance = "boo";
+        validateInstance(instance);
+
+        ValidationException failure = new ValidationException(PATTERN_STRING_SCHEMA, "string [boo] does not match pattern f.*o",
+                "pattern", "#/if");
+        verify(listener).ifSchemaMismatch(new ConditionalSchemaMismatchEvent(schema, instance, IF, failure));
+        verify(listener).elseSchemaMatch(new ConditionalSchemaMatchEvent(schema, instance, ELSE));
+        verifyNoMoreInteractions(listener);
+    }
+
+    @Test
+    public void ifMismatch_elseMismatch() {
+        String instance = "booooooooooooo";
+        validateInstance(instance);
+
+        ValidationException ifFailure = new ValidationException(PATTERN_STRING_SCHEMA,
+                "string [booooooooooooo] does not match pattern f.*o",
+                "pattern", "#/if");
+        verify(listener).ifSchemaMismatch(new ConditionalSchemaMismatchEvent(schema, instance, IF, ifFailure));
+        ValidationException elseFailure = new ValidationException(MAX_LENGTH_STRING_SCHEMA,
+                "expected maxLength: 4, actual: 14",
+                "maxLength", "#/else");
+        verify(listener).elseSchemaMismatch(new ConditionalSchemaMismatchEvent(schema, instance, ELSE, elseFailure));
+        verifyNoMoreInteractions(listener);
+    }
+
 }