Use checked predicates for matching results and failures

Switches the policy builders to use checked predicates for matching results and failures. Exceptions were already being treated as false results. This additional lenience will make it easier to assert results that throw checked exceptions. The API really should have always done this.

Author: jhalterman

core/src/main/java/dev/failsafe/CircuitBreakerBuilder.java

@@ -17,22 +17,22 @@
 
 import dev.failsafe.event.CircuitBreakerStateChangedEvent;
 import dev.failsafe.event.EventListener;
+import dev.failsafe.function.CheckedBiPredicate;
+import dev.failsafe.function.CheckedPredicate;
 import dev.failsafe.internal.CircuitBreakerImpl;
 import dev.failsafe.internal.util.Assert;
 import dev.failsafe.internal.util.Durations;
 
 import java.time.Duration;
-import java.util.function.BiPredicate;
-import java.util.function.Predicate;
 
 /**
  * Builds {@link CircuitBreaker} instances.
  * <ul>
  *   <li>By default, any exception is considered a failure and will be handled by the policy. You can override this by
  *   specifying your own {@code handle} conditions. The default exception handling condition will only be overridden by
- *   another condition that handles failure exceptions such as {@link #handle(Class)} or {@link #handleIf(BiPredicate)}.
+ *   another condition that handles failure exceptions such as {@link #handle(Class)} or {@link #handleIf(CheckedBiPredicate)}.
  *   Specifying a condition that only handles results, such as {@link #handleResult(Object)} or
- *   {@link #handleResultIf(Predicate)} will not replace the default exception handling condition.</li>
+ *   {@link #handleResultIf(CheckedPredicate)} will not replace the default exception handling condition.</li>
  *   <li>If multiple {@code handle} conditions are specified, any condition that matches an execution result or failure
  *   will trigger policy handling.</li>
  * </ul>

core/src/main/java/dev/failsafe/FailurePolicyBuilder.java

@@ -15,22 +15,23 @@
  */
 package dev.failsafe;
 
+import dev.failsafe.function.CheckedBiPredicate;
+import dev.failsafe.function.CheckedPredicate;
 import dev.failsafe.internal.util.Assert;
 
 import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
-import java.util.function.BiPredicate;
 import java.util.function.Predicate;
 
 /**
  * A Policy that allows configurable conditions to determine whether an execution is a failure.
  * <ul>
  *   <li>By default, any exception is considered a failure and will be handled by the policy. You can override this by
  *   specifying your own {@code handle} conditions. The default exception handling condition will only be overridden by
- *   another condition that handles failure exceptions such as {@link #handle(Class)} or {@link #handleIf(BiPredicate)}.
+ *   another condition that handles failure exceptions such as {@link #handle(Class)} or {@link #handleIf(CheckedBiPredicate)}.
  *   Specifying a condition that only handles results, such as {@link #handleResult(Object)} or
- *   {@link #handleResultIf(Predicate)} will not replace the default exception handling condition.</li>
+ *   {@link #handleResultIf(CheckedPredicate)} will not replace the default exception handling condition.</li>
  *   <li>If multiple {@code handle} conditions are specified, any condition that matches an execution result or failure
  *   will trigger policy handling.</li>
  * </ul>
@@ -84,27 +85,29 @@ public S handle(List<Class<? extends Throwable>> failures) {
   }
 
   /**
-   * Specifies that a failure has occurred if the {@code failurePredicate} matches the failure.
+   * Specifies that a failure has occurred if the {@code failurePredicate} matches the failure. Any exception thrown
+   * from the {@code failurePredicate} is treated as a {@code false} result.
    *
    * @throws NullPointerException if {@code failurePredicate} is null
    */
-  public S handleIf(Predicate<? extends Throwable> failurePredicate) {
+  public S handleIf(CheckedPredicate<? extends Throwable> failurePredicate) {
     Assert.notNull(failurePredicate, "failurePredicate");
     config.failuresChecked = true;
     config.failureConditions.add(failurePredicateFor(failurePredicate));
     return (S) this;
   }
 
   /**
-   * Specifies that a failure has occurred if the {@code resultPredicate} matches the execution result.
+   * Specifies that a failure has occurred if the {@code resultPredicate} matches the execution result. Any exception
+   * thrown from the {@code resultPredicate} is treated as a {@code false} result.
    *
    * @throws NullPointerException if {@code resultPredicate} is null
    */
   @SuppressWarnings("unchecked")
-  public S handleIf(BiPredicate<R, ? extends Throwable> resultPredicate) {
+  public S handleIf(CheckedBiPredicate<R, ? extends Throwable> resultPredicate) {
     Assert.notNull(resultPredicate, "resultPredicate");
     config.failuresChecked = true;
-    config.failureConditions.add((BiPredicate<R, Throwable>) resultPredicate);
+    config.failureConditions.add((CheckedBiPredicate<R, Throwable>) resultPredicate);
     return (S) this;
   }
 
@@ -120,11 +123,12 @@ public S handleResult(R result) {
   /**
    * Specifies that a failure has occurred if the {@code resultPredicate} matches the execution result. This method is
    * only considered when a result is returned from an execution, not when an exception is thrown. To handle results or
-   * exceptions with the same condition, use {@link #handleIf(BiPredicate)}.
+   * exceptions with the same condition, use {@link #handleIf(CheckedBiPredicate)}. Any exception thrown from the {@code
+   * resultPredicate} is treated as a {@code false} result.
    *
    * @throws NullPointerException if {@code resultPredicate} is null
    */
-  public S handleResultIf(Predicate<R> resultPredicate) {
+  public S handleResultIf(CheckedPredicate<R> resultPredicate) {
     Assert.notNull(resultPredicate, "resultPredicate");
     config.failureConditions.add(resultPredicateFor(resultPredicate));
     return (S) this;
@@ -133,16 +137,17 @@ public S handleResultIf(Predicate<R> resultPredicate) {
   /**
    * Returns a predicate that evaluates whether the {@code result} equals an execution result.
    */
-  static <R> BiPredicate<R, Throwable> resultPredicateFor(R result) {
+  static <R> CheckedBiPredicate<R, Throwable> resultPredicateFor(R result) {
     return (t, u) -> result == null ? t == null && u == null : Objects.equals(result, t);
   }
 
   /**
    * Returns a predicate that evaluates the {@code failurePredicate} against a failure.
    */
   @SuppressWarnings("unchecked")
-  static <R> BiPredicate<R, Throwable> failurePredicateFor(Predicate<? extends Throwable> failurePredicate) {
-    return (t, u) -> u != null && ((Predicate<Throwable>) failurePredicate).test(u);
+  static <R> CheckedBiPredicate<R, Throwable> failurePredicateFor(
+    CheckedPredicate<? extends Throwable> failurePredicate) {
+    return (t, u) -> u != null && ((CheckedPredicate<Throwable>) failurePredicate).test(u);
   }
 
   /**
@@ -151,7 +156,7 @@ static <R> BiPredicate<R, Throwable> failurePredicateFor(Predicate<? extends Thr
    * Short-circuits to false without invoking {@code resultPredicate}, when result is not present (i.e.
    * BiPredicate.test(null, Throwable)).
    */
-  static <R> BiPredicate<R, Throwable> resultPredicateFor(Predicate<R> resultPredicate) {
+  static <R> CheckedBiPredicate<R, Throwable> resultPredicateFor(CheckedPredicate<R> resultPredicate) {
     return (t, u) -> {
       if (u == null) {
         return resultPredicate.test(t);
@@ -167,7 +172,7 @@ static <R> BiPredicate<R, Throwable> resultPredicateFor(Predicate<R> resultPredi
   /**
    * Returns a predicate that returns whether any of the {@code failures} are assignable from an execution failure.
    */
-  static <R> BiPredicate<R, Throwable> failurePredicateFor(List<Class<? extends Throwable>> failures) {
+  static <R> CheckedBiPredicate<R, Throwable> failurePredicateFor(List<Class<? extends Throwable>> failures) {
     return (t, u) -> {
       if (u == null)
         return false;

core/src/main/java/dev/failsafe/FailurePolicyConfig.java

@@ -15,10 +15,11 @@
  */
 package dev.failsafe;
 
+import dev.failsafe.function.CheckedBiPredicate;
+import dev.failsafe.function.CheckedPredicate;
+
 import java.util.ArrayList;
 import java.util.List;
-import java.util.function.BiPredicate;
-import java.util.function.Predicate;
 
 /**
  * Configuration for policies that handle specific failures and conditions.
@@ -30,7 +31,7 @@ public abstract class FailurePolicyConfig<R> extends PolicyConfig<R> {
   /** Indicates whether failures are checked by a configured failure condition */
   boolean failuresChecked;
   /** Conditions that determine whether an execution is a failure */
-  List<BiPredicate<R, Throwable>> failureConditions;
+  List<CheckedBiPredicate<R, Throwable>> failureConditions;
 
   protected FailurePolicyConfig() {
     failureConditions = new ArrayList<>();
@@ -54,12 +55,12 @@ public boolean isFailuresChecked() {
    *
    * @see FailurePolicyBuilder#handle(Class...)
    * @see FailurePolicyBuilder#handle(List)
-   * @see FailurePolicyBuilder#handleIf(BiPredicate)
-   * @see FailurePolicyBuilder#handleIf(Predicate)
+   * @see FailurePolicyBuilder#handleIf(CheckedBiPredicate)
+   * @see FailurePolicyBuilder#handleIf(CheckedPredicate)
    * @see FailurePolicyBuilder#handleResult(Object) 
-   * @see FailurePolicyBuilder#handleResultIf(Predicate)
+   * @see FailurePolicyBuilder#handleResultIf(CheckedPredicate)
    */
-  public List<BiPredicate<R, Throwable>> getFailureConditions() {
+  public List<CheckedBiPredicate<R, Throwable>> getFailureConditions() {
     return failureConditions;
   }
 }

core/src/main/java/dev/failsafe/FallbackBuilder.java

@@ -17,22 +17,22 @@
 
 import dev.failsafe.event.EventListener;
 import dev.failsafe.event.ExecutionAttemptedEvent;
+import dev.failsafe.function.CheckedBiPredicate;
 import dev.failsafe.function.CheckedFunction;
+import dev.failsafe.function.CheckedPredicate;
 import dev.failsafe.internal.FallbackImpl;
 import dev.failsafe.internal.util.Assert;
 
 import java.util.concurrent.CompletableFuture;
-import java.util.function.BiPredicate;
-import java.util.function.Predicate;
 
 /**
  * Builds {@link Fallback} instances.
  * <ul>
  *   <li>By default, any exception is considered a failure and will be handled by the policy. You can override this by
  *   specifying your own {@code handle} conditions. The default exception handling condition will only be overridden by
- *   another condition that handles failure exceptions such as {@link #handle(Class)} or {@link #handleIf(BiPredicate)}.
+ *   another condition that handles failure exceptions such as {@link #handle(Class)} or {@link #handleIf(CheckedBiPredicate)}.
  *   Specifying a condition that only handles results, such as {@link #handleResult(Object)} or
- *   {@link #handleResultIf(Predicate)} will not replace the default exception handling condition.</li>
+ *   {@link #handleResultIf(CheckedPredicate)} will not replace the default exception handling condition.</li>
  *   <li>If multiple {@code handle} conditions are specified, any condition that matches an execution result or failure
  *   will trigger policy handling.</li>
  * </ul>

core/src/main/java/dev/failsafe/RetryPolicyBuilder.java

@@ -19,6 +19,8 @@
 import dev.failsafe.event.ExecutionAttemptedEvent;
 import dev.failsafe.event.ExecutionCompletedEvent;
 import dev.failsafe.event.ExecutionScheduledEvent;
+import dev.failsafe.function.CheckedBiPredicate;
+import dev.failsafe.function.CheckedPredicate;
 import dev.failsafe.internal.RetryPolicyImpl;
 import dev.failsafe.internal.util.Assert;
 import dev.failsafe.internal.util.Durations;
@@ -28,8 +30,6 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
-import java.util.function.BiPredicate;
-import java.util.function.Predicate;
 
 /**
  * Builds {@link RetryPolicy instances}.
@@ -40,9 +40,9 @@
  *   configuration methods.</li>
  *   <li>By default, any exception is considered a failure and will be handled by the policy. You can override this by
  *   specifying your own {@code handle} conditions. The default exception handling condition will only be overridden by
- *   another condition that handles failure exceptions such as {@link #handle(Class)} or {@link #handleIf(BiPredicate)}.
+ *   another condition that handles failure exceptions such as {@link #handle(Class)} or {@link #handleIf(CheckedBiPredicate)}.
  *   Specifying a condition that only handles results, such as {@link #handleResult(Object)} or
- *   {@link #handleResultIf(Predicate)} will not replace the default exception handling condition.</li>
+ *   {@link #handleResultIf(CheckedPredicate)} will not replace the default exception handling condition.</li>
  *   <li>If multiple {@code handle} conditions are specified, any condition that matches an execution result or failure
  *   will trigger policy handling.</li>
  *   <li>The {@code abortOn}, {@code abortWhen} and {@code abortIf} methods describe when retries should be aborted.</li>
@@ -83,24 +83,26 @@ public RetryPolicy<R> build() {
   }
 
   /**
-   * Specifies that retries should be aborted if the {@code completionPredicate} matches the completion result.
+   * Specifies that retries should be aborted if the {@code completionPredicate} matches the completion result. Any
+   * exception thrown from the {@code completionPredicate} is treated as a {@code false} result.
    *
    * @throws NullPointerException if {@code completionPredicate} is null
    */
   @SuppressWarnings("unchecked")
-  public RetryPolicyBuilder<R> abortIf(BiPredicate<R, ? extends Throwable> completionPredicate) {
+  public RetryPolicyBuilder<R> abortIf(CheckedBiPredicate<R, ? extends Throwable> completionPredicate) {
     Assert.notNull(completionPredicate, "completionPredicate");
-    config.abortConditions.add((BiPredicate<R, Throwable>) completionPredicate);
+    config.abortConditions.add((CheckedBiPredicate<R, Throwable>) completionPredicate);
     return this;
   }
 
   /**
    * Specifies that retries should be aborted if the {@code resultPredicate} matches the result. Predicate is not
-   * invoked when the operation fails.
+   * invoked when the operation fails. Any exception thrown from the {@code resultPredicate} is treated as a {@code
+   * false} result.
    *
    * @throws NullPointerException if {@code resultPredicate} is null
    */
-  public RetryPolicyBuilder<R> abortIf(Predicate<R> resultPredicate) {
+  public RetryPolicyBuilder<R> abortIf(CheckedPredicate<R> resultPredicate) {
     Assert.notNull(resultPredicate, "resultPredicate");
     config.abortConditions.add(resultPredicateFor(resultPredicate));
     return this;
@@ -146,11 +148,12 @@ public RetryPolicyBuilder<R> abortOn(List<Class<? extends Throwable>> failures)
   }
 
   /**
-   * Specifies that retries should be aborted if the {@code failurePredicate} matches the failure.
+   * Specifies that retries should be aborted if the {@code failurePredicate} matches the failure. Any exception thrown
+   * from the {@code failurePredicate} is treated as a {@code false} result.
    *
    * @throws NullPointerException if {@code failurePredicate} is null
    */
-  public RetryPolicyBuilder<R> abortOn(Predicate<? extends Throwable> failurePredicate) {
+  public RetryPolicyBuilder<R> abortOn(CheckedPredicate<? extends Throwable> failurePredicate) {
     Assert.notNull(failurePredicate, "failurePredicate");
     config.abortConditions.add(failurePredicateFor(failurePredicate));
     return this;

core/src/main/java/dev/failsafe/RetryPolicyConfig.java

@@ -19,13 +19,13 @@
 import dev.failsafe.event.ExecutionAttemptedEvent;
 import dev.failsafe.event.ExecutionCompletedEvent;
 import dev.failsafe.event.ExecutionScheduledEvent;
+import dev.failsafe.function.CheckedBiPredicate;
+import dev.failsafe.function.CheckedPredicate;
 
 import java.time.Duration;
 import java.time.temporal.ChronoUnit;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.function.BiPredicate;
-import java.util.function.Predicate;
 
 /**
  * Configuration for a {@link RetryPolicy}.
@@ -46,7 +46,7 @@ public class RetryPolicyConfig<R> extends DelayablePolicyConfig<R> {
   double jitterFactor;
   Duration maxDuration;
   int maxRetries;
-  List<BiPredicate<R, Throwable>> abortConditions;
+  List<CheckedBiPredicate<R, Throwable>> abortConditions;
 
   // Listeners
   EventListener<ExecutionCompletedEvent<R>> abortListener;
@@ -94,12 +94,12 @@ public boolean allowsRetries() {
    *
    * @see RetryPolicyBuilder#abortOn(Class...)
    * @see RetryPolicyBuilder#abortOn(List)
-   * @see RetryPolicyBuilder#abortOn(Predicate)
-   * @see RetryPolicyBuilder#abortIf(BiPredicate)
-   * @see RetryPolicyBuilder#abortIf(Predicate)
+   * @see RetryPolicyBuilder#abortOn(CheckedPredicate)
+   * @see RetryPolicyBuilder#abortIf(CheckedBiPredicate)
+   * @see RetryPolicyBuilder#abortIf(CheckedPredicate) 
    * @see RetryPolicyBuilder#abortWhen(Object) 
    */
-  public List<BiPredicate<R, Throwable>> getAbortConditions() {
+  public List<CheckedBiPredicate<R, Throwable>> getAbortConditions() {
     return abortConditions;
   }
 

core/src/main/java/dev/failsafe/function/CheckedBiPredicate.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+package dev.failsafe.function;
+
+/**
+ * A BiPredicate that throws checked exceptions.
+ *
+ * @param <T> first input type
+ * @param <U> second input type
+ * @author Jonathan Halterman
+ */
+@FunctionalInterface
+public interface CheckedBiPredicate<T, U> {
+  boolean test(T t, U u) throws Throwable;
+}

core/src/main/java/dev/failsafe/function/CheckedPredicate.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License
+ */
+package dev.failsafe.function;
+
+/**
+ * A Predicate that throws checked exceptions.
+ *
+ * @param <T> input type
+ * @author Jonathan Halterman
+ */
+@FunctionalInterface
+public interface CheckedPredicate<T> {
+  boolean test(T t) throws Throwable;
+}